Mercurial > hg > dmlib
annotate libgfx.c @ 452:d1f7ddc84c7c
Return more sensible error values where appropriate instead of just
DMERR_INVALID_DATA.
author | Matti Hamalainen <ccr@tnsp.org> |
---|---|
date | Sun, 04 Nov 2012 12:07:03 +0200 |
parents | fdc91f2a0d27 |
children | 349a2ff11531 |
rev | line source |
---|---|
435 | 1 /* |
2 * Functions for reading and converting various restricted | |
3 * C64/etc and/or indexed/paletted graphics formats. | |
4 * Programmed and designed by Matti 'ccr' Hamalainen | |
5 * (C) Copyright 2012 Tecnic Software productions (TNSP) | |
6 * | |
7 * Please read file 'COPYING' for information on license and distribution. | |
8 */ | |
9 #include "libgfx.h" | |
10 #include "dmfile.h" | |
11 #include "dmbstr.h" | |
12 | |
13 #ifdef DM_USE_LIBPNG | |
14 #include <png.h> | |
15 #endif | |
16 | |
17 | |
18 DMImage * dmImageAlloc(int width, int height) | |
19 { | |
20 DMImage *img = dmCalloc(1, sizeof(DMImage)); | |
21 if (img == NULL) | |
22 return NULL; | |
23 | |
24 img->width = img->pitch = width; | |
25 img->height = height; | |
26 img->data = dmMalloc(width * height * sizeof(Uint8)); | |
27 if (img->data == NULL) | |
28 { | |
29 dmFree(img); | |
30 return NULL; | |
31 } | |
32 | |
33 return img; | |
34 } | |
35 | |
36 | |
37 void dmImageFree(DMImage *img) | |
38 { | |
39 if (img != NULL) | |
40 { | |
41 if (!img->constpal) | |
42 { | |
43 dmFree(img->pal); | |
44 } | |
45 dmFree(img->data); | |
46 dmFree(img); | |
47 } | |
48 } | |
49 | |
50 | |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
51 BOOL dmPaletteAlloc(DMColor **ppal, int ncolors) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
52 { |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
53 if (ppal == NULL) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
54 return FALSE; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
55 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
56 return (*ppal = dmCalloc(ncolors, sizeof(DMColor))) != NULL; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
57 } |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
58 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
59 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
60 BOOL dmImageAllocPalette(DMImage *img, int ncolors) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
61 { |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
62 if (img == NULL) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
63 return FALSE; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
64 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
65 img->ncolors = ncolors; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
66 return dmPaletteAlloc(&(img->pal), ncolors); |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
67 } |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
68 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
69 |
435 | 70 int dmImageGetBytesPerPixel(int format) |
71 { | |
72 switch (format) | |
73 { | |
74 case DM_IFMT_PALETTE : return 1; | |
75 | |
76 case DM_IFMT_RGB_PLANE : | |
77 case DM_IFMT_RGB : return 3; | |
78 | |
79 case DM_IFMT_RGBA : return 4; | |
80 | |
81 default: return 0; | |
82 } | |
83 } | |
84 | |
85 | |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
86 static BOOL dmReadPaletteData(FILE *fp, DMColor *pal, int ncolors) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
87 { |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
88 int i; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
89 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
90 for (i = 0; i < ncolors; i++) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
91 { |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
92 Uint8 colR, colG, colB; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
93 if (!dm_fread_byte(fp, &colR) || |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
94 !dm_fread_byte(fp, &colG) || |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
95 !dm_fread_byte(fp, &colB)) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
96 return FALSE; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
97 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
98 pal[i].r = colR; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
99 pal[i].g = colG; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
100 pal[i].b = colB; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
101 } |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
102 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
103 return TRUE; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
104 } |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
105 |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
106 |
435 | 107 int dmWriteImageData(DMImage *img, void *cbdata, BOOL (*writeRowCB)(void *, Uint8 *, size_t), const DMImageSpec *spec) |
108 { | |
109 int x, y, yscale, xscale, res = 0, rowSize, rowWidth; | |
110 Uint8 *row = NULL; | |
111 | |
112 // Allocate memory for row buffer | |
113 rowWidth = img->width * spec->scale; | |
114 rowSize = rowWidth * dmImageGetBytesPerPixel(spec->format); | |
115 | |
116 if ((row = dmMalloc(rowSize + 16)) == NULL) | |
117 { | |
118 res = DMERR_MALLOC; | |
119 goto done; | |
120 } | |
121 | |
122 // Generate the image | |
123 for (y = 0; y < img->height; y++) | |
124 { | |
436
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
125 Uint8 *ptr1 = row, |
435 | 126 *ptr2 = ptr1 + rowWidth, |
127 *ptr3 = ptr2 + rowWidth; | |
128 | |
129 for (x = 0; x < img->width; x++) | |
130 { | |
131 Uint8 c = img->data[(y * img->pitch) + x], qr, qg, qb, qa; | |
132 switch (spec->format) | |
133 { | |
134 case DM_IFMT_PALETTE: | |
135 for (xscale = 0; xscale < spec->scale; xscale++) | |
436
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
136 *ptr1++ = c; |
435 | 137 break; |
138 | |
139 case DM_IFMT_RGBA: | |
140 qr = img->pal[c].r; | |
141 qg = img->pal[c].g; | |
142 qb = img->pal[c].b; | |
143 qa = (c == img->ctrans) ? 0 : 255; | |
144 | |
145 for (xscale = 0; xscale < spec->scale; xscale++) | |
146 { | |
436
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
147 *ptr1++ = qr; |
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
148 *ptr1++ = qg; |
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
149 *ptr1++ = qb; |
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
150 *ptr1++ = qa; |
435 | 151 } |
152 break; | |
153 | |
154 case DM_IFMT_RGB: | |
155 qr = img->pal[c].r; | |
156 qg = img->pal[c].g; | |
157 qb = img->pal[c].b; | |
158 | |
159 for (xscale = 0; xscale < spec->scale; xscale++) | |
160 { | |
436
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
161 *ptr1++ = qr; |
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
162 *ptr1++ = qg; |
86f956e4580f
Cosmetics, rename a variable.
Matti Hamalainen <ccr@tnsp.org>
parents:
435
diff
changeset
|
163 *ptr1++ = qb; |
435 | 164 } |
165 break; | |
166 | |
167 case DM_IFMT_RGB_PLANE: | |
168 qr = img->pal[c].r; | |
169 qg = img->pal[c].g; | |
170 qb = img->pal[c].b; | |
171 | |
172 for (xscale = 0; xscale < spec->scale; xscale++) | |
173 { | |
174 *ptr1++ = qr; | |
175 *ptr2++ = qg; | |
176 *ptr3++ = qb; | |
177 } | |
178 break; | |
179 } | |
180 } | |
181 | |
182 for (yscale = 0; yscale < spec->scale; yscale++) | |
183 { | |
184 if (!writeRowCB(cbdata, row, rowSize)) | |
185 { | |
186 res = DMERR_FWRITE; | |
187 goto done; | |
188 } | |
189 } | |
190 } | |
191 | |
192 done: | |
193 dmFree(row); | |
194 return res; | |
195 } | |
196 | |
197 | |
198 #define DMCOL(x) (((x) >> 4) & 0xf) | |
199 | |
200 int dmWriteIFFMasterRAWPalette(const char *filename, DMImage *img, int ncolors) | |
201 { | |
202 FILE *fp; | |
203 int i; | |
204 | |
205 if ((fp = fopen(filename, "w")) == NULL) | |
206 { | |
207 dmError("IFFMasterRAW: Could not open file '%s' for writing.\n", filename); | |
208 return -15; | |
209 } | |
210 | |
211 for (i = 0; i < ncolors; i++) | |
212 { | |
213 int color; | |
214 if (i < img->ncolors) | |
215 { | |
216 color = (DMCOL(img->pal[i].r) << 8) | | |
217 (DMCOL(img->pal[i].g) << 4) | | |
218 (DMCOL(img->pal[i].b)); | |
219 } | |
220 else | |
221 color = 0; | |
222 | |
223 fprintf(fp, "\tdc.w $%04X\n", color); | |
224 } | |
225 | |
440
b4ed5292d7bf
Close the file after writing.
Matti Hamalainen <ccr@tnsp.org>
parents:
436
diff
changeset
|
226 fclose(fp); |
435 | 227 return 0; |
228 } | |
229 | |
230 | |
231 int dmWriteIFFMasterRAWImageFILE(FILE *fp, DMImage *img, DMImageSpec *spec) | |
232 { | |
233 int xc, yc, plane, res; | |
234 DMBitStream bs; | |
235 | |
236 if ((res = dmInitBitStream(&bs, fp)) != DMERR_OK) | |
237 return res; | |
238 | |
239 if (spec->interleave) | |
240 { | |
241 // Output bitplanes in interleaved format (each plane of line sequentially) | |
242 for (yc = 0; yc < img->height; yc++) | |
243 { | |
244 for (plane = 0; plane < spec->nplanes; plane++) | |
245 { | |
246 Uint8 *sp = img->data + yc * img->pitch; | |
247 for (xc = 0; xc < img->width; xc++) | |
248 { | |
249 if (!dmPutBits(&bs, (sp[xc] & (1 << plane)) ? 1 : 0, 1)) | |
250 return DMERR_FWRITE; | |
251 } | |
252 } | |
253 } | |
254 } | |
255 else | |
256 { | |
257 // Output each bitplane in sequence | |
258 for (plane = 0; plane < spec->nplanes; plane++) | |
259 { | |
260 for (yc = 0; yc < img->height; yc++) | |
261 { | |
262 Uint8 *sp = img->data + yc * img->pitch; | |
263 for (xc = 0; xc < img->width; xc++) | |
264 { | |
265 if (!dmPutBits(&bs, (sp[xc] & (1 << plane)) ? 1 : 0, 1)) | |
266 return DMERR_FWRITE; | |
267 } | |
268 } | |
269 } | |
270 } | |
271 | |
272 return dmFlushBitStream(&bs); | |
273 } | |
274 | |
275 int dmWriteIFFMasterRAWImage(const char *filename, DMImage *img, DMImageSpec *spec) | |
276 { | |
277 FILE *fp; | |
278 int res; | |
279 | |
280 if ((fp = fopen(filename, "wb")) == NULL) | |
281 { | |
282 dmError("IFFMasterRAW: Could not open file '%s' for writing.\n", filename); | |
283 return DMERR_FOPEN; | |
284 } | |
285 | |
286 res = dmWriteIFFMasterRAWImageFILE(fp, img, spec); | |
287 | |
288 fclose(fp); | |
289 return res; | |
290 } | |
291 | |
292 | |
293 static BOOL dmWritePPMRow(void *cbdata, Uint8 *row, size_t len) | |
294 { | |
295 return fwrite(row, sizeof(Uint8), len, (FILE *) cbdata) == len; | |
296 } | |
297 | |
298 | |
299 int dmWritePPMImageFILE(FILE *fp, DMImage *img, DMImageSpec *spec) | |
300 { | |
301 // Write PPM header | |
302 fprintf(fp, | |
303 "P6\n%d %d\n255\n", | |
304 img->width * spec->scale, | |
305 img->height * spec->scale); | |
306 | |
307 // Write image data | |
308 spec->format = DM_IFMT_RGB; | |
309 return dmWriteImageData(img, (void *) fp, dmWritePPMRow, spec); | |
310 } | |
311 | |
312 | |
313 int dmWritePPMImage(const char *filename, DMImage *img, DMImageSpec *spec) | |
314 { | |
315 FILE *fp; | |
316 int res; | |
317 | |
318 // Create output file | |
319 if ((fp = fopen(filename, "wb")) == NULL) | |
320 { | |
321 dmError("PPM: could not open file '%s' for writing.\n", filename); | |
322 return DMERR_FOPEN; | |
323 } | |
324 | |
325 res = dmWritePPMImageFILE(fp, img, spec); | |
326 | |
327 fclose(fp); | |
328 return res; | |
329 } | |
330 | |
331 | |
332 #ifdef DM_USE_LIBPNG | |
333 static BOOL dmWritePNGRow(void *cbdata, Uint8 *row, size_t len) | |
334 { | |
335 png_structp png_ptr = cbdata; | |
336 (void) len; | |
337 | |
338 if (setjmp(png_jmpbuf(png_ptr))) | |
339 return FALSE; | |
340 | |
341 png_write_row(png_ptr, row); | |
342 | |
343 return TRUE; | |
344 } | |
345 | |
346 | |
347 int dmWritePNGImageFILE(FILE *fp, DMImage *img, DMImageSpec *spec) | |
348 { | |
349 png_structp png_ptr = NULL; | |
350 png_infop info_ptr = NULL; | |
351 png_colorp palette = NULL; | |
352 int fmt, res = DMERR_OK; | |
353 | |
354 // Create PNG structures | |
355 png_ptr = png_create_write_struct( | |
356 PNG_LIBPNG_VER_STRING, | |
357 NULL, NULL, NULL); | |
358 | |
359 if (png_ptr == NULL) | |
360 { | |
361 dmError("PNG: png_create_write_struct() failed.\n"); | |
362 res = DMERR_MALLOC; | |
363 goto error; | |
364 } | |
365 | |
366 info_ptr = png_create_info_struct(png_ptr); | |
367 if (info_ptr == NULL) | |
368 { | |
369 dmError("PNG: png_create_info_struct(%p) failed.\n", png_ptr); | |
370 res = DMERR_INIT_FAIL; | |
371 goto error; | |
372 } | |
373 | |
374 if (setjmp(png_jmpbuf(png_ptr))) | |
375 { | |
376 dmError("PNG: Error during image writing..\n"); | |
377 res = DMERR_INIT_FAIL; | |
378 goto error; | |
379 } | |
380 | |
381 png_init_io(png_ptr, fp); | |
382 | |
383 // Write PNG header info | |
384 switch (spec->format) | |
385 { | |
386 case DM_IFMT_PALETTE: fmt = PNG_COLOR_TYPE_PALETTE; break; | |
387 case DM_IFMT_RGB : fmt = PNG_COLOR_TYPE_RGB; break; | |
388 case DM_IFMT_RGBA : fmt = PNG_COLOR_TYPE_RGB_ALPHA; break; | |
389 default: | |
452
d1f7ddc84c7c
Return more sensible error values where appropriate instead of just
Matti Hamalainen <ccr@tnsp.org>
parents:
451
diff
changeset
|
390 dmError("PNG: Unsupported image format %d.\n", spec->format); |
d1f7ddc84c7c
Return more sensible error values where appropriate instead of just
Matti Hamalainen <ccr@tnsp.org>
parents:
451
diff
changeset
|
391 res = DMERR_NOT_SUPPORTED; |
435 | 392 goto error; |
393 } | |
394 | |
395 png_set_IHDR(png_ptr, info_ptr, | |
396 img->width * spec->scale, | |
397 img->height * spec->scale, | |
398 8, /* bits per component */ | |
399 fmt, | |
400 PNG_INTERLACE_NONE, | |
401 PNG_COMPRESSION_TYPE_DEFAULT, | |
402 PNG_FILTER_TYPE_DEFAULT); | |
403 | |
404 // Palette | |
405 if (spec->format == DM_IFMT_PALETTE) | |
406 { | |
407 int i; | |
408 | |
409 palette = png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH * sizeof(png_color)); | |
410 if (palette == NULL) | |
411 { | |
412 dmError("PNG: Could not allocate palette structure."); | |
452
d1f7ddc84c7c
Return more sensible error values where appropriate instead of just
Matti Hamalainen <ccr@tnsp.org>
parents:
451
diff
changeset
|
413 res = DMERR_MALLOC; |
435 | 414 goto error; |
415 } | |
416 | |
417 memset(palette, 0, PNG_MAX_PALETTE_LENGTH * sizeof(png_color)); | |
418 | |
419 for (i = 0; i < img->ncolors; i++) | |
420 { | |
421 palette[i].red = img->pal[i].r; | |
422 palette[i].green = img->pal[i].g; | |
423 palette[i].blue = img->pal[i].b; | |
424 } | |
425 | |
426 png_set_PLTE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH); | |
427 } | |
428 | |
429 // png_set_gAMA(png_ptr, info_ptr, 2.2); | |
430 | |
431 png_write_info(png_ptr, info_ptr); | |
432 | |
433 | |
434 // Write compressed image data | |
435 dmWriteImageData(img, (void *) png_ptr, dmWritePNGRow, spec); | |
436 | |
437 // Write footer | |
438 png_write_end(png_ptr, NULL); | |
439 | |
440 error: | |
441 png_free(png_ptr, palette); | |
442 palette = NULL; | |
443 | |
444 if (png_ptr && info_ptr) | |
445 png_destroy_write_struct(&png_ptr, &info_ptr); | |
446 | |
447 return res; | |
448 } | |
449 | |
450 | |
451 int dmWritePNGImage(const char *filename, DMImage *img, DMImageSpec *spec) | |
452 { | |
453 int res; | |
454 FILE *fp; | |
455 | |
456 if ((fp = fopen(filename, "wb")) == NULL) | |
457 { | |
458 dmError("PNG: could not open file '%s' for writing.\n", filename); | |
459 return DMERR_FOPEN; | |
460 } | |
461 | |
462 res = dmWritePNGImageFILE(fp, img, spec); | |
463 | |
464 fclose(fp); | |
465 return res; | |
466 } | |
467 #endif | |
468 | |
469 | |
470 typedef struct | |
471 { | |
472 Uint8 r,g,b; | |
473 } DMPCXColor; | |
474 | |
475 | |
476 typedef struct | |
477 { | |
478 Uint8 manufacturer, | |
479 version, | |
480 encoding, | |
481 bpp; | |
482 Uint16 xmin, ymin, xmax, ymax; | |
483 Uint16 hres, vres; | |
484 DMPCXColor colormap[16]; | |
485 Uint8 reserved; | |
486 Uint8 nplanes; | |
487 Uint16 bpl; | |
488 Uint16 palinfo; | |
489 Uint8 filler[58]; | |
490 } DMPCXHeader; | |
491 | |
492 | |
493 typedef struct | |
494 { | |
495 DMPCXHeader *header; | |
496 Uint8 *buf; | |
497 size_t bufLen, bufOffs; | |
498 int format; | |
499 FILE *fp; | |
500 } DMPCXData; | |
501 | |
502 | |
503 static inline Uint8 dmPCXGetByte(Uint8 *row, const size_t len, const size_t soffs) | |
504 { | |
505 return (soffs < len) ? row[soffs] : 0; | |
506 } | |
507 | |
508 static BOOL dmPCXFlush(DMPCXData *pcx) | |
509 { | |
510 BOOL ret = TRUE; | |
511 if (pcx->bufOffs > 0) | |
512 ret = fwrite(pcx->buf, sizeof(Uint8), pcx->bufOffs, pcx->fp) == pcx->bufOffs; | |
513 pcx->bufOffs = 0; | |
514 return ret; | |
515 } | |
516 | |
517 static inline BOOL dmPCXPutByte(DMPCXData *pcx, const Uint8 val) | |
518 { | |
519 if (pcx->bufOffs < pcx->bufLen) | |
520 { | |
521 pcx->buf[pcx->bufOffs++] = val; | |
522 return TRUE; | |
523 } | |
524 else | |
525 return dmPCXFlush(pcx); | |
526 } | |
527 | |
528 static BOOL dmWritePCXRow(void *cbdata, Uint8 *row, size_t len) | |
529 { | |
530 DMPCXData *pcx = (DMPCXData *) cbdata; | |
531 int plane; | |
532 size_t soffs = 0; | |
533 | |
534 // fprintf(stderr, "%d, %d * %d = %d\n", len, pcx->header->bpl, pcx->header->nplanes, pcx->header->nplanes * pcx->header->bpl); | |
535 | |
536 pcx->bufOffs = 0; | |
537 | |
538 for (plane = 0; plane < pcx->header->nplanes; plane++) | |
539 { | |
540 Uint8 data = dmPCXGetByte(row, len, soffs++), | |
541 count = 1; | |
542 | |
543 // size_t blen = pcx->header->bpl * pcx->header->nplanes; | |
544 size_t blen = pcx->header->bpl; | |
545 while (soffs < blen) | |
546 { | |
547 if (data == dmPCXGetByte(row, len, soffs) && count < 63) | |
548 { | |
549 count++; | |
550 soffs++; | |
551 } | |
552 else | |
553 { | |
554 if (count == 1 && (data & 0xC0) != 0xC0) | |
555 { | |
556 if (!dmPCXPutByte(pcx, data)) | |
557 return FALSE; | |
558 } | |
559 else | |
560 { | |
561 if (!dmPCXPutByte(pcx, 0xC0 | count) || | |
562 !dmPCXPutByte(pcx, data)) | |
563 return FALSE; | |
564 } | |
565 | |
566 data = dmPCXGetByte(row, len, soffs++); | |
567 count = 1; | |
568 } | |
569 } | |
570 | |
571 if (count > 1) | |
572 { | |
573 if (!dmPCXPutByte(pcx, 0xC0 | count) || | |
574 !dmPCXPutByte(pcx, data)) | |
575 return FALSE; | |
576 } | |
577 | |
578 if (!dmPCXFlush(pcx)) | |
579 return FALSE; | |
580 } | |
581 | |
582 | |
583 return TRUE; | |
584 } | |
585 | |
586 | |
587 int dmWritePCXImageFILE(FILE *fp, DMImage *img, DMImageSpec *spec) | |
588 { | |
589 DMPCXData pcx; | |
590 DMPCXHeader hdr; | |
591 int res; | |
592 | |
593 // Create output file | |
594 pcx.buf = NULL; | |
595 pcx.format = spec->paletted ? DM_IFMT_PALETTE : DM_IFMT_RGB_PLANE; | |
596 pcx.header = &hdr; | |
597 pcx.fp = fp; | |
598 | |
599 // Create PCX header | |
600 memset(&hdr, 0, sizeof(hdr)); | |
601 if (spec->paletted) | |
602 { | |
603 int i; | |
604 for (i = 0; i < (img->ncolors > 16 ? 16 : img->ncolors); i++) | |
605 { | |
606 hdr.colormap[i].r = img->pal[i].r; | |
607 hdr.colormap[i].g = img->pal[i].g; | |
608 hdr.colormap[i].b = img->pal[i].b; | |
609 } | |
610 } | |
611 hdr.manufacturer = 10; | |
612 hdr.version = 5; | |
613 hdr.encoding = 1; | |
614 hdr.bpp = 8; | |
615 hdr.hres = img->width * spec->scale; | |
616 hdr.vres = img->height * spec->scale; | |
617 hdr.xmin = hdr.ymin = 0; | |
618 hdr.xmax = hdr.hres - 1; | |
619 hdr.ymax = hdr.vres - 1; | |
620 hdr.nplanes = dmImageGetBytesPerPixel(pcx.format); | |
621 hdr.palinfo = 1; | |
622 | |
623 res = (img->width * spec->scale); | |
624 hdr.bpl = res / 2; | |
625 if (res % 2) hdr.bpl++; | |
626 hdr.bpl *= 2; | |
627 | |
628 dmMsg(2, "PCX: paletted=%d, nplanes=%d, bpp=%d, bpl=%d\n", | |
629 spec->paletted, hdr.nplanes, hdr.bpp, hdr.bpl); | |
630 | |
631 pcx.bufLen = hdr.bpl * 4; | |
632 if ((pcx.buf = dmMalloc(pcx.bufLen)) == NULL) | |
633 { | |
634 dmError("PCX: Could not allocate %d bytes for RLE compression buffer.\n", | |
635 pcx.bufLen); | |
636 res = DMERR_MALLOC; | |
637 goto error; | |
638 } | |
639 | |
640 // Write PCX header | |
641 if (!dm_fwrite_byte(pcx.fp, hdr.manufacturer) || | |
642 !dm_fwrite_byte(pcx.fp, hdr.version) || | |
643 !dm_fwrite_byte(pcx.fp, hdr.encoding) || | |
644 !dm_fwrite_byte(pcx.fp, hdr.bpp)) | |
645 { | |
646 dmError("PCX: Could not write basic header data.\n"); | |
647 res = DMERR_FWRITE; | |
648 goto error; | |
649 } | |
650 | |
651 if (!dm_fwrite_le16(pcx.fp, hdr.xmin) || | |
652 !dm_fwrite_le16(pcx.fp, hdr.ymin) || | |
653 !dm_fwrite_le16(pcx.fp, hdr.xmax) || | |
654 !dm_fwrite_le16(pcx.fp, hdr.ymax) || | |
655 !dm_fwrite_le16(pcx.fp, hdr.hres) || | |
656 !dm_fwrite_le16(pcx.fp, hdr.vres)) | |
657 { | |
658 dmError("PCX: Could not write image dimensions.\n"); | |
659 res = DMERR_FWRITE; | |
660 goto error; | |
661 } | |
662 | |
663 if (!dm_fwrite_str(pcx.fp, (Uint8 *) &hdr.colormap, sizeof(hdr.colormap))) | |
664 { | |
665 dmError("PCX: Could not write colormap.\n"); | |
666 res = DMERR_FWRITE; | |
667 goto error; | |
668 } | |
669 | |
670 if (!dm_fwrite_byte(pcx.fp, hdr.reserved) || | |
671 !dm_fwrite_byte(pcx.fp, hdr.nplanes) || | |
672 !dm_fwrite_le16(pcx.fp, hdr.bpl) || | |
673 !dm_fwrite_le16(pcx.fp, hdr.palinfo) || | |
674 !dm_fwrite_str(pcx.fp, (Uint8 *) &hdr.filler, sizeof(hdr.filler))) | |
675 { | |
676 dmError("PCX: Could not write header remainder.\n"); | |
677 res = DMERR_FWRITE; | |
678 goto error; | |
679 } | |
680 | |
681 // Write image data | |
682 res = dmWriteImageData(img, (void *) &pcx, dmWritePCXRow, spec); | |
683 | |
684 // Write VGA palette | |
685 if (spec->paletted) | |
686 { | |
687 int i; | |
688 dm_fwrite_byte(pcx.fp, 0x0C); | |
689 dmMsg(2, "PCX: Writing palette of %d active entries.\n", img->ncolors); | |
690 | |
691 for (i = 0; i < img->ncolors; i++) | |
692 { | |
693 dm_fwrite_byte(pcx.fp, img->pal[i].r); | |
694 dm_fwrite_byte(pcx.fp, img->pal[i].g); | |
695 dm_fwrite_byte(pcx.fp, img->pal[i].b); | |
696 } | |
697 | |
698 // Pad the palette, if necessary | |
699 for (; i < 256; i++) | |
700 { | |
701 dm_fwrite_byte(pcx.fp, 0); | |
702 dm_fwrite_byte(pcx.fp, 0); | |
703 dm_fwrite_byte(pcx.fp, 0); | |
704 } | |
705 } | |
706 | |
707 error: | |
708 dmFree(pcx.buf); | |
709 return res; | |
710 } | |
711 | |
712 | |
713 int dmWritePCXImage(const char *filename, DMImage *img, DMImageSpec *spec) | |
714 { | |
715 FILE *fp; | |
716 int res; | |
717 | |
718 if ((fp = fopen(filename, "wb")) == NULL) | |
719 { | |
720 dmError("PCX: Could not open file '%s' for writing.\n", filename); | |
721 return DMERR_FOPEN; | |
722 } | |
723 | |
724 res = dmWritePCXImageFILE(fp, img, spec); | |
725 | |
726 fclose(fp); | |
727 return res; | |
728 } | |
729 | |
730 | |
731 static BOOL dmPCXDecodeRLERow(FILE *fp, Uint8 *buf, const size_t bufLen) | |
732 { | |
733 size_t offs = 0; | |
734 do | |
735 { | |
736 int count; | |
737 Uint8 data; | |
738 | |
739 if (!dm_fread_byte(fp, &data)) | |
740 return FALSE; | |
741 | |
742 if ((data & 0xC0) == 0xC0) | |
743 { | |
744 count = data & 0x3F; | |
745 if (!dm_fread_byte(fp, &data)) | |
746 return FALSE; | |
747 } | |
748 else | |
749 count = 1; | |
750 | |
751 while (count-- && offs < bufLen) | |
752 buf[offs++] = data; | |
753 | |
754 } while (offs < bufLen); | |
755 | |
756 return TRUE; | |
757 } | |
758 | |
759 | |
760 int dmReadPCXImageFILE(FILE *fp, DMImage **pimg) | |
761 { | |
762 DMImage *img; | |
763 DMPCXData pcx; | |
764 DMPCXHeader hdr; | |
765 BOOL paletted; | |
766 int res = 0, yc, xc; | |
767 Uint8 *dp; | |
768 | |
769 pcx.buf = NULL; | |
770 | |
771 // Read PCX header | |
772 if (!dm_fread_byte(fp, &hdr.manufacturer) || | |
773 !dm_fread_byte(fp, &hdr.version) || | |
774 !dm_fread_byte(fp, &hdr.encoding) || | |
775 !dm_fread_byte(fp, &hdr.bpp)) | |
776 { | |
777 dmError("PCX: Could not read basic header data.\n"); | |
778 res = DMERR_FREAD; | |
779 goto error; | |
780 } | |
781 | |
782 if (hdr.manufacturer != 10 || | |
783 hdr.version != 5 || | |
784 hdr.encoding != 1 || | |
785 hdr.bpp != 8) | |
786 { | |
787 dmError("PCX: Not a PCX file, or unsupported variant.\n"); | |
788 res = DMERR_FREAD; | |
789 goto error; | |
790 } | |
791 | |
792 if (!dm_fread_le16(fp, &hdr.xmin) || | |
793 !dm_fread_le16(fp, &hdr.ymin) || | |
794 !dm_fread_le16(fp, &hdr.xmax) || | |
795 !dm_fread_le16(fp, &hdr.ymax) || | |
796 !dm_fread_le16(fp, &hdr.hres) || | |
797 !dm_fread_le16(fp, &hdr.vres)) | |
798 { | |
799 dmError("PCX: Could not read image dimensions.\n"); | |
800 res = DMERR_FREAD; | |
801 goto error; | |
802 } | |
803 | |
804 if (!dm_fread_str(fp, (Uint8 *) &hdr.colormap, sizeof(hdr.colormap))) | |
805 { | |
806 dmError("PCX: Could not read colormap.\n"); | |
807 res = DMERR_FREAD; | |
808 goto error; | |
809 } | |
810 | |
811 if (!dm_fread_byte(fp, &hdr.reserved) || | |
812 !dm_fread_byte(fp, &hdr.nplanes) || | |
813 !dm_fread_le16(fp, &hdr.bpl) || | |
814 !dm_fread_le16(fp, &hdr.palinfo) || | |
815 !dm_fread_str(fp, (Uint8 *) &hdr.filler, sizeof(hdr.filler))) | |
816 { | |
817 dmError("PCX: Could not read header remainder.\n"); | |
818 res = DMERR_FREAD; | |
819 goto error; | |
820 } | |
821 | |
822 if (hdr.nplanes != 3 && hdr.nplanes != 1) | |
823 { | |
824 dmError("PCX: Unsupported number of bitplanes %d.\n", hdr.nplanes); | |
825 res = DMERR_FREAD; | |
826 goto error; | |
827 } | |
828 | |
829 // Allocate image | |
830 if ((*pimg = img = dmImageAlloc(hdr.xmax - hdr.xmin + 1, hdr.ymax - hdr.ymin + 1)) == NULL) | |
831 { | |
832 dmError("PCX: Could not allocate image structure.\n"); | |
833 res = DMERR_MALLOC; | |
834 goto error; | |
835 } | |
836 | |
837 paletted = hdr.nplanes == 1; | |
838 pcx.bufLen = hdr.nplanes * hdr.bpl; | |
839 if ((pcx.buf = dmMalloc(pcx.bufLen)) == NULL) | |
840 { | |
841 dmError("PCX: Could not allocate RLE buffer.\n"); | |
842 res = DMERR_MALLOC; | |
843 goto error; | |
844 } | |
845 | |
846 // Read image data | |
847 dp = img->data; | |
848 for (yc = 0; yc < img->height; yc++) | |
849 { | |
850 // Decode row of RLE'd data | |
851 if (!dmPCXDecodeRLERow(fp, pcx.buf, pcx.bufLen)) | |
852 { | |
853 dmError("PCX: Error decoding RLE data.\n"); | |
854 res = DMERR_INVALID_DATA; | |
855 goto error; | |
856 } | |
857 | |
858 // Decode bitplanes | |
859 switch (hdr.nplanes) | |
860 { | |
861 case 1: | |
862 memcpy(dp, pcx.buf, img->width); | |
863 break; | |
864 | |
865 case 3: | |
866 { | |
867 Uint8 *dptr = dp, | |
868 *sptr1 = pcx.buf, | |
869 *sptr2 = sptr1 + hdr.bpl, | |
870 *sptr3 = sptr2 + hdr.bpl; | |
871 | |
872 for (xc = 0; xc < img->width; xc++) | |
873 { | |
874 *dptr++ = *sptr1++; | |
875 *dptr++ = *sptr2++; | |
876 *dptr++ = *sptr3++; | |
877 } | |
878 } | |
879 break; | |
880 } | |
881 | |
882 dp += img->pitch; | |
883 } | |
884 | |
885 // Read VGA palette | |
886 if (paletted) | |
887 { | |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
888 int i, ncolors; |
435 | 889 Uint8 tmpb; |
890 BOOL read; | |
891 | |
892 if (!dm_fread_byte(fp, &tmpb) || tmpb != 0x0C) | |
893 { | |
894 read = FALSE; | |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
895 ncolors = 16; |
435 | 896 } |
897 else | |
898 { | |
899 read = TRUE; | |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
900 ncolors = 256; |
435 | 901 } |
902 | |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
903 if (!dmImageAllocPalette(img, ncolors)) |
435 | 904 { |
905 dmError("PCX: Could not allocate palette data!\n"); | |
906 res = DMERR_MALLOC; | |
907 goto error; | |
908 } | |
909 | |
910 if (read) | |
911 { | |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
912 if (!dmReadPaletteData(fp, img->pal, ncolors)) |
435 | 913 { |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
914 dmError("PCX: Error reading palette.\n"); |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
915 return DMERR_FREAD; |
435 | 916 } |
917 } | |
918 else | |
919 { | |
920 for (i = 0; i < img->ncolors; i++) | |
921 { | |
922 if (i < 16) | |
923 { | |
924 img->pal[i].r = hdr.colormap[i].r; | |
925 img->pal[i].g = hdr.colormap[i].g; | |
926 img->pal[i].b = hdr.colormap[i].b; | |
927 } | |
928 } | |
929 } | |
930 } | |
931 | |
932 error: | |
933 dmFree(pcx.buf); | |
934 return res; | |
935 } | |
936 | |
937 | |
938 int dmReadPCXImage(const char *filename, DMImage **pimg) | |
939 { | |
940 FILE *fp; | |
941 int res; | |
942 | |
943 if ((fp = fopen(filename, "rb")) == NULL) | |
944 { | |
945 dmError("PCX: Could not open file '%s' for reading.\n", filename); | |
946 return -15; | |
947 } | |
948 | |
949 res = dmReadPCXImageFILE(fp, pimg); | |
950 | |
951 fclose(fp); | |
952 return res; | |
953 } | |
954 | |
955 | |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
956 #define IFF_ID_FORM 0x464F524D // "FORM" |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
957 #define IFF_ID_ILBM 0x494C424D // "ILBM" |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
958 #define IFF_ID_BMHD 0x424D4844 // "BMHD" |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
959 #define IFF_ID_CMAP 0x434D4150 // "CMAP" |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
960 #define IFF_ID_BODY 0x424F4459 // "BODY" |
449
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
961 #define IFF_ID_CAMG 0x43414D47 // "CAMG" |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
962 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
963 #define IFF_MASK_NONE 0 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
964 #define IFF_MASK_HAS_MASK 1 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
965 #define IFF_MASK_TRANSP 2 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
966 #define IFF_MASK_LASSO 3 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
967 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
968 #define IFF_COMP_NONE 0 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
969 #define IFF_COMP_BYTERUN1 1 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
970 |
449
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
971 #define IFF_CAMG_LACE 0x00000004 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
972 #define IFF_CAMG_HALFBRITE 0x00000080 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
973 #define IFF_CAMG_HAM 0x00000800 |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
974 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
975 typedef struct |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
976 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
977 Uint32 id; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
978 Uint32 size; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
979 int count; |
445 | 980 char str[6]; |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
981 } DMIFFChunk; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
982 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
983 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
984 typedef struct |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
985 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
986 Uint16 w, h; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
987 Sint16 x, y; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
988 Uint8 nplanes; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
989 Uint8 masking; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
990 Uint8 compression; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
991 Uint8 pad1; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
992 Uint16 transp; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
993 Uint8 xasp, yasp; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
994 Sint16 pagew, pageh; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
995 } DMIFFBMHD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
996 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
997 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
998 typedef struct |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
999 { |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1000 DMIFFChunk chBMHD, chCMAP, chBODY; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1001 DMIFFBMHD bmhd; |
449
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1002 Uint32 camg; |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1003 int ncolors; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1004 DMColor *pal; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1005 BOOL paletted; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1006 } DMIFF; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1007 |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1008 |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1009 static BOOL dmReadIFFChunk(FILE *fp, DMIFFChunk *chunk) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1010 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1011 if (!dm_fread_be32(fp, &chunk->id) || |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1012 !dm_fread_be32(fp, &chunk->size)) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1013 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1014 dmError("ILBM: Could not read IFF chunk header.\n"); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1015 return FALSE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1016 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1017 else |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1018 return TRUE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1019 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1020 |
445 | 1021 static char * dmGetIFFChunkID(DMIFFChunk *chunk) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1022 { |
445 | 1023 chunk->str[0] = (chunk->id >> 24) & 0xff; |
1024 chunk->str[1] = (chunk->id >> 16) & 0xff; | |
1025 chunk->str[2] = (chunk->id >> 8) & 0xff; | |
1026 chunk->str[3] = (chunk->id) & 0xff; | |
1027 chunk->str[4] = 0; | |
1028 return chunk->str; | |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1029 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1030 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1031 static BOOL dmSkipIFFChunkRest(FILE *fp, const DMIFFChunk *chunk, const Uint32 used) |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1032 { |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1033 if (chunk->size > used) |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1034 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1035 dmMsg(3, "ILBM: Skipping %d bytes (%d of %d consumed)\n", |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1036 chunk->size - used, used, chunk->size); |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1037 return fseeko(fp, chunk->size - used, SEEK_CUR) == 0; |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1038 } |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1039 else |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1040 return TRUE; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1041 } |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1042 |
445 | 1043 static BOOL dmCheckIFFChunk(DMIFFChunk *dest, DMIFFChunk *chunk, |
1044 const BOOL multi, const Uint32 minSize) | |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1045 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1046 if (dest->count > 0 && !multi) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1047 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1048 dmError("ILBM: Multiple instances of chunk %s found.\n", |
445 | 1049 dmGetIFFChunkID(chunk)); |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1050 return FALSE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1051 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1052 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1053 dest->count++; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1054 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1055 if (chunk->size < minSize) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1056 return FALSE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1057 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1058 return TRUE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1059 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1060 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1061 |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1062 static BOOL dmIFFDecodeByteRun1Row(FILE *fp, Uint8 *buf, const size_t bufLen) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1063 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1064 size_t offs = 0; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1065 do |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1066 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1067 Sint8 dcount; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1068 Uint8 data; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1069 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1070 if (!dm_fread_byte(fp, (Uint8 *) &dcount)) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1071 return FALSE; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1072 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1073 if (dcount == -128) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1074 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1075 if (!dm_fread_byte(fp, &data)) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1076 return FALSE; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1077 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1078 else |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1079 if (dcount < 0) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1080 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1081 int count = (-dcount) + 1; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1082 if (!dm_fread_byte(fp, &data)) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1083 return FALSE; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1084 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1085 while (count-- && offs < bufLen) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1086 buf[offs++] = data; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1087 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1088 else |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1089 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1090 int count = dcount + 1; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1091 while (count-- && offs < bufLen) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1092 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1093 if (!dm_fread_byte(fp, &data)) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1094 return FALSE; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1095 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1096 buf[offs++] = data; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1097 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1098 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1099 } while (offs < bufLen); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1100 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1101 return TRUE; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1102 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1103 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1104 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1105 static BOOL dmIFFReadOneRow(FILE *fp, DMIFF *iff, Uint8 *buf, const size_t bufLen) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1106 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1107 if (iff->bmhd.compression == IFF_COMP_BYTERUN1) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1108 return dmIFFDecodeByteRun1Row(fp, buf, bufLen); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1109 else |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1110 return dm_fread_str(fp, buf, bufLen); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1111 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1112 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1113 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1114 void dmDecodeBitPlane(Uint8 *dp, Uint8 *src, const int width, const int nplane) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1115 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1116 int xc; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1117 for (xc = 0; xc < width; xc++) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1118 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1119 const Uint8 data = (src[xc / 8] >> (7 - (xc & 7))) & 1; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1120 dp[xc] |= (data << nplane); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1121 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1122 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1123 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1124 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1125 int dmDecodeILBMBody(FILE *fp, DMIFF *iff, DMImage **pimg, Uint32 *read) |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1126 { |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1127 DMImage *img; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1128 Uint8 *buf; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1129 size_t bufLen; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1130 int yc, res = DMERR_OK; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1131 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1132 *read = 0; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1133 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1134 // Allocate image |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1135 if ((*pimg = img = dmImageAlloc(iff->bmhd.w, iff->bmhd.h)) == NULL) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1136 return DMERR_MALLOC; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1137 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1138 // Allocate planar decoding buffer |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1139 bufLen = ((img->width + 15) / 16) * 2; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1140 if ((buf = dmMalloc(bufLen)) == NULL) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1141 return DMERR_MALLOC; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1142 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1143 dmMsg(2, "ILBM: plane row size %d bytes.\n", bufLen); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1144 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1145 // Decode the chunk |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1146 for (yc = 0; yc < img->height; yc++) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1147 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1148 int plane; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1149 const int nplanes = iff->bmhd.nplanes; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1150 Uint8 *dp = img->data + (yc * img->pitch); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1151 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1152 memset(dp, 0, img->pitch); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1153 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1154 for (plane = 0; plane < nplanes; plane++) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1155 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1156 // Decompress or read data |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1157 if (!dmIFFReadOneRow(fp, iff, buf, bufLen)) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1158 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1159 dmError("ILBM: Error in reading image plane #%d.\n", plane); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1160 res = DMERR_FREAD; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1161 goto error; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1162 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1163 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1164 // Decode bitplane |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1165 dmDecodeBitPlane(dp, buf, img->width, plane); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1166 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1167 *read += bufLen; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1168 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1169 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1170 // Read mask data |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1171 if (iff->bmhd.masking == IFF_MASK_HAS_MASK) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1172 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1173 int xc; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1174 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1175 // Decompress or read data |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1176 if (!dmIFFReadOneRow(fp, iff, buf, bufLen)) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1177 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1178 dmError("ILBM: Error in reading mask plane.\n"); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1179 res = DMERR_FREAD; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1180 goto error; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1181 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1182 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1183 // Decode mask |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1184 for (xc = 0; xc < img->width; xc++) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1185 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1186 const Uint8 data = (buf[xc / 8] >> (7 - (xc & 7))) & 1; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1187 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1188 // Black out any pixels with mask bit 0 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1189 if (!data) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1190 dp[xc] = 0; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1191 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1192 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1193 *read += bufLen; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1194 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1195 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1196 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1197 error: |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1198 dmFree(buf); |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1199 return res; |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1200 } |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1201 |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1202 |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1203 int dmReadILBMImageFILE(FILE *fp, DMImage **pimg) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1204 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1205 Uint32 idILBM; |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1206 DMIFFChunk chunk; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1207 DMIFF iff; |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1208 Uint32 read; |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1209 BOOL parsed = FALSE; |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1210 int i, res = DMERR_OK; |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1211 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1212 memset(&iff, 0, sizeof(iff)); |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1213 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1214 // Read IFF FORM header |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1215 if (!dmReadIFFChunk(fp, &chunk) || |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1216 chunk.id != IFF_ID_FORM || |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1217 chunk.size < 32) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1218 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1219 dmError("ILBM: Not a IFF file.\n"); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1220 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1221 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1222 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1223 // Check IFF ILBM signature |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1224 if (!dm_fread_be32(fp, &idILBM) || |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1225 idILBM != IFF_ID_ILBM) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1226 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1227 dmError("ILBM: Not a ILBM file.\n"); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1228 return DMERR_INVALID_DATA; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1229 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1230 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1231 while (!parsed && !feof(fp)) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1232 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1233 if (!dmReadIFFChunk(fp, &chunk)) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1234 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1235 dmError("ILBM: Error reading IFF ILBM data.\n"); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1236 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1237 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1238 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1239 switch (chunk.id) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1240 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1241 case IFF_ID_BMHD: |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1242 // Check for multiple occurences of BMHD |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1243 if (!dmCheckIFFChunk(&iff.chBMHD, &chunk, FALSE, sizeof(iff.bmhd))) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1244 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1245 |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1246 // Read BMHD data |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1247 if (!dm_fread_be16(fp, &iff.bmhd.w) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1248 !dm_fread_be16(fp, &iff.bmhd.h) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1249 !dm_fread_be16(fp, (Uint16 *) &iff.bmhd.x) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1250 !dm_fread_be16(fp, (Uint16 *) &iff.bmhd.y) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1251 !dm_fread_byte(fp, &iff.bmhd.nplanes) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1252 !dm_fread_byte(fp, &iff.bmhd.masking) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1253 !dm_fread_byte(fp, &iff.bmhd.compression) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1254 !dm_fread_byte(fp, &iff.bmhd.pad1) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1255 !dm_fread_be16(fp, &iff.bmhd.transp) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1256 !dm_fread_byte(fp, &iff.bmhd.xasp) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1257 !dm_fread_byte(fp, &iff.bmhd.yasp) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1258 !dm_fread_be16(fp, (Uint16 *) &iff.bmhd.pagew) || |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1259 !dm_fread_be16(fp, (Uint16 *) &iff.bmhd.pageh)) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1260 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1261 dmError("ILBM: Error reading BMHD chunk.\n"); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1262 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1263 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1264 dmMsg(2, "ILBM: BMHD %d x %d @ %d, %d : nplanes=%d, comp=%d, mask=%d\n", |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1265 iff.bmhd.w, iff.bmhd.h, iff.bmhd.x, iff.bmhd.y, |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1266 iff.bmhd.nplanes, iff.bmhd.compression, iff.bmhd.masking); |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1267 |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1268 // Sanity check |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1269 if (iff.bmhd.nplanes < 1 || iff.bmhd.nplanes > 8 || |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1270 (iff.bmhd.compression != IFF_COMP_NONE && |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1271 iff.bmhd.compression != IFF_COMP_BYTERUN1) || |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1272 (iff.bmhd.masking != IFF_MASK_NONE && |
448
f1aab48a76fe
Add transp mask support to IFF ILBM loader.
Matti Hamalainen <ccr@tnsp.org>
parents:
447
diff
changeset
|
1273 iff.bmhd.masking != IFF_MASK_HAS_MASK && |
f1aab48a76fe
Add transp mask support to IFF ILBM loader.
Matti Hamalainen <ccr@tnsp.org>
parents:
447
diff
changeset
|
1274 iff.bmhd.masking != IFF_MASK_TRANSP)) |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1275 { |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1276 dmError("ILBM: Unsupported features, refusing to load.\n"); |
452
d1f7ddc84c7c
Return more sensible error values where appropriate instead of just
Matti Hamalainen <ccr@tnsp.org>
parents:
451
diff
changeset
|
1277 return DMERR_NOT_SUPPORTED; |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1278 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1279 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1280 if (!dmSkipIFFChunkRest(fp, &chunk, sizeof(iff.bmhd))) |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1281 return DMERR_FREAD; |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1282 break; |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1283 |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1284 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1285 case IFF_ID_CMAP: |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1286 // Check for multiple occurences of CMAP |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1287 if (!dmCheckIFFChunk(&iff.chCMAP, &chunk, FALSE, 3)) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1288 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1289 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1290 // Check for sanity |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1291 if (chunk.size % 3 != 0) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1292 dmError("ILBM: CMAP chunk size not divisible by 3, possibly broken file.\n"); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1293 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1294 iff.ncolors = chunk.size / 3; |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1295 dmMsg(2, "ILBM: CMAP %d entries (%d bytes)\n", |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1296 iff.ncolors, chunk.size, 1 << iff.bmhd.nplanes); |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1297 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1298 if (iff.bmhd.nplanes > 0 && iff.ncolors != 1 << iff.bmhd.nplanes) |
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1299 dmMsg(2, "ILBM: Expected %d entries in CMAP.\n", 1 << iff.bmhd.nplanes); |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1300 |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1301 // Read palette |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1302 if (iff.ncolors > 0) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1303 { |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1304 if (!dmPaletteAlloc(&iff.pal, iff.ncolors)) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1305 { |
451
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1306 dmError("ILBM: Could not allocate palette data.\n"); |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1307 return DMERR_MALLOC; |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1308 } |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1309 if (!dmReadPaletteData(fp, iff.pal, iff.ncolors)) |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1310 { |
fdc91f2a0d27
Modularize palette reading and handling code.
Matti Hamalainen <ccr@tnsp.org>
parents:
449
diff
changeset
|
1311 dmError("ILBM: Error reading CMAP.\n"); |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1312 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1313 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1314 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1315 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1316 if (iff.chBMHD.count && iff.chBODY.count) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1317 parsed = TRUE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1318 break; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1319 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1320 case IFF_ID_BODY: |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1321 // Check for multiple occurences of CMAP |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1322 if (!dmCheckIFFChunk(&iff.chBODY, &chunk, FALSE, 1)) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1323 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1324 |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1325 // Check for sanity |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1326 if (!iff.chBMHD.count) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1327 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1328 dmError("ILBM: BODY chunk before BMHD?\n"); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1329 return DMERR_INVALID_DATA; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1330 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1331 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1332 dmMsg(2, "ILBM: BODY chunk size %d bytes\n", chunk.size); |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1333 |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1334 // Decode the body |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1335 if ((res = dmDecodeILBMBody(fp, &iff, pimg, &read)) != DMERR_OK) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1336 return res; |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1337 |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1338 if (!dmSkipIFFChunkRest(fp, &chunk, read)) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1339 return DMERR_FREAD; |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1340 |
444
7d588807f91d
Clean up the IFF parser a bit.
Matti Hamalainen <ccr@tnsp.org>
parents:
443
diff
changeset
|
1341 if (iff.chCMAP.count) |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1342 parsed = TRUE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1343 break; |
449
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1344 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1345 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1346 case IFF_ID_CAMG: |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1347 if (!dm_fread_be32(fp, &iff.camg)) |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1348 { |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1349 dmError("ILBM: Error reading CAMG chunk.\n"); |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1350 return DMERR_FREAD; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1351 } |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1352 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1353 dmMsg(2, "ILBM: CAMG value 0x%08x\n", iff.camg); |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1354 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1355 if ((iff.camg & IFF_CAMG_HAM)) |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1356 { |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1357 dmError("ILBM: HAM files are not supported.\n"); |
452
d1f7ddc84c7c
Return more sensible error values where appropriate instead of just
Matti Hamalainen <ccr@tnsp.org>
parents:
451
diff
changeset
|
1358 return DMERR_NOT_SUPPORTED; |
449
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1359 } |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1360 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1361 if (!dmSkipIFFChunkRest(fp, &chunk, 4)) |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1362 return DMERR_FREAD; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1363 break; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1364 |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1365 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1366 default: |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1367 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1368 dmMsg(3, "Unknown chunk ID '%s', size %d\n", |
445 | 1369 dmGetIFFChunkID(&chunk), chunk.size); |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1370 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1371 if (fseeko(fp, chunk.size, SEEK_CUR) != 0) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1372 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1373 dmError("ILBM: Error skipping in file."); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1374 return DMERR_FREAD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1375 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1376 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1377 break; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1378 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1379 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1380 if (chunk.size & 1) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1381 fgetc(fp); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1382 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1383 |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1384 // Set colormap after finishing |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1385 if (iff.pal != NULL && iff.ncolors > 0 && *pimg != NULL) |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1386 { |
449
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1387 // If halfbrite is used, duplicate the palette |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1388 if (iff.camg & IFF_CAMG_HALFBRITE) |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1389 { |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1390 if (iff.ncolors > 128) |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1391 { |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1392 dmError("ILBM: Halfbrite enabled, but ncolors > 128.\n"); |
452
d1f7ddc84c7c
Return more sensible error values where appropriate instead of just
Matti Hamalainen <ccr@tnsp.org>
parents:
451
diff
changeset
|
1393 return DMERR_NOT_SUPPORTED; |
449
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1394 } |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1395 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1396 if ((iff.pal = dmRealloc(iff.pal, sizeof(DMColor) * iff.ncolors * 2)) == NULL) |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1397 return DMERR_MALLOC; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1398 |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1399 for (i = 0; i < iff.ncolors; i++) |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1400 { |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1401 int i2 = iff.ncolors + i; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1402 iff.pal[i2].r = iff.pal[i].r / 2; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1403 iff.pal[i2].g = iff.pal[i].g / 2; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1404 iff.pal[i2].b = iff.pal[i].b / 2; |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1405 } |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1406 } |
117f94b253af
Add support for CAMG chunk reading and possibly half-brite handling in IFF ILBM reader.
Matti Hamalainen <ccr@tnsp.org>
parents:
448
diff
changeset
|
1407 |
447
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1408 (*pimg)->ncolors = iff.ncolors; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1409 (*pimg)->pal = iff.pal; |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1410 } |
0e27860ddcfe
Finish initial implementation of IFF ILBM loader. And whoa .. it seems to be working.
Matti Hamalainen <ccr@tnsp.org>
parents:
445
diff
changeset
|
1411 |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1412 return res; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1413 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1414 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1415 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1416 int dmReadILBMImage(const char *filename, DMImage **pimg) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1417 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1418 FILE *fp; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1419 int res; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1420 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1421 if ((fp = fopen(filename, "rb")) == NULL) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1422 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1423 dmError("ILBM: Could not open file '%s' for reading.\n", filename); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1424 return DMERR_FOPEN; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1425 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1426 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1427 res = dmReadILBMImageFILE(fp, pimg); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1428 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1429 fclose(fp); |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1430 return res; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1431 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1432 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1433 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1434 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1435 |
435 | 1436 static int fmtProbePNG(const Uint8 *buf, const size_t len) |
1437 { | |
1438 if (len > 64 && buf[0] == 0x89 && | |
1439 buf[1] == 'P' && buf[2] == 'N' && buf[3] == 'G' && | |
1440 buf[4] == 0x0d && buf[5] == 0x0a) | |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1441 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1442 if (buf[12] == 'I' && buf[13] == 'H' && |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1443 buf[14] == 'D' && buf[15] == 'R') |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1444 return DM_PROBE_SCORE_MAX; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1445 else |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1446 return DM_PROBE_SCORE_GOOD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1447 } |
435 | 1448 |
1449 return DM_PROBE_SCORE_FALSE; | |
1450 } | |
1451 | |
1452 | |
1453 static int fmtProbePCX(const Uint8 *buf, const size_t len) | |
1454 { | |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1455 if (len > 128 + 32 && |
435 | 1456 buf[0] == 10 && |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1457 (buf[1] == 5 || buf[1] == 2 || buf[1] == 3) && |
435 | 1458 buf[2] == 1 && |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1459 (buf[3] == 8 || buf[3] == 4 || buf[3] == 3 || buf[3] == 1) && |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1460 buf[65] >= 1 && buf[65] <= 4) |
435 | 1461 return DM_PROBE_SCORE_GOOD; |
1462 | |
1463 return DM_PROBE_SCORE_FALSE; | |
1464 } | |
1465 | |
1466 | |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1467 static int fmtProbeILBM(const Uint8 *buf, const size_t len) |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1468 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1469 if (len > 32 && |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1470 buf[ 0] == 'F' && buf[ 1] == 'O' && |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1471 buf[ 2] == 'R' && buf[ 3] == 'M' && |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1472 buf[ 8] == 'I' && buf[ 9] == 'L' && |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1473 buf[10] == 'B' && buf[11] == 'M') |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1474 { |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1475 if (buf[12] == 'B' && buf[13] == 'M' && |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1476 buf[14] == 'H' && buf[15] == 'D') |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1477 return DM_PROBE_SCORE_MAX; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1478 else |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1479 return DM_PROBE_SCORE_GOOD; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1480 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1481 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1482 return DM_PROBE_SCORE_FALSE; |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1483 } |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1484 |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1485 |
435 | 1486 DMImageFormat dmImageFormatList[IMGFMT_LAST] = |
1487 { | |
1488 { | |
1489 "PNG", "Portable Network Graphics", | |
1490 fmtProbePNG, | |
1491 NULL, NULL, | |
1492 #ifdef DM_USE_LIBPNG | |
1493 dmWritePNGImage, dmWritePNGImageFILE, | |
1494 #else | |
1495 NULL, NULL, | |
1496 #endif | |
1497 }, | |
1498 { | |
1499 "PPM", "Portable PixMap", | |
1500 NULL, | |
1501 NULL, NULL, | |
1502 dmWritePPMImage, dmWritePPMImageFILE, | |
1503 }, | |
1504 { | |
1505 "PCX", "Z-Soft Paintbrush", | |
1506 fmtProbePCX, | |
1507 dmReadPCXImage, dmReadPCXImageFILE, | |
1508 dmWritePCXImage, dmWritePCXImageFILE, | |
1509 }, | |
1510 { | |
443
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1511 "ILBM", "IFF ILBM", |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1512 fmtProbeILBM, |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1513 dmReadILBMImage, dmReadILBMImageFILE, |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1514 NULL, NULL, |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1515 }, |
f7c9d1619c74
Beginnings of IFF ILBM reader. Not functional, only chunk parsing,
Matti Hamalainen <ccr@tnsp.org>
parents:
442
diff
changeset
|
1516 { |
435 | 1517 "ARAW", "IFFMaster Amiga RAW", |
1518 NULL, | |
1519 NULL, NULL, | |
1520 dmWriteIFFMasterRAWImage, dmWriteIFFMasterRAWImageFILE, | |
1521 } | |
1522 }; | |
1523 | |
1524 | |
1525 int dmImageProbeGeneric(const Uint8 *buf, const size_t len, DMImageFormat **pfmt, int *index) | |
1526 { | |
1527 int i, scoreMax = DM_PROBE_SCORE_FALSE, scoreIndex = -1; | |
1528 | |
1529 for (i = 0; i < IMGFMT_LAST; i++) | |
1530 { | |
1531 DMImageFormat *fmt = &dmImageFormatList[i]; | |
442
a67600e186d0
Fix probing to handle NULL probe functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
440
diff
changeset
|
1532 if (fmt->probe != NULL) |
435 | 1533 { |
442
a67600e186d0
Fix probing to handle NULL probe functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
440
diff
changeset
|
1534 int score = fmt->probe(buf, len); |
a67600e186d0
Fix probing to handle NULL probe functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
440
diff
changeset
|
1535 if (score > scoreMax) |
a67600e186d0
Fix probing to handle NULL probe functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
440
diff
changeset
|
1536 { |
a67600e186d0
Fix probing to handle NULL probe functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
440
diff
changeset
|
1537 scoreMax = score; |
a67600e186d0
Fix probing to handle NULL probe functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
440
diff
changeset
|
1538 scoreIndex = i; |
a67600e186d0
Fix probing to handle NULL probe functions.
Matti Hamalainen <ccr@tnsp.org>
parents:
440
diff
changeset
|
1539 } |
435 | 1540 } |
1541 } | |
1542 | |
1543 if (scoreIndex >= 0) | |
1544 { | |
1545 *pfmt = &dmImageFormatList[scoreIndex]; | |
1546 *index = scoreIndex; | |
1547 return scoreMax; | |
1548 } | |
1549 else | |
1550 return DM_PROBE_SCORE_FALSE; | |
1551 } |