1
///////////////////////////////////////////////////////////////////////////
3
// Copyright (c) 2006, Industrial Light & Magic, a division of Lucas
6
// All rights reserved.
8
// Redistribution and use in source and binary forms, with or without
9
// modification, are permitted provided that the following conditions are
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
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.
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.
33
///////////////////////////////////////////////////////////////////////////
36
//-----------------------------------------------------------------------------
38
// class B44Compressor
40
// This compressor is lossy for HALF channels; the compression rate
41
// is fixed at 32/14 (approximately 2.28). FLOAT and UINT channels
42
// are not compressed; their data are preserved exactly.
44
// Each HALF channel is split into blocks of 4 by 4 pixels. An
45
// uncompressed block occupies 32 bytes, which are re-interpreted
46
// as sixteen 16-bit unsigned integers, t[0] ... t[15]. Compression
47
// shrinks the block to 14 bytes. The compressed 14-byte block
52
// - a 6-bit shift value
54
// - 15 densely packed 6-bit values, r[0] ... r[14], which are
55
// computed by subtracting adjacent pixel values and right-
56
// shifting the differences according to the stored shift value.
58
// Differences between adjacent pixels are computed according
59
// to the following diagram:
61
// 0 --------> 1 --------> 2 --------> 3
67
// 4 --------> 5 --------> 6 --------> 7
73
// 8 --------> 9 --------> 10 --------> 11
79
// 12 --------> 13 --------> 14 --------> 15
87
// means that r[8] is the difference between t[5] and t[6].
89
// - optionally, a 4-by-4 pixel block where all pixels have the
90
// same value can be treated as a special case, where the
91
// compressed block contains only 3 instead of 14 bytes:
92
// t[0], followed by an "impossible" 6-bit shift value and
95
// This compressor can handle positive and negative pixel values.
96
// NaNs and infinities are replaced with zeroes before compression.
98
//-----------------------------------------------------------------------------
100
#include <ImfB44Compressor.h>
101
#include <ImfHeader.h>
102
#include <ImfChannelList.h>
104
#include <ImathFun.h>
105
#include <ImathBox.h>
130
#include "b44ExpLogTable.h"
134
convertFromLinear (unsigned short s[16])
136
for (int i = 0; i < 16; ++i)
137
s[i] = expTable[s[i]];
142
convertToLinear (unsigned short s[16])
144
for (int i = 0; i < 16; ++i)
145
s[i] = logTable[s[i]];
150
shiftAndRound (int x, int shift)
155
// y = x * pow (2, -shift),
157
// then round y to the nearest integer.
158
// In case of a tie, where y is exactly
159
// halfway between two integers, round
164
int a = (1 << shift) - 1;
166
int b = (x >> shift) & 1;
167
return (x + a + b) >> shift;
172
pack (const unsigned short s[16],
178
// Pack a block of 4 by 4 16-bit pixels (32 bytes) into
179
// either 14 or 3 bytes.
183
// Integers s[0] ... s[15] represent floating-point numbers
184
// in what is essentially a sign-magnitude format. Convert
185
// s[0] .. s[15] into a new set of integers, t[0] ... t[15],
186
// such that if t[i] is greater than t[j], the floating-point
187
// number that corresponds to s[i] is always greater than
188
// the floating-point number that corresponds to s[j].
190
// Also, replace any bit patterns that represent NaNs or
191
// infinities with bit patterns that represent floating-point
194
// bit pattern floating-point bit pattern
195
// in s[i] value in t[i]
201
// 0x7c00 +infinity 0x8000
202
// 0x7bff +HALF_MAX 0xfbff
206
// 0x0002 +2 * HALF_MIN 0x8002
207
// 0x0001 +HALF_MIN 0x8001
208
// 0x0000 +0.0 0x8000
209
// 0x8000 -0.0 0x7fff
210
// 0x8001 -HALF_MIN 0x7ffe
211
// 0x8002 -2 * HALF_MIN 0x7ffd
215
// 0xfbff -HALF_MAX 0x0400
216
// 0xfc00 -infinity 0x8000
223
unsigned short t[16];
225
for (int i = 0; i < 16; ++i)
227
if ((s[i] & 0x7c00) == 0x7c00)
229
else if (s[i] & 0x8000)
232
t[i] = s[i] | 0x8000;
236
// Find the maximum, tMax, of t[0] ... t[15].
239
unsigned short tMax = 0;
241
for (int i = 0; i < 16; ++i)
246
// Compute a set of running differences, r[0] ... r[14]:
247
// Find a shift value such that after rounding off the
248
// rightmost bits and shifting all differenes are between
249
// -32 and +31. Then bias the differences so that they
250
// end up between 0 and 63.
259
const int bias = 0x20;
266
// Compute absolute differences, d[0] ... d[15],
267
// between tMax and t[0] ... t[15].
269
// Shift and round the absolute differences.
272
for (int i = 0; i < 16; ++i)
273
d[i] = shiftAndRound (tMax - t[i], shift);
276
// Convert d[0] .. d[15] into running differences
279
r[ 0] = d[ 0] - d[ 4] + bias;
280
r[ 1] = d[ 4] - d[ 8] + bias;
281
r[ 2] = d[ 8] - d[12] + bias;
283
r[ 3] = d[ 0] - d[ 1] + bias;
284
r[ 4] = d[ 4] - d[ 5] + bias;
285
r[ 5] = d[ 8] - d[ 9] + bias;
286
r[ 6] = d[12] - d[13] + bias;
288
r[ 7] = d[ 1] - d[ 2] + bias;
289
r[ 8] = d[ 5] - d[ 6] + bias;
290
r[ 9] = d[ 9] - d[10] + bias;
291
r[10] = d[13] - d[14] + bias;
293
r[11] = d[ 2] - d[ 3] + bias;
294
r[12] = d[ 6] - d[ 7] + bias;
295
r[13] = d[10] - d[11] + bias;
296
r[14] = d[14] - d[15] + bias;
301
for (int i = 1; i < 15; ++i)
310
while (rMin < 0 || rMax > 0x3f);
312
if (rMin == bias && rMax == bias && optFlatFields)
315
// Special case - all pixels have the same value.
316
// We encode this in 3 instead of 14 bytes by
317
// storing the value 0xfc in the third output byte,
318
// which cannot occur in the 14-byte encoding.
331
// Adjust t[0] so that the pixel whose value is equal
332
// to tMax gets represented as accurately as possible.
335
t[0] = tMax - (d[0] << shift);
339
// Pack t[0], shift and r[0] ... r[14] into 14 bytes:
345
b[ 2] = (unsigned char) ((shift << 2) | (r[ 0] >> 4));
346
b[ 3] = (unsigned char) ((r[ 0] << 4) | (r[ 1] >> 2));
347
b[ 4] = (unsigned char) ((r[ 1] << 6) | r[ 2] );
349
b[ 5] = (unsigned char) ((r[ 3] << 2) | (r[ 4] >> 4));
350
b[ 6] = (unsigned char) ((r[ 4] << 4) | (r[ 5] >> 2));
351
b[ 7] = (unsigned char) ((r[ 5] << 6) | r[ 6] );
353
b[ 8] = (unsigned char) ((r[ 7] << 2) | (r[ 8] >> 4));
354
b[ 9] = (unsigned char) ((r[ 8] << 4) | (r[ 9] >> 2));
355
b[10] = (unsigned char) ((r[ 9] << 6) | r[10] );
357
b[11] = (unsigned char) ((r[11] << 2) | (r[12] >> 4));
358
b[12] = (unsigned char) ((r[12] << 4) | (r[13] >> 2));
359
b[13] = (unsigned char) ((r[13] << 6) | r[14] );
367
unpack14 (const unsigned char b[14], unsigned short s[16])
370
// Unpack a 14-byte block into 4 by 4 16-bit pixels.
374
assert (b[2] != 0xfc);
377
s[ 0] = (b[0] << 8) | b[1];
379
unsigned short shift = (b[ 2] >> 2);
380
unsigned short bias = (0x20 << shift);
382
s[ 4] = s[ 0] + ((((b[ 2] << 4) | (b[ 3] >> 4)) & 0x3f) << shift) - bias;
383
s[ 8] = s[ 4] + ((((b[ 3] << 2) | (b[ 4] >> 6)) & 0x3f) << shift) - bias;
384
s[12] = s[ 8] + ((b[ 4] & 0x3f) << shift) - bias;
386
s[ 1] = s[ 0] + ((b[ 5] >> 2) << shift) - bias;
387
s[ 5] = s[ 4] + ((((b[ 5] << 4) | (b[ 6] >> 4)) & 0x3f) << shift) - bias;
388
s[ 9] = s[ 8] + ((((b[ 6] << 2) | (b[ 7] >> 6)) & 0x3f) << shift) - bias;
389
s[13] = s[12] + ((b[ 7] & 0x3f) << shift) - bias;
391
s[ 2] = s[ 1] + ((b[ 8] >> 2) << shift) - bias;
392
s[ 6] = s[ 5] + ((((b[ 8] << 4) | (b[ 9] >> 4)) & 0x3f) << shift) - bias;
393
s[10] = s[ 9] + ((((b[ 9] << 2) | (b[10] >> 6)) & 0x3f) << shift) - bias;
394
s[14] = s[13] + ((b[10] & 0x3f) << shift) - bias;
396
s[ 3] = s[ 2] + ((b[11] >> 2) << shift) - bias;
397
s[ 7] = s[ 6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3f) << shift) - bias;
398
s[11] = s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3f) << shift) - bias;
399
s[15] = s[14] + ((b[13] & 0x3f) << shift) - bias;
401
for (int i = 0; i < 16; ++i)
413
unpack3 (const unsigned char b[3], unsigned short s[16])
416
// Unpack a 3-byte block into 4 by 4 identical 16-bit pixels.
420
assert (b[2] == 0xfc);
423
s[0] = (b[0] << 8) | b[1];
430
for (int i = 1; i < 16; ++i)
438
throw Iex::InputExc ("Error decompressing data "
439
"(input data are shorter than expected).");
446
throw Iex::InputExc ("Error decompressing data "
447
"(input data are longer than expected).");
453
struct B44Compressor::ChannelData
455
unsigned short * start;
456
unsigned short * end;
466
B44Compressor::B44Compressor
473
_maxScanLineSize (maxScanLineSize),
474
_optFlatFields (optFlatFields),
476
_numScanLines (numScanLines),
480
_channels (hdr.channels()),
484
// Allocate buffers for compressed an uncompressed pixel data,
485
// allocate a set of ChannelData structs to help speed up the
486
// compress() and uncompress() functions, below, and determine
487
// if uncompressed pixel data should be in native or Xdr format.
490
_tmpBuffer = new unsigned short [maxScanLineSize * numScanLines];
492
const ChannelList &channels = header().channels();
493
int numHalfChans = 0;
495
for (ChannelList::ConstIterator c = channels.begin();
499
assert (pixelTypeSize (c.channel().type) % pixelTypeSize (HALF) == 0);
502
if (c.channel().type == HALF)
507
// Compressed data may be larger than the input data
510
int padding = 12 * numHalfChans * (numScanLines + 3) / 4;
512
_outBuffer = new char [maxScanLineSize * numScanLines + padding];
513
_channelData = new ChannelData[_numChans];
517
for (ChannelList::ConstIterator c = channels.begin();
521
_channelData[i].ys = c.channel().ySampling;
522
_channelData[i].type = c.channel().type;
523
_channelData[i].pLinear = c.channel().pLinear;
524
_channelData[i].size =
525
pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);
528
const Box2i &dataWindow = hdr.dataWindow();
530
_minX = dataWindow.min.x;
531
_maxX = dataWindow.max.x;
532
_maxY = dataWindow.max.y;
535
// We can support uncompressed data in the machine's native
536
// format only if all image channels are of type HALF.
539
assert (sizeof (unsigned short) == pixelTypeSize (HALF));
541
if (_numChans == numHalfChans)
546
B44Compressor::~B44Compressor ()
548
delete [] _tmpBuffer;
549
delete [] _outBuffer;
550
delete [] _channelData;
555
B44Compressor::numScanLines () const
557
return _numScanLines;
562
B44Compressor::format () const
569
B44Compressor::compress (const char *inPtr,
574
return compress (inPtr,
576
Box2i (V2i (_minX, minY),
577
V2i (_maxX, minY + numScanLines() - 1)),
583
B44Compressor::compressTile (const char *inPtr,
588
return compress (inPtr, inSize, range, outPtr);
593
B44Compressor::uncompress (const char *inPtr,
598
return uncompress (inPtr,
600
Box2i (V2i (_minX, minY),
601
V2i (_maxX, minY + numScanLines() - 1)),
607
B44Compressor::uncompressTile (const char *inPtr,
612
return uncompress (inPtr, inSize, range, outPtr);
617
B44Compressor::compress (const char *inPtr,
623
// Compress a block of pixel data: First copy the input pixels
624
// from the input buffer into _tmpBuffer, rearranging them such
625
// that blocks of 4x4 pixels of a single channel can be accessed
626
// conveniently. Then compress each 4x4 block of HALF pixel data
627
// and append the result to the output buffer. Copy UINT and
628
// FLOAT data to the output buffer without compressing them.
636
// Special case - empty input buffer.
643
// For each channel, detemine how many pixels are stored
644
// in the input buffer, and where those pixels will be
645
// placed in _tmpBuffer.
648
int minX = range.min.x;
649
int maxX = min (range.max.x, _maxX);
650
int minY = range.min.y;
651
int maxY = min (range.max.y, _maxY);
653
unsigned short *tmpBufferEnd = _tmpBuffer;
656
for (ChannelList::ConstIterator c = _channels.begin();
657
c != _channels.end();
660
ChannelData &cd = _channelData[i];
662
cd.start = tmpBufferEnd;
665
cd.nx = numSamples (c.channel().xSampling, minX, maxX);
666
cd.ny = numSamples (c.channel().ySampling, minY, maxY);
668
tmpBufferEnd += cd.nx * cd.ny * cd.size;
674
// The data in the input buffer are in the machine-independent
675
// Xdr format. Copy the HALF channels into _tmpBuffer and
676
// convert them back into native format for compression.
677
// Copy UINT and FLOAT channels verbatim into _tmpBuffer.
680
for (int y = minY; y <= maxY; ++y)
682
for (int i = 0; i < _numChans; ++i)
684
ChannelData &cd = _channelData[i];
686
if (modp (y, cd.ys) != 0)
691
for (int x = cd.nx; x > 0; --x)
693
Xdr::read <CharPtrIO> (inPtr, *cd.end);
699
int n = cd.nx * cd.size;
700
memcpy (cd.end, inPtr, n * sizeof (unsigned short));
701
inPtr += n * sizeof (unsigned short);
710
// The input buffer contains only HALF channels, and they
711
// are in native, machine-dependent format. Copy the pixels
715
for (int y = minY; y <= maxY; ++y)
717
for (int i = 0; i < _numChans; ++i)
719
ChannelData &cd = _channelData[i];
722
assert (cd.type == HALF);
725
if (modp (y, cd.ys) != 0)
728
int n = cd.nx * cd.size;
729
memcpy (cd.end, inPtr, n * sizeof (unsigned short));
730
inPtr += n * sizeof (unsigned short);
737
// The pixels for each channel have been packed into a contiguous
738
// block in _tmpBuffer. HALF channels are in native format; UINT
739
// and FLOAT channels are in Xdr format.
744
for (int i = 1; i < _numChans; ++i)
745
assert (_channelData[i-1].end == _channelData[i].start);
747
assert (_channelData[_numChans-1].end == tmpBufferEnd);
752
// For each HALF channel, split the data in _tmpBuffer into 4x4
753
// pixel blocks. Compress each block and append the compressed
754
// data to the output buffer.
756
// UINT and FLOAT channels are copied from _tmpBuffer into the
757
// output buffer without further processing.
760
char *outEnd = _outBuffer;
762
for (int i = 0; i < _numChans; ++i)
764
ChannelData &cd = _channelData[i];
769
// UINT or FLOAT channel.
772
int n = cd.nx * cd.ny * cd.size * sizeof (unsigned short);
773
memcpy (outEnd, cd.start, n);
783
for (int y = 0; y < cd.ny; y += 4)
786
// Copy the next 4x4 pixel block into array s.
787
// If the width, cd.nx, or the height, cd.ny, of
788
// the pixel data in _tmpBuffer is not divisible
789
// by 4, then pad the data by repeating the
790
// rightmost column and the bottom row.
793
unsigned short *row0 = cd.start + y * cd.nx;
794
unsigned short *row1 = row0 + cd.nx;
795
unsigned short *row2 = row1 + cd.nx;
796
unsigned short *row3 = row2 + cd.nx;
809
for (int x = 0; x < cd.nx; x += 4)
811
unsigned short s[16];
817
for (int i = 0; i < 4; ++i)
819
int j = min (i, n - 1);
829
memcpy (&s[ 0], row0, 4 * sizeof (unsigned short));
830
memcpy (&s[ 4], row1, 4 * sizeof (unsigned short));
831
memcpy (&s[ 8], row2, 4 * sizeof (unsigned short));
832
memcpy (&s[12], row3, 4 * sizeof (unsigned short));
841
// Compress the contents of array s and append the
842
// results to the output buffer.
846
convertFromLinear (s);
848
outEnd += pack (s, (unsigned char *) outEnd,
849
_optFlatFields, !cd.pLinear);
854
return outEnd - _outBuffer;
859
B44Compressor::uncompress (const char *inPtr,
865
// This function is the reverse of the compress() function,
866
// above. First all pixels are moved from the input buffer
867
// into _tmpBuffer. UINT and FLOAT channels are copied
868
// verbatim; HALF channels are uncompressed in blocks of
869
// 4x4 pixels. Then the pixels in _tmpBuffer are copied
870
// into the output buffer and rearranged such that the data
871
// for for each scan line form a contiguous block.
881
int minX = range.min.x;
882
int maxX = min (range.max.x, _maxX);
883
int minY = range.min.y;
884
int maxY = min (range.max.y, _maxY);
886
unsigned short *tmpBufferEnd = _tmpBuffer;
889
for (ChannelList::ConstIterator c = _channels.begin();
890
c != _channels.end();
893
ChannelData &cd = _channelData[i];
895
cd.start = tmpBufferEnd;
898
cd.nx = numSamples (c.channel().xSampling, minX, maxX);
899
cd.ny = numSamples (c.channel().ySampling, minY, maxY);
901
tmpBufferEnd += cd.nx * cd.ny * cd.size;
904
for (int i = 0; i < _numChans; ++i)
906
ChannelData &cd = _channelData[i];
911
// UINT or FLOAT channel.
914
int n = cd.nx * cd.ny * cd.size * sizeof (unsigned short);
919
memcpy (cd.start, inPtr, n);
930
for (int y = 0; y < cd.ny; y += 4)
932
unsigned short *row0 = cd.start + y * cd.nx;
933
unsigned short *row1 = row0 + cd.nx;
934
unsigned short *row2 = row1 + cd.nx;
935
unsigned short *row3 = row2 + cd.nx;
937
for (int x = 0; x < cd.nx; x += 4)
939
unsigned short s[16];
944
if (((const unsigned char *)inPtr)[2] == 0xfc)
946
unpack3 ((const unsigned char *)inPtr, s);
955
unpack14 ((const unsigned char *)inPtr, s);
963
int n = (x + 3 < cd.nx)?
964
4 * sizeof (unsigned short) :
965
(cd.nx - x) * sizeof (unsigned short);
969
memcpy (row0, &s[ 0], n);
970
memcpy (row1, &s[ 4], n);
971
memcpy (row2, &s[ 8], n);
972
memcpy (row3, &s[12], n);
976
memcpy (row0, &s[ 0], n);
979
memcpy (row1, &s[ 4], n);
982
memcpy (row2, &s[ 8], n);
993
char *outEnd = _outBuffer;
997
for (int y = minY; y <= maxY; ++y)
999
for (int i = 0; i < _numChans; ++i)
1001
ChannelData &cd = _channelData[i];
1003
if (modp (y, cd.ys) != 0)
1006
if (cd.type == HALF)
1008
for (int x = cd.nx; x > 0; --x)
1010
Xdr::write <CharPtrIO> (outEnd, *cd.end);
1016
int n = cd.nx * cd.size;
1017
memcpy (outEnd, cd.end, n * sizeof (unsigned short));
1018
outEnd += n * sizeof (unsigned short);
1026
for (int y = minY; y <= maxY; ++y)
1028
for (int i = 0; i < _numChans; ++i)
1030
ChannelData &cd = _channelData[i];
1033
assert (cd.type == HALF);
1036
if (modp (y, cd.ys) != 0)
1039
int n = cd.nx * cd.size;
1040
memcpy (outEnd, cd.end, n * sizeof (unsigned short));
1041
outEnd += n * sizeof (unsigned short);
1049
for (int i = 1; i < _numChans; ++i)
1050
assert (_channelData[i-1].end == _channelData[i].start);
1052
assert (_channelData[_numChans-1].end == tmpBufferEnd);
1059
outPtr = _outBuffer;
1060
return outEnd - _outBuffer;
1
///////////////////////////////////////////////////////////////////////////
3
// Copyright (c) 2006, Industrial Light & Magic, a division of Lucas
6
// All rights reserved.
8
// Redistribution and use in source and binary forms, with or without
9
// modification, are permitted provided that the following conditions are
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
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.
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.
33
///////////////////////////////////////////////////////////////////////////
36
//-----------------------------------------------------------------------------
38
// class B44Compressor
40
// This compressor is lossy for HALF channels; the compression rate
41
// is fixed at 32/14 (approximately 2.28). FLOAT and UINT channels
42
// are not compressed; their data are preserved exactly.
44
// Each HALF channel is split into blocks of 4 by 4 pixels. An
45
// uncompressed block occupies 32 bytes, which are re-interpreted
46
// as sixteen 16-bit unsigned integers, t[0] ... t[15]. Compression
47
// shrinks the block to 14 bytes. The compressed 14-byte block
52
// - a 6-bit shift value
54
// - 15 densely packed 6-bit values, r[0] ... r[14], which are
55
// computed by subtracting adjacent pixel values and right-
56
// shifting the differences according to the stored shift value.
58
// Differences between adjacent pixels are computed according
59
// to the following diagram:
61
// 0 --------> 1 --------> 2 --------> 3
67
// 4 --------> 5 --------> 6 --------> 7
73
// 8 --------> 9 --------> 10 --------> 11
79
// 12 --------> 13 --------> 14 --------> 15
87
// means that r[8] is the difference between t[5] and t[6].
89
// - optionally, a 4-by-4 pixel block where all pixels have the
90
// same value can be treated as a special case, where the
91
// compressed block contains only 3 instead of 14 bytes:
92
// t[0], followed by an "impossible" 6-bit shift value and
95
// This compressor can handle positive and negative pixel values.
96
// NaNs and infinities are replaced with zeroes before compression.
98
//-----------------------------------------------------------------------------
100
#include <ImfB44Compressor.h>
101
#include <ImfHeader.h>
102
#include <ImfChannelList.h>
104
#include <ImathFun.h>
105
#include <ImathBox.h>
130
#include "b44ExpLogTable.h"
134
convertFromLinear (unsigned short s[16])
136
for (int i = 0; i < 16; ++i)
137
s[i] = expTable[s[i]];
142
convertToLinear (unsigned short s[16])
144
for (int i = 0; i < 16; ++i)
145
s[i] = logTable[s[i]];
150
shiftAndRound (int x, int shift)
155
// y = x * pow (2, -shift),
157
// then round y to the nearest integer.
158
// In case of a tie, where y is exactly
159
// halfway between two integers, round
164
int a = (1 << shift) - 1;
166
int b = (x >> shift) & 1;
167
return (x + a + b) >> shift;
172
pack (const unsigned short s[16],
178
// Pack a block of 4 by 4 16-bit pixels (32 bytes) into
179
// either 14 or 3 bytes.
183
// Integers s[0] ... s[15] represent floating-point numbers
184
// in what is essentially a sign-magnitude format. Convert
185
// s[0] .. s[15] into a new set of integers, t[0] ... t[15],
186
// such that if t[i] is greater than t[j], the floating-point
187
// number that corresponds to s[i] is always greater than
188
// the floating-point number that corresponds to s[j].
190
// Also, replace any bit patterns that represent NaNs or
191
// infinities with bit patterns that represent floating-point
194
// bit pattern floating-point bit pattern
195
// in s[i] value in t[i]
201
// 0x7c00 +infinity 0x8000
202
// 0x7bff +HALF_MAX 0xfbff
206
// 0x0002 +2 * HALF_MIN 0x8002
207
// 0x0001 +HALF_MIN 0x8001
208
// 0x0000 +0.0 0x8000
209
// 0x8000 -0.0 0x7fff
210
// 0x8001 -HALF_MIN 0x7ffe
211
// 0x8002 -2 * HALF_MIN 0x7ffd
215
// 0xfbff -HALF_MAX 0x0400
216
// 0xfc00 -infinity 0x8000
223
unsigned short t[16];
225
for (int i = 0; i < 16; ++i)
227
if ((s[i] & 0x7c00) == 0x7c00)
229
else if (s[i] & 0x8000)
232
t[i] = s[i] | 0x8000;
236
// Find the maximum, tMax, of t[0] ... t[15].
239
unsigned short tMax = 0;
241
for (int i = 0; i < 16; ++i)
246
// Compute a set of running differences, r[0] ... r[14]:
247
// Find a shift value such that after rounding off the
248
// rightmost bits and shifting all differenes are between
249
// -32 and +31. Then bias the differences so that they
250
// end up between 0 and 63.
259
const int bias = 0x20;
266
// Compute absolute differences, d[0] ... d[15],
267
// between tMax and t[0] ... t[15].
269
// Shift and round the absolute differences.
272
for (int i = 0; i < 16; ++i)
273
d[i] = shiftAndRound (tMax - t[i], shift);
276
// Convert d[0] .. d[15] into running differences
279
r[ 0] = d[ 0] - d[ 4] + bias;
280
r[ 1] = d[ 4] - d[ 8] + bias;
281
r[ 2] = d[ 8] - d[12] + bias;
283
r[ 3] = d[ 0] - d[ 1] + bias;
284
r[ 4] = d[ 4] - d[ 5] + bias;
285
r[ 5] = d[ 8] - d[ 9] + bias;
286
r[ 6] = d[12] - d[13] + bias;
288
r[ 7] = d[ 1] - d[ 2] + bias;
289
r[ 8] = d[ 5] - d[ 6] + bias;
290
r[ 9] = d[ 9] - d[10] + bias;
291
r[10] = d[13] - d[14] + bias;
293
r[11] = d[ 2] - d[ 3] + bias;
294
r[12] = d[ 6] - d[ 7] + bias;
295
r[13] = d[10] - d[11] + bias;
296
r[14] = d[14] - d[15] + bias;
301
for (int i = 1; i < 15; ++i)
310
while (rMin < 0 || rMax > 0x3f);
312
if (rMin == bias && rMax == bias && optFlatFields)
315
// Special case - all pixels have the same value.
316
// We encode this in 3 instead of 14 bytes by
317
// storing the value 0xfc in the third output byte,
318
// which cannot occur in the 14-byte encoding.
331
// Adjust t[0] so that the pixel whose value is equal
332
// to tMax gets represented as accurately as possible.
335
t[0] = tMax - (d[0] << shift);
339
// Pack t[0], shift and r[0] ... r[14] into 14 bytes:
345
b[ 2] = (unsigned char) ((shift << 2) | (r[ 0] >> 4));
346
b[ 3] = (unsigned char) ((r[ 0] << 4) | (r[ 1] >> 2));
347
b[ 4] = (unsigned char) ((r[ 1] << 6) | r[ 2] );
349
b[ 5] = (unsigned char) ((r[ 3] << 2) | (r[ 4] >> 4));
350
b[ 6] = (unsigned char) ((r[ 4] << 4) | (r[ 5] >> 2));
351
b[ 7] = (unsigned char) ((r[ 5] << 6) | r[ 6] );
353
b[ 8] = (unsigned char) ((r[ 7] << 2) | (r[ 8] >> 4));
354
b[ 9] = (unsigned char) ((r[ 8] << 4) | (r[ 9] >> 2));
355
b[10] = (unsigned char) ((r[ 9] << 6) | r[10] );
357
b[11] = (unsigned char) ((r[11] << 2) | (r[12] >> 4));
358
b[12] = (unsigned char) ((r[12] << 4) | (r[13] >> 2));
359
b[13] = (unsigned char) ((r[13] << 6) | r[14] );
367
unpack14 (const unsigned char b[14], unsigned short s[16])
370
// Unpack a 14-byte block into 4 by 4 16-bit pixels.
374
assert (b[2] != 0xfc);
377
s[ 0] = (b[0] << 8) | b[1];
379
unsigned short shift = (b[ 2] >> 2);
380
unsigned short bias = (0x20 << shift);
382
s[ 4] = s[ 0] + ((((b[ 2] << 4) | (b[ 3] >> 4)) & 0x3f) << shift) - bias;
383
s[ 8] = s[ 4] + ((((b[ 3] << 2) | (b[ 4] >> 6)) & 0x3f) << shift) - bias;
384
s[12] = s[ 8] + ((b[ 4] & 0x3f) << shift) - bias;
386
s[ 1] = s[ 0] + ((b[ 5] >> 2) << shift) - bias;
387
s[ 5] = s[ 4] + ((((b[ 5] << 4) | (b[ 6] >> 4)) & 0x3f) << shift) - bias;
388
s[ 9] = s[ 8] + ((((b[ 6] << 2) | (b[ 7] >> 6)) & 0x3f) << shift) - bias;
389
s[13] = s[12] + ((b[ 7] & 0x3f) << shift) - bias;
391
s[ 2] = s[ 1] + ((b[ 8] >> 2) << shift) - bias;
392
s[ 6] = s[ 5] + ((((b[ 8] << 4) | (b[ 9] >> 4)) & 0x3f) << shift) - bias;
393
s[10] = s[ 9] + ((((b[ 9] << 2) | (b[10] >> 6)) & 0x3f) << shift) - bias;
394
s[14] = s[13] + ((b[10] & 0x3f) << shift) - bias;
396
s[ 3] = s[ 2] + ((b[11] >> 2) << shift) - bias;
397
s[ 7] = s[ 6] + ((((b[11] << 4) | (b[12] >> 4)) & 0x3f) << shift) - bias;
398
s[11] = s[10] + ((((b[12] << 2) | (b[13] >> 6)) & 0x3f) << shift) - bias;
399
s[15] = s[14] + ((b[13] & 0x3f) << shift) - bias;
401
for (int i = 0; i < 16; ++i)
413
unpack3 (const unsigned char b[3], unsigned short s[16])
416
// Unpack a 3-byte block into 4 by 4 identical 16-bit pixels.
420
assert (b[2] == 0xfc);
423
s[0] = (b[0] << 8) | b[1];
430
for (int i = 1; i < 16; ++i)
438
throw Iex::InputExc ("Error decompressing data "
439
"(input data are shorter than expected).");
446
throw Iex::InputExc ("Error decompressing data "
447
"(input data are longer than expected).");
453
struct B44Compressor::ChannelData
455
unsigned short * start;
456
unsigned short * end;
466
B44Compressor::B44Compressor
473
_maxScanLineSize (maxScanLineSize),
474
_optFlatFields (optFlatFields),
476
_numScanLines (numScanLines),
480
_channels (hdr.channels()),
484
// Allocate buffers for compressed an uncompressed pixel data,
485
// allocate a set of ChannelData structs to help speed up the
486
// compress() and uncompress() functions, below, and determine
487
// if uncompressed pixel data should be in native or Xdr format.
490
_tmpBuffer = new unsigned short [maxScanLineSize * numScanLines];
492
const ChannelList &channels = header().channels();
493
int numHalfChans = 0;
495
for (ChannelList::ConstIterator c = channels.begin();
499
assert (pixelTypeSize (c.channel().type) % pixelTypeSize (HALF) == 0);
502
if (c.channel().type == HALF)
507
// Compressed data may be larger than the input data
510
int padding = 12 * numHalfChans * (numScanLines + 3) / 4;
512
_outBuffer = new char [maxScanLineSize * numScanLines + padding];
513
_channelData = new ChannelData[_numChans];
517
for (ChannelList::ConstIterator c = channels.begin();
521
_channelData[i].ys = c.channel().ySampling;
522
_channelData[i].type = c.channel().type;
523
_channelData[i].pLinear = c.channel().pLinear;
524
_channelData[i].size =
525
pixelTypeSize (c.channel().type) / pixelTypeSize (HALF);
528
const Box2i &dataWindow = hdr.dataWindow();
530
_minX = dataWindow.min.x;
531
_maxX = dataWindow.max.x;
532
_maxY = dataWindow.max.y;
535
// We can support uncompressed data in the machine's native
536
// format only if all image channels are of type HALF.
539
assert (sizeof (unsigned short) == pixelTypeSize (HALF));
541
if (_numChans == numHalfChans)
546
B44Compressor::~B44Compressor ()
548
delete [] _tmpBuffer;
549
delete [] _outBuffer;
550
delete [] _channelData;
555
B44Compressor::numScanLines () const
557
return _numScanLines;
562
B44Compressor::format () const
569
B44Compressor::compress (const char *inPtr,
574
return compress (inPtr,
576
Box2i (V2i (_minX, minY),
577
V2i (_maxX, minY + numScanLines() - 1)),
583
B44Compressor::compressTile (const char *inPtr,
588
return compress (inPtr, inSize, range, outPtr);
593
B44Compressor::uncompress (const char *inPtr,
598
return uncompress (inPtr,
600
Box2i (V2i (_minX, minY),
601
V2i (_maxX, minY + numScanLines() - 1)),
607
B44Compressor::uncompressTile (const char *inPtr,
612
return uncompress (inPtr, inSize, range, outPtr);
617
B44Compressor::compress (const char *inPtr,
623
// Compress a block of pixel data: First copy the input pixels
624
// from the input buffer into _tmpBuffer, rearranging them such
625
// that blocks of 4x4 pixels of a single channel can be accessed
626
// conveniently. Then compress each 4x4 block of HALF pixel data
627
// and append the result to the output buffer. Copy UINT and
628
// FLOAT data to the output buffer without compressing them.
636
// Special case - empty input buffer.
643
// For each channel, detemine how many pixels are stored
644
// in the input buffer, and where those pixels will be
645
// placed in _tmpBuffer.
648
int minX = range.min.x;
649
int maxX = min (range.max.x, _maxX);
650
int minY = range.min.y;
651
int maxY = min (range.max.y, _maxY);
653
unsigned short *tmpBufferEnd = _tmpBuffer;
656
for (ChannelList::ConstIterator c = _channels.begin();
657
c != _channels.end();
660
ChannelData &cd = _channelData[i];
662
cd.start = tmpBufferEnd;
665
cd.nx = numSamples (c.channel().xSampling, minX, maxX);
666
cd.ny = numSamples (c.channel().ySampling, minY, maxY);
668
tmpBufferEnd += cd.nx * cd.ny * cd.size;
674
// The data in the input buffer are in the machine-independent
675
// Xdr format. Copy the HALF channels into _tmpBuffer and
676
// convert them back into native format for compression.
677
// Copy UINT and FLOAT channels verbatim into _tmpBuffer.
680
for (int y = minY; y <= maxY; ++y)
682
for (int i = 0; i < _numChans; ++i)
684
ChannelData &cd = _channelData[i];
686
if (modp (y, cd.ys) != 0)
691
for (int x = cd.nx; x > 0; --x)
693
Xdr::read <CharPtrIO> (inPtr, *cd.end);
699
int n = cd.nx * cd.size;
700
memcpy (cd.end, inPtr, n * sizeof (unsigned short));
701
inPtr += n * sizeof (unsigned short);
710
// The input buffer contains only HALF channels, and they
711
// are in native, machine-dependent format. Copy the pixels
715
for (int y = minY; y <= maxY; ++y)
717
for (int i = 0; i < _numChans; ++i)
719
ChannelData &cd = _channelData[i];
722
assert (cd.type == HALF);
725
if (modp (y, cd.ys) != 0)
728
int n = cd.nx * cd.size;
729
memcpy (cd.end, inPtr, n * sizeof (unsigned short));
730
inPtr += n * sizeof (unsigned short);
737
// The pixels for each channel have been packed into a contiguous
738
// block in _tmpBuffer. HALF channels are in native format; UINT
739
// and FLOAT channels are in Xdr format.
744
for (int i = 1; i < _numChans; ++i)
745
assert (_channelData[i-1].end == _channelData[i].start);
747
assert (_channelData[_numChans-1].end == tmpBufferEnd);
752
// For each HALF channel, split the data in _tmpBuffer into 4x4
753
// pixel blocks. Compress each block and append the compressed
754
// data to the output buffer.
756
// UINT and FLOAT channels are copied from _tmpBuffer into the
757
// output buffer without further processing.
760
char *outEnd = _outBuffer;
762
for (int i = 0; i < _numChans; ++i)
764
ChannelData &cd = _channelData[i];
769
// UINT or FLOAT channel.
772
int n = cd.nx * cd.ny * cd.size * sizeof (unsigned short);
773
memcpy (outEnd, cd.start, n);
783
for (int y = 0; y < cd.ny; y += 4)
786
// Copy the next 4x4 pixel block into array s.
787
// If the width, cd.nx, or the height, cd.ny, of
788
// the pixel data in _tmpBuffer is not divisible
789
// by 4, then pad the data by repeating the
790
// rightmost column and the bottom row.
793
unsigned short *row0 = cd.start + y * cd.nx;
794
unsigned short *row1 = row0 + cd.nx;
795
unsigned short *row2 = row1 + cd.nx;
796
unsigned short *row3 = row2 + cd.nx;
809
for (int x = 0; x < cd.nx; x += 4)
811
unsigned short s[16];
817
for (int i = 0; i < 4; ++i)
819
int j = min (i, n - 1);
829
memcpy (&s[ 0], row0, 4 * sizeof (unsigned short));
830
memcpy (&s[ 4], row1, 4 * sizeof (unsigned short));
831
memcpy (&s[ 8], row2, 4 * sizeof (unsigned short));
832
memcpy (&s[12], row3, 4 * sizeof (unsigned short));
841
// Compress the contents of array s and append the
842
// results to the output buffer.
846
convertFromLinear (s);
848
outEnd += pack (s, (unsigned char *) outEnd,
849
_optFlatFields, !cd.pLinear);
854
return outEnd - _outBuffer;
859
B44Compressor::uncompress (const char *inPtr,
865
// This function is the reverse of the compress() function,
866
// above. First all pixels are moved from the input buffer
867
// into _tmpBuffer. UINT and FLOAT channels are copied
868
// verbatim; HALF channels are uncompressed in blocks of
869
// 4x4 pixels. Then the pixels in _tmpBuffer are copied
870
// into the output buffer and rearranged such that the data
871
// for for each scan line form a contiguous block.
881
int minX = range.min.x;
882
int maxX = min (range.max.x, _maxX);
883
int minY = range.min.y;
884
int maxY = min (range.max.y, _maxY);
886
unsigned short *tmpBufferEnd = _tmpBuffer;
889
for (ChannelList::ConstIterator c = _channels.begin();
890
c != _channels.end();
893
ChannelData &cd = _channelData[i];
895
cd.start = tmpBufferEnd;
898
cd.nx = numSamples (c.channel().xSampling, minX, maxX);
899
cd.ny = numSamples (c.channel().ySampling, minY, maxY);
901
tmpBufferEnd += cd.nx * cd.ny * cd.size;
904
for (int i = 0; i < _numChans; ++i)
906
ChannelData &cd = _channelData[i];
911
// UINT or FLOAT channel.
914
int n = cd.nx * cd.ny * cd.size * sizeof (unsigned short);
919
memcpy (cd.start, inPtr, n);
930
for (int y = 0; y < cd.ny; y += 4)
932
unsigned short *row0 = cd.start + y * cd.nx;
933
unsigned short *row1 = row0 + cd.nx;
934
unsigned short *row2 = row1 + cd.nx;
935
unsigned short *row3 = row2 + cd.nx;
937
for (int x = 0; x < cd.nx; x += 4)
939
unsigned short s[16];
944
if (((const unsigned char *)inPtr)[2] == 0xfc)
946
unpack3 ((const unsigned char *)inPtr, s);
955
unpack14 ((const unsigned char *)inPtr, s);
963
int n = (x + 3 < cd.nx)?
964
4 * sizeof (unsigned short) :
965
(cd.nx - x) * sizeof (unsigned short);
969
memcpy (row0, &s[ 0], n);
970
memcpy (row1, &s[ 4], n);
971
memcpy (row2, &s[ 8], n);
972
memcpy (row3, &s[12], n);
976
memcpy (row0, &s[ 0], n);
979
memcpy (row1, &s[ 4], n);
982
memcpy (row2, &s[ 8], n);
993
char *outEnd = _outBuffer;
997
for (int y = minY; y <= maxY; ++y)
999
for (int i = 0; i < _numChans; ++i)
1001
ChannelData &cd = _channelData[i];
1003
if (modp (y, cd.ys) != 0)
1006
if (cd.type == HALF)
1008
for (int x = cd.nx; x > 0; --x)
1010
Xdr::write <CharPtrIO> (outEnd, *cd.end);
1016
int n = cd.nx * cd.size;
1017
memcpy (outEnd, cd.end, n * sizeof (unsigned short));
1018
outEnd += n * sizeof (unsigned short);
1026
for (int y = minY; y <= maxY; ++y)
1028
for (int i = 0; i < _numChans; ++i)
1030
ChannelData &cd = _channelData[i];
1033
assert (cd.type == HALF);
1036
if (modp (y, cd.ys) != 0)
1039
int n = cd.nx * cd.size;
1040
memcpy (outEnd, cd.end, n * sizeof (unsigned short));
1041
outEnd += n * sizeof (unsigned short);
1049
for (int i = 1; i < _numChans; ++i)
1050
assert (_channelData[i-1].end == _channelData[i].start);
1052
assert (_channelData[_numChans-1].end == tmpBufferEnd);
1059
outPtr = _outBuffer;
1060
return outEnd - _outBuffer;
added
removed
Source/OpenEXR/IlmImf/ImfB44Compressor.cpp
