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

libfreerdp-core: parsing of alternate secondary drawing orders

Browse Source
This commit is contained in:
Marc-André Moreau 2011-08-02 16:58:42 -04:00
parent 281d06d744
commit b4437a783c
4 changed files with 453 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

313
include/freerdp/update.h
View File

@ -117,40 +117,6 @@ typedef struct
sint16 nYSrc;
} SCRBLT_ORDER;
typedef struct
{
sint16 srcLeft;
sint16 srcTop;
sint16 srcRight;
sint16 srcBottom;
uint16 bitmapId;
} DRAW_NINE_GRID_ORDER;
typedef struct
{
sint16 srcLeft;
sint16 srcTop;
sint16 srcRight;
sint16 srcBottom;
uint16 bitmapId;
uint8 nDeltaEntries;
uint8* codeDeltaList;
} MULTI_DRAW_NINE_GRID_ORDER;
typedef struct
{
uint16 backMode;
sint16 nXStart;
sint16 nYStart;
sint16 nXEnd;
sint16 nYEnd;
uint32 backColor;
uint8 bRop2;
uint8 penStyle;
uint8 penWidth;
uint32 penColor;
} LINE_TO_ORDER;
typedef struct
{
sint16 nLeftRect;
@ -162,46 +128,12 @@ typedef struct
typedef struct
{
uint32 savedBitmapPosition;
sint16 nLeftRect;
sint16 nTopRect;
sint16 nRightRect;
sint16 nBottomRect;
uint8 operation;
} SAVE_BITMAP_ORDER;
typedef struct
{
uint16 cacheId;
sint16 nLeftRect;
sint16 nTopRect;
sint16 nWidth;
sint16 nHeight;
uint8 bRop;
sint16 nXSrc;
sint16 nYSrc;
uint16 cacheIndex;
} MEMBLT_ORDER;
typedef struct
{
uint16 cacheId;
sint16 nLeftRect;
sint16 nTopRect;
sint16 nWidth;
sint16 nHeight;
uint8 bRop;
sint16 nXSrc;
sint16 nYSrc;
uint32 backColor;
uint32 foreColor;
uint8 brushOrgX;
uint8 brushOrgY;
uint8 brushStyle;
uint8 brushHatch;
uint8 brushExtra[7];
uint16 cacheIndex;
} MEM3BLT_ORDER;
sint16 srcLeft;
sint16 srcTop;
sint16 srcRight;
sint16 srcBottom;
uint16 bitmapId;
} DRAW_NINE_GRID_ORDER;
typedef struct
{
@ -256,6 +188,84 @@ typedef struct
uint8* codeDeltaList;
} MULTI_OPAQUE_RECT_ORDER;
typedef struct
{
sint16 srcLeft;
sint16 srcTop;
sint16 srcRight;
sint16 srcBottom;
uint16 bitmapId;
uint8 nDeltaEntries;
uint8* codeDeltaList;
} MULTI_DRAW_NINE_GRID_ORDER;
typedef struct
{
uint16 backMode;
sint16 nXStart;
sint16 nYStart;
sint16 nXEnd;
sint16 nYEnd;
uint32 backColor;
uint8 bRop2;
uint8 penStyle;
uint8 penWidth;
uint32 penColor;
} LINE_TO_ORDER;
typedef struct
{
sint16 xStart;
sint16 yStart;
uint8 bRop2;
uint32 penColor;
uint8 nDeltaEntries;
uint8* codeDeltaList;
} POLYLINE_ORDER;
typedef struct
{
uint16 cacheId;
sint16 nLeftRect;
sint16 nTopRect;
sint16 nWidth;
sint16 nHeight;
uint8 bRop;
sint16 nXSrc;
sint16 nYSrc;
uint16 cacheIndex;
} MEMBLT_ORDER;
typedef struct
{
uint16 cacheId;
sint16 nLeftRect;
sint16 nTopRect;
sint16 nWidth;
sint16 nHeight;
uint8 bRop;
sint16 nXSrc;
sint16 nYSrc;
uint32 backColor;
uint32 foreColor;
uint8 brushOrgX;
uint8 brushOrgY;
uint8 brushStyle;
uint8 brushHatch;
uint8 brushExtra[7];
uint16 cacheIndex;
} MEM3BLT_ORDER;
typedef struct
{
uint32 savedBitmapPosition;
sint16 nLeftRect;
sint16 nTopRect;
sint16 nRightRect;
sint16 nBottomRect;
uint8 operation;
} SAVE_BITMAP_ORDER;
typedef struct
{
uint8 cacheId;
@ -275,6 +285,51 @@ typedef struct
uint8* data;
} FAST_INDEX_ORDER;
typedef struct
{
uint8 cacheId;
uint16 fDrawing;
uint32 backColor;
uint32 foreColor;
sint16 bkLeft;
sint16 bkTop;
sint16 bkRight;
sint16 bkBottom;
sint16 opLeft;
sint16 opTop;
sint16 opRight;
sint16 opBottom;
uint16 x;
uint16 y;
uint8* data;
} FAST_GLYPH_ORDER;
typedef struct
{
uint8 cacheId;
uint8 flAccel;
uint8 ulCharInc;
uint8 fOpRedundant;
uint32 backColor;
uint32 foreColor;
sint16 bkLeft;
sint16 bkTop;
sint16 bkRight;
sint16 bkBottom;
sint16 opLeft;
sint16 opTop;
sint16 opRight;
sint16 opBottom;
uint8 brushOrgX;
uint8 brushOrgY;
uint8 brushStyle;
uint8 brushHatch;
uint8 brushExtra[7];
sint16 x;
sint16 y;
uint8* data;
} GLYPH_INDEX_ORDER;
typedef struct
{
sint16 xStart;
@ -303,35 +358,6 @@ typedef struct
uint8* codeDeltaList;
} POLYGON_CB_ORDER;
typedef struct
{
sint16 xStart;
sint16 yStart;
uint8 bRop2;
uint32 penColor;
uint8 nDeltaEntries;
uint8* codeDeltaList;
} POLYLINE_ORDER;
typedef struct
{
uint8 cacheId;
uint16 fDrawing;
uint32 backColor;
uint32 foreColor;
sint16 bkLeft;
sint16 bkTop;
sint16 bkRight;
sint16 bkBottom;
sint16 opLeft;
sint16 opTop;
sint16 opRight;
sint16 opBottom;
uint16 x;
uint16 y;
uint8* data;
} FAST_GLYPH_ORDER;
typedef struct
{
sint16 leftRect;
@ -360,32 +386,6 @@ typedef struct
uint8 brushExtra[7];
} ELLIPSE_CB_ORDER;
typedef struct
{
uint8 cacheId;
uint8 flAccel;
uint8 ulCharInc;
uint8 fOpRedundant;
uint32 backColor;
uint32 foreColor;
sint16 bkLeft;
sint16 bkTop;
sint16 bkRight;
sint16 bkBottom;
sint16 opLeft;
sint16 opTop;
sint16 opRight;
sint16 opBottom;
uint8 brushOrgX;
uint8 brushOrgY;
uint8 brushStyle;
uint8 brushHatch;
uint8 brushExtra[7];
sint16 x;
sint16 y;
uint8* data;
} GLYPH_INDEX_ORDER;
/* Secondary Drawing Orders */
typedef struct
@ -396,7 +396,7 @@ typedef struct
uint8 bitmapHeight;
uint16 bitmapLength;
uint16 cacheIndex;
uint8* bitmapComprHdr;
uint8 bitmapComprHdr[8];
uint8* bitmapDataStream;
} CACHE_BITMAP_ORDER;
@ -411,7 +411,7 @@ typedef struct
uint8 bitmapHeight;
uint16 bitmapLength;
uint16 cacheIndex;
uint8* bitmapComprHdr;
uint8 bitmapComprHdr[8];
uint8* bitmapDataStream;
} CACHE_BITMAP_V2_ORDER;
@ -528,42 +528,73 @@ typedef struct
typedef struct
{
uint8 bitmapFlags;
uint8 bitmapBpp;
uint16 bitmapType;
uint16 bitmapWidth;
uint16 bitmapHeight;
uint32 bitmapSize;
uint16 bitmapBlockSize;
uint8* bitmapBlock;
} STREAM_BITMAP_FIRST_ORDER;
typedef struct
{
uint8 bitmapFlags;
uint16 bitmapType;
uint16 bitmapBlockSize;
uint8* bitmapBlock;
} STREAM_BITMAP_NEXT_ORDER;
typedef struct
{
uint16 cbSize;
uint32 cbTotalSize;
uint32 cbTotalEmfSize;
uint8* emfRecords;
} DRAW_GDIPLUS_FIRST_ORDER;
typedef struct
{
uint16 cbSize;
uint8* emfRecords;
} DRAW_GDIPLUS_NEXT_ORDER;
typedef struct
{
uint16 cbSize;
uint32 cbTotalSize;
uint32 cbTotalEmfSize;
uint8* emfRecords;
} DRAW_GDIPLUS_END_ORDER;
typedef struct
{
uint8 flags;
uint16 cacheType;
uint16 cacheIndex;
uint16 cbSize;
uint32 cbTotalSize;
uint8* emfRecords;
} DRAW_GDIPLUS_CACHE_FIRST_ORDER;
typedef struct
{
uint8 flags;
uint16 cacheType;
uint16 cacheIndex;
uint16 cbSize;
uint8* emfRecords;
} DRAW_GDIPLUS_CACHE_NEXT_ORDER;
typedef struct
{
uint8 flags;
uint16 cacheType;
uint16 cacheIndex;
uint16 cbSize;
uint32 cbTotalSize;
uint8* emfRecords;
} DRAW_GDIPLUS_CACHE_END_ORDER;
/* Constants */
@ -598,6 +629,10 @@ typedef struct
#define FRAME_START 0x00000000
#define FRAME_END 0x00000001
#define STREAM_BITMAP_END 0x01
#define STREAM_BITMAP_COMPRESSED 0x02
#define STREAM_BITMAP_V2 0x04
/* Update Interface */
typedef struct rdp_update rdpUpdate;

278
libfreerdp-core/orders.c
View File

@ -46,6 +46,8 @@ uint8 PRIMARY_DRAWING_ORDER_STRINGS[][20] =
"GlyphIndex"
};
#define PRIMARY_DRAWING_ORDER_COUNT (sizeof(PRIMARY_DRAWING_ORDER_STRINGS) / sizeof(PRIMARY_DRAWING_ORDER_STRINGS[0]))
uint8 SECONDARY_DRAWING_ORDER_STRINGS[][32] =
{
"Cache Bitmap",
@ -59,6 +61,8 @@ uint8 SECONDARY_DRAWING_ORDER_STRINGS[][32] =
"Cache Bitmap V3"
};
#define SECONDARY_DRAWING_ORDER_COUNT (sizeof(SECONDARY_DRAWING_ORDER_STRINGS) / sizeof(SECONDARY_DRAWING_ORDER_STRINGS[0]))
uint8 ALTSEC_DRAWING_ORDER_STRINGS[][32] =
{
"Switch Surface",
@ -77,6 +81,8 @@ uint8 ALTSEC_DRAWING_ORDER_STRINGS[][32] =
"Frame Marker"
};
#define ALTSEC_DRAWING_ORDER_COUNT (sizeof(ALTSEC_DRAWING_ORDER_STRINGS) / sizeof(ALTSEC_DRAWING_ORDER_STRINGS[0]))
uint8 PRIMARY_DRAWING_ORDER_FIELD_BYTES[] =
{
DSTBLT_ORDER_FIELD_BYTES,
@ -104,6 +110,16 @@ uint8 PRIMARY_DRAWING_ORDER_FIELD_BYTES[] =
GLYPH_INDEX_ORDER_FIELD_BYTES
};
uint8 CBR2_BPP[] =
{
0, 0, 0, 8, 16, 24, 32
};
uint8 CBR23_BPP[] =
{
0, 0, 0, 8, 16, 24, 32
};
void update_read_coord(STREAM* s, sint16* coord, boolean delta)
{
sint8 byte;
@ -131,6 +147,37 @@ void update_read_color(STREAM* s, uint32* color)
*color |= (byte << 16);
}
void update_read_colorref(STREAM* s, uint32* color)
{
uint8 byte;
stream_read_uint8(s, byte);
*color = byte;
stream_read_uint8(s, byte);
*color |= (byte << 8);
stream_read_uint8(s, byte);
*color |= (byte << 16);
stream_seek_uint8(s);
}
void update_read_2byte_unsigned_encoding(STREAM* s, uint16* value)
{
uint8 byte;
stream_read_uint8(s, byte);
if (byte & 0x01)
{
*value = (byte & 0x7F) << 16;
stream_read_uint8(s, byte);
*value |= byte;
}
else
{
*value = byte;
}
}
/* Primary Drawing Orders */
void update_read_dstblt_order(STREAM* s, ORDER_INFO* orderInfo, DSTBLT_ORDER* dstblt)
@ -256,6 +303,8 @@ 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);
@ -275,10 +324,14 @@ void update_read_multi_dstblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_DSTB
stream_read_uint8(s, multi_dstblt->nDeltaEntries);
/* codeDeltaList */
stream_read_uint16(s, cbData);
stream_seek(s, 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);
@ -319,10 +372,14 @@ void update_read_multi_patblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_PATB
stream_read_uint8(s, multi_patblt->nDeltaEntries);
/* codeDeltaList */
stream_read_uint16(s, cbData);
stream_seek(s, 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);
@ -348,11 +405,14 @@ void update_read_multi_scrblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_SCRB
stream_read_uint8(s, multi_scrblt->nDeltaEntries);
/* codeDeltaList */
stream_read_uint16(s, cbData);
stream_seek(s, 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);
@ -388,6 +448,8 @@ void update_read_multi_opaque_rect_order(STREAM* s, ORDER_INFO* orderInfo, MULTI
stream_read_uint8(s, multi_opaque_rect->nDeltaEntries);
/* codeDeltaList */
stream_read_uint16(s, cbData);
stream_seek(s, cbData);
}
void update_read_multi_draw_nine_grid_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
@ -430,6 +492,8 @@ 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);
@ -446,6 +510,8 @@ void update_read_polyline_order(STREAM* s, ORDER_INFO* orderInfo, POLYLINE_ORDER
stream_read_uint8(s, polyline->nDeltaEntries);
/* codeDeltaList */
stream_read_uint8(s, cbData);
stream_seek(s, cbData);
}
void update_read_memblt_order(STREAM* s, ORDER_INFO* orderInfo, MEMBLT_ORDER* memblt)
@ -552,6 +618,8 @@ void update_read_save_bitmap_order(STREAM* s, ORDER_INFO* orderInfo, SAVE_BITMAP
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);
@ -595,10 +663,14 @@ void update_read_fast_index_order(STREAM* s, ORDER_INFO* orderInfo, FAST_INDEX_O
update_read_coord(s, &fast_index->y, orderInfo->deltaCoordinates);
/* bytes */
stream_read_uint8(s, cbData);
stream_seek(s, 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);
@ -642,10 +714,14 @@ void update_read_fast_glyph_order(STREAM* s, ORDER_INFO* orderInfo, FAST_GLYPH_O
update_read_coord(s, &fast_glyph->y, orderInfo->deltaCoordinates);
/* bytes */
stream_read_uint8(s, cbData);
stream_seek(s, cbData);
}
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);
@ -710,10 +786,14 @@ void update_read_glyph_index_order(STREAM* s, ORDER_INFO* orderInfo, GLYPH_INDEX
update_read_coord(s, &glyph_index->y, orderInfo->deltaCoordinates);
/* bytes */
stream_read_uint8(s, cbData);
stream_seek(s, 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);
@ -733,10 +813,14 @@ void update_read_polygon_sc_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_SC_O
stream_read_uint8(s, polygon_sc->nDeltaEntries);
/* codeDeltaList */
stream_read_uint8(s, cbData);
stream_seek(s, 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);
@ -774,6 +858,8 @@ void update_read_polygon_cb_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_CB_O
stream_read_uint8(s, polygon_cb->nDeltaEntries);
/* codeDeltaList */
stream_read_uint8(s, cbData);
stream_seek(s, cbData);
}
void update_read_ellipse_sc_order(STREAM* s, ORDER_INFO* orderInfo, ELLIPSE_SC_ORDER* ellipse_sc)
@ -844,19 +930,84 @@ void update_read_ellipse_cb_order(STREAM* s, ORDER_INFO* orderInfo, ELLIPSE_CB_O
/* Secondary Drawing Orders */
void update_read_cache_bitmap_order(STREAM* s, CACHE_BITMAP_ORDER* cache_bitmap_order, boolean compressed)
void update_read_cache_bitmap_order(STREAM* s, CACHE_BITMAP_ORDER* cache_bitmap_order, boolean compressed, uint16 flags)
{
stream_read_uint8(s, cache_bitmap_order->cacheId); /* cacheId (1 byte) */
stream_seek_uint8(s); /* pad1Octet (1 byte) */
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) */
if (compressed)
{
if (flags & NO_BITMAP_COMPRESSION_HDR)
{
stream_seek(s, cache_bitmap_order->bitmapLength); /* bitmapDataStream */
}
else
{
uint8* bitmapComprHdr = (uint8*) &(cache_bitmap_order->bitmapComprHdr);
stream_read(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
stream_seek(s, cache_bitmap_order->bitmapLength); /* bitmapDataStream */
}
}
else
{
stream_seek(s, cache_bitmap_order->bitmapLength); /* bitmapDataStream */
}
}
void update_read_cache_bitmap_v2_order(STREAM* s, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2_order, boolean compressed)
void update_read_cache_bitmap_v2_order(STREAM* s, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2_order, boolean compressed, uint16 flags)
{
uint8 bitsPerPixelId;
cache_bitmap_v2_order->cacheId = flags & 0x00000003;
cache_bitmap_v2_order->flags = (flags & 0x0000FF80) >> 7;
bitsPerPixelId = (flags & 0x00000078) >> 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) */
update_read_2byte_unsigned_encoding(s, &cache_bitmap_v2_order->cacheIndex); /* cacheIndex */
if (compressed)
{
if (cache_bitmap_v2_order->flags & CBR2_NO_BITMAP_COMPRESSION_HDR)
{
stream_seek(s, cache_bitmap_v2_order->bitmapLength); /* bitmapDataStream */
}
else
{
uint8* bitmapComprHdr = (uint8*) &(cache_bitmap_v2_order->bitmapComprHdr);
stream_read(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
stream_seek(s, cache_bitmap_v2_order->bitmapLength); /* bitmapDataStream */
}
}
else
{
stream_seek(s, cache_bitmap_v2_order->bitmapLength); /* bitmapDataStream */
}
}
void update_read_cache_bitmap_v3_order(STREAM* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order, boolean compressed)
void update_read_cache_bitmap_v3_order(STREAM* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order, boolean compressed, uint16 flags)
{
uint8 bitsPerPixelId;
cache_bitmap_v3_order->cacheId = flags & 0x00000003;
cache_bitmap_v3_order->flags = (flags & 0x0000FF80) >> 7;
bitsPerPixelId = (flags & 0x00000078) >> 3;
cache_bitmap_v3_order->bpp = CBR23_BPP[bitsPerPixelId];
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) */
}
void update_read_cache_color_table_order(STREAM* s, CACHE_COLOR_TABLE_ORDER* cache_color_table_order)
@ -883,62 +1034,140 @@ void update_read_cache_brush_order(STREAM* s, CACHE_BRUSH_ORDER* cache_brush_ord
void update_read_create_offscreen_bitmap_order(STREAM* s, CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
{
uint16 flags;
boolean deleteListPresent;
stream_read_uint16(s, flags); /* flags (2 bytes) */
create_offscreen_bitmap->offscreenBitmapId = flags & 0x7FFF;
deleteListPresent = (flags & 0x8000) ? True : False;
stream_read_uint16(s, create_offscreen_bitmap->cx); /* cx (2 bytes) */
stream_read_uint16(s, create_offscreen_bitmap->cy); /* cy (2 bytes) */
if (deleteListPresent)
{
int i;
OFFSCREEN_DELETE_LIST* deleteList;
deleteList = &(create_offscreen_bitmap->deleteList);
stream_read_uint16(s, deleteList->cIndices);
if (deleteList->indices == NULL)
deleteList->indices = xmalloc(deleteList->cIndices * 2);
else
deleteList->indices = xrealloc(deleteList->indices, deleteList->cIndices * 2);
for (i = 0; i < deleteList->cIndices; i++)
{
stream_read_uint16(s, deleteList->indices[i]);
}
}
}
void update_read_switch_surface_order(STREAM* s, SWITCH_SURFACE_ORDER* switch_surface)
{
stream_read_uint16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
}
void update_read_create_nine_grid_bitmap_order(STREAM* s, CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
{
NINE_GRID_BITMAP_INFO* nineGridInfo;
stream_read_uint8(s, create_nine_grid_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
stream_read_uint16(s, create_nine_grid_bitmap->bitmapId); /* bitmapId (2 bytes) */
nineGridInfo = &(create_nine_grid_bitmap->nineGridInfo);
stream_read_uint32(s, nineGridInfo->flFlags); /* flFlags (4 bytes) */
stream_read_uint16(s, nineGridInfo->ulLeftWidth); /* ulLeftWidth (2 bytes) */
stream_read_uint16(s, nineGridInfo->ulRightWidth); /* ulRightWidth (2 bytes) */
stream_read_uint16(s, nineGridInfo->ulTopHeight); /* ulTopHeight (2 bytes) */
stream_read_uint16(s, nineGridInfo->ulBottomHeight); /* ulBottomHeight (2 bytes) */
update_read_colorref(s, &nineGridInfo->crTransparent); /* crTransparent (4 bytes) */
}
void update_read_frame_marker_order(STREAM* s, FRAME_MARKER_ORDER* frame_marker)
{
stream_read_uint32(s, frame_marker->action); /* action (4 bytes) */
}
void update_read_stream_bitmap_first_order(STREAM* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
{
stream_read_uint8(s, stream_bitmap_first->bitmapFlags); /* bitmapFlags (1 byte) */
stream_read_uint8(s, stream_bitmap_first->bitmapBpp); /* bitmapBpp (1 byte) */
stream_read_uint16(s, stream_bitmap_first->bitmapType); /* bitmapType (2 bytes) */
stream_read_uint16(s, stream_bitmap_first->bitmapWidth); /* bitmapWidth (2 bytes) */
stream_read_uint16(s, stream_bitmap_first->bitmapHeight); /* bitmapHeigth (2 bytes) */
if (stream_bitmap_first->bitmapFlags & STREAM_BITMAP_V2)
stream_read_uint32(s, stream_bitmap_first->bitmapSize); /* bitmapSize (4 bytes) */
else
stream_read_uint16(s, stream_bitmap_first->bitmapSize); /* bitmapSize (2 bytes) */
stream_read_uint16(s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize (2 bytes) */
stream_seek(s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlock */
}
void update_read_stream_bitmap_next_order(STREAM* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_next)
{
stream_read_uint8(s, stream_bitmap_next->bitmapFlags); /* bitmapFlags (1 byte) */
stream_read_uint16(s, stream_bitmap_next->bitmapType); /* bitmapType (2 bytes) */
stream_read_uint16(s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize (2 bytes) */
stream_seek(s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlock */
}
void update_read_draw_gdiplus_first_order(STREAM* s, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
{
stream_seek_uint8(s); /* pad1Octet (1 byte) */
stream_read_uint16(s, draw_gdiplus_first->cbSize); /* cbSize (2 bytes) */
stream_read_uint32(s, draw_gdiplus_first->cbTotalSize); /* cbTotalSize (4 bytes) */
stream_read_uint32(s, draw_gdiplus_first->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
stream_seek(s, draw_gdiplus_first->cbSize); /* emfRecords */
}
void update_read_draw_gdiplus_next_order(STREAM* s, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
{
stream_seek_uint8(s); /* pad1Octet (1 byte) */
stream_read_uint16(s, draw_gdiplus_next->cbSize); /* cbSize (2 bytes) */
stream_seek(s, draw_gdiplus_next->cbSize); /* emfRecords */
}
void update_read_draw_gdiplus_end_order(STREAM* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
{
stream_seek_uint8(s); /* pad1Octet (1 byte) */
stream_read_uint16(s, draw_gdiplus_end->cbSize); /* cbSize (2 bytes) */
stream_read_uint32(s, draw_gdiplus_end->cbTotalSize); /* cbTotalSize (4 bytes) */
stream_read_uint32(s, draw_gdiplus_end->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
stream_seek(s, draw_gdiplus_end->cbSize); /* emfRecords */
}
void update_read_draw_gdiplus_cache_first_order(STREAM* s, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
{
stream_read_uint8(s, draw_gdiplus_cache_first->flags); /* flags (1 byte) */
stream_read_uint16(s, draw_gdiplus_cache_first->cacheType); /* cacheType (2 bytes) */
stream_read_uint16(s, draw_gdiplus_cache_first->cacheIndex); /* cacheIndex (2 bytes) */
stream_read_uint16(s, draw_gdiplus_cache_first->cbSize); /* cbSize (2 bytes) */
stream_read_uint32(s, draw_gdiplus_cache_first->cbTotalSize); /* cbTotalSize (4 bytes) */
stream_seek(s, draw_gdiplus_cache_first->cbSize); /* emfRecords */
}
void update_read_draw_gdiplus_cache_next_order(STREAM* s, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
{
stream_read_uint8(s, draw_gdiplus_cache_next->flags); /* flags (1 byte) */
stream_read_uint16(s, draw_gdiplus_cache_next->cacheType); /* cacheType (2 bytes) */
stream_read_uint16(s, draw_gdiplus_cache_next->cacheIndex); /* cacheIndex (2 bytes) */
stream_read_uint16(s, draw_gdiplus_cache_next->cbSize); /* cbSize (2 bytes) */
stream_seek(s, draw_gdiplus_cache_next->cbSize); /* emfRecords */
}
void update_read_draw_gdiplus_cache_end_order(STREAM* s, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
{
stream_read_uint8(s, draw_gdiplus_cache_end->flags); /* flags (1 byte) */
stream_read_uint16(s, draw_gdiplus_cache_end->cacheType); /* cacheType (2 bytes) */
stream_read_uint16(s, draw_gdiplus_cache_end->cacheIndex); /* cacheIndex (2 bytes) */
stream_read_uint16(s, draw_gdiplus_cache_end->cbSize); /* cbSize (2 bytes) */
stream_read_uint32(s, draw_gdiplus_cache_end->cbTotalSize); /* cbTotalSize (4 bytes) */
stream_seek(s, draw_gdiplus_cache_end->cbSize); /* emfRecords */
}
void update_read_field_flags(STREAM* s, uint32* fieldFlags, uint8 flags, uint8 fieldBytes)
@ -1020,7 +1249,10 @@ void update_recv_primary_order(rdpUpdate* update, STREAM* s, uint8 flags)
orderInfo->deltaCoordinates = (flags & ORDER_DELTA_COORDINATES) ? True : False;
printf("%s Primary Drawing Order\n", PRIMARY_DRAWING_ORDER_STRINGS[orderInfo->orderType]);
if (orderInfo->orderType < PRIMARY_DRAWING_ORDER_COUNT)
printf("%s Primary Drawing Order (%d)\n", PRIMARY_DRAWING_ORDER_STRINGS[orderInfo->orderType], orderInfo->orderType);
else
printf("Unknown Primary Drawing Order (%d)\n", orderInfo->orderType);
switch (orderInfo->orderType)
{
@ -1157,32 +1389,35 @@ void update_recv_secondary_order(rdpUpdate* update, STREAM* s, uint8 flags)
orderLength += 13; /* adjust length (13 bytes less than actual length) */
next += orderLength;
printf("%s Secondary Drawing Order\n", SECONDARY_DRAWING_ORDER_STRINGS[orderType]);
if (orderType < SECONDARY_DRAWING_ORDER_COUNT)
printf("%s Secondary Drawing Order (%d)\n", SECONDARY_DRAWING_ORDER_STRINGS[orderType], orderType);
else
printf("Unknown Secondary Drawing Order (%d)\n", orderType);
switch (orderType)
{
case ORDER_TYPE_BITMAP_UNCOMPRESSED:
update_read_cache_bitmap_order(s, &(update->cache_bitmap_order), False);
update_read_cache_bitmap_order(s, &(update->cache_bitmap_order), False, extraFlags);
IFCALL(update->CacheBitmap, update, &(update->cache_bitmap_order));
break;
case ORDER_TYPE_CACHE_BITMAP_COMPRESSED:
update_read_cache_bitmap_order(s, &(update->cache_bitmap_order), True);
update_read_cache_bitmap_order(s, &(update->cache_bitmap_order), True, extraFlags);
IFCALL(update->CacheBitmap, update, &(update->cache_bitmap_order));
break;
case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2:
update_read_cache_bitmap_v2_order(s, &(update->cache_bitmap_v2_order), False);
update_read_cache_bitmap_v2_order(s, &(update->cache_bitmap_v2_order), False, extraFlags);
IFCALL(update->CacheBitmapV2, update, &(update->cache_bitmap_v2_order));
break;
case ORDER_TYPE_BITMAP_COMPRESSED_V2:
update_read_cache_bitmap_v2_order(s, &(update->cache_bitmap_v2_order), True);
update_read_cache_bitmap_v2_order(s, &(update->cache_bitmap_v2_order), True, extraFlags);
IFCALL(update->CacheBitmapV2, update, &(update->cache_bitmap_v2_order));
break;
case ORDER_TYPE_BITMAP_COMPRESSED_V3:
update_read_cache_bitmap_v3_order(s, &(update->cache_bitmap_v3_order), True);
update_read_cache_bitmap_v3_order(s, &(update->cache_bitmap_v3_order), True, extraFlags);
IFCALL(update->CacheBitmapV3, update, &(update->cache_bitmap_v3_order));
break;
@ -1222,7 +1457,10 @@ void update_recv_altsec_order(rdpUpdate* update, STREAM* s, uint8 flags)
orderType = flags >>= 2; /* orderType is in higher 6 bits of flags field */
printf("%s Alternate Secondary Drawing Order\n", ALTSEC_DRAWING_ORDER_STRINGS[orderType]);
if (orderType < ALTSEC_DRAWING_ORDER_COUNT)
printf("%s Alternate Secondary Drawing Order (%d)\n", ALTSEC_DRAWING_ORDER_STRINGS[orderType], orderType);
else
printf("Unknown Alternate Secondary Drawing Order: %d\n", orderType);
switch (orderType)
{

19
libfreerdp-core/orders.h
View File

@ -70,6 +70,25 @@
#define ORDER_FIELD_22 0x200000
#define ORDER_FIELD_23 0x400000
/* Bitmap Cache Flags */
#define CBR2_8BPP 0x3
#define CBR2_16BPP 0x4
#define CBR2_24BPP 0x5
#define CBR2_32BPP 0x6
#define CBR2_HEIGHT_SAME_AS_WIDTH 0x01
#define CBR2_PERSISTENT_KEY_PRESENT 0x02
#define CBR2_NO_BITMAP_COMPRESSION_HDR 0x08
#define CBR2_DO_NOT_CACHE 0x10
#define CBR23_8BPP 0x3
#define CBR23_16BPP 0x4
#define CBR23_24BPP 0x5
#define CBR23_32BPP 0x6
#define CBR3_IGNORABLE_FLAG 0x08
#define CBR3_DO_NOT_CACHE 0x10
/* Order Classes */
#define ORDER_PRIMARY_CLASS 0x01
#define ORDER_SECONDARY_CLASS 0x03

3
libfreerdp-core/update.c
View File

@ -151,7 +151,8 @@ void update_recv(rdpUpdate* update, STREAM* s)
stream_read_uint16(s, updateType); /* updateType (2 bytes) */
//printf("%s Update Data PDU\n", UPDATE_TYPE_STRINGS[updateType]);
if (updateType != UPDATE_TYPE_BITMAP)
printf("%s Update Data PDU\n", UPDATE_TYPE_STRINGS[updateType]);
IFCALL(update->BeginPaint, update);