progs/samples/rgbtoppm.c

   1
   2 /* texture.c - by David Blythe, SGI */
   3
   4 /* texload is a simplistic routine for reading an SGI .rgb image file. */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 #include <GL/glut.h>
  11
  12 typedef struct _ImageRec {
  13     unsigned short imagic;
  14     unsigned short type;
  15     unsigned short dim;
  16     unsigned short xsize, ysize, zsize;
  17     unsigned int min, max;
  18     unsigned int wasteBytes;
  19     char name[80];
  20     unsigned long colorMap;
  21     FILE *file;
  22     unsigned char *tmp;
  23     unsigned long rleEnd;
  24     unsigned int *rowStart;
  25     int *rowSize;
  26 } ImageRec;
  27
  28 void
  29 rgbtorgb(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *l,int n) {
  30     while(n--) {
  31         l[0] = r[0];
  32         l[1] = g[0];
  33         l[2] = b[0];
  34         l += 3; r++; g++; b++;
  35     }
  36 }
  37
  38 static void
  39 ConvertShort(unsigned short *array, unsigned int length) {
  40     unsigned short b1, b2;
  41     unsigned char *ptr;
  42
  43     ptr = (unsigned char *)array;
  44     while (length--) {
  45         b1 = *ptr++;
  46         b2 = *ptr++;
  47         *array++ = (b1 << 8) | (b2);
  48     }
  49 }
  50
  51 static void
  52 ConvertUint(unsigned *array, unsigned int length) {
  53     unsigned int b1, b2, b3, b4;
  54     unsigned char *ptr;
  55
  56     ptr = (unsigned char *)array;
  57     while (length--) {
  58         b1 = *ptr++;
  59         b2 = *ptr++;
  60         b3 = *ptr++;
  61         b4 = *ptr++;
  62         *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
  63     }
  64 }
  65
  66 static ImageRec *ImageOpen(char *fileName)
  67 {
  68     union {
  69         int testWord;
  70         char testByte[4];
  71     } endianTest;
  72     ImageRec *image;
  73     int swapFlag;
  74     int x;
  75
  76     endianTest.testWord = 1;
  77     if (endianTest.testByte[0] == 1) {
  78         swapFlag = 1;
  79     } else {
  80         swapFlag = 0;
  81     }
  82
  83     image = (ImageRec *)malloc(sizeof(ImageRec));
  84     if (image == NULL) {
  85         fprintf(stderr, "Out of memory!\n");
  86         exit(1);
  87     }
  88     if ((image->file = fopen(fileName, "rb")) == NULL) {
  89         return NULL;
  90     }
  91
  92     fread(image, 1, 12, image->file);
  93
  94     if (swapFlag) {
  95         ConvertShort(&image->imagic, 6);
  96     }
  97
  98     image->tmp = (unsigned char *)malloc(image->xsize*256);
  99     if (image->tmp == NULL) {
 100         fprintf(stderr, "\nOut of memory!\n");
 101         exit(1);
 102     }
 103
 104     if ((image->type & 0xFF00) == 0x0100) {
 105         x = image->ysize * image->zsize * (int) sizeof(unsigned);
 106         image->rowStart = (unsigned *)malloc(x);
 107         image->rowSize = (int *)malloc(x);
 108         if (image->rowStart == NULL || image->rowSize == NULL) {
 109             fprintf(stderr, "\nOut of memory!\n");
 110             exit(1);
 111         }
 112         image->rleEnd = 512 + (2 * x);
 113         fseek(image->file, 512, SEEK_SET);
 114         fread(image->rowStart, 1, x, image->file);
 115         fread(image->rowSize, 1, x, image->file);
 116         if (swapFlag) {
 117             ConvertUint(image->rowStart, x/(int) sizeof(unsigned));
 118             ConvertUint((unsigned *)image->rowSize, x/(int) sizeof(int));
 119         }
 120     }
 121     return image;
 122 }
 123
 124 static void
 125 ImageClose(ImageRec *image) {
 126     fclose(image->file);
 127     free(image->tmp);
 128     free(image);
 129 }
 130
 131 static void
 132 ImageGetRow(ImageRec *image, unsigned char *buf, int y, int z) {
 133     unsigned char *iPtr, *oPtr, pixel;
 134     int count;
 135
 136     if ((image->type & 0xFF00) == 0x0100) {
 137         fseek(image->file, (long) image->rowStart[y+z*image->ysize], SEEK_SET);
 138         fread(image->tmp, 1, (unsigned int)image->rowSize[y+z*image->ysize],
 139               image->file);
 140
 141         iPtr = image->tmp;
 142         oPtr = buf;
 143         for (;;) {
 144             pixel = *iPtr++;
 145             count = (int)(pixel & 0x7F);
 146             if (!count) {
 147                 return;
 148             }
 149             if (pixel & 0x80) {
 150                 while (count--) {
 151                     *oPtr++ = *iPtr++;
 152                 }
 153             } else {
 154                 pixel = *iPtr++;
 155                 while (count--) {
 156                     *oPtr++ = pixel;
 157                 }
 158             }
 159         }
 160     } else {
 161         fseek(image->file, 512+(y*image->xsize)+(z*image->xsize*image->ysize),
 162               SEEK_SET);
 163         fread(buf, 1, image->xsize, image->file);
 164     }
 165 }
 166
 167 GLubyte *
 168 read_alpha_texture(char *name, int *width, int *height)
 169 {
 170     unsigned char *base, *lptr;
 171     ImageRec *image;
 172     int y;
 173
 174     image = ImageOpen(name);
 175     if(!image) {
 176         return NULL;
 177     }
 178
 179     (*width)=image->xsize;
 180     (*height)=image->ysize;
 181     if (image->zsize != 1) {
 182       ImageClose(image);
 183       return NULL;
 184     }
 185
 186     base = (unsigned char *)malloc(image->xsize*image->ysize*sizeof(unsigned char));
 187     lptr = base;
 188     for(y=0; y<image->ysize; y++) {
 189         ImageGetRow(image,lptr,y,0);
 190         lptr += image->xsize;
 191     }
 192     ImageClose(image);
 193
 194     return (unsigned char *) base;
 195 }
 196
 197 GLubyte *
 198 read_rgb_texture(char *name, int *width, int *height)
 199 {
 200     unsigned char *base, *ptr;
 201     unsigned char *rbuf, *gbuf, *bbuf, *abuf;
 202     ImageRec *image;
 203     int y;
 204
 205     image = ImageOpen(name);
 206
 207     if(!image)
 208         return NULL;
 209     (*width)=image->xsize;
 210     (*height)=image->ysize;
 211     if (image->zsize != 3 && image->zsize != 4) {
 212       ImageClose(image);
 213       return NULL;
 214     }
 215
 216     base = (unsigned char*)malloc(image->xsize*image->ysize*sizeof(unsigned int)*3);
 217     rbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
 218     gbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
 219     bbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
 220     abuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
 221     if(!base || !rbuf || !gbuf || !bbuf || !abuf) {
 222       if (base) free(base);
 223       if (rbuf) free(rbuf);
 224       if (gbuf) free(gbuf);
 225       if (bbuf) free(bbuf);
 226       if (abuf) free(abuf);
 227       return NULL;
 228     }
 229     ptr = base;
 230     for(y=0; y<image->ysize; y++) {
 231         if(image->zsize == 4) {
 232             ImageGetRow(image,rbuf,y,0);
 233             ImageGetRow(image,gbuf,y,1);
 234             ImageGetRow(image,bbuf,y,2);
 235             ImageGetRow(image,abuf,y,3);  /* Discard. */
 236             rgbtorgb(rbuf,gbuf,bbuf,ptr,image->xsize);
 237             ptr += (image->xsize * 3);
 238         } else {
 239             ImageGetRow(image,rbuf,y,0);
 240             ImageGetRow(image,gbuf,y,1);
 241             ImageGetRow(image,bbuf,y,2);
 242             rgbtorgb(rbuf,gbuf,bbuf,ptr,image->xsize);
 243             ptr += (image->xsize * 3);
 244         }
 245     }
 246     ImageClose(image);
 247     free(rbuf);
 248     free(gbuf);
 249     free(bbuf);
 250     free(abuf);
 251
 252     return (GLubyte *) base;
 253 }
 254
 255 int main(int argc, char **argv)
 256 {
 257         int width, height;
 258         GLubyte *data;
 259         char buff[32];
 260         int n;
 261         FILE *fo;
 262
 263         if (argc != 3)
 264         {
 265                 fprintf(stderr, "usage: %s <infile.rgb> <outfile.p6>\n", argv[0]);
 266                 return 1;
 267         }
 268
 269         data = read_rgb_texture(argv[1], &width, &height);
 270
 271         n = sprintf(buff, "P6\n%d %d\n255\n", width, height);
 272
 273         /* [dBorca] avoid LF to CRLF conversion */
 274         if ((fo = fopen(argv[2], "wb")) == NULL) {
 275            fprintf(stderr, "Cannot open output file!\n");
 276            exit(1);
 277         }
 278
 279         fwrite(buff, n, 1, fo);
 280         fwrite(data, width * 3, height, fo);
 281
 282         fclose(fo);
 283
 284         return 0;
 285 }