First version
[3rdparty/ote_partner/tlk.git] / lib / tga / tga.c
1 /*
2  * Copyright (c) 2008-2010 Travis Geiselbrecht
3  *
4  * Permission is hereby granted, free of charge, to any person obtaining
5  * a copy of this software and associated documentation files
6  * (the "Software"), to deal in the Software without restriction,
7  * including without limitation the rights to use, copy, modify, merge,
8  * publish, distribute, sublicense, and/or sell copies of the Software,
9  * and to permit persons to whom the Software is furnished to do so,
10  * subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be
13  * included in all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
18  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
19  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
20  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
21  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22  */
23
24 /**
25  * @file
26  * @brief  Parse tga format files
27  *
28  * @ingroup graphics
29  */
30
31 #include <debug.h>
32 #include <assert.h>
33 #include <compiler.h>
34 #include <lib/tga.h>
35
36 #define LOCAL_TRACE 0
37
38 struct tga_header {
39         uint8_t  idlength;
40         uint8_t  colormaptype;
41         uint8_t  datatypecode;
42         uint16_t colormaporigin;
43         uint16_t colormaplength;
44         uint8_t  colormapdepth;
45         uint16_t x_origin;
46         uint16_t y_origin;
47         uint16_t width;
48         uint16_t height;
49         uint8_t  bitsperpixel;
50         uint8_t  imagedescriptor;
51 } __PACKED;
52
53 static void print_tga_info(const struct tga_header *header)
54 {
55         LTRACEF("idlength %hhd\n", header->idlength);   
56         LTRACEF("colormaptype %hhd\n", header->colormaptype);   
57         LTRACEF("datatypecode %hhd\n", header->datatypecode);   
58         LTRACEF("colormaporigin %hd\n", header->colormaporigin);        
59         LTRACEF("colormaplength %hd\n", header->colormaplength);        
60         LTRACEF("colormapdepth %hhd\n", header->colormapdepth); 
61         LTRACEF("x_origin %hd\n", header->x_origin);    
62         LTRACEF("y_origin %hd\n", header->y_origin);    
63         LTRACEF("width %hd\n", header->width);  
64         LTRACEF("height %hd\n", header->height);        
65         LTRACEF("bitsperpixel %hhd\n", header->bitsperpixel);   
66         LTRACEF("imagedescriptor %hhd\n", header->imagedescriptor);     
67
68 }
69
70 static void decode_2byte(gfx_surface *surface, uint x, uint y, const void *input)
71 {
72         const uint8_t *in = (const uint8_t *)input;
73
74 //      printf("in 0x%hhx 0x%hhx\n", in[0], in[1]);
75         uint r,g,b;
76
77         b = (in[0] & 0x1f) << 3;
78         g = (((in[0] >> 5) & 0x7) | ((in[1] & 0x3) << 3)) << 3;
79         r = ((in[1] >> 2) & 0x1f) << 3;
80
81         gfx_putpixel(surface, x, y, 0xff000000 | r << 16 | g << 8 | b);
82 }
83
84 static void decode_3byte(gfx_surface *surface, uint x, uint y, const void *input)
85 {
86         const uint8_t *in = (const uint8_t *)input;
87
88 //      printf("in 0x%hhx 0x%hhx\n", in[0], in[1]);
89
90         gfx_putpixel(surface, x, y, 0xff000000 | in[2] << 16 | in[1] << 8 | in[0]);
91 }
92
93 static void decode_4byte(gfx_surface *surface, uint x, uint y, const void *input)
94 {
95         const uint8_t *in = (const uint8_t *)input;
96
97 //      printf("in 0x%hhx 0x%hhx 0x%hhx 0x%hhx\n", in[0], in[1], in[2], in[3]);
98
99         if (in[3] == 0)
100                 gfx_putpixel(surface, x, y, 0);
101         else
102                 gfx_putpixel(surface, x, y, in[3] << 24 | in[2] << 16 | in[1] << 8 | in[0]);
103 }
104
105 /**
106  * @brief  Decode a tga image
107  *
108  * @param  ptr  Pointer to tga data in memory
109  * @param  len  Length of tga data
110  * @param  format  Desired format of returned graphics surface
111  *
112  * @return Graphics surface or NULL on error.
113  *
114  * @ingroup graphics
115  */
116 gfx_surface *tga_decode(const void *ptr, size_t len, gfx_format format)
117 {
118         const struct tga_header *header = (const struct tga_header *)ptr;
119
120         LTRACEF("ptr %p, len %zu\n", ptr, len);
121
122 #if LOCAL_TRACE > 0
123         print_tga_info(header);
124 #endif
125
126         /* do some sanity checks */
127         if (header->datatypecode != 2 && header->datatypecode != 10) {
128                 dprintf(INFO, "tga_decode: unknown data type %d\n", header->datatypecode);
129                 return NULL;
130         }
131         if (header->bitsperpixel != 16 && header->bitsperpixel != 24 && header->bitsperpixel != 32) {
132                 dprintf(INFO, "tga_decode: unsupported bits per pixel %d\n", header->bitsperpixel);
133                 return NULL;
134         }
135         if (header->colormaptype != 0) {
136                 dprintf(INFO, "tga_decode: has colormap, can't handle\n");
137                 return NULL;
138         }
139
140         const void *imagestart = ((const uint8_t *)ptr + sizeof(struct tga_header) + header->idlength);
141
142         /* create a surface to hold the decoded bits */
143         gfx_surface *surface = gfx_create_surface(NULL, header->width, header->height, header->width, format);
144         DEBUG_ASSERT(surface);
145
146         /* copy the bits out */
147         void (*decodefunc)(gfx_surface *, uint x, uint y, const void *) = NULL;
148
149         uint step = 1;
150         if (header->bitsperpixel == 16) {
151                 step = 2;
152                 decodefunc = decode_2byte;
153         } else if (header->bitsperpixel == 24) {
154                 step = 3;
155                 decodefunc = decode_3byte;
156         } else if (header->bitsperpixel == 32) {
157                 step = 4;
158                 decodefunc = decode_4byte;
159         }
160
161         if (header->datatypecode == 2) {
162                 /* no RLE */
163                 uint pos = 0;
164                 uint x, y;
165                 uint surfacey;
166
167                 for (y = 0; y < header->height; y++) {
168
169                         if ((header->imagedescriptor & (1 << 5)) == 0)
170                                 surfacey = (surface->height - 1) - y;
171                         else
172                                 surfacey = y;
173
174                         for (x = 0; x < header->width; x++) {
175                                 decodefunc(surface, x, surfacey, (const uint8_t *)imagestart + pos);
176                                 pos += step;
177                         }
178                 }
179         } else if (header->datatypecode == 10) {
180                 /* RLE compression */
181                 uint pos = 0;
182                 uint count = 0;
183                 uint x, y;
184
185                 x = 0;
186                 if ((header->imagedescriptor & (1 << 5)) == 0)
187                         y = header->height - 1;
188                 else
189                         y = 0;
190
191                 while (count < (uint)header->height * (uint)header->width) {
192                         uint runpos;
193
194                         uint8_t run = *((const uint8_t *)imagestart + pos);
195                         bool repeat_run = (run & 0x80);
196                         uint runlen = (run & 0x7f) + 1;
197
198 //                      printf("pos 0x%x count %u run 0x%hhx runtype %d runlen %u\n", pos, count, run, run & 0x80, runlen);
199
200                         /* consume the run byte */
201                         pos++;
202
203                         /* start of a run */
204                         for (runpos = 0; runpos < runlen; runpos++) {
205                                 decodefunc(surface, x, y, (const uint8_t *)imagestart + pos);
206                                 count++;
207
208                                 x++;
209                                 if (x == surface->width) {
210                                         if ((header->imagedescriptor & (1 << 5)) == 0)
211                                                 y--;
212                                         else
213                                                 y++;
214                                         x = 0;
215                                 }
216
217                                 /* if a run of raw pixels, consume an input pixel */
218                                 if (!repeat_run)
219                                         pos += step;
220                         }
221                         /* if this was a run of repeated pixels, consume the one input pixel we repeated */
222                         if (repeat_run)
223                                 pos += step;
224
225                 }
226 //              printf("done with RLE: x %d, y %d, pos %d, count %d\n", x, y, pos, count);
227         }
228         
229         return surface;
230 }
231