progs/util/readtex.c

   1 /* readtex.c */
   2
   3 /*
   4  * Read an SGI .rgb image file and generate a mipmap texture set.
   5  * Much of this code was borrowed from SGI's tk OpenGL toolkit.
   6  */
   7
   8
   9
  10 #include <GL/gl.h>
  11 #include <GL/glu.h>
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include "readtex.h"
  16
  17
  18 #ifndef SEEK_SET
  19 #  define SEEK_SET 0
  20 #endif
  21
  22
  23 /*
  24 ** RGB Image Structure
  25 */
  26
  27 typedef struct _TK_RGBImageRec {
  28    GLint sizeX, sizeY;
  29    GLint components;
  30    unsigned char *data;
  31 } TK_RGBImageRec;
  32
  33
  34
  35 /******************************************************************************/
  36
  37 typedef struct _rawImageRec {
  38     unsigned short imagic;
  39     unsigned short type;
  40     unsigned short dim;
  41     unsigned short sizeX, sizeY, sizeZ;
  42     unsigned long min, max;
  43     unsigned long wasteBytes;
  44     char name[80];
  45     unsigned long colorMap;
  46     FILE *file;
  47     unsigned char *tmp, *tmpR, *tmpG, *tmpB, *tmpA;
  48     unsigned long rleEnd;
  49     GLuint *rowStart;
  50     GLint *rowSize;
  51 } rawImageRec;
  52
  53 /******************************************************************************/
  54
  55 static void ConvertShort(unsigned short *array, long length)
  56 {
  57    unsigned long b1, b2;
  58    unsigned char *ptr;
  59
  60    ptr = (unsigned char *)array;
  61    while (length--) {
  62       b1 = *ptr++;
  63       b2 = *ptr++;
  64       *array++ = (unsigned short) ((b1 << 8) | (b2));
  65    }
  66 }
  67
  68 static void ConvertLong(GLuint *array, long length)
  69 {
  70    unsigned long b1, b2, b3, b4;
  71    unsigned char *ptr;
  72
  73    ptr = (unsigned char *)array;
  74    while (length--) {
  75       b1 = *ptr++;
  76       b2 = *ptr++;
  77       b3 = *ptr++;
  78       b4 = *ptr++;
  79       *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
  80    }
  81 }
  82
  83 static rawImageRec *RawImageOpen(const char *fileName)
  84 {
  85    union {
  86       int testWord;
  87       char testByte[4];
  88    } endianTest;
  89    rawImageRec *raw;
  90    GLenum swapFlag;
  91    int x;
  92
  93    endianTest.testWord = 1;
  94    if (endianTest.testByte[0] == 1) {
  95       swapFlag = GL_TRUE;
  96    } else {
  97       swapFlag = GL_FALSE;
  98    }
  99
 100    raw = (rawImageRec *)calloc(1, sizeof(rawImageRec));
 101    if (raw == NULL) {
 102       fprintf(stderr, "Out of memory!\n");
 103       return NULL;
 104    }
 105    raw->file = fopen(fileName, "rb");
 106    if (raw->file == NULL) {
 107       const char *baseName = strrchr(fileName, '/');
 108       if(baseName)
 109          raw->file = fopen(baseName + 1, "rb");
 110       if(raw->file == NULL) {
 111          perror(fileName);
 112          free(raw);
 113          return NULL;
 114       }
 115    }
 116
 117    fread(raw, 1, 12, raw->file);
 118
 119    if (swapFlag) {
 120       ConvertShort(&raw->imagic, 1);
 121       ConvertShort(&raw->type, 1);
 122       ConvertShort(&raw->dim, 1);
 123       ConvertShort(&raw->sizeX, 1);
 124       ConvertShort(&raw->sizeY, 1);
 125       ConvertShort(&raw->sizeZ, 1);
 126    }
 127
 128    raw->tmp = (unsigned char *)malloc(raw->sizeX*256);
 129    raw->tmpR = (unsigned char *)malloc(raw->sizeX*256);
 130    raw->tmpG = (unsigned char *)malloc(raw->sizeX*256);
 131    raw->tmpB = (unsigned char *)malloc(raw->sizeX*256);
 132    if (raw->sizeZ==4) {
 133       raw->tmpA = (unsigned char *)malloc(raw->sizeX*256);
 134    }
 135    if (raw->tmp == NULL || raw->tmpR == NULL || raw->tmpG == NULL ||
 136        raw->tmpB == NULL) {
 137       fprintf(stderr, "Out of memory!\n");
 138       free(raw->tmp);
 139       free(raw->tmpR);
 140       free(raw->tmpG);
 141       free(raw->tmpB);
 142       free(raw->tmpA);
 143       free(raw);
 144       return NULL;
 145    }
 146
 147    if ((raw->type & 0xFF00) == 0x0100) {
 148       x = raw->sizeY * raw->sizeZ * sizeof(GLuint);
 149       raw->rowStart = (GLuint *)malloc(x);
 150       raw->rowSize = (GLint *)malloc(x);
 151       if (raw->rowStart == NULL || raw->rowSize == NULL) {
 152          fprintf(stderr, "Out of memory!\n");
 153          free(raw->tmp);
 154          free(raw->tmpR);
 155          free(raw->tmpG);
 156          free(raw->tmpB);
 157          free(raw->tmpA);
 158          free(raw->rowStart);
 159          free(raw->rowSize);
 160          free(raw);
 161          return NULL;
 162       }
 163       raw->rleEnd = 512 + (2 * x);
 164       fseek(raw->file, 512, SEEK_SET);
 165       fread(raw->rowStart, 1, x, raw->file);
 166       fread(raw->rowSize, 1, x, raw->file);
 167       if (swapFlag) {
 168          ConvertLong(raw->rowStart, (long) (x/sizeof(GLuint)));
 169          ConvertLong((GLuint *)raw->rowSize, (long) (x/sizeof(GLint)));
 170       }
 171    }
 172    return raw;
 173 }
 174
 175 static void RawImageClose(rawImageRec *raw)
 176 {
 177    fclose(raw->file);
 178    free(raw->tmp);
 179    free(raw->tmpR);
 180    free(raw->tmpG);
 181    free(raw->tmpB);
 182    if (raw->rowStart)
 183       free(raw->rowStart);
 184    if (raw->rowSize)
 185       free(raw->rowSize);
 186    if (raw->sizeZ>3) {
 187       free(raw->tmpA);
 188    }
 189    free(raw);
 190 }
 191
 192 static void RawImageGetRow(rawImageRec *raw, unsigned char *buf, int y, int z)
 193 {
 194    unsigned char *iPtr, *oPtr, pixel;
 195    int count, done = 0;
 196
 197    if ((raw->type & 0xFF00) == 0x0100) {
 198       fseek(raw->file, (long) raw->rowStart[y+z*raw->sizeY], SEEK_SET);
 199       fread(raw->tmp, 1, (unsigned int)raw->rowSize[y+z*raw->sizeY],
 200             raw->file);
 201
 202       iPtr = raw->tmp;
 203       oPtr = buf;
 204       while (!done) {
 205          pixel = *iPtr++;
 206          count = (int)(pixel & 0x7F);
 207          if (!count) {
 208                          done = 1;
 209             return;
 210          }
 211          if (pixel & 0x80) {
 212             while (count--) {
 213                *oPtr++ = *iPtr++;
 214             }
 215          } else {
 216             pixel = *iPtr++;
 217             while (count--) {
 218                *oPtr++ = pixel;
 219             }
 220          }
 221       }
 222    } else {
 223       fseek(raw->file, 512+(y*raw->sizeX)+(z*raw->sizeX*raw->sizeY),
 224             SEEK_SET);
 225       fread(buf, 1, raw->sizeX, raw->file);
 226    }
 227 }
 228
 229
 230 static void RawImageGetData(rawImageRec *raw, TK_RGBImageRec *final)
 231 {
 232    unsigned char *ptr;
 233    int i, j;
 234
 235    final->data = (unsigned char *)malloc((raw->sizeX+1)*(raw->sizeY+1)*4);
 236    if (final->data == NULL) {
 237       fprintf(stderr, "Out of memory!\n");
 238       return;
 239    }
 240
 241    ptr = final->data;
 242    for (i = 0; i < (int)(raw->sizeY); i++) {
 243       RawImageGetRow(raw, raw->tmpR, i, 0);
 244       RawImageGetRow(raw, raw->tmpG, i, 1);
 245       RawImageGetRow(raw, raw->tmpB, i, 2);
 246       if (raw->sizeZ>3) {
 247          RawImageGetRow(raw, raw->tmpA, i, 3);
 248       }
 249       for (j = 0; j < (int)(raw->sizeX); j++) {
 250          *ptr++ = *(raw->tmpR + j);
 251          *ptr++ = *(raw->tmpG + j);
 252          *ptr++ = *(raw->tmpB + j);
 253          if (raw->sizeZ>3) {
 254             *ptr++ = *(raw->tmpA + j);
 255          }
 256       }
 257    }
 258 }
 259
 260
 261 static TK_RGBImageRec *tkRGBImageLoad(const char *fileName)
 262 {
 263    rawImageRec *raw;
 264    TK_RGBImageRec *final;
 265
 266    raw = RawImageOpen(fileName);
 267    if (!raw) {
 268       fprintf(stderr, "File not found\n");
 269       return NULL;
 270    }
 271    final = (TK_RGBImageRec *)malloc(sizeof(TK_RGBImageRec));
 272    if (final == NULL) {
 273       fprintf(stderr, "Out of memory!\n");
 274       RawImageClose(raw);
 275       return NULL;
 276    }
 277    final->sizeX = raw->sizeX;
 278    final->sizeY = raw->sizeY;
 279    final->components = raw->sizeZ;
 280    RawImageGetData(raw, final);
 281    RawImageClose(raw);
 282    return final;
 283 }
 284
 285
 286 static void FreeImage( TK_RGBImageRec *image )
 287 {
 288    free(image->data);
 289    free(image);
 290 }
 291
 292
 293 /*
 294  * Load an SGI .rgb file and generate a set of 2-D mipmaps from it.
 295  * Input:  imageFile - name of .rgb to read
 296  *         intFormat - internal texture format to use, or number of components
 297  * Return:  GL_TRUE if success, GL_FALSE if error.
 298  */
 299 GLboolean LoadRGBMipmaps( const char *imageFile, GLint intFormat )
 300 {
 301    GLint w, h;
 302    return LoadRGBMipmaps2( imageFile, GL_TEXTURE_2D, intFormat, &w, &h );
 303 }
 304
 305
 306
 307 GLboolean LoadRGBMipmaps2( const char *imageFile, GLenum target,
 308                            GLint intFormat, GLint *width, GLint *height )
 309 {
 310    GLint error;
 311    GLenum format;
 312    TK_RGBImageRec *image;
 313
 314    image = tkRGBImageLoad( imageFile );
 315    if (!image) {
 316       return GL_FALSE;
 317    }
 318
 319    if (image->components==3) {
 320       format = GL_RGB;
 321    }
 322    else if (image->components==4) {
 323       format = GL_RGBA;
 324    }
 325    else {
 326       /* not implemented */
 327       fprintf(stderr,
 328               "Error in LoadRGBMipmaps %d-component images not implemented\n",
 329               image->components );
 330       FreeImage(image);
 331       return GL_FALSE;
 332    }
 333
 334    error = gluBuild2DMipmaps( target,
 335                               intFormat,
 336                               image->sizeX, image->sizeY,
 337                               format,
 338                               GL_UNSIGNED_BYTE,
 339                               image->data );
 340
 341    *width = image->sizeX;
 342    *height = image->sizeY;
 343
 344    FreeImage(image);
 345
 346    return error ? GL_FALSE : GL_TRUE;
 347 }
 348
 349
 350
 351 /*
 352  * Load an SGI .rgb file and return a pointer to the image data.
 353  * Input:  imageFile - name of .rgb to read
 354  * Output:  width - width of image
 355  *          height - height of image
 356  *          format - format of image (GL_RGB or GL_RGBA)
 357  * Return:  pointer to image data or NULL if error
 358  */
 359 GLubyte *LoadRGBImage( const char *imageFile, GLint *width, GLint *height,
 360                        GLenum *format )
 361 {
 362    TK_RGBImageRec *image;
 363    GLint bytes;
 364    GLubyte *buffer;
 365
 366    image = tkRGBImageLoad( imageFile );
 367    if (!image) {
 368       return NULL;
 369    }
 370
 371    if (image->components==3) {
 372       *format = GL_RGB;
 373    }
 374    else if (image->components==4) {
 375       *format = GL_RGBA;
 376    }
 377    else {
 378       /* not implemented */
 379       fprintf(stderr,
 380               "Error in LoadRGBImage %d-component images not implemented\n",
 381               image->components );
 382       FreeImage(image);
 383       return NULL;
 384    }
 385
 386    *width = image->sizeX;
 387    *height = image->sizeY;
 388
 389    bytes = image->sizeX * image->sizeY * image->components;
 390    buffer = (GLubyte *) malloc(bytes);
 391    if (!buffer) {
 392       FreeImage(image);
 393       return NULL;
 394    }
 395
 396    memcpy( (void *) buffer, (void *) image->data, bytes );
 397
 398    FreeImage(image);
 399
 400    return buffer;
 401 }
 402
 403 #define CLAMP( X, MIN, MAX )  ( (X)<(MIN) ? (MIN) : ((X)>(MAX) ? (MAX) : (X)) )
 404
 405
 406 static void ConvertRGBtoYUV(GLint w, GLint h, GLint texel_bytes,
 407                             const GLubyte *src,
 408                             GLushort *dest)
 409 {
 410    GLint i, j;
 411
 412    for (i = 0; i < h; i++) {
 413       for (j = 0; j < w; j++) {
 414          const GLfloat r = (src[0]) / 255.0;
 415          const GLfloat g = (src[1]) / 255.0;
 416          const GLfloat b = (src[2]) / 255.0;
 417          GLfloat y, cr, cb;
 418          GLint iy, icr, icb;
 419
 420          y  = r * 65.481 + g * 128.553 + b * 24.966 + 16;
 421          cb = r * -37.797 + g * -74.203 + b * 112.0 + 128;
 422          cr = r * 112.0 + g * -93.786 + b * -18.214 + 128;
 423          /*printf("%f %f %f -> %f %f %f\n", r, g, b, y, cb, cr);*/
 424          iy  = (GLint) CLAMP(y,  0, 254);
 425          icb = (GLint) CLAMP(cb, 0, 254);
 426          icr = (GLint) CLAMP(cr, 0, 254);
 427
 428          if (j & 1) {
 429             /* odd */
 430             *dest = (iy << 8) | icr;
 431          }
 432          else {
 433             /* even */
 434             *dest = (iy << 8) | icb;
 435          }
 436          dest++;
 437          src += texel_bytes;
 438       }
 439    }
 440 }
 441
 442
 443 /*
 444  * Load an SGI .rgb file and return a pointer to the image data, converted
 445  * to 422 yuv.
 446  *
 447  * Input:  imageFile - name of .rgb to read
 448  * Output:  width - width of image
 449  *          height - height of image
 450  * Return:  pointer to image data or NULL if error
 451  */
 452 GLushort *LoadYUVImage( const char *imageFile, GLint *width, GLint *height )
 453 {
 454    TK_RGBImageRec *image;
 455    GLushort *buffer;
 456
 457    image = tkRGBImageLoad( imageFile );
 458    if (!image) {
 459       return NULL;
 460    }
 461
 462    if (image->components != 3 && image->components !=4 ) {
 463       /* not implemented */
 464       fprintf(stderr,
 465               "Error in LoadYUVImage %d-component images not implemented\n",
 466               image->components );
 467       FreeImage(image);
 468       return NULL;
 469    }
 470
 471    *width = image->sizeX;
 472    *height = image->sizeY;
 473
 474    buffer = (GLushort *) malloc( image->sizeX * image->sizeY * 2 );
 475
 476    if (buffer)
 477       ConvertRGBtoYUV( image->sizeX,
 478                        image->sizeY,
 479                        image->components,
 480                        image->data,
 481                        buffer );
 482
 483
 484    FreeImage(image);
 485    return buffer;
 486 }
 487