/src/freeimage-svn/FreeImage/trunk/Source/OpenEXR/IlmImf/ImfMisc.cpp
Line | Count | Source |
1 | | /////////////////////////////////////////////////////////////////////////// |
2 | | // |
3 | | // Copyright (c) 2004, Industrial Light & Magic, a division of Lucas |
4 | | // Digital Ltd. LLC |
5 | | // |
6 | | // All rights reserved. |
7 | | // |
8 | | // Redistribution and use in source and binary forms, with or without |
9 | | // modification, are permitted provided that the following conditions are |
10 | | // met: |
11 | | // * Redistributions of source code must retain the above copyright |
12 | | // notice, this list of conditions and the following disclaimer. |
13 | | // * Redistributions in binary form must reproduce the above |
14 | | // copyright notice, this list of conditions and the following disclaimer |
15 | | // in the documentation and/or other materials provided with the |
16 | | // distribution. |
17 | | // * Neither the name of Industrial Light & Magic nor the names of |
18 | | // its contributors may be used to endorse or promote products derived |
19 | | // from this software without specific prior written permission. |
20 | | // |
21 | | // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
22 | | // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
23 | | // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
24 | | // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
25 | | // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
26 | | // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
27 | | // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
28 | | // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
29 | | // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
30 | | // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
31 | | // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
32 | | // |
33 | | /////////////////////////////////////////////////////////////////////////// |
34 | | |
35 | | |
36 | | |
37 | | //----------------------------------------------------------------------------- |
38 | | // |
39 | | // Miscellaneous helper functions for OpenEXR image file I/O |
40 | | // |
41 | | //----------------------------------------------------------------------------- |
42 | | |
43 | | #include <ImfMisc.h> |
44 | | #include <ImfHeader.h> |
45 | | #include <ImfAttribute.h> |
46 | | #include <ImfCompressor.h> |
47 | | #include <ImfChannelList.h> |
48 | | #include <ImfXdr.h> |
49 | | #include <ImathFun.h> |
50 | | #include <Iex.h> |
51 | | #include <ImfStdIO.h> |
52 | | #include <ImfConvert.h> |
53 | | #include <ImfPartType.h> |
54 | | #include <ImfTileDescription.h> |
55 | | #include "ImfNamespace.h" |
56 | | |
57 | | OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER |
58 | | |
59 | | using IMATH_NAMESPACE::Box2i; |
60 | | using IMATH_NAMESPACE::divp; |
61 | | using IMATH_NAMESPACE::modp; |
62 | | using std::vector; |
63 | | |
64 | | int |
65 | | pixelTypeSize (PixelType type) |
66 | 0 | { |
67 | 0 | int size; |
68 | |
|
69 | 0 | switch (type) |
70 | 0 | { |
71 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
72 | | |
73 | 0 | size = Xdr::size <unsigned int> (); |
74 | 0 | break; |
75 | | |
76 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
77 | |
|
78 | 0 | size = Xdr::size <half> (); |
79 | 0 | break; |
80 | | |
81 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
82 | |
|
83 | 0 | size = Xdr::size <float> (); |
84 | 0 | break; |
85 | | |
86 | 0 | default: |
87 | |
|
88 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel type."); |
89 | 0 | } |
90 | | |
91 | 0 | return size; |
92 | 0 | } |
93 | | |
94 | | |
95 | | int |
96 | | numSamples (int s, int a, int b) |
97 | 0 | { |
98 | 0 | int a1 = divp (a, s); |
99 | 0 | int b1 = divp (b, s); |
100 | 0 | return b1 - a1 + ((a1 * s < a)? 0: 1); |
101 | 0 | } |
102 | | |
103 | | |
104 | | size_t |
105 | | bytesPerLineTable (const Header &header, |
106 | | vector<size_t> &bytesPerLine) |
107 | 0 | { |
108 | 0 | const Box2i &dataWindow = header.dataWindow(); |
109 | 0 | const ChannelList &channels = header.channels(); |
110 | |
|
111 | 0 | bytesPerLine.resize (dataWindow.max.y - dataWindow.min.y + 1); |
112 | |
|
113 | 0 | for (ChannelList::ConstIterator c = channels.begin(); |
114 | 0 | c != channels.end(); |
115 | 0 | ++c) |
116 | 0 | { |
117 | 0 | int nBytes = pixelTypeSize (c.channel().type) * |
118 | 0 | (dataWindow.max.x - dataWindow.min.x + 1) / |
119 | 0 | c.channel().xSampling; |
120 | |
|
121 | 0 | for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i) |
122 | 0 | if (modp (y, c.channel().ySampling) == 0) |
123 | 0 | bytesPerLine[i] += nBytes; |
124 | 0 | } |
125 | |
|
126 | 0 | size_t maxBytesPerLine = 0; |
127 | |
|
128 | 0 | for (int y = dataWindow.min.y, i = 0; y <= dataWindow.max.y; ++y, ++i) |
129 | 0 | if (maxBytesPerLine < bytesPerLine[i]) |
130 | 0 | maxBytesPerLine = bytesPerLine[i]; |
131 | |
|
132 | 0 | return maxBytesPerLine; |
133 | 0 | } |
134 | | |
135 | | |
136 | | const int& |
137 | | sampleCount(const char* base, int xStride, int yStride, int x, int y) |
138 | 0 | { |
139 | 0 | const char* ptr = base + y * yStride + x * xStride; |
140 | 0 | int* intPtr = (int*) ptr; |
141 | |
|
142 | 0 | return *intPtr; |
143 | 0 | } |
144 | | |
145 | | int& |
146 | | sampleCount(char* base, int xStride, int yStride, int x, int y) |
147 | 0 | { |
148 | 0 | char* ptr = base + y * yStride + x * xStride; |
149 | 0 | int* intPtr = (int*) ptr; |
150 | | |
151 | 0 | return *intPtr; |
152 | 0 | } |
153 | | |
154 | | |
155 | | size_t |
156 | | bytesPerDeepLineTable (const Header &header, |
157 | | int minY, int maxY, |
158 | | const char* base, |
159 | | int xStride, |
160 | | int yStride, |
161 | | vector<size_t> &bytesPerLine) |
162 | 0 | { |
163 | 0 | const Box2i &dataWindow = header.dataWindow(); |
164 | 0 | const ChannelList &channels = header.channels(); |
165 | |
|
166 | 0 | for (ChannelList::ConstIterator c = channels.begin(); |
167 | 0 | c != channels.end(); |
168 | 0 | ++c) |
169 | 0 | { |
170 | 0 | for (int y = minY; y <= maxY; ++y) |
171 | 0 | if (modp (y, c.channel().ySampling) == 0) |
172 | 0 | { |
173 | 0 | int nBytes = 0; |
174 | 0 | for (int x = dataWindow.min.x; x <= dataWindow.max.x; x++) |
175 | 0 | { |
176 | 0 | if (modp (x, c.channel().xSampling) == 0) |
177 | 0 | nBytes += pixelTypeSize (c.channel().type) * |
178 | 0 | sampleCount(base, xStride, yStride, x, y); |
179 | 0 | } |
180 | 0 | bytesPerLine[y - dataWindow.min.y] += nBytes; |
181 | 0 | } |
182 | 0 | } |
183 | |
|
184 | 0 | size_t maxBytesPerLine = 0; |
185 | |
|
186 | 0 | for (int y = minY; y <= maxY; ++y) |
187 | 0 | if (maxBytesPerLine < bytesPerLine[y - dataWindow.min.y]) |
188 | 0 | maxBytesPerLine = bytesPerLine[y - dataWindow.min.y]; |
189 | |
|
190 | 0 | return maxBytesPerLine; |
191 | 0 | } |
192 | | |
193 | | |
194 | | size_t |
195 | | bytesPerDeepLineTable (const Header &header, |
196 | | char* base, |
197 | | int xStride, |
198 | | int yStride, |
199 | | vector<size_t> &bytesPerLine) |
200 | 0 | { |
201 | 0 | return bytesPerDeepLineTable(header, |
202 | 0 | header.dataWindow().min.y, |
203 | 0 | header.dataWindow().max.y, |
204 | 0 | base, |
205 | 0 | xStride, |
206 | 0 | yStride, |
207 | 0 | bytesPerLine); |
208 | 0 | } |
209 | | |
210 | | |
211 | | void |
212 | | offsetInLineBufferTable (const vector<size_t> &bytesPerLine, |
213 | | int scanline1, int scanline2, |
214 | | int linesInLineBuffer, |
215 | | vector<size_t> &offsetInLineBuffer) |
216 | 0 | { |
217 | 0 | offsetInLineBuffer.resize (bytesPerLine.size()); |
218 | |
|
219 | 0 | size_t offset = 0; |
220 | |
|
221 | 0 | for (int i = scanline1; i <= scanline2; ++i) |
222 | 0 | { |
223 | 0 | if (i % linesInLineBuffer == 0) |
224 | 0 | offset = 0; |
225 | |
|
226 | 0 | offsetInLineBuffer[i] = offset; |
227 | 0 | offset += bytesPerLine[i]; |
228 | 0 | } |
229 | 0 | } |
230 | | |
231 | | |
232 | | void |
233 | | offsetInLineBufferTable (const vector<size_t> &bytesPerLine, |
234 | | int linesInLineBuffer, |
235 | | vector<size_t> &offsetInLineBuffer) |
236 | 0 | { |
237 | 0 | offsetInLineBufferTable (bytesPerLine, |
238 | 0 | 0, bytesPerLine.size() - 1, |
239 | 0 | linesInLineBuffer, |
240 | 0 | offsetInLineBuffer); |
241 | 0 | } |
242 | | |
243 | | |
244 | | int |
245 | | lineBufferMinY (int y, int minY, int linesInLineBuffer) |
246 | 0 | { |
247 | 0 | return ((y - minY) / linesInLineBuffer) * linesInLineBuffer + minY; |
248 | 0 | } |
249 | | |
250 | | |
251 | | int |
252 | | lineBufferMaxY (int y, int minY, int linesInLineBuffer) |
253 | 0 | { |
254 | 0 | return lineBufferMinY (y, minY, linesInLineBuffer) + linesInLineBuffer - 1; |
255 | 0 | } |
256 | | |
257 | | |
258 | | Compressor::Format |
259 | | defaultFormat (Compressor * compressor) |
260 | 0 | { |
261 | 0 | return compressor? compressor->format(): Compressor::XDR; |
262 | 0 | } |
263 | | |
264 | | |
265 | | int |
266 | | numLinesInBuffer (Compressor * compressor) |
267 | 0 | { |
268 | 0 | return compressor? compressor->numScanLines(): 1; |
269 | 0 | } |
270 | | |
271 | | |
272 | | void |
273 | | copyIntoFrameBuffer (const char *& readPtr, |
274 | | char * writePtr, |
275 | | char * endPtr, |
276 | | size_t xStride, |
277 | | bool fill, |
278 | | double fillValue, |
279 | | Compressor::Format format, |
280 | | PixelType typeInFrameBuffer, |
281 | | PixelType typeInFile) |
282 | 0 | { |
283 | | // |
284 | | // Copy a horizontal row of pixels from an input |
285 | | // file's line or tile buffer to a frame buffer. |
286 | | // |
287 | |
|
288 | 0 | if (fill) |
289 | 0 | { |
290 | | // |
291 | | // The file contains no data for this channel. |
292 | | // Store a default value in the frame buffer. |
293 | | // |
294 | |
|
295 | 0 | switch (typeInFrameBuffer) |
296 | 0 | { |
297 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
298 | | |
299 | 0 | { |
300 | 0 | unsigned int fillVal = (unsigned int) (fillValue); |
301 | |
|
302 | 0 | while (writePtr <= endPtr) |
303 | 0 | { |
304 | 0 | *(unsigned int *) writePtr = fillVal; |
305 | 0 | writePtr += xStride; |
306 | 0 | } |
307 | 0 | } |
308 | 0 | break; |
309 | | |
310 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
311 | |
|
312 | 0 | { |
313 | 0 | half fillVal = half (fillValue); |
314 | |
|
315 | 0 | while (writePtr <= endPtr) |
316 | 0 | { |
317 | 0 | *(half *) writePtr = fillVal; |
318 | 0 | writePtr += xStride; |
319 | 0 | } |
320 | 0 | } |
321 | 0 | break; |
322 | | |
323 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
324 | |
|
325 | 0 | { |
326 | 0 | float fillVal = float (fillValue); |
327 | |
|
328 | 0 | while (writePtr <= endPtr) |
329 | 0 | { |
330 | 0 | *(float *) writePtr = fillVal; |
331 | 0 | writePtr += xStride; |
332 | 0 | } |
333 | 0 | } |
334 | 0 | break; |
335 | | |
336 | 0 | default: |
337 | |
|
338 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
339 | 0 | } |
340 | 0 | } |
341 | 0 | else if (format == Compressor::XDR) |
342 | 0 | { |
343 | | // |
344 | | // The the line or tile buffer is in XDR format. |
345 | | // |
346 | | // Convert the pixels from the file's machine- |
347 | | // independent representation, and store the |
348 | | // results in the frame buffer. |
349 | | // |
350 | |
|
351 | 0 | switch (typeInFrameBuffer) |
352 | 0 | { |
353 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
354 | | |
355 | 0 | switch (typeInFile) |
356 | 0 | { |
357 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
358 | |
|
359 | 0 | while (writePtr <= endPtr) |
360 | 0 | { |
361 | 0 | Xdr::read <CharPtrIO> (readPtr, *(unsigned int *) writePtr); |
362 | 0 | writePtr += xStride; |
363 | 0 | } |
364 | 0 | break; |
365 | | |
366 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
367 | |
|
368 | 0 | while (writePtr <= endPtr) |
369 | 0 | { |
370 | 0 | half h; |
371 | 0 | Xdr::read <CharPtrIO> (readPtr, h); |
372 | 0 | *(unsigned int *) writePtr = halfToUint (h); |
373 | 0 | writePtr += xStride; |
374 | 0 | } |
375 | 0 | break; |
376 | | |
377 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
378 | |
|
379 | 0 | while (writePtr <= endPtr) |
380 | 0 | { |
381 | 0 | float f; |
382 | 0 | Xdr::read <CharPtrIO> (readPtr, f); |
383 | 0 | *(unsigned int *)writePtr = floatToUint (f); |
384 | 0 | writePtr += xStride; |
385 | 0 | } |
386 | 0 | break; |
387 | | |
388 | 0 | default: |
389 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
390 | 0 | } |
391 | 0 | break; |
392 | | |
393 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
394 | |
|
395 | 0 | switch (typeInFile) |
396 | 0 | { |
397 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
398 | |
|
399 | 0 | while (writePtr <= endPtr) |
400 | 0 | { |
401 | 0 | unsigned int ui; |
402 | 0 | Xdr::read <CharPtrIO> (readPtr, ui); |
403 | 0 | *(half *) writePtr = uintToHalf (ui); |
404 | 0 | writePtr += xStride; |
405 | 0 | } |
406 | 0 | break; |
407 | | |
408 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
409 | |
|
410 | 0 | while (writePtr <= endPtr) |
411 | 0 | { |
412 | 0 | Xdr::read <CharPtrIO> (readPtr, *(half *) writePtr); |
413 | 0 | writePtr += xStride; |
414 | 0 | } |
415 | 0 | break; |
416 | | |
417 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
418 | |
|
419 | 0 | while (writePtr <= endPtr) |
420 | 0 | { |
421 | 0 | float f; |
422 | 0 | Xdr::read <CharPtrIO> (readPtr, f); |
423 | 0 | *(half *) writePtr = floatToHalf (f); |
424 | 0 | writePtr += xStride; |
425 | 0 | } |
426 | 0 | break; |
427 | 0 | default: |
428 | | |
429 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
430 | 0 | } |
431 | 0 | break; |
432 | | |
433 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
434 | |
|
435 | 0 | switch (typeInFile) |
436 | 0 | { |
437 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
438 | |
|
439 | 0 | while (writePtr <= endPtr) |
440 | 0 | { |
441 | 0 | unsigned int ui; |
442 | 0 | Xdr::read <CharPtrIO> (readPtr, ui); |
443 | 0 | *(float *) writePtr = float (ui); |
444 | 0 | writePtr += xStride; |
445 | 0 | } |
446 | 0 | break; |
447 | | |
448 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
449 | |
|
450 | 0 | while (writePtr <= endPtr) |
451 | 0 | { |
452 | 0 | half h; |
453 | 0 | Xdr::read <CharPtrIO> (readPtr, h); |
454 | 0 | *(float *) writePtr = float (h); |
455 | 0 | writePtr += xStride; |
456 | 0 | } |
457 | 0 | break; |
458 | | |
459 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
460 | |
|
461 | 0 | while (writePtr <= endPtr) |
462 | 0 | { |
463 | 0 | Xdr::read <CharPtrIO> (readPtr, *(float *) writePtr); |
464 | 0 | writePtr += xStride; |
465 | 0 | } |
466 | 0 | break; |
467 | 0 | default: |
468 | | |
469 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
470 | 0 | } |
471 | 0 | break; |
472 | | |
473 | 0 | default: |
474 | |
|
475 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
476 | 0 | } |
477 | 0 | } |
478 | 0 | else |
479 | 0 | { |
480 | | // |
481 | | // The the line or tile buffer is in NATIVE format. |
482 | | // Copy the results into the frame buffer. |
483 | | // |
484 | |
|
485 | 0 | switch (typeInFrameBuffer) |
486 | 0 | { |
487 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
488 | | |
489 | 0 | switch (typeInFile) |
490 | 0 | { |
491 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
492 | |
|
493 | 0 | while (writePtr <= endPtr) |
494 | 0 | { |
495 | 0 | for (size_t i = 0; i < sizeof (unsigned int); ++i) |
496 | 0 | writePtr[i] = readPtr[i]; |
497 | |
|
498 | 0 | readPtr += sizeof (unsigned int); |
499 | 0 | writePtr += xStride; |
500 | 0 | } |
501 | 0 | break; |
502 | | |
503 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
504 | |
|
505 | 0 | while (writePtr <= endPtr) |
506 | 0 | { |
507 | 0 | half h = *(half *) readPtr; |
508 | 0 | *(unsigned int *) writePtr = halfToUint (h); |
509 | 0 | readPtr += sizeof (half); |
510 | 0 | writePtr += xStride; |
511 | 0 | } |
512 | 0 | break; |
513 | | |
514 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
515 | |
|
516 | 0 | while (writePtr <= endPtr) |
517 | 0 | { |
518 | 0 | float f; |
519 | |
|
520 | 0 | for (size_t i = 0; i < sizeof (float); ++i) |
521 | 0 | ((char *)&f)[i] = readPtr[i]; |
522 | |
|
523 | 0 | *(unsigned int *)writePtr = floatToUint (f); |
524 | 0 | readPtr += sizeof (float); |
525 | 0 | writePtr += xStride; |
526 | 0 | } |
527 | 0 | break; |
528 | | |
529 | 0 | default: |
530 | | |
531 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
532 | 0 | } |
533 | 0 | break; |
534 | | |
535 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
536 | |
|
537 | 0 | switch (typeInFile) |
538 | 0 | { |
539 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
540 | |
|
541 | 0 | while (writePtr <= endPtr) |
542 | 0 | { |
543 | 0 | unsigned int ui; |
544 | |
|
545 | 0 | for (size_t i = 0; i < sizeof (unsigned int); ++i) |
546 | 0 | ((char *)&ui)[i] = readPtr[i]; |
547 | |
|
548 | 0 | *(half *) writePtr = uintToHalf (ui); |
549 | 0 | readPtr += sizeof (unsigned int); |
550 | 0 | writePtr += xStride; |
551 | 0 | } |
552 | 0 | break; |
553 | | |
554 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
555 | | |
556 | | // If we're tightly packed, just memcpy |
557 | 0 | if (xStride == sizeof(half)) { |
558 | 0 | int numBytes = endPtr-writePtr+sizeof(half); |
559 | 0 | memcpy(writePtr, readPtr, numBytes); |
560 | 0 | readPtr += numBytes; |
561 | 0 | writePtr += numBytes; |
562 | 0 | } else { |
563 | 0 | while (writePtr <= endPtr) |
564 | 0 | { |
565 | 0 | *(half *) writePtr = *(half *)readPtr; |
566 | 0 | readPtr += sizeof (half); |
567 | 0 | writePtr += xStride; |
568 | 0 | } |
569 | 0 | } |
570 | 0 | break; |
571 | | |
572 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
573 | |
|
574 | 0 | while (writePtr <= endPtr) |
575 | 0 | { |
576 | 0 | float f; |
577 | |
|
578 | 0 | for (size_t i = 0; i < sizeof (float); ++i) |
579 | 0 | ((char *)&f)[i] = readPtr[i]; |
580 | |
|
581 | 0 | *(half *) writePtr = floatToHalf (f); |
582 | 0 | readPtr += sizeof (float); |
583 | 0 | writePtr += xStride; |
584 | 0 | } |
585 | 0 | break; |
586 | 0 | default: |
587 | | |
588 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
589 | 0 | } |
590 | 0 | break; |
591 | | |
592 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
593 | |
|
594 | 0 | switch (typeInFile) |
595 | 0 | { |
596 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
597 | |
|
598 | 0 | while (writePtr <= endPtr) |
599 | 0 | { |
600 | 0 | unsigned int ui; |
601 | |
|
602 | 0 | for (size_t i = 0; i < sizeof (unsigned int); ++i) |
603 | 0 | ((char *)&ui)[i] = readPtr[i]; |
604 | |
|
605 | 0 | *(float *) writePtr = float (ui); |
606 | 0 | readPtr += sizeof (unsigned int); |
607 | 0 | writePtr += xStride; |
608 | 0 | } |
609 | 0 | break; |
610 | | |
611 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
612 | |
|
613 | 0 | while (writePtr <= endPtr) |
614 | 0 | { |
615 | 0 | half h = *(half *) readPtr; |
616 | 0 | *(float *) writePtr = float (h); |
617 | 0 | readPtr += sizeof (half); |
618 | 0 | writePtr += xStride; |
619 | 0 | } |
620 | 0 | break; |
621 | | |
622 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
623 | |
|
624 | 0 | while (writePtr <= endPtr) |
625 | 0 | { |
626 | 0 | for (size_t i = 0; i < sizeof (float); ++i) |
627 | 0 | writePtr[i] = readPtr[i]; |
628 | |
|
629 | 0 | readPtr += sizeof (float); |
630 | 0 | writePtr += xStride; |
631 | 0 | } |
632 | 0 | break; |
633 | 0 | default: |
634 | | |
635 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
636 | 0 | } |
637 | 0 | break; |
638 | | |
639 | 0 | default: |
640 | |
|
641 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
642 | 0 | } |
643 | 0 | } |
644 | 0 | } |
645 | | |
646 | | void |
647 | | copyIntoDeepFrameBuffer (const char *& readPtr, |
648 | | char * base, |
649 | | const char* sampleCountBase, |
650 | | ptrdiff_t sampleCountXStride, |
651 | | ptrdiff_t sampleCountYStride, |
652 | | int y, int minX, int maxX, |
653 | | int xOffsetForSampleCount, |
654 | | int yOffsetForSampleCount, |
655 | | int xOffsetForData, |
656 | | int yOffsetForData, |
657 | | ptrdiff_t sampleStride, |
658 | | ptrdiff_t xPointerStride, |
659 | | ptrdiff_t yPointerStride, |
660 | | bool fill, |
661 | | double fillValue, |
662 | | Compressor::Format format, |
663 | | PixelType typeInFrameBuffer, |
664 | | PixelType typeInFile) |
665 | 0 | { |
666 | | // |
667 | | // Copy a horizontal row of pixels from an input |
668 | | // file's line or tile buffer to a frame buffer. |
669 | | // |
670 | |
|
671 | 0 | if (fill) |
672 | 0 | { |
673 | | // |
674 | | // The file contains no data for this channel. |
675 | | // Store a default value in the frame buffer. |
676 | | // |
677 | |
|
678 | 0 | switch (typeInFrameBuffer) |
679 | 0 | { |
680 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
681 | |
|
682 | 0 | { |
683 | 0 | unsigned int fillVal = (unsigned int) (fillValue); |
684 | |
|
685 | 0 | for (int x = minX; x <= maxX; x++) |
686 | 0 | { |
687 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
688 | 0 | if(writePtr) |
689 | 0 | { |
690 | 0 | int count = sampleCount(sampleCountBase, |
691 | 0 | sampleCountXStride, |
692 | 0 | sampleCountYStride, |
693 | 0 | x - xOffsetForSampleCount, |
694 | 0 | y - yOffsetForSampleCount); |
695 | 0 | for (int i = 0; i < count; i++) |
696 | 0 | { |
697 | 0 | *(unsigned int *) writePtr = fillVal; |
698 | 0 | writePtr += sampleStride; |
699 | 0 | } |
700 | 0 | } |
701 | 0 | } |
702 | 0 | } |
703 | 0 | break; |
704 | | |
705 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
706 | |
|
707 | 0 | { |
708 | 0 | half fillVal = half (fillValue); |
709 | |
|
710 | 0 | for (int x = minX; x <= maxX; x++) |
711 | 0 | { |
712 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
713 | | |
714 | 0 | if(writePtr) |
715 | 0 | { |
716 | 0 | int count = sampleCount(sampleCountBase, |
717 | 0 | sampleCountXStride, |
718 | 0 | sampleCountYStride, |
719 | 0 | x - xOffsetForSampleCount, |
720 | 0 | y - yOffsetForSampleCount); |
721 | 0 | for (int i = 0; i < count; i++) |
722 | 0 | { |
723 | 0 | *(half *) writePtr = fillVal; |
724 | 0 | writePtr += sampleStride; |
725 | 0 | } |
726 | 0 | } |
727 | 0 | } |
728 | 0 | } |
729 | 0 | break; |
730 | | |
731 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
732 | |
|
733 | 0 | { |
734 | 0 | float fillVal = float (fillValue); |
735 | |
|
736 | 0 | for (int x = minX; x <= maxX; x++) |
737 | 0 | { |
738 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
739 | | |
740 | 0 | if(writePtr) |
741 | 0 | { |
742 | 0 | int count = sampleCount(sampleCountBase, |
743 | 0 | sampleCountXStride, |
744 | 0 | sampleCountYStride, |
745 | 0 | x - xOffsetForSampleCount, |
746 | 0 | y - yOffsetForSampleCount); |
747 | 0 | for (int i = 0; i < count; i++) |
748 | 0 | { |
749 | 0 | *(float *) writePtr = fillVal; |
750 | 0 | writePtr += sampleStride; |
751 | 0 | } |
752 | 0 | } |
753 | 0 | } |
754 | 0 | } |
755 | 0 | break; |
756 | | |
757 | 0 | default: |
758 | |
|
759 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
760 | 0 | } |
761 | 0 | } |
762 | 0 | else if (format == Compressor::XDR) |
763 | 0 | { |
764 | | // |
765 | | // The the line or tile buffer is in XDR format. |
766 | | // |
767 | | // Convert the pixels from the file's machine- |
768 | | // independent representation, and store the |
769 | | // results in the frame buffer. |
770 | | // |
771 | |
|
772 | 0 | switch (typeInFrameBuffer) |
773 | 0 | { |
774 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
775 | |
|
776 | 0 | switch (typeInFile) |
777 | 0 | { |
778 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
779 | |
|
780 | 0 | for (int x = minX; x <= maxX; x++) |
781 | 0 | { |
782 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
783 | | |
784 | 0 | int count = sampleCount(sampleCountBase, |
785 | 0 | sampleCountXStride, |
786 | 0 | sampleCountYStride, |
787 | 0 | x - xOffsetForSampleCount, |
788 | 0 | y - yOffsetForSampleCount); |
789 | 0 | if(writePtr) |
790 | 0 | { |
791 | | |
792 | 0 | for (int i = 0; i < count; i++) |
793 | 0 | { |
794 | 0 | Xdr::read <CharPtrIO> (readPtr, *(unsigned int *) writePtr); |
795 | 0 | writePtr += sampleStride; |
796 | 0 | } |
797 | 0 | }else{ |
798 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<unsigned int>()); |
799 | 0 | } |
800 | 0 | } |
801 | 0 | break; |
802 | | |
803 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
804 | |
|
805 | 0 | for (int x = minX; x <= maxX; x++) |
806 | 0 | { |
807 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
808 | | |
809 | 0 | int count = sampleCount(sampleCountBase, |
810 | 0 | sampleCountXStride, |
811 | 0 | sampleCountYStride, |
812 | 0 | x - xOffsetForSampleCount, |
813 | 0 | y - yOffsetForSampleCount); |
814 | 0 | if(writePtr) |
815 | 0 | { |
816 | |
|
817 | 0 | for (int i = 0; i < count; i++) |
818 | 0 | { |
819 | 0 | half h; |
820 | 0 | Xdr::read <CharPtrIO> (readPtr, h); |
821 | 0 | *(unsigned int *) writePtr = halfToUint (h); |
822 | 0 | writePtr += sampleStride; |
823 | 0 | } |
824 | 0 | }else{ |
825 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<half>()); |
826 | 0 | } |
827 | 0 | } |
828 | 0 | break; |
829 | | |
830 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
831 | |
|
832 | 0 | for (int x = minX; x <= maxX; x++) |
833 | 0 | { |
834 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
835 | | |
836 | 0 | int count = sampleCount(sampleCountBase, |
837 | 0 | sampleCountXStride, |
838 | 0 | sampleCountYStride, |
839 | 0 | x - xOffsetForSampleCount, |
840 | 0 | y - yOffsetForSampleCount); |
841 | | |
842 | 0 | if(writePtr) |
843 | 0 | { |
844 | 0 | for (int i = 0; i < count; i++) |
845 | 0 | { |
846 | 0 | float f; |
847 | 0 | Xdr::read <CharPtrIO> (readPtr, f); |
848 | 0 | *(unsigned int *)writePtr = floatToUint (f); |
849 | 0 | writePtr += sampleStride; |
850 | 0 | } |
851 | 0 | }else{ |
852 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<float>()); |
853 | 0 | } |
854 | | |
855 | 0 | } |
856 | 0 | break; |
857 | 0 | default: |
858 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
859 | 0 | } |
860 | 0 | break; |
861 | | |
862 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
863 | |
|
864 | 0 | switch (typeInFile) |
865 | 0 | { |
866 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
867 | |
|
868 | 0 | for (int x = minX; x <= maxX; x++) |
869 | 0 | { |
870 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
871 | | |
872 | 0 | int count = sampleCount(sampleCountBase, |
873 | 0 | sampleCountXStride, |
874 | 0 | sampleCountYStride, |
875 | 0 | x - xOffsetForSampleCount, |
876 | 0 | y - yOffsetForSampleCount); |
877 | 0 | if(writePtr) |
878 | 0 | { |
879 | |
|
880 | 0 | for (int i = 0; i < count; i++) |
881 | 0 | { |
882 | 0 | unsigned int ui; |
883 | 0 | Xdr::read <CharPtrIO> (readPtr, ui); |
884 | 0 | *(half *) writePtr = uintToHalf (ui); |
885 | 0 | writePtr += sampleStride; |
886 | 0 | } |
887 | 0 | }else{ |
888 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<unsigned int>()); |
889 | 0 | } |
890 | 0 | } |
891 | 0 | break; |
892 | | |
893 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
894 | |
|
895 | 0 | for (int x = minX; x <= maxX; x++) |
896 | 0 | { |
897 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
898 | | |
899 | 0 | int count = sampleCount(sampleCountBase, |
900 | 0 | sampleCountXStride, |
901 | 0 | sampleCountYStride, |
902 | 0 | x - xOffsetForSampleCount, |
903 | 0 | y - yOffsetForSampleCount); |
904 | 0 | if(writePtr) |
905 | 0 | { |
906 | | |
907 | 0 | for (int i = 0; i < count; i++) |
908 | 0 | { |
909 | 0 | Xdr::read <CharPtrIO> (readPtr, *(half *) writePtr); |
910 | 0 | writePtr += sampleStride; |
911 | 0 | } |
912 | 0 | }else{ |
913 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<half>()); |
914 | 0 | } |
915 | 0 | } |
916 | 0 | break; |
917 | | |
918 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
919 | |
|
920 | 0 | for (int x = minX; x <= maxX; x++) |
921 | 0 | { |
922 | 0 | char* writePtr = *(char **) (base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
923 | | |
924 | 0 | int count = sampleCount(sampleCountBase, |
925 | 0 | sampleCountXStride, |
926 | 0 | sampleCountYStride, |
927 | 0 | x - xOffsetForSampleCount, |
928 | 0 | y - yOffsetForSampleCount); |
929 | 0 | if(writePtr) |
930 | 0 | { |
931 | 0 | for (int i = 0; i < count; i++) |
932 | 0 | { |
933 | 0 | float f; |
934 | 0 | Xdr::read <CharPtrIO> (readPtr, f); |
935 | 0 | *(half *) writePtr = floatToHalf (f); |
936 | 0 | writePtr += sampleStride; |
937 | 0 | } |
938 | 0 | }else{ |
939 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<float>()); |
940 | 0 | } |
941 | 0 | } |
942 | 0 | break; |
943 | 0 | default: |
944 | | |
945 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
946 | 0 | } |
947 | 0 | break; |
948 | | |
949 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
950 | |
|
951 | 0 | switch (typeInFile) |
952 | 0 | { |
953 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
954 | |
|
955 | 0 | for (int x = minX; x <= maxX; x++) |
956 | 0 | { |
957 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
958 | | |
959 | 0 | int count = sampleCount(sampleCountBase, |
960 | 0 | sampleCountXStride, |
961 | 0 | sampleCountYStride, |
962 | 0 | x - xOffsetForSampleCount, |
963 | 0 | y - yOffsetForSampleCount); |
964 | 0 | if(writePtr) |
965 | 0 | { |
966 | 0 | for (int i = 0; i < count; i++) |
967 | 0 | { |
968 | 0 | unsigned int ui; |
969 | 0 | Xdr::read <CharPtrIO> (readPtr, ui); |
970 | 0 | *(float *) writePtr = float (ui); |
971 | 0 | writePtr += sampleStride; |
972 | 0 | } |
973 | 0 | }else{ |
974 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<unsigned int>()); |
975 | 0 | } |
976 | 0 | } |
977 | 0 | break; |
978 | | |
979 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
980 | |
|
981 | 0 | for (int x = minX; x <= maxX; x++) |
982 | 0 | { |
983 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
984 | | |
985 | 0 | int count = sampleCount(sampleCountBase, |
986 | 0 | sampleCountXStride, |
987 | 0 | sampleCountYStride, |
988 | 0 | x - xOffsetForSampleCount, |
989 | 0 | y - yOffsetForSampleCount); |
990 | 0 | if(writePtr) |
991 | 0 | { |
992 | |
|
993 | 0 | for (int i = 0; i < count; i++) |
994 | 0 | { |
995 | 0 | half h; |
996 | 0 | Xdr::read <CharPtrIO> (readPtr, h); |
997 | 0 | *(float *) writePtr = float (h); |
998 | 0 | writePtr += sampleStride; |
999 | 0 | } |
1000 | | |
1001 | 0 | }else{ |
1002 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<half>()); |
1003 | 0 | } |
1004 | 0 | } |
1005 | 0 | break; |
1006 | | |
1007 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1008 | |
|
1009 | 0 | for (int x = minX; x <= maxX; x++) |
1010 | 0 | { |
1011 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1012 | | |
1013 | 0 | int count = sampleCount(sampleCountBase, |
1014 | 0 | sampleCountXStride, |
1015 | 0 | sampleCountYStride, |
1016 | 0 | x - xOffsetForSampleCount, |
1017 | 0 | y - yOffsetForSampleCount); |
1018 | 0 | if(writePtr) |
1019 | 0 | { |
1020 | | |
1021 | 0 | for (int i = 0; i < count; i++) |
1022 | 0 | { |
1023 | 0 | Xdr::read <CharPtrIO> (readPtr, *(float *) writePtr); |
1024 | 0 | writePtr += sampleStride; |
1025 | 0 | } |
1026 | 0 | } else{ |
1027 | 0 | Xdr::skip <CharPtrIO> (readPtr,count*Xdr::size<float>()); |
1028 | 0 | } |
1029 | | |
1030 | 0 | } |
1031 | 0 | break; |
1032 | 0 | default: |
1033 | | |
1034 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1035 | 0 | } |
1036 | 0 | break; |
1037 | | |
1038 | 0 | default: |
1039 | |
|
1040 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1041 | 0 | } |
1042 | 0 | } |
1043 | 0 | else |
1044 | 0 | { |
1045 | | // |
1046 | | // The the line or tile buffer is in NATIVE format. |
1047 | | // Copy the results into the frame buffer. |
1048 | | // |
1049 | |
|
1050 | 0 | switch (typeInFrameBuffer) |
1051 | 0 | { |
1052 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1053 | |
|
1054 | 0 | switch (typeInFile) |
1055 | 0 | { |
1056 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1057 | |
|
1058 | 0 | for (int x = minX; x <= maxX; x++) |
1059 | 0 | { |
1060 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1061 | | |
1062 | 0 | int count = sampleCount(sampleCountBase, |
1063 | 0 | sampleCountXStride, |
1064 | 0 | sampleCountYStride, |
1065 | 0 | x - xOffsetForSampleCount, |
1066 | 0 | y - yOffsetForSampleCount); |
1067 | | |
1068 | 0 | if(writePtr) |
1069 | 0 | { |
1070 | 0 | for (int i = 0; i < count; i++) |
1071 | 0 | { |
1072 | 0 | for (size_t i = 0; i < sizeof (unsigned int); ++i) |
1073 | 0 | writePtr[i] = readPtr[i]; |
1074 | |
|
1075 | 0 | readPtr += sizeof (unsigned int); |
1076 | 0 | writePtr += sampleStride; |
1077 | 0 | } |
1078 | 0 | }else{ |
1079 | 0 | readPtr+=sizeof(unsigned int)*count; |
1080 | 0 | } |
1081 | 0 | } |
1082 | 0 | break; |
1083 | | |
1084 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1085 | |
|
1086 | 0 | for (int x = minX; x <= maxX; x++) |
1087 | 0 | { |
1088 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1089 | | |
1090 | 0 | int count = sampleCount(sampleCountBase, |
1091 | 0 | sampleCountXStride, |
1092 | 0 | sampleCountYStride, |
1093 | 0 | x - xOffsetForSampleCount, |
1094 | 0 | y - yOffsetForSampleCount); |
1095 | | |
1096 | 0 | if(writePtr) |
1097 | 0 | { |
1098 | 0 | for (int i = 0; i < count; i++) |
1099 | 0 | { |
1100 | 0 | half h = *(half *) readPtr; |
1101 | 0 | *(unsigned int *) writePtr = halfToUint (h); |
1102 | 0 | readPtr += sizeof (half); |
1103 | 0 | writePtr += sampleStride; |
1104 | 0 | } |
1105 | 0 | }else{ |
1106 | 0 | readPtr+=sizeof(half)*count; |
1107 | 0 | } |
1108 | 0 | } |
1109 | 0 | break; |
1110 | | |
1111 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1112 | |
|
1113 | 0 | for (int x = minX; x <= maxX; x++) |
1114 | 0 | { |
1115 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1116 | | |
1117 | 0 | int count = sampleCount(sampleCountBase, |
1118 | 0 | sampleCountXStride, |
1119 | 0 | sampleCountYStride, |
1120 | 0 | x - xOffsetForSampleCount, |
1121 | 0 | y - yOffsetForSampleCount); |
1122 | | |
1123 | 0 | if(writePtr) |
1124 | 0 | { |
1125 | | |
1126 | 0 | for (int i = 0; i < count; i++) |
1127 | 0 | { |
1128 | 0 | float f; |
1129 | |
|
1130 | 0 | for (size_t i = 0; i < sizeof (float); ++i) |
1131 | 0 | ((char *)&f)[i] = readPtr[i]; |
1132 | |
|
1133 | 0 | *(unsigned int *)writePtr = floatToUint (f); |
1134 | 0 | readPtr += sizeof (float); |
1135 | 0 | writePtr += sampleStride; |
1136 | 0 | } |
1137 | 0 | }else{ |
1138 | 0 | readPtr+=sizeof(float)*count; |
1139 | 0 | } |
1140 | 0 | } |
1141 | 0 | break; |
1142 | 0 | default: |
1143 | | |
1144 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1145 | 0 | } |
1146 | 0 | break; |
1147 | | |
1148 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1149 | |
|
1150 | 0 | switch (typeInFile) |
1151 | 0 | { |
1152 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1153 | |
|
1154 | 0 | for (int x = minX; x <= maxX; x++) |
1155 | 0 | { |
1156 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1157 | | |
1158 | 0 | int count = sampleCount(sampleCountBase, |
1159 | 0 | sampleCountXStride, |
1160 | 0 | sampleCountYStride, |
1161 | 0 | x - xOffsetForSampleCount, |
1162 | 0 | y - yOffsetForSampleCount); |
1163 | | |
1164 | 0 | if(writePtr) |
1165 | 0 | { |
1166 | 0 | for (int i = 0; i < count; i++) |
1167 | 0 | { |
1168 | 0 | unsigned int ui; |
1169 | | |
1170 | 0 | for (size_t i = 0; i < sizeof (unsigned int); ++i) |
1171 | 0 | ((char *)&ui)[i] = readPtr[i]; |
1172 | | |
1173 | 0 | *(half *) writePtr = uintToHalf (ui); |
1174 | 0 | readPtr += sizeof (unsigned int); |
1175 | 0 | writePtr += sampleStride; |
1176 | 0 | } |
1177 | 0 | }else{ |
1178 | 0 | readPtr+=sizeof(unsigned int)*count; |
1179 | 0 | } |
1180 | 0 | } |
1181 | 0 | break; |
1182 | | |
1183 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1184 | |
|
1185 | 0 | for (int x = minX; x <= maxX; x++) |
1186 | 0 | { |
1187 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1188 | | |
1189 | 0 | int count = sampleCount(sampleCountBase, |
1190 | 0 | sampleCountXStride, |
1191 | 0 | sampleCountYStride, |
1192 | 0 | x - xOffsetForSampleCount, |
1193 | 0 | y - yOffsetForSampleCount); |
1194 | | |
1195 | 0 | if(writePtr) |
1196 | 0 | { |
1197 | 0 | for (int i = 0; i < count; i++) |
1198 | 0 | { |
1199 | 0 | *(half *) writePtr = *(half *)readPtr; |
1200 | 0 | readPtr += sizeof (half); |
1201 | 0 | writePtr += sampleStride; |
1202 | 0 | } |
1203 | 0 | }else{ |
1204 | 0 | readPtr+=sizeof(half)*count; |
1205 | 0 | } |
1206 | 0 | } |
1207 | 0 | break; |
1208 | | |
1209 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1210 | |
|
1211 | 0 | for (int x = minX; x <= maxX; x++) |
1212 | 0 | { |
1213 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1214 | | |
1215 | 0 | int count = sampleCount(sampleCountBase, |
1216 | 0 | sampleCountXStride, |
1217 | 0 | sampleCountYStride, |
1218 | 0 | x - xOffsetForSampleCount, |
1219 | 0 | y - yOffsetForSampleCount); |
1220 | | |
1221 | 0 | if(writePtr) |
1222 | 0 | { |
1223 | 0 | for (int i = 0; i < count; i++) |
1224 | 0 | { |
1225 | 0 | float f; |
1226 | |
|
1227 | 0 | for (size_t i = 0; i < sizeof (float); ++i) |
1228 | 0 | ((char *)&f)[i] = readPtr[i]; |
1229 | |
|
1230 | 0 | *(half *) writePtr = floatToHalf (f); |
1231 | 0 | readPtr += sizeof (float); |
1232 | 0 | writePtr += sampleStride; |
1233 | 0 | } |
1234 | 0 | }else{ |
1235 | 0 | readPtr+=sizeof(float)*count; |
1236 | 0 | } |
1237 | 0 | } |
1238 | 0 | break; |
1239 | 0 | default: |
1240 | | |
1241 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1242 | 0 | } |
1243 | 0 | break; |
1244 | | |
1245 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1246 | |
|
1247 | 0 | switch (typeInFile) |
1248 | 0 | { |
1249 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1250 | |
|
1251 | 0 | for (int x = minX; x <= maxX; x++) |
1252 | 0 | { |
1253 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1254 | | |
1255 | 0 | int count = sampleCount(sampleCountBase, |
1256 | 0 | sampleCountXStride, |
1257 | 0 | sampleCountYStride, |
1258 | 0 | x - xOffsetForSampleCount, |
1259 | 0 | y - yOffsetForSampleCount); |
1260 | | |
1261 | 0 | if(writePtr) |
1262 | 0 | { |
1263 | 0 | for (int i = 0; i < count; i++) |
1264 | 0 | { |
1265 | 0 | unsigned int ui; |
1266 | | |
1267 | 0 | for (size_t i = 0; i < sizeof (unsigned int); ++i) |
1268 | 0 | ((char *)&ui)[i] = readPtr[i]; |
1269 | |
|
1270 | 0 | *(float *) writePtr = float (ui); |
1271 | 0 | readPtr += sizeof (unsigned int); |
1272 | 0 | writePtr += sampleStride; |
1273 | 0 | } |
1274 | 0 | }else{ |
1275 | 0 | readPtr+=sizeof(unsigned int)*count; |
1276 | 0 | } |
1277 | 0 | } |
1278 | 0 | break; |
1279 | | |
1280 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1281 | |
|
1282 | 0 | for (int x = minX; x <= maxX; x++) |
1283 | 0 | { |
1284 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1285 | | |
1286 | 0 | int count = sampleCount(sampleCountBase, |
1287 | 0 | sampleCountXStride, |
1288 | 0 | sampleCountYStride, |
1289 | 0 | x - xOffsetForSampleCount, |
1290 | 0 | y - yOffsetForSampleCount); |
1291 | | |
1292 | 0 | if(writePtr) |
1293 | 0 | { |
1294 | 0 | for (int i = 0; i < count; i++) |
1295 | 0 | { |
1296 | 0 | half h = *(half *) readPtr; |
1297 | 0 | *(float *) writePtr = float (h); |
1298 | 0 | readPtr += sizeof (half); |
1299 | 0 | writePtr += sampleStride; |
1300 | 0 | } |
1301 | 0 | }else{ |
1302 | 0 | readPtr+=sizeof(half)*count; |
1303 | 0 | } |
1304 | 0 | } |
1305 | 0 | break; |
1306 | | |
1307 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1308 | |
|
1309 | 0 | for (int x = minX; x <= maxX; x++) |
1310 | 0 | { |
1311 | 0 | char* writePtr = *(char **)(base+(y-yOffsetForData)*yPointerStride + (x-xOffsetForData)*xPointerStride); |
1312 | | |
1313 | 0 | int count = sampleCount(sampleCountBase, |
1314 | 0 | sampleCountXStride, |
1315 | 0 | sampleCountYStride, |
1316 | 0 | x - xOffsetForSampleCount, |
1317 | 0 | y - yOffsetForSampleCount); |
1318 | | |
1319 | 0 | if(writePtr) |
1320 | 0 | { |
1321 | 0 | for (int i = 0; i < count; i++) |
1322 | 0 | { |
1323 | 0 | for (size_t i = 0; i < sizeof (float); ++i) |
1324 | 0 | writePtr[i] = readPtr[i]; |
1325 | |
|
1326 | 0 | readPtr += sizeof (float); |
1327 | 0 | writePtr += sampleStride; |
1328 | 0 | } |
1329 | 0 | }else{ |
1330 | 0 | readPtr+=sizeof(float)*count; |
1331 | 0 | } |
1332 | 0 | } |
1333 | 0 | break; |
1334 | 0 | default: |
1335 | | |
1336 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1337 | 0 | } |
1338 | 0 | break; |
1339 | | |
1340 | 0 | default: |
1341 | |
|
1342 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1343 | 0 | } |
1344 | 0 | } |
1345 | 0 | } |
1346 | | |
1347 | | |
1348 | | void |
1349 | | skipChannel (const char *& readPtr, |
1350 | | PixelType typeInFile, |
1351 | | size_t xSize) |
1352 | 0 | { |
1353 | 0 | switch (typeInFile) |
1354 | 0 | { |
1355 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1356 | | |
1357 | 0 | Xdr::skip <CharPtrIO> (readPtr, Xdr::size <unsigned int> () * xSize); |
1358 | 0 | break; |
1359 | | |
1360 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1361 | |
|
1362 | 0 | Xdr::skip <CharPtrIO> (readPtr, Xdr::size <half> () * xSize); |
1363 | 0 | break; |
1364 | | |
1365 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1366 | |
|
1367 | 0 | Xdr::skip <CharPtrIO> (readPtr, Xdr::size <float> () * xSize); |
1368 | 0 | break; |
1369 | | |
1370 | 0 | default: |
1371 | |
|
1372 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1373 | 0 | } |
1374 | 0 | } |
1375 | | |
1376 | | |
1377 | | void |
1378 | | convertInPlace (char *& writePtr, |
1379 | | const char *& readPtr, |
1380 | | PixelType type, |
1381 | | size_t numPixels) |
1382 | 0 | { |
1383 | 0 | switch (type) |
1384 | 0 | { |
1385 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1386 | | |
1387 | 0 | for (size_t j = 0; j < numPixels; ++j) |
1388 | 0 | { |
1389 | 0 | Xdr::write <CharPtrIO> (writePtr, *(const unsigned int *) readPtr); |
1390 | 0 | readPtr += sizeof(unsigned int); |
1391 | 0 | } |
1392 | 0 | break; |
1393 | | |
1394 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1395 | | |
1396 | 0 | for (size_t j = 0; j < numPixels; ++j) |
1397 | 0 | { |
1398 | 0 | Xdr::write <CharPtrIO> (writePtr, *(const half *) readPtr); |
1399 | 0 | readPtr += sizeof(half); |
1400 | 0 | } |
1401 | 0 | break; |
1402 | | |
1403 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1404 | | |
1405 | 0 | for (size_t j = 0; j < numPixels; ++j) |
1406 | 0 | { |
1407 | 0 | Xdr::write <CharPtrIO> (writePtr, *(const float *) readPtr); |
1408 | 0 | readPtr += sizeof(float); |
1409 | 0 | } |
1410 | 0 | break; |
1411 | | |
1412 | 0 | default: |
1413 | | |
1414 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1415 | 0 | } |
1416 | 0 | } |
1417 | | |
1418 | | |
1419 | | void |
1420 | | copyFromFrameBuffer (char *& writePtr, |
1421 | | const char *& readPtr, |
1422 | | const char * endPtr, |
1423 | | size_t xStride, |
1424 | | Compressor::Format format, |
1425 | | PixelType type) |
1426 | 0 | { |
1427 | | // |
1428 | | // Copy a horizontal row of pixels from a frame |
1429 | | // buffer to an output file's line or tile buffer. |
1430 | | // |
1431 | |
|
1432 | 0 | if (format == Compressor::XDR) |
1433 | 0 | { |
1434 | | // |
1435 | | // The the line or tile buffer is in XDR format. |
1436 | | // |
1437 | |
|
1438 | 0 | switch (type) |
1439 | 0 | { |
1440 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1441 | |
|
1442 | 0 | while (readPtr <= endPtr) |
1443 | 0 | { |
1444 | 0 | Xdr::write <CharPtrIO> (writePtr, |
1445 | 0 | *(const unsigned int *) readPtr); |
1446 | 0 | readPtr += xStride; |
1447 | 0 | } |
1448 | 0 | break; |
1449 | | |
1450 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1451 | |
|
1452 | 0 | while (readPtr <= endPtr) |
1453 | 0 | { |
1454 | 0 | Xdr::write <CharPtrIO> (writePtr, *(const half *) readPtr); |
1455 | 0 | readPtr += xStride; |
1456 | 0 | } |
1457 | 0 | break; |
1458 | | |
1459 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1460 | |
|
1461 | 0 | while (readPtr <= endPtr) |
1462 | 0 | { |
1463 | 0 | Xdr::write <CharPtrIO> (writePtr, *(const float *) readPtr); |
1464 | 0 | readPtr += xStride; |
1465 | 0 | } |
1466 | 0 | break; |
1467 | | |
1468 | 0 | default: |
1469 | |
|
1470 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1471 | 0 | } |
1472 | 0 | } |
1473 | 0 | else |
1474 | 0 | { |
1475 | | // |
1476 | | // The the line or tile buffer is in NATIVE format. |
1477 | | // |
1478 | |
|
1479 | 0 | switch (type) |
1480 | 0 | { |
1481 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1482 | |
|
1483 | 0 | while (readPtr <= endPtr) |
1484 | 0 | { |
1485 | 0 | for (size_t i = 0; i < sizeof (unsigned int); ++i) |
1486 | 0 | *writePtr++ = readPtr[i]; |
1487 | |
|
1488 | 0 | readPtr += xStride; |
1489 | 0 | } |
1490 | 0 | break; |
1491 | | |
1492 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1493 | |
|
1494 | 0 | while (readPtr <= endPtr) |
1495 | 0 | { |
1496 | 0 | *(half *) writePtr = *(const half *) readPtr; |
1497 | 0 | writePtr += sizeof (half); |
1498 | 0 | readPtr += xStride; |
1499 | 0 | } |
1500 | 0 | break; |
1501 | | |
1502 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1503 | |
|
1504 | 0 | while (readPtr <= endPtr) |
1505 | 0 | { |
1506 | 0 | for (size_t i = 0; i < sizeof (float); ++i) |
1507 | 0 | *writePtr++ = readPtr[i]; |
1508 | |
|
1509 | 0 | readPtr += xStride; |
1510 | 0 | } |
1511 | 0 | break; |
1512 | | |
1513 | 0 | default: |
1514 | |
|
1515 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1516 | 0 | } |
1517 | 0 | } |
1518 | 0 | } |
1519 | | |
1520 | | void |
1521 | | copyFromDeepFrameBuffer (char *& writePtr, |
1522 | | const char * base, |
1523 | | char* sampleCountBase, |
1524 | | ptrdiff_t sampleCountXStride, |
1525 | | ptrdiff_t sampleCountYStride, |
1526 | | int y, int xMin, int xMax, |
1527 | | int xOffsetForSampleCount, |
1528 | | int yOffsetForSampleCount, |
1529 | | int xOffsetForData, |
1530 | | int yOffsetForData, |
1531 | | ptrdiff_t sampleStride, |
1532 | | ptrdiff_t dataXStride, |
1533 | | ptrdiff_t dataYStride, |
1534 | | Compressor::Format format, |
1535 | | PixelType type) |
1536 | 0 | { |
1537 | | // |
1538 | | // Copy a horizontal row of pixels from a frame |
1539 | | // buffer to an output file's line or tile buffer. |
1540 | | // |
1541 | |
|
1542 | 0 | if (format == Compressor::XDR) |
1543 | 0 | { |
1544 | | // |
1545 | | // The the line or tile buffer is in XDR format. |
1546 | | // |
1547 | |
|
1548 | 0 | switch (type) |
1549 | 0 | { |
1550 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1551 | |
|
1552 | 0 | for (int x = xMin; x <= xMax; x++) |
1553 | 0 | { |
1554 | 0 | unsigned int count = |
1555 | 0 | sampleCount(sampleCountBase, |
1556 | 0 | sampleCountXStride, |
1557 | 0 | sampleCountYStride, |
1558 | 0 | x - xOffsetForSampleCount, |
1559 | 0 | y - yOffsetForSampleCount); |
1560 | 0 | const char* ptr = base + (y-yOffsetForData) * dataYStride + (x-xOffsetForData) * dataXStride; |
1561 | 0 | const char* readPtr = ((const char**) ptr)[0]; |
1562 | 0 | for (unsigned int i = 0; i < count; i++) |
1563 | 0 | { |
1564 | 0 | Xdr::write <CharPtrIO> (writePtr, |
1565 | 0 | *(const unsigned int *) readPtr); |
1566 | 0 | readPtr += sampleStride; |
1567 | 0 | } |
1568 | 0 | } |
1569 | 0 | break; |
1570 | | |
1571 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1572 | |
|
1573 | 0 | for (int x = xMin; x <= xMax; x++) |
1574 | 0 | { |
1575 | 0 | unsigned int count = |
1576 | 0 | sampleCount(sampleCountBase, |
1577 | 0 | sampleCountXStride, |
1578 | 0 | sampleCountYStride, |
1579 | 0 | x - xOffsetForSampleCount, |
1580 | 0 | y - yOffsetForSampleCount); |
1581 | 0 | const char* ptr = base + (y-yOffsetForData) * dataYStride + (x-xOffsetForData) * dataXStride; |
1582 | 0 | const char* readPtr = ((const char**) ptr)[0]; |
1583 | 0 | for (unsigned int i = 0; i < count; i++) |
1584 | 0 | { |
1585 | 0 | Xdr::write <CharPtrIO> (writePtr, *(const half *) readPtr); |
1586 | 0 | readPtr += sampleStride; |
1587 | 0 | } |
1588 | 0 | } |
1589 | 0 | break; |
1590 | | |
1591 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1592 | |
|
1593 | 0 | for (int x = xMin; x <= xMax; x++) |
1594 | 0 | { |
1595 | 0 | unsigned int count = |
1596 | 0 | sampleCount(sampleCountBase, |
1597 | 0 | sampleCountXStride, |
1598 | 0 | sampleCountYStride, |
1599 | 0 | x - xOffsetForSampleCount, |
1600 | 0 | y - yOffsetForSampleCount); |
1601 | 0 | const char* ptr = base + (y-yOffsetForData) * dataYStride + (x-xOffsetForData) * dataXStride; |
1602 | | |
1603 | 0 | const char* readPtr = ((const char**) ptr)[0]; |
1604 | 0 | for (unsigned int i = 0; i < count; i++) |
1605 | 0 | { |
1606 | 0 | Xdr::write <CharPtrIO> (writePtr, *(const float *) readPtr); |
1607 | 0 | readPtr += sampleStride; |
1608 | 0 | } |
1609 | 0 | } |
1610 | 0 | break; |
1611 | | |
1612 | 0 | default: |
1613 | |
|
1614 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1615 | 0 | } |
1616 | 0 | } |
1617 | 0 | else |
1618 | 0 | { |
1619 | | // |
1620 | | // The the line or tile buffer is in NATIVE format. |
1621 | | // |
1622 | |
|
1623 | 0 | switch (type) |
1624 | 0 | { |
1625 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1626 | |
|
1627 | 0 | for (int x = xMin; x <= xMax; x++) |
1628 | 0 | { |
1629 | 0 | unsigned int count = |
1630 | 0 | sampleCount(sampleCountBase, |
1631 | 0 | sampleCountXStride, |
1632 | 0 | sampleCountYStride, |
1633 | 0 | x - xOffsetForSampleCount, |
1634 | 0 | y - yOffsetForSampleCount); |
1635 | | |
1636 | 0 | const char* ptr = base + (y-yOffsetForData) * dataYStride + (x-xOffsetForData) * dataXStride; |
1637 | 0 | const char* readPtr = ((const char**) ptr)[0]; |
1638 | 0 | for (unsigned int i = 0; i < count; i++) |
1639 | 0 | { |
1640 | 0 | for (size_t j = 0; j < sizeof (unsigned int); ++j) |
1641 | 0 | *writePtr++ = readPtr[j]; |
1642 | |
|
1643 | 0 | readPtr += sampleStride; |
1644 | 0 | } |
1645 | 0 | } |
1646 | 0 | break; |
1647 | | |
1648 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1649 | |
|
1650 | 0 | for (int x = xMin; x <= xMax; x++) |
1651 | 0 | { |
1652 | 0 | unsigned int count = |
1653 | 0 | sampleCount(sampleCountBase, |
1654 | 0 | sampleCountXStride, |
1655 | 0 | sampleCountYStride, |
1656 | 0 | x - xOffsetForSampleCount, |
1657 | 0 | y - yOffsetForSampleCount); |
1658 | 0 | const char* ptr = base + (y-yOffsetForData) * dataYStride + (x-xOffsetForData) * dataXStride; |
1659 | 0 | const char* readPtr = ((const char**) ptr)[0]; |
1660 | 0 | for (unsigned int i = 0; i < count; i++) |
1661 | 0 | { |
1662 | 0 | *(half *) writePtr = *(const half *) readPtr; |
1663 | 0 | writePtr += sizeof (half); |
1664 | 0 | readPtr += sampleStride; |
1665 | 0 | } |
1666 | 0 | } |
1667 | 0 | break; |
1668 | | |
1669 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1670 | |
|
1671 | 0 | for (int x = xMin; x <= xMax; x++) |
1672 | 0 | { |
1673 | 0 | unsigned int count = |
1674 | 0 | sampleCount(sampleCountBase, |
1675 | 0 | sampleCountXStride, |
1676 | 0 | sampleCountYStride, |
1677 | 0 | x - xOffsetForSampleCount, |
1678 | 0 | y - yOffsetForSampleCount); |
1679 | | |
1680 | 0 | const char* ptr = base + (y-yOffsetForData) * dataYStride + (x-xOffsetForData) * dataXStride; |
1681 | 0 | const char* readPtr = ((const char**) ptr)[0]; |
1682 | 0 | for (unsigned int i = 0; i < count; i++) |
1683 | 0 | { |
1684 | 0 | for (size_t j = 0; j < sizeof (float); ++j) |
1685 | 0 | *writePtr++ = readPtr[j]; |
1686 | |
|
1687 | 0 | readPtr += sampleStride; |
1688 | 0 | } |
1689 | 0 | } |
1690 | 0 | break; |
1691 | | |
1692 | 0 | default: |
1693 | |
|
1694 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1695 | 0 | } |
1696 | 0 | } |
1697 | 0 | } |
1698 | | |
1699 | | |
1700 | | void |
1701 | | fillChannelWithZeroes (char *& writePtr, |
1702 | | Compressor::Format format, |
1703 | | PixelType type, |
1704 | | size_t xSize) |
1705 | 0 | { |
1706 | 0 | if (format == Compressor::XDR) |
1707 | 0 | { |
1708 | | // |
1709 | | // Fill with data in XDR format. |
1710 | | // |
1711 | |
|
1712 | 0 | switch (type) |
1713 | 0 | { |
1714 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1715 | |
|
1716 | 0 | for (size_t j = 0; j < xSize; ++j) |
1717 | 0 | Xdr::write <CharPtrIO> (writePtr, (unsigned int) 0); |
1718 | |
|
1719 | 0 | break; |
1720 | | |
1721 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1722 | |
|
1723 | 0 | for (size_t j = 0; j < xSize; ++j) |
1724 | 0 | Xdr::write <CharPtrIO> (writePtr, (half) 0); |
1725 | |
|
1726 | 0 | break; |
1727 | | |
1728 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1729 | |
|
1730 | 0 | for (size_t j = 0; j < xSize; ++j) |
1731 | 0 | Xdr::write <CharPtrIO> (writePtr, (float) 0); |
1732 | |
|
1733 | 0 | break; |
1734 | | |
1735 | 0 | default: |
1736 | |
|
1737 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1738 | 0 | } |
1739 | 0 | } |
1740 | 0 | else |
1741 | 0 | { |
1742 | | // |
1743 | | // Fill with data in NATIVE format. |
1744 | | // |
1745 | |
|
1746 | 0 | switch (type) |
1747 | 0 | { |
1748 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::UINT: |
1749 | |
|
1750 | 0 | for (size_t j = 0; j < xSize; ++j) |
1751 | 0 | { |
1752 | 0 | static const unsigned int ui = 0; |
1753 | |
|
1754 | 0 | for (size_t i = 0; i < sizeof (ui); ++i) |
1755 | 0 | *writePtr++ = ((char *) &ui)[i]; |
1756 | 0 | } |
1757 | 0 | break; |
1758 | | |
1759 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::HALF: |
1760 | |
|
1761 | 0 | for (size_t j = 0; j < xSize; ++j) |
1762 | 0 | { |
1763 | 0 | *(half *) writePtr = half (0); |
1764 | 0 | writePtr += sizeof (half); |
1765 | 0 | } |
1766 | 0 | break; |
1767 | | |
1768 | 0 | case OPENEXR_IMF_INTERNAL_NAMESPACE::FLOAT: |
1769 | |
|
1770 | 0 | for (size_t j = 0; j < xSize; ++j) |
1771 | 0 | { |
1772 | 0 | static const float f = 0; |
1773 | |
|
1774 | 0 | for (size_t i = 0; i < sizeof (f); ++i) |
1775 | 0 | *writePtr++ = ((char *) &f)[i]; |
1776 | 0 | } |
1777 | 0 | break; |
1778 | | |
1779 | 0 | default: |
1780 | |
|
1781 | 0 | throw IEX_NAMESPACE::ArgExc ("Unknown pixel data type."); |
1782 | 0 | } |
1783 | 0 | } |
1784 | 0 | } |
1785 | | |
1786 | | bool |
1787 | | usesLongNames (const Header &header) |
1788 | 0 | { |
1789 | | // |
1790 | | // If an OpenEXR file contains any attribute names, attribute type names |
1791 | | // or channel names longer than 31 characters, then the file cannot be |
1792 | | // read by older versions of the IlmImf library (up to OpenEXR 1.6.1). |
1793 | | // Before writing the file header, we check if the header contains |
1794 | | // any names longer than 31 characters; if it does, then we set the |
1795 | | // LONG_NAMES_FLAG in the file version number. Older versions of the |
1796 | | // IlmImf library will refuse to read files that have the LONG_NAMES_FLAG |
1797 | | // set. Without the flag, older versions of the library would mis- |
1798 | | // interpret the file as broken. |
1799 | | // |
1800 | |
|
1801 | 0 | for (Header::ConstIterator i = header.begin(); |
1802 | 0 | i != header.end(); |
1803 | 0 | ++i) |
1804 | 0 | { |
1805 | 0 | if (strlen (i.name()) >= 32 || strlen (i.attribute().typeName()) >= 32) |
1806 | 0 | return true; |
1807 | 0 | } |
1808 | | |
1809 | 0 | const ChannelList &channels = header.channels(); |
1810 | |
|
1811 | 0 | for (ChannelList::ConstIterator i = channels.begin(); |
1812 | 0 | i != channels.end(); |
1813 | 0 | ++i) |
1814 | 0 | { |
1815 | 0 | if (strlen (i.name()) >= 32) |
1816 | 0 | return true; |
1817 | 0 | } |
1818 | | |
1819 | 0 | return false; |
1820 | 0 | } |
1821 | | |
1822 | | int |
1823 | | getScanlineChunkOffsetTableSize(const Header& header) |
1824 | 0 | { |
1825 | 0 | const Box2i &dataWindow = header.dataWindow(); |
1826 | |
|
1827 | 0 | vector<size_t> bytesPerLine; |
1828 | 0 | size_t maxBytesPerLine = bytesPerLineTable (header, |
1829 | 0 | bytesPerLine); |
1830 | |
|
1831 | 0 | Compressor* compressor = newCompressor(header.compression(), |
1832 | 0 | maxBytesPerLine, |
1833 | 0 | header); |
1834 | |
|
1835 | 0 | int linesInBuffer = numLinesInBuffer (compressor); |
1836 | |
|
1837 | 0 | int lineOffsetSize = (dataWindow.max.y - dataWindow.min.y + |
1838 | 0 | linesInBuffer) / linesInBuffer; |
1839 | |
|
1840 | 0 | delete compressor; |
1841 | |
|
1842 | 0 | return lineOffsetSize; |
1843 | 0 | } |
1844 | | |
1845 | | // |
1846 | | // Located in ImfTiledMisc.cpp |
1847 | | // |
1848 | | int |
1849 | | getTiledChunkOffsetTableSize(const Header& header); |
1850 | | |
1851 | | int |
1852 | | getChunkOffsetTableSize(const Header& header,bool ignore_attribute) |
1853 | 0 | { |
1854 | 0 | if(!ignore_attribute && header.hasChunkCount()) |
1855 | 0 | { |
1856 | 0 | return header.chunkCount(); |
1857 | 0 | } |
1858 | | |
1859 | 0 | if(header.hasType() && !isSupportedType(header.type())) |
1860 | 0 | { |
1861 | 0 | throw IEX_NAMESPACE::ArgExc ("unsupported header type to " |
1862 | 0 | "get chunk offset table size"); |
1863 | 0 | } |
1864 | 0 | if (isTiled(header.type()) == false) |
1865 | 0 | return getScanlineChunkOffsetTableSize(header); |
1866 | 0 | else |
1867 | 0 | return getTiledChunkOffsetTableSize(header); |
1868 | | |
1869 | 0 | } |
1870 | | |
1871 | | |
1872 | | OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT |