← Back to branch summary

~ubuntu-branches/ubuntu/raring/freerdp/raring-proposed

« back to all changes in this revision

Viewing changes to libfreerdp-core/orders.c

  • Committer: Package Import Robot
  • Author(s): Martin Pitt, Jeremy Bicha, Jean-Louis Dupond, Martin Pitt
  • Date: 2012-01-31 10:02:14 UTC
  • mfrom: (1.1.6)
  • Revision ID: package-import@ubuntu.com-20120131100214-jaok3uwvni7sqxth
Tags: 1.0.0-0git1
http://bugs.debian.org/647498
Upload current Debian packaging git to get this rolling for precise.

[ Jeremy Bicha ]
* New upstream release. Closes: #647498.
* Updated symbols and bumped soname
* debian/control:
  - Added new build dependencies
  - Bump Standards-Version to 3.9.2
* debian/source/format: Set to 3.0 (quilt)
* debian/rules: Turn on strict symbols checking
* debian/watch: Watch github

[ Jean-Louis Dupond ]
* debian/control: Updated homepage
* debian/copyright: Reflect upstream switch to the Apache license

[ Martin Pitt ]
* debian/libfreerdp0.symbols: Fix version number, should
  be 1.0~beta5, not 1.0-beta5.
* debian/control: Add libavcodec-dev build dependency, upstream build system
  checks for that. Thanks Jean-Louis Dupond!

Show diffs side-by-side

added added

removed removed

Lines of Context:
libfreerdp-core/orders.c
 
1
/**
 
2
 * FreeRDP: A Remote Desktop Protocol Client
 
3
 * Drawing Orders
 
4
 *
 
5
 * Copyright 2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 
6
 *
 
7
 * Licensed under the Apache License, Version 2.0 (the "License");
 
8
 * you may not use this file except in compliance with the License.
 
9
 * You may obtain a copy of the License at
 
10
 *
 
11
 *     http://www.apache.org/licenses/LICENSE-2.0
 
12
 *
 
13
 * Unless required by applicable law or agreed to in writing, software
 
14
 * distributed under the License is distributed on an "AS IS" BASIS,
 
15
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
16
 * See the License for the specific language governing permissions and
 
17
 * limitations under the License.
 
18
 */
 
19
 
 
20
#include "window.h"
 
21
#include <freerdp/api.h>
 
22
#include <freerdp/graphics.h>
 
23
#include <freerdp/codec/bitmap.h>
 
24
 
 
25
#include "orders.h"
 
26
 
 
27
#ifdef WITH_DEBUG_ORDERS
 
28
 
 
29
static const char* const PRIMARY_DRAWING_ORDER_STRINGS[] =
 
30
{
 
31
        "DstBlt",
 
32
        "PatBlt",
 
33
        "ScrBlt",
 
34
        "", "", "", "",
 
35
        "DrawNineGrid",
 
36
        "MultiDrawNineGrid",
 
37
        "LineTo",
 
38
        "OpaqueRect",
 
39
        "SaveBitmap",
 
40
        "",
 
41
        "MemBlt",
 
42
        "Mem3Blt",
 
43
        "MultiDstBlt",
 
44
        "MultiPatBlt",
 
45
        "MultiScrBlt",
 
46
        "MultiOpaqueRect",
 
47
        "FastIndex",
 
48
        "PolygonSC",
 
49
        "PolygonCB",
 
50
        "Polyline",
 
51
        "",
 
52
        "FastGlyph",
 
53
        "EllipseSC",
 
54
        "EllipseCB",
 
55
        "GlyphIndex"
 
56
};
 
57
 
 
58
#define PRIMARY_DRAWING_ORDER_COUNT     (sizeof(PRIMARY_DRAWING_ORDER_STRINGS) / sizeof(PRIMARY_DRAWING_ORDER_STRINGS[0]))
 
59
 
 
60
static const char* const SECONDARY_DRAWING_ORDER_STRINGS[] =
 
61
{
 
62
        "Cache Bitmap",
 
63
        "Cache Color Table",
 
64
        "Cache Bitmap (Compressed)",
 
65
        "Cache Glyph",
 
66
        "Cache Bitmap V2",
 
67
        "Cache Bitmap V2 (Compressed)",
 
68
        "",
 
69
        "Cache Brush",
 
70
        "Cache Bitmap V3"
 
71
};
 
72
 
 
73
#define SECONDARY_DRAWING_ORDER_COUNT   (sizeof(SECONDARY_DRAWING_ORDER_STRINGS) / sizeof(SECONDARY_DRAWING_ORDER_STRINGS[0]))
 
74
 
 
75
static const char* const ALTSEC_DRAWING_ORDER_STRINGS[] =
 
76
{
 
77
        "Switch Surface",
 
78
        "Create Offscreen Bitmap",
 
79
        "Stream Bitmap First",
 
80
        "Stream Bitmap Next",
 
81
        "Create NineGrid Bitmap",
 
82
        "Draw GDI+ First",
 
83
        "Draw GDI+ Next",
 
84
        "Draw GDI+ End",
 
85
        "Draw GDI+ Cache First",
 
86
        "Draw GDI+ Cache Next",
 
87
        "Draw GDI+ Cache End",
 
88
        "Windowing",
 
89
        "Desktop Composition",
 
90
        "Frame Marker"
 
91
};
 
92
 
 
93
#define ALTSEC_DRAWING_ORDER_COUNT      (sizeof(ALTSEC_DRAWING_ORDER_STRINGS) / sizeof(ALTSEC_DRAWING_ORDER_STRINGS[0]))
 
94
 
 
95
#endif /* WITH_DEBUG_ORDERS */
 
96
 
 
97
static const uint8 PRIMARY_DRAWING_ORDER_FIELD_BYTES[] =
 
98
{
 
99
        DSTBLT_ORDER_FIELD_BYTES,
 
100
        PATBLT_ORDER_FIELD_BYTES,
 
101
        SCRBLT_ORDER_FIELD_BYTES,
 
102
        0, 0, 0, 0,
 
103
        DRAW_NINE_GRID_ORDER_FIELD_BYTES,
 
104
        MULTI_DRAW_NINE_GRID_ORDER_FIELD_BYTES,
 
105
        LINE_TO_ORDER_FIELD_BYTES,
 
106
        OPAQUE_RECT_ORDER_FIELD_BYTES,
 
107
        SAVE_BITMAP_ORDER_FIELD_BYTES,
 
108
        0,
 
109
        MEMBLT_ORDER_FIELD_BYTES,
 
110
        MEM3BLT_ORDER_FIELD_BYTES,
 
111
        MULTI_DSTBLT_ORDER_FIELD_BYTES,
 
112
        MULTI_PATBLT_ORDER_FIELD_BYTES,
 
113
        MULTI_SCRBLT_ORDER_FIELD_BYTES,
 
114
        MULTI_OPAQUE_RECT_ORDER_FIELD_BYTES,
 
115
        FAST_INDEX_ORDER_FIELD_BYTES,
 
116
        POLYGON_SC_ORDER_FIELD_BYTES,
 
117
        POLYGON_CB_ORDER_FIELD_BYTES,
 
118
        POLYLINE_ORDER_FIELD_BYTES,
 
119
        0,
 
120
        FAST_GLYPH_ORDER_FIELD_BYTES,
 
121
        ELLIPSE_SC_ORDER_FIELD_BYTES,
 
122
        ELLIPSE_CB_ORDER_FIELD_BYTES,
 
123
        GLYPH_INDEX_ORDER_FIELD_BYTES
 
124
};
 
125
 
 
126
static const uint8 CBR2_BPP[] =
 
127
{
 
128
                0, 0, 0, 8, 16, 24, 32
 
129
};
 
130
 
 
131
static const uint8 CBR23_BPP[] =
 
132
{
 
133
                0, 0, 0, 8, 16, 24, 32
 
134
};
 
135
 
 
136
static const uint8 BMF_BPP[] =
 
137
{
 
138
                0, 1, 0, 8, 16, 24, 32
 
139
};
 
140
 
 
141
INLINE void update_read_coord(STREAM* s, sint32* coord, boolean delta)
 
142
{
 
143
        sint8 lsi8;
 
144
        sint16 lsi16;
 
145
 
 
146
        if (delta)
 
147
        {
 
148
                stream_read_uint8(s, lsi8);
 
149
                *coord += lsi8;
 
150
        }
 
151
        else
 
152
        {
 
153
                stream_read_uint16(s, lsi16);
 
154
                *coord = lsi16;
 
155
        }
 
156
}
 
157
 
 
158
INLINE void update_read_color(STREAM* s, uint32* color)
 
159
{
 
160
        uint8 byte;
 
161
 
 
162
        stream_read_uint8(s, byte);
 
163
        *color = byte;
 
164
        stream_read_uint8(s, byte);
 
165
        *color |= (byte << 8);
 
166
        stream_read_uint8(s, byte);
 
167
        *color |= (byte << 16);
 
168
}
 
169
 
 
170
INLINE void update_read_colorref(STREAM* s, uint32* color)
 
171
{
 
172
        uint8 byte;
 
173
 
 
174
        stream_read_uint8(s, byte);
 
175
        *color = byte;
 
176
        stream_read_uint8(s, byte);
 
177
        *color |= (byte << 8);
 
178
        stream_read_uint8(s, byte);
 
179
        *color |= (byte << 16);
 
180
        stream_seek_uint8(s);
 
181
}
 
182
 
 
183
INLINE void update_read_color_quad(STREAM* s, uint32* color)
 
184
{
 
185
        uint8 byte;
 
186
 
 
187
        stream_read_uint8(s, byte);
 
188
        *color = (byte << 16);
 
189
        stream_read_uint8(s, byte);
 
190
        *color |= (byte << 8);
 
191
        stream_read_uint8(s, byte);
 
192
        *color |= byte;
 
193
        stream_seek_uint8(s);
 
194
}
 
195
 
 
196
INLINE void update_read_2byte_unsigned(STREAM* s, uint32* value)
 
197
{
 
198
        uint8 byte;
 
199
 
 
200
        stream_read_uint8(s, byte);
 
201
 
 
202
        if (byte & 0x80)
 
203
        {
 
204
                *value = (byte & 0x7F) << 8;
 
205
                stream_read_uint8(s, byte);
 
206
                *value |= byte;
 
207
        }
 
208
        else
 
209
        {
 
210
                *value = (byte & 0x7F);
 
211
        }
 
212
}
 
213
 
 
214
INLINE void update_read_2byte_signed(STREAM* s, sint32* value)
 
215
{
 
216
        uint8 byte;
 
217
        boolean negative;
 
218
 
 
219
        stream_read_uint8(s, byte);
 
220
 
 
221
        negative = (byte & 0x40) ? true : false;
 
222
 
 
223
        *value = (byte & 0x3F);
 
224
 
 
225
        if (byte & 0x80)
 
226
        {
 
227
                stream_read_uint8(s, byte);
 
228
                *value = (*value << 8) | byte;
 
229
        }
 
230
 
 
231
        if (negative)
 
232
                *value *= -1;
 
233
}
 
234
 
 
235
INLINE void update_read_4byte_unsigned(STREAM* s, uint32* value)
 
236
{
 
237
        uint8 byte;
 
238
        uint8 count;
 
239
 
 
240
        stream_read_uint8(s, byte);
 
241
 
 
242
        count = (byte & 0xC0) >> 6;
 
243
 
 
244
        switch (count)
 
245
        {
 
246
                case 0:
 
247
                        *value = (byte & 0x3F);
 
248
                        break;
 
249
 
 
250
                case 1:
 
251
                        *value = (byte & 0x3F) << 8;
 
252
                        stream_read_uint8(s, byte);
 
253
                        *value |= byte;
 
254
                        break;
 
255
 
 
256
                case 2:
 
257
                        *value = (byte & 0x3F) << 16;
 
258
                        stream_read_uint8(s, byte);
 
259
                        *value |= (byte << 8);
 
260
                        stream_read_uint8(s, byte);
 
261
                        *value |= byte;
 
262
                        break;
 
263
 
 
264
                case 3:
 
265
                        *value = (byte & 0x3F) << 24;
 
266
                        stream_read_uint8(s, byte);
 
267
                        *value |= (byte << 16);
 
268
                        stream_read_uint8(s, byte);
 
269
                        *value |= (byte << 8);
 
270
                        stream_read_uint8(s, byte);
 
271
                        *value |= byte;
 
272
                        break;
 
273
 
 
274
                default:
 
275
                        break;
 
276
        }
 
277
}
 
278
 
 
279
INLINE void update_read_delta(STREAM* s, sint32* value)
 
280
{
 
281
        uint8 byte;
 
282
 
 
283
        stream_read_uint8(s, byte);
 
284
 
 
285
        if (byte & 0x40)
 
286
                *value = (byte | ~0x3F);
 
287
        else
 
288
                *value = (byte & 0x3F);
 
289
 
 
290
        if (byte & 0x80)
 
291
        {
 
292
                stream_read_uint8(s, byte);
 
293
                *value = (*value << 8) | byte;
 
294
        }
 
295
}
 
296
 
 
297
INLINE void update_read_glyph_delta(STREAM* s, uint16* value)
 
298
{
 
299
        uint8 byte;
 
300
 
 
301
        stream_read_uint8(s, byte);
 
302
 
 
303
        if (byte == 0x80)
 
304
                stream_read_uint16(s, *value);
 
305
        else
 
306
                *value = (byte & 0x3F);
 
307
}
 
308
 
 
309
INLINE void update_seek_glyph_delta(STREAM* s)
 
310
{
 
311
        uint8 byte;
 
312
 
 
313
        stream_read_uint8(s, byte);
 
314
 
 
315
        if (byte & 0x80)
 
316
                stream_seek_uint8(s);
 
317
}
 
318
 
 
319
INLINE void update_read_brush(STREAM* s, rdpBrush* brush, uint8 fieldFlags)
 
320
{
 
321
        if (fieldFlags & ORDER_FIELD_01)
 
322
                stream_read_uint8(s, brush->x);
 
323
 
 
324
        if (fieldFlags & ORDER_FIELD_02)
 
325
                stream_read_uint8(s, brush->y);
 
326
 
 
327
        if (fieldFlags & ORDER_FIELD_03)
 
328
                stream_read_uint8(s, brush->style);
 
329
 
 
330
        if (fieldFlags & ORDER_FIELD_04)
 
331
                stream_read_uint8(s, brush->hatch);
 
332
 
 
333
        if (brush->style & CACHED_BRUSH)
 
334
        {
 
335
                brush->index = brush->hatch;
 
336
 
 
337
                brush->bpp = BMF_BPP[brush->style & 0x0F];
 
338
 
 
339
                if (brush->bpp == 0)
 
340
                        brush->bpp = 1;
 
341
        }
 
342
 
 
343
        if (fieldFlags & ORDER_FIELD_05)
 
344
        {
 
345
                brush->data = (uint8*) brush->p8x8;
 
346
                stream_read_uint8(s, brush->data[7]);
 
347
                stream_read_uint8(s, brush->data[6]);
 
348
                stream_read_uint8(s, brush->data[5]);
 
349
                stream_read_uint8(s, brush->data[4]);
 
350
                stream_read_uint8(s, brush->data[3]);
 
351
                stream_read_uint8(s, brush->data[2]);
 
352
                stream_read_uint8(s, brush->data[1]);
 
353
                brush->data[0] = brush->hatch;
 
354
        }
 
355
}
 
356
 
 
357
INLINE void update_read_delta_rects(STREAM* s, DELTA_RECT* rectangles, int number)
 
358
{
 
359
        int i;
 
360
        uint8 flags = 0;
 
361
        uint8* zeroBits;
 
362
        int zeroBitsSize;
 
363
 
 
364
        if (number > 45)
 
365
                number = 45;
 
366
 
 
367
        zeroBitsSize = ((number + 1) / 2);
 
368
 
 
369
        stream_get_mark(s, zeroBits);
 
370
        stream_seek(s, zeroBitsSize);
 
371
 
 
372
        memset(rectangles, 0, sizeof(DELTA_RECT) * (number + 1));
 
373
 
 
374
        for (i = 1; i < number + 1; i++)
 
375
        {
 
376
                if ((i - 1) % 2 == 0)
 
377
                        flags = zeroBits[(i - 1) / 2];
 
378
 
 
379
                if (~flags & 0x80)
 
380
                        update_read_delta(s, &rectangles[i].left);
 
381
 
 
382
                if (~flags & 0x40)
 
383
                        update_read_delta(s, &rectangles[i].top);
 
384
 
 
385
                if (~flags & 0x20)
 
386
                        update_read_delta(s, &rectangles[i].width);
 
387
                else
 
388
                        rectangles[i].width = rectangles[i - 1].width;
 
389
 
 
390
                if (~flags & 0x10)
 
391
                        update_read_delta(s, &rectangles[i].height);
 
392
                else
 
393
                        rectangles[i].height = rectangles[i - 1].height;
 
394
 
 
395
                rectangles[i].left = rectangles[i].left + rectangles[i - 1].left;
 
396
                rectangles[i].top = rectangles[i].top + rectangles[i - 1].top;
 
397
 
 
398
                flags <<= 4;
 
399
        }
 
400
}
 
401
 
 
402
INLINE void update_read_delta_points(STREAM* s, DELTA_POINT* points, int number, sint16 x, sint16 y)
 
403
{
 
404
        int i;
 
405
        uint8 flags = 0;
 
406
        uint8* zeroBits;
 
407
        int zeroBitsSize;
 
408
 
 
409
        zeroBitsSize = ((number + 3) / 4);
 
410
 
 
411
        stream_get_mark(s, zeroBits);
 
412
        stream_seek(s, zeroBitsSize);
 
413
 
 
414
        memset(points, 0, sizeof(DELTA_POINT) * number);
 
415
 
 
416
        for (i = 0; i < number; i++)
 
417
        {
 
418
                if (i % 4 == 0)
 
419
                        flags = zeroBits[i / 4];
 
420
 
 
421
                if (~flags & 0x80)
 
422
                        update_read_delta(s, &points[i].x);
 
423
 
 
424
                if (~flags & 0x40)
 
425
                        update_read_delta(s, &points[i].y);
 
426
 
 
427
                flags <<= 2;
 
428
        }
 
429
}
 
430
 
 
431
/* Primary Drawing Orders */
 
432
 
 
433
void update_read_dstblt_order(STREAM* s, ORDER_INFO* orderInfo, DSTBLT_ORDER* dstblt)
 
434
{
 
435
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
436
                update_read_coord(s, &dstblt->nLeftRect, orderInfo->deltaCoordinates);
 
437
 
 
438
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
439
                update_read_coord(s, &dstblt->nTopRect, orderInfo->deltaCoordinates);
 
440
 
 
441
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
442
                update_read_coord(s, &dstblt->nWidth, orderInfo->deltaCoordinates);
 
443
 
 
444
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
445
                update_read_coord(s, &dstblt->nHeight, orderInfo->deltaCoordinates);
 
446
 
 
447
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
448
                stream_read_uint8(s, dstblt->bRop);
 
449
}
 
450
 
 
451
void update_read_patblt_order(STREAM* s, ORDER_INFO* orderInfo, PATBLT_ORDER* patblt)
 
452
{
 
453
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
454
                update_read_coord(s, &patblt->nLeftRect, orderInfo->deltaCoordinates);
 
455
 
 
456
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
457
                update_read_coord(s, &patblt->nTopRect, orderInfo->deltaCoordinates);
 
458
 
 
459
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
460
                update_read_coord(s, &patblt->nWidth, orderInfo->deltaCoordinates);
 
461
 
 
462
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
463
                update_read_coord(s, &patblt->nHeight, orderInfo->deltaCoordinates);
 
464
 
 
465
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
466
                stream_read_uint8(s, patblt->bRop);
 
467
 
 
468
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
469
                update_read_color(s, &patblt->backColor);
 
470
 
 
471
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
472
                update_read_color(s, &patblt->foreColor);
 
473
 
 
474
        update_read_brush(s, &patblt->brush, orderInfo->fieldFlags >> 7);
 
475
}
 
476
 
 
477
void update_read_scrblt_order(STREAM* s, ORDER_INFO* orderInfo, SCRBLT_ORDER* scrblt)
 
478
{
 
479
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
480
                update_read_coord(s, &scrblt->nLeftRect, orderInfo->deltaCoordinates);
 
481
 
 
482
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
483
                update_read_coord(s, &scrblt->nTopRect, orderInfo->deltaCoordinates);
 
484
 
 
485
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
486
                update_read_coord(s, &scrblt->nWidth, orderInfo->deltaCoordinates);
 
487
 
 
488
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
489
                update_read_coord(s, &scrblt->nHeight, orderInfo->deltaCoordinates);
 
490
 
 
491
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
492
                stream_read_uint8(s, scrblt->bRop);
 
493
 
 
494
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
495
                update_read_coord(s, &scrblt->nXSrc, orderInfo->deltaCoordinates);
 
496
 
 
497
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
498
                update_read_coord(s, &scrblt->nYSrc, orderInfo->deltaCoordinates);
 
499
}
 
500
 
 
501
void update_read_opaque_rect_order(STREAM* s, ORDER_INFO* orderInfo, OPAQUE_RECT_ORDER* opaque_rect)
 
502
{
 
503
        uint8 byte;
 
504
 
 
505
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
506
                update_read_coord(s, &opaque_rect->nLeftRect, orderInfo->deltaCoordinates);
 
507
 
 
508
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
509
                update_read_coord(s, &opaque_rect->nTopRect, orderInfo->deltaCoordinates);
 
510
 
 
511
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
512
                update_read_coord(s, &opaque_rect->nWidth, orderInfo->deltaCoordinates);
 
513
 
 
514
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
515
                update_read_coord(s, &opaque_rect->nHeight, orderInfo->deltaCoordinates);
 
516
 
 
517
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
518
        {
 
519
                stream_read_uint8(s, byte);
 
520
                opaque_rect->color = (opaque_rect->color & 0xFFFFFF00) | byte;
 
521
        }
 
522
 
 
523
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
524
        {
 
525
                stream_read_uint8(s, byte);
 
526
                opaque_rect->color = (opaque_rect->color & 0xFFFF00FF) | (byte << 8);
 
527
        }
 
528
 
 
529
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
530
        {
 
531
                stream_read_uint8(s, byte);
 
532
                opaque_rect->color = (opaque_rect->color & 0xFF00FFFF) | (byte << 16);
 
533
        }
 
534
}
 
535
 
 
536
void update_read_draw_nine_grid_order(STREAM* s, ORDER_INFO* orderInfo, DRAW_NINE_GRID_ORDER* draw_nine_grid)
 
537
{
 
538
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
539
                update_read_coord(s, &draw_nine_grid->srcLeft, orderInfo->deltaCoordinates);
 
540
 
 
541
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
542
                update_read_coord(s, &draw_nine_grid->srcTop, orderInfo->deltaCoordinates);
 
543
 
 
544
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
545
                update_read_coord(s, &draw_nine_grid->srcRight, orderInfo->deltaCoordinates);
 
546
 
 
547
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
548
                update_read_coord(s, &draw_nine_grid->srcBottom, orderInfo->deltaCoordinates);
 
549
 
 
550
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
551
                stream_read_uint16(s, draw_nine_grid->bitmapId);
 
552
}
 
553
 
 
554
void update_read_multi_dstblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_DSTBLT_ORDER* multi_dstblt)
 
555
{
 
556
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
557
                update_read_coord(s, &multi_dstblt->nLeftRect, orderInfo->deltaCoordinates);
 
558
 
 
559
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
560
                update_read_coord(s, &multi_dstblt->nTopRect, orderInfo->deltaCoordinates);
 
561
 
 
562
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
563
                update_read_coord(s, &multi_dstblt->nWidth, orderInfo->deltaCoordinates);
 
564
 
 
565
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
566
                update_read_coord(s, &multi_dstblt->nHeight, orderInfo->deltaCoordinates);
 
567
 
 
568
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
569
                stream_read_uint8(s, multi_dstblt->bRop);
 
570
 
 
571
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
572
                stream_read_uint8(s, multi_dstblt->numRectangles);
 
573
 
 
574
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
575
        {
 
576
                stream_read_uint16(s, multi_dstblt->cbData);
 
577
                update_read_delta_rects(s, multi_dstblt->rectangles, multi_dstblt->numRectangles);
 
578
        }
 
579
}
 
580
 
 
581
void update_read_multi_patblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_PATBLT_ORDER* multi_patblt)
 
582
{
 
583
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
584
                update_read_coord(s, &multi_patblt->nLeftRect, orderInfo->deltaCoordinates);
 
585
 
 
586
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
587
                update_read_coord(s, &multi_patblt->nTopRect, orderInfo->deltaCoordinates);
 
588
 
 
589
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
590
                update_read_coord(s, &multi_patblt->nWidth, orderInfo->deltaCoordinates);
 
591
 
 
592
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
593
                update_read_coord(s, &multi_patblt->nHeight, orderInfo->deltaCoordinates);
 
594
 
 
595
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
596
                stream_read_uint8(s, multi_patblt->bRop);
 
597
 
 
598
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
599
                update_read_color(s, &multi_patblt->backColor);
 
600
 
 
601
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
602
                update_read_color(s, &multi_patblt->foreColor);
 
603
 
 
604
        update_read_brush(s, &multi_patblt->brush, orderInfo->fieldFlags >> 7);
 
605
 
 
606
        if (orderInfo->fieldFlags & ORDER_FIELD_13)
 
607
                stream_read_uint8(s, multi_patblt->numRectangles);
 
608
 
 
609
        if (orderInfo->fieldFlags & ORDER_FIELD_14)
 
610
        {
 
611
                stream_read_uint16(s, multi_patblt->cbData);
 
612
                update_read_delta_rects(s, multi_patblt->rectangles, multi_patblt->numRectangles);
 
613
        }
 
614
}
 
615
 
 
616
void update_read_multi_scrblt_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_SCRBLT_ORDER* multi_scrblt)
 
617
{
 
618
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
619
                update_read_coord(s, &multi_scrblt->nLeftRect, orderInfo->deltaCoordinates);
 
620
 
 
621
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
622
                update_read_coord(s, &multi_scrblt->nTopRect, orderInfo->deltaCoordinates);
 
623
 
 
624
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
625
                update_read_coord(s, &multi_scrblt->nWidth, orderInfo->deltaCoordinates);
 
626
 
 
627
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
628
                update_read_coord(s, &multi_scrblt->nHeight, orderInfo->deltaCoordinates);
 
629
 
 
630
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
631
                stream_read_uint8(s, multi_scrblt->bRop);
 
632
 
 
633
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
634
                update_read_coord(s, &multi_scrblt->nXSrc, orderInfo->deltaCoordinates);
 
635
 
 
636
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
637
                update_read_coord(s, &multi_scrblt->nYSrc, orderInfo->deltaCoordinates);
 
638
 
 
639
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
640
                stream_read_uint8(s, multi_scrblt->numRectangles);
 
641
 
 
642
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
643
        {
 
644
                stream_read_uint16(s, multi_scrblt->cbData);
 
645
                update_read_delta_rects(s, multi_scrblt->rectangles, multi_scrblt->numRectangles);
 
646
        }
 
647
}
 
648
 
 
649
void update_read_multi_opaque_rect_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
 
650
{
 
651
        uint8 byte;
 
652
 
 
653
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
654
                update_read_coord(s, &multi_opaque_rect->nLeftRect, orderInfo->deltaCoordinates);
 
655
 
 
656
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
657
                update_read_coord(s, &multi_opaque_rect->nTopRect, orderInfo->deltaCoordinates);
 
658
 
 
659
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
660
                update_read_coord(s, &multi_opaque_rect->nWidth, orderInfo->deltaCoordinates);
 
661
 
 
662
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
663
                update_read_coord(s, &multi_opaque_rect->nHeight, orderInfo->deltaCoordinates);
 
664
 
 
665
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
666
        {
 
667
                stream_read_uint8(s, byte);
 
668
                multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFFFF00) | byte;
 
669
        }
 
670
 
 
671
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
672
        {
 
673
                stream_read_uint8(s, byte);
 
674
                multi_opaque_rect->color = (multi_opaque_rect->color & 0xFFFF00FF) | (byte << 8);
 
675
        }
 
676
 
 
677
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
678
        {
 
679
                stream_read_uint8(s, byte);
 
680
                multi_opaque_rect->color = (multi_opaque_rect->color & 0xFF00FFFF) | (byte << 16);
 
681
        }
 
682
 
 
683
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
684
                stream_read_uint8(s, multi_opaque_rect->numRectangles);
 
685
 
 
686
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
687
        {
 
688
                stream_read_uint16(s, multi_opaque_rect->cbData);
 
689
                update_read_delta_rects(s, multi_opaque_rect->rectangles, multi_opaque_rect->numRectangles);
 
690
        }
 
691
}
 
692
 
 
693
void update_read_multi_draw_nine_grid_order(STREAM* s, ORDER_INFO* orderInfo, MULTI_DRAW_NINE_GRID_ORDER* multi_draw_nine_grid)
 
694
{
 
695
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
696
                update_read_coord(s, &multi_draw_nine_grid->srcLeft, orderInfo->deltaCoordinates);
 
697
 
 
698
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
699
                update_read_coord(s, &multi_draw_nine_grid->srcTop, orderInfo->deltaCoordinates);
 
700
 
 
701
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
702
                update_read_coord(s, &multi_draw_nine_grid->srcRight, orderInfo->deltaCoordinates);
 
703
 
 
704
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
705
                update_read_coord(s, &multi_draw_nine_grid->srcBottom, orderInfo->deltaCoordinates);
 
706
 
 
707
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
708
                stream_read_uint16(s, multi_draw_nine_grid->bitmapId);
 
709
 
 
710
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
711
                stream_read_uint8(s, multi_draw_nine_grid->nDeltaEntries);
 
712
 
 
713
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
714
        {
 
715
                stream_read_uint16(s, multi_draw_nine_grid->cbData);
 
716
                stream_seek(s, multi_draw_nine_grid->cbData);
 
717
        }
 
718
}
 
719
 
 
720
void update_read_line_to_order(STREAM* s, ORDER_INFO* orderInfo, LINE_TO_ORDER* line_to)
 
721
{
 
722
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
723
                stream_read_uint16(s, line_to->backMode);
 
724
 
 
725
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
726
                update_read_coord(s, &line_to->nXStart, orderInfo->deltaCoordinates);
 
727
 
 
728
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
729
                update_read_coord(s, &line_to->nYStart, orderInfo->deltaCoordinates);
 
730
 
 
731
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
732
                update_read_coord(s, &line_to->nXEnd, orderInfo->deltaCoordinates);
 
733
 
 
734
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
735
                update_read_coord(s, &line_to->nYEnd, orderInfo->deltaCoordinates);
 
736
 
 
737
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
738
                update_read_color(s, &line_to->backColor);
 
739
 
 
740
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
741
                stream_read_uint8(s, line_to->bRop2);
 
742
 
 
743
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
744
                stream_read_uint8(s, line_to->penStyle);
 
745
 
 
746
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
747
                stream_read_uint8(s, line_to->penWidth);
 
748
 
 
749
        if (orderInfo->fieldFlags & ORDER_FIELD_10)
 
750
                update_read_color(s, &line_to->penColor);
 
751
}
 
752
 
 
753
void update_read_polyline_order(STREAM* s, ORDER_INFO* orderInfo, POLYLINE_ORDER* polyline)
 
754
{
 
755
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
756
                update_read_coord(s, &polyline->xStart, orderInfo->deltaCoordinates);
 
757
 
 
758
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
759
                update_read_coord(s, &polyline->yStart, orderInfo->deltaCoordinates);
 
760
 
 
761
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
762
                stream_read_uint8(s, polyline->bRop2);
 
763
 
 
764
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
765
                stream_seek_uint16(s);
 
766
 
 
767
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
768
                update_read_color(s, &polyline->penColor);
 
769
 
 
770
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
771
                stream_read_uint8(s, polyline->numPoints);
 
772
 
 
773
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
774
        {
 
775
                stream_read_uint8(s, polyline->cbData);
 
776
 
 
777
                if (polyline->points == NULL)
 
778
                        polyline->points = (DELTA_POINT*) xmalloc(sizeof(DELTA_POINT) * polyline->numPoints);
 
779
                else
 
780
                        polyline->points = (DELTA_POINT*) xrealloc(polyline->points, sizeof(DELTA_POINT) * polyline->numPoints);
 
781
 
 
782
                update_read_delta_points(s, polyline->points, polyline->numPoints, polyline->xStart, polyline->yStart);
 
783
        }
 
784
}
 
785
 
 
786
void update_read_memblt_order(STREAM* s, ORDER_INFO* orderInfo, MEMBLT_ORDER* memblt)
 
787
{
 
788
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
789
                stream_read_uint16(s, memblt->cacheId);
 
790
 
 
791
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
792
                update_read_coord(s, &memblt->nLeftRect, orderInfo->deltaCoordinates);
 
793
 
 
794
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
795
                update_read_coord(s, &memblt->nTopRect, orderInfo->deltaCoordinates);
 
796
 
 
797
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
798
                update_read_coord(s, &memblt->nWidth, orderInfo->deltaCoordinates);
 
799
 
 
800
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
801
                update_read_coord(s, &memblt->nHeight, orderInfo->deltaCoordinates);
 
802
 
 
803
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
804
                stream_read_uint8(s, memblt->bRop);
 
805
 
 
806
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
807
                update_read_coord(s, &memblt->nXSrc, orderInfo->deltaCoordinates);
 
808
 
 
809
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
810
                update_read_coord(s, &memblt->nYSrc, orderInfo->deltaCoordinates);
 
811
 
 
812
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
813
                stream_read_uint16(s, memblt->cacheIndex);
 
814
 
 
815
        memblt->colorIndex = (memblt->cacheId >> 8);
 
816
        memblt->cacheId = (memblt->cacheId & 0xFF);
 
817
}
 
818
 
 
819
void update_read_mem3blt_order(STREAM* s, ORDER_INFO* orderInfo, MEM3BLT_ORDER* mem3blt)
 
820
{
 
821
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
822
                stream_read_uint16(s, mem3blt->cacheId);
 
823
 
 
824
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
825
                update_read_coord(s, &mem3blt->nLeftRect, orderInfo->deltaCoordinates);
 
826
 
 
827
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
828
                update_read_coord(s, &mem3blt->nTopRect, orderInfo->deltaCoordinates);
 
829
 
 
830
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
831
                update_read_coord(s, &mem3blt->nWidth, orderInfo->deltaCoordinates);
 
832
 
 
833
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
834
                update_read_coord(s, &mem3blt->nHeight, orderInfo->deltaCoordinates);
 
835
 
 
836
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
837
                stream_read_uint8(s, mem3blt->bRop);
 
838
 
 
839
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
840
                update_read_coord(s, &mem3blt->nXSrc, orderInfo->deltaCoordinates);
 
841
 
 
842
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
843
                update_read_coord(s, &mem3blt->nYSrc, orderInfo->deltaCoordinates);
 
844
 
 
845
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
846
                update_read_color(s, &mem3blt->backColor);
 
847
 
 
848
        if (orderInfo->fieldFlags & ORDER_FIELD_10)
 
849
                update_read_color(s, &mem3blt->foreColor);
 
850
 
 
851
        update_read_brush(s, &mem3blt->brush, orderInfo->fieldFlags >> 10);
 
852
 
 
853
        if (orderInfo->fieldFlags & ORDER_FIELD_16)
 
854
                stream_read_uint16(s, mem3blt->cacheIndex);
 
855
 
 
856
        mem3blt->colorIndex = (mem3blt->cacheId >> 8);
 
857
        mem3blt->cacheId = (mem3blt->cacheId & 0xFF);
 
858
}
 
859
 
 
860
void update_read_save_bitmap_order(STREAM* s, ORDER_INFO* orderInfo, SAVE_BITMAP_ORDER* save_bitmap)
 
861
{
 
862
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
863
                stream_read_uint32(s, save_bitmap->savedBitmapPosition);
 
864
 
 
865
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
866
                update_read_coord(s, &save_bitmap->nLeftRect, orderInfo->deltaCoordinates);
 
867
 
 
868
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
869
                update_read_coord(s, &save_bitmap->nTopRect, orderInfo->deltaCoordinates);
 
870
 
 
871
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
872
                update_read_coord(s, &save_bitmap->nRightRect, orderInfo->deltaCoordinates);
 
873
 
 
874
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
875
                update_read_coord(s, &save_bitmap->nBottomRect, orderInfo->deltaCoordinates);
 
876
 
 
877
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
878
                stream_read_uint8(s, save_bitmap->operation);
 
879
}
 
880
 
 
881
void update_read_glyph_index_order(STREAM* s, ORDER_INFO* orderInfo, GLYPH_INDEX_ORDER* glyph_index)
 
882
{
 
883
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
884
                stream_read_uint8(s, glyph_index->cacheId);
 
885
 
 
886
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
887
                stream_read_uint8(s, glyph_index->flAccel);
 
888
 
 
889
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
890
                stream_read_uint8(s, glyph_index->ulCharInc);
 
891
 
 
892
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
893
                stream_read_uint8(s, glyph_index->fOpRedundant);
 
894
 
 
895
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
896
                update_read_color(s, &glyph_index->backColor);
 
897
 
 
898
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
899
                update_read_color(s, &glyph_index->foreColor);
 
900
 
 
901
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
902
                stream_read_uint16(s, glyph_index->bkLeft);
 
903
 
 
904
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
905
                stream_read_uint16(s, glyph_index->bkTop);
 
906
 
 
907
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
908
                stream_read_uint16(s, glyph_index->bkRight);
 
909
 
 
910
        if (orderInfo->fieldFlags & ORDER_FIELD_10)
 
911
                stream_read_uint16(s, glyph_index->bkBottom);
 
912
 
 
913
        if (orderInfo->fieldFlags & ORDER_FIELD_11)
 
914
                stream_read_uint16(s, glyph_index->opLeft);
 
915
 
 
916
        if (orderInfo->fieldFlags & ORDER_FIELD_12)
 
917
                stream_read_uint16(s, glyph_index->opTop);
 
918
 
 
919
        if (orderInfo->fieldFlags & ORDER_FIELD_13)
 
920
                stream_read_uint16(s, glyph_index->opRight);
 
921
 
 
922
        if (orderInfo->fieldFlags & ORDER_FIELD_14)
 
923
                stream_read_uint16(s, glyph_index->opBottom);
 
924
 
 
925
        update_read_brush(s, &glyph_index->brush, orderInfo->fieldFlags >> 14);
 
926
 
 
927
        if (orderInfo->fieldFlags & ORDER_FIELD_20)
 
928
                stream_read_uint16(s, glyph_index->x);
 
929
 
 
930
        if (orderInfo->fieldFlags & ORDER_FIELD_21)
 
931
                stream_read_uint16(s, glyph_index->y);
 
932
 
 
933
        if (orderInfo->fieldFlags & ORDER_FIELD_22)
 
934
        {
 
935
                stream_read_uint8(s, glyph_index->cbData);
 
936
                memcpy(glyph_index->data, s->p, glyph_index->cbData);
 
937
                stream_seek(s, glyph_index->cbData);
 
938
        }
 
939
}
 
940
 
 
941
void update_read_fast_index_order(STREAM* s, ORDER_INFO* orderInfo, FAST_INDEX_ORDER* fast_index)
 
942
{
 
943
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
944
                stream_read_uint8(s, fast_index->cacheId);
 
945
 
 
946
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
947
        {
 
948
                stream_read_uint8(s, fast_index->ulCharInc);
 
949
                stream_read_uint8(s, fast_index->flAccel);
 
950
        }
 
951
 
 
952
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
953
                update_read_color(s, &fast_index->backColor);
 
954
 
 
955
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
956
                update_read_color(s, &fast_index->foreColor);
 
957
 
 
958
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
959
                update_read_coord(s, &fast_index->bkLeft, orderInfo->deltaCoordinates);
 
960
 
 
961
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
962
                update_read_coord(s, &fast_index->bkTop, orderInfo->deltaCoordinates);
 
963
 
 
964
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
965
                update_read_coord(s, &fast_index->bkRight, orderInfo->deltaCoordinates);
 
966
 
 
967
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
968
                update_read_coord(s, &fast_index->bkBottom, orderInfo->deltaCoordinates);
 
969
 
 
970
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
971
                update_read_coord(s, &fast_index->opLeft, orderInfo->deltaCoordinates);
 
972
 
 
973
        if (orderInfo->fieldFlags & ORDER_FIELD_10)
 
974
                update_read_coord(s, &fast_index->opTop, orderInfo->deltaCoordinates);
 
975
 
 
976
        if (orderInfo->fieldFlags & ORDER_FIELD_11)
 
977
                update_read_coord(s, &fast_index->opRight, orderInfo->deltaCoordinates);
 
978
 
 
979
        if (orderInfo->fieldFlags & ORDER_FIELD_12)
 
980
                update_read_coord(s, &fast_index->opBottom, orderInfo->deltaCoordinates);
 
981
 
 
982
        if (orderInfo->fieldFlags & ORDER_FIELD_13)
 
983
                update_read_coord(s, &fast_index->x, orderInfo->deltaCoordinates);
 
984
 
 
985
        if (orderInfo->fieldFlags & ORDER_FIELD_14)
 
986
                update_read_coord(s, &fast_index->y, orderInfo->deltaCoordinates);
 
987
 
 
988
        if (orderInfo->fieldFlags & ORDER_FIELD_15)
 
989
        {
 
990
                stream_read_uint8(s, fast_index->cbData);
 
991
                memcpy(fast_index->data, s->p, fast_index->cbData);
 
992
                stream_seek(s, fast_index->cbData);
 
993
        }
 
994
}
 
995
 
 
996
void update_read_fast_glyph_order(STREAM* s, ORDER_INFO* orderInfo, FAST_GLYPH_ORDER* fast_glyph)
 
997
{
 
998
        GLYPH_DATA_V2* glyph;
 
999
        uint8* phold;
 
1000
 
 
1001
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
1002
                stream_read_uint8(s, fast_glyph->cacheId);
 
1003
 
 
1004
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
1005
        {
 
1006
                stream_read_uint8(s, fast_glyph->ulCharInc);
 
1007
                stream_read_uint8(s, fast_glyph->flAccel);
 
1008
        }
 
1009
 
 
1010
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
1011
                update_read_color(s, &fast_glyph->backColor);
 
1012
 
 
1013
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
1014
                update_read_color(s, &fast_glyph->foreColor);
 
1015
 
 
1016
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
1017
                update_read_coord(s, &fast_glyph->bkLeft, orderInfo->deltaCoordinates);
 
1018
 
 
1019
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
1020
                update_read_coord(s, &fast_glyph->bkTop, orderInfo->deltaCoordinates);
 
1021
 
 
1022
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
1023
                update_read_coord(s, &fast_glyph->bkRight, orderInfo->deltaCoordinates);
 
1024
 
 
1025
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
1026
                update_read_coord(s, &fast_glyph->bkBottom, orderInfo->deltaCoordinates);
 
1027
 
 
1028
        if (orderInfo->fieldFlags & ORDER_FIELD_09)
 
1029
                update_read_coord(s, &fast_glyph->opLeft, orderInfo->deltaCoordinates);
 
1030
 
 
1031
        if (orderInfo->fieldFlags & ORDER_FIELD_10)
 
1032
                update_read_coord(s, &fast_glyph->opTop, orderInfo->deltaCoordinates);
 
1033
 
 
1034
        if (orderInfo->fieldFlags & ORDER_FIELD_11)
 
1035
                update_read_coord(s, &fast_glyph->opRight, orderInfo->deltaCoordinates);
 
1036
 
 
1037
        if (orderInfo->fieldFlags & ORDER_FIELD_12)
 
1038
                update_read_coord(s, &fast_glyph->opBottom, orderInfo->deltaCoordinates);
 
1039
 
 
1040
        if (orderInfo->fieldFlags & ORDER_FIELD_13)
 
1041
                update_read_coord(s, &fast_glyph->x, orderInfo->deltaCoordinates);
 
1042
 
 
1043
        if (orderInfo->fieldFlags & ORDER_FIELD_14)
 
1044
                update_read_coord(s, &fast_glyph->y, orderInfo->deltaCoordinates);
 
1045
 
 
1046
        if (orderInfo->fieldFlags & ORDER_FIELD_15)
 
1047
        {
 
1048
                stream_read_uint8(s, fast_glyph->cbData);
 
1049
                memcpy(fast_glyph->data, s->p, fast_glyph->cbData);
 
1050
                phold = s->p;
 
1051
                stream_seek(s, 1);
 
1052
                if ((fast_glyph->cbData > 1) && (fast_glyph->glyph_data == NULL))
 
1053
                {
 
1054
                        /* parse optional glyph data */
 
1055
                        glyph = (GLYPH_DATA_V2*) xmalloc(sizeof(GLYPH_DATA_V2));
 
1056
                        glyph->cacheIndex = fast_glyph->data[0];
 
1057
                        update_read_2byte_signed(s, &glyph->x);
 
1058
                        update_read_2byte_signed(s, &glyph->y);
 
1059
                        update_read_2byte_unsigned(s, &glyph->cx);
 
1060
                        update_read_2byte_unsigned(s, &glyph->cy);
 
1061
                        glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
 
1062
                        glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
 
1063
                        glyph->aj = (uint8*) xmalloc(glyph->cb);
 
1064
                        stream_read(s, glyph->aj, glyph->cb);
 
1065
                        fast_glyph->glyph_data = glyph;
 
1066
                }
 
1067
                s->p = phold + fast_glyph->cbData;
 
1068
        }
 
1069
}
 
1070
 
 
1071
void update_read_polygon_sc_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_SC_ORDER* polygon_sc)
 
1072
{
 
1073
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
1074
                update_read_coord(s, &polygon_sc->xStart, orderInfo->deltaCoordinates);
 
1075
 
 
1076
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
1077
                update_read_coord(s, &polygon_sc->yStart, orderInfo->deltaCoordinates);
 
1078
 
 
1079
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
1080
                stream_read_uint8(s, polygon_sc->bRop2);
 
1081
 
 
1082
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
1083
                stream_read_uint8(s, polygon_sc->fillMode);
 
1084
 
 
1085
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
1086
                update_read_color(s, &polygon_sc->brushColor);
 
1087
 
 
1088
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
1089
                stream_read_uint8(s, polygon_sc->nDeltaEntries);
 
1090
 
 
1091
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
1092
        {
 
1093
                stream_read_uint8(s, polygon_sc->cbData);
 
1094
                stream_seek(s, polygon_sc->cbData);
 
1095
        }
 
1096
}
 
1097
 
 
1098
void update_read_polygon_cb_order(STREAM* s, ORDER_INFO* orderInfo, POLYGON_CB_ORDER* polygon_cb)
 
1099
{
 
1100
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
1101
                update_read_coord(s, &polygon_cb->xStart, orderInfo->deltaCoordinates);
 
1102
 
 
1103
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
1104
                update_read_coord(s, &polygon_cb->yStart, orderInfo->deltaCoordinates);
 
1105
 
 
1106
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
1107
                stream_read_uint8(s, polygon_cb->bRop2);
 
1108
 
 
1109
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
1110
                stream_read_uint8(s, polygon_cb->fillMode);
 
1111
 
 
1112
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
1113
                update_read_color(s, &polygon_cb->backColor);
 
1114
 
 
1115
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
1116
                update_read_color(s, &polygon_cb->foreColor);
 
1117
 
 
1118
        update_read_brush(s, &polygon_cb->brush, orderInfo->fieldFlags >> 6);
 
1119
 
 
1120
        if (orderInfo->fieldFlags & ORDER_FIELD_12)
 
1121
                stream_read_uint8(s, polygon_cb->nDeltaEntries);
 
1122
 
 
1123
        if (orderInfo->fieldFlags & ORDER_FIELD_13)
 
1124
        {
 
1125
                stream_read_uint8(s, polygon_cb->cbData);
 
1126
                stream_seek(s, polygon_cb->cbData);
 
1127
        }
 
1128
}
 
1129
 
 
1130
void update_read_ellipse_sc_order(STREAM* s, ORDER_INFO* orderInfo, ELLIPSE_SC_ORDER* ellipse_sc)
 
1131
{
 
1132
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
1133
                update_read_coord(s, &ellipse_sc->leftRect, orderInfo->deltaCoordinates);
 
1134
 
 
1135
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
1136
                update_read_coord(s, &ellipse_sc->topRect, orderInfo->deltaCoordinates);
 
1137
 
 
1138
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
1139
                update_read_coord(s, &ellipse_sc->rightRect, orderInfo->deltaCoordinates);
 
1140
 
 
1141
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
1142
                update_read_coord(s, &ellipse_sc->bottomRect, orderInfo->deltaCoordinates);
 
1143
 
 
1144
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
1145
                stream_read_uint8(s, ellipse_sc->bRop2);
 
1146
 
 
1147
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
1148
                stream_read_uint8(s, ellipse_sc->fillMode);
 
1149
 
 
1150
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
1151
                update_read_color(s, &ellipse_sc->color);
 
1152
}
 
1153
 
 
1154
void update_read_ellipse_cb_order(STREAM* s, ORDER_INFO* orderInfo, ELLIPSE_CB_ORDER* ellipse_cb)
 
1155
{
 
1156
        if (orderInfo->fieldFlags & ORDER_FIELD_01)
 
1157
                update_read_coord(s, &ellipse_cb->leftRect, orderInfo->deltaCoordinates);
 
1158
 
 
1159
        if (orderInfo->fieldFlags & ORDER_FIELD_02)
 
1160
                update_read_coord(s, &ellipse_cb->topRect, orderInfo->deltaCoordinates);
 
1161
 
 
1162
        if (orderInfo->fieldFlags & ORDER_FIELD_03)
 
1163
                update_read_coord(s, &ellipse_cb->rightRect, orderInfo->deltaCoordinates);
 
1164
 
 
1165
        if (orderInfo->fieldFlags & ORDER_FIELD_04)
 
1166
                update_read_coord(s, &ellipse_cb->bottomRect, orderInfo->deltaCoordinates);
 
1167
 
 
1168
        if (orderInfo->fieldFlags & ORDER_FIELD_05)
 
1169
                stream_read_uint8(s, ellipse_cb->bRop2);
 
1170
 
 
1171
        if (orderInfo->fieldFlags & ORDER_FIELD_06)
 
1172
                stream_read_uint8(s, ellipse_cb->fillMode);
 
1173
 
 
1174
        if (orderInfo->fieldFlags & ORDER_FIELD_07)
 
1175
                update_read_color(s, &ellipse_cb->backColor);
 
1176
 
 
1177
        if (orderInfo->fieldFlags & ORDER_FIELD_08)
 
1178
                update_read_color(s, &ellipse_cb->foreColor);
 
1179
 
 
1180
        update_read_brush(s, &ellipse_cb->brush, orderInfo->fieldFlags >> 8);
 
1181
}
 
1182
 
 
1183
/* Secondary Drawing Orders */
 
1184
 
 
1185
void update_read_cache_bitmap_order(STREAM* s, CACHE_BITMAP_ORDER* cache_bitmap_order, boolean compressed, uint16 flags)
 
1186
{
 
1187
        stream_read_uint8(s, cache_bitmap_order->cacheId); /* cacheId (1 byte) */
 
1188
        stream_seek_uint8(s); /* pad1Octet (1 byte) */
 
1189
        stream_read_uint8(s, cache_bitmap_order->bitmapWidth); /* bitmapWidth (1 byte) */
 
1190
        stream_read_uint8(s, cache_bitmap_order->bitmapHeight); /* bitmapHeight (1 byte) */
 
1191
        stream_read_uint8(s, cache_bitmap_order->bitmapBpp); /* bitmapBpp (1 byte) */
 
1192
        stream_read_uint16(s, cache_bitmap_order->bitmapLength); /* bitmapLength (2 bytes) */
 
1193
        stream_read_uint16(s, cache_bitmap_order->cacheIndex); /* cacheIndex (2 bytes) */
 
1194
 
 
1195
        if (compressed)
 
1196
        {
 
1197
                if ((flags & NO_BITMAP_COMPRESSION_HDR) == 0)
 
1198
                {
 
1199
                        uint8* bitmapComprHdr = (uint8*) &(cache_bitmap_order->bitmapComprHdr);
 
1200
                        stream_read(s, bitmapComprHdr, 8); /* bitmapComprHdr (8 bytes) */
 
1201
                        cache_bitmap_order->bitmapLength -= 8;
 
1202
                }
 
1203
                stream_get_mark(s, cache_bitmap_order->bitmapDataStream);
 
1204
                stream_seek(s, cache_bitmap_order->bitmapLength);
 
1205
        }
 
1206
        else
 
1207
        {
 
1208
                stream_get_mark(s, cache_bitmap_order->bitmapDataStream);
 
1209
                stream_seek(s, cache_bitmap_order->bitmapLength); /* bitmapDataStream */
 
1210
        }
 
1211
        cache_bitmap_order->compressed = compressed;
 
1212
}
 
1213
 
 
1214
void update_read_cache_bitmap_v2_order(STREAM* s, CACHE_BITMAP_V2_ORDER* cache_bitmap_v2_order, boolean compressed, uint16 flags)
 
1215
{
 
1216
        uint8 bitsPerPixelId;
 
1217
 
 
1218
        cache_bitmap_v2_order->cacheId = flags & 0x0003;
 
1219
        cache_bitmap_v2_order->flags = (flags & 0xFF80) >> 7;
 
1220
 
 
1221
        bitsPerPixelId = (flags & 0x0078) >> 3;
 
1222
        cache_bitmap_v2_order->bitmapBpp = CBR2_BPP[bitsPerPixelId];
 
1223
 
 
1224
        if (cache_bitmap_v2_order->flags & CBR2_PERSISTENT_KEY_PRESENT)
 
1225
        {
 
1226
                stream_read_uint32(s, cache_bitmap_v2_order->key1); /* key1 (4 bytes) */
 
1227
                stream_read_uint32(s, cache_bitmap_v2_order->key2); /* key2 (4 bytes) */
 
1228
        }
 
1229
 
 
1230
        if (cache_bitmap_v2_order->flags & CBR2_HEIGHT_SAME_AS_WIDTH)
 
1231
        {
 
1232
                update_read_2byte_unsigned(s, &cache_bitmap_v2_order->bitmapWidth); /* bitmapWidth */
 
1233
                cache_bitmap_v2_order->bitmapHeight = cache_bitmap_v2_order->bitmapWidth;
 
1234
        }
 
1235
        else
 
1236
        {
 
1237
                update_read_2byte_unsigned(s, &cache_bitmap_v2_order->bitmapWidth); /* bitmapWidth */
 
1238
                update_read_2byte_unsigned(s, &cache_bitmap_v2_order->bitmapHeight); /* bitmapHeight */
 
1239
        }
 
1240
 
 
1241
        update_read_4byte_unsigned(s, &cache_bitmap_v2_order->bitmapLength); /* bitmapLength */
 
1242
        update_read_2byte_unsigned(s, &cache_bitmap_v2_order->cacheIndex); /* cacheIndex */
 
1243
 
 
1244
        if (cache_bitmap_v2_order->flags & CBR2_DO_NOT_CACHE)
 
1245
                cache_bitmap_v2_order->cacheIndex = BITMAP_CACHE_WAITING_LIST_INDEX;
 
1246
 
 
1247
        if (compressed)
 
1248
        {
 
1249
                if (!(cache_bitmap_v2_order->flags & CBR2_NO_BITMAP_COMPRESSION_HDR))
 
1250
                {
 
1251
                        stream_read_uint16(s, cache_bitmap_v2_order->cbCompFirstRowSize); /* cbCompFirstRowSize (2 bytes) */
 
1252
                        stream_read_uint16(s, cache_bitmap_v2_order->cbCompMainBodySize); /* cbCompMainBodySize (2 bytes) */
 
1253
                        stream_read_uint16(s, cache_bitmap_v2_order->cbScanWidth); /* cbScanWidth (2 bytes) */
 
1254
                        stream_read_uint16(s, cache_bitmap_v2_order->cbUncompressedSize); /* cbUncompressedSize (2 bytes) */
 
1255
                        cache_bitmap_v2_order->bitmapLength = cache_bitmap_v2_order->cbCompMainBodySize;
 
1256
                }
 
1257
 
 
1258
                stream_get_mark(s, cache_bitmap_v2_order->bitmapDataStream);
 
1259
                stream_seek(s, cache_bitmap_v2_order->bitmapLength);
 
1260
        }
 
1261
        else
 
1262
        {
 
1263
                stream_get_mark(s, cache_bitmap_v2_order->bitmapDataStream);
 
1264
                stream_seek(s, cache_bitmap_v2_order->bitmapLength);
 
1265
        }
 
1266
        cache_bitmap_v2_order->compressed = compressed;
 
1267
}
 
1268
 
 
1269
void update_read_cache_bitmap_v3_order(STREAM* s, CACHE_BITMAP_V3_ORDER* cache_bitmap_v3_order, boolean compressed, uint16 flags)
 
1270
{
 
1271
        uint8 bitsPerPixelId;
 
1272
        BITMAP_DATA_EX* bitmapData;
 
1273
 
 
1274
        cache_bitmap_v3_order->cacheId = flags & 0x00000003;
 
1275
        cache_bitmap_v3_order->flags = (flags & 0x0000FF80) >> 7;
 
1276
 
 
1277
        bitsPerPixelId = (flags & 0x00000078) >> 3;
 
1278
        cache_bitmap_v3_order->bpp = CBR23_BPP[bitsPerPixelId];
 
1279
 
 
1280
        stream_read_uint16(s, cache_bitmap_v3_order->cacheIndex); /* cacheIndex (2 bytes) */
 
1281
        stream_read_uint32(s, cache_bitmap_v3_order->key1); /* key1 (4 bytes) */
 
1282
        stream_read_uint32(s, cache_bitmap_v3_order->key2); /* key2 (4 bytes) */
 
1283
 
 
1284
        bitmapData = &cache_bitmap_v3_order->bitmapData;
 
1285
 
 
1286
        stream_read_uint8(s, bitmapData->bpp);
 
1287
        stream_seek_uint8(s); /* reserved1 (1 byte) */
 
1288
        stream_seek_uint8(s); /* reserved2 (1 byte) */
 
1289
        stream_read_uint8(s, bitmapData->codecID); /* codecID (1 byte) */
 
1290
        stream_read_uint16(s, bitmapData->width); /* width (2 bytes) */
 
1291
        stream_read_uint16(s, bitmapData->height); /* height (2 bytes) */
 
1292
        stream_read_uint32(s, bitmapData->length); /* length (4 bytes) */
 
1293
 
 
1294
        if (bitmapData->data == NULL)
 
1295
                bitmapData->data = (uint8*) xmalloc(bitmapData->length);
 
1296
        else
 
1297
                bitmapData->data = (uint8*) xrealloc(bitmapData->data, bitmapData->length);
 
1298
 
 
1299
        stream_read(s, bitmapData->data, bitmapData->length);
 
1300
}
 
1301
 
 
1302
void update_read_cache_color_table_order(STREAM* s, CACHE_COLOR_TABLE_ORDER* cache_color_table_order, uint16 flags)
 
1303
{
 
1304
        int i;
 
1305
        uint32* colorTable;
 
1306
 
 
1307
        stream_read_uint8(s, cache_color_table_order->cacheIndex); /* cacheIndex (1 byte) */
 
1308
        stream_read_uint8(s, cache_color_table_order->numberColors); /* numberColors (2 bytes) */
 
1309
 
 
1310
        colorTable = cache_color_table_order->colorTable;
 
1311
 
 
1312
        if (colorTable == NULL)
 
1313
                colorTable = (uint32*) xmalloc(cache_color_table_order->numberColors * 4);
 
1314
        else
 
1315
                colorTable = (uint32*) xrealloc(colorTable, cache_color_table_order->numberColors * 4);
 
1316
 
 
1317
        for (i = 0; i < (int) cache_color_table_order->numberColors; i++)
 
1318
        {
 
1319
                update_read_color_quad(s, &colorTable[i]);
 
1320
        }
 
1321
 
 
1322
        cache_color_table_order->colorTable = colorTable;
 
1323
}
 
1324
 
 
1325
void update_read_cache_glyph_order(STREAM* s, CACHE_GLYPH_ORDER* cache_glyph_order, uint16 flags)
 
1326
{
 
1327
        int i;
 
1328
        sint16 lsi16;
 
1329
        GLYPH_DATA* glyph;
 
1330
 
 
1331
        stream_read_uint8(s, cache_glyph_order->cacheId); /* cacheId (1 byte) */
 
1332
        stream_read_uint8(s, cache_glyph_order->cGlyphs); /* cGlyphs (1 byte) */
 
1333
 
 
1334
        for (i = 0; i < (int) cache_glyph_order->cGlyphs; i++)
 
1335
        {
 
1336
                if (cache_glyph_order->glyphData[i] == NULL)
 
1337
                {
 
1338
                        cache_glyph_order->glyphData[i] = (GLYPH_DATA*) xmalloc(sizeof(GLYPH_DATA));
 
1339
                }
 
1340
                glyph = cache_glyph_order->glyphData[i];
 
1341
 
 
1342
                stream_read_uint16(s, glyph->cacheIndex);
 
1343
                stream_read_uint16(s, lsi16);
 
1344
                glyph->x = lsi16;
 
1345
                stream_read_uint16(s, lsi16);
 
1346
                glyph->y = lsi16;
 
1347
                stream_read_uint16(s, glyph->cx);
 
1348
                stream_read_uint16(s, glyph->cy);
 
1349
 
 
1350
                glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
 
1351
                glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
 
1352
 
 
1353
                glyph->aj = (uint8*) xmalloc(glyph->cb);
 
1354
 
 
1355
                stream_read(s, glyph->aj, glyph->cb);
 
1356
        }
 
1357
 
 
1358
        if (flags & CG_GLYPH_UNICODE_PRESENT)
 
1359
                stream_seek(s, cache_glyph_order->cGlyphs * 2);
 
1360
}
 
1361
 
 
1362
void update_read_cache_glyph_v2_order(STREAM* s, CACHE_GLYPH_V2_ORDER* cache_glyph_v2_order, uint16 flags)
 
1363
{
 
1364
        int i;
 
1365
        GLYPH_DATA_V2* glyph;
 
1366
 
 
1367
        cache_glyph_v2_order->cacheId = (flags & 0x000F);
 
1368
        cache_glyph_v2_order->flags = (flags & 0x00F0) >> 4;
 
1369
        cache_glyph_v2_order->cGlyphs = (flags & 0xFF00) >> 8;
 
1370
 
 
1371
        for (i = 0; i < (int) cache_glyph_v2_order->cGlyphs; i++)
 
1372
        {
 
1373
                if (cache_glyph_v2_order->glyphData[i] == NULL)
 
1374
                {
 
1375
                        cache_glyph_v2_order->glyphData[i] = (GLYPH_DATA_V2*) xmalloc(sizeof(GLYPH_DATA_V2));
 
1376
                }
 
1377
                glyph = cache_glyph_v2_order->glyphData[i];
 
1378
 
 
1379
                stream_read_uint8(s, glyph->cacheIndex);
 
1380
                update_read_2byte_signed(s, &glyph->x);
 
1381
                update_read_2byte_signed(s, &glyph->y);
 
1382
                update_read_2byte_unsigned(s, &glyph->cx);
 
1383
                update_read_2byte_unsigned(s, &glyph->cy);
 
1384
 
 
1385
                glyph->cb = ((glyph->cx + 7) / 8) * glyph->cy;
 
1386
                glyph->cb += ((glyph->cb % 4) > 0) ? 4 - (glyph->cb % 4) : 0;
 
1387
 
 
1388
                glyph->aj = (uint8*) xmalloc(glyph->cb);
 
1389
 
 
1390
                stream_read(s, glyph->aj, glyph->cb);
 
1391
        }
 
1392
 
 
1393
        if (flags & CG_GLYPH_UNICODE_PRESENT)
 
1394
                stream_seek(s, cache_glyph_v2_order->cGlyphs * 2);
 
1395
}
 
1396
 
 
1397
void update_decompress_brush(STREAM* s, uint8* output, uint8 bpp)
 
1398
{
 
1399
        int index;
 
1400
        int x, y, k;
 
1401
        uint8 byte = 0;
 
1402
        uint8* palette;
 
1403
        int bytesPerPixel;
 
1404
 
 
1405
        palette = s->p + 16;
 
1406
        bytesPerPixel = ((bpp + 1) / 8);
 
1407
 
 
1408
        for (y = 7; y >= 0; y--)
 
1409
        {
 
1410
                for (x = 0; x < 8; x++)
 
1411
                {
 
1412
                        if ((x % 4) == 0)
 
1413
                                stream_read_uint8(s, byte);
 
1414
 
 
1415
                        index = ((byte >> ((3 - (x % 4)) * 2)) & 0x03);
 
1416
 
 
1417
                        for (k = 0; k < bytesPerPixel; k++)
 
1418
                        {
 
1419
                                output[((y * 8 + x) * bytesPerPixel) + k] = palette[(index * bytesPerPixel) + k];
 
1420
                        }
 
1421
                }
 
1422
        }
 
1423
}
 
1424
 
 
1425
void update_read_cache_brush_order(STREAM* s, CACHE_BRUSH_ORDER* cache_brush_order, uint16 flags)
 
1426
{
 
1427
        int i;
 
1428
        int size;
 
1429
        uint8 iBitmapFormat;
 
1430
        boolean compressed = false;
 
1431
 
 
1432
        stream_read_uint8(s, cache_brush_order->index); /* cacheEntry (1 byte) */
 
1433
 
 
1434
        stream_read_uint8(s, iBitmapFormat); /* iBitmapFormat (1 byte) */
 
1435
        cache_brush_order->bpp = BMF_BPP[iBitmapFormat];
 
1436
 
 
1437
        stream_read_uint8(s, cache_brush_order->cx); /* cx (1 byte) */
 
1438
        stream_read_uint8(s, cache_brush_order->cy); /* cy (1 byte) */
 
1439
        stream_read_uint8(s, cache_brush_order->style); /* style (1 byte) */
 
1440
        stream_read_uint8(s, cache_brush_order->length); /* iBytes (1 byte) */
 
1441
 
 
1442
        if ((cache_brush_order->cx == 8) && (cache_brush_order->cy == 8))
 
1443
        {
 
1444
                size = (cache_brush_order->bpp == 1) ? 8 : 8 * 8 * cache_brush_order->bpp;
 
1445
 
 
1446
                cache_brush_order->data = (uint8*) xmalloc(size);
 
1447
 
 
1448
                if (cache_brush_order->bpp == 1)
 
1449
                {
 
1450
                        if (cache_brush_order->length != 8)
 
1451
                        {
 
1452
                                printf("incompatible 1bpp brush of length:%d\n", cache_brush_order->length);
 
1453
                                return;
 
1454
                        }
 
1455
 
 
1456
                        /* rows are encoded in reverse order */
 
1457
 
 
1458
                        for (i = 7; i >= 0; i--)
 
1459
                        {
 
1460
                                stream_read_uint8(s, cache_brush_order->data[i]);
 
1461
                        }
 
1462
                }
 
1463
                else
 
1464
                {
 
1465
                        if ((iBitmapFormat == BMF_8BPP) && (cache_brush_order->length == 20))
 
1466
                                compressed = true;
 
1467
                        else if ((iBitmapFormat == BMF_16BPP) && (cache_brush_order->length == 24))
 
1468
                                compressed = true;
 
1469
                        else if ((iBitmapFormat == BMF_32BPP) && (cache_brush_order->length == 32))
 
1470
                                compressed = true;
 
1471
 
 
1472
                        if (compressed != false)
 
1473
                        {
 
1474
                                /* compressed brush */
 
1475
                                update_decompress_brush(s, cache_brush_order->data, cache_brush_order->bpp);
 
1476
                        }
 
1477
                        else
 
1478
                        {
 
1479
                                /* uncompressed brush */
 
1480
                                int scanline = (cache_brush_order->bpp / 8) * 8;
 
1481
 
 
1482
                                for (i = 7; i >= 0; i--)
 
1483
                                {
 
1484
                                        stream_read(s, &cache_brush_order->data[i * scanline], scanline);
 
1485
                                }
 
1486
                        }
 
1487
                }
 
1488
        }
 
1489
}
 
1490
 
 
1491
/* Alternate Secondary Drawing Orders */
 
1492
 
 
1493
void update_read_create_offscreen_bitmap_order(STREAM* s, CREATE_OFFSCREEN_BITMAP_ORDER* create_offscreen_bitmap)
 
1494
{
 
1495
        uint16 flags;
 
1496
        boolean deleteListPresent;
 
1497
        OFFSCREEN_DELETE_LIST* deleteList;
 
1498
 
 
1499
        stream_read_uint16(s, flags); /* flags (2 bytes) */
 
1500
        create_offscreen_bitmap->id = flags & 0x7FFF;
 
1501
        deleteListPresent = (flags & 0x8000) ? true : false;
 
1502
 
 
1503
        stream_read_uint16(s, create_offscreen_bitmap->cx); /* cx (2 bytes) */
 
1504
        stream_read_uint16(s, create_offscreen_bitmap->cy); /* cy (2 bytes) */
 
1505
 
 
1506
        deleteList = &(create_offscreen_bitmap->deleteList);
 
1507
        if (deleteListPresent)
 
1508
        {
 
1509
                int i;
 
1510
 
 
1511
                stream_read_uint16(s, deleteList->cIndices);
 
1512
 
 
1513
                if (deleteList->cIndices > deleteList->sIndices)
 
1514
                {
 
1515
                        deleteList->sIndices = deleteList->cIndices;
 
1516
                        deleteList->indices = xrealloc(deleteList->indices, deleteList->sIndices * 2);
 
1517
                }
 
1518
 
 
1519
                for (i = 0; i < (int) deleteList->cIndices; i++)
 
1520
                {
 
1521
                        stream_read_uint16(s, deleteList->indices[i]);
 
1522
                }
 
1523
        }
 
1524
        else
 
1525
        {
 
1526
                deleteList->cIndices = 0;
 
1527
        }
 
1528
}
 
1529
 
 
1530
void update_read_switch_surface_order(STREAM* s, SWITCH_SURFACE_ORDER* switch_surface)
 
1531
{
 
1532
        stream_read_uint16(s, switch_surface->bitmapId); /* bitmapId (2 bytes) */
 
1533
}
 
1534
 
 
1535
void update_read_create_nine_grid_bitmap_order(STREAM* s, CREATE_NINE_GRID_BITMAP_ORDER* create_nine_grid_bitmap)
 
1536
{
 
1537
        NINE_GRID_BITMAP_INFO* nineGridInfo;
 
1538
 
 
1539
        stream_read_uint8(s, create_nine_grid_bitmap->bitmapBpp); /* bitmapBpp (1 byte) */
 
1540
        stream_read_uint16(s, create_nine_grid_bitmap->bitmapId); /* bitmapId (2 bytes) */
 
1541
 
 
1542
        nineGridInfo = &(create_nine_grid_bitmap->nineGridInfo);
 
1543
        stream_read_uint32(s, nineGridInfo->flFlags); /* flFlags (4 bytes) */
 
1544
        stream_read_uint16(s, nineGridInfo->ulLeftWidth); /* ulLeftWidth (2 bytes) */
 
1545
        stream_read_uint16(s, nineGridInfo->ulRightWidth); /* ulRightWidth (2 bytes) */
 
1546
        stream_read_uint16(s, nineGridInfo->ulTopHeight); /* ulTopHeight (2 bytes) */
 
1547
        stream_read_uint16(s, nineGridInfo->ulBottomHeight); /* ulBottomHeight (2 bytes) */
 
1548
        update_read_colorref(s, &nineGridInfo->crTransparent); /* crTransparent (4 bytes) */
 
1549
}
 
1550
 
 
1551
void update_read_frame_marker_order(STREAM* s, FRAME_MARKER_ORDER* frame_marker)
 
1552
{
 
1553
        stream_read_uint32(s, frame_marker->action); /* action (4 bytes) */
 
1554
}
 
1555
 
 
1556
void update_read_stream_bitmap_first_order(STREAM* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_first)
 
1557
{
 
1558
        stream_read_uint8(s, stream_bitmap_first->bitmapFlags); /* bitmapFlags (1 byte) */
 
1559
        stream_read_uint8(s, stream_bitmap_first->bitmapBpp); /* bitmapBpp (1 byte) */
 
1560
        stream_read_uint16(s, stream_bitmap_first->bitmapType); /* bitmapType (2 bytes) */
 
1561
        stream_read_uint16(s, stream_bitmap_first->bitmapWidth); /* bitmapWidth (2 bytes) */
 
1562
        stream_read_uint16(s, stream_bitmap_first->bitmapHeight); /* bitmapHeigth (2 bytes) */
 
1563
 
 
1564
        if (stream_bitmap_first->bitmapFlags & STREAM_BITMAP_V2)
 
1565
                stream_read_uint32(s, stream_bitmap_first->bitmapSize); /* bitmapSize (4 bytes) */
 
1566
        else
 
1567
                stream_read_uint16(s, stream_bitmap_first->bitmapSize); /* bitmapSize (2 bytes) */
 
1568
 
 
1569
        stream_read_uint16(s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlockSize (2 bytes) */
 
1570
        stream_seek(s, stream_bitmap_first->bitmapBlockSize); /* bitmapBlock */
 
1571
}
 
1572
 
 
1573
void update_read_stream_bitmap_next_order(STREAM* s, STREAM_BITMAP_FIRST_ORDER* stream_bitmap_next)
 
1574
{
 
1575
        stream_read_uint8(s, stream_bitmap_next->bitmapFlags); /* bitmapFlags (1 byte) */
 
1576
        stream_read_uint16(s, stream_bitmap_next->bitmapType); /* bitmapType (2 bytes) */
 
1577
        stream_read_uint16(s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlockSize (2 bytes) */
 
1578
        stream_seek(s, stream_bitmap_next->bitmapBlockSize); /* bitmapBlock */
 
1579
}
 
1580
 
 
1581
void update_read_draw_gdiplus_first_order(STREAM* s, DRAW_GDIPLUS_FIRST_ORDER* draw_gdiplus_first)
 
1582
{
 
1583
        stream_seek_uint8(s); /* pad1Octet (1 byte) */
 
1584
        stream_read_uint16(s, draw_gdiplus_first->cbSize); /* cbSize (2 bytes) */
 
1585
        stream_read_uint32(s, draw_gdiplus_first->cbTotalSize); /* cbTotalSize (4 bytes) */
 
1586
        stream_read_uint32(s, draw_gdiplus_first->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
 
1587
        stream_seek(s, draw_gdiplus_first->cbSize); /* emfRecords */
 
1588
}
 
1589
 
 
1590
void update_read_draw_gdiplus_next_order(STREAM* s, DRAW_GDIPLUS_NEXT_ORDER* draw_gdiplus_next)
 
1591
{
 
1592
        stream_seek_uint8(s); /* pad1Octet (1 byte) */
 
1593
        stream_read_uint16(s, draw_gdiplus_next->cbSize); /* cbSize (2 bytes) */
 
1594
        stream_seek(s, draw_gdiplus_next->cbSize); /* emfRecords */
 
1595
}
 
1596
 
 
1597
void update_read_draw_gdiplus_end_order(STREAM* s, DRAW_GDIPLUS_END_ORDER* draw_gdiplus_end)
 
1598
{
 
1599
        stream_seek_uint8(s); /* pad1Octet (1 byte) */
 
1600
        stream_read_uint16(s, draw_gdiplus_end->cbSize); /* cbSize (2 bytes) */
 
1601
        stream_read_uint32(s, draw_gdiplus_end->cbTotalSize); /* cbTotalSize (4 bytes) */
 
1602
        stream_read_uint32(s, draw_gdiplus_end->cbTotalEmfSize); /* cbTotalEmfSize (4 bytes) */
 
1603
        stream_seek(s, draw_gdiplus_end->cbSize); /* emfRecords */
 
1604
}
 
1605
 
 
1606
void update_read_draw_gdiplus_cache_first_order(STREAM* s, DRAW_GDIPLUS_CACHE_FIRST_ORDER* draw_gdiplus_cache_first)
 
1607
{
 
1608
        stream_read_uint8(s, draw_gdiplus_cache_first->flags); /* flags (1 byte) */
 
1609
        stream_read_uint16(s, draw_gdiplus_cache_first->cacheType); /* cacheType (2 bytes) */
 
1610
        stream_read_uint16(s, draw_gdiplus_cache_first->cacheIndex); /* cacheIndex (2 bytes) */
 
1611
        stream_read_uint16(s, draw_gdiplus_cache_first->cbSize); /* cbSize (2 bytes) */
 
1612
        stream_read_uint32(s, draw_gdiplus_cache_first->cbTotalSize); /* cbTotalSize (4 bytes) */
 
1613
        stream_seek(s, draw_gdiplus_cache_first->cbSize); /* emfRecords */
 
1614
}
 
1615
 
 
1616
void update_read_draw_gdiplus_cache_next_order(STREAM* s, DRAW_GDIPLUS_CACHE_NEXT_ORDER* draw_gdiplus_cache_next)
 
1617
{
 
1618
        stream_read_uint8(s, draw_gdiplus_cache_next->flags); /* flags (1 byte) */
 
1619
        stream_read_uint16(s, draw_gdiplus_cache_next->cacheType); /* cacheType (2 bytes) */
 
1620
        stream_read_uint16(s, draw_gdiplus_cache_next->cacheIndex); /* cacheIndex (2 bytes) */
 
1621
        stream_read_uint16(s, draw_gdiplus_cache_next->cbSize); /* cbSize (2 bytes) */
 
1622
        stream_seek(s, draw_gdiplus_cache_next->cbSize); /* emfRecords */
 
1623
}
 
1624
 
 
1625
void update_read_draw_gdiplus_cache_end_order(STREAM* s, DRAW_GDIPLUS_CACHE_END_ORDER* draw_gdiplus_cache_end)
 
1626
{
 
1627
        stream_read_uint8(s, draw_gdiplus_cache_end->flags); /* flags (1 byte) */
 
1628
        stream_read_uint16(s, draw_gdiplus_cache_end->cacheType); /* cacheType (2 bytes) */
 
1629
        stream_read_uint16(s, draw_gdiplus_cache_end->cacheIndex); /* cacheIndex (2 bytes) */
 
1630
        stream_read_uint16(s, draw_gdiplus_cache_end->cbSize); /* cbSize (2 bytes) */
 
1631
        stream_read_uint32(s, draw_gdiplus_cache_end->cbTotalSize); /* cbTotalSize (4 bytes) */
 
1632
        stream_seek(s, draw_gdiplus_cache_end->cbSize); /* emfRecords */
 
1633
}
 
1634
 
 
1635
void update_read_field_flags(STREAM* s, uint32* fieldFlags, uint8 flags, uint8 fieldBytes)
 
1636
{
 
1637
        int i;
 
1638
        uint8 byte;
 
1639
 
 
1640
        if (flags & ORDER_ZERO_FIELD_BYTE_BIT0)
 
1641
                fieldBytes--;
 
1642
 
 
1643
        if (flags & ORDER_ZERO_FIELD_BYTE_BIT1)
 
1644
        {
 
1645
                if (fieldBytes > 1)
 
1646
                        fieldBytes -= 2;
 
1647
                else
 
1648
                        fieldBytes = 0;
 
1649
        }
 
1650
 
 
1651
        *fieldFlags = 0;
 
1652
        for (i = 0; i < fieldBytes; i++)
 
1653
        {
 
1654
                stream_read_uint8(s, byte);
 
1655
                *fieldFlags |= byte << (i * 8);
 
1656
        }
 
1657
}
 
1658
 
 
1659
void update_read_bounds(STREAM* s, rdpBounds* bounds)
 
1660
{
 
1661
        uint8 flags;
 
1662
 
 
1663
        stream_read_uint8(s, flags); /* field flags */
 
1664
 
 
1665
        if (flags & BOUND_LEFT)
 
1666
                update_read_coord(s, &bounds->left, false);
 
1667
        else if (flags & BOUND_DELTA_LEFT)
 
1668
                update_read_coord(s, &bounds->left, true);
 
1669
 
 
1670
        if (flags & BOUND_TOP)
 
1671
                update_read_coord(s, &bounds->top, false);
 
1672
        else if (flags & BOUND_DELTA_TOP)
 
1673
                update_read_coord(s, &bounds->top, true);
 
1674
 
 
1675
        if (flags & BOUND_RIGHT)
 
1676
                update_read_coord(s, &bounds->right, false);
 
1677
        else if (flags & BOUND_DELTA_RIGHT)
 
1678
                update_read_coord(s, &bounds->right, true);
 
1679
 
 
1680
        if (flags & BOUND_BOTTOM)
 
1681
                update_read_coord(s, &bounds->bottom, false);
 
1682
        else if (flags & BOUND_DELTA_BOTTOM)
 
1683
                update_read_coord(s, &bounds->bottom, true);
 
1684
}
 
1685
 
 
1686
void update_recv_primary_order(rdpUpdate* update, STREAM* s, uint8 flags)
 
1687
{
 
1688
        ORDER_INFO* orderInfo;
 
1689
        rdpContext* context = update->context;
 
1690
        rdpPrimaryUpdate* primary = update->primary;
 
1691
 
 
1692
        orderInfo = &(primary->order_info);
 
1693
 
 
1694
        if (flags & ORDER_TYPE_CHANGE)
 
1695
                stream_read_uint8(s, orderInfo->orderType); /* orderType (1 byte) */
 
1696
 
 
1697
        update_read_field_flags(s, &(orderInfo->fieldFlags), flags,
 
1698
                        PRIMARY_DRAWING_ORDER_FIELD_BYTES[orderInfo->orderType]);
 
1699
 
 
1700
        if (flags & ORDER_BOUNDS)
 
1701
        {
 
1702
                if (!(flags & ORDER_ZERO_BOUNDS_DELTAS))
 
1703
                        update_read_bounds(s, &orderInfo->bounds);
 
1704
 
 
1705
                IFCALL(update->SetBounds, context, &orderInfo->bounds);
 
1706
        }
 
1707
 
 
1708
        orderInfo->deltaCoordinates = (flags & ORDER_DELTA_COORDINATES) ? true : false;
 
1709
 
 
1710
#ifdef WITH_DEBUG_ORDERS
 
1711
        if (orderInfo->orderType < PRIMARY_DRAWING_ORDER_COUNT)
 
1712
                printf("%s Primary Drawing Order (0x%02X)\n", PRIMARY_DRAWING_ORDER_STRINGS[orderInfo->orderType], orderInfo->orderType);
 
1713
        else
 
1714
                printf("Unknown Primary Drawing Order (0x%02X)\n", orderInfo->orderType);
 
1715
#endif
 
1716
 
 
1717
        switch (orderInfo->orderType)
 
1718
        {
 
1719
                case ORDER_TYPE_DSTBLT:
 
1720
                        update_read_dstblt_order(s, orderInfo, &(primary->dstblt));
 
1721
                        IFCALL(primary->DstBlt, context, &primary->dstblt);
 
1722
                        break;
 
1723
 
 
1724
                case ORDER_TYPE_PATBLT:
 
1725
                        update_read_patblt_order(s, orderInfo, &(primary->patblt));
 
1726
                        IFCALL(primary->PatBlt, context, &primary->patblt);
 
1727
                        break;
 
1728
 
 
1729
                case ORDER_TYPE_SCRBLT:
 
1730
                        update_read_scrblt_order(s, orderInfo, &(primary->scrblt));
 
1731
                        IFCALL(primary->ScrBlt, context, &primary->scrblt);
 
1732
                        break;
 
1733
 
 
1734
                case ORDER_TYPE_OPAQUE_RECT:
 
1735
                        update_read_opaque_rect_order(s, orderInfo, &(primary->opaque_rect));
 
1736
                        IFCALL(primary->OpaqueRect, context, &primary->opaque_rect);
 
1737
                        break;
 
1738
 
 
1739
                case ORDER_TYPE_DRAW_NINE_GRID:
 
1740
                        update_read_draw_nine_grid_order(s, orderInfo, &(primary->draw_nine_grid));
 
1741
                        IFCALL(primary->DrawNineGrid, context, &primary->draw_nine_grid);
 
1742
                        break;
 
1743
 
 
1744
                case ORDER_TYPE_MULTI_DSTBLT:
 
1745
                        update_read_multi_dstblt_order(s, orderInfo, &(primary->multi_dstblt));
 
1746
                        IFCALL(primary->MultiDstBlt, context, &primary->multi_dstblt);
 
1747
                        break;
 
1748
 
 
1749
                case ORDER_TYPE_MULTI_PATBLT:
 
1750
                        update_read_multi_patblt_order(s, orderInfo, &(primary->multi_patblt));
 
1751
                        IFCALL(primary->MultiPatBlt, context, &primary->multi_patblt);
 
1752
                        break;
 
1753
 
 
1754
                case ORDER_TYPE_MULTI_SCRBLT:
 
1755
                        update_read_multi_scrblt_order(s, orderInfo, &(primary->multi_scrblt));
 
1756
                        IFCALL(primary->MultiScrBlt, context, &primary->multi_scrblt);
 
1757
                        break;
 
1758
 
 
1759
                case ORDER_TYPE_MULTI_OPAQUE_RECT:
 
1760
                        update_read_multi_opaque_rect_order(s, orderInfo, &(primary->multi_opaque_rect));
 
1761
                        IFCALL(primary->MultiOpaqueRect, context, &primary->multi_opaque_rect);
 
1762
                        break;
 
1763
 
 
1764
                case ORDER_TYPE_MULTI_DRAW_NINE_GRID:
 
1765
                        update_read_multi_draw_nine_grid_order(s, orderInfo, &(primary->multi_draw_nine_grid));
 
1766
                        IFCALL(primary->MultiDrawNineGrid, context, &primary->multi_draw_nine_grid);
 
1767
                        break;
 
1768
 
 
1769
                case ORDER_TYPE_LINE_TO:
 
1770
                        update_read_line_to_order(s, orderInfo, &(primary->line_to));
 
1771
                        IFCALL(primary->LineTo, context, &primary->line_to);
 
1772
                        break;
 
1773
 
 
1774
                case ORDER_TYPE_POLYLINE:
 
1775
                        update_read_polyline_order(s, orderInfo, &(primary->polyline));
 
1776
                        IFCALL(primary->Polyline, context, &primary->polyline);
 
1777
                        break;
 
1778
 
 
1779
                case ORDER_TYPE_MEMBLT:
 
1780
                        update_read_memblt_order(s, orderInfo, &(primary->memblt));
 
1781
                        IFCALL(primary->MemBlt, context, &primary->memblt);
 
1782
                        break;
 
1783
 
 
1784
                case ORDER_TYPE_MEM3BLT:
 
1785
                        update_read_mem3blt_order(s, orderInfo, &(primary->mem3blt));
 
1786
                        IFCALL(primary->Mem3Blt, context, &primary->mem3blt);
 
1787
                        break;
 
1788
 
 
1789
                case ORDER_TYPE_SAVE_BITMAP:
 
1790
                        update_read_save_bitmap_order(s, orderInfo, &(primary->save_bitmap));
 
1791
                        IFCALL(primary->SaveBitmap, context, &primary->save_bitmap);
 
1792
                        break;
 
1793
 
 
1794
                case ORDER_TYPE_GLYPH_INDEX:
 
1795
                        update_read_glyph_index_order(s, orderInfo, &(primary->glyph_index));
 
1796
                        IFCALL(primary->GlyphIndex, context, &primary->glyph_index);
 
1797
                        break;
 
1798
 
 
1799
                case ORDER_TYPE_FAST_INDEX:
 
1800
                        update_read_fast_index_order(s, orderInfo, &(primary->fast_index));
 
1801
                        IFCALL(primary->FastIndex, context, &primary->fast_index);
 
1802
                        break;
 
1803
 
 
1804
                case ORDER_TYPE_FAST_GLYPH:
 
1805
                        update_read_fast_glyph_order(s, orderInfo, &(primary->fast_glyph));
 
1806
                        IFCALL(primary->FastGlyph, context, &primary->fast_glyph);
 
1807
                        break;
 
1808
 
 
1809
                case ORDER_TYPE_POLYGON_SC:
 
1810
                        update_read_polygon_sc_order(s, orderInfo, &(primary->polygon_sc));
 
1811
                        IFCALL(primary->PolygonSC, context, &primary->polygon_sc);
 
1812
                        break;
 
1813
 
 
1814
                case ORDER_TYPE_POLYGON_CB:
 
1815
                        update_read_polygon_cb_order(s, orderInfo, &(primary->polygon_cb));
 
1816
                        IFCALL(primary->PolygonCB, context, &primary->polygon_cb);
 
1817
                        break;
 
1818
 
 
1819
                case ORDER_TYPE_ELLIPSE_SC:
 
1820
                        update_read_ellipse_sc_order(s, orderInfo, &(primary->ellipse_sc));
 
1821
                        IFCALL(primary->EllipseSC, context, &primary->ellipse_sc);
 
1822
                        break;
 
1823
 
 
1824
                case ORDER_TYPE_ELLIPSE_CB:
 
1825
                        update_read_ellipse_cb_order(s, orderInfo, &(primary->ellipse_cb));
 
1826
                        IFCALL(primary->EllipseCB, context, &primary->ellipse_cb);
 
1827
                        break;
 
1828
 
 
1829
                default:
 
1830
                        break;
 
1831
        }
 
1832
 
 
1833
        if (flags & ORDER_BOUNDS)
 
1834
        {
 
1835
                IFCALL(update->SetBounds, context, NULL);
 
1836
        }
 
1837
}
 
1838
 
 
1839
void update_recv_secondary_order(rdpUpdate* update, STREAM* s, uint8 flags)
 
1840
{
 
1841
        uint8* next;
 
1842
        uint8 orderType;
 
1843
        uint16 extraFlags;
 
1844
        uint16 orderLength;
 
1845
        rdpContext* context = update->context;
 
1846
        rdpSecondaryUpdate* secondary = update->secondary;
 
1847
 
 
1848
        stream_read_uint16(s, orderLength); /* orderLength (2 bytes) */
 
1849
        stream_read_uint16(s, extraFlags); /* extraFlags (2 bytes) */
 
1850
        stream_read_uint8(s, orderType); /* orderType (1 byte) */
 
1851
 
 
1852
        next = s->p + ((sint16) orderLength) + 7;
 
1853
 
 
1854
#ifdef WITH_DEBUG_ORDERS
 
1855
        if (orderType < SECONDARY_DRAWING_ORDER_COUNT)
 
1856
                printf("%s Secondary Drawing Order (0x%02X)\n", SECONDARY_DRAWING_ORDER_STRINGS[orderType], orderType);
 
1857
        else
 
1858
                printf("Unknown Secondary Drawing Order (0x%02X)\n", orderType);
 
1859
#endif
 
1860
 
 
1861
        switch (orderType)
 
1862
        {
 
1863
                case ORDER_TYPE_BITMAP_UNCOMPRESSED:
 
1864
                        update_read_cache_bitmap_order(s, &(secondary->cache_bitmap_order), false, extraFlags);
 
1865
                        IFCALL(secondary->CacheBitmap, context, &(secondary->cache_bitmap_order));
 
1866
                        break;
 
1867
 
 
1868
                case ORDER_TYPE_CACHE_BITMAP_COMPRESSED:
 
1869
                        update_read_cache_bitmap_order(s, &(secondary->cache_bitmap_order), true, extraFlags);
 
1870
                        IFCALL(secondary->CacheBitmap, context, &(secondary->cache_bitmap_order));
 
1871
                        break;
 
1872
 
 
1873
                case ORDER_TYPE_BITMAP_UNCOMPRESSED_V2:
 
1874
                        update_read_cache_bitmap_v2_order(s, &(secondary->cache_bitmap_v2_order), false, extraFlags);
 
1875
                        IFCALL(secondary->CacheBitmapV2, context, &(secondary->cache_bitmap_v2_order));
 
1876
                        break;
 
1877
 
 
1878
                case ORDER_TYPE_BITMAP_COMPRESSED_V2:
 
1879
                        update_read_cache_bitmap_v2_order(s, &(secondary->cache_bitmap_v2_order), true, extraFlags);
 
1880
                        IFCALL(secondary->CacheBitmapV2, context, &(secondary->cache_bitmap_v2_order));
 
1881
                        break;
 
1882
 
 
1883
                case ORDER_TYPE_BITMAP_COMPRESSED_V3:
 
1884
                        update_read_cache_bitmap_v3_order(s, &(secondary->cache_bitmap_v3_order), true, extraFlags);
 
1885
                        IFCALL(secondary->CacheBitmapV3, context, &(secondary->cache_bitmap_v3_order));
 
1886
                        break;
 
1887
 
 
1888
                case ORDER_TYPE_CACHE_COLOR_TABLE:
 
1889
                        update_read_cache_color_table_order(s, &(secondary->cache_color_table_order), extraFlags);
 
1890
                        IFCALL(secondary->CacheColorTable, context, &(secondary->cache_color_table_order));
 
1891
                        break;
 
1892
 
 
1893
                case ORDER_TYPE_CACHE_GLYPH:
 
1894
                        if (secondary->glyph_v2)
 
1895
                        {
 
1896
                                update_read_cache_glyph_v2_order(s, &(secondary->cache_glyph_v2_order), extraFlags);
 
1897
                                IFCALL(secondary->CacheGlyphV2, context, &(secondary->cache_glyph_v2_order));
 
1898
                        }
 
1899
                        else
 
1900
                        {
 
1901
                                update_read_cache_glyph_order(s, &(secondary->cache_glyph_order), extraFlags);
 
1902
                                IFCALL(secondary->CacheGlyph, context, &(secondary->cache_glyph_order));
 
1903
                        }
 
1904
                        break;
 
1905
 
 
1906
                case ORDER_TYPE_CACHE_BRUSH:
 
1907
                        update_read_cache_brush_order(s, &(secondary->cache_brush_order), extraFlags);
 
1908
                        IFCALL(secondary->CacheBrush, context, &(secondary->cache_brush_order));
 
1909
                        break;
 
1910
 
 
1911
                default:
 
1912
                        break;
 
1913
        }
 
1914
 
 
1915
        s->p = next;
 
1916
}
 
1917
 
 
1918
void update_recv_altsec_order(rdpUpdate* update, STREAM* s, uint8 flags)
 
1919
{
 
1920
        uint8 orderType;
 
1921
        rdpContext* context = update->context;
 
1922
        rdpAltSecUpdate* altsec = update->altsec;
 
1923
 
 
1924
        orderType = flags >>= 2; /* orderType is in higher 6 bits of flags field */
 
1925
 
 
1926
#ifdef WITH_DEBUG_ORDERS
 
1927
        if (orderType < ALTSEC_DRAWING_ORDER_COUNT)
 
1928
                printf("%s Alternate Secondary Drawing Order (0x%02X)\n", ALTSEC_DRAWING_ORDER_STRINGS[orderType], orderType);
 
1929
        else
 
1930
                printf("Unknown Alternate Secondary Drawing Order: 0x%02X\n", orderType);
 
1931
#endif
 
1932
 
 
1933
        switch (orderType)
 
1934
        {
 
1935
                case ORDER_TYPE_CREATE_OFFSCREEN_BITMAP:
 
1936
                        update_read_create_offscreen_bitmap_order(s, &(altsec->create_offscreen_bitmap));
 
1937
                        IFCALL(altsec->CreateOffscreenBitmap, context, &(altsec->create_offscreen_bitmap));
 
1938
                        break;
 
1939
 
 
1940
                case ORDER_TYPE_SWITCH_SURFACE:
 
1941
                        update_read_switch_surface_order(s, &(altsec->switch_surface));
 
1942
                        IFCALL(altsec->SwitchSurface, context, &(altsec->switch_surface));
 
1943
                        break;
 
1944
 
 
1945
                case ORDER_TYPE_CREATE_NINE_GRID_BITMAP:
 
1946
                        update_read_create_nine_grid_bitmap_order(s, &(altsec->create_nine_grid_bitmap));
 
1947
                        IFCALL(altsec->CreateNineGridBitmap, context, &(altsec->create_nine_grid_bitmap));
 
1948
                        break;
 
1949
 
 
1950
                case ORDER_TYPE_FRAME_MARKER:
 
1951
                        update_read_frame_marker_order(s, &(altsec->frame_marker));
 
1952
                        IFCALL(altsec->FrameMarker, context, &(altsec->frame_marker));
 
1953
                        break;
 
1954
 
 
1955
                case ORDER_TYPE_STREAM_BITMAP_FIRST:
 
1956
                        update_read_stream_bitmap_first_order(s, &(altsec->stream_bitmap_first));
 
1957
                        IFCALL(altsec->StreamBitmapFirst, context, &(altsec->stream_bitmap_first));
 
1958
                        break;
 
1959
 
 
1960
                case ORDER_TYPE_STREAM_BITMAP_NEXT:
 
1961
                        update_read_stream_bitmap_next_order(s, &(altsec->stream_bitmap_next));
 
1962
                        IFCALL(altsec->StreamBitmapNext, context, &(altsec->stream_bitmap_next));
 
1963
                        break;
 
1964
 
 
1965
                case ORDER_TYPE_GDIPLUS_FIRST:
 
1966
                        update_read_draw_gdiplus_first_order(s, &(altsec->draw_gdiplus_first));
 
1967
                        IFCALL(altsec->DrawGdiPlusFirst, context, &(altsec->draw_gdiplus_first));
 
1968
                        break;
 
1969
 
 
1970
                case ORDER_TYPE_GDIPLUS_NEXT:
 
1971
                        update_read_draw_gdiplus_next_order(s, &(altsec->draw_gdiplus_next));
 
1972
                        IFCALL(altsec->DrawGdiPlusNext, context, &(altsec->draw_gdiplus_next));
 
1973
                        break;
 
1974
 
 
1975
                case ORDER_TYPE_GDIPLUS_END:
 
1976
                        update_read_draw_gdiplus_end_order(s, &(altsec->draw_gdiplus_end));
 
1977
                        IFCALL(altsec->DrawGdiPlusEnd, context, &(altsec->draw_gdiplus_end));
 
1978
                        break;
 
1979
 
 
1980
                case ORDER_TYPE_GDIPLUS_CACHE_FIRST:
 
1981
                        update_read_draw_gdiplus_cache_first_order(s, &(altsec->draw_gdiplus_cache_first));
 
1982
                        IFCALL(altsec->DrawGdiPlusCacheFirst, context, &(altsec->draw_gdiplus_cache_first));
 
1983
                        break;
 
1984
 
 
1985
                case ORDER_TYPE_GDIPLUS_CACHE_NEXT:
 
1986
                        update_read_draw_gdiplus_cache_next_order(s, &(altsec->draw_gdiplus_cache_next));
 
1987
                        IFCALL(altsec->DrawGdiPlusCacheNext, context, &(altsec->draw_gdiplus_cache_next));
 
1988
                        break;
 
1989
 
 
1990
                case ORDER_TYPE_GDIPLUS_CACHE_END:
 
1991
                        update_read_draw_gdiplus_cache_end_order(s, &(altsec->draw_gdiplus_cache_end));
 
1992
                        IFCALL(altsec->DrawGdiPlusCacheEnd, context, &(altsec->draw_gdiplus_cache_end));
 
1993
                        break;
 
1994
 
 
1995
                case ORDER_TYPE_WINDOW:
 
1996
                        update_recv_altsec_window_order(update, s);
 
1997
                        break;
 
1998
 
 
1999
                case ORDER_TYPE_COMPDESK_FIRST:
 
2000
                        break;
 
2001
 
 
2002
                default:
 
2003
                        break;
 
2004
        }
 
2005
}
 
2006
 
 
2007
void update_recv_order(rdpUpdate* update, STREAM* s)
 
2008
{
 
2009
        uint8 controlFlags;
 
2010
 
 
2011
        stream_read_uint8(s, controlFlags); /* controlFlags (1 byte) */
 
2012
 
 
2013
        if (!(controlFlags & ORDER_STANDARD))
 
2014
                update_recv_altsec_order(update, s, controlFlags);
 
2015
        else if (controlFlags & ORDER_SECONDARY)
 
2016
                update_recv_secondary_order(update, s, controlFlags);
 
2017
        else
 
2018
                update_recv_primary_order(update, s, controlFlags);
 
2019
}
 
2020