path: root/src/OpenGl/OpenGl_ImageBox.cxx

/*
* Fonction
* ~~~~~~~~
*   Gestion des images sous OpenGL
*
*
* Attention:
* ~~~~~~~~~~~
*  Ce package a ete teste sur SGI, OSF, SUN, HP et WNT.
*
*
* Historique des modifications
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
*   22-05-97: PCT ; creation
*   10-07-98: FGU ; Ajout : ReadScaledImage 
*                   Mise a jour des dimensions de l image
*    02.15.100 JR : Implicit convertion
*/
/*----------------------------------------------------------------------*/

/*----------------------------------------------------------------------*/
/*
* Includes
*/

#include <stdio.h>
#include <stdlib.h> 
#include <string.h>

#include <OpenGl_ImageBox.hxx>

/*----------------------------------------------------------------------*/
/*
* Types definis
*/

typedef struct _ImageRec {
  unsigned short imagic;
  unsigned short type;
  unsigned short dim;
  unsigned short xsize, ysize, zsize;
  unsigned int min, max;
  unsigned int wasteBytes;
  char name[80];
  unsigned long colorMap;
  FILE *file;
  unsigned char *tmp, *tmpR, *tmpG, *tmpB;
  unsigned long rleEnd;
  unsigned int *rowStart;
  int *rowSize;
} ImageRec;

/*----------------------------------------------------------------------*/
/*
* Fonctions privees
*/

static void
ConvertShort(unsigned short *array, long length) {
  unsigned long b1, b2;
  unsigned char *ptr;

  ptr = (unsigned char *)array;
  while (length--) {
    b1 = *ptr++;
    b2 = *ptr++;
    *array++ = (unsigned short )((b1 << 8) | (b2));
  }
}
/*----------------------------------------------------------------------*/

static void
ConvertLong(unsigned *array, long length) {
  unsigned long b1, b2, b3, b4;
  unsigned char *ptr;

  ptr = (unsigned char *)array;
  while (length--) {
    b1 = *ptr++;
    b2 = *ptr++;
    b3 = *ptr++;
    b4 = *ptr++;
    *array++ = (b1 << 24) | (b2 << 16) | (b3 << 8) | (b4);
  }
}
/*----------------------------------------------------------------------*/

static ImageRec *ImageOpen(char *fileName)
{
  union {
    int testWord;
    char testByte[4];
  } endianTest;
  ImageRec *image;
  int swapFlag;
  int x;

  endianTest.testWord = 1;
  if (endianTest.testByte[0] == 1) {
    swapFlag = 1;
  } else {
    swapFlag = 0;
  }

  image = (ImageRec *)malloc(sizeof(ImageRec));
  if (image == NULL) {
    fprintf(stderr, "Out of memory!\n");
    exit(1);
  }
  if ((image->file = fopen(fileName, "rb")) == NULL) {
    perror(fileName);
    exit(1);
  }

  fread(image, 1, 12, image->file);

  if (swapFlag) {
    ConvertShort(&image->imagic, 6);
  }

  image->tmp = (unsigned char *)malloc(image->xsize*256);
  image->tmpR = (unsigned char *)malloc(image->xsize*256);
  image->tmpG = (unsigned char *)malloc(image->xsize*256);
  image->tmpB = (unsigned char *)malloc(image->xsize*256);
  if (image->tmp == NULL || image->tmpR == NULL || image->tmpG == NULL ||
    image->tmpB == NULL) {
      fprintf(stderr, "Out of memory!\n");
      exit(1);
    }

    if ((image->type & 0xFF00) == 0x0100) {
      x = image->ysize * image->zsize * sizeof(unsigned);
      image->rowStart = (unsigned *)malloc(x);
      image->rowSize = (int *)malloc(x);
      if (image->rowStart == NULL || image->rowSize == NULL) {
        fprintf(stderr, "Out of memory!\n");
        exit(1);
      }
      image->rleEnd = 512 + (2 * x);
      fseek(image->file, 512, SEEK_SET);
      fread(image->rowStart, 1, x, image->file);
      fread(image->rowSize, 1, x, image->file);
      if (swapFlag) {
        ConvertLong(image->rowStart, x/sizeof(unsigned));
        ConvertLong((unsigned *)image->rowSize, x/sizeof(int));
      }
    }
    return image;
}
/*----------------------------------------------------------------------*/

static void
ImageClose(ImageRec *image) {
  fclose(image->file);
  free(image->tmp);
  free(image->tmpR);
  free(image->tmpG);
  free(image->tmpB);
  free(image);
}
/*----------------------------------------------------------------------*/

static void
ImageGetRow(ImageRec *image, unsigned char *buf, int y, int z) {
  unsigned char *iPtr, *oPtr, pixel;
  int count;

  if ((image->type & 0xFF00) == 0x0100) {
    fseek(image->file, image->rowStart[y+z*image->ysize], SEEK_SET);
    fread(image->tmp, 1, (unsigned int)image->rowSize[y+z*image->ysize],
      image->file);

    iPtr = image->tmp;
    oPtr = buf;
    while (1) {
      pixel = *iPtr++;
      count = (int)(pixel & 0x7F);
      if (!count) {
        return;
      }
      if (pixel & 0x80) {
        while (count--) {
          *oPtr++ = *iPtr++;
        }
      } else {
        pixel = *iPtr++;
        while (count--) {
          *oPtr++ = pixel;
        }
      }
    }
  } else {
    fseek(image->file, 512+(y*image->xsize)+(z*image->xsize*image->ysize),
      SEEK_SET);
    fread(buf, 1, image->xsize, image->file);
  }
}

/*----------------------------------------------------------------------*/
/*
* Fonctions publiques 
*/

/*----------------------------------------------------------------------*/
void ReadScaledImage(char *file, int xsize, int ysize, char *buf, unsigned short *zsize)
{    
  ImageRec *image = ImageOpen(file);
  unsigned char *rbuf, *gbuf=NULL, *bbuf=NULL;    
  int row, rrow, i, ri;
  char *p = buf;

  *zsize = image->zsize;

  /* Allocation memoire */
  rbuf=(unsigned char *)malloc(image->xsize * sizeof(unsigned char));

  if (image->zsize > 2) {
    gbuf = (unsigned char *) malloc (image->xsize * sizeof(unsigned char));
    bbuf = (unsigned char *) malloc (image->xsize * sizeof(unsigned char));
  }

  /* Lecture image rang apres rang */    
  for (row = 0; row < ysize; row++) {
    /* rang a lire */
    rrow = (row*image->ysize)/ysize;

    if (*zsize > 2) {
      ImageGetRow(image, rbuf, rrow, 0);
      ImageGetRow(image, gbuf, rrow, 1);
      ImageGetRow(image, bbuf, rrow, 2);
    }
    else
      ImageGetRow(image, rbuf, rrow, 0);

    /* stockage au format RGB */
    for (i=0; i < xsize; i++) {
      ri = (i*image->xsize)/xsize;
      if (*zsize > 2) {
        *p++ = rbuf[ri];
        *p++ = gbuf[ri];
        *p++ = bbuf[ri];
      }
      else {
        *p++ = rbuf[ri];
        *p++ = rbuf[ri];
        *p++ = rbuf[ri];
      }
    }
  }

  /* delete image buffers */
  free(rbuf);
  if (*zsize > 2) {
    free(gbuf);
    free(bbuf);
  }

  ImageClose(image);    
}

/*----------------------------------------------------------------------*/
void ReadSizeImage(char *file, int *xsize, int *ysize)
{
  /* Lecture image */
  ImageRec *image = ImageOpen(file);

  /* Affectation taille */
  *xsize = image->xsize;
  *ysize = image->ysize;
}

/*----------------------------------------------------------------------*/
void bwtorgba(unsigned char *b,unsigned char *l,int n) {
  while(n--) {
    l[0] = *b;
    l[1] = *b;
    l[2] = *b;
    l[3] = 0xff;
    l += 4; b++;
  }
}

/*----------------------------------------------------------------------*/

void rgbtorgba(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *l,int n) {
  while(n--) {
    l[0] = r[0];
    l[1] = g[0];
    l[2] = b[0];
    l[3] = 0xff;
    l += 4; r++; g++; b++;
  }
}

/*----------------------------------------------------------------------*/

void rgbatorgba(unsigned char *r,unsigned char *g,unsigned char *b,unsigned char *a,unsigned char *l,int n) {
  while(n--) {
    l[0] = r[0];
    l[1] = g[0];
    l[2] = b[0];
    l[3] = a[0];
    l += 4; r++; g++; b++; a++;
  }
}

/*----------------------------------------------------------------------*/

unsigned *
read_texture(char *name, int *width, int *height, int *components) {
  unsigned *base, *lptr;
  unsigned char *rbuf, *gbuf, *bbuf, *abuf;
  ImageRec *image;
  int y;

  image = ImageOpen(name);

  if(!image)
    return NULL;
  (*width)=image->xsize;
  (*height)=image->ysize;
  (*components)=image->zsize;
  base = (unsigned *)malloc(image->xsize*image->ysize*sizeof(unsigned));
  rbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  gbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  bbuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  abuf = (unsigned char *)malloc(image->xsize*sizeof(unsigned char));
  if(!base || !rbuf || !gbuf || !bbuf)
  {  
    free(base);
    free(rbuf);
    free(gbuf);
    free(bbuf);
    free(abuf);
    return NULL;
  }
  lptr = base;
  for(y=0; y<image->ysize; y++) {
    if(image->zsize>=4) {
      ImageGetRow(image,rbuf,y,0);
      ImageGetRow(image,gbuf,y,1);
      ImageGetRow(image,bbuf,y,2);
      ImageGetRow(image,abuf,y,3);
      rgbatorgba(rbuf,gbuf,bbuf,abuf,(unsigned char *)lptr,image->xsize);
      lptr += image->xsize;
    } else if(image->zsize==3) {
      ImageGetRow(image,rbuf,y,0);
      ImageGetRow(image,gbuf,y,1);
      ImageGetRow(image,bbuf,y,2);
      rgbtorgba(rbuf,gbuf,bbuf,(unsigned char *)lptr,image->xsize);
      lptr += image->xsize;
    } else {
      ImageGetRow(image,rbuf,y,0);
      bwtorgba(rbuf,(unsigned char *)lptr,image->xsize);
      lptr += image->xsize;
    }
  }
  ImageClose(image);
  free(rbuf);
  free(gbuf);
  free(bbuf);
  free(abuf);

  return (unsigned *) base;
}

/*----------------------------------------------------------------------*/