← Back to branch summary

~ubuntu-branches/ubuntu/wily/freerdp/wily-proposed

« back to all changes in this revision

Viewing changes to client/Windows/wf_gdi.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:
client/Windows/wf_gdi.c
 
1
/**
 
2
 * FreeRDP: A Remote Desktop Protocol Client
 
3
 * Windows GDI
 
4
 *
 
5
 * Copyright 2009-2011 Jay Sorg
 
6
 * Copyright 2010-2011 Vic Lee
 
7
 * Copyright 2010-2011 Marc-Andre Moreau <marcandre.moreau@gmail.com>
 
8
 *
 
9
 * Licensed under the Apache License, Version 2.0 (the "License");
 
10
 * you may not use this file except in compliance with the License.
 
11
 * You may obtain a copy of the License at
 
12
 *
 
13
 *     http://www.apache.org/licenses/LICENSE-2.0
 
14
 *
 
15
 * Unless required by applicable law or agreed to in writing, software
 
16
 * distributed under the License is distributed on an "AS IS" BASIS,
 
17
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
18
 * See the License for the specific language governing permissions and
 
19
 * limitations under the License.
 
20
 */
 
21
 
 
22
#include <stdio.h>
 
23
#include <stdlib.h>
 
24
#include <string.h>
 
25
#include <conio.h>
 
26
 
 
27
#include <freerdp/gdi/gdi.h>
 
28
#include <freerdp/constants.h>
 
29
#include <freerdp/codec/color.h>
 
30
#include <freerdp/codec/bitmap.h>
 
31
#include <freerdp/utils/memory.h>
 
32
#include <freerdp/codec/rfx.h>
 
33
#include <freerdp/codec/nsc.h>
 
34
 
 
35
#include "wfreerdp.h"
 
36
#include "wf_graphics.h"
 
37
 
 
38
const uint8 wf_rop2_table[] =
 
39
{
 
40
        R2_BLACK,       /* 0 */
 
41
        R2_NOTMERGEPEN, /* DPon */
 
42
        R2_MASKNOTPEN,  /* DPna */
 
43
        R2_NOTCOPYPEN,  /* Pn */
 
44
        R2_MASKPENNOT,  /* PDna */
 
45
        R2_NOT,         /* Dn */
 
46
        R2_XORPEN,      /* DPx */
 
47
        R2_NOTMASKPEN,  /* DPan */
 
48
        R2_MASKPEN,     /* DPa */
 
49
        R2_NOTXORPEN,   /* DPxn */
 
50
        R2_NOP,         /* D */
 
51
        R2_MERGENOTPEN, /* DPno */
 
52
        R2_COPYPEN,     /* P */
 
53
        R2_MERGEPENNOT, /* PDno */
 
54
        R2_MERGEPEN,    /* PDo */
 
55
        R2_WHITE,       /* 1 */
 
56
};
 
57
 
 
58
boolean wf_set_rop2(HDC hdc, int rop2)
 
59
{
 
60
        if ((rop2 < 0x01) || (rop2 > 0x10))
 
61
        {
 
62
                printf("Unsupported ROP2: %d\n", rop2);
 
63
                return false;
 
64
        }
 
65
 
 
66
        SetROP2(hdc, wf_rop2_table[rop2 - 1]);
 
67
 
 
68
        return true;
 
69
}
 
70
 
 
71
wfBitmap* wf_glyph_new(wfInfo* wfi, GLYPH_DATA* glyph)
 
72
{
 
73
        wfBitmap* glyph_bmp;
 
74
        glyph_bmp = wf_image_new(wfi, glyph->cx, glyph->cy, 1, glyph->aj);
 
75
        return glyph_bmp;
 
76
}
 
77
 
 
78
void wf_glyph_free(wfBitmap* glyph)
 
79
{
 
80
        wf_image_free(glyph);
 
81
}
 
82
 
 
83
uint8* wf_glyph_convert(wfInfo* wfi, int width, int height, uint8* data)
 
84
{
 
85
        int indexx;
 
86
        int indexy;
 
87
        uint8* src;
 
88
        uint8* dst;
 
89
        uint8* cdata;
 
90
        int src_bytes_per_row;
 
91
        int dst_bytes_per_row;
 
92
 
 
93
        src_bytes_per_row = (width + 7) / 8;
 
94
        dst_bytes_per_row = src_bytes_per_row + (src_bytes_per_row % 2);
 
95
        cdata = (uint8 *) malloc(dst_bytes_per_row * height);
 
96
 
 
97
        src = data;
 
98
        for (indexy = 0; indexy < height; indexy++)
 
99
        {
 
100
                dst = cdata + indexy * dst_bytes_per_row;
 
101
 
 
102
                for (indexx = 0; indexx < dst_bytes_per_row; indexx++)
 
103
                {
 
104
                        if (indexx < src_bytes_per_row)
 
105
                                *dst++ = *src++;
 
106
                        else
 
107
                                *dst++ = 0;
 
108
                }
 
109
        }
 
110
 
 
111
        return cdata;
 
112
}
 
113
 
 
114
HBRUSH wf_create_brush(wfInfo * wfi, rdpBrush* brush, uint32 color, int bpp)
 
115
{
 
116
        int i;
 
117
        HBRUSH br;
 
118
        LOGBRUSH lbr;
 
119
        uint8* cdata;
 
120
        uint8 ipattern[8];
 
121
        HBITMAP pattern = NULL;
 
122
 
 
123
        lbr.lbStyle = brush->style;
 
124
 
 
125
        if (lbr.lbStyle == BS_DIBPATTERN || lbr.lbStyle == BS_DIBPATTERN8X8 || lbr.lbStyle == BS_DIBPATTERNPT)
 
126
                lbr.lbColor = DIB_RGB_COLORS;
 
127
        else
 
128
                lbr.lbColor = color;
 
129
 
 
130
        if (lbr.lbStyle == BS_PATTERN || lbr.lbStyle == BS_PATTERN8X8)
 
131
        {
 
132
                if (brush->bpp > 1)
 
133
                {
 
134
                        pattern = wf_create_dib(wfi, 8, 8, bpp, brush->data, NULL);
 
135
                        lbr.lbHatch = (ULONG_PTR) pattern;
 
136
                }
 
137
                else
 
138
                {
 
139
                        for (i = 0; i != 8; i++)
 
140
                                ipattern[7 - i] = brush->data[i];
 
141
        
 
142
                        cdata = wf_glyph_convert(wfi, 8, 8, ipattern);
 
143
                        pattern = CreateBitmap(8, 8, 1, 1, cdata);
 
144
                        lbr.lbHatch = (ULONG_PTR) pattern;
 
145
                        free(cdata);
 
146
                }
 
147
        }
 
148
        else if (lbr.lbStyle == BS_HATCHED)
 
149
        {
 
150
                lbr.lbHatch = brush->hatch;
 
151
        }
 
152
        else
 
153
        {
 
154
                lbr.lbHatch = 0;
 
155
        }
 
156
 
 
157
        br = CreateBrushIndirect(&lbr);
 
158
        SetBrushOrgEx(wfi->drawing->hdc, brush->x, brush->y, NULL);
 
159
 
 
160
        if (pattern != NULL)
 
161
                DeleteObject(pattern);
 
162
 
 
163
        return br;
 
164
}
 
165
 
 
166
void wf_invalidate_region(wfInfo* wfi, int x, int y, int width, int height)
 
167
{
 
168
        wfi->update_rect.left = x;
 
169
        wfi->update_rect.top = y;
 
170
        wfi->update_rect.right = x + width;
 
171
        wfi->update_rect.bottom = y + height;
 
172
        InvalidateRect(wfi->hwnd, &(wfi->update_rect), FALSE);
 
173
        gdi_InvalidateRegion(wfi->hdc, x, y, width, height);
 
174
}
 
175
 
 
176
void wf_toggle_fullscreen(wfInfo* wfi)
 
177
{
 
178
        ShowWindow(wfi->hwnd, SW_HIDE);
 
179
        wfi->fullscreen = !wfi->fullscreen;
 
180
        SetForegroundWindow(wfi->hwnd);
 
181
}
 
182
 
 
183
void wf_gdi_palette_update(rdpContext* context, PALETTE_UPDATE* palette)
 
184
{
 
185
 
 
186
}
 
187
 
 
188
void wf_set_null_clip_rgn(wfInfo* wfi)
 
189
{
 
190
        SelectClipRgn(wfi->drawing->hdc, NULL);
 
191
}
 
192
 
 
193
void wf_set_clip_rgn(wfInfo* wfi, int x, int y, int width, int height)
 
194
{
 
195
        HRGN clip;
 
196
        clip = CreateRectRgn(x, y, x + width, y + height);
 
197
        SelectClipRgn(wfi->drawing->hdc, clip);
 
198
        DeleteObject(clip);
 
199
}
 
200
 
 
201
void wf_gdi_set_bounds(rdpContext* context, rdpBounds* bounds)
 
202
{
 
203
        HRGN hrgn;
 
204
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
205
 
 
206
        if (bounds != NULL)
 
207
        {
 
208
                hrgn = CreateRectRgn(bounds->left, bounds->top, bounds->right + 1, bounds->bottom + 1);
 
209
                SelectClipRgn(wfi->drawing->hdc, hrgn);
 
210
                DeleteObject(hrgn);
 
211
        }
 
212
        else
 
213
        {
 
214
                SelectClipRgn(wfi->drawing->hdc, NULL);
 
215
        }
 
216
}
 
217
 
 
218
void wf_gdi_dstblt(rdpContext* context, DSTBLT_ORDER* dstblt)
 
219
{
 
220
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
221
 
 
222
        BitBlt(wfi->drawing->hdc, dstblt->nLeftRect, dstblt->nTopRect,
 
223
                        dstblt->nWidth, dstblt->nHeight, NULL, 0, 0, gdi_rop3_code(dstblt->bRop));
 
224
 
 
225
        wf_invalidate_region(wfi, dstblt->nLeftRect, dstblt->nTopRect,
 
226
                        dstblt->nWidth, dstblt->nHeight);
 
227
}
 
228
 
 
229
void wf_gdi_patblt(rdpContext* context, PATBLT_ORDER* patblt)
 
230
{
 
231
        HBRUSH brush;
 
232
        HBRUSH org_brush;
 
233
        int org_bkmode;
 
234
        uint32 fgcolor;
 
235
        uint32 bgcolor;
 
236
        COLORREF org_bkcolor;
 
237
        COLORREF org_textcolor;
 
238
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
239
 
 
240
        fgcolor = freerdp_color_convert_bgr(patblt->foreColor, wfi->srcBpp, 32, wfi->clrconv);
 
241
        bgcolor = freerdp_color_convert_bgr(patblt->backColor, wfi->srcBpp, 32, wfi->clrconv);
 
242
 
 
243
        brush = wf_create_brush(wfi, &patblt->brush, fgcolor, wfi->srcBpp);
 
244
        org_bkmode = SetBkMode(wfi->drawing->hdc, OPAQUE);
 
245
        org_bkcolor = SetBkColor(wfi->drawing->hdc, bgcolor);
 
246
        org_textcolor = SetTextColor(wfi->drawing->hdc, fgcolor);
 
247
        org_brush = (HBRUSH)SelectObject(wfi->drawing->hdc, brush);
 
248
 
 
249
        PatBlt(wfi->drawing->hdc, patblt->nLeftRect, patblt->nTopRect,
 
250
                patblt->nWidth, patblt->nHeight, gdi_rop3_code(patblt->bRop));
 
251
 
 
252
        SelectObject(wfi->drawing->hdc, org_brush);
 
253
        DeleteObject(brush);
 
254
 
 
255
        SetBkMode(wfi->drawing->hdc, org_bkmode);
 
256
        SetBkColor(wfi->drawing->hdc, org_bkcolor);
 
257
        SetTextColor(wfi->drawing->hdc, org_textcolor);
 
258
 
 
259
        if (wfi->drawing == wfi->primary)
 
260
                wf_invalidate_region(wfi, patblt->nLeftRect, patblt->nTopRect, patblt->nWidth, patblt->nHeight);
 
261
}
 
262
 
 
263
void wf_gdi_scrblt(rdpContext* context, SCRBLT_ORDER* scrblt)
 
264
{
 
265
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
266
 
 
267
        BitBlt(wfi->drawing->hdc, scrblt->nLeftRect, scrblt->nTopRect,
 
268
                        scrblt->nWidth, scrblt->nHeight, wfi->primary->hdc,
 
269
                        scrblt->nXSrc, scrblt->nYSrc, gdi_rop3_code(scrblt->bRop));
 
270
 
 
271
        wf_invalidate_region(wfi, scrblt->nLeftRect, scrblt->nTopRect,
 
272
                        scrblt->nWidth, scrblt->nHeight);
 
273
}
 
274
 
 
275
void wf_gdi_opaque_rect(rdpContext* context, OPAQUE_RECT_ORDER* opaque_rect)
 
276
{
 
277
        RECT rect;
 
278
        HBRUSH brush;
 
279
        uint32 brush_color;
 
280
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
281
 
 
282
        brush_color = freerdp_color_convert_var_bgr(opaque_rect->color, wfi->srcBpp, 24, wfi->clrconv);
 
283
 
 
284
        rect.left = opaque_rect->nLeftRect;
 
285
        rect.top = opaque_rect->nTopRect;
 
286
        rect.right = opaque_rect->nLeftRect + opaque_rect->nWidth;
 
287
        rect.bottom = opaque_rect->nTopRect + opaque_rect->nHeight;
 
288
        brush = CreateSolidBrush(brush_color);
 
289
        FillRect(wfi->drawing->hdc, &rect, brush);
 
290
        DeleteObject(brush);
 
291
 
 
292
        if (wfi->drawing == wfi->primary)
 
293
                wf_invalidate_region(wfi, rect.left, rect.top, rect.right - rect.left + 1, rect.bottom - rect.top + 1);
 
294
}
 
295
 
 
296
void wf_gdi_multi_opaque_rect(rdpContext* context, MULTI_OPAQUE_RECT_ORDER* multi_opaque_rect)
 
297
{
 
298
        int i;
 
299
        RECT rect;
 
300
        HBRUSH brush;
 
301
        uint32 brush_color;
 
302
        DELTA_RECT* rectangle;
 
303
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
304
 
 
305
        for (i = 1; i < (int) multi_opaque_rect->numRectangles + 1; i++)
 
306
        {
 
307
                rectangle = &multi_opaque_rect->rectangles[i];
 
308
 
 
309
                brush_color = freerdp_color_convert_var_bgr(multi_opaque_rect->color, wfi->srcBpp, 32, wfi->clrconv);
 
310
 
 
311
                rect.left = rectangle->left;
 
312
                rect.top = rectangle->top;
 
313
                rect.right = rectangle->left + rectangle->width;
 
314
                rect.bottom = rectangle->top + rectangle->height;
 
315
                brush = CreateSolidBrush(brush_color);
 
316
 
 
317
                brush = CreateSolidBrush(brush_color);
 
318
                FillRect(wfi->drawing->hdc, &rect, brush);
 
319
 
 
320
                if (wfi->drawing == wfi->primary)
 
321
                        wf_invalidate_region(wfi, rect.left, rect.top, rect.right - rect.left + 1, rect.bottom - rect.top + 1);
 
322
 
 
323
                DeleteObject(brush);
 
324
        }
 
325
}
 
326
 
 
327
void wf_gdi_line_to(rdpContext* context, LINE_TO_ORDER* line_to)
 
328
{
 
329
        HPEN pen;
 
330
        HPEN org_pen;
 
331
        int x, y, w, h;
 
332
        uint32 pen_color;
 
333
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
334
 
 
335
        pen_color = freerdp_color_convert_bgr(line_to->penColor, wfi->srcBpp, wfi->dstBpp, wfi->clrconv);
 
336
 
 
337
        pen = CreatePen(line_to->penStyle, line_to->penWidth, pen_color);
 
338
 
 
339
        wf_set_rop2(wfi->drawing->hdc, line_to->bRop2);
 
340
        org_pen = (HPEN) SelectObject(wfi->drawing->hdc, pen);
 
341
        
 
342
        MoveToEx(wfi->drawing->hdc, line_to->nXStart, line_to->nYStart, NULL);
 
343
        LineTo(wfi->drawing->hdc, line_to->nXEnd, line_to->nYEnd);
 
344
 
 
345
        x = (line_to->nXStart < line_to->nXEnd) ? line_to->nXStart : line_to->nXEnd;
 
346
        y = (line_to->nYStart < line_to->nYEnd) ? line_to->nYStart : line_to->nYEnd;
 
347
        w = (line_to->nXStart < line_to->nXEnd) ? (line_to->nXEnd - line_to->nXStart) : (line_to->nXStart - line_to->nXEnd);
 
348
        h = (line_to->nYStart < line_to->nYEnd) ? (line_to->nYEnd - line_to->nYStart) : (line_to->nYStart - line_to->nYEnd);
 
349
 
 
350
        if (wfi->drawing == wfi->primary)
 
351
                wf_invalidate_region(wfi, x, y, w, h);
 
352
 
 
353
        SelectObject(wfi->drawing->hdc, org_pen);
 
354
        DeleteObject(pen);
 
355
}
 
356
 
 
357
void wf_gdi_polyline(rdpContext* context, POLYLINE_ORDER* polyline)
 
358
{
 
359
        int i;
 
360
        POINT* pts;
 
361
        int org_rop2;
 
362
        HPEN hpen;
 
363
        HPEN org_hpen;
 
364
        uint32 pen_color;
 
365
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
366
 
 
367
        pen_color = freerdp_color_convert_bgr(polyline->penColor, wfi->srcBpp, wfi->dstBpp, wfi->clrconv);
 
368
 
 
369
        hpen = CreatePen(0, 1, pen_color);
 
370
        org_rop2 = wf_set_rop2(wfi->drawing->hdc, polyline->bRop2);
 
371
        org_hpen = (HPEN) SelectObject(wfi->drawing->hdc, hpen);
 
372
 
 
373
        if (polyline->numPoints > 0)
 
374
        {
 
375
                pts = (POINT*) xmalloc(sizeof(POINT) * polyline->numPoints);
 
376
 
 
377
                for (i = 0; i < (int) polyline->numPoints; i++)
 
378
                {
 
379
                        pts[i].x = polyline->points[i].x;
 
380
                        pts[i].y = polyline->points[i].y;
 
381
 
 
382
                        if (wfi->drawing == wfi->primary)
 
383
                                wf_invalidate_region(wfi, pts[i].x, pts[i].y, pts[i].x + 1, pts[i].y + 1);
 
384
                }
 
385
 
 
386
                Polyline(wfi->drawing->hdc, pts, polyline->numPoints);
 
387
                xfree(pts);
 
388
        }
 
389
 
 
390
        SelectObject(wfi->drawing->hdc, org_hpen);
 
391
        wf_set_rop2(wfi->drawing->hdc, org_rop2);
 
392
        DeleteObject(hpen);
 
393
}
 
394
 
 
395
void wf_gdi_memblt(rdpContext* context, MEMBLT_ORDER* memblt)
 
396
{
 
397
        wfBitmap* bitmap;
 
398
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
399
 
 
400
        bitmap = (wfBitmap*) memblt->bitmap;
 
401
 
 
402
        BitBlt(wfi->drawing->hdc, memblt->nLeftRect, memblt->nTopRect,
 
403
                        memblt->nWidth, memblt->nHeight, bitmap->hdc,
 
404
                        memblt->nXSrc, memblt->nYSrc, gdi_rop3_code(memblt->bRop));
 
405
 
 
406
        if (wfi->drawing == wfi->primary)
 
407
                wf_invalidate_region(wfi, memblt->nLeftRect, memblt->nTopRect, memblt->nWidth, memblt->nHeight);
 
408
}
 
409
 
 
410
void wf_gdi_surface_bits(rdpContext* context, SURFACE_BITS_COMMAND* surface_bits_command)
 
411
{
 
412
        int i, j;
 
413
        int tx, ty;
 
414
        char* tile_bitmap;
 
415
        RFX_MESSAGE* message;
 
416
        wfInfo* wfi = ((wfContext*) context)->wfi;
 
417
 
 
418
        RFX_CONTEXT* rfx_context = (RFX_CONTEXT*) wfi->rfx_context;
 
419
        NSC_CONTEXT* nsc_context = (NSC_CONTEXT*) wfi->nsc_context;
 
420
 
 
421
        tile_bitmap = (char*) xzalloc(32);
 
422
 
 
423
        if (surface_bits_command->codecID == CODEC_ID_REMOTEFX)
 
424
        {
 
425
                message = rfx_process_message(rfx_context, surface_bits_command->bitmapData, surface_bits_command->bitmapDataLength);
 
426
 
 
427
                /* blit each tile */
 
428
                for (i = 0; i < message->num_tiles; i++)
 
429
                {
 
430
                        tx = message->tiles[i]->x + surface_bits_command->destLeft;
 
431
                        ty = message->tiles[i]->y + surface_bits_command->destTop;
 
432
 
 
433
                        freerdp_image_convert(message->tiles[i]->data, wfi->tile->pdata, 64, 64, 32, 32, wfi->clrconv);
 
434
 
 
435
                        for (j = 0; j < message->num_rects; j++)
 
436
                        {
 
437
                                wf_set_clip_rgn(wfi,
 
438
                                        surface_bits_command->destLeft + message->rects[j].x,
 
439
                                        surface_bits_command->destTop + message->rects[j].y,
 
440
                                        message->rects[j].width, message->rects[j].height);
 
441
 
 
442
                                BitBlt(wfi->primary->hdc, tx, ty, 64, 64, wfi->tile->hdc, 0, 0, SRCCOPY);
 
443
                        }
 
444
                }
 
445
 
 
446
                wf_set_null_clip_rgn(wfi);
 
447
 
 
448
                /* invalidate regions */
 
449
                for (i = 0; i < message->num_rects; i++)
 
450
                {
 
451
                        tx = surface_bits_command->destLeft + message->rects[i].x;
 
452
                        ty = surface_bits_command->destTop + message->rects[i].y;
 
453
                        wf_invalidate_region(wfi, tx, ty, message->rects[i].width, message->rects[i].height);
 
454
                }
 
455
 
 
456
                rfx_message_free(rfx_context, message);
 
457
        }
 
458
        else if (surface_bits_command->codecID == CODEC_ID_NSCODEC)
 
459
        {
 
460
                nsc_context->width = surface_bits_command->width;
 
461
                nsc_context->height = surface_bits_command->height;
 
462
                nsc_process_message(nsc_context, surface_bits_command->bitmapData, surface_bits_command->bitmapDataLength);
 
463
                wfi->image->_bitmap.width = surface_bits_command->width;
 
464
                wfi->image->_bitmap.height = surface_bits_command->height;
 
465
                wfi->image->_bitmap.bpp = surface_bits_command->bpp;
 
466
                wfi->image->_bitmap.data = (uint8*) xrealloc(wfi->image->_bitmap.data, wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
 
467
                freerdp_image_flip(nsc_context->bmpdata, wfi->image->_bitmap.data, wfi->image->_bitmap.width, wfi->image->_bitmap.height, 32);
 
468
                BitBlt(wfi->primary->hdc, surface_bits_command->destLeft, surface_bits_command->destTop, surface_bits_command->width, surface_bits_command->height, wfi->image->hdc, 0, 0, GDI_SRCCOPY);
 
469
                nsc_context_destroy(nsc_context);
 
470
        } 
 
471
        else if (surface_bits_command->codecID == CODEC_ID_NONE)
 
472
        {
 
473
                wfi->image->_bitmap.width = surface_bits_command->width;
 
474
                wfi->image->_bitmap.height = surface_bits_command->height;
 
475
                wfi->image->_bitmap.bpp = surface_bits_command->bpp;
 
476
 
 
477
                wfi->image->_bitmap.data = (uint8*) xrealloc(wfi->image->_bitmap.data,
 
478
                                wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
 
479
 
 
480
                if ((surface_bits_command->bpp != 32) || (wfi->clrconv->alpha == true))
 
481
                {
 
482
                        uint8* temp_image;
 
483
 
 
484
                        freerdp_image_convert(surface_bits_command->bitmapData, wfi->image->_bitmap.data,
 
485
                                wfi->image->_bitmap.width, wfi->image->_bitmap.height,
 
486
                                wfi->image->_bitmap.bpp, 32, wfi->clrconv);
 
487
 
 
488
                        surface_bits_command->bpp = 32;
 
489
                        surface_bits_command->bitmapData = wfi->image->_bitmap.data;
 
490
 
 
491
                        temp_image = (uint8*) xmalloc(wfi->image->_bitmap.width * wfi->image->_bitmap.height * 4);
 
492
                        freerdp_image_flip(wfi->image->_bitmap.data, temp_image, wfi->image->_bitmap.width, wfi->image->_bitmap.height, 32);
 
493
                        xfree(wfi->image->_bitmap.data);
 
494
                        wfi->image->_bitmap.data = temp_image;
 
495
                }
 
496
                else
 
497
                {
 
498
                        freerdp_image_flip(surface_bits_command->bitmapData, wfi->image->_bitmap.data,
 
499
                                        wfi->image->_bitmap.width, wfi->image->_bitmap.height, 32);
 
500
                }
 
501
 
 
502
                BitBlt(wfi->primary->hdc, surface_bits_command->destLeft, surface_bits_command->destTop,
 
503
                                surface_bits_command->width, surface_bits_command->height, wfi->image->hdc, 0, 0, SRCCOPY);
 
504
        }
 
505
        else
 
506
        {
 
507
                printf("Unsupported codecID %d\n", surface_bits_command->codecID);
 
508
        }
 
509
 
 
510
        if (tile_bitmap != NULL)
 
511
                xfree(tile_bitmap);
 
512
}
 
513
 
 
514
void wf_gdi_register_update_callbacks(rdpUpdate* update)
 
515
{
 
516
        rdpPrimaryUpdate* primary = update->primary;
 
517
 
 
518
        update->Palette = wf_gdi_palette_update;
 
519
        update->SetBounds = wf_gdi_set_bounds;
 
520
 
 
521
        primary->DstBlt = wf_gdi_dstblt;
 
522
        primary->PatBlt = wf_gdi_patblt;
 
523
        primary->ScrBlt = wf_gdi_scrblt;
 
524
        primary->OpaqueRect = wf_gdi_opaque_rect;
 
525
        primary->DrawNineGrid = NULL;
 
526
        primary->MultiDstBlt = NULL;
 
527
        primary->MultiPatBlt = NULL;
 
528
        primary->MultiScrBlt = NULL;
 
529
        primary->MultiOpaqueRect = wf_gdi_multi_opaque_rect;
 
530
        primary->MultiDrawNineGrid = NULL;
 
531
        primary->LineTo = wf_gdi_line_to;
 
532
        primary->Polyline = wf_gdi_polyline;
 
533
        primary->MemBlt = wf_gdi_memblt;
 
534
        primary->Mem3Blt = NULL;
 
535
        primary->SaveBitmap = NULL;
 
536
        primary->GlyphIndex = NULL;
 
537
        primary->FastIndex = NULL;
 
538
        primary->FastGlyph = NULL;
 
539
        primary->PolygonSC = NULL;
 
540
        primary->PolygonCB = NULL;
 
541
        primary->EllipseSC = NULL;
 
542
        primary->EllipseCB = NULL;
 
543
 
 
544
        update->SurfaceBits = wf_gdi_surface_bits;
 
545
}