ReactOS 0.4.15-dev-5672-gf73ac17
orders.c File Reference
#include "precomp.h"
#include "orders.h"
Include dependency graph for orders.c:

Go to the source code of this file.

Functions

static void rdp_in_present (STREAM s, uint32 *present, uint8 flags, int size)
 
static void rdp_in_coord (STREAM s, sint16 *coord, RD_BOOL delta)
 
static int parse_delta (uint8 *buffer, int *offset)
 
static void rdp_in_colour (STREAM s, uint32 *colour)
 
static RD_BOOL rdp_parse_bounds (STREAM s, BOUNDS *bounds)
 
static RD_BOOL rdp_parse_pen (STREAM s, PEN *pen, uint32 present)
 
static void setup_brush (BRUSH *out_brush, BRUSH *in_brush)
 
static RD_BOOL rdp_parse_brush (STREAM s, BRUSH *brush, uint32 present)
 
static void process_destblt (STREAM s, DESTBLT_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_patblt (STREAM s, PATBLT_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_screenblt (STREAM s, SCREENBLT_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_line (STREAM s, LINE_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_rect (STREAM s, RECT_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_desksave (STREAM s, DESKSAVE_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_memblt (STREAM s, MEMBLT_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_triblt (STREAM s, TRIBLT_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_polygon (STREAM s, POLYGON_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_polygon2 (STREAM s, POLYGON2_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_polyline (STREAM s, POLYLINE_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_ellipse (STREAM s, ELLIPSE_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_ellipse2 (STREAM s, ELLIPSE2_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_text2 (STREAM s, TEXT2_ORDER *os, uint32 present, RD_BOOL delta)
 
static void process_raw_bmpcache (STREAM s)
 
static void process_bmpcache (STREAM s)
 
static void process_bmpcache2 (STREAM s, uint16 flags, RD_BOOL compressed)
 
static void process_colcache (STREAM s)
 
static void process_fontcache (STREAM s)
 
static void process_compressed_8x8_brush_data (uint8 *in, uint8 *out, int Bpp)
 
static void process_brushcache (STREAM s, uint16 flags)
 
static void process_secondary_order (STREAM s)
 
void process_orders (STREAM s, uint16 num_orders)
 
void reset_order_state (void)
 

Variables

uint8g_next_packet
 
static RDP_ORDER_STATE g_order_state
 
RDP_VERSION g_rdp_version
 

Function Documentation

◆ parse_delta()

static int parse_delta ( uint8 buffer,
int offset 
)
static

Definition at line 74 of file orders.c.

75{
76 int value = buffer[(*offset)++];
77 int two_byte = value & 0x80;
78
79 if (value & 0x40) /* sign bit */
80 value |= ~0x3f;
81 else
82 value &= 0x3f;
83
84 if (two_byte)
85 value = (value << 8) | buffer[(*offset)++];
86
87 return value;
88}
GLuint buffer
Definition: glext.h:5915
GLintptr offset
Definition: glext.h:5920
Definition: pdh_main.c:94

Referenced by process_polygon(), process_polygon2(), and process_polyline().

◆ process_bmpcache()

static void process_bmpcache ( STREAM  s)
static

Definition at line 951 of file orders.c.

952{
954 uint16 cache_idx, size;
955 uint8 cache_id, width, height, bpp, Bpp;
956 uint8 *data, *bmpdata;
957 uint16 bufsize, pad2, row_size, final_size;
958 uint8 pad1;
959
960 pad2 = row_size = final_size = 0xffff; /* Shut the compiler up */
961
962 in_uint8(s, cache_id);
963 in_uint8(s, pad1); /* pad */
964 in_uint8(s, width);
965 in_uint8(s, height);
966 in_uint8(s, bpp);
967 Bpp = (bpp + 7) / 8;
968 in_uint16_le(s, bufsize); /* bufsize */
969 in_uint16_le(s, cache_idx);
970
971 if (g_rdp_version >= RDP_V5)
972 {
973 size = bufsize;
974 }
975 else
976 {
977
978 /* Begin compressedBitmapData */
979 in_uint16_le(s, pad2); /* pad */
981 /* in_uint8s(s, 4); *//* row_size, final_size */
982 in_uint16_le(s, row_size);
983 in_uint16_le(s, final_size);
984
985 }
986 in_uint8p(s, data, size);
987
988 DEBUG(("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d,bpp=%d,size=%d,pad1=%d,bufsize=%d,pad2=%d,rs=%d,fs=%d)\n", width, height, cache_id, cache_idx, bpp, size, pad1, bufsize, pad2, row_size, final_size));
989
990 bmpdata = (uint8 *) xmalloc(width * height * Bpp);
991
992 if (bitmap_decompress(bmpdata, width, height, data, size, Bpp))
993 {
994 bitmap = ui_create_bitmap(width, height, bmpdata);
995 cache_put_bitmap(cache_id, cache_idx, bitmap);
996 }
997 else
998 {
999 DEBUG(("Failed to decompress bitmap data\n"));
1000 }
1001 if (pad1 || pad2) {}
1002
1003 xfree(bmpdata);
1004}
RD_BOOL bitmap_decompress(uint8 *output, int width, int height, uint8 *input, int size, int Bpp)
Definition: bitmap.c:884
void cache_put_bitmap(uint8 id, uint16 idx, RD_HBITMAP bitmap)
Definition: cache.c:218
RDP_VERSION g_rdp_version
Definition: uimain.c:74
#define in_uint16_le(s, v)
Definition: parse.h:55
#define in_uint8p(s, v, n)
Definition: parse.h:89
#define in_uint8(s, v)
Definition: parse.h:88
void xfree(void *mem)
Definition: uimain.c:758
RD_HBITMAP ui_create_bitmap(int width, int height, uint8 *data)
Definition: uimain.c:277
void * xmalloc(int size)
Definition: uimain.c:747
#define DEBUG(args)
Definition: rdesktop.h:129
unsigned short uint16
Definition: types.h:30
@ RDP_V5
Definition: types.h:44
unsigned char uint8
Definition: types.h:28
DWORD bpp
Definition: surface.c:185
GLdouble s
Definition: gl.h:2039
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLint GLint GLsizei GLsizei height
Definition: gl.h:1546
GLint GLint GLsizei width
Definition: gl.h:1546
GLsizeiptr size
Definition: glext.h:5919
GLenum GLuint GLsizei bufsize
Definition: glext.h:7473
Definition: uimain.c:89

Referenced by process_secondary_order().

◆ process_bmpcache2()

static void process_bmpcache2 ( STREAM  s,
uint16  flags,
RD_BOOL  compressed 
)
static

Definition at line 1008 of file orders.c.

1009{
1011 int y;
1012 uint8 cache_id, cache_idx_low, width, height, Bpp;
1013 uint16 cache_idx, bufsize;
1014 uint8 *data, *bmpdata, *bitmap_id;
1015
1016 bitmap_id = NULL; /* prevent compiler warning */
1017 cache_id = flags & ID_MASK;
1018 Bpp = ((flags & MODE_MASK) >> MODE_SHIFT) - 2;
1019
1020 if (flags & PERSIST)
1021 {
1022 in_uint8p(s, bitmap_id, 8);
1023 }
1024
1025 if (flags & SQUARE)
1026 {
1027 in_uint8(s, width);
1028 height = width;
1029 }
1030 else
1031 {
1032 in_uint8(s, width);
1033 in_uint8(s, height);
1034 }
1035
1038 in_uint8(s, cache_idx);
1039
1040 if (cache_idx & LONG_FORMAT)
1041 {
1042 in_uint8(s, cache_idx_low);
1043 cache_idx = ((cache_idx ^ LONG_FORMAT) << 8) + cache_idx_low;
1044 }
1045
1047
1048 DEBUG(("BMPCACHE2(compr=%d,flags=%x,cx=%d,cy=%d,id=%d,idx=%d,Bpp=%d,bs=%d)\n",
1049 compressed, flags, width, height, cache_id, cache_idx, Bpp, bufsize));
1050
1051 bmpdata = (uint8 *) xmalloc(width * height * Bpp);
1052
1053 if (compressed)
1054 {
1055 if (!bitmap_decompress(bmpdata, width, height, data, bufsize, Bpp))
1056 {
1057 DEBUG(("Failed to decompress bitmap data\n"));
1058 xfree(bmpdata);
1059 return;
1060 }
1061 }
1062 else
1063 {
1064 for (y = 0; y < height; y++)
1065 memcpy(&bmpdata[(height - y - 1) * (width * Bpp)],
1066 &data[y * (width * Bpp)], width * Bpp);
1067 }
1068
1069 bitmap = ui_create_bitmap(width, height, bmpdata);
1070
1071 if (bitmap)
1072 {
1073 cache_put_bitmap(cache_id, cache_idx, bitmap);
1074 if (flags & PERSIST)
1075 pstcache_save_bitmap(cache_id, cache_idx, bitmap_id, width, height,
1076 width * height * Bpp, bmpdata);
1077 }
1078 else
1079 {
1080 DEBUG(("process_bmpcache2: ui_create_bitmap failed\n"));
1081 }
1082
1083 xfree(bmpdata);
1084}
#define MODE_SHIFT
Definition: orders.h:331
#define BUFSIZE_MASK
Definition: orders.h:334
#define ID_MASK
Definition: orders.h:325
#define PERSIST
Definition: orders.h:328
#define MODE_MASK
Definition: orders.h:326
#define LONG_FORMAT
Definition: orders.h:333
#define SQUARE
Definition: orders.h:327
#define in_uint16_be(s, v)
Definition: parse.h:75
RD_BOOL pstcache_save_bitmap(uint8 cache_id, uint16 cache_idx, uint8 *key, uint8 width, uint8 height, uint16 length, uint8 *data)
Definition: pstcache.c:82
#define NULL
Definition: types.h:112
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLbitfield flags
Definition: glext.h:7161
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878

Referenced by process_secondary_order().

◆ process_brushcache()

static void process_brushcache ( STREAM  s,
uint16  flags 
)
static

Definition at line 1186 of file orders.c.

1187{
1188 BRUSHDATA brush_data;
1189 uint8 cache_idx, colour_code, width, height, size, type;
1190 uint8 *comp_brush;
1191 int index;
1192 int Bpp;
1193
1194 in_uint8(s, cache_idx);
1195 in_uint8(s, colour_code);
1196 in_uint8(s, width);
1197 in_uint8(s, height);
1198 in_uint8(s, type); /* type, 0x8x = cached */
1199 in_uint8(s, size);
1200
1201 DEBUG(("BRUSHCACHE(idx=%d,wd=%d,ht=%d,sz=%d)\n", cache_idx, width, height, size));
1202
1203 if ((width == 8) && (height == 8))
1204 {
1205 if (colour_code == 1)
1206 {
1207 brush_data.colour_code = 1;
1208 brush_data.data_size = 8;
1209 brush_data.data = xmalloc(8);
1210 if (size == 8)
1211 {
1212 /* read it bottom up */
1213 for (index = 7; index >= 0; index--)
1214 {
1215 in_uint8(s, brush_data.data[index]);
1216 }
1217 }
1218 else
1219 {
1220 warning("incompatible brush, colour_code %d size %d\n", colour_code,
1221 size);
1222 }
1223 cache_put_brush_data(1, cache_idx, &brush_data);
1224 }
1225 else if ((colour_code >= 3) && (colour_code <= 6))
1226 {
1227 Bpp = colour_code - 2;
1228 brush_data.colour_code = colour_code;
1229 brush_data.data_size = 8 * 8 * Bpp;
1230 brush_data.data = xmalloc(8 * 8 * Bpp);
1231 if (size == 16 + 4 * Bpp)
1232 {
1233 in_uint8p(s, comp_brush, 16 + 4 * Bpp);
1234 process_compressed_8x8_brush_data(comp_brush, brush_data.data, Bpp);
1235 }
1236 else
1237 {
1238 in_uint8a(s, brush_data.data, 8 * 8 * Bpp);
1239 }
1240 cache_put_brush_data(colour_code, cache_idx, &brush_data);
1241 }
1242 else
1243 {
1244 warning("incompatible brush, colour_code %d size %d\n", colour_code, size);
1245 }
1246 }
1247 else
1248 {
1249 warning("incompatible brush, width height %d %d\n", width, height);
1250 }
1251 if (type) {}
1252}
void cache_put_brush_data(uint8 colour_code, uint8 idx, BRUSHDATA *brush_data)
Definition: cache.c:455
static void process_compressed_8x8_brush_data(uint8 *in, uint8 *out, int Bpp)
Definition: orders.c:1152
#define in_uint8a(s, v, n)
Definition: parse.h:90
#define index(s, c)
Definition: various.h:29
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint index
Definition: glext.h:6031
#define warning(s)
Definition: debug.h:83
uint32 data_size
Definition: types.h:95
uint8 * data
Definition: types.h:96
uint32 colour_code
Definition: types.h:94

Referenced by process_secondary_order().

◆ process_colcache()

static void process_colcache ( STREAM  s)
static

Definition at line 1088 of file orders.c.

1089{
1091 COLOURMAP map;
1092 RD_HCOLOURMAP hmap;
1093 uint8 cache_id;
1094 int i;
1095
1096 in_uint8(s, cache_id);
1097 in_uint16_le(s, map.ncolours);
1098
1099 map.colours = (COLOURENTRY *) xmalloc(sizeof(COLOURENTRY) * map.ncolours);
1100
1101 for (i = 0; i < map.ncolours; i++)
1102 {
1103 entry = &map.colours[i];
1104 in_uint8(s, entry->blue);
1105 in_uint8(s, entry->green);
1106 in_uint8(s, entry->red);
1107 in_uint8s(s, 1); /* pad */
1108 }
1109
1110 DEBUG(("COLCACHE(id=%d,n=%d)\n", cache_id, map.ncolours));
1111
1112 hmap = ui_create_colourmap(&map);
1113
1114 if (cache_id)
1115 ui_set_colourmap(hmap);
1116
1117 xfree(map.colours);
1118}
#define in_uint8s(s, n)
Definition: parse.h:91
void ui_set_colourmap(RD_HCOLOURMAP map)
Definition: qtewin.cpp:1527
RD_HCOLOURMAP ui_create_colourmap(COLOURMAP *colours)
Definition: uimain.c:336
Definition: _map.h:48
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
uint32_t entry
Definition: isohybrid.c:63

Referenced by process_secondary_order().

◆ process_compressed_8x8_brush_data()

static void process_compressed_8x8_brush_data ( uint8 in,
uint8 out,
int  Bpp 
)
static

Definition at line 1152 of file orders.c.

1153{
1154 int x, y, pal_index, in_index, shift, do2, i;
1155 uint8 *pal;
1156
1157 in_index = 0;
1158 pal = in + 16;
1159 /* read it bottom up */
1160 for (y = 7; y >= 0; y--)
1161 {
1162 /* 2 bytes per row */
1163 x = 0;
1164 for (do2 = 0; do2 < 2; do2++)
1165 {
1166 /* 4 pixels per byte */
1167 shift = 6;
1168 while (shift >= 0)
1169 {
1170 pal_index = (in[in_index] >> shift) & 3;
1171 /* size of palette entries depends on Bpp */
1172 for (i = 0; i < Bpp; i++)
1173 {
1174 out[(y * 8 + x) * Bpp + i] = pal[pal_index * Bpp + i];
1175 }
1176 x++;
1177 shift -= 2;
1178 }
1179 in_index++;
1180 }
1181 }
1182}
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLuint in
Definition: glext.h:9616
#define shift
Definition: input.c:1755
static FILE * out
Definition: regtests2xml.c:44

Referenced by process_brushcache().

◆ process_desksave()

static void process_desksave ( STREAM  s,
DESKSAVE_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 374 of file orders.c.

375{
376 int width, height;
377
378 if (present & 0x01)
379 in_uint32_le(s, os->offset);
380
381 if (present & 0x02)
382 rdp_in_coord(s, &os->left, delta);
383
384 if (present & 0x04)
385 rdp_in_coord(s, &os->top, delta);
386
387 if (present & 0x08)
388 rdp_in_coord(s, &os->right, delta);
389
390 if (present & 0x10)
391 rdp_in_coord(s, &os->bottom, delta);
392
393 if (present & 0x20)
394 in_uint8(s, os->action);
395
396 DEBUG(("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n",
397 os->left, os->top, os->right, os->bottom, os->offset, os->action));
398
399 width = os->right - os->left + 1;
400 height = os->bottom - os->top + 1;
401
402 if (os->action == 0)
403 ui_desktop_save(os->offset, os->left, os->top, width, height);
404 else
405 ui_desktop_restore(os->offset, os->left, os->top, width, height);
406}
static void rdp_in_coord(STREAM s, sint16 *coord, RD_BOOL delta)
Definition: orders.c:57
#define in_uint32_le(s, v)
Definition: parse.h:56
void ui_desktop_save(uint32 offset, int x, int y, int cx, int cy)
Definition: uimain.c:567
void ui_desktop_restore(uint32 offset, int x, int y, int cx, int cy)
Definition: uimain.c:561
sint16 top
Definition: orders.h:125
uint8 action
Definition: orders.h:128
sint16 left
Definition: orders.h:124
sint16 right
Definition: orders.h:126
uint32 offset
Definition: orders.h:123
sint16 bottom
Definition: orders.h:127

Referenced by process_orders().

◆ process_destblt()

static void process_destblt ( STREAM  s,
DESTBLT_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 201 of file orders.c.

202{
203 if (present & 0x01)
204 rdp_in_coord(s, &os->x, delta);
205
206 if (present & 0x02)
207 rdp_in_coord(s, &os->y, delta);
208
209 if (present & 0x04)
210 rdp_in_coord(s, &os->cx, delta);
211
212 if (present & 0x08)
213 rdp_in_coord(s, &os->cy, delta);
214
215 if (present & 0x10)
216 in_uint8(s, os->opcode);
217
218 DEBUG(("DESTBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d)\n",
219 os->opcode, os->x, os->y, os->cx, os->cy));
220
221 ui_destblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy);
222}
#define ROP2_S(rop3)
Definition: constants.h:263
void ui_destblt(uint8 opcode, int x, int y, int cx, int cy)
Definition: uimain.c:607
sint16 cy
Definition: orders.h:63
sint16 y
Definition: orders.h:61
sint16 x
Definition: orders.h:60
uint8 opcode
Definition: orders.h:64
sint16 cx
Definition: orders.h:62

Referenced by process_orders().

◆ process_ellipse()

static void process_ellipse ( STREAM  s,
ELLIPSE_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 763 of file orders.c.

764{
765 if (present & 0x01)
766 rdp_in_coord(s, &os->left, delta);
767
768 if (present & 0x02)
769 rdp_in_coord(s, &os->top, delta);
770
771 if (present & 0x04)
772 rdp_in_coord(s, &os->right, delta);
773
774 if (present & 0x08)
775 rdp_in_coord(s, &os->bottom, delta);
776
777 if (present & 0x10)
778 in_uint8(s, os->opcode);
779
780 if (present & 0x20)
781 in_uint8(s, os->fillmode);
782
783 if (present & 0x40)
784 rdp_in_colour(s, &os->fgcolour);
785
786 DEBUG(("ELLIPSE(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,fg=0x%x)\n", os->left, os->top,
787 os->right, os->bottom, os->opcode, os->fillmode, os->fgcolour));
788
789 ui_ellipse(os->opcode - 1, os->fillmode, os->left, os->top, os->right - os->left,
790 os->bottom - os->top, NULL, 0, os->fgcolour);
791}
static void rdp_in_colour(STREAM s, uint32 *colour)
Definition: orders.c:92
void ui_ellipse(uint8 opcode, uint8 fillmode, int x, int y, int cx, int cy, BRUSH *brush, int bgcolour, int fgcolour)
Definition: uimain.c:699
sint16 left
Definition: orders.h:216
sint16 top
Definition: orders.h:217
sint16 bottom
Definition: orders.h:219
uint8 fillmode
Definition: orders.h:221
uint8 opcode
Definition: orders.h:220
uint32 fgcolour
Definition: orders.h:222
sint16 right
Definition: orders.h:218

Referenced by process_orders().

◆ process_ellipse2()

static void process_ellipse2 ( STREAM  s,
ELLIPSE2_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 795 of file orders.c.

796{
797 BRUSH brush;
798
799 if (present & 0x0001)
800 rdp_in_coord(s, &os->left, delta);
801
802 if (present & 0x0002)
803 rdp_in_coord(s, &os->top, delta);
804
805 if (present & 0x0004)
806 rdp_in_coord(s, &os->right, delta);
807
808 if (present & 0x0008)
809 rdp_in_coord(s, &os->bottom, delta);
810
811 if (present & 0x0010)
812 in_uint8(s, os->opcode);
813
814 if (present & 0x0020)
815 in_uint8(s, os->fillmode);
816
817 if (present & 0x0040)
818 rdp_in_colour(s, &os->bgcolour);
819
820 if (present & 0x0080)
821 rdp_in_colour(s, &os->fgcolour);
822
823 rdp_parse_brush(s, &os->brush, present >> 8);
824
825 DEBUG(("ELLIPSE2(l=%d,t=%d,r=%d,b=%d,op=0x%x,fm=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
826 os->left, os->top, os->right, os->bottom, os->opcode, os->fillmode, os->brush.style,
827 os->bgcolour, os->fgcolour));
828
829 setup_brush(&brush, &os->brush);
830
831 ui_ellipse(os->opcode - 1, os->fillmode, os->left, os->top, os->right - os->left,
832 os->bottom - os->top, &brush, os->bgcolour, os->fgcolour);
833}
static RD_BOOL rdp_parse_brush(STREAM s, BRUSH *brush, uint32 present)
Definition: orders.c:179
static void setup_brush(BRUSH *out_brush, BRUSH *in_brush)
Definition: orders.c:151
Definition: brush.hpp:16
sint16 top
Definition: orders.h:230
uint8 fillmode
Definition: orders.h:234
sint16 bottom
Definition: orders.h:232
uint32 bgcolour
Definition: orders.h:236
uint8 opcode
Definition: orders.h:233
sint16 right
Definition: orders.h:231
uint32 fgcolour
Definition: orders.h:237
sint16 left
Definition: orders.h:229
BRUSH brush
Definition: orders.h:235

Referenced by process_orders().

◆ process_fontcache()

static void process_fontcache ( STREAM  s)
static

Definition at line 1122 of file orders.c.

1123{
1125 uint8 font, nglyphs;
1126 uint16 character, offset, baseline, width, height;
1127 int i, datasize;
1128 uint8 *data;
1129
1130 in_uint8(s, font);
1131 in_uint8(s, nglyphs);
1132
1133 DEBUG(("FONTCACHE(font=%d,n=%d)\n", font, nglyphs));
1134
1135 for (i = 0; i < nglyphs; i++)
1136 {
1137 in_uint16_le(s, character);
1139 in_uint16_le(s, baseline);
1142
1143 datasize = (height * ((width + 7) / 8) + 3) & ~3;
1145
1147 cache_put_font(font, character, offset, baseline, width, height, bitmap);
1148 }
1149}
void cache_put_font(uint8 font, uint16 character, uint16 offset, uint16 baseline, uint16 width, uint16 height, RD_HGLYPH pixmap)
Definition: cache.c:296
RD_HGLYPH ui_create_glyph(int width, int height, uint8 *data)
Definition: uimain.c:234
static SIZE_T datasize
Definition: asm.c:30
Definition: mk_font.cpp:20

Referenced by process_secondary_order().

◆ process_line()

static void process_line ( STREAM  s,
LINE_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 295 of file orders.c.

296{
297 if (present & 0x0001)
298 in_uint16_le(s, os->mixmode);
299
300 if (present & 0x0002)
301 rdp_in_coord(s, &os->startx, delta);
302
303 if (present & 0x0004)
304 rdp_in_coord(s, &os->starty, delta);
305
306 if (present & 0x0008)
307 rdp_in_coord(s, &os->endx, delta);
308
309 if (present & 0x0010)
310 rdp_in_coord(s, &os->endy, delta);
311
312 if (present & 0x0020)
313 rdp_in_colour(s, &os->bgcolour);
314
315 if (present & 0x0040)
316 in_uint8(s, os->opcode);
317
318 rdp_parse_pen(s, &os->pen, present >> 7);
319
320 DEBUG(("LINE(op=0x%x,sx=%d,sy=%d,dx=%d,dy=%d,fg=0x%x)\n",
321 os->opcode, os->startx, os->starty, os->endx, os->endy, os->pen.colour));
322
323 if (os->opcode < 0x01 || os->opcode > 0x10)
324 {
325 error("bad ROP2 0x%x\n", os->opcode);
326 return;
327 }
328
329 ui_line(os->opcode - 1, os->startx, os->starty, os->endx, os->endy, &os->pen);
330}
static RD_BOOL rdp_parse_pen(STREAM s, PEN *pen, uint32 present)
Definition: orders.c:136
void ui_line(uint8 opcode, int startx, int starty, int endx, int endy, PEN *pen)
Definition: uimain.c:513
#define error(str)
Definition: mkdosfs.c:1605
uint8 opcode
Definition: orders.h:104
uint16 mixmode
Definition: orders.h:98
sint16 startx
Definition: orders.h:99
PEN pen
Definition: orders.h:105
sint16 endy
Definition: orders.h:102
sint16 endx
Definition: orders.h:101
sint16 starty
Definition: orders.h:100
uint32 bgcolour
Definition: orders.h:103
uint32 colour
Definition: types.h:86

Referenced by process_orders().

◆ process_memblt()

static void process_memblt ( STREAM  s,
MEMBLT_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 410 of file orders.c.

411{
413
414 if (present & 0x0001)
415 {
416 in_uint8(s, os->cache_id);
417 in_uint8(s, os->colour_table);
418 }
419
420 if (present & 0x0002)
421 rdp_in_coord(s, &os->x, delta);
422
423 if (present & 0x0004)
424 rdp_in_coord(s, &os->y, delta);
425
426 if (present & 0x0008)
427 rdp_in_coord(s, &os->cx, delta);
428
429 if (present & 0x0010)
430 rdp_in_coord(s, &os->cy, delta);
431
432 if (present & 0x0020)
433 in_uint8(s, os->opcode);
434
435 if (present & 0x0040)
436 rdp_in_coord(s, &os->srcx, delta);
437
438 if (present & 0x0080)
439 rdp_in_coord(s, &os->srcy, delta);
440
441 if (present & 0x0100)
443
444 DEBUG(("MEMBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d)\n",
445 os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx));
446
448 if (bitmap == NULL)
449 return;
450
451 ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, bitmap, os->srcx, os->srcy);
452}
RD_HBITMAP cache_get_bitmap(uint8 id, uint16 idx)
Definition: cache.c:195
void ui_memblt(uint8 opcode, int x, int y, int cx, int cy, RD_HBITMAP src, int srcx, int srcy)
uint8 opcode
Definition: orders.h:161
uint8 cache_id
Definition: orders.h:156
uint8 colour_table
Definition: orders.h:155
sint16 srcy
Definition: orders.h:163
sint16 y
Definition: orders.h:158
sint16 cx
Definition: orders.h:159
sint16 cy
Definition: orders.h:160
sint16 x
Definition: orders.h:157
uint16 cache_idx
Definition: orders.h:164
sint16 srcx
Definition: orders.h:162

Referenced by process_orders().

◆ process_orders()

void process_orders ( STREAM  s,
uint16  num_orders 
)

Definition at line 1311 of file orders.c.

1312{
1314 uint32 present;
1315 uint8 order_flags;
1316 int size, processed = 0;
1317 RD_BOOL delta;
1318
1319 while (processed < num_orders)
1320 {
1321 in_uint8(s, order_flags);
1322
1323 if (!(order_flags & RDP_ORDER_STANDARD))
1324 {
1325 error("order parsing failed\n");
1326 break;
1327 }
1328
1329 if (order_flags & RDP_ORDER_SECONDARY)
1330 {
1332 }
1333 else
1334 {
1335 if (order_flags & RDP_ORDER_CHANGE)
1336 {
1337 in_uint8(s, os->order_type);
1338 }
1339
1340 switch (os->order_type)
1341 {
1342 case RDP_ORDER_TRIBLT:
1343 case RDP_ORDER_TEXT2:
1344 size = 3;
1345 break;
1346
1347 case RDP_ORDER_PATBLT:
1348 case RDP_ORDER_MEMBLT:
1349 case RDP_ORDER_LINE:
1350 case RDP_ORDER_POLYGON2:
1351 case RDP_ORDER_ELLIPSE2:
1352 size = 2;
1353 break;
1354
1355 default:
1356 size = 1;
1357 }
1358
1359 rdp_in_present(s, &present, order_flags, size);
1360
1361 if (order_flags & RDP_ORDER_BOUNDS)
1362 {
1363 if (!(order_flags & RDP_ORDER_LASTBOUNDS))
1364 rdp_parse_bounds(s, &os->bounds);
1365
1367 os->bounds.top,
1368 os->bounds.right -
1369 os->bounds.left + 1,
1370 os->bounds.bottom - os->bounds.top + 1);
1371 }
1372
1373 delta = order_flags & RDP_ORDER_DELTA;
1374
1375 switch (os->order_type)
1376 {
1377 case RDP_ORDER_DESTBLT:
1378 process_destblt(s, &os->destblt, present, delta);
1379 break;
1380
1381 case RDP_ORDER_PATBLT:
1382 process_patblt(s, &os->patblt, present, delta);
1383 break;
1384
1386 process_screenblt(s, &os->screenblt, present, delta);
1387 break;
1388
1389 case RDP_ORDER_LINE:
1390 process_line(s, &os->line, present, delta);
1391 break;
1392
1393 case RDP_ORDER_RECT:
1394 process_rect(s, &os->rect, present, delta);
1395 break;
1396
1397 case RDP_ORDER_DESKSAVE:
1398 process_desksave(s, &os->desksave, present, delta);
1399 break;
1400
1401 case RDP_ORDER_MEMBLT:
1402 process_memblt(s, &os->memblt, present, delta);
1403 break;
1404
1405 case RDP_ORDER_TRIBLT:
1406 process_triblt(s, &os->triblt, present, delta);
1407 break;
1408
1409 case RDP_ORDER_POLYGON:
1410 process_polygon(s, &os->polygon, present, delta);
1411 break;
1412
1413 case RDP_ORDER_POLYGON2:
1414 process_polygon2(s, &os->polygon2, present, delta);
1415 break;
1416
1417 case RDP_ORDER_POLYLINE:
1418 process_polyline(s, &os->polyline, present, delta);
1419 break;
1420
1421 case RDP_ORDER_ELLIPSE:
1422 process_ellipse(s, &os->ellipse, present, delta);
1423 break;
1424
1425 case RDP_ORDER_ELLIPSE2:
1426 process_ellipse2(s, &os->ellipse2, present, delta);
1427 break;
1428
1429 case RDP_ORDER_TEXT2:
1430 process_text2(s, &os->text2, present, delta);
1431 break;
1432
1433 default:
1434 unimpl("order %d\n", os->order_type);
1435 return;
1436 }
1437
1438 if (order_flags & RDP_ORDER_BOUNDS)
1439 ui_reset_clip();
1440 }
1441
1442 processed++;
1443 }
1444#if 0
1445 /* not true when RDP_COMPRESSION is set */
1446 if (s->p != g_next_packet)
1447 error("%d bytes remaining\n", (int) (g_next_packet - s->p));
1448#endif
1449
1450}
static void process_rect(STREAM s, RECT_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:334
static void process_polygon2(STREAM s, POLYGON2_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:597
static void process_desksave(STREAM s, DESKSAVE_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:374
static void process_triblt(STREAM s, TRIBLT_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:456
static void process_ellipse2(STREAM s, ELLIPSE2_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:795
static void process_destblt(STREAM s, DESTBLT_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:201
static void process_polygon(STREAM s, POLYGON_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:518
uint8 * g_next_packet
Definition: rdp.c:45
static void process_ellipse(STREAM s, ELLIPSE_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:763
static void rdp_in_present(STREAM s, uint32 *present, uint8 flags, int size)
Definition: orders.c:29
static RDP_ORDER_STATE g_order_state
Definition: orders.c:24
static void process_screenblt(STREAM s, SCREENBLT_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:264
static void process_memblt(STREAM s, MEMBLT_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:410
static void process_text2(STREAM s, TEXT2_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:837
static void process_polyline(STREAM s, POLYLINE_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:685
static RD_BOOL rdp_parse_bounds(STREAM s, BOUNDS *bounds)
Definition: orders.c:105
static void process_secondary_order(STREAM s)
Definition: orders.c:1256
static void process_patblt(STREAM s, PATBLT_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:226
static void process_line(STREAM s, LINE_ORDER *os, uint32 present, RD_BOOL delta)
Definition: orders.c:295
#define RDP_ORDER_BOUNDS
Definition: orders.h:22
@ RDP_ORDER_POLYLINE
Definition: orders.h:41
@ RDP_ORDER_RECT
Definition: orders.h:35
@ RDP_ORDER_ELLIPSE
Definition: orders.h:42
@ RDP_ORDER_LINE
Definition: orders.h:34
@ RDP_ORDER_TRIBLT
Definition: orders.h:38
@ RDP_ORDER_DESTBLT
Definition: orders.h:31
@ RDP_ORDER_ELLIPSE2
Definition: orders.h:43
@ RDP_ORDER_TEXT2
Definition: orders.h:44
@ RDP_ORDER_PATBLT
Definition: orders.h:32
@ RDP_ORDER_MEMBLT
Definition: orders.h:37
@ RDP_ORDER_DESKSAVE
Definition: orders.h:36
@ RDP_ORDER_SCREENBLT
Definition: orders.h:33
@ RDP_ORDER_POLYGON2
Definition: orders.h:40
@ RDP_ORDER_POLYGON
Definition: orders.h:39
#define RDP_ORDER_CHANGE
Definition: orders.h:23
#define RDP_ORDER_SECONDARY
Definition: orders.h:21
#define RDP_ORDER_STANDARD
Definition: orders.h:20
#define RDP_ORDER_LASTBOUNDS
Definition: orders.h:25
#define RDP_ORDER_DELTA
Definition: orders.h:24
void unimpl(char *format,...)
Definition: uimain.c:801
void ui_set_clip(int x, int y, int cx, int cy)
Definition: uimain.c:320
void ui_reset_clip(void)
Definition: uimain.c:328
unsigned int uint32
Definition: types.h:32
int RD_BOOL
Definition: types.h:21
sint16 left
Definition: types.h:74
sint16 top
Definition: types.h:75
sint16 right
Definition: types.h:76
sint16 bottom
Definition: types.h:77
ELLIPSE2_ORDER ellipse2
Definition: orders.h:286
DESKSAVE_ORDER desksave
Definition: orders.h:279
BOUNDS bounds
Definition: orders.h:272
POLYGON_ORDER polygon
Definition: orders.h:282
DESTBLT_ORDER destblt
Definition: orders.h:274
RECT_ORDER rect
Definition: orders.h:278
MEMBLT_ORDER memblt
Definition: orders.h:280
LINE_ORDER line
Definition: orders.h:277
TRIBLT_ORDER triblt
Definition: orders.h:281
POLYGON2_ORDER polygon2
Definition: orders.h:283
PATBLT_ORDER patblt
Definition: orders.h:275
POLYLINE_ORDER polyline
Definition: orders.h:284
SCREENBLT_ORDER screenblt
Definition: orders.h:276
ELLIPSE_ORDER ellipse
Definition: orders.h:285
TEXT2_ORDER text2
Definition: orders.h:287
uint8 order_type
Definition: orders.h:271
static int processed(const type_t *type)
Definition: typegen.c:2254

Referenced by process_update_pdu(), and rdp5_process().

◆ process_patblt()

static void process_patblt ( STREAM  s,
PATBLT_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 226 of file orders.c.

227{
228 BRUSH brush;
229
230 if (present & 0x0001)
231 rdp_in_coord(s, &os->x, delta);
232
233 if (present & 0x0002)
234 rdp_in_coord(s, &os->y, delta);
235
236 if (present & 0x0004)
237 rdp_in_coord(s, &os->cx, delta);
238
239 if (present & 0x0008)
240 rdp_in_coord(s, &os->cy, delta);
241
242 if (present & 0x0010)
243 in_uint8(s, os->opcode);
244
245 if (present & 0x0020)
246 rdp_in_colour(s, &os->bgcolour);
247
248 if (present & 0x0040)
249 rdp_in_colour(s, &os->fgcolour);
250
251 rdp_parse_brush(s, &os->brush, present >> 7);
252
253 DEBUG(("PATBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,bs=%d,bg=0x%x,fg=0x%x)\n", os->opcode, os->x,
254 os->y, os->cx, os->cy, os->brush.style, os->bgcolour, os->fgcolour));
255
256 setup_brush(&brush, &os->brush);
257
258 ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,
259 &brush, os->bgcolour, os->fgcolour);
260}
#define ROP2_P(rop3)
Definition: constants.h:264
void ui_patblt(uint8 opcode, int x, int y, int cx, int cy, BRUSH *brush, int bgcolour, int fgcolour)
Definition: uimain.c:597
BRUSH brush
Definition: orders.h:78
sint16 y
Definition: orders.h:72
uint32 fgcolour
Definition: orders.h:77
sint16 cy
Definition: orders.h:74
uint32 bgcolour
Definition: orders.h:76
sint16 x
Definition: orders.h:71
uint8 opcode
Definition: orders.h:75
sint16 cx
Definition: orders.h:73

Referenced by process_orders().

◆ process_polygon()

static void process_polygon ( STREAM  s,
POLYGON_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 518 of file orders.c.

519{
520 int index, data, next;
521 uint8 flags = 0;
523
524 if (present & 0x01)
525 rdp_in_coord(s, &os->x, delta);
526
527 if (present & 0x02)
528 rdp_in_coord(s, &os->y, delta);
529
530 if (present & 0x04)
531 in_uint8(s, os->opcode);
532
533 if (present & 0x08)
534 in_uint8(s, os->fillmode);
535
536 if (present & 0x10)
537 rdp_in_colour(s, &os->fgcolour);
538
539 if (present & 0x20)
540 in_uint8(s, os->npoints);
541
542 if (present & 0x40)
543 {
544 in_uint8(s, os->datasize);
545 in_uint8a(s, os->data, os->datasize);
546 }
547
548 DEBUG(("POLYGON(x=%d,y=%d,op=0x%x,fm=%d,fg=0x%x,n=%d,sz=%d)\n",
549 os->x, os->y, os->opcode, os->fillmode, os->fgcolour, os->npoints, os->datasize));
550
551 DEBUG(("Data: "));
552
553 for (index = 0; index < os->datasize; index++)
554 DEBUG(("%02x ", os->data[index]));
555
556 DEBUG(("\n"));
557
558 if (os->opcode < 0x01 || os->opcode > 0x10)
559 {
560 error("bad ROP2 0x%x\n", os->opcode);
561 return;
562 }
563
564 points = (RD_POINT *) xmalloc((os->npoints + 1) * sizeof(RD_POINT));
565 memset(points, 0, (os->npoints + 1) * sizeof(RD_POINT));
566
567 points[0].x = os->x;
568 points[0].y = os->y;
569
570 index = 0;
571 data = ((os->npoints - 1) / 4) + 1;
572 for (next = 1; (next <= os->npoints) && (next < 256) && (data < os->datasize); next++)
573 {
574 if ((next - 1) % 4 == 0)
575 flags = os->data[index++];
576
577 if (~flags & 0x80)
578 points[next].x = parse_delta(os->data, &data);
579
580 if (~flags & 0x40)
581 points[next].y = parse_delta(os->data, &data);
582
583 flags <<= 2;
584 }
585
586 if (next - 1 == os->npoints)
587 ui_polygon(os->opcode - 1, os->fillmode, points, os->npoints + 1, NULL, 0,
588 os->fgcolour);
589 else
590 error("polygon parse error\n");
591
592 xfree(points);
593}
static int parse_delta(uint8 *buffer, int *offset)
Definition: orders.c:74
void ui_polygon(uint8 opcode, uint8 fillmode, RD_POINT *point, int npoints, BRUSH *brush, int bgcolour, int fgcolour)
Definition: uimain.c:671
struct _RD_POINT RD_POINT
GLsizei const GLfloat * points
Definition: glext.h:8112
if(dx< 0)
Definition: linetemp.h:194
static unsigned __int64 next
Definition: rand_nt.c:6
#define memset(x, y, z)
Definition: compat.h:39
sint16 x
Definition: orders.h:173
uint8 data[MAX_DATA]
Definition: orders.h:180
uint8 opcode
Definition: orders.h:175
uint8 datasize
Definition: orders.h:179
uint8 npoints
Definition: orders.h:178
uint32 fgcolour
Definition: orders.h:177
uint8 fillmode
Definition: orders.h:176
sint16 y
Definition: orders.h:174

Referenced by process_orders().

◆ process_polygon2()

static void process_polygon2 ( STREAM  s,
POLYGON2_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 597 of file orders.c.

598{
599 int index, data, next;
600 uint8 flags = 0;
602 BRUSH brush;
603
604 if (present & 0x0001)
605 rdp_in_coord(s, &os->x, delta);
606
607 if (present & 0x0002)
608 rdp_in_coord(s, &os->y, delta);
609
610 if (present & 0x0004)
611 in_uint8(s, os->opcode);
612
613 if (present & 0x0008)
614 in_uint8(s, os->fillmode);
615
616 if (present & 0x0010)
617 rdp_in_colour(s, &os->bgcolour);
618
619 if (present & 0x0020)
620 rdp_in_colour(s, &os->fgcolour);
621
622 rdp_parse_brush(s, &os->brush, present >> 6);
623
624 if (present & 0x0800)
625 in_uint8(s, os->npoints);
626
627 if (present & 0x1000)
628 {
629 in_uint8(s, os->datasize);
630 in_uint8a(s, os->data, os->datasize);
631 }
632
633 DEBUG(("POLYGON2(x=%d,y=%d,op=0x%x,fm=%d,bs=%d,bg=0x%x,fg=0x%x,n=%d,sz=%d)\n",
634 os->x, os->y, os->opcode, os->fillmode, os->brush.style, os->bgcolour, os->fgcolour,
635 os->npoints, os->datasize));
636
637 DEBUG(("Data: "));
638
639 for (index = 0; index < os->datasize; index++)
640 DEBUG(("%02x ", os->data[index]));
641
642 DEBUG(("\n"));
643
644 if (os->opcode < 0x01 || os->opcode > 0x10)
645 {
646 error("bad ROP2 0x%x\n", os->opcode);
647 return;
648 }
649
650 setup_brush(&brush, &os->brush);
651
652 points = (RD_POINT *) xmalloc((os->npoints + 1) * sizeof(RD_POINT));
653 memset(points, 0, (os->npoints + 1) * sizeof(RD_POINT));
654
655 points[0].x = os->x;
656 points[0].y = os->y;
657
658 index = 0;
659 data = ((os->npoints - 1) / 4) + 1;
660 for (next = 1; (next <= os->npoints) && (next < 256) && (data < os->datasize); next++)
661 {
662 if ((next - 1) % 4 == 0)
663 flags = os->data[index++];
664
665 if (~flags & 0x80)
666 points[next].x = parse_delta(os->data, &data);
667
668 if (~flags & 0x40)
669 points[next].y = parse_delta(os->data, &data);
670
671 flags <<= 2;
672 }
673
674 if (next - 1 == os->npoints)
675 ui_polygon(os->opcode - 1, os->fillmode, points, os->npoints + 1,
676 &brush, os->bgcolour, os->fgcolour);
677 else
678 error("polygon2 parse error\n");
679
680 xfree(points);
681}
sint16 y
Definition: orders.h:188
uint8 npoints
Definition: orders.h:194
uint8 fillmode
Definition: orders.h:190
uint32 bgcolour
Definition: orders.h:191
BRUSH brush
Definition: orders.h:193
uint8 opcode
Definition: orders.h:189
uint8 data[MAX_DATA]
Definition: orders.h:196
sint16 x
Definition: orders.h:187
uint8 datasize
Definition: orders.h:195
uint32 fgcolour
Definition: orders.h:192

Referenced by process_orders().

◆ process_polyline()

static void process_polyline ( STREAM  s,
POLYLINE_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 685 of file orders.c.

686{
687 int index, next, data;
688 uint8 flags = 0;
689 PEN pen;
691
692 if (present & 0x01)
693 rdp_in_coord(s, &os->x, delta);
694
695 if (present & 0x02)
696 rdp_in_coord(s, &os->y, delta);
697
698 if (present & 0x04)
699 in_uint8(s, os->opcode);
700
701 if (present & 0x10)
702 rdp_in_colour(s, &os->fgcolour);
703
704 if (present & 0x20)
705 in_uint8(s, os->lines);
706
707 if (present & 0x40)
708 {
709 in_uint8(s, os->datasize);
710 in_uint8a(s, os->data, os->datasize);
711 }
712
713 DEBUG(("POLYLINE(x=%d,y=%d,op=0x%x,fg=0x%x,n=%d,sz=%d)\n",
714 os->x, os->y, os->opcode, os->fgcolour, os->lines, os->datasize));
715
716 DEBUG(("Data: "));
717
718 for (index = 0; index < os->datasize; index++)
719 DEBUG(("%02x ", os->data[index]));
720
721 DEBUG(("\n"));
722
723 if (os->opcode < 0x01 || os->opcode > 0x10)
724 {
725 error("bad ROP2 0x%x\n", os->opcode);
726 return;
727 }
728
729 points = (RD_POINT *) xmalloc((os->lines + 1) * sizeof(RD_POINT));
730 memset(points, 0, (os->lines + 1) * sizeof(RD_POINT));
731
732 points[0].x = os->x;
733 points[0].y = os->y;
734 pen.style = pen.width = 0;
735 pen.colour = os->fgcolour;
736
737 index = 0;
738 data = ((os->lines - 1) / 4) + 1;
739 for (next = 1; (next <= os->lines) && (data < os->datasize); next++)
740 {
741 if ((next - 1) % 4 == 0)
742 flags = os->data[index++];
743
744 if (~flags & 0x80)
745 points[next].x = parse_delta(os->data, &data);
746
747 if (~flags & 0x40)
748 points[next].y = parse_delta(os->data, &data);
749
750 flags <<= 2;
751 }
752
753 if (next - 1 == os->lines)
754 ui_polyline(os->opcode - 1, points, os->lines + 1, &pen);
755 else
756 error("polyline parse error\n");
757
758 xfree(points);
759}
void ui_polyline(uint8 opcode, RD_POINT *points, int npoints, PEN *pen)
Definition: uimain.c:679
Definition: types.h:83
uint8 style
Definition: types.h:84
uint8 width
Definition: types.h:85
uint8 lines
Definition: orders.h:207
sint16 y
Definition: orders.h:204
sint16 x
Definition: orders.h:203
uint32 fgcolour
Definition: orders.h:206
uint8 datasize
Definition: orders.h:208
uint8 data[MAX_DATA]
Definition: orders.h:209
uint8 opcode
Definition: orders.h:205

Referenced by process_orders().

◆ process_raw_bmpcache()

static void process_raw_bmpcache ( STREAM  s)
static

Definition at line 918 of file orders.c.

919{
921 uint16 cache_idx, bufsize;
922 uint8 cache_id, width, height, bpp, Bpp;
923 uint8 *data, *inverted;
924 int y;
925
926 in_uint8(s, cache_id);
927 in_uint8s(s, 1); /* pad */
928 in_uint8(s, width);
929 in_uint8(s, height);
930 in_uint8(s, bpp);
931 Bpp = (bpp + 7) / 8;
933 in_uint16_le(s, cache_idx);
935
936 DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n", width, height, cache_id, cache_idx));
937 inverted = (uint8 *) xmalloc(width * height * Bpp);
938 for (y = 0; y < height; y++)
939 {
940 memcpy(&inverted[(height - y - 1) * (width * Bpp)], &data[y * (width * Bpp)],
941 width * Bpp);
942 }
943
944 bitmap = ui_create_bitmap(width, height, inverted);
945 xfree(inverted);
946 cache_put_bitmap(cache_id, cache_idx, bitmap);
947}

Referenced by process_secondary_order().

◆ process_rect()

static void process_rect ( STREAM  s,
RECT_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 334 of file orders.c.

335{
336 uint32 i;
337 if (present & 0x01)
338 rdp_in_coord(s, &os->x, delta);
339
340 if (present & 0x02)
341 rdp_in_coord(s, &os->y, delta);
342
343 if (present & 0x04)
344 rdp_in_coord(s, &os->cx, delta);
345
346 if (present & 0x08)
347 rdp_in_coord(s, &os->cy, delta);
348
349 if (present & 0x10)
350 {
351 in_uint8(s, i);
352 os->colour = (os->colour & 0xffffff00) | i;
353 }
354
355 if (present & 0x20)
356 {
357 in_uint8(s, i);
358 os->colour = (os->colour & 0xffff00ff) | (i << 8);
359 }
360
361 if (present & 0x40)
362 {
363 in_uint8(s, i);
364 os->colour = (os->colour & 0xff00ffff) | (i << 16);
365 }
366
367 DEBUG(("RECT(x=%d,y=%d,cx=%d,cy=%d,fg=0x%x)\n", os->x, os->y, os->cx, os->cy, os->colour));
368
369 ui_rect(os->x, os->y, os->cx, os->cy, os->colour);
370}
void ui_rect(int x, int y, int cx, int cy, int colour)
Definition: uimain.c:573
sint16 cx
Definition: orders.h:114
sint16 x
Definition: orders.h:112
sint16 cy
Definition: orders.h:115
uint32 colour
Definition: orders.h:116
sint16 y
Definition: orders.h:113

Referenced by process_orders().

◆ process_screenblt()

static void process_screenblt ( STREAM  s,
SCREENBLT_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 264 of file orders.c.

265{
266 if (present & 0x0001)
267 rdp_in_coord(s, &os->x, delta);
268
269 if (present & 0x0002)
270 rdp_in_coord(s, &os->y, delta);
271
272 if (present & 0x0004)
273 rdp_in_coord(s, &os->cx, delta);
274
275 if (present & 0x0008)
276 rdp_in_coord(s, &os->cy, delta);
277
278 if (present & 0x0010)
279 in_uint8(s, os->opcode);
280
281 if (present & 0x0020)
282 rdp_in_coord(s, &os->srcx, delta);
283
284 if (present & 0x0040)
285 rdp_in_coord(s, &os->srcy, delta);
286
287 DEBUG(("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n",
288 os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy));
289
290 ui_screenblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy, os->srcx, os->srcy);
291}
void ui_screenblt(uint8 opcode, int x, int y, int cx, int cy, int srcx, int srcy)
Definition: uimain.c:581
sint16 x
Definition: orders.h:85
sint16 cx
Definition: orders.h:87
sint16 srcx
Definition: orders.h:90
sint16 cy
Definition: orders.h:88
uint8 opcode
Definition: orders.h:89
sint16 srcy
Definition: orders.h:91
sint16 y
Definition: orders.h:86

Referenced by process_orders().

◆ process_secondary_order()

static void process_secondary_order ( STREAM  s)
static

Definition at line 1256 of file orders.c.

1257{
1258 /* The length isn't calculated correctly by the server.
1259 * For very compact orders the length becomes negative
1260 * so a signed integer must be used. */
1261 uint16 length;
1262 uint16 flags;
1263 uint8 type;
1264 uint8 *next_order;
1265
1267 in_uint16_le(s, flags); /* used by bmpcache2 */
1268 in_uint8(s, type);
1269
1270 next_order = s->p + (sint16) length + 7;
1271
1272 switch (type)
1273 {
1276 break;
1277
1278 case RDP_ORDER_COLCACHE:
1280 break;
1281
1282 case RDP_ORDER_BMPCACHE:
1284 break;
1285
1288 break;
1289
1291 process_bmpcache2(s, flags, False); /* uncompressed */
1292 break;
1293
1295 process_bmpcache2(s, flags, True); /* compressed */
1296 break;
1297
1300 break;
1301
1302 default:
1303 unimpl("secondary order %d\n", type);
1304 }
1305
1306 s->p = next_order;
1307}
static void process_bmpcache(STREAM s)
Definition: orders.c:951
static void process_bmpcache2(STREAM s, uint16 flags, RD_BOOL compressed)
Definition: orders.c:1008
static void process_brushcache(STREAM s, uint16 flags)
Definition: orders.c:1186
static void process_fontcache(STREAM s)
Definition: orders.c:1122
static void process_raw_bmpcache(STREAM s)
Definition: orders.c:918
static void process_colcache(STREAM s)
Definition: orders.c:1088
@ RDP_ORDER_RAW_BMPCACHE2
Definition: orders.h:53
@ RDP_ORDER_BRUSHCACHE
Definition: orders.h:55
@ RDP_ORDER_BMPCACHE2
Definition: orders.h:54
@ RDP_ORDER_COLCACHE
Definition: orders.h:50
@ RDP_ORDER_FONTCACHE
Definition: orders.h:52
@ RDP_ORDER_RAW_BMPCACHE
Definition: orders.h:49
@ RDP_ORDER_BMPCACHE
Definition: orders.h:51
#define False
Definition: types.h:25
signed short sint16
Definition: types.h:31
#define True
Definition: types.h:24
GLuint GLsizei GLsizei * length
Definition: glext.h:6040

Referenced by process_orders().

◆ process_text2()

static void process_text2 ( STREAM  s,
TEXT2_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 837 of file orders.c.

838{
839 int i;
840 BRUSH brush;
841
842 if (present & 0x000001)
843 in_uint8(s, os->font);
844
845 if (present & 0x000002)
846 in_uint8(s, os->flags);
847
848 if (present & 0x000004)
849 in_uint8(s, os->opcode);
850
851 if (present & 0x000008)
852 in_uint8(s, os->mixmode);
853
854 if (present & 0x000010)
855 rdp_in_colour(s, &os->fgcolour);
856
857 if (present & 0x000020)
858 rdp_in_colour(s, &os->bgcolour);
859
860 if (present & 0x000040)
861 in_uint16_le(s, os->clipleft);
862
863 if (present & 0x000080)
864 in_uint16_le(s, os->cliptop);
865
866 if (present & 0x000100)
868
869 if (present & 0x000200)
871
872 if (present & 0x000400)
873 in_uint16_le(s, os->boxleft);
874
875 if (present & 0x000800)
876 in_uint16_le(s, os->boxtop);
877
878 if (present & 0x001000)
879 in_uint16_le(s, os->boxright);
880
881 if (present & 0x002000)
883
884 rdp_parse_brush(s, &os->brush, present >> 14);
885
886 if (present & 0x080000)
887 in_uint16_le(s, os->x);
888
889 if (present & 0x100000)
890 in_uint16_le(s, os->y);
891
892 if (present & 0x200000)
893 {
894 in_uint8(s, os->length);
895 in_uint8a(s, os->text, os->length);
896 }
897
898 DEBUG(("TEXT2(x=%d,y=%d,cl=%d,ct=%d,cr=%d,cb=%d,bl=%d,bt=%d,br=%d,bb=%d,bs=%d,bg=0x%x,fg=0x%x,font=%d,fl=0x%x,op=0x%x,mix=%d,n=%d)\n", os->x, os->y, os->clipleft, os->cliptop, os->clipright, os->clipbottom, os->boxleft, os->boxtop, os->boxright, os->boxbottom, os->brush.style, os->bgcolour, os->fgcolour, os->font, os->flags, os->opcode, os->mixmode, os->length));
899
900 DEBUG(("Text: "));
901
902 for (i = 0; i < os->length; i++)
903 DEBUG(("%02x ", os->text[i]));
904
905 DEBUG(("\n"));
906
907 setup_brush(&brush, &os->brush);
908
909 ui_draw_text(os->font, os->flags, os->opcode - 1, os->mixmode, os->x, os->y,
910 os->clipleft, os->cliptop, os->clipright - os->clipleft,
911 os->clipbottom - os->cliptop, os->boxleft, os->boxtop,
912 os->boxright - os->boxleft, os->boxbottom - os->boxtop,
913 &brush, os->bgcolour, os->fgcolour, os->text, os->length);
914}
void ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode, int x, int y, int clipx, int clipy, int clipcx, int clipcy, int boxx, int boxy, int boxcx, int boxcy, BRUSH *brush, int bgcolour, int fgcolour, uint8 *text, uint8 length)
Definition: uimain.c:412
uint8 text[MAX_TEXT]
Definition: orders.h:264
uint8 flags
Definition: orders.h:247
sint16 boxbottom
Definition: orders.h:259
sint16 cliptop
Definition: orders.h:253
uint8 mixmode
Definition: orders.h:249
uint32 bgcolour
Definition: orders.h:250
sint16 boxleft
Definition: orders.h:256
sint16 clipleft
Definition: orders.h:252
uint32 fgcolour
Definition: orders.h:251
sint16 y
Definition: orders.h:262
sint16 x
Definition: orders.h:261
sint16 clipright
Definition: orders.h:254
sint16 clipbottom
Definition: orders.h:255
sint16 boxtop
Definition: orders.h:257
uint8 length
Definition: orders.h:263
uint8 opcode
Definition: orders.h:248
sint16 boxright
Definition: orders.h:258
uint8 font
Definition: orders.h:246
BRUSH brush
Definition: orders.h:260

Referenced by process_orders().

◆ process_triblt()

static void process_triblt ( STREAM  s,
TRIBLT_ORDER os,
uint32  present,
RD_BOOL  delta 
)
static

Definition at line 456 of file orders.c.

457{
459 BRUSH brush;
460
461 if (present & 0x000001)
462 {
463 in_uint8(s, os->cache_id);
464 in_uint8(s, os->colour_table);
465 }
466
467 if (present & 0x000002)
468 rdp_in_coord(s, &os->x, delta);
469
470 if (present & 0x000004)
471 rdp_in_coord(s, &os->y, delta);
472
473 if (present & 0x000008)
474 rdp_in_coord(s, &os->cx, delta);
475
476 if (present & 0x000010)
477 rdp_in_coord(s, &os->cy, delta);
478
479 if (present & 0x000020)
480 in_uint8(s, os->opcode);
481
482 if (present & 0x000040)
483 rdp_in_coord(s, &os->srcx, delta);
484
485 if (present & 0x000080)
486 rdp_in_coord(s, &os->srcy, delta);
487
488 if (present & 0x000100)
489 rdp_in_colour(s, &os->bgcolour);
490
491 if (present & 0x000200)
492 rdp_in_colour(s, &os->fgcolour);
493
494 rdp_parse_brush(s, &os->brush, present >> 10);
495
496 if (present & 0x008000)
498
499 if (present & 0x010000)
500 in_uint16_le(s, os->unknown);
501
502 DEBUG(("TRIBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
503 os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id, os->cache_idx,
504 os->brush.style, os->bgcolour, os->fgcolour));
505
507 if (bitmap == NULL)
508 return;
509
510 setup_brush(&brush, &os->brush);
511
512 ui_triblt(os->opcode, os->x, os->y, os->cx, os->cy,
513 bitmap, os->srcx, os->srcy, &brush, os->bgcolour, os->fgcolour);
514}
void ui_triblt(uint8 opcode, int x, int y, int cx, int cy, RD_HBITMAP src, int srcx, int srcy, BRUSH *brush, int bgcolour, int fgcolour)
sint16 srcx
Definition: orders.h:142
uint16 cache_idx
Definition: orders.h:147
BRUSH brush
Definition: orders.h:146
sint16 cx
Definition: orders.h:139
sint16 srcy
Definition: orders.h:143
uint8 opcode
Definition: orders.h:141
uint8 colour_table
Definition: orders.h:135
sint16 cy
Definition: orders.h:140
uint32 bgcolour
Definition: orders.h:144
uint8 cache_id
Definition: orders.h:136
sint16 y
Definition: orders.h:138
uint16 unknown
Definition: orders.h:148
uint32 fgcolour
Definition: orders.h:145
sint16 x
Definition: orders.h:137

Referenced by process_orders().

◆ rdp_in_colour()

static void rdp_in_colour ( STREAM  s,
uint32 colour 
)
static

Definition at line 92 of file orders.c.

93{
94 uint32 i;
95 in_uint8(s, i);
96 *colour = i;
97 in_uint8(s, i);
98 *colour |= i << 8;
99 in_uint8(s, i);
100 *colour |= i << 16;
101}

Referenced by process_ellipse(), process_ellipse2(), process_line(), process_patblt(), process_polygon(), process_polygon2(), process_polyline(), process_text2(), process_triblt(), and rdp_parse_pen().

◆ rdp_in_coord()

static void rdp_in_coord ( STREAM  s,
sint16 coord,
RD_BOOL  delta 
)
static

Definition at line 57 of file orders.c.

58{
59 sint8 change;
60
61 if (delta)
62 {
63 in_uint8(s, change);
64 *coord += change;
65 }
66 else
67 {
69 }
70}
signed char sint8
Definition: types.h:29
GLuint coord
Definition: glext.h:9511

Referenced by process_desksave(), process_destblt(), process_ellipse(), process_ellipse2(), process_line(), process_memblt(), process_patblt(), process_polygon(), process_polygon2(), process_polyline(), process_rect(), process_screenblt(), process_triblt(), and rdp_parse_bounds().

◆ rdp_in_present()

static void rdp_in_present ( STREAM  s,
uint32 present,
uint8  flags,
int  size 
)
static

Definition at line 29 of file orders.c.

30{
31 uint8 bits;
32 int i;
33
35 {
36 size--;
37 }
38
40 {
41 if (size < 2)
42 size = 0;
43 else
44 size -= 2;
45 }
46
47 *present = 0;
48 for (i = 0; i < size; i++)
49 {
50 in_uint8(s, bits);
51 *present |= bits << (i * 8);
52 }
53}
#define RDP_ORDER_TINY
Definition: orders.h:27
#define RDP_ORDER_SMALL
Definition: orders.h:26
GLenum GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * bits
Definition: glext.h:10929
#define bits
Definition: infblock.c:15

Referenced by process_orders().

◆ rdp_parse_bounds()

static RD_BOOL rdp_parse_bounds ( STREAM  s,
BOUNDS bounds 
)
static

Definition at line 105 of file orders.c.

106{
107 uint8 present;
108
109 in_uint8(s, present);
110
111 if (present & 1)
112 rdp_in_coord(s, &bounds->left, False);
113 else if (present & 16)
114 rdp_in_coord(s, &bounds->left, True);
115
116 if (present & 2)
117 rdp_in_coord(s, &bounds->top, False);
118 else if (present & 32)
119 rdp_in_coord(s, &bounds->top, True);
120
121 if (present & 4)
122 rdp_in_coord(s, &bounds->right, False);
123 else if (present & 64)
124 rdp_in_coord(s, &bounds->right, True);
125
126 if (present & 8)
127 rdp_in_coord(s, &bounds->bottom, False);
128 else if (present & 128)
129 rdp_in_coord(s, &bounds->bottom, True);
130
131 return s_check(s);
132}
#define s_check(s)
Definition: parse.h:42

Referenced by process_orders().

◆ rdp_parse_brush()

static RD_BOOL rdp_parse_brush ( STREAM  s,
BRUSH brush,
uint32  present 
)
static

Definition at line 179 of file orders.c.

180{
181 if (present & 1)
182 in_uint8(s, brush->xorigin);
183
184 if (present & 2)
185 in_uint8(s, brush->yorigin);
186
187 if (present & 4)
188 in_uint8(s, brush->style);
189
190 if (present & 8)
191 in_uint8(s, brush->pattern[0]);
192
193 if (present & 16)
194 in_uint8a(s, &brush->pattern[1], 7);
195
196 return s_check(s);
197}

Referenced by process_ellipse2(), process_patblt(), process_polygon2(), process_text2(), and process_triblt().

◆ rdp_parse_pen()

static RD_BOOL rdp_parse_pen ( STREAM  s,
PEN pen,
uint32  present 
)
static

Definition at line 136 of file orders.c.

137{
138 if (present & 1)
139 in_uint8(s, pen->style);
140
141 if (present & 2)
142 in_uint8(s, pen->width);
143
144 if (present & 4)
145 rdp_in_colour(s, &pen->colour);
146
147 return s_check(s);
148}

Referenced by process_line().

◆ reset_order_state()

void reset_order_state ( void  )

Definition at line 1454 of file orders.c.

Referenced by process_demand_active().

◆ setup_brush()

static void setup_brush ( BRUSH out_brush,
BRUSH in_brush 
)
static

Definition at line 151 of file orders.c.

152{
153 BRUSHDATA *brush_data;
154 uint8 cache_idx;
155 uint8 colour_code;
156
157 memcpy(out_brush, in_brush, sizeof(BRUSH));
158 if (out_brush->style & 0x80)
159 {
160 colour_code = out_brush->style & 0x0f;
161 cache_idx = out_brush->pattern[0];
162 brush_data = cache_get_brush_data(colour_code, cache_idx);
163 if ((brush_data == NULL) || (brush_data->data == NULL))
164 {
165 error("error getting brush data, style %x\n", out_brush->style);
166 out_brush->bd = NULL;
167 memset(out_brush->pattern, 0, 8);
168 }
169 else
170 {
171 out_brush->bd = brush_data;
172 }
173 out_brush->style = 3;
174 }
175}
BRUSHDATA * cache_get_brush_data(uint8 colour_code, uint8 idx)
Definition: cache.c:441

Referenced by process_ellipse2(), process_patblt(), process_polygon2(), process_text2(), and process_triblt().

Variable Documentation

◆ g_next_packet

uint8* g_next_packet
extern

Definition at line 45 of file rdp.c.

Referenced by process_orders().

◆ g_order_state

RDP_ORDER_STATE g_order_state
static

Definition at line 24 of file orders.c.

Referenced by process_orders(), and reset_order_state().

◆ g_rdp_version

RDP_VERSION g_rdp_version
extern

Definition at line 74 of file uimain.c.

Referenced by process_bmpcache().