trunk/rdesktop/bitmap.c

/*
   rdesktop: A Remote Desktop Protocol client.
   Bitmap decompression routines
   Copyright (C) Matthew Chapman 1999-2001
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "rdesktop.h"

#define CVAL(p)   (*(p++))
#define SVAL(p)   ((*((p++) + 1) << 8) | CVAL(p))

#define UNROLL8(exp) { exp exp exp exp exp exp exp exp }

#define REPEAT(statement) \
{ \
        while((count & ~0x7) && ((x+8) < width)) \
                UNROLL8( statement; count--; x++; ); \
        \
        while((count > 0) && (x < width)) { statement; count--; x++; } \
}

#define MASK_UPDATE() \
{ \
        mixmask <<= 1; \
        if (mixmask == 0) \
        { \
                mask = fom_mask ? fom_mask : CVAL(input); \
                mixmask = 1; \
        } \
}

BOOL
bitmap_decompress(unsigned char *output, int width, int height,
                  unsigned char *input, int size)
{
        unsigned char *end = input + size;
        unsigned char *prevline = NULL, *line = NULL;
        int opcode, count, offset, isfillormix, x = width;
        int lastopcode = -1, insertmix = False, bicolour = False;
        uint8 code, colour1 = 0, colour2 = 0;
        uint8 mixmask, mask = 0, mix = 0xff;
        int fom_mask = 0;

        while (input < end)
        {
                fom_mask = 0;
                code = CVAL(input);
                opcode = code >> 4;

                /* Handle different opcode forms */
                switch (opcode)
                {
                        case 0xc:
                        case 0xd:
                        case 0xe:
                                opcode -= 6;
                                count = code & 0xf;
                                offset = 16;
                                break;

                        case 0xf:
                                opcode = code & 0xf;
                                if (opcode < 9)
                                        count = SVAL(input);
                                else
                                        count = (opcode < 0xb) ? 8 : 1;
                                offset = 0;
                                break;

                        default:
                                opcode >>= 1;
                                count = code & 0x1f;
                                offset = 32;
                                break;
                }

                /* Handle strange cases for counts */
                if (offset != 0)
                {
                        isfillormix = ((opcode == 2) || (opcode == 7));

                        if (count == 0)
                        {
                                if (isfillormix)
                                        count = CVAL(input) + 1;
                                else
                                        count = CVAL(input) + offset;
                        }
                        else if (isfillormix)
                        {
                                count <<= 3;
                        }
                }

                /* Read preliminary data */
                switch (opcode)
                {
                        case 0: /* Fill */
                                if ((lastopcode == opcode)
                                    && !((x == width) && (prevline == NULL)))
                                        insertmix = True;
                                break;
                        case 8: /* Bicolour */
                                colour1 = CVAL(input);
                        case 3: /* Colour */
                                colour2 = CVAL(input);
                                break;
                        case 6: /* SetMix/Mix */
                        case 7: /* SetMix/FillOrMix */
                                mix = CVAL(input);
                                opcode -= 5;
                                break;
                        case 9: /* FillOrMix_1 */
                                mask = 0x03;
                                opcode = 0x02;
                                fom_mask = 3;
                                break;
                        case 0x0a:      /* FillOrMix_2 */
                                mask = 0x05;
                                opcode = 0x02;
                                fom_mask = 5;
                                break;

                }

                lastopcode = opcode;
                mixmask = 0;

                /* Output body */
                while (count > 0)
                {
                        if (x >= width)
                        {
                                if (height <= 0)
                                        return False;

                                x = 0;
                                height--;

                                prevline = line;
                                line = output + height * width;
                        }

                        switch (opcode)
                        {
                                case 0: /* Fill */
                                        if (insertmix)
                                        {
                                                if (prevline == NULL)
                                                        line[x] = mix;
                                                else
                                                        line[x] =
                                                                prevline[x] ^
                                                                mix;

                                                insertmix = False;
                                                count--;
                                                x++;
                                        }

                                        if (prevline == NULL)
                                        {
                                                REPEAT(line[x] = 0);
                                        }
                                        else
                                        {
                                                REPEAT(line[x] = prevline[x]);
                                        }
                                        break;

                                case 1: /* Mix */
                                        if (prevline == NULL)
                                        {
                                                REPEAT(line[x] = mix);
                                        }
                                        else
                                        {
                                                REPEAT(line[x] =
                                                       prevline[x] ^ mix);
                                        }
                                        break;

                                case 2: /* Fill or Mix */
                                        if (prevline == NULL)
                                        {
                                                REPEAT(MASK_UPDATE();
                                                       if (mask & mixmask)
                                                       line[x] = mix;
                                                       else
                                                       line[x] = 0;);
                                        }
                                        else
                                        {
                                                REPEAT(MASK_UPDATE();
                                                       if (mask & mixmask)
                                                       line[x] =
                                                       prevline[x] ^ mix;
                                                       else
                                                       line[x] =
                                                       prevline[x];);
                                        }
                                        break;

                                case 3: /* Colour */
                                        REPEAT(line[x] = colour2);
                                        break;

                                case 4: /* Copy */
                                        REPEAT(line[x] = CVAL(input));
                                        break;

                                case 8: /* Bicolour */
                                        REPEAT(if (bicolour)
                                               {
                                               line[x] = colour2;
                                               bicolour = False;}
                                               else
                                               {
                                               line[x] = colour1;
                                               bicolour = True; count++;}
                                        );
                                        break;

                                case 0xd:       /* White */
                                        REPEAT(line[x] = 0xff);
                                        break;

                                case 0xe:       /* Black */
                                        REPEAT(line[x] = 0x00);
                                        break;

                                default:
                                        unimpl("bitmap opcode 0x%x\n",
                                               opcode);
                                        return False;
                        }
                }
        }

        return True;
}
1	matty	3	/*
2			rdesktop: A Remote Desktop Protocol client.
3			Bitmap decompression routines
4	matty	30	Copyright (C) Matthew Chapman 1999-2001
5	matty	3
6			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
8			the Free Software Foundation; either version 2 of the License, or
9			(at your option) any later version.
10
11			This program is distributed in the hope that it will be useful,
12			but WITHOUT ANY WARRANTY; without even the implied warranty of
13			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			GNU General Public License for more details.
15
16			You should have received a copy of the GNU General Public License
17			along with this program; if not, write to the Free Software
18			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21	matty	10	#include "rdesktop.h"
22	matty	3
23	matty	7	#define CVAL(p) (*(p++))
24			#define SVAL(p) ((*((p++) + 1) << 8) \| CVAL(p))
25	matty	3
26	matty	28	#define UNROLL8(exp) { exp exp exp exp exp exp exp exp }
27	matty	3
28	matty	28	#define REPEAT(statement) \
29			{ \
30			while((count & ~0x7) && ((x+8) < width)) \
31			UNROLL8( statement; count--; x++; ); \
32			\
33			while((count > 0) && (x < width)) { statement; count--; x++; } \
34			}
35
36			#define MASK_UPDATE() \
37			{ \
38			mixmask <<= 1; \
39			if (mixmask == 0) \
40			{ \
41			mask = fom_mask ? fom_mask : CVAL(input); \
42			mixmask = 1; \
43			} \
44			}
45
46	matty	25	BOOL
47			bitmap_decompress(unsigned char *output, int width, int height,
48			unsigned char *input, int size)
49	matty	3	{
50			unsigned char *end = input + size;
51	matty	10	unsigned char prevline = NULL, line = NULL;
52	matty	7	int opcode, count, offset, isfillormix, x = width;
53	matty	19	int lastopcode = -1, insertmix = False, bicolour = False;
54	matty	10	uint8 code, colour1 = 0, colour2 = 0;
55			uint8 mixmask, mask = 0, mix = 0xff;
56	matty	28	int fom_mask = 0;
57	matty	3
58			while (input < end)
59			{
60	matty	28	fom_mask = 0;
61	matty	7	code = CVAL(input);
62			opcode = code >> 4;
63
64			/* Handle different opcode forms */
65			switch (opcode)
66	matty	3	{
67	matty	7	case 0xc:
68			case 0xd:
69			case 0xe:
70			opcode -= 6;
71			count = code & 0xf;
72			offset = 16;
73			break;
74	matty	3
75	matty	7	case 0xf:
76			opcode = code & 0xf;
77	matty	28	if (opcode < 9)
78			count = SVAL(input);
79			else
80			count = (opcode < 0xb) ? 8 : 1;
81	matty	7	offset = 0;
82			break;
83
84			default:
85			opcode >>= 1;
86			count = code & 0x1f;
87			offset = 32;
88			break;
89			}
90
91			/* Handle strange cases for counts */
92			if (offset != 0)
93			{
94			isfillormix = ((opcode == 2) \|\| (opcode == 7));
95
96			if (count == 0)
97	matty	3	{
98	matty	7	if (isfillormix)
99			count = CVAL(input) + 1;
100			else
101			count = CVAL(input) + offset;
102	matty	3	}
103	matty	7	else if (isfillormix)
104			{
105			count <<= 3;
106			}
107			}
108	matty	3
109	matty	7	/* Read preliminary data */
110			switch (opcode)
111			{
112	matty	24	case 0: /* Fill */
113	matty	18	if ((lastopcode == opcode)
114			&& !((x == width) && (prevline == NULL)))
115	matty	9	insertmix = True;
116	matty	3	break;
117	matty	24	case 8: /* Bicolour */
118	matty	9	colour1 = CVAL(input);
119	matty	24	case 3: /* Colour */
120	matty	9	colour2 = CVAL(input);
121			break;
122	matty	24	case 6: /* SetMix/Mix */
123			case 7: /* SetMix/FillOrMix */
124	matty	7	mix = CVAL(input);
125			opcode -= 5;
126	matty	3	break;
127	matty	28	case 9: /* FillOrMix_1 */
128			mask = 0x03;
129			opcode = 0x02;
130			fom_mask = 3;
131			break;
132			case 0x0a: /* FillOrMix_2 */
133			mask = 0x05;
134			opcode = 0x02;
135			fom_mask = 5;
136			break;
137
138	matty	7	}
139	matty	28
140	matty	9	lastopcode = opcode;
141	matty	28	mixmask = 0;
142	matty	3
143	matty	7	/* Output body */
144			while (count > 0)
145			{
146			if (x >= width)
147			{
148			if (height <= 0)
149	matty	9	return False;
150	matty	7
151			x = 0;
152			height--;
153
154			prevline = line;
155			line = output + height * width;
156			}
157
158			switch (opcode)
159			{
160	matty	24	case 0: /* Fill */
161	matty	9	if (insertmix)
162			{
163			if (prevline == NULL)
164			line[x] = mix;
165			else
166	matty	24	line[x] =
167			prevline[x] ^
168			mix;
169	matty	9
170			insertmix = False;
171			count--;
172			x++;
173			}
174
175	matty	7	if (prevline == NULL)
176	matty	24	{
177			REPEAT(line[x] = 0);
178			}
179	matty	7	else
180	matty	24	{
181			REPEAT(line[x] = prevline[x]);
182			}
183	matty	3	break;
184	matty	7
185	matty	24	case 1: /* Mix */
186	matty	7	if (prevline == NULL)
187	matty	24	{
188			REPEAT(line[x] = mix);
189			}
190	matty	7	else
191	matty	24	{
192			REPEAT(line[x] =
193			prevline[x] ^ mix);
194			}
195	matty	3	break;
196	matty	7
197	matty	24	case 2: /* Fill or Mix */
198	matty	7	if (prevline == NULL)
199	matty	24	{
200			REPEAT(MASK_UPDATE();
201			if (mask & mixmask)
202			line[x] = mix;
203			else
204			line[x] = 0;);
205			}
206	matty	7	else
207	matty	24	{
208			REPEAT(MASK_UPDATE();
209			if (mask & mixmask)
210			line[x] =
211			prevline[x] ^ mix;
212			else
213			line[x] =
214			prevline[x];);
215			}
216	matty	7	break;
217	matty	3
218	matty	24	case 3: /* Colour */
219			REPEAT(line[x] = colour2);
220	matty	7	break;
221	matty	3
222	matty	24	case 4: /* Copy */
223			REPEAT(line[x] = CVAL(input));
224	matty	7	break;
225	matty	3
226	matty	24	case 8: /* Bicolour */
227			REPEAT(if (bicolour)
228			{
229			line[x] = colour2;
230			bicolour = False;}
231			else
232			{
233			line[x] = colour1;
234			bicolour = True; count++;}
235			);
236	matty	7	break;
237	matty	3
238	matty	28	case 0xd: /* White */
239	matty	24	REPEAT(line[x] = 0xff);
240	matty	7	break;
241	matty	3
242	matty	28	case 0xe: /* Black */
243	matty	24	REPEAT(line[x] = 0x00);
244	matty	7	break;
245	matty	3
246	matty	7	default:
247	matty	30	unimpl("bitmap opcode 0x%x\n",
248	matty	24	opcode);
249	matty	7	return False;
250			}
251			}
252	matty	3	}
253
254	matty	7	return True;
255	matty	3	}