?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added type conversion to red, green and blue components, otherwise
[AROS.git] / tools / ilbmtoc / ilbmtoc.c
blobdef244be5006152e66d21905a064f6dd4a62259a
1 /*
2 Copyright © 1995-2010, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Tool to convert IFF ILBM images into C source.
6
7 Lang:
8
9 */
10
11 /****************************************************************************************/
12
13 #include <stdio.h>
14 #include <string.h>
15 #include <stdlib.h>
16 #include <ctype.h>
17
18 /****************************************************************************************/
19
20 #define MAKE_ID(a,b,c,d) (((a)<<24) | ((b)<<16) | ((c)<<8) | ((d)))
21
22 #define ID_FORM MAKE_ID('F','O','R','M')
23 #define ID_ILBM MAKE_ID('I','L','B','M')
24 #define ID_CMAP MAKE_ID('C','M','A','P')
25 #define ID_BODY MAKE_ID('B','O','D','Y')
26 #define ID_BMHD MAKE_ID('B','M','H','D')
27
28 #define CMP_NONE 0
29 #define CMP_BYTERUN1 1
30
31 #define MSK_HASMASK 1
32
33 /****************************************************************************************/
34
35 /* For this tool it does not really matter if the following types
36 have a bigger sizeof() than on Amiga */
37
38 #ifndef __AROS__
39 typedef unsigned long ULONG;
40 typedef long LONG;
41 typedef unsigned short UWORD;
42 typedef short WORD;
43 typedef short BOOL;
44 typedef unsigned char UBYTE;
45 #else
46 #include <exec/types.h>
47 #endif
48
49 /****************************************************************************************/
50
51 struct BitMapHeader
52 {
53 UWORD bmh_Width;
54 UWORD bmh_Height;
55 WORD bmh_Left;
56 WORD bmh_Top;
57 UBYTE bmh_Depth;
58 UBYTE bmh_Masking;
59 UBYTE bmh_Compression;
60 UBYTE bmh_Pad;
61 UWORD bmh_Transparent;
62 UBYTE bmh_XAspect;
63 UBYTE bmh_YAspect;
64 WORD bmh_PageWidth;
65 WORD bmh_PageHeight;
66 };
67
68 /****************************************************************************************/
69
70 static char *filename;
71 static FILE *file;
72 static unsigned char *filebuffer, *body, *planarbuffer, *chunkybuffer;
73 static unsigned char *planarbuffer_packed, *chunkybuffer_packed;
74 static long filesize, bodysize, bodysize_packed;
75 static long filepos;
76 static struct BitMapHeader bmh;
77 static LONG cmapentries, totdepth, bpr;
78 static BOOL have_bmhd, have_cmap, have_body;
79 static UBYTE red[256], green[256], blue[256];
80 static char imagename[1000];
81 static char bigimagename[1000];
82 static BOOL brush2c; // compatibility with brush2c from MUI SDK
83 static BOOL brush2pix; // compatibility with brush2pix from JabberWocky
84
85 /****************************************************************************************/
86
87 static void cleanup(char *msg, int rc)
88 {
89 if (msg) fprintf(stderr, "ilbmtoc: %s\n", msg);
90
91 if (chunkybuffer_packed) free(chunkybuffer_packed);
92 if (planarbuffer_packed) free(planarbuffer_packed);
93 if (chunkybuffer) free(chunkybuffer);
94 if (planarbuffer) free(planarbuffer);
95 if (filebuffer) free(filebuffer);
96
97 if (file) fclose(file);
98
99 exit(rc);
100 }
101
102 /****************************************************************************************/
103
104 static void getarguments(int argc, char **argv)
105 {
106 char *imagenamestart, *sp;
107 WORD i;
108 unsigned int narg = 1;
109
110 if (!strcasecmp(argv[1], "-b2c"))
111 {
112 brush2c = 1;
113 narg++;
114 }
115 else if (!strcasecmp(argv[1], "-b2p"))
116 {
117 brush2pix = 1;
118 narg++;
119 }
120
121 if (argc > narg)
122 filename = argv[narg++];
123 else
124 cleanup("Usage: ilbmtoc [-b2c|-b2p] filename [imagename]", 1);
125
126 if (argc > narg)
127 imagenamestart = argv[narg];
128 else
129 {
130 imagenamestart = filename;
131 for(;;)
132 {
133 sp = strchr(imagenamestart + 1, '/');
134 if (!sp) sp = strchr(imagenamestart + 1, '\\');
135 if (!sp) sp = strchr(imagenamestart + 1, ':');
136 if (!sp) break;
137
138 imagenamestart = sp + 1;
139 }
140 }
141
142 if (strlen(imagename) >= sizeof(imagename)) cleanup("Image name too long!", 1);
143
144 strcpy(imagename, imagenamestart);
145 if ((sp = strchr(imagename, '.'))) *sp = 0;
146
147 for(i = 0; i < strlen(imagename); i++) bigimagename[i] = toupper(imagename[i]);
148 }
149
150 /****************************************************************************************/
151
152 static ULONG getlong(void)
153 {
154 ULONG ret;
155
156 if (filepos > filesize - 4) cleanup("Tried to read over file end!", 1);
157
158 ret = filebuffer[filepos++] * 0x1000000;
159 ret += filebuffer[filepos++] * 0x10000;
160 ret += filebuffer[filepos++] * 0x100;
161 ret += filebuffer[filepos++];
162
163 return ret;
164 }
165
166 /****************************************************************************************/
167
168 static UWORD getword(void)
169 {
170 UWORD ret;
171
172 if (filepos > filesize - 2) cleanup("Tried to read over file end!", 1);
173
174 ret = filebuffer[filepos++] * 0x100;
175 ret += filebuffer[filepos++];
176
177 return ret;
178 }
179
180 /****************************************************************************************/
181
182 static UBYTE getbyte(void)
183 {
184 ULONG ret;
185
186 if (filepos > filesize - 1) cleanup("Tried to read over file end!", 1);
187 ret = filebuffer[filepos++];
188
189 return ret;
190 }
191
192 /****************************************************************************************/
193
194 static void skipbytes(ULONG howmany)
195 {
196 filepos += howmany;
197 }
198
199 /****************************************************************************************/
200
201 static void openfile(void)
202 {
203 file = fopen(filename, "rb");
204 if (!file) cleanup("Can't open file!", 1);
205
206 fseek(file, 0, SEEK_END);
207 filesize = ftell(file);
208
209 if (filesize < 12) cleanup("Bad file size!", 1);
210
211 fprintf(stderr, "Filesize is %ld\n", filesize);
212
213 fseek(file, 0, SEEK_SET);
214
215 filebuffer = malloc(filesize + 10);
216 if (!filebuffer) cleanup("Memory allocation for file buffer failed!", 1);
217
218 if (fread(filebuffer, 1, filesize, file) != filesize)
219 cleanup("Error reading file!", 1);
220
221 fclose(file); file = NULL;
222 }
223
224 /****************************************************************************************/
225
226 static void checkfile(void)
227 {
228 ULONG id;
229 ULONG size;
230
231 id = getlong();
232 if (id != ID_FORM) cleanup("File is not an IFF file!", 1);
233
234 size = getlong();
235 if (size != filesize - 8) cleanup("File is IFF, but has bad size in IFF header!", 1);
236
237 id = getlong();
238 if (id != ID_ILBM) cleanup("File is IFF, but not of type ILBM!", 1);
239 }
240
241 /****************************************************************************************/
242
243 static void scanfile(void)
244 {
245 WORD i;
246
247 for(;;)
248 {
249 ULONG id;
250 ULONG size;
251
252 id = getlong();
253 size = getlong();
254
255 /* Cast the IFF identifier to 4 ASCII chars:
256 (Use unsigned as i ANSI-C the cast to signed is implementation-dependent.) */
257 fprintf( stderr, "Chunk: %c%c%c%c Size: %ld\n"
258 , (unsigned char) (id >> 24)
259 , (unsigned char) (id >> 16)
260 , (unsigned char) (id >> 8)
261 , (unsigned char) (id)
262 , size
263 );
264
265 switch(id)
266 {
267 case ID_BMHD:
268 if (size != 20) cleanup("Bad BMHD chunk size!", 1);
269
270 bmh.bmh_Width = getword();
271 bmh.bmh_Height = getword();
272 bmh.bmh_Left = (WORD)getword();
273 bmh.bmh_Top = (WORD)getword();
274 bmh.bmh_Depth = getbyte();
275 bmh.bmh_Masking = getbyte();
276 bmh.bmh_Compression = getbyte();
277 bmh.bmh_Pad = getbyte();
278 bmh.bmh_Transparent = getword();
279 bmh.bmh_XAspect = getbyte();
280 bmh.bmh_YAspect = getbyte();
281 bmh.bmh_PageWidth = (WORD)getword();
282 bmh.bmh_PageHeight = (WORD)getword();
283
284 if (bmh.bmh_Depth > 8) cleanup("ILBM file has too many colors!", 1);
285 if ((bmh.bmh_Compression != CMP_NONE) && (bmh.bmh_Compression != CMP_BYTERUN1)) cleanup("Compression method unsupported!", 1);
286
287 have_bmhd = 1;
288
289 totdepth = bmh.bmh_Depth + ((bmh.bmh_Masking == MSK_HASMASK) ? 1 : 0);
290
291 bpr = ((bmh.bmh_Width + 15) & ~15) / 8;
292
293 fprintf(stderr, "BMHD: %d x %d x %d (%ld)\n", bmh.bmh_Width,
294 bmh.bmh_Height,
295 bmh.bmh_Depth,
296 totdepth);
297 break;
298
299 case ID_CMAP:
300 if (!have_bmhd) cleanup("CMAP chunk before BMHD chunk (or no BMHD chunk at all!", 1);
301
302 cmapentries = size / 3;
303 if (size & 1) size++;
304
305 if ((cmapentries < 2) || (cmapentries > 256)) cleanup("CMAP chunk has bad number of entries!", 1);
306
307 for(i = 0; i < cmapentries; i++)
308 {
309 red[i] = getbyte();
310 green[i] = getbyte();
311 blue[i] = getbyte();
312 size -= 3;
313 }
314
315 skipbytes(size);
316
317 have_cmap = 1;
318
319 break;
320
321 case ID_BODY:
322 if (!have_bmhd) cleanup("BODY chunk before BMHD chunk (or no BMHD chunk at all!", 1);
323 body = &filebuffer[filepos];
324 bodysize = size;
325
326 if (bmh.bmh_Compression == CMP_NONE)
327 {
328 LONG shouldbesize = totdepth * bpr * bmh.bmh_Height;
329 if (bodysize != shouldbesize) cleanup("BODY chunk size seems to be wrong!", 1);
330 }
331
332 have_body = 1;
333 /* Fall through */
334
335 default:
336 if (size & 1) size++;
337 skipbytes(size);
338 break;
339 }
340
341 if (filepos == filesize) break;
342 if (have_bmhd && have_body && have_cmap) break;
343 }
344
345 if (!have_bmhd) cleanup("BMHD chunk missing!", 1);
346 if (!have_body) cleanup("BODY chunk missing!", 1);
347 }
348
349 /****************************************************************************************/
350
351 static unsigned char *unpack_byterun1(unsigned char *source, unsigned char *dest, LONG unpackedsize)
352 {
353 unsigned char r;
354 signed char c;
355
356 for(;;)
357 {
358 c = (signed char)(*source++);
359 if (c >= 0)
360 {
361 while(c-- >= 0)
362 {
363 *dest++ = *source++;
364 if (--unpackedsize <= 0) return source;
365 }
366 }
367 else if (c != -128)
368 {
369 c = -c;
370 r = *source++;
371
372 while(c-- >= 0)
373 {
374 *dest++ = r;
375 if (--unpackedsize <= 0) return source;
376 }
377 }
378 }
379
380 }
381
382 /****************************************************************************************/
383
384 static BOOL norm1(LONG count, unsigned char **source_backup,
385 unsigned char **dest, LONG *checksize)
386 {
387 //if (count >= 0) fprintf(stderr, "XX: non packable %d\n",count);
388
389 while(count >= 0)
390 {
391 LONG step = count;
392
393 if (step > 127) step = 127;
394
395 *checksize -= step;
396 *checksize -= 2;
397
398 if (*checksize <= 0) return 0;
399
400 count -= step;
401
402 *(*dest)++ = step;
403
404
405 while(step-- >= 0)
406 {
407 *(*dest)++ = *(*source_backup)++;
408 }
409
410 count--;
411
412 }
413
414 return 1;
415 }
416
417 static BOOL copy1(unsigned char r, LONG count, unsigned char **dest, LONG *checksize)
418 {
419 //if (count >= 1) fprintf(stderr, "XX: repeat %02x x %d\n", r, count);
420
421 while(--count >= 0)
422 {
423 LONG step = count;
424
425 if (step > 127) step = 127;
426
427 count -= step;
428 step = -step;
429 *checksize -= 2;
430 if (*checksize <= 0) return 0;
431
432 *(*dest)++ = (unsigned char)step;
433 *(*dest)++ = r;
434 }
435
436 return 1;
437 }
438
439 static BOOL pack_byterun1(unsigned char *source, unsigned char *dest,
440 LONG size, LONG check_size, LONG *packsize)
441 {
442 unsigned char *source_backup, *dest_backup;
443 LONG samebytes_counter, samebytes, count;
444 LONG checksize = check_size;
445 unsigned char oldbyte, actbyte;
446
447 if (checksize < 0) checksize = 0x7FFFFFFF;
448
449 oldbyte = *source;
450 samebytes_counter = 0;
451 source_backup = source;
452 dest_backup = dest;
453
454 for(;;)
455 {
456 //fprintf(stderr, "size = %d. checksize = %d\n", size, checksize);
457 if (--size < 0) break;
458 actbyte = *source++;
459 if (actbyte == oldbyte)
460 {
461 samebytes_counter++;
462 continue;
463 }
464
465 oldbyte = actbyte;
466
467 samebytes = samebytes_counter;
468 samebytes_counter = 1;
469
470 if (samebytes < 3) continue;
471
472 count = (LONG)(source - source_backup - samebytes - 2);
473 if (!norm1(count, &source_backup, &dest, &checksize)) return 0;
474
475 if (!copy1(source[-2], samebytes, &dest, &checksize)) return 0;
476
477 source_backup = source - 1;
478 }
479 //fprintf(stderr, "done\n");
480
481 if (samebytes_counter >= 3)
482 {
483 samebytes = samebytes_counter;
484 count = (LONG)(source - source_backup - samebytes - 1);
485 if (!norm1(count, &source_backup, &dest, &checksize)) return 0;
486 if (!copy1(source[-2], samebytes, &dest, &checksize)) return 0;
487 }
488 else
489 {
490 count = (LONG)(source - source_backup - 1);
491 if (!norm1(count, &source_backup, &dest, &checksize)) return 0;
492 }
493 //fprintf(stderr, "realdone\n");
494
495 if (packsize) *packsize = (LONG)(dest - dest_backup);
496
497 return 1;
498 }
499
500 /****************************************************************************************/
501
502 static void p2c(unsigned char *source, unsigned char *dest, LONG width, LONG height,
503 LONG totplanes, LONG wantplanes, LONG chunkybpr)
504 {
505 LONG alignedwidth, x, y, p, bpr, bpl;
506
507 alignedwidth = (width + 15) & ~15;
508 bpr = alignedwidth / 8;
509 bpl = bpr * totplanes;
510
511 for(y = 0; y < height; y++)
512 {
513 for(x = 0; x < width; x++)
514 {
515 LONG mask = 1 << (7 - (x & 7));
516 LONG offset = x / 8;
517 unsigned char chunkypix = 0;
518
519 for(p = 0; p < wantplanes; p++)
520 {
521 if (source[p * bpr + offset] & mask) chunkypix |= (1 << p);
522 }
523 dest[x] = chunkypix;
524 }
525
526 source += bpl;
527 dest += chunkybpr;
528 }
529
530
531 }
532
533 /****************************************************************************************/
534
535 static void convertbody(void)
536 {
537 LONG unpackedsize = bpr * bmh.bmh_Height * totdepth;
538
539 planarbuffer = malloc(unpackedsize);
540 if (!planarbuffer) cleanup("Memory allocation for planar buffer failed!", 1);
541
542 if (bmh.bmh_Compression == CMP_NONE)
543 {
544 memcpy(planarbuffer, body, unpackedsize);
545 }
546 else
547 {
548 unpack_byterun1(body, planarbuffer, unpackedsize);
549 }
550
551 chunkybuffer = malloc(bmh.bmh_Width * bmh.bmh_Height);
552 if (!chunkybuffer) cleanup("Memory allocation for chunky buffer failed!", 1);
553
554 p2c(planarbuffer,
555 chunkybuffer,
556 bmh.bmh_Width,
557 bmh.bmh_Height,
558 totdepth,
559 bmh.bmh_Depth,
560 bmh.bmh_Width);
561 }
562
563 /****************************************************************************************/
564
565 static void packdata(void)
566 {
567 LONG chunkysize = (LONG)bmh.bmh_Width * (LONG)bmh.bmh_Height;
568 BOOL success;
569
570 chunkybuffer_packed = malloc(chunkysize);
571
572 if (!chunkybuffer_packed) cleanup("Memory allocation for packed chunky buffer failed!", 1);
573
574 fprintf(stderr, "Starting packing\n");
575
576 success = pack_byterun1(chunkybuffer, chunkybuffer_packed,
577 chunkysize, chunkysize, &bodysize_packed);
578
579 fprintf(stderr, "Done packing. Success = %d\n", success);
580 if (!success)
581 {
582 free(chunkybuffer_packed); chunkybuffer_packed = 0;
583 }
584 }
585
586 /****************************************************************************************/
587
588 static void gensource(void)
589 {
590 unsigned char *buffer;
591 LONG i, x, buffersize;
592
593 printf("#include <exec/types.h>\n");
594 printf("\n");
595 printf("#define %s_WIDTH %d\n", bigimagename, bmh.bmh_Width);
596 printf("#define %s_HEIGHT %d\n", bigimagename, bmh.bmh_Height);
597 printf("#define %s_PACKED %d\n", bigimagename, (chunkybuffer_packed || planarbuffer_packed) ? 1 : 0);
598 printf("#define %s_PLANES %d\n", bigimagename, bmh.bmh_Depth);
599 if (have_cmap)
600 printf("#define %s_COLORS %ld\n", bigimagename, cmapentries);
601
602 printf("\n");
603
604 if (have_cmap)
605 {
606 printf("const ULONG %s_pal[%ld] =\n", imagename, cmapentries);
607 printf("{\n");
608 for(i = 0; i < cmapentries; i++)
609 {
610 ULONG col = (((ULONG)red[i]) << 16) +
611 (((ULONG)green[i]) << 8) +
612 ((ULONG)blue[i]);
613
614 printf(" 0x%06lx", col);
615 if (i == cmapentries - 1)
616 printf("\n");
617 else
618 printf(",\n");
619 }
620 printf("};\n\n");
621 }
622
623
624 if (chunkybuffer_packed)
625 {
626 buffer = chunkybuffer_packed;
627 buffersize = bodysize_packed;
628 }
629 else
630 {
631 buffer = chunkybuffer;
632 buffersize = bodysize;
633 }
634
635 printf("const UBYTE %s_data[%ld] =\n", imagename, buffersize);
636 printf("{");
637
638 i = 0;
639
640 for(x = 0; x < buffersize; x++)
641 {
642 if ((i++ % 20) == 0) printf("\n ");
643 printf("0x%02x", buffer[x]);
644 if (!(x == buffersize - 1)) printf(",");
645 }
646
647 printf("\n");
648 printf("};\n");
649 }
650
651 /****************************************************************************************/
652
653 static void genbrush2csource(void)
654 {
655 int i;
656
657 if (have_cmap)
658 {
659 printf("#ifdef USE_%s_COLORS\n", bigimagename);
660 printf("const ULONG %s_colors[%ld] =\n{\n", imagename, cmapentries * 3);
661 for (i = 0; i < cmapentries; i++)
662 {
663 printf("\t0x%08lx,0x%08lx,0x%08lx,\n",
664 (long) ((ULONG)red[i] << 24 | (ULONG)red[i] << 16 | (ULONG)red[i] << 8 | (ULONG)red[i]),
665 (long) ((ULONG)green[i] << 24 | (ULONG)green[i] << 16 | (ULONG)green[i] << 8 | (ULONG)green[i]),
666 (long) ((ULONG)blue[i] << 24 | (ULONG)blue[i] << 16 | (ULONG)blue[i] << 8 | (ULONG)blue[i]));
667 }
668 printf("};\n");
669 printf("#endif\n\n");
670 }
671
672 if (have_body)
673 {
674 printf("#define %s_WIDTH %3d\n", bigimagename, bmh.bmh_Width);
675 printf("#define %s_HEIGHT %3d\n", bigimagename, bmh.bmh_Height);
676 printf("#define %s_DEPTH %3d\n", bigimagename, bmh.bmh_Depth);
677 printf("#define %s_COMPRESSION %3d\n", bigimagename, bmh.bmh_Compression);
678 printf("#define %s_MASKING %3d\n", bigimagename, bmh.bmh_Masking);
679 printf("\n");
680
681 printf("#ifdef USE_%s_HEADER\n", bigimagename);
682 printf("const struct BitMapHeader %s_header =\n{ %ld,%ld,%ld,%ld,%ld,%ld,%ld,0,%ld,%ld,%ld,%ld,%ld };\n",
683 imagename, (long)bmh.bmh_Width, (long)bmh.bmh_Height, (long)bmh.bmh_Left, (long)bmh.bmh_Top,
684 (long)bmh.bmh_Depth, (long)bmh.bmh_Masking, (long)bmh.bmh_Compression, (long)bmh.bmh_Transparent,
685 (long)bmh.bmh_XAspect, (long)bmh.bmh_YAspect, (long)bmh.bmh_PageWidth, (long)bmh.bmh_PageHeight);
686 printf("#endif\n\n");
687
688 printf("#ifdef USE_%s_BODY\n", bigimagename);
689 printf("const UBYTE %s_body[%ld] = {\n", imagename, bodysize);
690 for (i = 0; i < bodysize; i++)
691 {
692 printf("0x%02lx,", (long)(body[i]));
693 if (!((i + 1) % 15)) printf("\n");
694 }
695 printf(" };\n");
696 printf("#endif\n");
697 }
698 }
699
700 /****************************************************************************************/
701
702 static void genbrush2pixsource(void)
703 {
704 int i;
705
706 if (have_cmap)
707 {
708 printf("const ULONG %s_colors[%ld] =\n{\n", imagename, cmapentries * 3);
709 for (i = 0; i < cmapentries; i++)
710 {
711 printf("\t0x%08lx,0x%08lx,0x%08lx,\n",
712 (long)((ULONG)red[i] << 24 | (ULONG)red[i] << 16 | (ULONG)red[i] << 8 | (ULONG)red[i]),
713 (long)((ULONG)green[i] << 24 | (ULONG)green[i] << 16 | (ULONG)green[i] << 8 | (ULONG)green[i]),
714 (long)((ULONG)blue[i] << 24 | (ULONG)blue[i] << 16 | (ULONG)blue[i] << 8 | (ULONG)blue[i]));
715 }
716 printf("};\n\n");
717 }
718
719 if (have_body)
720 {
721 printf("#define %s_WIDTH %3d\n", bigimagename, bmh.bmh_Width);
722 printf("#define %s_HEIGHT %3d\n", bigimagename, bmh.bmh_Height);
723 printf("#define %s_DEPTH %3d\n", bigimagename, bmh.bmh_Depth);
724 printf("#define %s_COMPRESSION %3d\n", bigimagename, bmh.bmh_Compression);
725 printf("#define %s_MASKING %3d\n", bigimagename, bmh.bmh_Masking);
726 printf("\n");
727
728 printf("const UBYTE %s_body[%ld] = {\n", imagename, bodysize);
729 for (i = 0; i < bodysize; i++)
730 {
731 printf("0x%02lx,", (long)(body[i]));
732 if (!((i + 1) % 15)) printf("\n");
733 }
734 printf(" };\n");
735 }
736
737 if (have_cmap && have_body)
738 {
739 printf("\nmuidefpix %s_defpix =\n{\n", imagename);
740 printf("\t%s_body,\n", imagename);
741 printf("\t%s_colors,\n", imagename);
742 printf("\t%s_WIDTH, %s_HEIGHT, %s_DEPTH,\n", bigimagename, bigimagename, bigimagename);
743 printf("\t%s_COMPRESSION, %s_MASKING \n", bigimagename, bigimagename);
744 printf("};\n");
745 }
746 }
747
748 /****************************************************************************************/
749
750 int main(int argc, char **argv)
751 {
752 getarguments(argc, argv);
753 openfile();
754 checkfile();
755 scanfile();
756
757 if (brush2c)
758 {
759 genbrush2csource();
760 }
761 else if (brush2pix)
762 {
763 genbrush2pixsource();
764 }
765 else
766 {
767 convertbody();
768 packdata();
769 gensource();
770 }
771
772 cleanup(0, 0);
773 }
774
775 /****************************************************************************************/
Mirror of AROS' svn.