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