/[rdesktop]/sourceforge.net/trunk/rdesktop/orders.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

Diff of /sourceforge.net/trunk/rdesktop/orders.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 17 by matty, Thu Sep 28 15:54:11 2000 UTC revision 49 by mmihalik, Fri Apr 19 12:06:08 2002 UTC
# Line 1  Line 1 
1  /*  /*
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     RDP order processing     RDP order processing
4     Copyright (C) Matthew Chapman 1999-2000     Copyright (C) Matthew Chapman 1999-2001
5    
6     This program is free software; you can redistribute it and/or modify     This program is free software; you can redistribute it and/or modify
7     it under the terms of the GNU General Public License as published by     it under the terms of the GNU General Public License as published by
# Line 21  Line 21 
21  #include "rdesktop.h"  #include "rdesktop.h"
22  #include "orders.h"  #include "orders.h"
23    
24  extern unsigned char *next_packet;  extern uint8 *next_packet;
25  static RDP_ORDER_STATE order_state;  static RDP_ORDER_STATE order_state;
26    
27  /* Read field indicating which parameters are present */  /* Read field indicating which parameters are present */
28  static void rdp_in_present(STREAM s, uint32 *present, uint8 flags, int size)  static void
29    rdp_in_present(STREAM s, uint32 *present, uint8 flags, int size)
30  {  {
31          uint8 bits;          uint8 bits;
32          int i;          int i;
# Line 52  static void rdp_in_present(STREAM s, uin Line 53  static void rdp_in_present(STREAM s, uin
53  }  }
54    
55  /* Read a co-ordinate (16-bit, or 8-bit delta) */  /* Read a co-ordinate (16-bit, or 8-bit delta) */
56  static void rdp_in_coord(STREAM s, uint16 *coord, BOOL delta)  static void
57    rdp_in_coord(STREAM s, uint16 *coord, BOOL delta)
58  {  {
59          uint8 change;          uint8 change;
60    
61          if (delta)          if (delta)
62          {          {
63                  in_uint8(s, change);                  in_uint8(s, change);
64                  *coord += (char)change;                  *coord += (signed char) change;
65          }          }
66          else          else
67          {          {
# Line 68  static void rdp_in_coord(STREAM s, uint1 Line 70  static void rdp_in_coord(STREAM s, uint1
70  }  }
71    
72  /* Read a colour entry */  /* Read a colour entry */
73  static void rdp_in_colour(STREAM s, uint8 *colour)  static void
74    rdp_in_colour(STREAM s, uint8 *colour)
75  {  {
76          in_uint8(s, *colour);          in_uint8(s, *colour);
77          s->p += 2;          s->p += 2;
78  }  }
79    
80  /* Parse bounds information */  /* Parse bounds information */
81  static BOOL rdp_parse_bounds(STREAM s, BOUNDS *bounds)  static BOOL
82    rdp_parse_bounds(STREAM s, BOUNDS *bounds)
83  {  {
84          uint8 present;          uint8 present;
85    
# Line 105  static BOOL rdp_parse_bounds(STREAM s, B Line 109  static BOOL rdp_parse_bounds(STREAM s, B
109  }  }
110    
111  /* Parse a pen */  /* Parse a pen */
112  static BOOL rdp_parse_pen(STREAM s, PEN *pen, uint32 present)  static BOOL
113    rdp_parse_pen(STREAM s, PEN *pen, uint32 present)
114  {  {
115          if (present & 1)          if (present & 1)
116                  in_uint8(s, pen->style);                  in_uint8(s, pen->style);
# Line 120  static BOOL rdp_parse_pen(STREAM s, PEN Line 125  static BOOL rdp_parse_pen(STREAM s, PEN
125  }  }
126    
127  /* Parse a brush */  /* Parse a brush */
128  static BOOL rdp_parse_brush(STREAM s, BRUSH *brush, uint32 present)  static BOOL
129    rdp_parse_brush(STREAM s, BRUSH *brush, uint32 present)
130  {  {
131          if (present & 1)          if (present & 1)
132                  in_uint8(s, brush->xorigin);                  in_uint8(s, brush->xorigin);
# Line 141  static BOOL rdp_parse_brush(STREAM s, BR Line 147  static BOOL rdp_parse_brush(STREAM s, BR
147  }  }
148    
149  /* Process a destination blt order */  /* Process a destination blt order */
150  static void process_destblt(STREAM s, DESTBLT_ORDER *os,  static void
151                                  uint32 present, BOOL delta)  process_destblt(STREAM s, DESTBLT_ORDER *os, uint32 present, BOOL delta)
152  {  {
153          if (present & 0x01)          if (present & 0x01)
154                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 159  static void process_destblt(STREAM s, DE Line 165  static void process_destblt(STREAM s, DE
165          if (present & 0x10)          if (present & 0x10)
166                  in_uint8(s, os->opcode);                  in_uint8(s, os->opcode);
167    
168          DEBUG("DESTBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d)\n",          DEBUG(("DESTBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d)\n",
169                os->opcode, os->x, os->y, os->cx, os->cy);                 os->opcode, os->x, os->y, os->cx, os->cy));
170    
171          ui_destblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy);          ui_destblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy);
172  }  }
173    
174  /* Process a pattern blt order */  /* Process a pattern blt order */
175  static void process_patblt(STREAM s, PATBLT_ORDER *os,  static void
176                                  uint32 present, BOOL delta)  process_patblt(STREAM s, PATBLT_ORDER *os, uint32 present, BOOL delta)
177  {  {
178          if (present & 0x0001)          if (present & 0x0001)
179                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 192  static void process_patblt(STREAM s, PAT Line 198  static void process_patblt(STREAM s, PAT
198    
199          rdp_parse_brush(s, &os->brush, present >> 7);          rdp_parse_brush(s, &os->brush, present >> 7);
200    
201          DEBUG("PATBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,bs=%d,bg=0x%x,fg=0x%x)\n",          DEBUG(("PATBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
202                os->opcode, os->x, os->y, os->cx, os->cy,                 os->opcode, os->x, os->y, os->cx, os->cy,
203                os->brush.style, os->bgcolour, os->fgcolour);                 os->brush.style, os->bgcolour, os->fgcolour));
204    
205          ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,          ui_patblt(ROP2_P(os->opcode), os->x, os->y, os->cx, os->cy,
206                                  &os->brush, os->bgcolour, os->fgcolour);                    &os->brush, os->bgcolour, os->fgcolour);
207  }  }
208    
209  /* Process a screen blt order */  /* Process a screen blt order */
210  static void process_screenblt(STREAM s, SCREENBLT_ORDER *os,  static void
211                                          uint32 present, BOOL delta)  process_screenblt(STREAM s, SCREENBLT_ORDER *os, uint32 present, BOOL delta)
212  {  {
213          if (present & 0x0001)          if (present & 0x0001)
214                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 225  static void process_screenblt(STREAM s, Line 231  static void process_screenblt(STREAM s,
231          if (present & 0x0040)          if (present & 0x0040)
232                  rdp_in_coord(s, &os->srcy, delta);                  rdp_in_coord(s, &os->srcy, delta);
233    
234          DEBUG("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n",          DEBUG(("SCREENBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,srcx=%d,srcy=%d)\n",
235                os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy);                 os->opcode, os->x, os->y, os->cx, os->cy, os->srcx, os->srcy));
236    
237          ui_screenblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy,          ui_screenblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy,
238                                  os->srcx, os->srcy);                       os->srcx, os->srcy);
239  }  }
240    
241  /* Process a line order */  /* Process a line order */
242  static void process_line(STREAM s, LINE_ORDER *os, uint32 present, BOOL delta)  static void
243    process_line(STREAM s, LINE_ORDER *os, uint32 present, BOOL delta)
244  {  {
245          if (present & 0x0001)          if (present & 0x0001)
246                  in_uint16_le(s, os->mixmode);                  in_uint16_le(s, os->mixmode);
# Line 258  static void process_line(STREAM s, LINE_ Line 265  static void process_line(STREAM s, LINE_
265    
266          rdp_parse_pen(s, &os->pen, present >> 7);          rdp_parse_pen(s, &os->pen, present >> 7);
267    
268          DEBUG("LINE(op=0x%x,sx=%d,sy=%d,dx=%d,dx=%d,fg=0x%x)\n",          DEBUG(("LINE(op=0x%x,sx=%d,sy=%d,dx=%d,dx=%d,fg=0x%x)\n",
269                os->opcode, os->startx, os->starty, os->endx, os->endy,                 os->opcode, os->startx, os->starty, os->endx, os->endy,
270                os->pen.colour);                 os->pen.colour));
271    
272          if (os->opcode < 0x01 || os->opcode > 0x10)          if (os->opcode < 0x01 || os->opcode > 0x10)
273          {          {
274                  ERROR("bad ROP2 0x%x\n", os->opcode);                  error("bad ROP2 0x%x\n", os->opcode);
275                  return;                  return;
276          }          }
277    
278          ui_line(os->opcode-1, os->startx, os->starty,          ui_line(os->opcode - 1, os->startx, os->starty,
279                          os->endx, os->endy, &os->pen);                  os->endx, os->endy, &os->pen);
280  }  }
281    
282  /* Process an opaque rectangle order */  /* Process an opaque rectangle order */
283  static void process_rect(STREAM s, RECT_ORDER *os, uint32 present, BOOL delta)  static void
284    process_rect(STREAM s, RECT_ORDER *os, uint32 present, BOOL delta)
285  {  {
286          if (present & 0x01)          if (present & 0x01)
287                  rdp_in_coord(s, &os->x, delta);                  rdp_in_coord(s, &os->x, delta);
# Line 290  static void process_rect(STREAM s, RECT_ Line 298  static void process_rect(STREAM s, RECT_
298          if (present & 0x10)          if (present & 0x10)
299                  in_uint8(s, os->colour);                  in_uint8(s, os->colour);
300    
301          DEBUG("RECT(x=%d,y=%d,cx=%d,cy=%d,fg=0x%x)\n",          DEBUG(("RECT(x=%d,y=%d,cx=%d,cy=%d,fg=0x%x)\n",
302                os->x, os->y, os->cx, os->cy, os->colour);                 os->x, os->y, os->cx, os->cy, os->colour));
303    
304          ui_rect(os->x, os->y, os->cx, os->cy, os->colour);          ui_rect(os->x, os->y, os->cx, os->cy, os->colour);
305  }  }
306    
307  /* Process a desktop save order */  /* Process a desktop save order */
308  static void process_desksave(STREAM s, DESKSAVE_ORDER *os,  static void
309                                  uint32 present, BOOL delta)  process_desksave(STREAM s, DESKSAVE_ORDER *os, uint32 present, BOOL delta)
310  {  {
311          int width, height;          int width, height;
312    
# Line 320  static void process_desksave(STREAM s, D Line 328  static void process_desksave(STREAM s, D
328          if (present & 0x20)          if (present & 0x20)
329                  in_uint8(s, os->action);                  in_uint8(s, os->action);
330    
331          DEBUG("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n",          DEBUG(("DESKSAVE(l=%d,t=%d,r=%d,b=%d,off=%d,op=%d)\n",
332                os->left, os->top, os->right, os->bottom, os->offset,                 os->left, os->top, os->right, os->bottom, os->offset,
333                os->action);                 os->action));
334    
335          width = os->right - os->left + 1;          width = os->right - os->left + 1;
336          height = os->bottom - os->top + 1;          height = os->bottom - os->top + 1;
# Line 330  static void process_desksave(STREAM s, D Line 338  static void process_desksave(STREAM s, D
338          if (os->action == 0)          if (os->action == 0)
339                  ui_desktop_save(os->offset, os->left, os->top, width, height);                  ui_desktop_save(os->offset, os->left, os->top, width, height);
340          else          else
341                  ui_desktop_restore(os->offset, os->left, os->top, width, height);                  ui_desktop_restore(os->offset, os->left, os->top, width,
342                                       height);
343  }  }
344    
345  /* Process a memory blt order */  /* Process a memory blt order */
346  static void process_memblt(STREAM s, MEMBLT_ORDER *os,  static void
347                                  uint32 present, BOOL delta)  process_memblt(STREAM s, MEMBLT_ORDER *os, uint32 present, BOOL delta)
348  {  {
349          HBITMAP bitmap;          HBITMAP bitmap;
350    
# Line 369  static void process_memblt(STREAM s, MEM Line 378  static void process_memblt(STREAM s, MEM
378          if (present & 0x0100)          if (present & 0x0100)
379                  in_uint16_le(s, os->cache_idx);                  in_uint16_le(s, os->cache_idx);
380    
381          DEBUG("MEMBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d)\n",          DEBUG(("MEMBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d)\n",
382                os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id,                 os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id,
383                os->cache_idx);                 os->cache_idx));
384    
385          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
386          if (bitmap == NULL)          if (bitmap == NULL)
387                  return;                  return;
388    
389          ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy,          ui_memblt(ROP2_S(os->opcode), os->x, os->y, os->cx, os->cy,
390                          bitmap, os->srcx, os->srcy);                    bitmap, os->srcx, os->srcy);
391  }  }
392    
393  /* Process a 3-way blt order */  /* Process a 3-way blt order */
394  static void process_triblt(STREAM s, TRIBLT_ORDER *os,  static void
395                                  uint32 present, BOOL delta)  process_triblt(STREAM s, TRIBLT_ORDER *os, uint32 present, BOOL delta)
396  {  {
397          HBITMAP bitmap;          HBITMAP bitmap;
398    
# Line 428  static void process_triblt(STREAM s, TRI Line 437  static void process_triblt(STREAM s, TRI
437          if (present & 0x010000)          if (present & 0x010000)
438                  in_uint16_le(s, os->unknown);                  in_uint16_le(s, os->unknown);
439    
440          DEBUG("TRIBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d,bs=%d,bg=0x%x,fg=0x%x)\n",          DEBUG(("TRIBLT(op=0x%x,x=%d,y=%d,cx=%d,cy=%d,id=%d,idx=%d,bs=%d,bg=0x%x,fg=0x%x)\n",
441                os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id,                 os->opcode, os->x, os->y, os->cx, os->cy, os->cache_id,
442                os->cache_idx, os->brush.style, os->bgcolour, os->fgcolour);                 os->cache_idx, os->brush.style, os->bgcolour, os->fgcolour));
443    
444          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);          bitmap = cache_get_bitmap(os->cache_id, os->cache_idx);
445          if (bitmap == NULL)          if (bitmap == NULL)
446                  return;                  return;
447    
448          ui_triblt(os->opcode, os->x, os->y, os->cx, os->cy,          ui_triblt(os->opcode, os->x, os->y, os->cx, os->cy,
449                          bitmap, os->srcx, os->srcy,                    bitmap, os->srcx, os->srcy,
450                          &os->brush, os->bgcolour, os->fgcolour);                    &os->brush, os->bgcolour, os->fgcolour);
451  }  }
452    
453  /* Parse a delta co-ordinate in polyline order form */  /* Parse a delta co-ordinate in polyline order form */
454  static int parse_delta(uint8 *buffer, int *offset)  static int
455    parse_delta(uint8 *buffer, int *offset)
456  {  {
457          int value = buffer[(*offset)++];          int value = buffer[(*offset)++];
458          int two_byte = value & 0x80;          int two_byte = value & 0x80;
459    
460          if (value & 0x40) /* sign bit */          if (value & 0x40)       /* sign bit */
461                  value |= ~0x3f;                  value |= ~0x3f;
462          else          else
463                  value &= 0x3f;                  value &= 0x3f;
# Line 459  static int parse_delta(uint8 *buffer, in Line 469  static int parse_delta(uint8 *buffer, in
469  }  }
470    
471  /* Process a polyline order */  /* Process a polyline order */
472  static void process_polyline(STREAM s, POLYLINE_ORDER *os,  static void
473                                  uint32 present, BOOL delta)  process_polyline(STREAM s, POLYLINE_ORDER *os, uint32 present, BOOL delta)
474  {  {
475          int index, line, data;          int index, line, data;
476          int x, y, xfrom, yfrom;          int x, y, xfrom, yfrom;
# Line 488  static void process_polyline(STREAM s, P Line 498  static void process_polyline(STREAM s, P
498                  in_uint8a(s, os->data, os->datasize);                  in_uint8a(s, os->data, os->datasize);
499          }          }
500    
501          DEBUG("POLYLINE(x=%d,y=%d,fl=0x%x,fg=0x%x,n=%d,sz=%d)\n",          DEBUG(("POLYLINE(x=%d,y=%d,fl=0x%x,fg=0x%x,n=%d,sz=%d)\n",
502                  os->x, os->y, os->flags, os->fgcolour, os->lines, os->datasize);                 os->x, os->y, os->flags, os->fgcolour, os->lines, os->datasize));
503    
504          DEBUG("Data: ");          DEBUG(("Data: "));
505    
506          for (index = 0; index < os->datasize; index++)          for (index = 0; index < os->datasize; index++)
507                  DEBUG("%02x ", os->data[index]);                  DEBUG(("%02x ", os->data[index]));
508    
509          DEBUG("\n");          DEBUG(("\n"));
510    
511          x = os->x;          x = os->x;
512          y = os->y;          y = os->y;
# Line 514  static void process_polyline(STREAM s, P Line 524  static void process_polyline(STREAM s, P
524                          flags = os->data[index++];                          flags = os->data[index++];
525    
526                  if ((flags & 0xc0) == 0)                  if ((flags & 0xc0) == 0)
527                          flags |= 0xc0;   /* none = both */                          flags |= 0xc0;  /* none = both */
528    
529                  if (flags & 0x40)                  if (flags & 0x40)
530                          x += parse_delta(os->data, &data);                          x += parse_delta(os->data, &data);
# Line 522  static void process_polyline(STREAM s, P Line 532  static void process_polyline(STREAM s, P
532                  if (flags & 0x80)                  if (flags & 0x80)
533                          y += parse_delta(os->data, &data);                          y += parse_delta(os->data, &data);
534    
535                  ui_line(ROP2_COPY, xfrom, yfrom, x, y, &pen);                  ui_line(ROP2_NXOR, xfrom, yfrom, x, y, &pen);
536    
537                  flags <<= 2;                  flags <<= 2;
538          }          }
539  }  }
540    
541  /* Process a text order */  /* Process a text order */
542  static void process_text2(STREAM s, TEXT2_ORDER *os, uint32 present, BOOL delta)  static void
543    process_text2(STREAM s, TEXT2_ORDER *os, uint32 present, BOOL delta)
544  {  {
         DATABLOB *entry;  
545          int i;          int i;
546    
547          if (present & 0x000001)          if (present & 0x000001)
# Line 588  static void process_text2(STREAM s, TEXT Line 598  static void process_text2(STREAM s, TEXT
598                  in_uint8a(s, os->text, os->length);                  in_uint8a(s, os->text, os->length);
599          }          }
600    
601          DEBUG("TEXT2(x=%d,y=%d,cl=%d,ct=%d,cr=%d,cb=%d,bl=%d,bt=%d,bb=%d,br=%d,fg=0x%x,bg=0x%x,font=%d,fl=0x%x,mix=%d,unk=0x%x,n=%d)\n",          DEBUG(("TEXT2(x=%d,y=%d,cl=%d,ct=%d,cr=%d,cb=%d,bl=%d,bt=%d,bb=%d,br=%d,fg=0x%x,bg=0x%x,font=%d,fl=0x%x,mix=%d,unk=0x%x,n=%d)\n",
602                  os->x, os->y, os->clipleft, os->cliptop, os->clipright,                 os->x, os->y, os->clipleft, os->cliptop, os->clipright,
603                  os->clipbottom, os->boxleft, os->boxtop, os->boxright,                 os->clipbottom, os->boxleft, os->boxtop, os->boxright,
604                  os->boxbottom, os->fgcolour, os->bgcolour, os->font,                 os->boxbottom, os->fgcolour, os->bgcolour, os->font,
605                  os->flags, os->mixmode, os->unknown, os->length);                 os->flags, os->mixmode, os->unknown, os->length));
606    
607          DEBUG("Text: ");          DEBUG(("Text: "));
608    
609          for (i = 0; i < os->length; i++)          for (i = 0; i < os->length; i++)
610                  DEBUG("%02x ", os->text[i]);                  DEBUG(("%02x ", os->text[i]));
611    
612          DEBUG("\n");          DEBUG(("\n"));
   
         /* Process special cache strings */  
         if ((os->length >= 2) && (os->text[0] == 0xfe))  
         {  
                 entry = cache_get_text(os->text[1]);  
   
                 if (entry == NULL)  
                         return;  
                   
                 memcpy(os->text, entry->data, entry->size);  
                 os->length = entry->size;  
         }  
         else if ((os->length >= 3) && (os->text[os->length-3] == 0xff))  
         {  
                 os->length -= 3;  
                 cache_put_text(os->text[os->length+1], os->text, os->length);  
         }  
613    
614          ui_draw_text(os->font, os->flags, os->mixmode, os->x, os->y,          ui_draw_text(os->font, os->flags, os->mixmode, os->x, os->y,
615                          os->clipleft, os->cliptop,                       os->clipleft, os->cliptop,
616                          os->clipright - os->clipleft,                       os->clipright - os->clipleft,
617                          os->clipbottom - os->cliptop,                       os->clipbottom - os->cliptop,
618                          os->boxleft, os->boxtop,                       os->boxleft, os->boxtop,
619                          os->boxright - os->boxleft,                       os->boxright - os->boxleft,
620                          os->boxbottom - os->boxtop,                       os->boxbottom - os->boxtop,
621                          os->bgcolour, os->fgcolour, os->text, os->length);                       os->bgcolour, os->fgcolour, os->text, os->length);
622  }  }
623    
624  /* Process a raw bitmap cache order */  /* Process a raw bitmap cache order */
625  static void process_raw_bmpcache(STREAM s)  static void
626    process_raw_bmpcache(STREAM s)
627  {  {
628          HBITMAP bitmap;          HBITMAP bitmap;
629          uint16 cache_idx, bufsize;          uint16 cache_idx, bufsize;
630          uint8 cache_id, width, height, bpp;          uint8 cache_id, width, height, bpp;
631          uint8 *data;          uint8 *data, *inverted;
632            int y;
633    
634          in_uint8(s, cache_id);          in_uint8(s, cache_id);
635          in_uint8s(s, 1); /* pad */          in_uint8s(s, 1);        /* pad */
636          in_uint8(s, width);          in_uint8(s, width);
637          in_uint8(s, height);          in_uint8(s, height);
638          in_uint8(s, bpp);          in_uint8(s, bpp);
# Line 645  static void process_raw_bmpcache(STREAM Line 640  static void process_raw_bmpcache(STREAM
640          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
641          in_uint8p(s, data, bufsize);          in_uint8p(s, data, bufsize);
642    
643          DEBUG("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n",          DEBUG(("RAW_BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n",
644                width, height, cache_id, cache_idx);                 width, height, cache_id, cache_idx));
645            inverted = xmalloc(width * height);
646            for (y = 0; y < height; y++)
647            {
648                    memcpy(&inverted[(height - y - 1) * width], &data[y * width],
649                           width);
650            }
651    
652          bitmap = ui_create_bitmap(width, height, data);          bitmap = ui_create_bitmap(width, height, inverted);
653            xfree(inverted);
654          cache_put_bitmap(cache_id, cache_idx, bitmap);          cache_put_bitmap(cache_id, cache_idx, bitmap);
655  }  }
656    
657  /* Process a bitmap cache order */  /* Process a bitmap cache order */
658  static void process_bmpcache(STREAM s)  static void
659    process_bmpcache(STREAM s)
660  {  {
661          HBITMAP bitmap;          HBITMAP bitmap;
662          uint16 cache_idx, size;          uint16 cache_idx, size;
# Line 661  static void process_bmpcache(STREAM s) Line 664  static void process_bmpcache(STREAM s)
664          uint8 *data, *bmpdata;          uint8 *data, *bmpdata;
665    
666          in_uint8(s, cache_id);          in_uint8(s, cache_id);
667          in_uint8s(s, 1); /* pad */          in_uint8s(s, 1);        /* pad */
668          in_uint8(s, width);          in_uint8(s, width);
669          in_uint8(s, height);          in_uint8(s, height);
670          in_uint8(s, bpp);          in_uint8(s, bpp);
671          in_uint8s(s, 2); /* bufsize */          in_uint8s(s, 2);        /* bufsize */
672          in_uint16_le(s, cache_idx);          in_uint16_le(s, cache_idx);
673          in_uint8s(s, 2); /* pad */          in_uint8s(s, 2);        /* pad */
674          in_uint16_le(s, size);          in_uint16_le(s, size);
675          in_uint8s(s, 4); /* row_size, final_size */          in_uint8s(s, 4);        /* row_size, final_size */
676          in_uint8p(s, data, size);          in_uint8p(s, data, size);
677    
678          DEBUG("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n",          DEBUG(("BMPCACHE(cx=%d,cy=%d,id=%d,idx=%d)\n",
679                width, height, cache_id, cache_idx);                 width, height, cache_id, cache_idx));
680    
681          bmpdata = xmalloc(width * height);          bmpdata = xmalloc(width * height);
682    
# Line 687  static void process_bmpcache(STREAM s) Line 690  static void process_bmpcache(STREAM s)
690  }  }
691    
692  /* Process a colourmap cache order */  /* Process a colourmap cache order */
693  static void process_colcache(STREAM s)  static void
694    process_colcache(STREAM s)
695  {  {
696          COLOURENTRY *entry;          COLOURENTRY *entry;
697          COLOURMAP map;          COLOURMAP map;
# Line 706  static void process_colcache(STREAM s) Line 710  static void process_colcache(STREAM s)
710                  in_uint8(s, entry->blue);                  in_uint8(s, entry->blue);
711                  in_uint8(s, entry->green);                  in_uint8(s, entry->green);
712                  in_uint8(s, entry->red);                  in_uint8(s, entry->red);
713                  in_uint8s(s, 1); /* pad */                  in_uint8s(s, 1);        /* pad */
714          }          }
715    
716          DEBUG("COLCACHE(id=%d,n=%d)\n", cache_id, map.ncolours);          DEBUG(("COLCACHE(id=%d,n=%d)\n", cache_id, map.ncolours));
717    
718          hmap = ui_create_colourmap(&map);          hmap = ui_create_colourmap(&map);
719          ui_set_colourmap(hmap);          ui_set_colourmap(hmap);
# Line 718  static void process_colcache(STREAM s) Line 722  static void process_colcache(STREAM s)
722  }  }
723    
724  /* Process a font cache order */  /* Process a font cache order */
725  static void process_fontcache(STREAM s)  static void
726    process_fontcache(STREAM s)
727  {  {
728          HGLYPH bitmap;          HGLYPH bitmap;
729          uint8 font, nglyphs;          uint8 font, nglyphs;
730          uint16 character, baseline, width, height;          uint16 character, offset, baseline, width, height;
731          uint8 *data, *rev_data, in, out;          int i, datasize;
732          int i, j, datasize;          uint8 *data;
733    
734          in_uint8(s, font);          in_uint8(s, font);
735          in_uint8(s, nglyphs);          in_uint8(s, nglyphs);
736    
737          DEBUG("FONTCACHE(font=%d,n=%d)\n", font, nglyphs);          DEBUG(("FONTCACHE(font=%d,n=%d)\n", font, nglyphs));
738    
739          for (i = 0; i < nglyphs; i++)          for (i = 0; i < nglyphs; i++)
740          {          {
741                  in_uint16_le(s, character);                  in_uint16_le(s, character);
742                  in_uint8s(s, 2); /* unknown */                  in_uint16_le(s, offset);
743                  in_uint16_le(s, baseline);                  in_uint16_le(s, baseline);
744                  in_uint16_le(s, width);                  in_uint16_le(s, width);
745                  in_uint16_le(s, height);                  in_uint16_le(s, height);
# Line 742  static void process_fontcache(STREAM s) Line 747  static void process_fontcache(STREAM s)
747                  datasize = (height * ((width + 7) / 8) + 3) & ~3;                  datasize = (height * ((width + 7) / 8) + 3) & ~3;
748                  in_uint8p(s, data, datasize);                  in_uint8p(s, data, datasize);
749    
750                  /* Need to reverse bit order */                  bitmap = ui_create_glyph(width, height, data);
751                  rev_data = xmalloc(datasize);                  cache_put_font(font, character, offset, baseline,
752                                   width, height, bitmap);
                 for (j = 0; j < datasize; j++)  
                 {  
                         in = data[j];  
                         out = 0;  
                         if (in & 1) out |= 128;  
                         if (in & 2) out |= 64;  
                         if (in & 4) out |= 32;  
                         if (in & 8) out |= 16;  
                         if (in & 16) out |= 8;  
                         if (in & 32) out |= 4;  
                         if (in & 64) out |= 2;  
                         if (in & 128) out |= 1;  
                         rev_data[j] = out;  
                 }  
   
                 bitmap = ui_create_glyph(width, height, rev_data);  
                 xfree(rev_data);  
   
                 cache_put_font(font, character, baseline, width, height, bitmap);  
753          }          }
754  }  }
755    
756  /* Process a secondary order */  /* Process a secondary order */
757  static void process_secondary_order(STREAM s)  static void
758    process_secondary_order(STREAM s)
759  {  {
760          uint16 length;          uint16 length;
761          uint8 type;          uint8 type;
762          uint8 *next_order;          uint8 *next_order;
763    
764          in_uint16_le(s, length);          in_uint16_le(s, length);
765          in_uint8s(s, 2); /* flags */          in_uint8s(s, 2);        /* flags */
766          in_uint8(s, type);          in_uint8(s, type);
767    
768          next_order = s->p + length + 7;          next_order = s->p + length + 7;
# Line 799  static void process_secondary_order(STRE Line 786  static void process_secondary_order(STRE
786                          break;                          break;
787    
788                  default:                  default:
789                          NOTIMP("secondary order %d\n", type);                          unimpl("secondary order %d\n", type);
790          }          }
791    
792          s->p = next_order;          s->p = next_order;
793  }  }
794    
795  /* Process an order PDU */  /* Process an order PDU */
796  void process_orders(STREAM s)  void
797    process_orders(STREAM s)
798  {  {
799          RDP_ORDER_STATE *os = &order_state;          RDP_ORDER_STATE *os = &order_state;
800          uint32 present;          uint32 present;
# Line 815  void process_orders(STREAM s) Line 803  void process_orders(STREAM s)
803          int size, processed = 0;          int size, processed = 0;
804          BOOL delta;          BOOL delta;
805    
806          in_uint8s(s, 2); /* pad */          in_uint8s(s, 2);        /* pad */
807          in_uint16_le(s, num_orders);          in_uint16_le(s, num_orders);
808          in_uint8s(s, 2); /* pad */          in_uint8s(s, 2);        /* pad */
809    
810          while (processed < num_orders)          while (processed < num_orders)
811          {          {
# Line 825  void process_orders(STREAM s) Line 813  void process_orders(STREAM s)
813    
814                  if (!(order_flags & RDP_ORDER_STANDARD))                  if (!(order_flags & RDP_ORDER_STANDARD))
815                  {                  {
816                          ERROR("order parsing failed\n");                          error("order parsing failed\n");
817                          break;                          break;
818                  }                  }
819    
# Line 865  void process_orders(STREAM s) Line 853  void process_orders(STREAM s)
853                                          rdp_parse_bounds(s, &os->bounds);                                          rdp_parse_bounds(s, &os->bounds);
854    
855                                  ui_set_clip(os->bounds.left,                                  ui_set_clip(os->bounds.left,
856                                          os->bounds.top,                                              os->bounds.top,
857                                          os->bounds.right - os->bounds.left + 1,                                              os->bounds.right -
858                                          os->bounds.bottom - os->bounds.top + 1);                                              os->bounds.left + 1,
859                                                os->bounds.bottom -
860                                                os->bounds.top + 1);
861                          }                          }
862    
863                          delta = order_flags & RDP_ORDER_DELTA;                          delta = order_flags & RDP_ORDER_DELTA;
# Line 891  void process_orders(STREAM s) Line 881  void process_orders(STREAM s)
881    
882                                  case RDP_ORDER_LINE:                                  case RDP_ORDER_LINE:
883                                          process_line(s, &os->line,                                          process_line(s, &os->line,
884                                                          present, delta);                                                       present, delta);
885                                          break;                                          break;
886    
887                                  case RDP_ORDER_RECT:                                  case RDP_ORDER_RECT:
# Line 925  void process_orders(STREAM s) Line 915  void process_orders(STREAM s)
915                                          break;                                          break;
916    
917                                  default:                                  default:
918                                          NOTIMP("order %d\n", os->order_type);                                          unimpl("order %d\n", os->order_type);
919                                          return;                                          return;
920                          }                          }
921    
# Line 937  void process_orders(STREAM s) Line 927  void process_orders(STREAM s)
927          }          }
928    
929          if (s->p != next_packet)          if (s->p != next_packet)
930                  WARN("%d bytes remaining\n", (int)(next_packet - s->p));                  error("%d bytes remaining\n", (int) (next_packet - s->p));
931  }  }
932    
933  /* Reset order state */  /* Reset order state */
934  void reset_order_state()  void
935    reset_order_state()
936  {  {
937          memset(&order_state, 0, sizeof(order_state));          memset(&order_state, 0, sizeof(order_state));
938            order_state.order_type = RDP_ORDER_PATBLT;
939  }  }
   
Legend:
Removed from v.17  
changed lines
  Added in v.49
  ViewVC Help
Powered by ViewVC 1.1.26