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, 6);
 121    }
 122
 123    raw->tmp = (unsigned char *)malloc(raw->sizeX*256);
 124    raw->tmpR = (unsigned char *)malloc(raw->sizeX*256);
 125    raw->tmpG = (unsigned char *)malloc(raw->sizeX*256);
 126    raw->tmpB = (unsigned char *)malloc(raw->sizeX*256);
 127    if (raw->sizeZ==4) {
 128       raw->tmpA = (unsigned char *)malloc(raw->sizeX*256);
 129    }
 130    if (raw->tmp == NULL || raw->tmpR == NULL || raw->tmpG == NULL ||
 131        raw->tmpB == NULL) {
 132       fprintf(stderr, "Out of memory!\n");
 133       return NULL;
 134    }
 135
 136    if ((raw->type & 0xFF00) == 0x0100) {
 137       x = raw->sizeY * raw->sizeZ * sizeof(GLuint);
 138       raw->rowStart = (GLuint *)malloc(x);
 139       raw->rowSize = (GLint *)malloc(x);
 140       if (raw->rowStart == NULL || raw->rowSize == NULL) {
 141          fprintf(stderr, "Out of memory!\n");
 142          return NULL;
 143       }
 144       raw->rleEnd = 512 + (2 * x);
 145       fseek(raw->file, 512, SEEK_SET);
 146       fread(raw->rowStart, 1, x, raw->file);
 147       fread(raw->rowSize, 1, x, raw->file);
 148       if (swapFlag) {
 149          ConvertLong(raw->rowStart, (long) (x/sizeof(GLuint)));
 150          ConvertLong((GLuint *)raw->rowSize, (long) (x/sizeof(GLint)));
 151       }
 152    }
 153    return raw;
 154 }
 155
 156 static void RawImageClose(rawImageRec *raw)
 157 {
 158    fclose(raw->file);
 159    free(raw->tmp);
 160    free(raw->tmpR);
 161    free(raw->tmpG);
 162    free(raw->tmpB);
 163    if (raw->rowStart)
 164       free(raw->rowStart);
 165    if (raw->rowSize)
 166       free(raw->rowSize);
 167    if (raw->sizeZ>3) {
 168       free(raw->tmpA);
 169    }
 170    free(raw);
 171 }
 172
 173 static void RawImageGetRow(rawImageRec *raw, unsigned char *buf, int y, int z)
 174 {
 175    unsigned char *iPtr, *oPtr, pixel;
 176    int count, done = 0;
 177
 178    if ((raw->type & 0xFF00) == 0x0100) {
 179       fseek(raw->file, (long) raw->rowStart[y+z*raw->sizeY], SEEK_SET);
 180       fread(raw->tmp, 1, (unsigned int)raw->rowSize[y+z*raw->sizeY],
 181             raw->file);
 182
 183       iPtr = raw->tmp;
 184       oPtr = buf;
 185       while (!done) {
 186          pixel = *iPtr++;
 187          count = (int)(pixel & 0x7F);
 188          if (!count) {
 189                          done = 1;
 190             return;
 191          }
 192          if (pixel & 0x80) {
 193             while (count--) {
 194                *oPtr++ = *iPtr++;
 195             }
 196          } else {
 197             pixel = *iPtr++;
 198             while (count--) {
 199                *oPtr++ = pixel;
 200             }
 201          }
 202       }
 203    } else {
 204       fseek(raw->file, 512+(y*raw->sizeX)+(z*raw->sizeX*raw->sizeY),
 205             SEEK_SET);
 206       fread(buf, 1, raw->sizeX, raw->file);
 207    }
 208 }
 209
 210
 211 static void RawImageGetData(rawImageRec *raw, TK_RGBImageRec *final)
 212 {
 213    unsigned char *ptr;
 214    int i, j;
 215
 216    final->data = (unsigned char *)malloc((raw->sizeX+1)*(raw->sizeY+1)*4);
 217    if (final->data == NULL) {
 218       fprintf(stderr, "Out of memory!\n");
 219    }
 220
 221    ptr = final->data;
 222    for (i = 0; i < (int)(raw->sizeY); i++) {
 223       RawImageGetRow(raw, raw->tmpR, i, 0);
 224       RawImageGetRow(raw, raw->tmpG, i, 1);
 225       RawImageGetRow(raw, raw->tmpB, i, 2);
 226       if (raw->sizeZ>3) {
 227          RawImageGetRow(raw, raw->tmpA, i, 3);
 228       }
 229       for (j = 0; j < (int)(raw->sizeX); j++) {
 230          *ptr++ = *(raw->tmpR + j);
 231          *ptr++ = *(raw->tmpG + j);
 232          *ptr++ = *(raw->tmpB + j);
 233          if (raw->sizeZ>3) {
 234             *ptr++ = *(raw->tmpA + j);
 235          }
 236       }
 237    }
 238 }
 239
 240
 241 static TK_RGBImageRec *tkRGBImageLoad(const char *fileName)
 242 {
 243    rawImageRec *raw;
 244    TK_RGBImageRec *final;
 245
 246    raw = RawImageOpen(fileName);
 247    if (!raw) {
 248       fprintf(stderr, "File not found\n");
 249       return NULL;
 250    }
 251    final = (TK_RGBImageRec *)malloc(sizeof(TK_RGBImageRec));
 252    if (final == NULL) {
 253       fprintf(stderr, "Out of memory!\n");
 254       RawImageClose(raw);
 255       return NULL;
 256    }
 257    final->sizeX = raw->sizeX;
 258    final->sizeY = raw->sizeY;
 259    final->components = raw->sizeZ;
 260    RawImageGetData(raw, final);
 261    RawImageClose(raw);
 262    return final;
 263 }
 264
 265
 266 static void FreeImage( TK_RGBImageRec *image )
 267 {
 268    free(image->data);
 269    free(image);
 270 }
 271
 272
 273 /*
 274  * Load an SGI .rgb file and generate a set of 2-D mipmaps from it.
 275  * Input:  imageFile - name of .rgb to read
 276  *         intFormat - internal texture format to use, or number of components
 277  * Return:  GL_TRUE if success, GL_FALSE if error.
 278  */
 279 GLboolean LoadRGBMipmaps( const char *imageFile, GLint intFormat )
 280 {
 281    GLint w, h;
 282    return LoadRGBMipmaps2( imageFile, GL_TEXTURE_2D, intFormat, &w, &h );
 283 }
 284
 285
 286
 287 GLboolean LoadRGBMipmaps2( const char *imageFile, GLenum target,
 288                            GLint intFormat, GLint *width, GLint *height )
 289 {
 290    GLint error;
 291    GLenum format;
 292    TK_RGBImageRec *image;
 293
 294    image = tkRGBImageLoad( imageFile );
 295    if (!image) {
 296       return GL_FALSE;
 297    }
 298
 299    if (image->components==3) {
 300       format = GL_RGB;
 301    }
 302    else if (image->components==4) {
 303       format = GL_RGBA;
 304    }
 305    else {
 306       /* not implemented */
 307       fprintf(stderr,
 308               "Error in LoadRGBMipmaps %d-component images not implemented\n",
 309               image->components );
 310       FreeImage(image);
 311       return GL_FALSE;
 312    }
 313
 314    error = gluBuild2DMipmaps( target,
 315                               intFormat,
 316                               image->sizeX, image->sizeY,
 317                               format,
 318                               GL_UNSIGNED_BYTE,
 319                               image->data );
 320
 321    *width = image->sizeX;
 322    *height = image->sizeY;
 323
 324    FreeImage(image);
 325
 326    return error ? GL_FALSE : GL_TRUE;
 327 }
 328
 329
 330
 331 /*
 332  * Load an SGI .rgb file and return a pointer to the image data.
 333  * Input:  imageFile - name of .rgb to read
 334  * Output:  width - width of image
 335  *          height - height of image
 336  *          format - format of image (GL_RGB or GL_RGBA)
 337  * Return:  pointer to image data or NULL if error
 338  */
 339 GLubyte *LoadRGBImage( const char *imageFile, GLint *width, GLint *height,
 340                        GLenum *format )
 341 {
 342    TK_RGBImageRec *image;
 343    GLint bytes;
 344    GLubyte *buffer;
 345
 346    image = tkRGBImageLoad( imageFile );
 347    if (!image) {
 348       return NULL;
 349    }
 350
 351    if (image->components==3) {
 352       *format = GL_RGB;
 353    }
 354    else if (image->components==4) {
 355       *format = GL_RGBA;
 356    }
 357    else {
 358       /* not implemented */
 359       fprintf(stderr,
 360               "Error in LoadRGBImage %d-component images not implemented\n",
 361               image->components );
 362       FreeImage(image);
 363       return NULL;
 364    }
 365
 366    *width = image->sizeX;
 367    *height = image->sizeY;
 368
 369    bytes = image->sizeX * image->sizeY * image->components;
 370    buffer = (GLubyte *) malloc(bytes);
 371    if (!buffer) {
 372       FreeImage(image);
 373       return NULL;
 374    }
 375
 376    memcpy( (void *) buffer, (void *) image->data, bytes );
 377
 378    FreeImage(image);
 379
 380    return buffer;
 381 }
 382
 383 #define CLAMP( X, MIN, MAX )  ( (X)<(MIN) ? (MIN) : ((X)>(MAX) ? (MAX) : (X)) )
 384
 385
 386 static void ConvertRGBtoYUV(GLint w, GLint h, GLint texel_bytes,
 387                             const GLubyte *src,
 388                             GLushort *dest)
 389 {
 390    GLint i, j;
 391
 392    for (i = 0; i < h; i++) {
 393       for (j = 0; j < w; j++) {
 394          const GLfloat r = (src[0]) / 255.0;
 395          const GLfloat g = (src[1]) / 255.0;
 396          const GLfloat b = (src[2]) / 255.0;
 397          GLfloat y, cr, cb;
 398          GLint iy, icr, icb;
 399
 400          y  = r * 65.481 + g * 128.553 + b * 24.966 + 16;
 401          cb = r * -37.797 + g * -74.203 + b * 112.0 + 128;
 402          cr = r * 112.0 + g * -93.786 + b * -18.214 + 128;
 403          /*printf("%f %f %f -> %f %f %f\n", r, g, b, y, cb, cr);*/
 404          iy  = (GLint) CLAMP(y,  0, 254);
 405          icb = (GLint) CLAMP(cb, 0, 254);
 406          icr = (GLint) CLAMP(cr, 0, 254);
 407
 408          if (j & 1) {
 409             /* odd */
 410             *dest = (iy << 8) | icr;
 411          }
 412          else {
 413             /* even */
 414             *dest = (iy << 8) | icb;
 415          }
 416          dest++;
 417          src += texel_bytes;
 418       }
 419    }
 420 }
 421
 422
 423 /*
 424  * Load an SGI .rgb file and return a pointer to the image data, converted
 425  * to 422 yuv.
 426  *
 427  * Input:  imageFile - name of .rgb to read
 428  * Output:  width - width of image
 429  *          height - height of image
 430  * Return:  pointer to image data or NULL if error
 431  */
 432 GLushort *LoadYUVImage( const char *imageFile, GLint *width, GLint *height )
 433 {
 434    TK_RGBImageRec *image;
 435    GLushort *buffer;
 436
 437    image = tkRGBImageLoad( imageFile );
 438    if (!image) {
 439       return NULL;
 440    }
 441
 442    if (image->components != 3 && image->components !=4 ) {
 443       /* not implemented */
 444       fprintf(stderr,
 445               "Error in LoadYUVImage %d-component images not implemented\n",
 446               image->components );
 447       FreeImage(image);
 448       return NULL;
 449    }
 450
 451    *width = image->sizeX;
 452    *height = image->sizeY;
 453
 454    buffer = (GLushort *) malloc( image->sizeX * image->sizeY * 2 );
 455
 456    if (buffer)
 457       ConvertRGBtoYUV( image->sizeX,
 458                        image->sizeY,
 459                        image->components,
 460                        image->data,
 461                        buffer );
 462
 463
 464    FreeImage(image);
 465    return buffer;
 466 }
 467