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