svn merge -r 12937:13095 https://svn.blender.org/svnroot/bf-blender/trunk/blender
[blender.git] / source / blender / imbuf / intern / cineon / logImageCore.c
1 /*
2  *       Cineon image file format library routines.
3  *
4  *       Copyright 1999,2000,2001 David Hodson <hodsond@acm.org>
5  *
6  *       This program is free software; you can redistribute it and/or modify it
7  *       under the terms of the GNU General Public License as published by the Free
8  *       Software Foundation; either version 2 of the License, or (at your option)
9  *       any later version.
10  *
11  *       This program is distributed in the hope that it will be useful, but
12  *       WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13  *       or FITNESS FOR A PARTICULAR PURPOSE.    See the GNU General Public License
14  *       for more details.
15  *
16  *       You should have received a copy of the GNU General Public License
17  *       along with this program; if not, write to the Free Software
18  *       Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  *
20  */
21
22 #include "logImageCore.h"
23
24 #include <time.h>                                /* strftime() */
25 #include <math.h>
26 /* Makes rint consistent in Windows and Linux: */
27 #define rint(x) floor(x+0.5)
28
29 #ifdef WIN32
30 #include <winsock.h>
31 #else
32 #include <sys/types.h>
33 #include <sys/socket.h>
34 #include <netinet/in.h>
35 #include <sys/param.h>
36 #endif
37
38 #if defined(__hpux)
39 /* These are macros in hpux */
40 #ifdef htonl
41 #undef htonl
42 #undef htons
43 #undef ntohl
44 #undef ntohs
45 #endif
46 unsigned int htonl(h) unsigned int h; { return(h); }
47 unsigned short htons(h) unsigned short h; { return(h); }
48 unsigned int ntohl(n) unsigned int n; { return(n); }
49 unsigned short ntohs(n) unsigned short n; { return(n); }
50 #endif
51         
52         
53 /* obscure LogImage conversion */
54 /* from 10 bit int to 0.0 - 1.0 */
55 /* magic numbers left intact */
56 static double
57 convertTo(int inp, int white, float gamma) {
58         /*      return pow(pow(10.0, ((inp - white) * 0.002 / 0.6)), gamma); */
59         return pow(10.0, (inp - white) * gamma * 0.002 / 0.6);
60 }
61
62 static double
63 convertFrom(double inp, int white, float gamma) {
64         return white + log10(inp) / (gamma * 0.002 / 0.6);
65 }
66
67 /* set up the 10 bit to 8 bit and 8 bit to 10 bit tables */
68 void
69 setupLut(LogImageFile *logImage) {
70
71         int i;
72         double f_black;
73         double scale;
74
75         f_black = convertTo(logImage->params.blackPoint, logImage->params.whitePoint, logImage->params.gamma);
76         scale = 255.0 / (1.0 - f_black);
77
78         for (i = 0; i <= logImage->params.blackPoint; ++i) {
79                 logImage->lut10[i] = 0;
80         }
81         for (; i < logImage->params.whitePoint; ++i) {
82                 double f_i;
83                 f_i = convertTo(i, logImage->params.whitePoint, logImage->params.gamma);
84                 logImage->lut10[i] = (int)rint(scale * (f_i - f_black));
85         }
86         for (; i < 1024; ++i) {
87                 logImage->lut10[i] = 255;
88         }
89
90         for (i = 0; i < 256; ++i) {
91                 double f_i = f_black + (i / 255.0) * (1.0 - f_black);
92                 logImage->lut8[i] = convertFrom(f_i, logImage->params.whitePoint, logImage->params.gamma);
93         }
94 }
95
96 /* how many longwords to hold this many pixels? */
97 int
98 pixelsToLongs(int numPixels) {
99         return (numPixels + 2) / 3;
100 }
101
102 /* byte reversed float */
103
104 typedef union {
105         U32 i;
106         R32 f;
107 } Hack;
108
109 R32
110 htonf(R32 f) {
111         Hack hack;
112         hack.f = f;
113         hack.i = htonl(hack.i);
114         return hack.f;
115 }
116
117 R32
118 ntohf(R32 f) {
119         Hack hack;
120         hack.f = f;
121         hack.i = ntohl(hack.i);
122         return hack.f;
123 }
124
125 #define UNDEF_FLOAT 0x7F800000
126
127 R32
128 undefined() {
129         Hack hack;
130         hack.i = UNDEF_FLOAT;
131         return hack.f;
132 }
133
134 /* reverse an endian-swapped U16 */
135 U16
136 reverseU16(U16 value) {
137
138         union {
139                 U16 whole;
140                 char part[2];
141         } buff;
142         char temp;
143         buff.whole = value;
144         temp = buff.part[0];
145         buff.part[0] = buff.part[1];
146         buff.part[1] = temp;
147         return buff.whole;
148 }
149
150 /* reverse an endian-swapped U32 */
151 U32
152 reverseU32(U32 value) {
153
154         union {
155                 U32 whole;
156                 char part[4];
157         } buff;
158         char temp;
159         buff.whole = value;
160         temp = buff.part[0];
161         buff.part[0] = buff.part[3];
162         buff.part[3] = temp;
163         temp = buff.part[1];
164         buff.part[1] = buff.part[2];
165         buff.part[2] = temp;
166         return buff.whole;
167 }
168
169 /* reverse an endian-swapped R32 */
170 R32
171 reverseR32(R32 value) {
172
173         union {
174                 R32 whole;
175                 char part[4];
176         } buff;
177         char temp;
178         buff.whole = value;
179         temp = buff.part[0];
180         buff.part[0] = buff.part[3];
181         buff.part[3] = temp;
182         temp = buff.part[1];
183         buff.part[1] = buff.part[2];
184         buff.part[2] = temp;
185         return buff.whole;
186 }
187
188 #if 0
189 /* bytes per line for images packed 3 10 bit pixels to 32 bits, 32 bit aligned */
190 int
191 bytesPerLine_10_4(int numPixels) {
192         return ((numPixels + 2) / 3) * 4;
193 }
194
195 void
196 seekLine_noPadding(LogImageFile* logImage, int lineNumber) {
197         int fileOffset = bytesPerLine_10_4(lineNumber * logImage->width * logImage->depth);
198         int filePos = logImage->imageOffset + fileOffset;
199         if (fseek(logImage->file, filePos, SEEK_SET) != 0) {
200                 /* complain? */
201         }
202 }
203
204 void
205 seekLine_padding(LogImageFile* logImage, int lineNumber) {
206         int fileOffset = lineNumber * bytesPerLine_10_4(logImage->width * logImage->depth);
207         int filePos = logImage->imageOffset + fileOffset;
208         if (fseek(logImage->file, filePos, SEEK_SET) != 0) {
209                 /* complain? */
210         }
211 }
212 #endif