static const BYTE CBR2_BPP[] =
{
- 0, 0, 0, 8, 16, 24, 32
+ 0, 0, 0, 8, 16, 24, 32
};
static const BYTE BPP_CBR2[] =
{
- 0, 0, 0, 0, 0, 0, 0, 0,
- 3, 0, 0, 0, 0, 0, 0, 0,
- 4, 0, 0, 0, 0, 0, 0, 0,
- 5, 0, 0, 0, 0, 0, 0, 0,
- 6, 0, 0, 0, 0, 0, 0, 0
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 3, 0, 0, 0, 0, 0, 0, 0,
+ 4, 0, 0, 0, 0, 0, 0, 0,
+ 5, 0, 0, 0, 0, 0, 0, 0,
+ 6, 0, 0, 0, 0, 0, 0, 0
};
static const BYTE CBR23_BPP[] =
{
- 0, 0, 0, 8, 16, 24, 32
+ 0, 0, 0, 8, 16, 24, 32
};
static const BYTE BPP_CBR23[] =
{
- 0, 0, 0, 0, 0, 0, 0, 0,
- 3, 0, 0, 0, 0, 0, 0, 0,
- 4, 0, 0, 0, 0, 0, 0, 0,
- 5, 0, 0, 0, 0, 0, 0, 0,
- 6, 0, 0, 0, 0, 0, 0, 0
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 3, 0, 0, 0, 0, 0, 0, 0,
+ 4, 0, 0, 0, 0, 0, 0, 0,
+ 5, 0, 0, 0, 0, 0, 0, 0,
+ 6, 0, 0, 0, 0, 0, 0, 0
};
static const BYTE BMF_BPP[] =
{
- 0, 1, 0, 8, 16, 24, 32
+ 0, 1, 0, 8, 16, 24, 32
};
static const BYTE BPP_BMF[] =
{
- 0, 1, 0, 0, 0, 0, 0, 0,
- 3, 0, 0, 0, 0, 0, 0, 0,
- 4, 0, 0, 0, 0, 0, 0, 0,
- 5, 0, 0, 0, 0, 0, 0, 0,
- 6, 0, 0, 0, 0, 0, 0, 0
+ 0, 1, 0, 0, 0, 0, 0, 0,
+ 3, 0, 0, 0, 0, 0, 0, 0,
+ 4, 0, 0, 0, 0, 0, 0, 0,
+ 5, 0, 0, 0, 0, 0, 0, 0,
+ 6, 0, 0, 0, 0, 0, 0, 0
};
static INLINE BOOL update_read_coord(wStream* s, INT32* coord, BOOL delta)
return TRUE;
}
-#if 0
-static INLINE BOOL update_write_coord_delta(wStream* s, INT32 prevCoord, INT32 nextCoord)
-{
- INT8 lsi8;
-
- lsi8 = nextCoord - prevCoord;
- Stream_Write_UINT8(s, lsi8);
-
- return TRUE;
-}
-#endif
-
static INLINE BOOL update_read_color(wStream* s, UINT32* color)
{
BYTE byte;
*color |= ((UINT32) byte << 8);
Stream_Read_UINT8(s, byte);
*color |= (UINT32) byte;
-
return TRUE;
}
static INLINE BOOL update_write_color(wStream* s, UINT32 color)
{
BYTE byte;
-
byte = (color & 0xFF);
Stream_Write_UINT8(s, byte);
byte = ((color >> 8) & 0xFF);
Stream_Write_UINT8(s, byte);
byte = ((color >> 16) & 0xFF);
Stream_Write_UINT8(s, byte);
-
return TRUE;
}
static INLINE void update_read_colorref(wStream* s, UINT32* color)
{
BYTE byte;
-
Stream_Read_UINT8(s, byte);
*color = byte;
Stream_Read_UINT8(s, byte);
static INLINE void update_read_color_quad(wStream* s, UINT32* color)
{
BYTE byte;
-
Stream_Read_UINT8(s, byte);
*color = (byte << 16);
Stream_Read_UINT8(s, byte);
static INLINE void update_write_color_quad(wStream* s, UINT32 color)
{
BYTE byte;
-
byte = (color << 16) & 0xFF;
Stream_Write_UINT8(s, byte);
byte = (color << 8) & 0xFF;
if (Stream_GetRemainingLength(s) < 1)
return FALSE;
+
Stream_Read_UINT8(s, byte);
if (byte & 0x80)
return FALSE;
Stream_Read_UINT8(s, byte);
-
negative = (byte & 0x40) ? TRUE : FALSE;
-
*value = (byte & 0x3F);
if (byte & 0x80)
return FALSE;
Stream_Read_UINT8(s, byte);
-
count = (byte & 0xC0) >> 6;
if (Stream_GetRemainingLength(s) < count)
WLog_ERR(TAG, "Stream_GetRemainingLength(s) < 1");
return FALSE;
}
+
Stream_Read_UINT8(s, byte);
if (byte & 0x40)
WLog_ERR(TAG, "Stream_GetRemainingLength(s) < 1");
return FALSE;
}
+
Stream_Read_UINT8(s, byte);
*value = (*value << 8) | byte;
}
+
return TRUE;
}
static INLINE void update_read_glyph_delta(wStream* s, UINT16* value)
{
BYTE byte;
-
Stream_Read_UINT8(s, byte);
if (byte == 0x80)
static INLINE void update_seek_glyph_delta(wStream* s)
{
BYTE byte;
-
Stream_Read_UINT8(s, byte);
if (byte & 0x80)
}
#endif
-static INLINE BOOL update_read_brush(wStream* s, rdpBrush* brush, BYTE fieldFlags)
+static INLINE BOOL update_read_brush(wStream* s, rdpBrush* brush,
+ BYTE fieldFlags)
{
if (fieldFlags & ORDER_FIELD_01)
{
if (brush->style & CACHED_BRUSH)
{
brush->index = brush->hatch;
-
brush->bpp = BMF_BPP[brush->style & 0x0F];
if (brush->bpp == 0)
}
static INLINE BOOL update_write_brush(wStream* s, rdpBrush* brush,
- BYTE fieldFlags)
+ BYTE fieldFlags)
{
if (fieldFlags & ORDER_FIELD_01)
{
if (brush->style & CACHED_BRUSH)
{
brush->hatch = brush->index;
-
brush->bpp = BMF_BPP[brush->style & 0x0F];
if (brush->bpp == 0)
return TRUE;
}
-static INLINE BOOL update_read_delta_rects(wStream* s, DELTA_RECT* rectangles, int number)
+static INLINE BOOL update_read_delta_rects(wStream* s, DELTA_RECT* rectangles,
+ int number)
{
int i;
BYTE flags = 0;
Stream_GetPointer(s, zeroBits);
Stream_Seek(s, zeroBitsSize);
-
ZeroMemory(rectangles, sizeof(DELTA_RECT) * (number + 1));
for (i = 1; i < number + 1; i++)
rectangles[i].left = rectangles[i].left + rectangles[i - 1].left;
rectangles[i].top = rectangles[i].top + rectangles[i - 1].top;
-
flags <<= 4;
}
return TRUE;
}
-static INLINE BOOL update_read_delta_points(wStream* s, DELTA_POINT* points, int number, INT16 x, INT16 y)
+static INLINE BOOL update_read_delta_points(wStream* s, DELTA_POINT* points,
+ int number, INT16 x, INT16 y)
{
int i;
BYTE flags = 0;
BYTE* zeroBits;
UINT32 zeroBitsSize;
-
zeroBitsSize = ((number + 3) / 4);
if (Stream_GetRemainingLength(s) < zeroBitsSize)
Stream_GetPointer(s, zeroBits);
Stream_Seek(s, zeroBitsSize);
-
ZeroMemory(points, sizeof(DELTA_POINT) * number);
for (i = 0; i < number; i++)
flags <<= 2;
}
+
return TRUE;
}
} while(0)
/* Primary Drawing Orders */
-static BOOL update_read_dstblt_order(wStream* s, ORDER_INFO* orderInfo, DSTBLT_ORDER* dstblt)
+static BOOL update_read_dstblt_order(wStream* s, ORDER_INFO* orderInfo,
+ DSTBLT_ORDER* dstblt)
{
ORDER_FIELD_COORD(1, dstblt->nLeftRect);
ORDER_FIELD_COORD(2, dstblt->nTopRect);
}
int update_approximate_dstblt_order(ORDER_INFO* orderInfo,
- const DSTBLT_ORDER* dstblt)
+ const DSTBLT_ORDER* dstblt)
{
return 32;
}
BOOL update_write_dstblt_order(wStream* s, ORDER_INFO* orderInfo,
- const DSTBLT_ORDER* dstblt)
+ const DSTBLT_ORDER* dstblt)
{
-
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_dstblt_order(orderInfo, dstblt)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_dstblt_order(orderInfo, dstblt)))
return FALSE;
orderInfo->fieldFlags = 0;
-
orderInfo->fieldFlags |= ORDER_FIELD_01;
update_write_coord(s, dstblt->nLeftRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_02;
update_write_coord(s, dstblt->nTopRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_03;
update_write_coord(s, dstblt->nWidth);
-
orderInfo->fieldFlags |= ORDER_FIELD_04;
update_write_coord(s, dstblt->nHeight);
-
orderInfo->fieldFlags |= ORDER_FIELD_05;
Stream_Write_UINT8(s, dstblt->bRop);
-
return TRUE;
}
-static BOOL update_read_patblt_order(wStream* s, ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
+static BOOL update_read_patblt_order(wStream* s, ORDER_INFO* orderInfo,
+ PATBLT_ORDER* patblt)
{
ORDER_FIELD_COORD(1, patblt->nLeftRect);
ORDER_FIELD_COORD(2, patblt->nTopRect);
return 32;
}
-BOOL update_write_patblt_order(wStream* s, ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
+BOOL update_write_patblt_order(wStream* s, ORDER_INFO* orderInfo,
+ PATBLT_ORDER* patblt)
{
-
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_patblt_order(orderInfo, patblt)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_patblt_order(orderInfo, patblt)))
return FALSE;
orderInfo->fieldFlags = 0;
-
orderInfo->fieldFlags |= ORDER_FIELD_01;
update_write_coord(s, patblt->nLeftRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_02;
update_write_coord(s, patblt->nTopRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_03;
update_write_coord(s, patblt->nWidth);
-
orderInfo->fieldFlags |= ORDER_FIELD_04;
update_write_coord(s, patblt->nHeight);
-
orderInfo->fieldFlags |= ORDER_FIELD_05;
Stream_Write_UINT8(s, patblt->bRop);
-
orderInfo->fieldFlags |= ORDER_FIELD_06;
update_write_color(s, patblt->backColor);
-
orderInfo->fieldFlags |= ORDER_FIELD_07;
update_write_color(s, patblt->foreColor);
-
orderInfo->fieldFlags |= ORDER_FIELD_08;
orderInfo->fieldFlags |= ORDER_FIELD_09;
orderInfo->fieldFlags |= ORDER_FIELD_10;
orderInfo->fieldFlags |= ORDER_FIELD_11;
orderInfo->fieldFlags |= ORDER_FIELD_12;
update_write_brush(s, &patblt->brush, orderInfo->fieldFlags >> 7);
-
return TRUE;
}
static BOOL update_read_scrblt_order(wStream* s, ORDER_INFO* orderInfo,
- SCRBLT_ORDER* scrblt)
+ SCRBLT_ORDER* scrblt)
{
ORDER_FIELD_COORD(1, scrblt->nLeftRect);
ORDER_FIELD_COORD(2, scrblt->nTopRect);
ORDER_FIELD_BYTE(5, scrblt->bRop);
ORDER_FIELD_COORD(6, scrblt->nXSrc);
ORDER_FIELD_COORD(7, scrblt->nYSrc);
-
return TRUE;
}
int update_approximate_scrblt_order(ORDER_INFO* orderInfo,
- const SCRBLT_ORDER* scrblt)
+ const SCRBLT_ORDER* scrblt)
{
return 32;
}
BOOL update_write_scrblt_order(wStream* s, ORDER_INFO* orderInfo,
- const SCRBLT_ORDER* scrblt)
+ const SCRBLT_ORDER* scrblt)
{
-
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_scrblt_order(orderInfo, scrblt)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_scrblt_order(orderInfo, scrblt)))
return FALSE;
orderInfo->fieldFlags = 0;
-
orderInfo->fieldFlags |= ORDER_FIELD_01;
update_write_coord(s, scrblt->nLeftRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_02;
update_write_coord(s, scrblt->nTopRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_03;
update_write_coord(s, scrblt->nWidth);
-
orderInfo->fieldFlags |= ORDER_FIELD_04;
update_write_coord(s, scrblt->nHeight);
-
orderInfo->fieldFlags |= ORDER_FIELD_05;
Stream_Write_UINT8(s, scrblt->bRop);
-
orderInfo->fieldFlags |= ORDER_FIELD_06;
update_write_coord(s, scrblt->nXSrc);
-
orderInfo->fieldFlags |= ORDER_FIELD_07;
update_write_coord(s, scrblt->nYSrc);
-
return TRUE;
}
static BOOL update_read_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo,
- OPAQUE_RECT_ORDER* opaque_rect)
+ OPAQUE_RECT_ORDER* opaque_rect)
{
BYTE byte;
-
ORDER_FIELD_COORD(1, opaque_rect->nLeftRect);
ORDER_FIELD_COORD(2, opaque_rect->nTopRect);
ORDER_FIELD_COORD(3, opaque_rect->nWidth);
}
int update_approximate_opaque_rect_order(ORDER_INFO* orderInfo,
- const OPAQUE_RECT_ORDER* opaque_rect)
+ const OPAQUE_RECT_ORDER* opaque_rect)
{
return 32;
}
BOOL update_write_opaque_rect_order(wStream* s, ORDER_INFO* orderInfo,
- const OPAQUE_RECT_ORDER* opaque_rect)
+ const OPAQUE_RECT_ORDER* opaque_rect)
{
BYTE byte;
int inf = update_approximate_opaque_rect_order(orderInfo, opaque_rect);
return FALSE;
orderInfo->fieldFlags = 0;
-
orderInfo->fieldFlags |= ORDER_FIELD_01;
update_write_coord(s, opaque_rect->nLeftRect);
orderInfo->fieldFlags |= ORDER_FIELD_02;
update_write_coord(s, opaque_rect->nWidth);
orderInfo->fieldFlags |= ORDER_FIELD_04;
update_write_coord(s, opaque_rect->nHeight);
-
orderInfo->fieldFlags |= ORDER_FIELD_05;
byte = opaque_rect->color & 0x000000FF;
Stream_Write_UINT8(s, byte);
-
orderInfo->fieldFlags |= ORDER_FIELD_06;
byte = (opaque_rect->color & 0x0000FF00) >> 8;
Stream_Write_UINT8(s, byte);
-
orderInfo->fieldFlags |= ORDER_FIELD_07;
byte = (opaque_rect->color & 0x00FF0000) >> 16;
Stream_Write_UINT8(s, byte);
-
return TRUE;
}
static BOOL update_read_draw_nine_grid_order(wStream* s, ORDER_INFO* orderInfo,
- DRAW_NINE_GRID_ORDER* draw_nine_grid)
+ DRAW_NINE_GRID_ORDER* draw_nine_grid)
{
ORDER_FIELD_COORD(1, draw_nine_grid->srcLeft);
ORDER_FIELD_COORD(2, draw_nine_grid->srcTop);
ORDER_FIELD_COORD(3, draw_nine_grid->srcRight);
ORDER_FIELD_COORD(4, draw_nine_grid->srcBottom);
ORDER_FIELD_UINT16(5, draw_nine_grid->bitmapId);
-
return TRUE;
}
static BOOL update_read_multi_dstblt_order(wStream* s, ORDER_INFO* orderInfo,
- MULTI_DSTBLT_ORDER* multi_dstblt)
+ MULTI_DSTBLT_ORDER* multi_dstblt)
{
ORDER_FIELD_COORD(1, multi_dstblt->nLeftRect);
ORDER_FIELD_COORD(2, multi_dstblt->nTopRect);
return FALSE;
Stream_Read_UINT16(s, multi_dstblt->cbData);
-
- return update_read_delta_rects(s, multi_dstblt->rectangles, multi_dstblt->numRectangles);
+ return update_read_delta_rects(s, multi_dstblt->rectangles,
+ multi_dstblt->numRectangles);
}
return TRUE;
}
static BOOL update_read_multi_patblt_order(wStream* s, ORDER_INFO* orderInfo,
- MULTI_PATBLT_ORDER* multi_patblt)
+ MULTI_PATBLT_ORDER* multi_patblt)
{
ORDER_FIELD_COORD(1, multi_patblt->nLeftRect);
ORDER_FIELD_COORD(2, multi_patblt->nTopRect);
Stream_Read_UINT16(s, multi_patblt->cbData);
- if (!update_read_delta_rects(s, multi_patblt->rectangles, multi_patblt->numRectangles))
+ if (!update_read_delta_rects(s, multi_patblt->rectangles,
+ multi_patblt->numRectangles))
return FALSE;
}
+
return TRUE;
}
static BOOL update_read_multi_scrblt_order(wStream* s, ORDER_INFO* orderInfo,
- MULTI_SCRBLT_ORDER* multi_scrblt)
+ MULTI_SCRBLT_ORDER* multi_scrblt)
{
ORDER_FIELD_COORD(1, multi_scrblt->nLeftRect);
ORDER_FIELD_COORD(2, multi_scrblt->nTopRect);
return FALSE;
Stream_Read_UINT16(s, multi_scrblt->cbData);
- return update_read_delta_rects(s, multi_scrblt->rectangles, multi_scrblt->numRectangles);
+ return update_read_delta_rects(s, multi_scrblt->rectangles,
+ multi_scrblt->numRectangles);
}
+
return TRUE;
}
static BOOL update_read_multi_opaque_rect_order(wStream* s,
- ORDER_INFO* orderInfo,
- MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
+ ORDER_INFO* orderInfo,
+ MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
{
BYTE byte;
-
ORDER_FIELD_COORD(1, multi_opaque_rect->nLeftRect);
ORDER_FIELD_COORD(2, multi_opaque_rect->nTopRect);
ORDER_FIELD_COORD(3, multi_opaque_rect->nWidth);
return FALSE;
Stream_Read_UINT8(s, byte);
- multi_opaque_rect->color = (multi_opaque_rect->color & 0xFF00FFFF) | ((UINT32) byte << 16);
+ multi_opaque_rect->color = (multi_opaque_rect->color & 0xFF00FFFF) | ((
+ UINT32) byte << 16);
}
if (orderInfo->fieldFlags & ORDER_FIELD_06)
return FALSE;
Stream_Read_UINT8(s, byte);
- multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFF00FF) | ((UINT32) byte << 8);
+ multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFF00FF) | ((
+ UINT32) byte << 8);
}
if (orderInfo->fieldFlags & ORDER_FIELD_07)
return FALSE;
Stream_Read_UINT8(s, byte);
- multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFFFF00) | (UINT32) byte;
+ multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFFFF00) |
+ (UINT32) byte;
}
ORDER_FIELD_BYTE(8, multi_opaque_rect->numRectangles);
{
if (Stream_GetRemainingLength(s) < 2)
return FALSE;
+
Stream_Read_UINT16(s, multi_opaque_rect->cbData);
- return update_read_delta_rects(s, multi_opaque_rect->rectangles, multi_opaque_rect->numRectangles);
+ return update_read_delta_rects(s, multi_opaque_rect->rectangles,
+ multi_opaque_rect->numRectangles);
}
return TRUE;
}
static BOOL update_read_multi_draw_nine_grid_order(wStream* s,
- ORDER_INFO* orderInfo,
- MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
+ ORDER_INFO* orderInfo,
+ MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
{
ORDER_FIELD_COORD(1, multi_draw_nine_grid->srcLeft);
ORDER_FIELD_COORD(2, multi_draw_nine_grid->srcTop);
}
static BOOL update_read_line_to_order(wStream* s, ORDER_INFO* orderInfo,
- LINE_TO_ORDER* line_to)
+ LINE_TO_ORDER* line_to)
{
ORDER_FIELD_UINT16(1, line_to->backMode);
ORDER_FIELD_COORD(2, line_to->nXStart);
}
int update_approximate_line_to_order(ORDER_INFO* orderInfo,
- const LINE_TO_ORDER* line_to)
+ const LINE_TO_ORDER* line_to)
{
return 32;
}
BOOL update_write_line_to_order(wStream* s, ORDER_INFO* orderInfo,
- const LINE_TO_ORDER* line_to)
+ const LINE_TO_ORDER* line_to)
{
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_line_to_order(orderInfo, line_to)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_line_to_order(orderInfo, line_to)))
return FALSE;
orderInfo->fieldFlags = 0;
-
orderInfo->fieldFlags |= ORDER_FIELD_01;
Stream_Write_UINT16(s, line_to->backMode);
-
orderInfo->fieldFlags |= ORDER_FIELD_02;
update_write_coord(s, line_to->nXStart);
-
orderInfo->fieldFlags |= ORDER_FIELD_03;
update_write_coord(s, line_to->nYStart);
-
orderInfo->fieldFlags |= ORDER_FIELD_04;
update_write_coord(s, line_to->nXEnd);
-
orderInfo->fieldFlags |= ORDER_FIELD_05;
update_write_coord(s, line_to->nYEnd);
-
orderInfo->fieldFlags |= ORDER_FIELD_06;
update_write_color(s, line_to->backColor);
-
orderInfo->fieldFlags |= ORDER_FIELD_07;
Stream_Write_UINT8(s, line_to->bRop2);
-
orderInfo->fieldFlags |= ORDER_FIELD_08;
Stream_Write_UINT8(s, line_to->penStyle);
-
orderInfo->fieldFlags |= ORDER_FIELD_09;
Stream_Write_UINT8(s, line_to->penWidth);
-
orderInfo->fieldFlags |= ORDER_FIELD_10;
update_write_color(s, line_to->penColor);
-
return TRUE;
}
static BOOL update_read_polyline_order(wStream* s, ORDER_INFO* orderInfo,
- POLYLINE_ORDER* polyline)
+ POLYLINE_ORDER* polyline)
{
UINT16 word;
UINT32 new_num = polyline->numDeltaEntries;
-
ORDER_FIELD_COORD(1, polyline->xStart);
ORDER_FIELD_COORD(2, polyline->yStart);
ORDER_FIELD_BYTE(3, polyline->bRop2);
if (orderInfo->fieldFlags & ORDER_FIELD_07)
{
- DELTA_POINT *new_points;
+ DELTA_POINT* new_points;
if (Stream_GetRemainingLength(s) < 1)
{
WLog_ERR(TAG, "Stream_GetRemainingLength(s) < 1");
return FALSE;
}
+
Stream_Read_UINT8(s, polyline->cbData);
+ new_points = (DELTA_POINT*) realloc(polyline->points,
+ sizeof(DELTA_POINT) * new_num);
- new_points = (DELTA_POINT*) realloc(polyline->points, sizeof(DELTA_POINT) * new_num);
if (!new_points)
{
WLog_ERR(TAG, "realloc(%i) failed", new_num);
return FALSE;
}
+
polyline->points = new_points;
polyline->numDeltaEntries = new_num;
-
- return update_read_delta_points(s, polyline->points, polyline->numDeltaEntries, polyline->xStart, polyline->yStart);
+ return update_read_delta_points(s, polyline->points, polyline->numDeltaEntries,
+ polyline->xStart, polyline->yStart);
}
return TRUE;
}
static BOOL update_read_memblt_order(wStream* s, ORDER_INFO* orderInfo,
- MEMBLT_ORDER* memblt)
+ MEMBLT_ORDER* memblt)
{
ORDER_FIELD_UINT16(1, memblt->cacheId);
ORDER_FIELD_COORD(2, memblt->nLeftRect);
ORDER_FIELD_COORD(7, memblt->nXSrc);
ORDER_FIELD_COORD(8, memblt->nYSrc);
ORDER_FIELD_UINT16(9, memblt->cacheIndex);
-
memblt->colorIndex = (memblt->cacheId >> 8);
memblt->cacheId = (memblt->cacheId & 0xFF);
memblt->bitmap = NULL;
-
return TRUE;
}
int update_approximate_memblt_order(ORDER_INFO* orderInfo,
- const MEMBLT_ORDER* memblt)
+ const MEMBLT_ORDER* memblt)
{
return 64;
}
BOOL update_write_memblt_order(wStream* s, ORDER_INFO* orderInfo,
- const MEMBLT_ORDER* memblt)
+ const MEMBLT_ORDER* memblt)
{
UINT16 cacheId;
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_memblt_order(orderInfo, memblt)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_memblt_order(orderInfo, memblt)))
return FALSE;
cacheId = (memblt->cacheId & 0xFF) | ((memblt->colorIndex & 0xFF) << 8);
-
orderInfo->fieldFlags |= ORDER_FIELD_01;
Stream_Write_UINT16(s, cacheId);
-
orderInfo->fieldFlags |= ORDER_FIELD_02;
update_write_coord(s, memblt->nLeftRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_03;
update_write_coord(s, memblt->nTopRect);
-
orderInfo->fieldFlags |= ORDER_FIELD_04;
update_write_coord(s, memblt->nWidth);
-
orderInfo->fieldFlags |= ORDER_FIELD_05;
update_write_coord(s, memblt->nHeight);
-
orderInfo->fieldFlags |= ORDER_FIELD_06;
Stream_Write_UINT8(s, memblt->bRop);
-
orderInfo->fieldFlags |= ORDER_FIELD_07;
update_write_coord(s, memblt->nXSrc);
-
orderInfo->fieldFlags |= ORDER_FIELD_08;
update_write_coord(s, memblt->nYSrc);
-
orderInfo->fieldFlags |= ORDER_FIELD_09;
Stream_Write_UINT16(s, memblt->cacheIndex);
-
return TRUE;
}
static BOOL update_read_mem3blt_order(wStream* s, ORDER_INFO* orderInfo,
- MEM3BLT_ORDER* mem3blt)
+ MEM3BLT_ORDER* mem3blt)
{
ORDER_FIELD_UINT16(1, mem3blt->cacheId);
ORDER_FIELD_COORD(2, mem3blt->nLeftRect);
mem3blt->colorIndex = (mem3blt->cacheId >> 8);
mem3blt->cacheId = (mem3blt->cacheId & 0xFF);
mem3blt->bitmap = NULL;
-
return TRUE;
}
static BOOL update_read_save_bitmap_order(wStream* s, ORDER_INFO* orderInfo,
- SAVE_BITMAP_ORDER* save_bitmap)
+ SAVE_BITMAP_ORDER* save_bitmap)
{
ORDER_FIELD_UINT32(1, save_bitmap->savedBitmapPosition);
ORDER_FIELD_COORD(2, save_bitmap->nLeftRect);
}
static BOOL update_read_glyph_index_order(wStream* s, ORDER_INFO* orderInfo,
- GLYPH_INDEX_ORDER* glyph_index)
+ GLYPH_INDEX_ORDER* glyph_index)
{
ORDER_FIELD_BYTE(1, glyph_index->cacheId);
ORDER_FIELD_BYTE(2, glyph_index->flAccel);
}
int update_approximate_glyph_index_order(ORDER_INFO* orderInfo,
- const GLYPH_INDEX_ORDER* glyph_index)
+ const GLYPH_INDEX_ORDER* glyph_index)
{
return 64;
}
BOOL update_write_glyph_index_order(wStream* s, ORDER_INFO* orderInfo,
- GLYPH_INDEX_ORDER* glyph_index)
+ GLYPH_INDEX_ORDER* glyph_index)
{
int inf = update_approximate_glyph_index_order(orderInfo, glyph_index);
return FALSE;
orderInfo->fieldFlags = 0;
-
orderInfo->fieldFlags |= ORDER_FIELD_01;
Stream_Write_UINT8(s, glyph_index->cacheId);
-
orderInfo->fieldFlags |= ORDER_FIELD_02;
Stream_Write_UINT8(s, glyph_index->flAccel);
-
orderInfo->fieldFlags |= ORDER_FIELD_03;
Stream_Write_UINT8(s, glyph_index->ulCharInc);
-
orderInfo->fieldFlags |= ORDER_FIELD_04;
Stream_Write_UINT8(s, glyph_index->fOpRedundant);
-
orderInfo->fieldFlags |= ORDER_FIELD_05;
update_write_color(s, glyph_index->backColor);
-
orderInfo->fieldFlags |= ORDER_FIELD_06;
update_write_color(s, glyph_index->foreColor);
-
orderInfo->fieldFlags |= ORDER_FIELD_07;
Stream_Write_UINT16(s, glyph_index->bkLeft);
-
orderInfo->fieldFlags |= ORDER_FIELD_08;
Stream_Write_UINT16(s, glyph_index->bkTop);
-
orderInfo->fieldFlags |= ORDER_FIELD_09;
Stream_Write_UINT16(s, glyph_index->bkRight);
-
orderInfo->fieldFlags |= ORDER_FIELD_10;
Stream_Write_UINT16(s, glyph_index->bkBottom);
-
orderInfo->fieldFlags |= ORDER_FIELD_11;
Stream_Write_UINT16(s, glyph_index->opLeft);
-
orderInfo->fieldFlags |= ORDER_FIELD_12;
Stream_Write_UINT16(s, glyph_index->opTop);
-
orderInfo->fieldFlags |= ORDER_FIELD_13;
Stream_Write_UINT16(s, glyph_index->opRight);
-
orderInfo->fieldFlags |= ORDER_FIELD_14;
Stream_Write_UINT16(s, glyph_index->opBottom);
-
orderInfo->fieldFlags |= ORDER_FIELD_15;
orderInfo->fieldFlags |= ORDER_FIELD_16;
orderInfo->fieldFlags |= ORDER_FIELD_17;
orderInfo->fieldFlags |= ORDER_FIELD_18;
orderInfo->fieldFlags |= ORDER_FIELD_19;
update_write_brush(s, &glyph_index->brush, orderInfo->fieldFlags >> 14);
-
orderInfo->fieldFlags |= ORDER_FIELD_20;
Stream_Write_UINT16(s, glyph_index->x);
-
orderInfo->fieldFlags |= ORDER_FIELD_21;
Stream_Write_UINT16(s, glyph_index->y);
-
orderInfo->fieldFlags |= ORDER_FIELD_22;
Stream_Write_UINT8(s, glyph_index->cbData);
Stream_Write(s, glyph_index->data, glyph_index->cbData);
-
return TRUE;
}
static BOOL update_read_fast_index_order(wStream* s, ORDER_INFO* orderInfo,
- FAST_INDEX_ORDER* fast_index)
+ FAST_INDEX_ORDER* fast_index)
{
ORDER_FIELD_BYTE(1, fast_index->cacheId);
ORDER_FIELD_2BYTE(2, fast_index->ulCharInc, fast_index->flAccel);
}
static BOOL update_read_fast_glyph_order(wStream* s, ORDER_INFO* orderInfo,
- FAST_GLYPH_ORDER* fastGlyph)
+ FAST_GLYPH_ORDER* fastGlyph)
{
BYTE* phold;
GLYPH_DATA_V2* glyph = &fastGlyph->glyphData;
-
ORDER_FIELD_BYTE(1, fastGlyph->cacheId);
ORDER_FIELD_2BYTE(2, fastGlyph->ulCharInc, fastGlyph->flAccel);
ORDER_FIELD_COLOR(3, fastGlyph->backColor);
glyph->cacheIndex = fastGlyph->data[0];
if (!update_read_2byte_signed(s, &glyph->x) ||
- !update_read_2byte_signed(s, &glyph->y) ||
- !update_read_2byte_unsigned(s, &glyph->cx) ||
- !update_read_2byte_unsigned(s, &glyph->cy))
+ !update_read_2byte_signed(s, &glyph->y) ||
+ !update_read_2byte_unsigned(s, &glyph->cx) ||
+ !update_read_2byte_unsigned(s, &glyph->cy))
return FALSE;
glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
-
new_cb = ((glyph->cx + 7) / 8) * glyph->cy;
new_cb += ((new_cb % 4) > 0) ? 4 - (new_cb % 4) : 0;
+
if (Stream_GetRemainingLength(s) < new_cb)
return FALSE;
if (new_cb)
{
- BYTE *new_aj;
+ BYTE* new_aj;
new_aj = (BYTE*) realloc(glyph->aj, new_cb);
+
if (!new_aj)
return FALSE;
}
static BOOL update_read_polygon_sc_order(wStream* s, ORDER_INFO* orderInfo,
- POLYGON_SC_ORDER* polygon_sc)
+ POLYGON_SC_ORDER* polygon_sc)
{
UINT32 num = polygon_sc->numPoints;
-
ORDER_FIELD_COORD(1, polygon_sc->xStart);
ORDER_FIELD_COORD(2, polygon_sc->yStart);
ORDER_FIELD_BYTE(3, polygon_sc->bRop2);
if (orderInfo->fieldFlags & ORDER_FIELD_07)
{
- DELTA_POINT *newpoints;
+ DELTA_POINT* newpoints;
if (Stream_GetRemainingLength(s) < 1)
return FALSE;
Stream_Read_UINT8(s, polygon_sc->cbData);
+ newpoints = (DELTA_POINT*) realloc(polygon_sc->points,
+ sizeof(DELTA_POINT) * num);
- newpoints = (DELTA_POINT*) realloc(polygon_sc->points, sizeof(DELTA_POINT) * num);
if (!newpoints)
return FALSE;
polygon_sc->points = newpoints;
polygon_sc->numPoints = num;
-
- return update_read_delta_points(s, polygon_sc->points, polygon_sc->numPoints, polygon_sc->xStart, polygon_sc->yStart);
+ return update_read_delta_points(s, polygon_sc->points, polygon_sc->numPoints,
+ polygon_sc->xStart, polygon_sc->yStart);
}
return TRUE;
}
static BOOL update_read_polygon_cb_order(wStream* s, ORDER_INFO* orderInfo,
- POLYGON_CB_ORDER* polygon_cb)
+ POLYGON_CB_ORDER* polygon_cb)
{
UINT32 num = polygon_cb->numPoints;
-
ORDER_FIELD_COORD(1, polygon_cb->xStart);
ORDER_FIELD_COORD(2, polygon_cb->yStart);
ORDER_FIELD_BYTE(3, polygon_cb->bRop2);
if (orderInfo->fieldFlags & ORDER_FIELD_13)
{
- DELTA_POINT *newpoints;
+ DELTA_POINT* newpoints;
if (Stream_GetRemainingLength(s) < 1)
return FALSE;
Stream_Read_UINT8(s, polygon_cb->cbData);
+ newpoints = (DELTA_POINT*) realloc(polygon_cb->points,
+ sizeof(DELTA_POINT) * num);
- newpoints = (DELTA_POINT*) realloc(polygon_cb->points, sizeof(DELTA_POINT) * num);
if (!newpoints)
return FALSE;
polygon_cb->points = newpoints;
polygon_cb->numPoints = num;
- if (!update_read_delta_points(s, polygon_cb->points, polygon_cb->numPoints, polygon_cb->xStart, polygon_cb->yStart))
+
+ if (!update_read_delta_points(s, polygon_cb->points, polygon_cb->numPoints,
+ polygon_cb->xStart, polygon_cb->yStart))
return FALSE;
}
- polygon_cb->backMode = (polygon_cb->bRop2 & 0x80) ? BACKMODE_TRANSPARENT : BACKMODE_OPAQUE;
+ polygon_cb->backMode = (polygon_cb->bRop2 & 0x80) ? BACKMODE_TRANSPARENT :
+ BACKMODE_OPAQUE;
polygon_cb->bRop2 = (polygon_cb->bRop2 & 0x1F);
-
return TRUE;
}
static BOOL update_read_ellipse_sc_order(wStream* s, ORDER_INFO* orderInfo,
- ELLIPSE_SC_ORDER* ellipse_sc)
+ ELLIPSE_SC_ORDER* ellipse_sc)
{
ORDER_FIELD_COORD(1, ellipse_sc->leftRect);
ORDER_FIELD_COORD(2, ellipse_sc->topRect);
}
static BOOL update_read_ellipse_cb_order(wStream* s, ORDER_INFO* orderInfo,
- ELLIPSE_CB_ORDER* ellipse_cb)
+ ELLIPSE_CB_ORDER* ellipse_cb)
{
ORDER_FIELD_COORD(1, ellipse_cb->leftRect);
ORDER_FIELD_COORD(2, ellipse_cb->topRect);
}
/* Secondary Drawing Orders */
-static BOOL update_read_cache_bitmap_order(wStream* s, CACHE_BITMAP_ORDER* cache_bitmap,
- BOOL compressed, UINT16 flags)
+static BOOL update_read_cache_bitmap_order(wStream* s,
+ CACHE_BITMAP_ORDER* cache_bitmap,
+ BOOL compressed, UINT16 flags)
{
if (Stream_GetRemainingLength(s) < 9)
return FALSE;
Stream_Read_UINT8(s, cache_bitmap->bitmapWidth); /* bitmapWidth (1 byte) */
Stream_Read_UINT8(s, cache_bitmap->bitmapHeight); /* bitmapHeight (1 byte) */
Stream_Read_UINT8(s, cache_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
+
if ((cache_bitmap->bitmapBpp < 1) || (cache_bitmap->bitmapBpp > 32))
{
WLog_ERR(TAG, "invalid bitmap bpp %d", cache_bitmap->bitmapBpp);
return FALSE;
}
+
Stream_Read_UINT16(s, cache_bitmap->bitmapLength); /* bitmapLength (2 bytes) */
Stream_Read_UINT16(s, cache_bitmap->cacheIndex); /* cacheIndex (2 bytes) */
{
if ((flags & NO_BITMAP_COMPRESSION_HDR) == 0)
{
- BYTE* bitmapComprHdr = (BYTE*) &(cache_bitmap->bitmapComprHdr);
+ BYTE* bitmapComprHdr = (BYTE*) & (cache_bitmap->bitmapComprHdr);
if (Stream_GetRemainingLength(s) < 8)
return FALSE;
}
cache_bitmap->compressed = compressed;
-
return TRUE;
}
-int update_approximate_cache_bitmap_order(const CACHE_BITMAP_ORDER* cache_bitmap,
- BOOL compressed, UINT16* flags)
+int update_approximate_cache_bitmap_order(const CACHE_BITMAP_ORDER*
+ cache_bitmap,
+ BOOL compressed, UINT16* flags)
{
return 64 + cache_bitmap->bitmapLength;
}
BOOL update_write_cache_bitmap_order(wStream* s,
- const CACHE_BITMAP_ORDER* cache_bitmap,
- BOOL compressed, UINT16* flags)
+ const CACHE_BITMAP_ORDER* cache_bitmap,
+ BOOL compressed, UINT16* flags)
{
UINT32 bitmapLength = cache_bitmap->bitmapLength;
- int inf = update_approximate_cache_bitmap_order(cache_bitmap, compressed, flags);
+ int inf = update_approximate_cache_bitmap_order(cache_bitmap, compressed,
+ flags);
+
if (!Stream_EnsureRemainingCapacity(s, inf))
return FALSE;
{
if ((*flags & NO_BITMAP_COMPRESSION_HDR) == 0)
{
- BYTE* bitmapComprHdr = (BYTE*) &(cache_bitmap->bitmapComprHdr);
+ BYTE* bitmapComprHdr = (BYTE*) & (cache_bitmap->bitmapComprHdr);
Stream_Write(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
bitmapLength -= 8;
}
}
static BOOL update_read_cache_bitmap_v2_order(wStream* s,
- CACHE_BITMAP_V2_ORDER* cache_bitmap_v2,
- BOOL compressed, UINT16 flags)
+ CACHE_BITMAP_V2_ORDER* cache_bitmap_v2,
+ BOOL compressed, UINT16 flags)
{
BYTE bitsPerPixelId;
-
cache_bitmap_v2->cacheId = flags & 0x0003;
cache_bitmap_v2->flags = (flags & 0xFF80) >> 7;
-
bitsPerPixelId = (flags & 0x0078) >> 3;
cache_bitmap_v2->bitmapBpp = CBR2_BPP[bitsPerPixelId];
if (cache_bitmap_v2->flags & CBR2_HEIGHT_SAME_AS_WIDTH)
{
- if (!update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
+ if (!update_read_2byte_unsigned(s,
+ &cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
return FALSE;
cache_bitmap_v2->bitmapHeight = cache_bitmap_v2->bitmapWidth;
}
else
{
- if (!update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapWidth) || /* bitmapWidth */
- !update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
+ if (!update_read_2byte_unsigned(s, &cache_bitmap_v2->bitmapWidth)
+ || /* bitmapWidth */
+ !update_read_2byte_unsigned(s,
+ &cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
return FALSE;
}
- if (!update_read_4byte_unsigned(s, &cache_bitmap_v2->bitmapLength) || /* bitmapLength */
- !update_read_2byte_unsigned(s, &cache_bitmap_v2->cacheIndex)) /* cacheIndex */
+ if (!update_read_4byte_unsigned(s, &cache_bitmap_v2->bitmapLength)
+ || /* bitmapLength */
+ !update_read_2byte_unsigned(s, &cache_bitmap_v2->cacheIndex)) /* cacheIndex */
return FALSE;
if (cache_bitmap_v2->flags & CBR2_DO_NOT_CACHE)
if (Stream_GetRemainingLength(s) < 8)
return FALSE;
- Stream_Read_UINT16(s, cache_bitmap_v2->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
- Stream_Read_UINT16(s, cache_bitmap_v2->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
+ Stream_Read_UINT16(s,
+ cache_bitmap_v2->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
+ Stream_Read_UINT16(s,
+ cache_bitmap_v2->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
Stream_Read_UINT16(s, cache_bitmap_v2->cbScanWidth); /* cbScanWidth (2 bytes) */
- Stream_Read_UINT16(s, cache_bitmap_v2->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
+ Stream_Read_UINT16(s,
+ cache_bitmap_v2->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
cache_bitmap_v2->bitmapLength = cache_bitmap_v2->cbCompMainBodySize;
}
}
cache_bitmap_v2->compressed = compressed;
-
return TRUE;
}
-int update_approximate_cache_bitmap_v2_order(CACHE_BITMAP_V2_ORDER* cache_bitmap_v2, BOOL compressed, UINT16* flags)
+int update_approximate_cache_bitmap_v2_order(CACHE_BITMAP_V2_ORDER*
+ cache_bitmap_v2, BOOL compressed, UINT16* flags)
{
return 64 + cache_bitmap_v2->bitmapLength;
}
-BOOL update_write_cache_bitmap_v2_order(wStream* s, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2, BOOL compressed, UINT16* flags)
+BOOL update_write_cache_bitmap_v2_order(wStream* s,
+ CACHE_BITMAP_V2_ORDER* cache_bitmap_v2, BOOL compressed, UINT16* flags)
{
BYTE bitsPerPixelId;
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_cache_bitmap_v2_order(cache_bitmap_v2, compressed, flags)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_cache_bitmap_v2_order(cache_bitmap_v2, compressed, flags)))
return FALSE;
bitsPerPixelId = BPP_CBR2[cache_bitmap_v2->bitmapBpp];
-
*flags = (cache_bitmap_v2->cacheId & 0x0003) |
- (bitsPerPixelId << 3) | ((cache_bitmap_v2->flags << 7) & 0xFF80);
+ (bitsPerPixelId << 3) | ((cache_bitmap_v2->flags << 7) & 0xFF80);
if (cache_bitmap_v2->flags & CBR2_PERSISTENT_KEY_PRESENT)
{
if (cache_bitmap_v2->flags & CBR2_HEIGHT_SAME_AS_WIDTH)
{
- if (!update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
+ if (!update_write_2byte_unsigned(s,
+ cache_bitmap_v2->bitmapWidth)) /* bitmapWidth */
return FALSE;
}
else
{
- if (!update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapWidth) || /* bitmapWidth */
- !update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
+ if (!update_write_2byte_unsigned(s, cache_bitmap_v2->bitmapWidth)
+ || /* bitmapWidth */
+ !update_write_2byte_unsigned(s,
+ cache_bitmap_v2->bitmapHeight)) /* bitmapHeight */
return FALSE;
}
if (cache_bitmap_v2->flags & CBR2_DO_NOT_CACHE)
cache_bitmap_v2->cacheIndex = BITMAP_CACHE_WAITING_LIST_INDEX;
- if (!update_write_4byte_unsigned(s, cache_bitmap_v2->bitmapLength) || /* bitmapLength */
- !update_write_2byte_unsigned(s, cache_bitmap_v2->cacheIndex)) /* cacheIndex */
+ if (!update_write_4byte_unsigned(s, cache_bitmap_v2->bitmapLength)
+ || /* bitmapLength */
+ !update_write_2byte_unsigned(s, cache_bitmap_v2->cacheIndex)) /* cacheIndex */
return FALSE;
if (compressed)
{
if (!(cache_bitmap_v2->flags & CBR2_NO_BITMAP_COMPRESSION_HDR))
{
- Stream_Write_UINT16(s, cache_bitmap_v2->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
- Stream_Write_UINT16(s, cache_bitmap_v2->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
- Stream_Write_UINT16(s, cache_bitmap_v2->cbScanWidth); /* cbScanWidth (2 bytes) */
- Stream_Write_UINT16(s, cache_bitmap_v2->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
+ Stream_Write_UINT16(s,
+ cache_bitmap_v2->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
+ Stream_Write_UINT16(s,
+ cache_bitmap_v2->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
+ Stream_Write_UINT16(s,
+ cache_bitmap_v2->cbScanWidth); /* cbScanWidth (2 bytes) */
+ Stream_Write_UINT16(s,
+ cache_bitmap_v2->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
cache_bitmap_v2->bitmapLength = cache_bitmap_v2->cbCompMainBodySize;
}
if (!Stream_EnsureRemainingCapacity(s, cache_bitmap_v2->bitmapLength))
return FALSE;
- Stream_Write(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
+
+ Stream_Write(s, cache_bitmap_v2->bitmapDataStream,
+ cache_bitmap_v2->bitmapLength);
}
else
{
if (!Stream_EnsureRemainingCapacity(s, cache_bitmap_v2->bitmapLength))
return FALSE;
- Stream_Write(s, cache_bitmap_v2->bitmapDataStream, cache_bitmap_v2->bitmapLength);
+
+ Stream_Write(s, cache_bitmap_v2->bitmapDataStream,
+ cache_bitmap_v2->bitmapLength);
}
cache_bitmap_v2->compressed = compressed;
-
return TRUE;
}
static BOOL update_read_cache_bitmap_v3_order(wStream* s,
- CACHE_BITMAP_V3_ORDER* cache_bitmap_v3,
- UINT16 flags)
+ CACHE_BITMAP_V3_ORDER* cache_bitmap_v3,
+ UINT16 flags)
{
BYTE bitsPerPixelId;
BITMAP_DATA_EX* bitmapData;
UINT32 new_len;
- BYTE *new_data;
-
+ BYTE* new_data;
cache_bitmap_v3->cacheId = flags & 0x00000003;
cache_bitmap_v3->flags = (flags & 0x0000FF80) >> 7;
-
bitsPerPixelId = (flags & 0x00000078) >> 3;
cache_bitmap_v3->bpp = CBR23_BPP[bitsPerPixelId];
Stream_Read_UINT16(s, cache_bitmap_v3->cacheIndex); /* cacheIndex (2 bytes) */
Stream_Read_UINT32(s, cache_bitmap_v3->key1); /* key1 (4 bytes) */
Stream_Read_UINT32(s, cache_bitmap_v3->key2); /* key2 (4 bytes) */
-
bitmapData = &cache_bitmap_v3->bitmapData;
-
Stream_Read_UINT8(s, bitmapData->bpp);
+
if ((bitmapData->bpp < 1) || (bitmapData->bpp > 32))
{
WLog_ERR(TAG, "invalid bpp value %d", bitmapData->bpp);
return FALSE;
}
+
Stream_Seek_UINT8(s); /* reserved1 (1 byte) */
Stream_Seek_UINT8(s); /* reserved2 (1 byte) */
Stream_Read_UINT8(s, bitmapData->codecID); /* codecID (1 byte) */
return FALSE;
new_data = (BYTE*) realloc(bitmapData->data, new_len);
+
if (!new_data)
return FALSE;
+
bitmapData->data = new_data;
bitmapData->length = new_len;
Stream_Read(s, bitmapData->data, bitmapData->length);
-
return TRUE;
}
-int update_approximate_cache_bitmap_v3_order(CACHE_BITMAP_V3_ORDER* cache_bitmap_v3, UINT16* flags)
+int update_approximate_cache_bitmap_v3_order(CACHE_BITMAP_V3_ORDER*
+ cache_bitmap_v3, UINT16* flags)
{
BITMAP_DATA_EX* bitmapData = &cache_bitmap_v3->bitmapData;
return 64 + bitmapData->length;
}
-BOOL update_write_cache_bitmap_v3_order(wStream* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3, UINT16* flags)
+BOOL update_write_cache_bitmap_v3_order(wStream* s,
+ CACHE_BITMAP_V3_ORDER* cache_bitmap_v3, UINT16* flags)
{
BYTE bitsPerPixelId;
BITMAP_DATA_EX* bitmapData;
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_cache_bitmap_v3_order(cache_bitmap_v3, flags)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_cache_bitmap_v3_order(cache_bitmap_v3, flags)))
return FALSE;
bitmapData = &cache_bitmap_v3->bitmapData;
bitsPerPixelId = BPP_CBR23[cache_bitmap_v3->bpp];
-
*flags = (cache_bitmap_v3->cacheId & 0x00000003) |
- ((cache_bitmap_v3->flags << 7) & 0x0000FF80) |
- ((bitsPerPixelId << 3) & 0x00000078);
-
+ ((cache_bitmap_v3->flags << 7) & 0x0000FF80) |
+ ((bitsPerPixelId << 3) & 0x00000078);
Stream_Write_UINT16(s, cache_bitmap_v3->cacheIndex); /* cacheIndex (2 bytes) */
Stream_Write_UINT32(s, cache_bitmap_v3->key1); /* key1 (4 bytes) */
Stream_Write_UINT32(s, cache_bitmap_v3->key2); /* key2 (4 bytes) */
-
Stream_Write_UINT8(s, bitmapData->bpp);
Stream_Write_UINT8(s, 0); /* reserved1 (1 byte) */
Stream_Write_UINT8(s, 0); /* reserved2 (1 byte) */
Stream_Write_UINT16(s, bitmapData->width); /* width (2 bytes) */
Stream_Write_UINT16(s, bitmapData->height); /* height (2 bytes) */
Stream_Write_UINT32(s, bitmapData->length); /* length (4 bytes) */
-
Stream_Write(s, bitmapData->data, bitmapData->length);
-
return TRUE;
}
static BOOL update_read_cache_color_table_order(wStream* s,
- CACHE_COLOR_TABLE_ORDER* cache_color_table,
- UINT16 flags)
+ CACHE_COLOR_TABLE_ORDER* cache_color_table,
+ UINT16 flags)
{
int i;
UINT32* colorTable;
return FALSE;
Stream_Read_UINT8(s, cache_color_table->cacheIndex); /* cacheIndex (1 byte) */
- Stream_Read_UINT16(s, cache_color_table->numberColors); /* numberColors (2 bytes) */
+ Stream_Read_UINT16(s,
+ cache_color_table->numberColors); /* numberColors (2 bytes) */
if (cache_color_table->numberColors != 256)
{
}
int update_approximate_cache_color_table_order(
- const CACHE_COLOR_TABLE_ORDER* cache_color_table, UINT16* flags)
+ const CACHE_COLOR_TABLE_ORDER* cache_color_table, UINT16* flags)
{
return 16 + (256 * 4);
}
BOOL update_write_cache_color_table_order(wStream* s,
- const CACHE_COLOR_TABLE_ORDER* cache_color_table,
- UINT16* flags)
+ const CACHE_COLOR_TABLE_ORDER* cache_color_table,
+ UINT16* flags)
{
int i, inf;
UINT32* colorTable;
return FALSE;
inf = update_approximate_cache_color_table_order(cache_color_table, flags);
+
if (!Stream_EnsureRemainingCapacity(s, inf))
return FALSE;
Stream_Write_UINT8(s, cache_color_table->cacheIndex); /* cacheIndex (1 byte) */
- Stream_Write_UINT16(s, cache_color_table->numberColors); /* numberColors (2 bytes) */
-
+ Stream_Write_UINT16(s,
+ cache_color_table->numberColors); /* numberColors (2 bytes) */
colorTable = (UINT32*) &cache_color_table->colorTable;
for (i = 0; i < (int) cache_color_table->numberColors; i++)
}
static BOOL update_read_cache_glyph_order(wStream* s,
- CACHE_GLYPH_ORDER* cache_glyph_order,
- UINT16 flags)
+ CACHE_GLYPH_ORDER* cache_glyph_order,
+ UINT16 flags)
{
int i;
INT16 lsi16;
glyph->y = lsi16;
Stream_Read_UINT16(s, glyph->cx);
Stream_Read_UINT16(s, glyph->cy);
-
glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
return FALSE;
glyph->aj = (BYTE*) malloc(glyph->cb);
+
if (!glyph->aj)
return FALSE;
+
Stream_Read(s, glyph->aj, glyph->cb);
}
}
int update_approximate_cache_glyph_order(
- const CACHE_GLYPH_ORDER* cache_glyph, UINT16* flags)
+ const CACHE_GLYPH_ORDER* cache_glyph, UINT16* flags)
{
return 2 + cache_glyph->cGlyphs * 32;
}
BOOL update_write_cache_glyph_order(wStream* s,
- const CACHE_GLYPH_ORDER* cache_glyph,
- UINT16* flags)
+ const CACHE_GLYPH_ORDER* cache_glyph,
+ UINT16* flags)
{
int i, inf;
INT16 lsi16;
const GLYPH_DATA* glyph;
-
inf = update_approximate_cache_glyph_order(cache_glyph, flags);
+
if (!Stream_EnsureRemainingCapacity(s, inf))
return FALSE;
for (i = 0; i < (int) cache_glyph->cGlyphs; i++)
{
UINT32 cb;
-
glyph = &cache_glyph->glyphData[i];
-
Stream_Write_UINT16(s, glyph->cacheIndex); /* cacheIndex (2 bytes) */
-
lsi16 = glyph->x;
Stream_Write_UINT16(s, lsi16); /* x (2 bytes) */
-
lsi16 = glyph->y;
Stream_Write_UINT16(s, lsi16); /* y (2 bytes) */
-
Stream_Write_UINT16(s, glyph->cx); /* cx (2 bytes) */
Stream_Write_UINT16(s, glyph->cy); /* cy (2 bytes) */
-
cb = ((glyph->cx + 7) / 8) * glyph->cy;
cb += ((cb % 4) > 0) ? 4 - (cb % 4) : 0;
-
Stream_Write(s, glyph->aj, cb);
}
}
static BOOL update_read_cache_glyph_v2_order(wStream* s,
- CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
- UINT16 flags)
+ CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
+ UINT16 flags)
{
int i;
GLYPH_DATA_V2* glyph;
-
cache_glyph_v2->cacheId = (flags & 0x000F);
cache_glyph_v2->flags = (flags & 0x00F0) >> 4;
cache_glyph_v2->cGlyphs = (flags & 0xFF00) >> 8;
Stream_Read_UINT8(s, glyph->cacheIndex);
if (!update_read_2byte_signed(s, &glyph->x) ||
- !update_read_2byte_signed(s, &glyph->y) ||
- !update_read_2byte_unsigned(s, &glyph->cx) ||
- !update_read_2byte_unsigned(s, &glyph->cy))
+ !update_read_2byte_signed(s, &glyph->y) ||
+ !update_read_2byte_unsigned(s, &glyph->cx) ||
+ !update_read_2byte_unsigned(s, &glyph->cy))
{
return FALSE;
}
return FALSE;
glyph->aj = (BYTE*) malloc(glyph->cb);
+
if (!glyph->aj)
return FALSE;
+
Stream_Read(s, glyph->aj, glyph->cb);
}
}
int update_approximate_cache_glyph_v2_order(
- const CACHE_GLYPH_V2_ORDER* cache_glyph_v2, UINT16* flags)
+ const CACHE_GLYPH_V2_ORDER* cache_glyph_v2, UINT16* flags)
{
return 8 + cache_glyph_v2->cGlyphs * 32;
}
BOOL update_write_cache_glyph_v2_order(wStream* s,
- const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
- UINT16* flags)
+ const CACHE_GLYPH_V2_ORDER* cache_glyph_v2,
+ UINT16* flags)
{
int i, inf;
-
inf = update_approximate_cache_glyph_v2_order(cache_glyph_v2, flags);
+
if (!Stream_EnsureRemainingCapacity(s, inf))
return FALSE;
*flags = (cache_glyph_v2->cacheId & 0x000F) |
- ((cache_glyph_v2->flags & 0x000F) << 4) |
- ((cache_glyph_v2->cGlyphs & 0x00FF) << 8);
+ ((cache_glyph_v2->flags & 0x000F) << 4) |
+ ((cache_glyph_v2->cGlyphs & 0x00FF) << 8);
for (i = 0; i < (int) cache_glyph_v2->cGlyphs; i++)
{
UINT32 cb;
const GLYPH_DATA_V2* glyph = &cache_glyph_v2->glyphData[i];
-
Stream_Write_UINT8(s, glyph->cacheIndex);
if (!update_write_2byte_signed(s, glyph->x) ||
- !update_write_2byte_signed(s, glyph->y) ||
- !update_write_2byte_unsigned(s, glyph->cx) ||
- !update_write_2byte_unsigned(s, glyph->cy))
+ !update_write_2byte_signed(s, glyph->y) ||
+ !update_write_2byte_unsigned(s, glyph->cx) ||
+ !update_write_2byte_unsigned(s, glyph->cy))
{
return FALSE;
}
BYTE byte = 0;
BYTE* palette;
int bytesPerPixel;
-
palette = Stream_Pointer(s) + 16;
bytesPerPixel = ((bpp + 1) / 8);
for (k = 0; k < bytesPerPixel; k++)
{
- output[((y * 8 + x) * bytesPerPixel) + k] = palette[(index * bytesPerPixel) + k];
+ output[((y * 8 + x) * bytesPerPixel) + k] = palette[(index * bytesPerPixel) +
+ k];
}
}
}
}
static BOOL update_read_cache_brush_order(wStream* s,
- CACHE_BRUSH_ORDER* cache_brush,
- UINT16 flags)
+ CACHE_BRUSH_ORDER* cache_brush,
+ UINT16 flags)
{
int i;
int size;
return FALSE;
Stream_Read_UINT8(s, cache_brush->index); /* cacheEntry (1 byte) */
-
Stream_Read_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
cache_brush->bpp = BMF_BPP[iBitmapFormat];
-
Stream_Read_UINT8(s, cache_brush->cx); /* cx (1 byte) */
Stream_Read_UINT8(s, cache_brush->cy); /* cy (1 byte) */
Stream_Read_UINT8(s, cache_brush->style); /* style (1 byte) */
}
int update_approximate_cache_brush_order(
- const CACHE_BRUSH_ORDER* cache_brush, UINT16* flags)
+ const CACHE_BRUSH_ORDER* cache_brush, UINT16* flags)
{
return 64;
}
BOOL update_write_cache_brush_order(wStream* s,
- const CACHE_BRUSH_ORDER* cache_brush,
- UINT16* flags)
+ const CACHE_BRUSH_ORDER* cache_brush,
+ UINT16* flags)
{
int i;
int size;
BYTE iBitmapFormat;
BOOL compressed = FALSE;
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_cache_brush_order(cache_brush, flags)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_cache_brush_order(cache_brush, flags)))
return FALSE;
iBitmapFormat = BPP_BMF[cache_brush->bpp];
-
Stream_Write_UINT8(s, cache_brush->index); /* cacheEntry (1 byte) */
Stream_Write_UINT8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
-
Stream_Write_UINT8(s, cache_brush->cx); /* cx (1 byte) */
Stream_Write_UINT8(s, cache_brush->cy); /* cy (1 byte) */
Stream_Write_UINT8(s, cache_brush->style); /* style (1 byte) */
/* Alternate Secondary Drawing Orders */
static BOOL update_read_create_offscreen_bitmap_order(wStream* s,
- CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
+ CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
{
UINT16 flags;
BOOL deleteListPresent;
Stream_Read_UINT16(s, flags); /* flags (2 bytes) */
create_offscreen_bitmap->id = 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) */
-
deleteList = &(create_offscreen_bitmap->deleteList);
if (deleteListPresent)
if (deleteList->cIndices > deleteList->sIndices)
{
- UINT16 *new_indices;
+ UINT16* new_indices;
+ new_indices = (UINT16*)realloc(deleteList->indices, deleteList->sIndices * 2);
- new_indices = (UINT16 *)realloc(deleteList->indices, deleteList->sIndices * 2);
if (!new_indices)
return FALSE;
}
int update_approximate_create_offscreen_bitmap_order(
- const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
+ const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
{
- const OFFSCREEN_DELETE_LIST* deleteList = &(create_offscreen_bitmap->deleteList);
+ const OFFSCREEN_DELETE_LIST* deleteList = &
+ (create_offscreen_bitmap->deleteList);
return 32 + deleteList->cIndices * 2;
}
BOOL update_write_create_offscreen_bitmap_order(
- wStream* s,
- const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
+ wStream* s,
+ const CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
{
UINT16 flags;
BOOL deleteListPresent;
const OFFSCREEN_DELETE_LIST* deleteList;
- if (!Stream_EnsureRemainingCapacity(s, update_approximate_create_offscreen_bitmap_order(create_offscreen_bitmap)))
+ if (!Stream_EnsureRemainingCapacity(s,
+ update_approximate_create_offscreen_bitmap_order(create_offscreen_bitmap)))
return FALSE;
deleteList = &(create_offscreen_bitmap->deleteList);
-
flags = create_offscreen_bitmap->id & 0x7FFF;
-
deleteListPresent = (deleteList->cIndices > 0) ? TRUE : FALSE;
if (deleteListPresent)
flags |= 0x8000;
Stream_Write_UINT16(s, flags); /* flags (2 bytes) */
-
Stream_Write_UINT16(s, create_offscreen_bitmap->cx); /* cx (2 bytes) */
Stream_Write_UINT16(s, create_offscreen_bitmap->cy); /* cy (2 bytes) */
if (deleteListPresent)
{
int i;
-
Stream_Write_UINT16(s, deleteList->cIndices);
for (i = 0; i < (int) deleteList->cIndices; i++)
}
static BOOL update_read_switch_surface_order(wStream* s,
- SWITCH_SURFACE_ORDER* switch_surface)
+ SWITCH_SURFACE_ORDER* switch_surface)
{
if (Stream_GetRemainingLength(s) < 2)
return FALSE;
Stream_Read_UINT16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
-
return TRUE;
}
int update_approximate_switch_surface_order(
- const SWITCH_SURFACE_ORDER* switch_surface)
+ const SWITCH_SURFACE_ORDER* switch_surface)
{
return 2;
}
BOOL update_write_switch_surface_order(
- wStream* s, const SWITCH_SURFACE_ORDER* switch_surface)
+ wStream* s, const SWITCH_SURFACE_ORDER* switch_surface)
{
int inf = update_approximate_switch_surface_order(switch_surface);
+
if (!Stream_EnsureRemainingCapacity(s, inf))
return FALSE;
Stream_Write_UINT16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
-
return TRUE;
}
static BOOL update_read_create_nine_grid_bitmap_order(
- wStream* s,
- CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
+ wStream* s,
+ CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
{
NINE_GRID_BITMAP_INFO* nineGridInfo;
if (Stream_GetRemainingLength(s) < 19)
return FALSE;
- Stream_Read_UINT8(s, create_nine_grid_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
- if ((create_nine_grid_bitmap->bitmapBpp < 1) || (create_nine_grid_bitmap->bitmapBpp > 32))
+ Stream_Read_UINT8(s,
+ create_nine_grid_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
+
+ if ((create_nine_grid_bitmap->bitmapBpp < 1)
+ || (create_nine_grid_bitmap->bitmapBpp > 32))
{
WLog_ERR(TAG, "invalid bpp value %d", create_nine_grid_bitmap->bitmapBpp);
return FALSE;
}
- Stream_Read_UINT16(s, create_nine_grid_bitmap->bitmapId); /* bitmapId (2 bytes) */
+ 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) */
-
+ Stream_Read_UINT16(s,
+ nineGridInfo->ulBottomHeight); /* ulBottomHeight (2 bytes) */
+ update_read_colorref(s,
+ &nineGridInfo->crTransparent); /* crTransparent (4 bytes) */
return TRUE;
}
static BOOL update_read_frame_marker_order(wStream* s,
- FRAME_MARKER_ORDER* frame_marker)
+ FRAME_MARKER_ORDER* frame_marker)
{
if (Stream_GetRemainingLength(s) < 4)
return FALSE;
Stream_Read_UINT32(s, frame_marker->action); /* action (4 bytes) */
-
return TRUE;
}
static BOOL update_read_stream_bitmap_first_order(
- wStream* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
+ wStream* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
{
if (Stream_GetRemainingLength(s) < 10) // 8 + 2 at least
return FALSE;
- Stream_Read_UINT8(s, stream_bitmap_first->bitmapFlags); /* bitmapFlags (1 byte) */
+ Stream_Read_UINT8(s,
+ stream_bitmap_first->bitmapFlags); /* bitmapFlags (1 byte) */
Stream_Read_UINT8(s, stream_bitmap_first->bitmapBpp); /* bitmapBpp (1 byte) */
- if ((stream_bitmap_first->bitmapBpp < 1) || (stream_bitmap_first->bitmapBpp > 32))
+
+ if ((stream_bitmap_first->bitmapBpp < 1)
+ || (stream_bitmap_first->bitmapBpp > 32))
{
WLog_ERR(TAG, "invalid bpp value %d", stream_bitmap_first->bitmapBpp);
return FALSE;
}
- 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) */
+ 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)
{
if (Stream_GetRemainingLength(s) < 4)
return FALSE;
- Stream_Read_UINT32(s, stream_bitmap_first->bitmapSize); /* bitmapSize (4 bytes) */
+ Stream_Read_UINT32(s,
+ stream_bitmap_first->bitmapSize); /* bitmapSize (4 bytes) */
}
else
{
if (Stream_GetRemainingLength(s) < 2)
return FALSE;
- Stream_Read_UINT16(s, stream_bitmap_first->bitmapSize); /* bitmapSize (2 bytes) */
+ Stream_Read_UINT16(s,
+ stream_bitmap_first->bitmapSize); /* bitmapSize (2 bytes) */
}
- FIELD_SKIP_BUFFER16(s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
-
+ FIELD_SKIP_BUFFER16(s,
+ stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
return TRUE;
}
static BOOL update_read_stream_bitmap_next_order(
- wStream* s, STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next)
+ wStream* s, STREAM_BITMAP_NEXT_ORDER* stream_bitmap_next)
{
if (Stream_GetRemainingLength(s) < 5)
return FALSE;
- Stream_Read_UINT8(s, stream_bitmap_next->bitmapFlags); /* bitmapFlags (1 byte) */
- Stream_Read_UINT16(s, stream_bitmap_next->bitmapType); /* bitmapType (2 bytes) */
- FIELD_SKIP_BUFFER16(s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
-
+ Stream_Read_UINT8(s,
+ stream_bitmap_next->bitmapFlags); /* bitmapFlags (1 byte) */
+ Stream_Read_UINT16(s,
+ stream_bitmap_next->bitmapType); /* bitmapType (2 bytes) */
+ FIELD_SKIP_BUFFER16(s,
+ stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize(2 bytes) + bitmapBlock */
return TRUE;
}
static BOOL update_read_draw_gdiplus_first_order(
- wStream* s, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
+ wStream* s, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
{
if (Stream_GetRemainingLength(s) < 11)
return FALSE;
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_Read_UINT32(s,
+ draw_gdiplus_first->cbTotalSize); /* cbTotalSize (4 bytes) */
+ Stream_Read_UINT32(s,
+ draw_gdiplus_first->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_first->cbSize); /* emfRecords */
}
static BOOL update_read_draw_gdiplus_next_order(
- wStream* s, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
+ wStream* s, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
{
if (Stream_GetRemainingLength(s) < 3)
return FALSE;
Stream_Seek_UINT8(s); /* pad1Octet (1 byte) */
- FIELD_SKIP_BUFFER16(s, draw_gdiplus_next->cbSize); /* cbSize(2 bytes) + emfRecords */
-
+ FIELD_SKIP_BUFFER16(s,
+ draw_gdiplus_next->cbSize); /* cbSize(2 bytes) + emfRecords */
return TRUE;
}
static BOOL update_read_draw_gdiplus_end_order(
- wStream* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
+ wStream* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
{
if (Stream_GetRemainingLength(s) < 11)
return FALSE;
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_Read_UINT32(s,
+ draw_gdiplus_end->cbTotalSize); /* cbTotalSize (4 bytes) */
+ Stream_Read_UINT32(s,
+ draw_gdiplus_end->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_end->cbSize); /* emfRecords */
}
static BOOL update_read_draw_gdiplus_cache_first_order(
- wStream* s, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
+ wStream* s, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
{
if (Stream_GetRemainingLength(s) < 11)
return FALSE;
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->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_Read_UINT32(s,
+ draw_gdiplus_cache_first->cbTotalSize); /* cbTotalSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_cache_first->cbSize); /* emfRecords */
}
static BOOL update_read_draw_gdiplus_cache_next_order(
- wStream* s, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
+ wStream* s, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
{
if (Stream_GetRemainingLength(s) < 7)
return FALSE;
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) */
- FIELD_SKIP_BUFFER16(s, draw_gdiplus_cache_next->cbSize); /* cbSize(2 bytes) + emfRecords */
-
+ Stream_Read_UINT16(s,
+ draw_gdiplus_cache_next->cacheType); /* cacheType (2 bytes) */
+ Stream_Read_UINT16(s,
+ draw_gdiplus_cache_next->cacheIndex); /* cacheIndex (2 bytes) */
+ FIELD_SKIP_BUFFER16(s,
+ draw_gdiplus_cache_next->cbSize); /* cbSize(2 bytes) + emfRecords */
return TRUE;
}
static BOOL update_read_draw_gdiplus_cache_end_order(
- wStream* s, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
+ wStream* s, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
{
if (Stream_GetRemainingLength(s) < 11)
return FALSE;
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->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_Read_UINT32(s,
+ draw_gdiplus_cache_end->cbTotalSize); /* cbTotalSize (4 bytes) */
return Stream_SafeSeek(s, draw_gdiplus_cache_end->cbSize); /* emfRecords */
}
-static BOOL update_read_field_flags(wStream* s, UINT32* fieldFlags, BYTE flags, BYTE fieldBytes)
+static BOOL update_read_field_flags(wStream* s, UINT32* fieldFlags, BYTE flags,
+ BYTE fieldBytes)
{
int i;
BYTE byte;
return FALSE;
*fieldFlags = 0;
+
for (i = 0; i < fieldBytes; i++)
{
Stream_Read_UINT8(s, byte);
return TRUE;
}
-BOOL update_write_field_flags(wStream* s, UINT32 fieldFlags, BYTE flags, BYTE fieldBytes)
+BOOL update_write_field_flags(wStream* s, UINT32 fieldFlags, BYTE flags,
+ BYTE fieldBytes)
{
BYTE byte;
}
else if (orderInfo->boundsFlags & BOUND_DELTA_LEFT)
{
-
}
if (orderInfo->boundsFlags & BOUND_TOP)
}
else if (orderInfo->boundsFlags & BOUND_DELTA_TOP)
{
-
}
if (orderInfo->boundsFlags & BOUND_RIGHT)
}
else if (orderInfo->boundsFlags & BOUND_DELTA_RIGHT)
{
-
}
if (orderInfo->boundsFlags & BOUND_BOTTOM)
}
else if (orderInfo->boundsFlags & BOUND_DELTA_BOTTOM)
{
-
}
return TRUE;
ORDER_INFO* orderInfo;
rdpContext* context = update->context;
rdpPrimaryUpdate* primary = update->primary;
-
orderInfo = &(primary->order_info);
if (flags & ORDER_TYPE_CHANGE)
}
if (!update_read_field_flags(s, &(orderInfo->fieldFlags), flags,
- PRIMARY_DRAWING_ORDER_FIELD_BYTES[orderInfo->orderType]))
+ PRIMARY_DRAWING_ORDER_FIELD_BYTES[orderInfo->orderType]))
{
WLog_ERR(TAG, "update_read_field_flags() failed");
return FALSE;
}
orderInfo->deltaCoordinates = (flags & ORDER_DELTA_COORDINATES) ? TRUE : FALSE;
-
#ifdef WITH_DEBUG_ORDERS
- WLog_DBG(TAG, "%s Primary Drawing Order (0x%02X)", PRIMARY_DRAWING_ORDER_STRINGS[orderInfo->orderType], orderInfo->orderType);
+ WLog_DBG(TAG, "%s Primary Drawing Order (0x%02X)",
+ PRIMARY_DRAWING_ORDER_STRINGS[orderInfo->orderType], orderInfo->orderType);
#endif
switch (orderInfo->orderType)
WLog_ERR(TAG, "ORDER_TYPE_DSTBLT - update_read_dstblt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DstBlt");
IFCALL(primary->DstBlt, context, &primary->dstblt);
break;
WLog_ERR(TAG, "ORDER_TYPE_PATBLT - update_read_patblt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "PatBlt");
IFCALL(primary->PatBlt, context, &primary->patblt);
break;
WLog_ERR(TAG, "ORDER_TYPE_SCRBLT - update_read_scrblt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "ScrBlt");
IFCALL(primary->ScrBlt, context, &primary->scrblt);
break;
case ORDER_TYPE_OPAQUE_RECT:
if (!update_read_opaque_rect_order(s, orderInfo, &(primary->opaque_rect)))
{
- WLog_ERR(TAG, "ORDER_TYPE_OPAQUE_RECT - update_read_opaque_rect_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_OPAQUE_RECT - update_read_opaque_rect_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "OpaqueRect");
IFCALL(primary->OpaqueRect, context, &primary->opaque_rect);
break;
case ORDER_TYPE_DRAW_NINE_GRID:
if (!update_read_draw_nine_grid_order(s, orderInfo, &(primary->draw_nine_grid)))
{
- WLog_ERR(TAG, "ORDER_TYPE_DRAW_NINE_GRID - update_read_draw_nine_grid_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_DRAW_NINE_GRID - update_read_draw_nine_grid_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DrawNineGrid");
IFCALL(primary->DrawNineGrid, context, &primary->draw_nine_grid);
break;
case ORDER_TYPE_MULTI_DSTBLT:
if (!update_read_multi_dstblt_order(s, orderInfo, &(primary->multi_dstblt)))
{
- WLog_ERR(TAG, "ORDER_TYPE_MULTI_DSTBLT - update_read_multi_dstblt_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_MULTI_DSTBLT - update_read_multi_dstblt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "MultiDstBlt");
IFCALL(primary->MultiDstBlt, context, &primary->multi_dstblt);
break;
case ORDER_TYPE_MULTI_PATBLT:
if (!update_read_multi_patblt_order(s, orderInfo, &(primary->multi_patblt)))
{
- WLog_ERR(TAG, "ORDER_TYPE_MULTI_PATBLT - update_read_multi_patblt_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_MULTI_PATBLT - update_read_multi_patblt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "MultiPatBlt");
IFCALL(primary->MultiPatBlt, context, &primary->multi_patblt);
break;
case ORDER_TYPE_MULTI_SCRBLT:
if (!update_read_multi_scrblt_order(s, orderInfo, &(primary->multi_scrblt)))
{
- WLog_ERR(TAG, "ORDER_TYPE_MULTI_SCRBLT - update_read_multi_scrblt_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_MULTI_SCRBLT - update_read_multi_scrblt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "MultiScrBlt");
IFCALL(primary->MultiScrBlt, context, &primary->multi_scrblt);
break;
case ORDER_TYPE_MULTI_OPAQUE_RECT:
- if (!update_read_multi_opaque_rect_order(s, orderInfo, &(primary->multi_opaque_rect)))
+ if (!update_read_multi_opaque_rect_order(s, orderInfo,
+ &(primary->multi_opaque_rect)))
{
- WLog_ERR(TAG, "ORDER_TYPE_MULTI_OPAQUE_RECT - update_read_multi_opaque_rect_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_MULTI_OPAQUE_RECT - update_read_multi_opaque_rect_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "MultiOpaqueRect");
IFCALL(primary->MultiOpaqueRect, context, &primary->multi_opaque_rect);
break;
case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
- if (!update_read_multi_draw_nine_grid_order(s, orderInfo, &(primary->multi_draw_nine_grid)))
+ if (!update_read_multi_draw_nine_grid_order(s, orderInfo,
+ &(primary->multi_draw_nine_grid)))
{
- WLog_ERR(TAG, "ORDER_TYPE_MULTI_DRAW_NINE_GRID - update_read_multi_draw_nine_grid_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_MULTI_DRAW_NINE_GRID - update_read_multi_draw_nine_grid_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "MultiDrawNineGrid");
IFCALL(primary->MultiDrawNineGrid, context, &primary->multi_draw_nine_grid);
break;
WLog_ERR(TAG, "ORDER_TYPE_LINE_TO - update_read_line_to_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "LineTo");
IFCALL(primary->LineTo, context, &primary->line_to);
break;
WLog_ERR(TAG, "ORDER_TYPE_POLYLINE - update_read_polyline_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "Polyline");
IFCALL(primary->Polyline, context, &primary->polyline);
break;
WLog_ERR(TAG, "ORDER_TYPE_MEMBLT - update_read_memblt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "MemBlt");
IFCALL(primary->MemBlt, context, &primary->memblt);
break;
WLog_ERR(TAG, "ORDER_TYPE_MEM3BLT - update_read_mem3blt_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "Mem3Blt");
IFCALL(primary->Mem3Blt, context, &primary->mem3blt);
break;
case ORDER_TYPE_SAVE_BITMAP:
if (!update_read_save_bitmap_order(s, orderInfo, &(primary->save_bitmap)))
{
- WLog_ERR(TAG, "ORDER_TYPE_SAVE_BITMAP - update_read_save_bitmap_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_SAVE_BITMAP - update_read_save_bitmap_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "SaveBitmap");
IFCALL(primary->SaveBitmap, context, &primary->save_bitmap);
break;
case ORDER_TYPE_GLYPH_INDEX:
if (!update_read_glyph_index_order(s, orderInfo, &(primary->glyph_index)))
{
- WLog_ERR(TAG, "ORDER_TYPE_GLYPH_INDEX - update_read_glyph_index_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_GLYPH_INDEX - update_read_glyph_index_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "GlyphIndex");
IFCALL(primary->GlyphIndex, context, &primary->glyph_index);
break;
WLog_ERR(TAG, "ORDER_TYPE_FAST_INDEX - update_read_fast_index_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "FastIndex");
IFCALL(primary->FastIndex, context, &primary->fast_index);
break;
WLog_ERR(TAG, "ORDER_TYPE_FAST_GLYPH - update_read_fast_glyph_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "FastGlyph");
IFCALL(primary->FastGlyph, context, &primary->fast_glyph);
break;
WLog_ERR(TAG, "ORDER_TYPE_POLYGON_SC - update_read_polygon_sc_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "PolygonSC");
IFCALL(primary->PolygonSC, context, &primary->polygon_sc);
break;
WLog_ERR(TAG, "ORDER_TYPE_POLYGON_CB - update_read_polygon_cb_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "PolygonCB");
IFCALL(primary->PolygonCB, context, &primary->polygon_cb);
break;
WLog_ERR(TAG, "ORDER_TYPE_ELLIPSE_SC - update_read_ellipse_sc_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "EllipseSC");
IFCALL(primary->EllipseSC, context, &primary->ellipse_sc);
break;
WLog_ERR(TAG, "ORDER_TYPE_ELLIPSE_CB - update_read_ellipse_cb_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "EllipseCB");
IFCALL(primary->EllipseCB, context, &primary->ellipse_cb);
break;
Stream_Read_UINT16(s, orderLength); /* orderLength (2 bytes) */
Stream_Read_UINT16(s, extraFlags); /* extraFlags (2 bytes) */
Stream_Read_UINT8(s, orderType); /* orderType (1 byte) */
-
next = Stream_Pointer(s) + ((INT16) orderLength) + 7;
-
#ifdef WITH_DEBUG_ORDERS
+
if (orderType < SECONDARY_DRAWING_ORDER_COUNT)
- WLog_DBG(TAG, "%s Secondary Drawing Order (0x%02X)", SECONDARY_DRAWING_ORDER_STRINGS[orderType], orderType);
+ WLog_DBG(TAG, "%s Secondary Drawing Order (0x%02X)",
+ SECONDARY_DRAWING_ORDER_STRINGS[orderType], orderType);
else
WLog_DBG(TAG, "Unknown Secondary Drawing Order (0x%02X)", orderType);
+
#endif
switch (orderType)
{
case ORDER_TYPE_BITMAP_UNCOMPRESSED:
- if (!update_read_cache_bitmap_order(s, &(secondary->cache_bitmap_order), FALSE, extraFlags))
+ if (!update_read_cache_bitmap_order(s, &(secondary->cache_bitmap_order), FALSE,
+ extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_BITMAP_UNCOMPRESSED - update_read_cache_bitmap_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_BITMAP_UNCOMPRESSED - update_read_cache_bitmap_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheBitmapUncompressed");
IFCALL(secondary->CacheBitmap, context, &(secondary->cache_bitmap_order));
break;
case ORDER_TYPE_CACHE_BITMAP_COMPRESSED:
- if (!update_read_cache_bitmap_order(s, &(secondary->cache_bitmap_order), TRUE, extraFlags))
+ if (!update_read_cache_bitmap_order(s, &(secondary->cache_bitmap_order), TRUE,
+ extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_CACHE_BITMAP_COMPRESSED - update_read_cache_bitmap_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_CACHE_BITMAP_COMPRESSED - update_read_cache_bitmap_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheBitmapCompressed");
IFCALL(secondary->CacheBitmap, context, &(secondary->cache_bitmap_order));
break;
case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2:
- if (!update_read_cache_bitmap_v2_order(s, &(secondary->cache_bitmap_v2_order), FALSE, extraFlags))
+ if (!update_read_cache_bitmap_v2_order(s, &(secondary->cache_bitmap_v2_order),
+ FALSE, extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_BITMAP_UNCOMPRESSED_V2 - update_read_cache_bitmap_v2_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_BITMAP_UNCOMPRESSED_V2 - update_read_cache_bitmap_v2_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheBitmapUncompressedV2");
IFCALL(secondary->CacheBitmapV2, context, &(secondary->cache_bitmap_v2_order));
break;
case ORDER_TYPE_BITMAP_COMPRESSED_V2:
- if (!update_read_cache_bitmap_v2_order(s, &(secondary->cache_bitmap_v2_order), TRUE, extraFlags))
+ if (!update_read_cache_bitmap_v2_order(s, &(secondary->cache_bitmap_v2_order),
+ TRUE, extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_BITMAP_COMPRESSED_V2 - update_read_cache_bitmap_v2_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_BITMAP_COMPRESSED_V2 - update_read_cache_bitmap_v2_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheBitmapCompressedV2");
IFCALL(secondary->CacheBitmapV2, context, &(secondary->cache_bitmap_v2_order));
break;
case ORDER_TYPE_BITMAP_COMPRESSED_V3:
- if (!update_read_cache_bitmap_v3_order(s, &(secondary->cache_bitmap_v3_order), extraFlags))
+ if (!update_read_cache_bitmap_v3_order(s, &(secondary->cache_bitmap_v3_order),
+ extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_BITMAP_COMPRESSED_V3 - update_read_cache_bitmap_v3_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_BITMAP_COMPRESSED_V3 - update_read_cache_bitmap_v3_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheBitmapCompressedV3");
IFCALL(secondary->CacheBitmapV3, context, &(secondary->cache_bitmap_v3_order));
break;
case ORDER_TYPE_CACHE_COLOR_TABLE:
- if (!update_read_cache_color_table_order(s, &(secondary->cache_color_table_order), extraFlags))
+ if (!update_read_cache_color_table_order(s,
+ &(secondary->cache_color_table_order), extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_CACHE_COLOR_TABLE - update_read_cache_color_table_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_CACHE_COLOR_TABLE - update_read_cache_color_table_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheColorTable");
- IFCALL(secondary->CacheColorTable, context, &(secondary->cache_color_table_order));
+ IFCALL(secondary->CacheColorTable, context,
+ &(secondary->cache_color_table_order));
break;
case ORDER_TYPE_CACHE_GLYPH:
if (secondary->glyph_v2)
{
- if (!update_read_cache_glyph_v2_order(s, &(secondary->cache_glyph_v2_order), extraFlags))
+ if (!update_read_cache_glyph_v2_order(s, &(secondary->cache_glyph_v2_order),
+ extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_CACHE_GLYPH - update_read_cache_glyph_v2_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_CACHE_GLYPH - update_read_cache_glyph_v2_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheGlyphV2");
IFCALL(secondary->CacheGlyphV2, context, &(secondary->cache_glyph_v2_order));
}
else
{
- if (!update_read_cache_glyph_order(s, &(secondary->cache_glyph_order), extraFlags))
+ if (!update_read_cache_glyph_order(s, &(secondary->cache_glyph_order),
+ extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_CACHE_GLYPH - update_read_cache_glyph_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_CACHE_GLYPH - update_read_cache_glyph_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheGlyph");
IFCALL(secondary->CacheGlyph, context, &(secondary->cache_glyph_order));
}
+
break;
case ORDER_TYPE_CACHE_BRUSH:
- if (!update_read_cache_brush_order(s, &(secondary->cache_brush_order), extraFlags))
+ if (!update_read_cache_brush_order(s, &(secondary->cache_brush_order),
+ extraFlags))
{
- WLog_ERR(TAG, "ORDER_TYPE_CACHE_BRUSH - update_read_cache_brush_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_CACHE_BRUSH - update_read_cache_brush_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CacheBrush");
IFCALL(secondary->CacheBrush, context, &(secondary->cache_brush_order));
break;
}
Stream_SetPointer(s, next);
-
return TRUE;
}
-BOOL update_recv_altsec_order(rdpUpdate* update, wStream* s, BYTE flags)
+static BOOL update_recv_altsec_order(rdpUpdate* update, wStream* s, BYTE flags)
{
BYTE orderType;
rdpContext* context = update->context;
rdpAltSecUpdate* altsec = update->altsec;
-
orderType = flags >>= 2; /* orderType is in higher 6 bits of flags field */
-
#ifdef WITH_DEBUG_ORDERS
+
if (orderType < ALTSEC_DRAWING_ORDER_COUNT)
- WLog_DBG(TAG, "%s Alternate Secondary Drawing Order (0x%02X)", ALTSEC_DRAWING_ORDER_STRINGS[orderType], orderType);
+ WLog_DBG(TAG, "%s Alternate Secondary Drawing Order (0x%02X)",
+ ALTSEC_DRAWING_ORDER_STRINGS[orderType], orderType);
else
WLog_DBG(TAG, "Unknown Alternate Secondary Drawing Order: 0x%02X", orderType);
+
#endif
switch (orderType)
{
case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
- if (!update_read_create_offscreen_bitmap_order(s, &(altsec->create_offscreen_bitmap)))
+ if (!update_read_create_offscreen_bitmap_order(s,
+ &(altsec->create_offscreen_bitmap)))
{
- WLog_ERR(TAG, "ORDER_TYPE_CREATE_OFFSCREEN_BITMAP - update_read_create_offscreen_bitmap_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_CREATE_OFFSCREEN_BITMAP - update_read_create_offscreen_bitmap_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CreateOffscreenBitmap");
- IFCALL(altsec->CreateOffscreenBitmap, context, &(altsec->create_offscreen_bitmap));
+ IFCALL(altsec->CreateOffscreenBitmap, context,
+ &(altsec->create_offscreen_bitmap));
break;
case ORDER_TYPE_SWITCH_SURFACE:
if (!update_read_switch_surface_order(s, &(altsec->switch_surface)))
{
- WLog_ERR(TAG, "ORDER_TYPE_SWITCH_SURFACE - update_read_switch_surface_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_SWITCH_SURFACE - update_read_switch_surface_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "SwitchSurface");
IFCALL(altsec->SwitchSurface, context, &(altsec->switch_surface));
break;
case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
- if (!update_read_create_nine_grid_bitmap_order(s, &(altsec->create_nine_grid_bitmap)))
+ if (!update_read_create_nine_grid_bitmap_order(s,
+ &(altsec->create_nine_grid_bitmap)))
{
- WLog_ERR(TAG, "ORDER_TYPE_CREATE_NINE_GRID_BITMAP - update_read_create_nine_grid_bitmap_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_CREATE_NINE_GRID_BITMAP - update_read_create_nine_grid_bitmap_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "CreateNineGridBitmap");
- IFCALL(altsec->CreateNineGridBitmap, context, &(altsec->create_nine_grid_bitmap));
+ IFCALL(altsec->CreateNineGridBitmap, context,
+ &(altsec->create_nine_grid_bitmap));
break;
case ORDER_TYPE_FRAME_MARKER:
if (!update_read_frame_marker_order(s, &(altsec->frame_marker)))
{
- WLog_ERR(TAG, "ORDER_TYPE_FRAME_MARKER - update_read_frame_marker_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_FRAME_MARKER - update_read_frame_marker_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "AltSecFrameMarker: action: %s (%d)",
- (!altsec->frame_marker.action) ? "Begin" : "End", altsec->frame_marker.action);
+ (!altsec->frame_marker.action) ? "Begin" : "End", altsec->frame_marker.action);
IFCALL(altsec->FrameMarker, context, &(altsec->frame_marker));
break;
case ORDER_TYPE_STREAM_BITMAP_FIRST:
if (!update_read_stream_bitmap_first_order(s, &(altsec->stream_bitmap_first)))
{
- WLog_ERR(TAG, "ORDER_TYPE_STREAM_BITMAP_FIRST - update_read_stream_bitmap_first_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_STREAM_BITMAP_FIRST - update_read_stream_bitmap_first_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "StreamBitmapFirst");
IFCALL(altsec->StreamBitmapFirst, context, &(altsec->stream_bitmap_first));
break;
case ORDER_TYPE_STREAM_BITMAP_NEXT:
if (!update_read_stream_bitmap_next_order(s, &(altsec->stream_bitmap_next)))
{
- WLog_ERR(TAG, "ORDER_TYPE_STREAM_BITMAP_NEXT - update_read_stream_bitmap_next_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_STREAM_BITMAP_NEXT - update_read_stream_bitmap_next_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "StreamBitmapNext");
IFCALL(altsec->StreamBitmapNext, context, &(altsec->stream_bitmap_next));
break;
case ORDER_TYPE_GDIPLUS_FIRST:
if (!update_read_draw_gdiplus_first_order(s, &(altsec->draw_gdiplus_first)))
{
- WLog_ERR(TAG, "ORDER_TYPE_GDIPLUS_FIRST - update_read_draw_gdiplus_first_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_GDIPLUS_FIRST - update_read_draw_gdiplus_first_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DrawGdiPlusFirst");
IFCALL(altsec->DrawGdiPlusFirst, context, &(altsec->draw_gdiplus_first));
break;
case ORDER_TYPE_GDIPLUS_NEXT:
if (!update_read_draw_gdiplus_next_order(s, &(altsec->draw_gdiplus_next)))
{
- WLog_ERR(TAG, "ORDER_TYPE_GDIPLUS_NEXT - update_read_draw_gdiplus_next_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_GDIPLUS_NEXT - update_read_draw_gdiplus_next_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DrawGdiPlusNext");
IFCALL(altsec->DrawGdiPlusNext, context, &(altsec->draw_gdiplus_next));
break;
case ORDER_TYPE_GDIPLUS_END:
if (update_read_draw_gdiplus_end_order(s, &(altsec->draw_gdiplus_end)))
{
- WLog_ERR(TAG, "ORDER_TYPE_GDIPLUS_END - update_read_draw_gdiplus_end_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_GDIPLUS_END - update_read_draw_gdiplus_end_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DrawGdiPlusEnd");
IFCALL(altsec->DrawGdiPlusEnd, context, &(altsec->draw_gdiplus_end));
break;
case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
- if (!update_read_draw_gdiplus_cache_first_order(s, &(altsec->draw_gdiplus_cache_first)))
+ if (!update_read_draw_gdiplus_cache_first_order(s,
+ &(altsec->draw_gdiplus_cache_first)))
{
- WLog_ERR(TAG, "ORDER_TYPE_GDIPLUS_CACHE_FIRST - update_read_draw_gdiplus_cache_first_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_GDIPLUS_CACHE_FIRST - update_read_draw_gdiplus_cache_first_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DrawGdiPlusCacheFirst");
- IFCALL(altsec->DrawGdiPlusCacheFirst, context, &(altsec->draw_gdiplus_cache_first));
+ IFCALL(altsec->DrawGdiPlusCacheFirst, context,
+ &(altsec->draw_gdiplus_cache_first));
break;
case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
- if (!update_read_draw_gdiplus_cache_next_order(s, &(altsec->draw_gdiplus_cache_next)))
+ if (!update_read_draw_gdiplus_cache_next_order(s,
+ &(altsec->draw_gdiplus_cache_next)))
{
- WLog_ERR(TAG, "ORDER_TYPE_GDIPLUS_CACHE_NEXT - update_read_draw_gdiplus_cache_next_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_GDIPLUS_CACHE_NEXT - update_read_draw_gdiplus_cache_next_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DrawGdiPlusCacheNext");
- IFCALL(altsec->DrawGdiPlusCacheNext, context, &(altsec->draw_gdiplus_cache_next));
+ IFCALL(altsec->DrawGdiPlusCacheNext, context,
+ &(altsec->draw_gdiplus_cache_next));
break;
case ORDER_TYPE_GDIPLUS_CACHE_END:
- if (!update_read_draw_gdiplus_cache_end_order(s, &(altsec->draw_gdiplus_cache_end)))
+ if (!update_read_draw_gdiplus_cache_end_order(s,
+ &(altsec->draw_gdiplus_cache_end)))
{
- WLog_ERR(TAG, "ORDER_TYPE_GDIPLUS_CACHE_END - update_read_draw_gdiplus_cache_end_order() failed");
+ WLog_ERR(TAG,
+ "ORDER_TYPE_GDIPLUS_CACHE_END - update_read_draw_gdiplus_cache_end_order() failed");
return FALSE;
}
+
WLog_Print(update->log, WLOG_DEBUG, "DrawGdiPlusCacheEnd");
IFCALL(altsec->DrawGdiPlusCacheEnd, context, &(altsec->draw_gdiplus_cache_end));
break;
default:
break;
}
+
return TRUE;
}
projects / platform / upstream / freerdp.git / commitdiff