logImageCore.c

Go to the documentation of this file.

/*
 *       Cineon image file format library routines.
 *
 *       Copyright 1999,2000,2001 David Hodson <hodsond@acm.org>
 *
 *       This program is free software; you can redistribute it and/or modify it
 *       under the terms of the GNU General Public License as published by the Free
 *       Software Foundation; either version 2 of the License, or (at your option)
 *       any later version.
 *
 *       This program is distributed in the hope that it will be useful, but
 *       WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 *       or FITNESS FOR A PARTICULAR PURPOSE.    See the GNU General Public License
 *       for more details.
 *
 *       You should have received a copy of the GNU General Public License
 *       along with this program; if not, write to the Free Software
 *       Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 */

#include "logImageCore.h"

#include <time.h>                                /* strftime() */
#include <math.h>
/* Makes rint consistent in Windows and Linux: */
#define rint(x) floor(x+0.5)

#ifdef WIN32
#include <winsock.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/param.h>
#endif

#if defined(__hpux)
/* These are macros in hpux */
#ifdef htonl
#undef htonl
#undef htons
#undef ntohl
#undef ntohs
#endif
unsigned int htonl(h) unsigned int h; { return(h); }
unsigned short htons(h) unsigned short h; { return(h); }
unsigned int ntohl(n) unsigned int n; { return(n); }
unsigned short ntohs(n) unsigned short n; { return(n); }
#endif
        
        
/* obscure LogImage conversion */
/* from 10 bit int to 0.0 - 1.0 */
/* magic numbers left intact */
static double
convertTo(int inp, int white, float gamma) {
        /*      return pow(pow(10.0, ((inp - white) * 0.002 / 0.6)), gamma); */
        return pow(10.0, (inp - white) * gamma * 0.002 / 0.6);
}

static double
convertFrom(double inp, int white, float gamma) {
        return white + log10(inp) / (gamma * 0.002 / 0.6);
}

/* set up the 10 bit to 8 bit and 8 bit to 10 bit tables */
void
setupLut(LogImageFile *logImage) {

        int i;
        double f_black;
        double scale;

        f_black = convertTo(logImage->params.blackPoint, logImage->params.whitePoint, logImage->params.gamma);
        scale = 255.0 / (1.0 - f_black);

        for (i = 0; i <= logImage->params.blackPoint; ++i) {
                logImage->lut10[i] = 0;
        }
        for (; i < logImage->params.whitePoint; ++i) {
                double f_i;
                f_i = convertTo(i, logImage->params.whitePoint, logImage->params.gamma);
                logImage->lut10[i] = (int)rint(scale * (f_i - f_black));
        }
        for (; i < 1024; ++i) {
                logImage->lut10[i] = 255;
        }

        for (i = 0; i < 256; ++i) {
                double f_i = f_black + (i / 255.0) * (1.0 - f_black);
                logImage->lut8[i] = convertFrom(f_i, logImage->params.whitePoint, logImage->params.gamma);
        }
}

/* set up the 10 bit to 16 bit and 16 bit to 10 bit tables */
void
setupLut16(LogImageFile *logImage) {

        int i;
        double f_black;
        double scale;

        f_black = convertTo(logImage->params.blackPoint, logImage->params.whitePoint, logImage->params.gamma);
        scale = 65535.0 / (1.0 - f_black);

        for (i = 0; i <= logImage->params.blackPoint; ++i) {
                logImage->lut10_16[i] = 0;
        }
        for (; i < logImage->params.whitePoint; ++i) {
                double f_i;
                f_i = convertTo(i, logImage->params.whitePoint, logImage->params.gamma);
                logImage->lut10_16[i] = (int)rint(scale * (f_i - f_black));
        }
        for (; i < 1024; ++i) {
                logImage->lut10_16[i] = 65535;
        }

        for (i = 0; i < 65536; ++i) {
                double f_i = f_black + (i / 65535.0) * (1.0 - f_black);
                logImage->lut16_16[i] = convertFrom(f_i, logImage->params.whitePoint, logImage->params.gamma);
        }
}

/* how many longwords to hold this many pixels? */
int
pixelsToLongs(int numPixels) {
        return (numPixels + 2) / 3;
}

/* byte reversed float */

typedef union {
        U32 i;
        R32 f;
} Hack;

R32
htonf(R32 f) {
        Hack hack;
        hack.f = f;
        hack.i = htonl(hack.i);
        return hack.f;
}

R32
ntohf(R32 f) {
        Hack hack;
        hack.f = f;
        hack.i = ntohl(hack.i);
        return hack.f;
}

#define UNDEF_FLOAT 0x7F800000

R32
undefined(void) {
        Hack hack;
        hack.i = UNDEF_FLOAT;
        return hack.f;
}

/* reverse an endian-swapped U16 */
U16
reverseU16(U16 value) {

        union {
                U16 whole;
                char part[2];
        } buff;
        char temp;
        buff.whole = value;
        temp = buff.part[0];
        buff.part[0] = buff.part[1];
        buff.part[1] = temp;
        return buff.whole;
}

/* reverse an endian-swapped U32 */
U32
reverseU32(U32 value) {

        union {
                U32 whole;
                char part[4];
        } buff;
        char temp;
        buff.whole = value;
        temp = buff.part[0];
        buff.part[0] = buff.part[3];
        buff.part[3] = temp;
        temp = buff.part[1];
        buff.part[1] = buff.part[2];
        buff.part[2] = temp;
        return buff.whole;
}

/* reverse an endian-swapped R32 */
R32
reverseR32(R32 value) {

        union {
                R32 whole;
                char part[4];
        } buff;
        char temp;
        buff.whole = value;
        temp = buff.part[0];
        buff.part[0] = buff.part[3];
        buff.part[3] = temp;
        temp = buff.part[1];
        buff.part[1] = buff.part[2];
        buff.part[2] = temp;
        return buff.whole;
}

#if 0
/* bytes per line for images packed 3 10 bit pixels to 32 bits, 32 bit aligned */
int
bytesPerLine_10_4(int numPixels) {
        return ((numPixels + 2) / 3) * 4;
}

void
seekLine_noPadding(LogImageFile* logImage, int lineNumber) {
        int fileOffset = bytesPerLine_10_4(lineNumber * logImage->width * logImage->depth);
        int filePos = logImage->imageOffset + fileOffset;
        if (fseek(logImage->file, filePos, SEEK_SET) != 0) {
                /* complain? */
        }
}

void
seekLine_padding(LogImageFile* logImage, int lineNumber) {
        int fileOffset = lineNumber * bytesPerLine_10_4(logImage->width * logImage->depth);
        int filePos = logImage->imageOffset + fileOffset;
        if (fseek(logImage->file, filePos, SEEK_SET) != 0) {
                /* complain? */
        }
}
#endif