_img_sgi.C

Ir a la documentación de este archivo.

//===========================================================================
//= _img_sgi.cc                                           Noviembre de 1999 =
//=-------------------------------------------------------------------------=
//= Lector de archivos de imagen en formato SGI RGB.                        =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

#include "toolkits/media/_img_sgi.h"

//===========================================================================
//= Constantes y macros                                                     =
//===========================================================================

#define IMAGIC      0x01da
#define IMAGIC_SWAP 0xda01

#define SWAP_SHORT_BYTES(x) ((((x) & 0xff) << 8) | (((x) & 0xff00) >> 8))
#define SWAP_LONG_BYTES(x) (((((x) & 0xff) << 24) | (((x) & 0xff00) << 8)) | \
((((x) & 0xff0000) >> 8) | (((x) & 0xff000000) >> 24)))

//===========================================================================
//= Clase LECTOR_SGIRGB                                                     =
//===========================================================================

BOOLEAN
LECTOR_SGIRGB::init(FILE *_fd)
{
    unsigned long *rinic, *rtam, ulTmp;
    int x, i;

    fd = _fd;
    /* Read the image header */
    fread(this, 1, 12, fd);
    /* Check byte order  */
    if ( imagic == IMAGIC_SWAP ) {
        type = (UWORD)SWAP_SHORT_BYTES(type);
        dim = (UWORD)SWAP_SHORT_BYTES(dim);
        x_tam = (UWORD)SWAP_SHORT_BYTES(x_tam);
        y_tam = (UWORD)SWAP_SHORT_BYTES(y_tam);
        sizeZ = (UWORD)SWAP_SHORT_BYTES(sizeZ);
    }

    for ( i = 0 ; i <= sizeZ ; i++ ) {
        tmp[i] = new BYTE [x_tam*256];
        if ( !tmp[i] ) {
            fprintf(stderr, "Out of memory!\n");
            return FALSE;
        }
    }

    if ( (type & 0xFF00) == 0x0100 ) /* RLE image */ {
        x = y_tam * sizeZ * sizeof(long);
        rowStart = new unsigned long [ x/sizeof(long) ];
        rowSize = new unsigned long [ x/sizeof(long) ];
        if (rowStart == NULL || rowSize == NULL) {
            fprintf(stderr, "Out of memory!\n");
            return FALSE;
        }
        rleEnd = 512 + (2 * x);
        fseek(fd, 512, SEEK_SET);
        fread(rowStart, 1, x, fd);
        fread(rowSize, 1, x, fd);
        if (imagic == IMAGIC_SWAP) {
            x /= sizeof(long);
            rinic = rowStart;
            rtam = rowSize;
            while ( x-- ) {
                ulTmp = *rinic;
                *rinic++ = SWAP_LONG_BYTES(ulTmp);
                ulTmp = *rtam;
                *rtam++ = SWAP_LONG_BYTES(ulTmp);
            }
        }
    }
    return TRUE;
}

void
LECTOR_SGIRGB::elim(void)
{
    int i;

    for ( i = 0 ; i <= sizeZ ; i++ ) delete tmp[i];
}

void
LECTOR_SGIRGB::leer_linea(unsigned char *buf, int y, int z)
{
    unsigned char *iPtr, *oPtr, pixel;
    int count;

    if ((type & 0xFF00) == 0x0100)  /* RLE image */ {
        fseek(fd, rowStart[y+z*y_tam], SEEK_SET);
        fread(tmp[0], 1, (unsigned int)rowSize[y+z*y_tam],
              fd);

        iPtr = tmp[0];
        oPtr = buf;
        do {
            pixel = *iPtr++;
            count = (int)(pixel & 0x7F);
            if ( !count ) return;
            if ( pixel & 0x80 ) {
                while ( count-- ) *oPtr++ = *iPtr++;                
              }
              else {
                pixel = *iPtr++;
                while ( count-- ) *oPtr++ = pixel;
                count = 1;
            }
         } while ( count );
      }
      else /* verbatim image */ {
        fseek(fd, 512+(y*x_tam)+(z*x_tam*y_tam),
              SEEK_SET);
        fread(buf, 1, x_tam, fd);
    }
}

void
LECTOR_SGIRGB::leer(BYTE *Data)
{
    int i, j, k;
    int remain = 0;

    switch ( sizeZ ) {
      case 1:
        remain = x_tam % 4;
        break;
      case 2:
        remain = x_tam % 2;
        break;
      case 3:
        remain = (x_tam * 3) & 0x3;
        if (remain)
            remain = 4 - remain;
        break;
      case 4:
        remain = 0;
        break;
    }

    for (i = 0; i < y_tam; i++) 
    {
        for ( k = 0; k < sizeZ ; k++ )
            leer_linea(tmp[k+1], i, k);
        for (j = 0; j < x_tam; j++) 
            for ( k = 1; k <= sizeZ ; k++ )
                *Data++ = *(tmp[k] + j);
        Data += remain;
    }
}

//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.