1 /* -*- C++ -*-
2 * Copyright 2019-2020 LibRaw LLC (info@libraw.org)
3 *
4 LibRaw is free software; you can redistribute it and/or modify
5 it under the terms of the one of two licenses as you choose:
6
7 1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
8 (See file LICENSE.LGPL provided in LibRaw distribution archive for details).
9
10 2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
11 (See file LICENSE.CDDL provided in LibRaw distribution archive for details).
12
13 */
14
15 #include "../../internal/libraw_cxx_defs.h"
16
17 #ifdef USE_ZLIB
__DNG_HalfToFloat(ushort halfValue)18 inline unsigned int __DNG_HalfToFloat(ushort halfValue)
19 {
20 int sign = (halfValue >> 15) & 0x00000001;
21 int exponent = (halfValue >> 10) & 0x0000001f;
22 int mantissa = halfValue & 0x000003ff;
23 if (exponent == 0)
24 {
25 if (mantissa == 0)
26 {
27 return (unsigned int)(sign << 31);
28 }
29 else
30 {
31 while (!(mantissa & 0x00000400))
32 {
33 mantissa <<= 1;
34 exponent -= 1;
35 }
36 exponent += 1;
37 mantissa &= ~0x00000400;
38 }
39 }
40 else if (exponent == 31)
41 {
42 if (mantissa == 0)
43 {
44 return (unsigned int)((sign << 31) | ((0x1eL + 127 - 15) << 23) |
45 (0x3ffL << 13));
46 }
47 else
48 {
49 return 0;
50 }
51 }
52 exponent += (127 - 15);
53 mantissa <<= 13;
54 return (unsigned int)((sign << 31) | (exponent << 23) | mantissa);
55 }
56
__DNG_FP24ToFloat(const unsigned char * input)57 inline unsigned int __DNG_FP24ToFloat(const unsigned char *input)
58 {
59 int sign = (input[0] >> 7) & 0x01;
60 int exponent = (input[0]) & 0x7F;
61 int mantissa = (((int)input[1]) << 8) | input[2];
62 if (exponent == 0)
63 {
64 if (mantissa == 0)
65 {
66 return (unsigned int)(sign << 31);
67 }
68 else
69 {
70 while (!(mantissa & 0x00010000))
71 {
72 mantissa <<= 1;
73 exponent -= 1;
74 }
75 exponent += 1;
76 mantissa &= ~0x00010000;
77 }
78 }
79 else if (exponent == 127)
80 {
81 if (mantissa == 0)
82 {
83 return (unsigned int)((sign << 31) | ((0x7eL + 128 - 64) << 23) |
84 (0xffffL << 7));
85 }
86 else
87 {
88 // Nan -- Just set to zero.
89 return 0;
90 }
91 }
92 exponent += (128 - 64);
93 mantissa <<= 7;
94 return (uint32_t)((sign << 31) | (exponent << 23) | mantissa);
95 }
96
DecodeDeltaBytes(unsigned char * bytePtr,int cols,int channels)97 inline void DecodeDeltaBytes(unsigned char *bytePtr, int cols, int channels)
98 {
99 if (channels == 1)
100 {
101 unsigned char b0 = bytePtr[0];
102 bytePtr += 1;
103 for (uint32_t col = 1; col < cols; ++col)
104 {
105 b0 += bytePtr[0];
106 bytePtr[0] = b0;
107 bytePtr += 1;
108 }
109 }
110 else if (channels == 3)
111 {
112 unsigned char b0 = bytePtr[0];
113 unsigned char b1 = bytePtr[1];
114 unsigned char b2 = bytePtr[2];
115 bytePtr += 3;
116 for (int col = 1; col < cols; ++col)
117 {
118 b0 += bytePtr[0];
119 b1 += bytePtr[1];
120 b2 += bytePtr[2];
121 bytePtr[0] = b0;
122 bytePtr[1] = b1;
123 bytePtr[2] = b2;
124 bytePtr += 3;
125 }
126 }
127 else if (channels == 4)
128 {
129 unsigned char b0 = bytePtr[0];
130 unsigned char b1 = bytePtr[1];
131 unsigned char b2 = bytePtr[2];
132 unsigned char b3 = bytePtr[3];
133 bytePtr += 4;
134 for (uint32_t col = 1; col < cols; ++col)
135 {
136 b0 += bytePtr[0];
137 b1 += bytePtr[1];
138 b2 += bytePtr[2];
139 b3 += bytePtr[3];
140 bytePtr[0] = b0;
141 bytePtr[1] = b1;
142 bytePtr[2] = b2;
143 bytePtr[3] = b3;
144 bytePtr += 4;
145 }
146 }
147 else
148 {
149 for (int col = 1; col < cols; ++col)
150 {
151 for (int chan = 0; chan < channels; ++chan)
152 {
153 bytePtr[chan + channels] += bytePtr[chan];
154 }
155 bytePtr += channels;
156 }
157 }
158 }
159
DecodeFPDelta(unsigned char * input,unsigned char * output,int cols,int channels,int bytesPerSample)160 static void DecodeFPDelta(unsigned char *input, unsigned char *output, int cols,
161 int channels, int bytesPerSample)
162 {
163 DecodeDeltaBytes(input, cols * bytesPerSample, channels);
164 int32_t rowIncrement = cols * channels;
165
166 if (bytesPerSample == 2)
167 {
168
169 #if LibRawBigEndian
170 const unsigned char *input0 = input;
171 const unsigned char *input1 = input + rowIncrement;
172 #else
173 const unsigned char *input1 = input;
174 const unsigned char *input0 = input + rowIncrement;
175 #endif
176 for (int col = 0; col < rowIncrement; ++col)
177 {
178 output[0] = input0[col];
179 output[1] = input1[col];
180 output += 2;
181 }
182 }
183 else if (bytesPerSample == 3)
184 {
185 const unsigned char *input0 = input;
186 const unsigned char *input1 = input + rowIncrement;
187 const unsigned char *input2 = input + rowIncrement * 2;
188 for (int col = 0; col < rowIncrement; ++col)
189 {
190 output[0] = input0[col];
191 output[1] = input1[col];
192 output[2] = input2[col];
193 output += 3;
194 }
195 }
196 else
197 {
198 #if LibRawBigEndian
199 const unsigned char *input0 = input;
200 const unsigned char *input1 = input + rowIncrement;
201 const unsigned char *input2 = input + rowIncrement * 2;
202 const unsigned char *input3 = input + rowIncrement * 3;
203 #else
204 const unsigned char *input3 = input;
205 const unsigned char *input2 = input + rowIncrement;
206 const unsigned char *input1 = input + rowIncrement * 2;
207 const unsigned char *input0 = input + rowIncrement * 3;
208 #endif
209 for (int col = 0; col < rowIncrement; ++col)
210 {
211 output[0] = input0[col];
212 output[1] = input1[col];
213 output[2] = input2[col];
214 output[3] = input3[col];
215 output += 4;
216 }
217 }
218 }
219
expandFloats(unsigned char * dst,int tileWidth,int bytesps)220 static float expandFloats(unsigned char *dst, int tileWidth, int bytesps)
221 {
222 float max = 0.f;
223 if (bytesps == 2)
224 {
225 uint16_t *dst16 = (ushort *)dst;
226 uint32_t *dst32 = (unsigned int *)dst;
227 float *f32 = (float *)dst;
228 for (int index = tileWidth - 1; index >= 0; --index)
229 {
230 dst32[index] = __DNG_HalfToFloat(dst16[index]);
231 max = MAX(max, f32[index]);
232 }
233 }
234 else if (bytesps == 3)
235 {
236 uint8_t *dst8 = ((unsigned char *)dst) + (tileWidth - 1) * 3;
237 uint32_t *dst32 = (unsigned int *)dst;
238 float *f32 = (float *)dst;
239 for (int index = tileWidth - 1; index >= 0; --index, dst8 -= 3)
240 {
241 dst32[index] = __DNG_FP24ToFloat(dst8);
242 max = MAX(max, f32[index]);
243 }
244 }
245 else if (bytesps == 4)
246 {
247 float *f32 = (float *)dst;
248 for (int index = 0; index < tileWidth; index++)
249 max = MAX(max, f32[index]);
250 }
251 return max;
252 }
253
deflate_dng_load_raw()254 void LibRaw::deflate_dng_load_raw()
255 {
256 int iifd = find_ifd_by_offset(libraw_internal_data.unpacker_data.data_offset);
257 if(iifd < 0 || iifd > libraw_internal_data.identify_data.tiff_nifds)
258 throw LIBRAW_EXCEPTION_DECODE_RAW;
259 struct tiff_ifd_t *ifd = &tiff_ifd[iifd];
260
261 float *float_raw_image = 0;
262 float max = 0.f;
263
264 if (ifd->samples != 1 && ifd->samples != 3 && ifd->samples != 4)
265 throw LIBRAW_EXCEPTION_DECODE_RAW; // Only float deflated supported
266
267 if (libraw_internal_data.unpacker_data.tiff_samples != ifd->samples)
268 throw LIBRAW_EXCEPTION_DECODE_RAW; // Wrong IFD
269
270 size_t tilesH = (imgdata.sizes.raw_width +
271 libraw_internal_data.unpacker_data.tile_width - 1) /
272 libraw_internal_data.unpacker_data.tile_width;
273 size_t tilesV = (imgdata.sizes.raw_height +
274 libraw_internal_data.unpacker_data.tile_length - 1) /
275 libraw_internal_data.unpacker_data.tile_length;
276 size_t tileCnt = tilesH * tilesV;
277
278 if (ifd->sample_format == 3)
279 { // Floating point data
280 float_raw_image = (float *)calloc(
281 tileCnt * libraw_internal_data.unpacker_data.tile_length *
282 libraw_internal_data.unpacker_data.tile_width * ifd->samples,
283 sizeof(float));
284 // imgdata.color.maximum = 65535;
285 // imgdata.color.black = 0;
286 // memset(imgdata.color.cblack,0,sizeof(imgdata.color.cblack));
287 }
288 else
289 throw LIBRAW_EXCEPTION_DECODE_RAW; // Only float deflated supported
290
291 int xFactor;
292 switch (ifd->predictor)
293 {
294 case 3:
295 default:
296 xFactor = 1;
297 break;
298 case 34894:
299 xFactor = 2;
300 break;
301 case 34895:
302 xFactor = 4;
303 break;
304 }
305
306 if (libraw_internal_data.unpacker_data.tile_length < INT_MAX)
307 {
308 if (tileCnt < 1 || tileCnt > 1000000)
309 throw LIBRAW_EXCEPTION_DECODE_RAW;
310
311 size_t *tOffsets = (size_t *)malloc(tileCnt * sizeof(size_t));
312 for (int t = 0; t < tileCnt; ++t)
313 tOffsets[t] = get4();
314
315 size_t *tBytes = (size_t *)malloc(tileCnt * sizeof(size_t));
316 unsigned long maxBytesInTile = 0;
317 if (tileCnt == 1)
318 tBytes[0] = maxBytesInTile = ifd->bytes;
319 else
320 {
321 libraw_internal_data.internal_data.input->seek(ifd->bytes, SEEK_SET);
322 for (size_t t = 0; t < tileCnt; ++t)
323 {
324 tBytes[t] = get4();
325 maxBytesInTile = MAX(maxBytesInTile, tBytes[t]);
326 }
327 }
328 unsigned tilePixels = libraw_internal_data.unpacker_data.tile_width *
329 libraw_internal_data.unpacker_data.tile_length;
330 unsigned pixelSize = sizeof(float) * ifd->samples;
331 unsigned tileBytes = tilePixels * pixelSize;
332 unsigned tileRowBytes =
333 libraw_internal_data.unpacker_data.tile_width * pixelSize;
334
335 unsigned char *cBuffer = (unsigned char *)malloc(maxBytesInTile);
336 unsigned char *uBuffer = (unsigned char *)malloc(
337 tileBytes + tileRowBytes); // extra row for decoding
338
339 for (size_t y = 0, t = 0; y < imgdata.sizes.raw_height;
340 y += libraw_internal_data.unpacker_data.tile_length)
341 {
342 for (size_t x = 0; x < imgdata.sizes.raw_width;
343 x += libraw_internal_data.unpacker_data.tile_width, ++t)
344 {
345 libraw_internal_data.internal_data.input->seek(tOffsets[t], SEEK_SET);
346 libraw_internal_data.internal_data.input->read(cBuffer, 1, tBytes[t]);
347 unsigned long dstLen = tileBytes;
348 int err =
349 uncompress(uBuffer + tileRowBytes, &dstLen, cBuffer, tBytes[t]);
350 if (err != Z_OK)
351 {
352 free(tOffsets);
353 free(tBytes);
354 free(cBuffer);
355 free(uBuffer);
356 throw LIBRAW_EXCEPTION_DECODE_RAW;
357 return;
358 }
359 else
360 {
361 int bytesps = ifd->bps >> 3;
362 size_t rowsInTile =
363 y + libraw_internal_data.unpacker_data.tile_length >
364 imgdata.sizes.raw_height
365 ? imgdata.sizes.raw_height - y
366 : libraw_internal_data.unpacker_data.tile_length;
367 size_t colsInTile =
368 x + libraw_internal_data.unpacker_data.tile_width >
369 imgdata.sizes.raw_width
370 ? imgdata.sizes.raw_width - x
371 : libraw_internal_data.unpacker_data.tile_width;
372
373 for (size_t row = 0; row < rowsInTile;
374 ++row) // do not process full tile if not needed
375 {
376 unsigned char *dst =
377 uBuffer + row * libraw_internal_data.unpacker_data.tile_width *
378 bytesps * ifd->samples;
379 unsigned char *src = dst + tileRowBytes;
380 DecodeFPDelta(src, dst,
381 libraw_internal_data.unpacker_data.tile_width /
382 xFactor,
383 ifd->samples * xFactor, bytesps);
384 float lmax = expandFloats(
385 dst,
386 libraw_internal_data.unpacker_data.tile_width * ifd->samples,
387 bytesps);
388 max = MAX(max, lmax);
389 unsigned char *dst2 = (unsigned char *)&float_raw_image
390 [((y + row) * imgdata.sizes.raw_width + x) * ifd->samples];
391 memmove(dst2, dst, colsInTile * ifd->samples * sizeof(float));
392 }
393 }
394 }
395 }
396 free(tOffsets);
397 free(tBytes);
398 free(cBuffer);
399 free(uBuffer);
400 }
401 imgdata.color.fmaximum = max;
402
403 // Set fields according to data format
404
405 imgdata.rawdata.raw_alloc = float_raw_image;
406 if (ifd->samples == 1)
407 {
408 imgdata.rawdata.float_image = float_raw_image;
409 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch =
410 imgdata.sizes.raw_width * 4;
411 }
412 else if (ifd->samples == 3)
413 {
414 imgdata.rawdata.float3_image = (float(*)[3])float_raw_image;
415 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch =
416 imgdata.sizes.raw_width * 12;
417 }
418 else if (ifd->samples == 4)
419 {
420 imgdata.rawdata.float4_image = (float(*)[4])float_raw_image;
421 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch =
422 imgdata.sizes.raw_width * 16;
423 }
424
425 if (imgdata.params.raw_processing_options &
426 LIBRAW_PROCESSING_CONVERTFLOAT_TO_INT)
427 convertFloatToInt(); // with default settings
428 }
429 #else
deflate_dng_load_raw()430 void LibRaw::deflate_dng_load_raw() { throw LIBRAW_EXCEPTION_DECODE_RAW; }
431 #endif
float_dng_load_raw_placeholder()432 void LibRaw::float_dng_load_raw_placeholder()
433 {
434 // placeholder only, real decoding implemented in DNG SDK
435 throw LIBRAW_EXCEPTION_DECODE_RAW;
436 }
437
is_floating_point()438 int LibRaw::is_floating_point()
439 {
440 struct tiff_ifd_t *ifd = &tiff_ifd[0];
441 while (ifd < &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds] &&
442 ifd->offset != libraw_internal_data.unpacker_data.data_offset)
443 ++ifd;
444 if (ifd == &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds])
445 return 0;
446
447 return ifd->sample_format == 3;
448 }
449
have_fpdata()450 int LibRaw::have_fpdata()
451 {
452 return imgdata.rawdata.float_image || imgdata.rawdata.float3_image ||
453 imgdata.rawdata.float4_image;
454 }
455
convertFloatToInt(float dmin,float dmax,float dtarget)456 void LibRaw::convertFloatToInt(float dmin /* =4096.f */,
457 float dmax /* =32767.f */,
458 float dtarget /*= 16383.f */)
459 {
460 int samples = 0;
461 float *data = 0;
462 if (imgdata.rawdata.float_image)
463 {
464 samples = 1;
465 data = imgdata.rawdata.float_image;
466 }
467 else if (imgdata.rawdata.float3_image)
468 {
469 samples = 3;
470 data = (float *)imgdata.rawdata.float3_image;
471 }
472 else if (imgdata.rawdata.float4_image)
473 {
474 samples = 4;
475 data = (float *)imgdata.rawdata.float4_image;
476 }
477 else
478 return;
479
480 ushort *raw_alloc = (ushort *)malloc(
481 imgdata.sizes.raw_height * imgdata.sizes.raw_width *
482 libraw_internal_data.unpacker_data.tiff_samples * sizeof(ushort));
483 float tmax = MAX(imgdata.color.maximum, 1);
484 float datamax = imgdata.color.fmaximum;
485
486 tmax = MAX(tmax, datamax);
487 tmax = MAX(tmax, 1.f);
488
489 float multip = 1.f;
490 if (tmax < dmin || tmax > dmax)
491 {
492 imgdata.rawdata.color.fnorm = imgdata.color.fnorm = multip = dtarget / tmax;
493 imgdata.rawdata.color.maximum = imgdata.color.maximum = dtarget;
494 imgdata.rawdata.color.black = imgdata.color.black =
495 (float)imgdata.color.black * multip;
496 for (int i = 0;
497 i < int(sizeof(imgdata.color.cblack)/sizeof(imgdata.color.cblack[0]));
498 i++)
499 if (i != 4 && i != 5)
500 imgdata.rawdata.color.cblack[i] = imgdata.color.cblack[i] =
501 (float)imgdata.color.cblack[i] * multip;
502 }
503 else
504 imgdata.rawdata.color.fnorm = imgdata.color.fnorm = 0.f;
505
506 for (size_t i = 0; i < imgdata.sizes.raw_height * imgdata.sizes.raw_width *
507 libraw_internal_data.unpacker_data.tiff_samples;
508 ++i)
509 {
510 float val = MAX(data[i], 0.f);
511 raw_alloc[i] = (ushort)(val * multip);
512 }
513
514 if (samples == 1)
515 {
516 imgdata.rawdata.raw_alloc = imgdata.rawdata.raw_image = raw_alloc;
517 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch =
518 imgdata.sizes.raw_width * 2;
519 }
520 else if (samples == 3)
521 {
522 imgdata.rawdata.raw_alloc = imgdata.rawdata.color3_image =
523 (ushort(*)[3])raw_alloc;
524 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch =
525 imgdata.sizes.raw_width * 6;
526 }
527 else if (samples == 4)
528 {
529 imgdata.rawdata.raw_alloc = imgdata.rawdata.color4_image =
530 (ushort(*)[4])raw_alloc;
531 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch =
532 imgdata.sizes.raw_width * 8;
533 }
534 free(data); // remove old allocation
535 imgdata.rawdata.float_image = 0;
536 imgdata.rawdata.float3_image = 0;
537 imgdata.rawdata.float4_image = 0;
538 }
539