Cleanup: style, use braces for imbuf
[blender.git] / source / blender / imbuf / intern / targa.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup imbuf
22  */
23
24 #ifdef WIN32
25 #  include <io.h>
26 #endif
27
28 #include "BLI_utildefines.h"
29 #include "BLI_fileops.h"
30
31 #include "MEM_guardedalloc.h"
32
33 #include "imbuf.h"
34
35 #include "IMB_imbuf_types.h"
36 #include "IMB_imbuf.h"
37
38 #include "IMB_filetype.h"
39
40 #include "IMB_colormanagement.h"
41 #include "IMB_colormanagement_intern.h"
42
43 /* this one is only def-ed once, strangely... related to GS? */
44 #define GSS(x) (((uchar *)(x))[1] << 8 | ((uchar *)(x))[0])
45
46 /***/
47
48 typedef struct TARGA {
49   unsigned char numid;
50   unsigned char maptyp;
51   unsigned char imgtyp;
52   short maporig;
53   short mapsize;
54   unsigned char mapbits;
55   short xorig;
56   short yorig;
57   short xsize;
58   short ysize;
59   unsigned char pixsize;
60   unsigned char imgdes;
61 } TARGA;
62
63 /***/
64
65 static int tga_out1(unsigned int data, FILE *file)
66 {
67   uchar *p;
68
69   p = (uchar *)&data;
70   if (putc(p[0], file) == EOF) {
71     return EOF;
72   }
73   return ~EOF;
74 }
75
76 static int tga_out2(unsigned int data, FILE *file)
77 {
78   uchar *p;
79
80   p = (uchar *)&data;
81   if (putc(p[0], file) == EOF) {
82     return EOF;
83   }
84   if (putc(p[1], file) == EOF) {
85     return EOF;
86   }
87   return ~EOF;
88 }
89
90 static int tga_out3(unsigned int data, FILE *file)
91 {
92   uchar *p;
93
94   p = (uchar *)&data;
95   if (putc(p[2], file) == EOF) {
96     return EOF;
97   }
98   if (putc(p[1], file) == EOF) {
99     return EOF;
100   }
101   if (putc(p[0], file) == EOF) {
102     return EOF;
103   }
104   return ~EOF;
105 }
106
107 static int tga_out4(unsigned int data, FILE *file)
108 {
109   uchar *p;
110
111   p = (uchar *)&data;
112   /* order = bgra */
113   if (putc(p[2], file) == EOF) {
114     return EOF;
115   }
116   if (putc(p[1], file) == EOF) {
117     return EOF;
118   }
119   if (putc(p[0], file) == EOF) {
120     return EOF;
121   }
122   if (putc(p[3], file) == EOF) {
123     return EOF;
124   }
125   return ~EOF;
126 }
127
128 static bool makebody_tga(ImBuf *ibuf, FILE *file, int (*out)(unsigned int, FILE *))
129 {
130   register int last, this;
131   register int copy, bytes;
132   register unsigned int *rect, *rectstart, *temp;
133   int y;
134
135   for (y = 0; y < ibuf->y; y++) {
136     bytes = ibuf->x - 1;
137     rectstart = rect = ibuf->rect + (y * ibuf->x);
138     last = *rect++;
139     this = *rect++;
140     copy = last ^ this;
141     while (bytes > 0) {
142       if (copy) {
143         do {
144           last = this;
145           this = *rect++;
146           if (last == this) {
147             if (this == rect[-3]) { /* three the same? */
148               bytes--;              /* set bytes */
149               break;
150             }
151           }
152         } while (--bytes != 0);
153
154         copy = rect - rectstart;
155         copy--;
156         if (bytes) {
157           copy -= 2;
158         }
159
160         temp = rect;
161         rect = rectstart;
162
163         while (copy) {
164           last = copy;
165           if (copy >= 128) {
166             last = 128;
167           }
168           copy -= last;
169           if (fputc(last - 1, file) == EOF) {
170             return 0;
171           }
172           do {
173             if (out(*rect++, file) == EOF) {
174               return 0;
175             }
176           } while (--last != 0);
177         }
178         rectstart = rect;
179         rect = temp;
180         last = this;
181
182         copy = 0;
183       }
184       else {
185         while (*rect++ == this) { /* seek for first different byte */
186           if (--bytes == 0) {
187             break; /* oor end of line */
188           }
189         }
190         rect--;
191         copy = rect - rectstart;
192         rectstart = rect;
193         bytes--;
194         this = *rect++;
195
196         while (copy) {
197           if (copy > 128) {
198             if (fputc(255, file) == EOF) {
199               return 0;
200             }
201             copy -= 128;
202           }
203           else {
204             if (copy == 1) {
205               if (fputc(0, file) == EOF) {
206                 return 0;
207               }
208             }
209             else if (fputc(127 + copy, file) == EOF) {
210               return 0;
211             }
212             copy = 0;
213           }
214           if (out(last, file) == EOF) {
215             return 0;
216           }
217         }
218         copy = 1;
219       }
220     }
221   }
222   return 1;
223 }
224
225 static bool dumptarga(struct ImBuf *ibuf, FILE *file)
226 {
227   int size;
228   uchar *rect;
229
230   if (ibuf == NULL) {
231     return 0;
232   }
233   if (ibuf->rect == NULL) {
234     return 0;
235   }
236
237   size = ibuf->x * ibuf->y;
238   rect = (uchar *)ibuf->rect;
239
240   if (ibuf->planes <= 8) {
241     while (size > 0) {
242       if (putc(*rect, file) == EOF) {
243         return 0;
244       }
245       size--;
246       rect += 4;
247     }
248   }
249   else if (ibuf->planes <= 16) {
250     while (size > 0) {
251       putc(rect[0], file);
252       if (putc(rect[1], file) == EOF) {
253         return 0;
254       }
255       size--;
256       rect += 4;
257     }
258   }
259   else if (ibuf->planes <= 24) {
260     while (size > 0) {
261       putc(rect[2], file);
262       putc(rect[1], file);
263       if (putc(rect[0], file) == EOF) {
264         return 0;
265       }
266       size--;
267       rect += 4;
268     }
269   }
270   else if (ibuf->planes <= 32) {
271     while (size > 0) {
272       putc(rect[2], file);
273       putc(rect[1], file);
274       putc(rect[0], file);
275       if (putc(rect[3], file) == EOF) {
276         return 0;
277       }
278       size--;
279       rect += 4;
280     }
281   }
282   else {
283     return 0;
284   }
285
286   return 1;
287 }
288
289 int imb_savetarga(struct ImBuf *ibuf, const char *name, int flags)
290 {
291   char buf[20] = {0};
292   FILE *fildes;
293   bool ok = false;
294
295   (void)flags; /* unused */
296
297   buf[16] = (ibuf->planes + 0x7) & ~0x7;
298   if (ibuf->planes > 8) {
299     buf[2] = 10;
300   }
301   else {
302     buf[2] = 11;
303   }
304
305   if (ibuf->foptions.flag & RAWTGA) {
306     buf[2] &= ~8;
307   }
308
309   buf[8] = 0;
310   buf[9] = 0;
311   buf[10] = 0;
312   buf[11] = 0;
313
314   buf[12] = ibuf->x & 0xff;
315   buf[13] = ibuf->x >> 8;
316   buf[14] = ibuf->y & 0xff;
317   buf[15] = ibuf->y >> 8;
318
319   /* Don't forget to indicate that your 32 bit
320    * targa uses 8 bits for the alpha channel! */
321   if (ibuf->planes == 32) {
322     buf[17] |= 0x08;
323   }
324   fildes = BLI_fopen(name, "wb");
325   if (!fildes) {
326     return 0;
327   }
328
329   if (fwrite(buf, 1, 18, fildes) != 18) {
330     fclose(fildes);
331     return 0;
332   }
333
334   if (ibuf->foptions.flag & RAWTGA) {
335     ok = dumptarga(ibuf, fildes);
336   }
337   else {
338     switch ((ibuf->planes + 7) >> 3) {
339       case 1:
340         ok = makebody_tga(ibuf, fildes, tga_out1);
341         break;
342       case 2:
343         ok = makebody_tga(ibuf, fildes, tga_out2);
344         break;
345       case 3:
346         ok = makebody_tga(ibuf, fildes, tga_out3);
347         break;
348       case 4:
349         ok = makebody_tga(ibuf, fildes, tga_out4);
350         break;
351     }
352   }
353
354   fclose(fildes);
355   return ok;
356 }
357
358 static int checktarga(TARGA *tga, const unsigned char *mem)
359 {
360   tga->numid = mem[0];
361   tga->maptyp = mem[1];
362   tga->imgtyp = mem[2];
363
364   tga->maporig = GSS(mem + 3);
365   tga->mapsize = GSS(mem + 5);
366   tga->mapbits = mem[7];
367   tga->xorig = GSS(mem + 8);
368   tga->yorig = GSS(mem + 10);
369   tga->xsize = GSS(mem + 12);
370   tga->ysize = GSS(mem + 14);
371   tga->pixsize = mem[16];
372   tga->imgdes = mem[17];
373
374   if (tga->maptyp > 1) {
375     return 0;
376   }
377   switch (tga->imgtyp) {
378     case 1:  /* raw cmap */
379     case 2:  /* raw rgb */
380     case 3:  /* raw b&w */
381     case 9:  /* cmap */
382     case 10: /* rgb */
383     case 11: /* b&w */
384       break;
385     default:
386       return 0;
387   }
388   if (tga->mapsize && tga->mapbits > 32) {
389     return 0;
390   }
391   if (tga->xsize <= 0) {
392     return 0;
393   }
394   if (tga->ysize <= 0) {
395     return 0;
396   }
397   if (tga->pixsize > 32) {
398     return 0;
399   }
400   if (tga->pixsize == 0) {
401     return 0;
402   }
403   return 1;
404 }
405
406 int imb_is_a_targa(const unsigned char *buf)
407 {
408   TARGA tga;
409
410   return checktarga(&tga, buf);
411 }
412
413 static void complete_partial_load(struct ImBuf *ibuf, unsigned int *rect)
414 {
415   int size = (ibuf->x * ibuf->y) - (rect - ibuf->rect);
416   if (size) {
417     printf("decodetarga: incomplete file, %.1f%% missing\n",
418            100 * ((float)size / (ibuf->x * ibuf->y)));
419
420     /* not essential but makes displaying partially rendered TGA's less ugly  */
421     memset(rect, 0, size);
422   }
423   else {
424     /* shouldn't happen */
425     printf("decodetarga: incomplete file, all pixels written\n");
426   }
427 }
428
429 static void decodetarga(struct ImBuf *ibuf, const unsigned char *mem, size_t mem_size, int psize)
430 {
431   const unsigned char *mem_end = mem + mem_size;
432   int count, col, size;
433   unsigned int *rect;
434   uchar *cp = (uchar *)&col;
435
436   if (ibuf == NULL) {
437     return;
438   }
439   if (ibuf->rect == NULL) {
440     return;
441   }
442
443   size = ibuf->x * ibuf->y;
444   rect = ibuf->rect;
445
446   /* set alpha */
447   cp[0] = 0xff;
448   cp[1] = cp[2] = 0;
449
450   while (size > 0) {
451     count = *mem++;
452
453     if (mem > mem_end) {
454       goto partial_load;
455     }
456
457     if (count >= 128) {
458       /*if (count == 128) printf("TARGA: 128 in file !\n");*/
459       count -= 127;
460
461       if (psize & 2) {
462         if (psize & 1) {
463           /* order = bgra */
464           cp[0] = mem[3];
465           cp[1] = mem[0];
466           cp[2] = mem[1];
467           cp[3] = mem[2];
468           /*col = (mem[3] << 24) + (mem[0] << 16) + (mem[1] << 8) + mem[2];*/
469           mem += 4;
470         }
471         else {
472           cp[1] = mem[0];
473           cp[2] = mem[1];
474           cp[3] = mem[2];
475           /*col = 0xff000000 + (mem[0] << 16) + (mem[1] << 8) + mem[2];*/
476           mem += 3;
477         }
478       }
479       else {
480         if (psize & 1) {
481           cp[0] = mem[0];
482           cp[1] = mem[1];
483           mem += 2;
484         }
485         else {
486           col = *mem++;
487         }
488       }
489
490       size -= count;
491       if (size >= 0) {
492         while (count > 0) {
493           *rect++ = col;
494           count--;
495         }
496       }
497     }
498     else {
499       count++;
500       size -= count;
501       if (size >= 0) {
502         while (count > 0) {
503           if (psize & 2) {
504             if (psize & 1) {
505               /* order = bgra */
506               cp[0] = mem[3];
507               cp[1] = mem[0];
508               cp[2] = mem[1];
509               cp[3] = mem[2];
510               /*col = (mem[3] << 24) + (mem[0] << 16) + (mem[1] << 8) + mem[2];*/
511               mem += 4;
512             }
513             else {
514               cp[1] = mem[0];
515               cp[2] = mem[1];
516               cp[3] = mem[2];
517               /*col = 0xff000000 + (mem[0] << 16) + (mem[1] << 8) + mem[2];*/
518               mem += 3;
519             }
520           }
521           else {
522             if (psize & 1) {
523               cp[0] = mem[0];
524               cp[1] = mem[1];
525               mem += 2;
526             }
527             else {
528               col = *mem++;
529             }
530           }
531           *rect++ = col;
532           count--;
533
534           if (mem > mem_end) {
535             goto partial_load;
536           }
537         }
538
539         if (mem > mem_end) {
540           goto partial_load;
541         }
542       }
543     }
544   }
545   if (size) {
546     printf("decodetarga: count would overwrite %d pixels\n", -size);
547   }
548   return;
549
550 partial_load:
551   complete_partial_load(ibuf, rect);
552 }
553
554 static void ldtarga(struct ImBuf *ibuf, const unsigned char *mem, size_t mem_size, int psize)
555 {
556   const unsigned char *mem_end = mem + mem_size;
557   int col, size;
558   unsigned int *rect;
559   uchar *cp = (uchar *)&col;
560
561   if (ibuf == NULL) {
562     return;
563   }
564   if (ibuf->rect == NULL) {
565     return;
566   }
567
568   size = ibuf->x * ibuf->y;
569   rect = ibuf->rect;
570
571   /* set alpha */
572   cp[0] = 0xff;
573   cp[1] = cp[2] = 0;
574
575   while (size > 0) {
576     if (mem > mem_end) {
577       goto partial_load;
578     }
579
580     if (psize & 2) {
581       if (psize & 1) {
582         /* order = bgra */
583         cp[0] = mem[3];
584         cp[1] = mem[0];
585         cp[2] = mem[1];
586         cp[3] = mem[2];
587         /*col = (mem[3] << 24) + (mem[0] << 16) + (mem[1] << 8) + mem[2];*/
588         mem += 4;
589       }
590       else {
591         /* set alpha for 24 bits colors */
592         cp[1] = mem[0];
593         cp[2] = mem[1];
594         cp[3] = mem[2];
595         /*col = 0xff000000 + (mem[0] << 16) + (mem[1] << 8) + mem[2];*/
596         mem += 3;
597       }
598     }
599     else {
600       if (psize & 1) {
601         cp[0] = mem[0];
602         cp[1] = mem[1];
603         mem += 2;
604       }
605       else {
606         col = *mem++;
607       }
608     }
609     *rect++ = col;
610     size--;
611   }
612   return;
613
614 partial_load:
615   complete_partial_load(ibuf, rect);
616 }
617
618 ImBuf *imb_loadtarga(const unsigned char *mem,
619                      size_t mem_size,
620                      int flags,
621                      char colorspace[IM_MAX_SPACE])
622 {
623   TARGA tga;
624   struct ImBuf *ibuf;
625   int count, size;
626   unsigned int *rect, *cmap = NULL /*, mincol = 0*/, cmap_max = 0;
627   int32_t cp_data;
628   uchar *cp = (uchar *)&cp_data;
629
630   if (checktarga(&tga, mem) == 0) {
631     return NULL;
632   }
633
634   colorspace_set_default_role(colorspace, IM_MAX_SPACE, COLOR_ROLE_DEFAULT_BYTE);
635
636   if (flags & IB_test) {
637     ibuf = IMB_allocImBuf(tga.xsize, tga.ysize, tga.pixsize, 0);
638   }
639   else {
640     ibuf = IMB_allocImBuf(tga.xsize, tga.ysize, (tga.pixsize + 0x7) & ~0x7, IB_rect);
641   }
642
643   if (ibuf == NULL) {
644     return NULL;
645   }
646   ibuf->ftype = IMB_FTYPE_TGA;
647   if (tga.imgtyp < 4) {
648     ibuf->foptions.flag |= RAWTGA;
649   }
650   mem = mem + 18 + tga.numid;
651
652   cp[0] = 0xff;
653   cp[1] = cp[2] = 0;
654
655   if (tga.mapsize) {
656     /* load color map */
657     /*mincol = tga.maporig;*/ /*UNUSED*/
658     cmap_max = tga.mapsize;
659     cmap = MEM_callocN(sizeof(unsigned int) * cmap_max, "targa cmap");
660
661     for (count = 0; count < cmap_max; count++) {
662       switch (tga.mapbits >> 3) {
663         case 4:
664           cp[0] = mem[3];
665           cp[1] = mem[0];
666           cp[2] = mem[1];
667           cp[3] = mem[2];
668           mem += 4;
669           break;
670         case 3:
671           cp[1] = mem[0];
672           cp[2] = mem[1];
673           cp[3] = mem[2];
674           mem += 3;
675           break;
676         case 2:
677           cp[1] = mem[1];
678           cp[0] = mem[0];
679           mem += 2;
680           break;
681         case 1:
682           cp_data = *mem++;
683           break;
684       }
685       cmap[count] = cp_data;
686     }
687
688     size = 0;
689     for (int cmap_index = cmap_max - 1; cmap_index > 0; cmap_index >>= 1) {
690       size++;
691     }
692     ibuf->planes = size;
693
694     if (tga.mapbits != 32) { /* set alpha bits  */
695       cmap[0] &= BIG_LONG(0x00ffffffl);
696     }
697   }
698
699   if (flags & IB_test) {
700     if (cmap) {
701       MEM_freeN(cmap);
702     }
703     return ibuf;
704   }
705
706   if (tga.imgtyp != 1 && tga.imgtyp != 9) { /* happens sometimes (beuh) */
707     if (cmap) {
708       MEM_freeN(cmap);
709       cmap = NULL;
710     }
711   }
712
713   switch (tga.imgtyp) {
714     case 1:
715     case 2:
716     case 3:
717       if (tga.pixsize <= 8) {
718         ldtarga(ibuf, mem, mem_size, 0);
719       }
720       else if (tga.pixsize <= 16) {
721         ldtarga(ibuf, mem, mem_size, 1);
722       }
723       else if (tga.pixsize <= 24) {
724         ldtarga(ibuf, mem, mem_size, 2);
725       }
726       else if (tga.pixsize <= 32) {
727         ldtarga(ibuf, mem, mem_size, 3);
728       }
729       break;
730     case 9:
731     case 10:
732     case 11:
733       if (tga.pixsize <= 8) {
734         decodetarga(ibuf, mem, mem_size, 0);
735       }
736       else if (tga.pixsize <= 16) {
737         decodetarga(ibuf, mem, mem_size, 1);
738       }
739       else if (tga.pixsize <= 24) {
740         decodetarga(ibuf, mem, mem_size, 2);
741       }
742       else if (tga.pixsize <= 32) {
743         decodetarga(ibuf, mem, mem_size, 3);
744       }
745       break;
746   }
747
748   if (cmap) {
749     /* apply color map */
750     rect = ibuf->rect;
751     for (size = ibuf->x * ibuf->y; size > 0; --size, ++rect) {
752       int cmap_index = *rect;
753       if (cmap_index >= 0 && cmap_index < cmap_max) {
754         *rect = cmap[cmap_index];
755       }
756     }
757
758     MEM_freeN(cmap);
759   }
760
761   if (tga.pixsize == 16) {
762     unsigned int col;
763     rect = ibuf->rect;
764     for (size = ibuf->x * ibuf->y; size > 0; --size, ++rect) {
765       col = *rect;
766       cp = (uchar *)rect;
767       mem = (uchar *)&col;
768
769       cp[3] = ((mem[1] << 1) & 0xf8);
770       cp[2] = ((mem[0] & 0xe0) >> 2) + ((mem[1] & 0x03) << 6);
771       cp[1] = ((mem[0] << 3) & 0xf8);
772       cp[1] += cp[1] >> 5;
773       cp[2] += cp[2] >> 5;
774       cp[3] += cp[3] >> 5;
775       cp[0] = 0xff;
776     }
777     ibuf->planes = 24;
778   }
779
780   if (tga.imgtyp == 3 || tga.imgtyp == 11) {
781     uchar *crect;
782     unsigned int *lrect, col;
783
784     crect = (uchar *)ibuf->rect;
785     lrect = (unsigned int *)ibuf->rect;
786
787     for (size = ibuf->x * ibuf->y; size > 0; size--) {
788       col = *lrect++;
789
790       crect[0] = 255;
791       crect[1] = crect[2] = crect[3] = col;
792       crect += 4;
793     }
794   }
795
796   if (tga.imgdes & 0x20) {
797     IMB_flipy(ibuf);
798   }
799
800   if (ibuf->rect) {
801     IMB_convert_rgba_to_abgr(ibuf);
802   }
803
804   return ibuf;
805 }