home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / OpenGL 1.0 SDK / Source / Libraries / tk / tkimage.c < prev    next >
Encoding:
C/C++ Source or Header  |  1999-05-18  |  4.5 KB  |  202 lines  |  [TEXT/CWIE]
  1. #include <stdio.h>
  2. #include <stdlib.h> 
  3. #include <string.h>
  4. #include "tk.h"
  5. #include "tkprivate.h"
  6.  
  7. typedef struct _rawImageRec {
  8.     unsigned short imagic;
  9.     unsigned short type;
  10.     unsigned short dim;
  11.     unsigned short sizeX, sizeY, sizeZ;
  12.     unsigned long min, max;
  13.     unsigned long wasteBytes;
  14.     char name[80];
  15.     unsigned long colorMap;
  16.     FILE *file;
  17.     unsigned char *tmp, *tmpR, *tmpG, *tmpB;
  18.     unsigned long rleEnd;
  19.     GLuint *rowStart;
  20.     GLint *rowSize;
  21. } rawImageRec;
  22.  
  23. static void ConvertShort(unsigned short *array, long length)
  24. {
  25.     unsigned long b1, b2;
  26.     unsigned char *ptr;
  27.  
  28.     ptr = (unsigned char *)array;
  29.     while (length--) {
  30.     b1 = *ptr++;
  31.     b2 = *ptr++;
  32.     *array++ = (b1 << 8) | (b2);
  33.     }
  34. }
  35.  
  36. static void ConvertLong(GLuint *array, long length)
  37. {
  38.     unsigned long b1, b2, b3, b4;
  39.     unsigned char *ptr;
  40.  
  41.     ptr = (unsigned char *)array;
  42.     while (length--) {
  43.     b1 = *ptr++;
  44.     b2 = *ptr++;
  45.     b3 = *ptr++;
  46.     b4 = *ptr++;
  47.     *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
  48.     }
  49. }
  50.  
  51. static rawImageRec *RawImageOpen(char *fileName)
  52. {
  53.     union {
  54.     int testWord;
  55.     char testByte[4];
  56.     } endianTest;
  57.     rawImageRec *raw;
  58.     GLenum swapFlag;
  59.     int x;
  60.  
  61.     endianTest.testWord = 1;
  62.     if (endianTest.testByte[0] == 1) {
  63.     swapFlag = GL_TRUE;
  64.     } else {
  65.     swapFlag = GL_FALSE;
  66.     }
  67.  
  68.     raw = (rawImageRec *)malloc(sizeof(rawImageRec));
  69.     if (raw == NULL) {
  70.     fprintf(stderr, "5) Out of memory!\n");
  71.     exit(0);
  72.     }
  73.     if ((raw->file = fopen(fileName, "rb")) == NULL) {
  74.     perror(fileName);
  75.     exit(0);
  76.     }
  77.  
  78.     fread(raw, 1, 12, raw->file);
  79.  
  80.     if (swapFlag) {
  81.     ConvertShort(&raw->imagic, 6);
  82.     }
  83.  
  84.     raw->tmp = (unsigned char *)malloc(raw->sizeX*256);
  85.     raw->tmpR = (unsigned char *)malloc(raw->sizeX*256);
  86.     raw->tmpG = (unsigned char *)malloc(raw->sizeX*256);
  87.     raw->tmpB = (unsigned char *)malloc(raw->sizeX*256);
  88.     if (raw->tmp == NULL || raw->tmpR == NULL || raw->tmpG == NULL ||
  89.     raw->tmpB == NULL) {
  90.     fprintf(stderr, "1) Out of memory!\n");
  91.     fprintf(stderr, "memory size : %d\n", raw->sizeX*256);
  92.     exit(0);
  93.     }
  94.  
  95.     if ((raw->type & 0xFF00) == 0x0100) {
  96.     x = raw->sizeY * raw->sizeZ * sizeof(GLuint);
  97.     raw->rowStart = (GLuint *)malloc(x);
  98.     raw->rowSize = (GLint *)malloc(x);
  99.     if (raw->rowStart == NULL || raw->rowSize == NULL) {
  100.         fprintf(stderr, "2) Out of memory!\n");
  101.         exit(0);
  102.     }
  103.     raw->rleEnd = 512 + (2 * x);
  104.     fseek(raw->file, 512, SEEK_SET);
  105.     fread(raw->rowStart, 1, x, raw->file);
  106.     fread(raw->rowSize, 1, x, raw->file);
  107.     if (swapFlag) {
  108.         ConvertLong(raw->rowStart, x/sizeof(GLuint));
  109.         ConvertLong((GLuint *)raw->rowSize, x/sizeof(GLint));
  110.     }
  111.     }
  112.     return raw;
  113. }
  114.  
  115. static void RawImageClose(rawImageRec *raw)
  116. {
  117.  
  118.     fclose(raw->file);
  119.     free(raw->tmp);
  120.     free(raw->tmpR);
  121.     free(raw->tmpG);
  122.     free(raw->tmpB);
  123.     free(raw);
  124. }
  125.  
  126. static void RawImageGetRow(rawImageRec *raw, unsigned char *buf, int y, int z)
  127. {
  128.     unsigned char *iPtr, *oPtr, pixel;
  129.     int count;
  130.  
  131.     if ((raw->type & 0xFF00) == 0x0100) {
  132.     fseek(raw->file, raw->rowStart[y+z*raw->sizeY], SEEK_SET);
  133.     fread(raw->tmp, 1, (unsigned int)raw->rowSize[y+z*raw->sizeY],
  134.           raw->file);
  135.  
  136.     iPtr = raw->tmp;
  137.     oPtr = buf;
  138.     while (1) {
  139.         pixel = *iPtr++;
  140.         count = (int)(pixel & 0x7F);
  141.         if (!count) {
  142.         return;
  143.         }
  144.         if (pixel & 0x80) {
  145.         while (count--) {
  146.             *oPtr++ = *iPtr++;
  147.         }
  148.         } else {
  149.         pixel = *iPtr++;
  150.         while (count--) {
  151.             *oPtr++ = pixel;
  152.         }
  153.         }
  154.     }
  155.     } else {
  156.     fseek(raw->file, 512+(y*raw->sizeX)+(z*raw->sizeX*raw->sizeY),
  157.           SEEK_SET);
  158.     fread(buf, 1, raw->sizeX, raw->file);
  159.     }
  160. }
  161.  
  162. static void RawImageGetData(rawImageRec *raw, TK_RGBImageRec *final)
  163. {
  164.     unsigned char *ptr;
  165.     int i, j;
  166.  
  167.     final->data = (unsigned char *)malloc((raw->sizeX+1)*(raw->sizeY+1)*4);
  168.     if (final->data == NULL) {
  169.     fprintf(stderr, "3) Out of memory!\n");
  170.     exit(0);
  171.     }
  172.  
  173.     ptr = final->data;
  174.     for (i = 0; i < raw->sizeY; i++) {
  175.     RawImageGetRow(raw, raw->tmpR, i, 0);
  176.     RawImageGetRow(raw, raw->tmpG, i, 1);
  177.     RawImageGetRow(raw, raw->tmpB, i, 2);
  178.     for (j = 0; j < raw->sizeX; j++) {
  179.         *ptr++ = *(raw->tmpR + j);
  180.         *ptr++ = *(raw->tmpG + j);
  181.         *ptr++ = *(raw->tmpB + j);
  182.     }
  183.     }
  184. }
  185.  
  186. TK_RGBImageRec *tkRGBImageLoad(char *fileName)
  187. {
  188.     rawImageRec *raw;
  189.     TK_RGBImageRec *final;
  190.  
  191.     raw = RawImageOpen(fileName);
  192.     final = (TK_RGBImageRec *)malloc(sizeof(TK_RGBImageRec));
  193.     if (final == NULL) {
  194.     fprintf(stderr, "4) Out of memory!\n");
  195.     exit(0);
  196.     }
  197.     final->sizeX = raw->sizeX;
  198.     final->sizeY = raw->sizeY;
  199.     RawImageGetData(raw, final);
  200.     RawImageClose(raw);
  201.     return final;
  202. }