?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Check for SYS/GL during library init. Reason is that
[AROS.git] / workbench / libs / icon / diskobj35io.c
bloba0f45b32f3b0365079b3aa2b693fd01fa023340c
1 /*
2 Copyright © 1995-2013, The AROS Development Team. All rights reserved.
3 $Id$
4 */
5
6 /****************************************************************************************/
7
8 #include <aros/debug.h>
9
10 #include <datatypes/pictureclass.h>
11
12 #include <proto/dos.h>
13 #include <proto/alib.h>
14
15 #include <zlib.h>
16
17 #include <aros/bigendianio.h>
18 #include <aros/asmcall.h>
19
20 #include "icon_intern.h"
21
22 /****************************************************************************************/
23
24 #define ID_ICON MAKE_ID('I','C','O','N')
25 #define ID_FACE MAKE_ID('F','A','C','E')
26 #define ID_IMAG MAKE_ID('I','M','A','G')
27 #define ID_png MAKE_ID('p','n','g',' ')
28 #define ID_ARGB MAKE_ID('A','R','G','B')
29
30 /****************************************************************************************/
31
32 struct FileFaceChunk
33 {
34 UBYTE Width;
35 UBYTE Height;
36 UBYTE Flags;
37 UBYTE Aspect;
38 UBYTE MaxPaletteBytes[2];
39 };
40
41 struct FileImageChunk
42 {
43 UBYTE TransparentColor;
44 UBYTE NumColors;
45 UBYTE Flags;
46 UBYTE ImageFormat;
47 UBYTE PaletteFormat;
48 UBYTE Depth;
49 UBYTE NumImageBytes[2];
50 UBYTE NumPaletteBytes[2];
51 };
52
53 /****************************************************************************************/
54
55 static LONG MyDOSStreamHandler(struct Hook *hook, struct IFFHandle * iff, struct IFFStreamCmd * cmd)
56 {
57 LONG error = 0;
58
59 struct IconBase *IconBase = hook->h_Data;
60
61 switch(cmd->sc_Command)
62 {
63 case IFFCMD_INIT:
64 case IFFCMD_CLEANUP:
65 error = 0;
66 break;
67
68 case IFFCMD_READ:
69 error = (FRead((BPTR)iff->iff_Stream, cmd->sc_Buf, 1, cmd->sc_NBytes)) != cmd->sc_NBytes;
70 break;
71
72 case IFFCMD_WRITE:
73 error = (FWrite((BPTR)iff->iff_Stream, cmd->sc_Buf, 1, cmd->sc_NBytes)) != cmd->sc_NBytes;
74 break;
75
76 case IFFCMD_SEEK:
77 Flush((BPTR)iff->iff_Stream);
78 error = (Seek((BPTR)iff->iff_Stream, cmd->sc_NBytes, OFFSET_CURRENT)) == -1;
79 break;
80 }
81
82 return error;
83 }
84
85 static LONG MyMemStreamHandler(struct Hook *hook, struct IFFHandle * iff, struct IFFStreamCmd * cmd)
86 {
87 LONG error = 0;
88 APTR *buffp = (APTR *)iff->iff_Stream;
89 APTR buff = *buffp;
90
91 switch(cmd->sc_Command)
92 {
93 case IFFCMD_INIT:
94 case IFFCMD_CLEANUP:
95 error = 0;
96 break;
97
98 case IFFCMD_READ:
99 error = 0;
100 CopyMem(buff, cmd->sc_Buf, cmd->sc_NBytes);
101 (*buffp) += cmd->sc_NBytes;
102 break;
103
104 case IFFCMD_WRITE:
105 error = 0;
106 CopyMem(cmd->sc_Buf, buff, cmd->sc_NBytes);
107 (*buffp) += cmd->sc_NBytes;
108 break;
109
110 case IFFCMD_SEEK:
111 (*buffp) += cmd->sc_NBytes;
112 error = 0;
113 break;
114 }
115
116 return error;
117 }
118
119 /****************************************************************************************/
120
121 /* Decode35() based on ModifyIcon by Dirk Stöcker */
122
123 /****************************************************************************************/
124
125 static char *Decode35(UBYTE *buffer, UBYTE *outbuffer, LONG numbytes, LONG bits, LONG entries)
126 {
127 int cop = 0, loop = 0, numbits = 0, mask, curentry = 0;
128 ULONG bitbuf = 0;
129 UBYTE byte;
130
131 mask = (1<<bits)-1;
132
133 while((numbytes || (cop && numbits >= bits)) && (curentry < entries))
134 {
135 if(!cop)
136 {
137 if(numbits < 8)
138 {
139 bitbuf = (bitbuf<<8)|*(buffer++); --numbytes;
140 numbits += 8;
141 }
142
143 byte = (bitbuf>>(numbits-8))&0xFF;
144 numbits -= 8;
145
146 if(byte <= 127) cop = byte+1;
147 else if(byte > 128) loop = 256-byte+1;
148 else continue;
149 }
150
151 if(cop) ++loop;
152
153 if(numbits < bits)
154 {
155 bitbuf = (bitbuf<<8)|*(buffer++); --numbytes;
156 numbits += 8;
157 }
158
159 byte = (bitbuf>>(numbits-bits))&mask;
160
161 while(loop && (curentry < entries))
162 {
163 *outbuffer++ = byte;
164 ++curentry;
165 --loop;
166 }
167
168 if(cop) --cop;
169
170 numbits -= bits;
171 }
172
173 return curentry != entries ? "error decoding new icon data" : 0;
174 }
175
176 /****************************************************************************************/
177
178 VOID MakeMask35(UBYTE *imgdata, UBYTE *imgmask, UBYTE transpcolor, LONG imagew, LONG imageh)
179 {
180 UBYTE *src, *dst;
181 WORD x, y, bpr, mask;
182
183 memset(imgmask, 0xFF, RASSIZE(imagew, imageh));
184
185 bpr = ((imagew + 15) & ~15) / 8;
186 src = imgdata;
187 dst = imgmask;
188
189 for(y = 0; y < imageh; y++)
190 {
191 UBYTE *dstx = dst;
192
193 mask = 0x80;
194
195 for(x = 0; x < imagew; x++)
196 {
197 if (*(src++) == transpcolor)
198 {
199 *dstx &= ~mask;
200 }
201
202 mask >>= 1;
203 if (!mask)
204 {
205 mask = 0x80;
206 dstx++;
207 }
208 }
209 dst += bpr;
210
211 }
212
213 }
214
215 /****************************************************************************************/
216 void *malloc(size_t size)
217 {
218 return AllocVec(size, MEMF_PUBLIC);
219 }
220
221 void free(void *ptr)
222 {
223 FreeVec(ptr);
224 }
225
226 STATIC BOOL ReadARGB35(struct DiskObject *icon, struct IFFHandle *iff, struct FileFaceChunk *fc,
227 LONG chunksize, UBYTE **argbptr,
228 struct IconBase *IconBase)
229 {
230 UBYTE *src, *mem, *argb = NULL;
231 LONG imagew, imageh;
232 ULONG zsize;
233 uLongf size;
234 int err;
235
236 imagew = fc->Width + 1;
237 imageh = fc->Height + 1;
238 size = imagew * imageh * 4;
239
240 D(bug("[%s] ARGB size is %dx%d, %d => %d bytes\n", __func__, imagew, imageh, chunksize, size));
241
242 src = mem = AllocMemIcon(icon, chunksize, MEMF_PUBLIC, IconBase);
243 if (!src) return FALSE;
244
245 if (ReadChunkBytes(iff, src, chunksize) != chunksize)
246 {
247 goto fail;
248 }
249
250 argb = AllocMemIcon(icon, size, MEMF_PUBLIC, IconBase);
251 if (!argb) goto fail;
252
253 zsize = AROS_BE2WORD(*((UWORD *)(src + 6))) + 1;
254 err = uncompress(argb, &size, src + 10, zsize);
255 if (err != Z_OK) {
256 D(bug("%s: Can't uncompress %d ARGB bytes: %s\n", __func__, zsize, zError(err)));
257 goto fail;
258 }
259
260 *argbptr = argb;
261
262 return TRUE;
263
264 fail:
265 return FALSE;
266 }
267
268 /****************************************************************************************/
269
270 STATIC BOOL ReadImage35(struct DiskObject *icon, struct IFFHandle *iff, struct FileFaceChunk *fc,
271 struct FileImageChunk *ic, UBYTE **imgdataptr,
272 struct ColorRegister **imgpalptr, struct IconBase *IconBase)
273 {
274 UBYTE *src, *mem, *imgdata = NULL;
275 struct ColorRegister *imgpal = NULL;
276 LONG size, imgsize, palsize, imagew, imageh, numcols;
277
278 imagew = fc->Width + 1;
279 imageh = fc->Height + 1;
280 numcols = ic->NumColors + 1;
281
282 imgsize = ic->NumImageBytes[0] * 256 + ic->NumImageBytes[1] + 1;
283 if (ic->Flags & IMAGE35F_HASPALETTE)
284 {
285 palsize = ic->NumPaletteBytes[0] * 256 + ic->NumPaletteBytes[1] + 1;
286 }
287 else
288 {
289 palsize = 0;
290 }
291
292 D(bug("[%s] Image size is %dx%d, %d bytes\n", __func__, imagew, imageh, imgsize));
293 D(bug("[%s] Palette size is %d colors, %d bytes\n", __func__, numcols, palsize));
294
295 size = imgsize + palsize;
296
297 src = mem = AllocMemIcon(icon, size, MEMF_PUBLIC, IconBase);
298 if (!src) return FALSE;
299
300 if (ReadChunkBytes(iff, src, size) != size)
301 {
302 return FALSE;
303 }
304
305 if (ic->Flags & IMAGE35F_HASPALETTE)
306 {
307 if (numcols < 1 || numcols > 256)
308 return FALSE;
309
310 size = numcols * sizeof(struct ColorRegister);
311 imgpal = AllocMemIcon(icon, size, MEMF_PUBLIC, IconBase);
312 if (!imgpal) goto fail;
313 }
314
315 size = imagew * imageh;
316 imgdata = AllocMemIcon(icon, size, MEMF_PUBLIC, IconBase);
317 if (!imgdata) goto fail;
318
319 if (ic->ImageFormat == 0)
320 {
321 memcpy(imgdata, src, imagew * imageh);
322 }
323 else
324 {
325 Decode35(src, imgdata, imgsize, ic->Depth, imagew * imageh);
326 }
327 src += imgsize;
328
329 if (ic->Flags & IMAGE35F_HASPALETTE)
330 {
331 struct ColorRegister *dst;
332
333 dst = imgpal;
334
335 D(bug("[%s] PaletteFormat %d, src %p\n", __func__, ic->PaletteFormat, src));
336 if (ic->PaletteFormat == 0)
337 {
338 ULONG i, r, g, b;
339
340 for(i = 0; i < numcols; i++)
341 {
342 r = *src++;
343 g = *src++;
344 b = *src++;
345
346 dst->red = r;
347 dst->green = g;
348 dst->blue = b;
349 dst++;
350 }
351 }
352 else
353 {
354 CONST_STRPTR err;
355
356 err = Decode35(src, (UBYTE *)imgpal, palsize, 8, 3 * numcols);
357 if (err) {
358 D(bug("[%s] Palette decode error: %s\n", __func__, err));
359 imgpal = NULL;
360 }
361
362
363 if (imgpal && sizeof(struct ColorRegister) != 3)
364 {
365 struct ColorRegister *dst;
366 UWORD i, r, g, b;
367
368 D(bug("[%s] Realigning ColorRegister\n", __func__));
369
370 src = (APTR)imgpal + 3 * numcols;
371 dst = (struct ColorRegister *)(imgpal + sizeof(struct ColorRegister) * numcols);
372
373 for (i = 0; i < numcols; i++)
374 {
375 b = *--src;
376 g = *--src;
377 r = *--src;
378
379 dst--;
380
381 dst->red = r;
382 dst->green = g;
383 dst->blue = b;
384 }
385 }
386 }
387
388 } /* if (ic->Flags & IMAGE35F_HASPALETTE) */
389
390 *imgdataptr = imgdata;
391 *imgpalptr = imgpal;
392
393 return TRUE;
394
395 fail:
396 return FALSE;
397 }
398
399 /****************************************************************************************/
400
401 BOOL ReadIcon35(struct NativeIcon *icon, struct Hook *streamhook,
402 void *stream, struct IconBase *IconBase)
403 {
404 static const LONG const stopchunks[] =
405 {
406 ID_ICON, ID_FACE,
407 ID_ICON, ID_IMAG,
408 ID_ICON, ID_png,
409 ID_ICON, ID_ARGB,
410 };
411
412 struct IFFHandle *iff;
413 struct Hook iffhook;
414 struct FileFaceChunk fc;
415 struct FileImageChunk ic1, ic2;
416 UBYTE *argb1data = NULL, *argb2data = NULL;
417 UBYTE *img1data = NULL, *img2data = NULL;
418 struct ColorRegister *img1pal = NULL, *img2pal = NULL;
419 BOOL have_face = FALSE, have_imag1 = FALSE, have_imag2 = FALSE;
420 BOOL have_argb1 = FALSE, have_argb2 = FALSE;
421 int have_png = 0;
422 LONG here, extrasize;
423 APTR data;
424
425 D(bug("ReadIcon35, stream %p\n", stream));
426
427 here = Seek((BPTR)stream, 0, OFFSET_CURRENT);
428 D(bug("[%s] Extra data starts at %d\n", __func__, here));
429 Seek((BPTR)stream, 0, OFFSET_END);
430 extrasize = Seek((BPTR)stream, 0, OFFSET_CURRENT);
431 D(bug("[%s] Extra data ends at %d\n", __func__, extrasize));
432 extrasize -= here;
433 Seek((BPTR)stream, here, OFFSET_BEGINNING);
434 D(bug("[%s] .. %d bytes\n", __func__, extrasize));
435
436 /* No extra data? That's fine. */
437 if (extrasize <= 0) {
438 D(bug("[%s] No extra data\n", __func__));
439 return TRUE;
440 }
441
442 if (IFFParseBase == NULL)
443 return FALSE;
444
445 data = AllocMemIcon(&icon->ni_DiskObject, extrasize, MEMF_PUBLIC,
446 IconBase);
447 if (data == NULL)
448 return FALSE;
449
450 if (Read((BPTR)stream, data, extrasize) != extrasize) {
451 D(bug("[%s] Can't read extra data\n", __func__));
452 return FALSE;
453 }
454
455 icon->ni_Extra.Data = data;
456 icon->ni_Extra.Size = extrasize;
457
458 iffhook.h_Entry = (HOOKFUNC)HookEntry;
459 iffhook.h_SubEntry = (HOOKFUNC)MyMemStreamHandler;
460 iffhook.h_Data = (APTR)IconBase;
461
462 if ((iff = AllocIFF()))
463 {
464 D(bug("ReadIcon35. AllocIFF okay\n"));
465
466 iff->iff_Stream = (IPTR)&data;
467
468 InitIFF(iff, IFFF_RSEEK, &iffhook);
469
470 if (!OpenIFF(iff, IFFF_READ))
471 {
472 D(bug("ReadIcon35. OpenIFF okay\n"));
473
474 if (!StopChunks(iff, stopchunks, 4))
475 {
476 LONG error;
477
478 D(bug("ReadIcon35. StopChunks okay\n"));
479
480 while(!(error = ParseIFF(iff, IFFPARSE_SCAN)))
481 {
482 struct ContextNode *cn;
483
484 cn = CurrentChunk(iff);
485
486 D(bug("inside ParseIFF loop\n"));
487 if ((cn->cn_ID == ID_FACE) && (cn->cn_Size >= sizeof(struct FileFaceChunk)))
488 {
489 D(bug("ReadIcon35. Found FACE chunk\n"));
490 if (ReadChunkBytes(iff, &fc, sizeof(fc)) == sizeof(fc))
491 {
492 have_face = TRUE;
493 }
494 }
495 else if (have_face && (cn->cn_ID == ID_IMAG) && (cn->cn_Size >= sizeof(struct FileImageChunk)))
496 {
497 D(bug("ReadIcon35. Found IMAG chunk\n"));
498 if (ReadChunkBytes(iff, (have_imag1 ? &ic2 : &ic1), sizeof(ic1)) == sizeof(ic1))
499 {
500 if (have_imag1)
501 {
502 if (ReadImage35(&icon->ni_DiskObject, iff, &fc, &ic2, &img2data, &img2pal, IconBase))
503 {
504 have_imag2 = TRUE;
505 }
506 }
507 else
508 {
509 if (ReadImage35(&icon->ni_DiskObject, iff, &fc, &ic1, &img1data, &img1pal, IconBase))
510 {
511 have_imag1 = TRUE;
512 }
513 }
514
515 }
516 } else if (cn->cn_ID == ID_ARGB) {
517 D(bug("ReadIcon35. Found ARGB chunk\n"));
518 if (have_argb1)
519 {
520 if (ReadARGB35(&icon->ni_DiskObject, iff, &fc, cn->cn_Size, &argb2data, IconBase))
521 {
522 have_argb2 = TRUE;
523 }
524 }
525 else
526 {
527 if (ReadARGB35(&icon->ni_DiskObject, iff, &fc, cn->cn_Size, &argb1data, IconBase))
528 {
529 have_argb1 = TRUE;
530 }
531 }
532 } else if (cn->cn_ID == ID_png) {
533 if (have_png < 2) {
534 LONG here = data - icon->ni_Extra.Data;
535 D(bug("[%s] Found PNG image %d\n", __func__, have_png));
536 icon->ni_Extra.PNG[have_png].Offset = here;
537 icon->ni_Extra.PNG[have_png].Size = cn->cn_Size;
538 } else {
539 D(bug("[%s] Ignoring PNG image %d\n", __func__, have_png));
540 }
541 have_png++;
542 } else {
543 D(bug("[%s] Unknown chunk ID 0x%08x\n", __func__, cn->cn_ID));
544 }
545
546 } /* while(!ParseIFF(iff, IFFPARSE_SCAN)) */
547
548 } /* if (!StopChunks(iff, stopchunks, 4)) */
549
550 } /* if (!OpenIFF(iff, IFFF_READ)) */
551
552 FreeIFF(iff);
553
554 } /* if ((iff = AllocIFF())) */
555
556 /* Only use the Width and Height fields of a FACE section
557 * if it also contains image data.
558 */
559 if (have_face) {
560 if (have_argb1 || have_argb2 || have_imag1 || have_imag2) {
561 icon->ni_Face.Width = fc.Width + 1;
562 icon->ni_Face.Height = fc.Height + 1;
563 }
564 //icon->icon35.flags = fc.Flags;
565 icon->ni_Face.Aspect = fc.Aspect;
566 }
567
568 if (have_argb1)
569 {
570 icon->ni_Image[0].ARGB = (APTR)argb1data;
571 }
572
573 if (have_argb2)
574 {
575 icon->ni_Image[1].ARGB = (APTR)argb2data;
576 }
577
578 if (have_imag1)
579 {
580 icon->ni_Image[0].ImageData = img1data;
581 icon->ni_Image[0].Palette = img1pal;
582 icon->ni_Image[0].Pens = ic1.NumColors + 1;
583 icon->ni_Image[0].TransparentColor = ic1.TransparentColor;
584
585 if (icon->ni_Image[0].Pens < 1 || icon->ni_Image[0].Pens > 256)
586 return FALSE;
587
588 if (have_imag2)
589 {
590 icon->ni_Image[1].ImageData = img2data;
591 icon->ni_Image[1].TransparentColor = ic2.TransparentColor;
592
593 if (img2pal)
594 {
595 icon->ni_Image[1].Palette = img2pal;
596 icon->ni_Image[1].Pens = ic2.NumColors + 1;
597 if (icon->ni_Image[1].Pens < 1 || icon->ni_Image[0].Pens > 256)
598 return FALSE;
599
600 }
601 else
602 {
603 icon->ni_Image[1].Palette = img1pal;
604 icon->ni_Image[1].Pens = ic1.NumColors + 1;
605 }
606 }
607 }
608
609 return TRUE;
610 }
611
612 /****************************************************************************************/
613
614 /* Encode35() based on ModifyIcon source by Dirk Stöcker */
615
616 /****************************************************************************************/
617
618 static UBYTE *Encode35(struct DiskObject *icon, ULONG depth, UBYTE *dtype, LONG *dsize, ULONG size, CONST UBYTE *src, APTR IconBase)
619 {
620 int i, j, k;
621 ULONG bitbuf, numbits;
622 UBYTE *buf;
623 LONG ressize, numcopy, numequal;
624
625 buf = AllocMemIcon(icon, size * 2, MEMF_PUBLIC, IconBase);
626 if (!buf) return NULL;
627
628 numcopy = 0;
629 numequal = 1;
630 bitbuf = 0;
631 numbits = 0;
632 ressize = 0;
633 k = 0; /* the really output pointer */
634
635 for(i = 1; numequal || numcopy;)
636 {
637 if(i < size && numequal && (src[i-1] == src[i]))
638 {
639 ++numequal; ++i;
640 }
641 else if(i < size && numequal*depth <= 16)
642 {
643 numcopy += numequal; numequal = 1; ++i;
644 }
645 else
646 {
647 /* care for end case, where it maybe better to join the two */
648 if(i == size && numcopy + numequal <= 128 && (numequal-1)*depth <= 8)
649 {
650 numcopy += numequal; numequal = 0;
651 }
652
653 if(numcopy)
654 {
655 if((j = numcopy) > 128) j = 128;
656
657 bitbuf = (bitbuf<<8) | (j-1);
658 numcopy -= j;
659 }
660 else
661 {
662 if((j = numequal) > 128) j = 128;
663
664 bitbuf = (bitbuf<<8) | (256-(j-1));
665 numequal -= j;
666 k += j-1;
667 j = 1;
668 }
669
670 buf[ressize++] = (bitbuf >> numbits);
671
672 while(j--)
673 {
674 numbits += depth;
675 bitbuf = (bitbuf<<depth) | src[k++];
676
677 if(numbits >= 8)
678 {
679 numbits -= 8;
680 buf[ressize++] = (bitbuf >> numbits);
681 }
682 }
683
684 if(i < size && !numcopy && !numequal)
685 {
686 numequal = 1; ++i;
687 }
688 }
689 }
690
691 if(numbits)
692 buf[ressize++] = bitbuf << (8-numbits);
693
694 if(ressize > size) /* no RLE */
695 {
696 ressize = size;
697 *dtype = 0;
698 for(i = 0; i < size; ++i)
699 buf[i]= src[i];
700 }
701 else
702 *dtype = 1;
703
704 *dsize = ressize;
705
706 return buf;
707 }
708
709 /****************************************************************************************/
710
711 static BOOL WriteARGB35(struct IFFHandle *iff, struct NativeIcon *icon,
712 APTR ARGB, struct IconBase *IconBase)
713 {
714 struct ARGB35_Header {
715 ULONG ztype; /* Always 1 */
716 ULONG zsize; /* Compressed size, -1 */
717 UWORD resv; /* Always 0 */
718 } ahdr;
719 Bytef *zdest;
720 uLongf zsize, size;
721 int err;
722 BOOL ok = FALSE;
723
724 /* Assume uncompressible.. */
725 zsize = size = icon->ni_Face.Width * icon->ni_Face.Height * 4;
726
727 zdest = AllocVec(zsize, MEMF_ANY);
728 if (!zdest)
729 return FALSE;
730
731 err = compress(zdest, &zsize, ARGB, size);
732 if (err != Z_OK) {
733 D(bug("%s: Can't compress %d ARGB bytes: %s\n", __func__, size, zError(err)));
734 goto exit;
735 }
736
737 ahdr.ztype = AROS_LONG2BE(1);
738 ahdr.zsize = AROS_LONG2BE(zsize - 1);
739 ahdr.resv = AROS_WORD2BE(0);
740
741 if (!PushChunk(iff, ID_ICON, ID_ARGB, IFFSIZE_UNKNOWN))
742 {
743 ok = TRUE;
744
745 if ((WriteChunkBytes(iff, &ahdr, sizeof(ahdr)) != sizeof(ahdr)) ||
746 (WriteChunkBytes(iff, zdest, zsize) != zsize))
747 {
748 ok = FALSE;
749 }
750
751 PopChunk(iff);
752 }
753
754 exit:
755 FreeVec(zdest);
756 return ok;
757 }
758
759 /****************************************************************************************/
760
761 static BOOL WriteImage35(struct IFFHandle *iff, struct NativeIcon *icon,
762 struct NativeIconImage *img, struct IconBase *IconBase)
763 {
764 struct FileImageChunk ic;
765 UBYTE *imagedata, *pal = NULL;
766 LONG imagesize, palsize = 0;
767 UBYTE imagepacked, palpacked = 0;
768 UBYTE imageflags = 0;
769 BOOL ok = FALSE;
770
771 if (img->Palette)
772 {
773 pal = Encode35(&icon->ni_DiskObject, 8, &palpacked, &palsize, img->Pens * 3, (APTR)img->Palette, IconBase);
774 if (!pal) return FALSE;
775 imageflags |= IMAGE35F_HASPALETTE;
776 }
777
778 if (img->TransparentColor >= 0)
779 imageflags |= IMAGE35F_HASTRANSPARENTCOLOR;
780
781 imagedata = Encode35(&icon->ni_DiskObject, 8, &imagepacked, &imagesize,
782 icon->ni_Face.Width * icon->ni_Face.Height, img->ImageData, IconBase);
783
784 if (!imagedata)
785 {
786 return FALSE;
787 }
788
789 ic.TransparentColor = (imageflags & IMAGE35F_HASTRANSPARENTCOLOR) ? 255 : img->TransparentColor;
790 ic.NumColors = img->Pens - 1;
791 ic.Flags = imageflags;
792 ic.ImageFormat = imagepacked;
793 ic.PaletteFormat = palpacked;
794 ic.Depth = 8;
795 ic.NumImageBytes[0] = (imagesize - 1) / 256;
796 ic.NumImageBytes[1] = (imagesize - 1) & 255;
797 ic.NumPaletteBytes[0] = (palsize - 1) / 256;
798 ic.NumPaletteBytes[1] = (palsize - 1) & 255;
799
800 if (!PushChunk(iff, ID_ICON, ID_IMAG, IFFSIZE_UNKNOWN))
801 {
802 ok = TRUE;
803
804 if (WriteChunkBytes(iff, &ic, sizeof(ic)) != sizeof(ic))
805 {
806 ok = FALSE;
807 }
808
809 if (ok)
810 {
811 if (WriteChunkBytes(iff, imagedata, imagesize) != imagesize)
812 {
813 ok = FALSE;
814 }
815 }
816
817 if (ok && pal)
818 {
819 if (WriteChunkBytes(iff, pal, palsize) != palsize)
820 {
821 ok = FALSE;
822 }
823 }
824
825
826 PopChunk(iff);
827
828 } /* if (!PushChunk(iff, ID_ICON, ID_IMAG, IFFSIZE_UNKNOWN)) */
829
830 return ok;
831 }
832
833 /****************************************************************************************/
834
835 BOOL WriteIcon35(struct NativeIcon *icon, struct Hook *streamhook,
836 void *stream, struct IconBase *IconBase)
837 {
838 struct IFFHandle *iff;
839 struct Hook iffhook;
840 struct FileFaceChunk fc;
841 BOOL ok = FALSE;
842
843 D(bug("WriteIcon35\n"));
844
845 if (IFFParseBase == NULL)
846 {
847 D(bug("%s: IFFParseBase is NULL\n", __func__));
848 return FALSE;
849 }
850
851 if (!GetNativeIcon(&icon->ni_DiskObject, IconBase))
852 {
853 D(bug("%s: No native icon data\n", __func__));
854 return TRUE;
855 }
856
857 /* If the extra imagery wasn't modified, just write it out. */
858 if (icon->ni_Extra.Size != 0) {
859 LONG len;
860
861 len = FWrite((BPTR)stream, icon->ni_Extra.Data, 1, icon->ni_Extra.Size);
862 if (len < 0 || (ULONG)len != icon->ni_Extra.Size)
863 return FALSE;
864
865 return TRUE;
866 }
867
868 D(bug("%s: Write Icon %p\n", __func__, icon));
869 D(bug("%s: n_Image[0].ImageData = %p\n", __func__, icon->ni_Image[0].ImageData));
870 D(bug("%s: n_Image[1].ImageData = %p\n", __func__, icon->ni_Image[1].ImageData));
871 D(bug("%s: n_Image[0].ARGB = %p\n", __func__, icon->ni_Image[0].ARGB));
872 D(bug("%s: n_Image[1].ARGB = %p\n", __func__, icon->ni_Image[1].ARGB));
873
874 if (icon->ni_Image[0].ImageData == NULL && icon->ni_Image[0].ARGB == NULL)
875 {
876 D(bug("%s: No image data to write\n", __func__));
877 return TRUE;
878 }
879
880 iffhook.h_Entry = (HOOKFUNC)HookEntry;
881 iffhook.h_SubEntry = (HOOKFUNC)MyDOSStreamHandler;
882 iffhook.h_Data = (APTR)IconBase;
883
884 if ((iff = AllocIFF()))
885 {
886 D(bug("WriteIcon35. AllocIFF okay\n"));
887
888 iff->iff_Stream = (IPTR)stream;
889
890 InitIFF(iff, IFFF_RSEEK, &iffhook);
891
892 if (!OpenIFF(iff, IFFF_WRITE))
893 {
894 D(bug("WriteIcon35. OpenIFF okay\n"));
895
896 if (!PushChunk(iff, ID_ICON, ID_FORM, IFFSIZE_UNKNOWN))
897 {
898 D(bug("WriteIcon35. PushChunk(ID_ICON, ID_FORM) okay\n"));
899
900 if (!PushChunk(iff, ID_ICON, ID_FACE, sizeof(struct FileFaceChunk)))
901 {
902 WORD cmapentries;
903
904 D(bug("WriteIcon35. PushChunk(ID_ICON, ID_FACE) okay\n"));
905
906 fc.Width = icon->ni_Face.Width - 1;
907 fc.Height = icon->ni_Face.Height - 1;
908 fc.Flags = (icon->ni_Frameless) ? ICON35F_FRAMELESS : 0;
909 fc.Aspect = icon->ni_Face.Aspect;
910
911 cmapentries = icon->ni_Image[0].Pens;
912
913 if (icon->ni_Image[1].ImageData &&
914 icon->ni_Image[1].Palette)
915 {
916 if (icon->ni_Image[1].Pens > cmapentries)
917 {
918 cmapentries = icon->ni_Image[1].Pens;
919 }
920 }
921
922 cmapentries = cmapentries * 3 - 1;
923
924 fc.MaxPaletteBytes[0] = cmapentries / 256;
925 fc.MaxPaletteBytes[1] = cmapentries & 255;
926
927 if (WriteChunkBytes(iff, &fc, sizeof(fc)) == sizeof(fc))
928 {
929 D(bug("WriteIcon35. WriteChunkBytes of FACE chunk ok.\n"));
930
931 PopChunk(iff);
932
933 if (icon->ni_Image[0].ImageData)
934 {
935 if (WriteImage35(iff, icon, &icon->ni_Image[0], IconBase))
936 {
937 D(bug("WriteIcon35. WriteImage35() of 1st image ok.\n"));
938
939 if (icon->ni_Image[1].ImageData)
940 {
941 if (WriteImage35(iff, icon, &icon->ni_Image[1], IconBase))
942 {
943 D(bug("WriteIcon35. WriteImage35() of 2nd image ok.\n"));
944
945 ok = TRUE;
946 }
947
948 } /* if (icon->ni_Image[1].ImageData) */
949 else
950 {
951 ok = TRUE;
952 }
953
954 } /* if (WriteImage35(iff, &icon, &icon->ni_Image[0], IconBase)) */
955 } /* if (icon->ni_Image[0].ImageData) */
956
957 if (icon->ni_Image[0].ARGB)
958 {
959 if (WriteARGB35(iff, icon, &icon->ni_Image[0].ARGB, IconBase))
960 {
961 D(bug("WriteIcon35. WriteImage35() of 1st image ok.\n"));
962 if (icon->ni_Image[1].ARGB)
963 {
964 if (WriteARGB35(iff, icon, &icon->ni_Image[1].ARGB, IconBase))
965 {
966 D(bug("WriteIcon35. WriteImage35() of 2nd image ok.\n"));
967 ok = TRUE;
968 }
969 } else {
970 ok = TRUE;
971 }
972 } /* if (WriteARGB35(iff, icon, &icon->ni_Image[0].ARGB, IconBase) */
973 } /* if (icon->ni_Image[0].ARGB) */
974
975 } /* if (WriteChunkBytes(iff, &fc, sizeof(fc)) == sizeof(fc)) */
976 else
977 {
978 PopChunk(iff);
979 }
980
981 } /* if (!PushChunk(iff, ID_ICON, ID_FACE, sizeof(struct FileFaceChunk))) */
982
983 if (icon->ni_Extra.PNG[0].Size &&
984 !PushChunk(iff, ID_ICON, ID_png, IFFSIZE_UNKNOWN)) {
985 WriteChunkBytes(iff, icon->ni_Extra.Data + icon->ni_Extra.PNG[0].Offset, icon->ni_Extra.PNG[0].Size);
986
987 PopChunk(iff);
988 }
989
990 if (icon->ni_Extra.PNG[1].Size &&
991 !PushChunk(iff, ID_ICON, ID_png, IFFSIZE_UNKNOWN)) {
992 WriteChunkBytes(iff, icon->ni_Extra.Data + icon->ni_Extra.PNG[1].Offset, icon->ni_Extra.PNG[1].Size);
993
994 PopChunk(iff);
995 }
996
997 PopChunk(iff);
998
999 } /* if (!PushChunk(iff, ID_ICON, ID_FORM, IFFSIZE_UNKNOWN)) */
1000
1001 } /* if (!OpenIFF(iff, IFFF_READ)) */
1002
1003 } /* if ((iff = AllocIFF())) */
1004
1005 return ok;
1006 }
1007
1008 /****************************************************************************************/
1009
1010 VOID FreeIcon35(struct NativeIcon *icon, struct IconBase *IconBase)
1011 {
1012 }
1013
1014 /****************************************************************************************/
1015
Mirror of AROS' svn.