1 /* -*- C++ -*-
2 * File: libraw_cxx.cpp
3 * Copyright 2008-2018 LibRaw LLC (info@libraw.org)
4 * Created: Sat Mar 8 , 2008
5 *
6 * LibRaw C++ interface (implementation)
7
8 LibRaw is free software; you can redistribute it and/or modify
9 it under the terms of the one of two licenses as you choose:
10
11 1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
12 (See file LICENSE.LGPL provided in LibRaw distribution archive for details).
13
14 2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
15 (See file LICENSE.CDDL provided in LibRaw distribution archive for details).
16
17 */
18
19 #include <math.h>
20 #include <errno.h>
21 #include <float.h>
22 #include <new>
23 #include <exception>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #if !defined(_WIN32) && !defined(__MINGW32__)
27 #include <netinet/in.h>
28 #else
29 #include <winsock2.h>
30 #endif
31 #define LIBRAW_LIBRARY_BUILD
32 #include "libraw/libraw.h"
33 #include "internal/defines.h"
34 #ifdef USE_ZLIB
35 #include <zlib.h>
36 #endif
37
38 #ifdef USE_RAWSPEED
39 #include "../RawSpeed/rawspeed_xmldata.cpp"
40 #include <RawSpeed/StdAfx.h>
41 #include <RawSpeed/FileMap.h>
42 #include <RawSpeed/RawParser.h>
43 #include <RawSpeed/RawDecoder.h>
44 #include <RawSpeed/CameraMetaData.h>
45 #include <RawSpeed/ColorFilterArray.h>
46 #endif
47
48 #ifdef USE_DNGSDK
49 #include "dng_host.h"
50 #include "dng_negative.h"
51 #include "dng_simple_image.h"
52 #include "dng_info.h"
53 #endif
54
55 #include "libraw_fuji_compressed.cpp"
56
57 #ifdef __cplusplus
58 extern "C"
59 {
60 #endif
default_memory_callback(void *,const char * file,const char * where)61 void default_memory_callback(void *, const char *file, const char *where)
62 {
63 fprintf(stderr, "%s: Out of memory in %s\n", file ? file : "unknown file", where);
64 }
65
default_data_callback(void *,const char * file,const int offset)66 void default_data_callback(void *, const char *file, const int offset)
67 {
68 if (offset < 0)
69 fprintf(stderr, "%s: Unexpected end of file\n", file ? file : "unknown file");
70 else
71 fprintf(stderr, "%s: data corrupted at %d\n", file ? file : "unknown file", offset);
72 }
libraw_strerror(int e)73 const char *libraw_strerror(int e)
74 {
75 enum LibRaw_errors errorcode = (LibRaw_errors)e;
76 switch (errorcode)
77 {
78 case LIBRAW_SUCCESS:
79 return "No error";
80 case LIBRAW_UNSPECIFIED_ERROR:
81 return "Unspecified error";
82 case LIBRAW_FILE_UNSUPPORTED:
83 return "Unsupported file format or not RAW file";
84 case LIBRAW_REQUEST_FOR_NONEXISTENT_IMAGE:
85 return "Request for nonexisting image number";
86 case LIBRAW_OUT_OF_ORDER_CALL:
87 return "Out of order call of libraw function";
88 case LIBRAW_NO_THUMBNAIL:
89 return "No thumbnail in file";
90 case LIBRAW_UNSUPPORTED_THUMBNAIL:
91 return "Unsupported thumbnail format";
92 case LIBRAW_INPUT_CLOSED:
93 return "No input stream, or input stream closed";
94 case LIBRAW_UNSUFFICIENT_MEMORY:
95 return "Unsufficient memory";
96 case LIBRAW_DATA_ERROR:
97 return "Corrupted data or unexpected EOF";
98 case LIBRAW_IO_ERROR:
99 return "Input/output error";
100 case LIBRAW_CANCELLED_BY_CALLBACK:
101 return "Cancelled by user callback";
102 case LIBRAW_BAD_CROP:
103 return "Bad crop box";
104 case LIBRAW_TOO_BIG:
105 return "Image too big for processing";
106 default:
107 return "Unknown error code";
108 }
109 }
110
111 #ifdef __cplusplus
112 }
113 #endif
114
115 #define Sigma_X3F 22
116
117 const double LibRaw_constants::xyz_rgb[3][3] = {
118 {0.4124564, 0.3575761, 0.1804375}, {0.2126729, 0.7151522, 0.0721750}, {0.0193339, 0.1191920, 0.9503041}};
119
120 const float LibRaw_constants::d65_white[3] = {0.95047f, 1.0f, 1.08883f};
121
122 #define P1 imgdata.idata
123 #define S imgdata.sizes
124 #define O imgdata.params
125 #define C imgdata.color
126 #define T imgdata.thumbnail
127 #define IO libraw_internal_data.internal_output_params
128 #define ID libraw_internal_data.internal_data
129
130 #define EXCEPTION_HANDLER(e) \
131 do \
132 { \
133 /* fprintf(stderr,"Exception %d caught\n",e);*/ \
134 switch (e) \
135 { \
136 case LIBRAW_EXCEPTION_ALLOC: \
137 recycle(); \
138 return LIBRAW_UNSUFFICIENT_MEMORY; \
139 case LIBRAW_EXCEPTION_TOOBIG: \
140 recycle(); \
141 return LIBRAW_TOO_BIG; \
142 case LIBRAW_EXCEPTION_DECODE_RAW: \
143 case LIBRAW_EXCEPTION_DECODE_JPEG: \
144 recycle(); \
145 return LIBRAW_DATA_ERROR; \
146 case LIBRAW_EXCEPTION_DECODE_JPEG2000: \
147 recycle(); \
148 return LIBRAW_DATA_ERROR; \
149 case LIBRAW_EXCEPTION_IO_EOF: \
150 case LIBRAW_EXCEPTION_IO_CORRUPT: \
151 recycle(); \
152 return LIBRAW_IO_ERROR; \
153 case LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK: \
154 recycle(); \
155 return LIBRAW_CANCELLED_BY_CALLBACK; \
156 case LIBRAW_EXCEPTION_BAD_CROP: \
157 recycle(); \
158 return LIBRAW_BAD_CROP; \
159 default: \
160 return LIBRAW_UNSPECIFIED_ERROR; \
161 } \
162 } while (0)
163
version()164 const char *LibRaw::version() { return LIBRAW_VERSION_STR; }
versionNumber()165 int LibRaw::versionNumber() { return LIBRAW_VERSION; }
strerror(int p)166 const char *LibRaw::strerror(int p) { return libraw_strerror(p); }
167
capabilities()168 unsigned LibRaw::capabilities()
169 {
170 unsigned ret = 0;
171 #ifdef USE_RAWSPEED
172 ret |= LIBRAW_CAPS_RAWSPEED;
173 #endif
174 #ifdef USE_DNGSDK
175 ret |= LIBRAW_CAPS_DNGSDK;
176 #endif
177 return ret;
178 }
179
parse_custom_cameras(unsigned limit,libraw_custom_camera_t table[],char ** list)180 unsigned LibRaw::parse_custom_cameras(unsigned limit, libraw_custom_camera_t table[], char **list)
181 {
182 if (!list)
183 return 0;
184 unsigned index = 0;
185 for (int i = 0; i < limit; i++)
186 {
187 if (!list[i])
188 break;
189 if (strlen(list[i]) < 10)
190 continue;
191 char *string = (char *)malloc(strlen(list[i]) + 1);
192 strcpy(string, list[i]);
193 char *start = string;
194 memset(&table[index], 0, sizeof(table[0]));
195 for (int j = 0; start && j < 14; j++)
196 {
197 char *end = strchr(start, ',');
198 if (end)
199 {
200 *end = 0;
201 end++;
202 } // move to next char
203 while (isspace(*start) && *start)
204 start++; // skip leading spaces?
205 unsigned val = strtol(start, 0, 10);
206 switch (j)
207 {
208 case 0:
209 table[index].fsize = val;
210 break;
211 case 1:
212 table[index].rw = val;
213 break;
214 case 2:
215 table[index].rh = val;
216 break;
217 case 3:
218 table[index].lm = val;
219 break;
220 case 4:
221 table[index].tm = val;
222 break;
223 case 5:
224 table[index].rm = val;
225 break;
226 case 6:
227 table[index].bm = val;
228 break;
229 case 7:
230 table[index].lf = val;
231 break;
232 case 8:
233 table[index].cf = val;
234 break;
235 case 9:
236 table[index].max = val;
237 break;
238 case 10:
239 table[index].flags = val;
240 break;
241 case 11:
242 strncpy(table[index].t_make, start, sizeof(table[index].t_make) - 1);
243 break;
244 case 12:
245 strncpy(table[index].t_model, start, sizeof(table[index].t_model) - 1);
246 break;
247 case 13:
248 table[index].offset = val;
249 break;
250 default:
251 break;
252 }
253 start = end;
254 }
255 free(string);
256 if (table[index].t_make[0])
257 index++;
258 }
259 return index;
260 }
261
derror()262 void LibRaw::derror()
263 {
264 if (!libraw_internal_data.unpacker_data.data_error && libraw_internal_data.internal_data.input)
265 {
266 if (libraw_internal_data.internal_data.input->eof())
267 {
268 if (callbacks.data_cb)
269 (*callbacks.data_cb)(callbacks.datacb_data, libraw_internal_data.internal_data.input->fname(), -1);
270 throw LIBRAW_EXCEPTION_IO_EOF;
271 }
272 else
273 {
274 if (callbacks.data_cb)
275 (*callbacks.data_cb)(callbacks.datacb_data, libraw_internal_data.internal_data.input->fname(),
276 libraw_internal_data.internal_data.input->tell());
277 // throw LIBRAW_EXCEPTION_IO_CORRUPT;
278 }
279 }
280 libraw_internal_data.unpacker_data.data_error++;
281 }
282
dcraw_clear_mem(libraw_processed_image_t * p)283 void LibRaw::dcraw_clear_mem(libraw_processed_image_t *p)
284 {
285 if (p)
286 ::free(p);
287 }
288
is_sraw()289 int LibRaw::is_sraw() { return load_raw == &LibRaw::canon_sraw_load_raw || load_raw == &LibRaw::nikon_load_sraw; }
is_coolscan_nef()290 int LibRaw::is_coolscan_nef() { return load_raw == &LibRaw::nikon_coolscan_load_raw; }
is_jpeg_thumb()291 int LibRaw::is_jpeg_thumb() { return thumb_load_raw == 0 && write_thumb == &LibRaw::jpeg_thumb; }
292
is_nikon_sraw()293 int LibRaw::is_nikon_sraw() { return load_raw == &LibRaw::nikon_load_sraw; }
sraw_midpoint()294 int LibRaw::sraw_midpoint()
295 {
296 if (load_raw == &LibRaw::canon_sraw_load_raw)
297 return 8192;
298 else if (load_raw == &LibRaw::nikon_load_sraw)
299 return 2048;
300 else
301 return 0;
302 }
303
304 #ifdef USE_RAWSPEED
305 using namespace RawSpeed;
306 class CameraMetaDataLR : public CameraMetaData
307 {
308 public:
CameraMetaDataLR()309 CameraMetaDataLR() : CameraMetaData() {}
CameraMetaDataLR(char * filename)310 CameraMetaDataLR(char *filename) : CameraMetaData(filename) {}
311 CameraMetaDataLR(char *data, int sz);
312 };
313
CameraMetaDataLR(char * data,int sz)314 CameraMetaDataLR::CameraMetaDataLR(char *data, int sz) : CameraMetaData()
315 {
316 ctxt = xmlNewParserCtxt();
317 if (ctxt == NULL)
318 {
319 ThrowCME("CameraMetaData:Could not initialize context.");
320 }
321
322 xmlResetLastError();
323 doc = xmlCtxtReadMemory(ctxt, data, sz, "", NULL, XML_PARSE_DTDVALID);
324
325 if (doc == NULL)
326 {
327 ThrowCME("CameraMetaData: XML Document could not be parsed successfully. Error was: %s", ctxt->lastError.message);
328 }
329
330 if (ctxt->valid == 0)
331 {
332 if (ctxt->lastError.code == 0x5e)
333 {
334 // printf("CameraMetaData: Unable to locate DTD, attempting to ignore.");
335 }
336 else
337 {
338 ThrowCME("CameraMetaData: XML file does not validate. DTD Error was: %s", ctxt->lastError.message);
339 }
340 }
341
342 xmlNodePtr cur;
343 cur = xmlDocGetRootElement(doc);
344 if (xmlStrcmp(cur->name, (const xmlChar *)"Cameras"))
345 {
346 ThrowCME("CameraMetaData: XML document of the wrong type, root node is not cameras.");
347 return;
348 }
349
350 cur = cur->xmlChildrenNode;
351 while (cur != NULL)
352 {
353 if ((!xmlStrcmp(cur->name, (const xmlChar *)"Camera")))
354 {
355 Camera *camera = new Camera(doc, cur);
356 addCamera(camera);
357
358 // Create cameras for aliases.
359 for (unsigned int i = 0; i < camera->aliases.size(); i++)
360 {
361 addCamera(new Camera(camera, i));
362 }
363 }
364 cur = cur->next;
365 }
366 if (doc)
367 xmlFreeDoc(doc);
368 doc = 0;
369 if (ctxt)
370 xmlFreeParserCtxt(ctxt);
371 ctxt = 0;
372 }
373
374 #define RAWSPEED_DATA_COUNT (sizeof(_rawspeed_data_xml) / sizeof(_rawspeed_data_xml[0]))
make_camera_metadata()375 static CameraMetaDataLR *make_camera_metadata()
376 {
377 int len = 0, i;
378 for (i = 0; i < RAWSPEED_DATA_COUNT; i++)
379 if (_rawspeed_data_xml[i])
380 {
381 len += strlen(_rawspeed_data_xml[i]);
382 }
383 char *rawspeed_xml = (char *)calloc(len + 1, sizeof(_rawspeed_data_xml[0][0]));
384 if (!rawspeed_xml)
385 return NULL;
386 int offt = 0;
387 for (i = 0; i < RAWSPEED_DATA_COUNT; i++)
388 if (_rawspeed_data_xml[i])
389 {
390 int ll = strlen(_rawspeed_data_xml[i]);
391 if (offt + ll > len)
392 break;
393 memmove(rawspeed_xml + offt, _rawspeed_data_xml[i], ll);
394 offt += ll;
395 }
396 rawspeed_xml[offt] = 0;
397 CameraMetaDataLR *ret = NULL;
398 try
399 {
400 ret = new CameraMetaDataLR(rawspeed_xml, offt);
401 }
402 catch (...)
403 {
404 // Mask all exceptions
405 }
406 free(rawspeed_xml);
407 return ret;
408 }
409
410 #endif
411
412 #define ZERO(a) memset(&a, 0, sizeof(a))
413
cleargps(libraw_gps_info_t * q)414 static void cleargps(libraw_gps_info_t *q)
415 {
416 for (int i = 0; i < 3; i++)
417 q->latitude[i] = q->longtitude[i] = q->gpstimestamp[i] = 0.f;
418 q->altitude = 0.f;
419 q->altref = q->latref = q->longref = q->gpsstatus = q->gpsparsed = 0;
420 }
421
LibRaw(unsigned int flags)422 LibRaw::LibRaw(unsigned int flags) : memmgr(1024)
423 {
424 double aber[4] = {1, 1, 1, 1};
425 double gamm[6] = {0.45, 4.5, 0, 0, 0, 0};
426 unsigned greybox[4] = {0, 0, UINT_MAX, UINT_MAX};
427 unsigned cropbox[4] = {0, 0, UINT_MAX, UINT_MAX};
428 #ifdef DCRAW_VERBOSE
429 verbose = 1;
430 #else
431 verbose = 0;
432 #endif
433 ZERO(imgdata);
434
435 cleargps(&imgdata.other.parsed_gps);
436 ZERO(libraw_internal_data);
437 ZERO(callbacks);
438
439 _rawspeed_camerameta = _rawspeed_decoder = NULL;
440 dnghost = NULL;
441 _x3f_data = NULL;
442
443 #ifdef USE_RAWSPEED
444 CameraMetaDataLR *camerameta = make_camera_metadata(); // May be NULL in case of exception in make_camera_metadata()
445 _rawspeed_camerameta = static_cast<void *>(camerameta);
446 #endif
447 callbacks.mem_cb = (flags & LIBRAW_OPIONS_NO_MEMERR_CALLBACK) ? NULL : &default_memory_callback;
448 callbacks.data_cb = (flags & LIBRAW_OPIONS_NO_DATAERR_CALLBACK) ? NULL : &default_data_callback;
449 callbacks.exif_cb = NULL; // no default callback
450 callbacks.pre_identify_cb = NULL;
451 callbacks.post_identify_cb = NULL;
452 callbacks.pre_subtractblack_cb = callbacks.pre_scalecolors_cb = callbacks.pre_preinterpolate_cb
453 = callbacks.pre_interpolate_cb = callbacks.interpolate_bayer_cb = callbacks.interpolate_xtrans_cb
454 = callbacks.post_interpolate_cb = callbacks.pre_converttorgb_cb = callbacks.post_converttorgb_cb
455 = NULL;
456
457 memmove(&imgdata.params.aber, &aber, sizeof(aber));
458 memmove(&imgdata.params.gamm, &gamm, sizeof(gamm));
459 memmove(&imgdata.params.greybox, &greybox, sizeof(greybox));
460 memmove(&imgdata.params.cropbox, &cropbox, sizeof(cropbox));
461
462 imgdata.params.bright = 1;
463 imgdata.params.use_camera_matrix = 1;
464 imgdata.params.user_flip = -1;
465 imgdata.params.user_black = -1;
466 imgdata.params.user_cblack[0] = imgdata.params.user_cblack[1] = imgdata.params.user_cblack[2] =
467 imgdata.params.user_cblack[3] = -1000001;
468 imgdata.params.user_sat = -1;
469 imgdata.params.user_qual = -1;
470 imgdata.params.output_color = 1;
471 imgdata.params.output_bps = 8;
472 imgdata.params.use_fuji_rotate = 1;
473 imgdata.params.exp_shift = 1.0;
474 imgdata.params.auto_bright_thr = LIBRAW_DEFAULT_AUTO_BRIGHTNESS_THRESHOLD;
475 imgdata.params.adjust_maximum_thr = LIBRAW_DEFAULT_ADJUST_MAXIMUM_THRESHOLD;
476 imgdata.params.use_rawspeed = 1;
477 imgdata.params.use_dngsdk = LIBRAW_DNG_DEFAULT;
478 imgdata.params.no_auto_scale = 0;
479 imgdata.params.no_interpolation = 0;
480 imgdata.params.raw_processing_options = LIBRAW_PROCESSING_DP2Q_INTERPOLATERG | LIBRAW_PROCESSING_DP2Q_INTERPOLATEAF |
481 LIBRAW_PROCESSING_CONVERTFLOAT_TO_INT;
482 imgdata.params.sony_arw2_posterization_thr = 0;
483 imgdata.params.green_matching = 0;
484 imgdata.params.custom_camera_strings = 0;
485 imgdata.params.coolscan_nef_gamma = 1.0f;
486 imgdata.parent_class = this;
487 imgdata.progress_flags = 0;
488 imgdata.color.baseline_exposure = -999.f;
489 _exitflag = 0;
490 tls = new LibRaw_TLS;
491 tls->init();
492
493 }
494
set_rawspeed_camerafile(char * filename)495 int LibRaw::set_rawspeed_camerafile(char *filename)
496 {
497 #ifdef USE_RAWSPEED
498 try
499 {
500 CameraMetaDataLR *camerameta = new CameraMetaDataLR(filename);
501 if (_rawspeed_camerameta)
502 {
503 CameraMetaDataLR *d = static_cast<CameraMetaDataLR *>(_rawspeed_camerameta);
504 delete d;
505 }
506 _rawspeed_camerameta = static_cast<void *>(camerameta);
507 }
508 catch (...)
509 {
510 // just return error code
511 return -1;
512 }
513 #endif
514 return 0;
515 }
516
~LibRaw()517 LibRaw::~LibRaw()
518 {
519 recycle();
520 delete tls;
521 #ifdef USE_RAWSPEED
522 if (_rawspeed_camerameta)
523 {
524 CameraMetaDataLR *cmeta = static_cast<CameraMetaDataLR *>(_rawspeed_camerameta);
525 delete cmeta;
526 _rawspeed_camerameta = NULL;
527 }
528 #endif
529 }
530
malloc(size_t t)531 void *LibRaw::malloc(size_t t)
532 {
533 void *p = memmgr.malloc(t);
534 if (!p)
535 throw LIBRAW_EXCEPTION_ALLOC;
536 return p;
537 }
realloc(void * q,size_t t)538 void *LibRaw::realloc(void *q, size_t t)
539 {
540 void *p = memmgr.realloc(q, t);
541 if (!p)
542 throw LIBRAW_EXCEPTION_ALLOC;
543 return p;
544 }
545
calloc(size_t n,size_t t)546 void *LibRaw::calloc(size_t n, size_t t)
547 {
548 void *p = memmgr.calloc(n, t);
549 if (!p)
550 throw LIBRAW_EXCEPTION_ALLOC;
551 return p;
552 }
free(void * p)553 void LibRaw::free(void *p) { memmgr.free(p); }
554
recycle_datastream()555 void LibRaw::recycle_datastream()
556 {
557 if (libraw_internal_data.internal_data.input && libraw_internal_data.internal_data.input_internal)
558 {
559 delete libraw_internal_data.internal_data.input;
560 libraw_internal_data.internal_data.input = NULL;
561 }
562 libraw_internal_data.internal_data.input_internal = 0;
563 }
564
565 void x3f_clear(void *);
566
recycle()567 void LibRaw::recycle()
568 {
569 recycle_datastream();
570 #define FREE(a) \
571 do \
572 { \
573 if (a) \
574 { \
575 free(a); \
576 a = NULL; \
577 } \
578 } while (0)
579
580 FREE(imgdata.image);
581
582 FREE(imgdata.thumbnail.thumb);
583 FREE(libraw_internal_data.internal_data.meta_data);
584 FREE(libraw_internal_data.output_data.histogram);
585 FREE(libraw_internal_data.output_data.oprof);
586 FREE(imgdata.color.profile);
587 FREE(imgdata.rawdata.ph1_cblack);
588 FREE(imgdata.rawdata.ph1_rblack);
589 FREE(imgdata.rawdata.raw_alloc);
590 FREE(imgdata.idata.xmpdata);
591
592 #undef FREE
593
594 ZERO(imgdata.sizes);
595 imgdata.sizes.raw_crop.cleft = 0xffff;
596 imgdata.sizes.raw_crop.ctop = 0xffff;
597
598 ZERO(imgdata.idata);
599 ZERO(imgdata.makernotes);
600 ZERO(imgdata.color);
601 ZERO(imgdata.other);
602 ZERO(imgdata.thumbnail);
603 ZERO(imgdata.rawdata);
604 imgdata.makernotes.olympus.OlympusCropID = -1;
605 imgdata.makernotes.sony.raw_crop.cleft = 0xffff;
606 imgdata.makernotes.sony.raw_crop.ctop = 0xffff;
607 cleargps(&imgdata.other.parsed_gps);
608 imgdata.color.baseline_exposure = -999.f;
609
610 imgdata.makernotes.fuji.FujiExpoMidPointShift = -999.f;
611 imgdata.makernotes.fuji.FujiDynamicRange = 0xffff;
612 imgdata.makernotes.fuji.FujiFilmMode = 0xffff;
613 imgdata.makernotes.fuji.FujiDynamicRangeSetting = 0xffff;
614 imgdata.makernotes.fuji.FujiDevelopmentDynamicRange = 0xffff;
615 imgdata.makernotes.fuji.FujiAutoDynamicRange = 0xffff;
616 imgdata.makernotes.fuji.FocusMode = 0xffff;
617 imgdata.makernotes.fuji.AFMode = 0xffff;
618 imgdata.makernotes.fuji.FocusPixel[0] = imgdata.makernotes.fuji.FocusPixel[1] = 0xffff;
619 imgdata.makernotes.fuji.ImageStabilization[0] = imgdata.makernotes.fuji.ImageStabilization[1] =
620 imgdata.makernotes.fuji.ImageStabilization[2] = 0xffff;
621
622 imgdata.makernotes.sony.SonyCameraType = 0xffff;
623 imgdata.makernotes.sony.real_iso_offset = 0xffff;
624 imgdata.makernotes.sony.ImageCount3_offset = 0xffff;
625 imgdata.makernotes.sony.ElectronicFrontCurtainShutter = 0xffff;
626
627 imgdata.makernotes.kodak.BlackLevelTop = 0xffff;
628 imgdata.makernotes.kodak.BlackLevelBottom = 0xffff;
629
630 imgdata.color.dng_color[0].illuminant = imgdata.color.dng_color[1].illuminant = 0xffff;
631
632 for (int i = 0; i < 4; i++)
633 imgdata.color.dng_levels.analogbalance[i] = 1.0f;
634
635 ZERO(libraw_internal_data);
636 ZERO(imgdata.lens);
637 imgdata.lens.makernotes.CanonFocalUnits = 1;
638 imgdata.lens.makernotes.LensID = 0xffffffffffffffffULL;
639 ZERO(imgdata.shootinginfo);
640 imgdata.shootinginfo.DriveMode = -1;
641 imgdata.shootinginfo.FocusMode = -1;
642 imgdata.shootinginfo.MeteringMode = -1;
643 imgdata.shootinginfo.AFPoint = -1;
644 imgdata.shootinginfo.ExposureMode = -1;
645 imgdata.shootinginfo.ImageStabilization = -1;
646
647 _exitflag = 0;
648 #ifdef USE_RAWSPEED
649 if (_rawspeed_decoder)
650 {
651 RawDecoder *d = static_cast<RawDecoder *>(_rawspeed_decoder);
652 delete d;
653 }
654 _rawspeed_decoder = 0;
655 #endif
656
657 if (_x3f_data)
658 {
659 x3f_clear(_x3f_data);
660 _x3f_data = 0;
661 }
662
663 memmgr.cleanup();
664
665 imgdata.thumbnail.tformat = LIBRAW_THUMBNAIL_UNKNOWN;
666 imgdata.progress_flags = 0;
667
668 load_raw = thumb_load_raw = 0;
669
670 tls->init();
671 }
672
unpack_function_name()673 const char *LibRaw::unpack_function_name()
674 {
675 libraw_decoder_info_t decoder_info;
676 get_decoder_info(&decoder_info);
677 return decoder_info.decoder_name;
678 }
679
get_decoder_info(libraw_decoder_info_t * d_info)680 int LibRaw::get_decoder_info(libraw_decoder_info_t *d_info)
681 {
682 if (!d_info)
683 return LIBRAW_UNSPECIFIED_ERROR;
684 d_info->decoder_name = 0;
685 d_info->decoder_flags = 0;
686 if (!load_raw)
687 return LIBRAW_OUT_OF_ORDER_CALL;
688
689 int rawdata = (imgdata.idata.filters || P1.colors == 1);
690 // dcraw.c names order
691 if (load_raw == &LibRaw::android_tight_load_raw)
692 {
693 d_info->decoder_name = "android_tight_load_raw()";
694 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
695 }
696 else if (load_raw == &LibRaw::android_loose_load_raw)
697 {
698 d_info->decoder_name = "android_loose_load_raw()";
699 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
700 }
701 else if (load_raw == &LibRaw::canon_600_load_raw)
702 {
703 d_info->decoder_name = "canon_600_load_raw()";
704 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
705 }
706 else if (load_raw == &LibRaw::fuji_compressed_load_raw)
707 {
708 d_info->decoder_name = "fuji_compressed_load_raw()";
709 }
710 else if (load_raw == &LibRaw::fuji_14bit_load_raw)
711 {
712 d_info->decoder_name = "fuji_14bit_load_raw()";
713 }
714 else if (load_raw == &LibRaw::canon_load_raw)
715 {
716 d_info->decoder_name = "canon_load_raw()";
717 }
718 else if (load_raw == &LibRaw::lossless_jpeg_load_raw)
719 {
720 d_info->decoder_name = "lossless_jpeg_load_raw()";
721 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_TRYRAWSPEED;
722 }
723 else if (load_raw == &LibRaw::canon_sraw_load_raw)
724 {
725 d_info->decoder_name = "canon_sraw_load_raw()";
726 // d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
727 }
728 else if (load_raw == &LibRaw::lossless_dng_load_raw)
729 {
730 d_info->decoder_name = "lossless_dng_load_raw()";
731 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_TRYRAWSPEED | LIBRAW_DECODER_ADOBECOPYPIXEL;
732 }
733 else if (load_raw == &LibRaw::packed_dng_load_raw)
734 {
735 d_info->decoder_name = "packed_dng_load_raw()";
736 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_TRYRAWSPEED | LIBRAW_DECODER_ADOBECOPYPIXEL;
737 }
738 else if (load_raw == &LibRaw::pentax_load_raw)
739 {
740 d_info->decoder_name = "pentax_load_raw()";
741 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
742 }
743 else if (load_raw == &LibRaw::nikon_load_raw)
744 {
745 d_info->decoder_name = "nikon_load_raw()";
746 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
747 }
748 else if (load_raw == &LibRaw::nikon_coolscan_load_raw)
749 {
750 d_info->decoder_name = "nikon_coolscan_load_raw()";
751 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
752 }
753 else if (load_raw == &LibRaw::nikon_load_sraw)
754 {
755 d_info->decoder_name = "nikon_load_sraw()";
756 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_FIXEDMAXC;
757 }
758 else if (load_raw == &LibRaw::nikon_yuv_load_raw)
759 {
760 d_info->decoder_name = "nikon_load_yuv_load_raw()";
761 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_FIXEDMAXC;
762 }
763 else if (load_raw == &LibRaw::rollei_load_raw)
764 {
765 // UNTESTED
766 d_info->decoder_name = "rollei_load_raw()";
767 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
768 }
769 else if (load_raw == &LibRaw::phase_one_load_raw)
770 {
771 d_info->decoder_name = "phase_one_load_raw()";
772 }
773 else if (load_raw == &LibRaw::phase_one_load_raw_c)
774 {
775 d_info->decoder_name = "phase_one_load_raw_c()";
776 }
777 else if (load_raw == &LibRaw::hasselblad_load_raw)
778 {
779 d_info->decoder_name = "hasselblad_load_raw()";
780 }
781 else if (load_raw == &LibRaw::leaf_hdr_load_raw)
782 {
783 d_info->decoder_name = "leaf_hdr_load_raw()";
784 }
785 else if (load_raw == &LibRaw::unpacked_load_raw)
786 {
787 d_info->decoder_name = "unpacked_load_raw()";
788 }
789 else if (load_raw == &LibRaw::unpacked_load_raw_reversed)
790 {
791 d_info->decoder_name = "unpacked_load_raw_reversed()";
792 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
793 }
794 else if (load_raw == &LibRaw::sinar_4shot_load_raw)
795 {
796 // UNTESTED
797 d_info->decoder_name = "sinar_4shot_load_raw()";
798 }
799 else if (load_raw == &LibRaw::imacon_full_load_raw)
800 {
801 d_info->decoder_name = "imacon_full_load_raw()";
802 }
803 else if (load_raw == &LibRaw::hasselblad_full_load_raw)
804 {
805 d_info->decoder_name = "hasselblad_full_load_raw()";
806 }
807 else if (load_raw == &LibRaw::packed_load_raw)
808 {
809 d_info->decoder_name = "packed_load_raw()";
810 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
811 }
812 else if (load_raw == &LibRaw::broadcom_load_raw)
813 {
814 // UNTESTED
815 d_info->decoder_name = "broadcom_load_raw()";
816 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
817 }
818 else if (load_raw == &LibRaw::nokia_load_raw)
819 {
820 // UNTESTED
821 d_info->decoder_name = "nokia_load_raw()";
822 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
823 }
824 else if (load_raw == &LibRaw::canon_rmf_load_raw)
825 {
826 // UNTESTED
827 d_info->decoder_name = "canon_rmf_load_raw()";
828 }
829 else if (load_raw == &LibRaw::panasonic_load_raw)
830 {
831 d_info->decoder_name = "panasonic_load_raw()";
832 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
833 }
834 else if (load_raw == &LibRaw::olympus_load_raw)
835 {
836 d_info->decoder_name = "olympus_load_raw()";
837 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
838 }
839 else if (load_raw == &LibRaw::minolta_rd175_load_raw)
840 {
841 // UNTESTED
842 d_info->decoder_name = "minolta_rd175_load_raw()";
843 }
844 else if (load_raw == &LibRaw::quicktake_100_load_raw)
845 {
846 // UNTESTED
847 d_info->decoder_name = "quicktake_100_load_raw()";
848 }
849 else if (load_raw == &LibRaw::kodak_radc_load_raw)
850 {
851 d_info->decoder_name = "kodak_radc_load_raw()";
852 }
853 else if (load_raw == &LibRaw::kodak_jpeg_load_raw)
854 {
855 // UNTESTED + RBAYER
856 d_info->decoder_name = "kodak_jpeg_load_raw()";
857 }
858 else if (load_raw == &LibRaw::lossy_dng_load_raw)
859 {
860 // Check rbayer
861 d_info->decoder_name = "lossy_dng_load_raw()";
862 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED | LIBRAW_DECODER_HASCURVE;
863 }
864 else if (load_raw == &LibRaw::kodak_dc120_load_raw)
865 {
866 d_info->decoder_name = "kodak_dc120_load_raw()";
867 }
868 else if (load_raw == &LibRaw::eight_bit_load_raw)
869 {
870 d_info->decoder_name = "eight_bit_load_raw()";
871 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_FIXEDMAXC;
872 }
873 else if (load_raw == &LibRaw::kodak_c330_load_raw)
874 {
875 d_info->decoder_name = "kodak_yrgb_load_raw()";
876 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_FIXEDMAXC;
877 }
878 else if (load_raw == &LibRaw::kodak_c603_load_raw)
879 {
880 d_info->decoder_name = "kodak_yrgb_load_raw()";
881 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_FIXEDMAXC;
882 }
883 else if (load_raw == &LibRaw::kodak_262_load_raw)
884 {
885 d_info->decoder_name = "kodak_262_load_raw()"; // UNTESTED!
886 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_FIXEDMAXC;
887 }
888 else if (load_raw == &LibRaw::kodak_65000_load_raw)
889 {
890 d_info->decoder_name = "kodak_65000_load_raw()";
891 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE;
892 }
893 else if (load_raw == &LibRaw::kodak_ycbcr_load_raw)
894 {
895 // UNTESTED
896 d_info->decoder_name = "kodak_ycbcr_load_raw()";
897 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_FIXEDMAXC;
898 }
899 else if (load_raw == &LibRaw::kodak_rgb_load_raw)
900 {
901 // UNTESTED
902 d_info->decoder_name = "kodak_rgb_load_raw()";
903 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
904 }
905 else if (load_raw == &LibRaw::sony_load_raw)
906 {
907 d_info->decoder_name = "sony_load_raw()";
908 }
909 else if (load_raw == &LibRaw::sony_arw_load_raw)
910 {
911 d_info->decoder_name = "sony_arw_load_raw()";
912 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
913 }
914 else if (load_raw == &LibRaw::sony_arw2_load_raw)
915 {
916 d_info->decoder_name = "sony_arw2_load_raw()";
917 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE | LIBRAW_DECODER_TRYRAWSPEED | LIBRAW_DECODER_SONYARW2;
918 }
919 else if (load_raw == &LibRaw::sony_arq_load_raw)
920 {
921 d_info->decoder_name = "sony_arq_load_raw()";
922 d_info->decoder_flags = LIBRAW_DECODER_LEGACY_WITH_MARGINS;
923 }
924 else if (load_raw == &LibRaw::samsung_load_raw)
925 {
926 d_info->decoder_name = "samsung_load_raw()";
927 d_info->decoder_flags = LIBRAW_DECODER_TRYRAWSPEED;
928 }
929 else if (load_raw == &LibRaw::samsung2_load_raw)
930 {
931 d_info->decoder_name = "samsung2_load_raw()";
932 }
933 else if (load_raw == &LibRaw::samsung3_load_raw)
934 {
935 d_info->decoder_name = "samsung3_load_raw()";
936 }
937 else if (load_raw == &LibRaw::smal_v6_load_raw)
938 {
939 // UNTESTED
940 d_info->decoder_name = "smal_v6_load_raw()";
941 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
942 }
943 else if (load_raw == &LibRaw::smal_v9_load_raw)
944 {
945 // UNTESTED
946 d_info->decoder_name = "smal_v9_load_raw()";
947 d_info->decoder_flags = LIBRAW_DECODER_FIXEDMAXC;
948 }
949 else if (load_raw == &LibRaw::redcine_load_raw)
950 {
951 d_info->decoder_name = "redcine_load_raw()";
952 d_info->decoder_flags = LIBRAW_DECODER_HASCURVE;
953 }
954 else if (load_raw == &LibRaw::x3f_load_raw)
955 {
956 d_info->decoder_name = "x3f_load_raw()";
957 d_info->decoder_flags = LIBRAW_DECODER_OWNALLOC | LIBRAW_DECODER_FIXEDMAXC | LIBRAW_DECODER_LEGACY_WITH_MARGINS;
958 }
959 else if (load_raw == &LibRaw::pentax_4shot_load_raw)
960 {
961 d_info->decoder_name = "pentax_4shot_load_raw()";
962 d_info->decoder_flags = LIBRAW_DECODER_OWNALLOC;
963 }
964 else if (load_raw == &LibRaw::deflate_dng_load_raw)
965 {
966 d_info->decoder_name = "deflate_dng_load_raw()";
967 d_info->decoder_flags = LIBRAW_DECODER_OWNALLOC;
968 }
969 else if (load_raw == &LibRaw::nikon_load_striped_packed_raw)
970 {
971 d_info->decoder_name = "nikon_load_striped_packed_raw()";
972 }
973 else
974 {
975 d_info->decoder_name = "Unknown unpack function";
976 d_info->decoder_flags = LIBRAW_DECODER_NOTSET;
977 }
978 return LIBRAW_SUCCESS;
979 }
980
adjust_maximum()981 int LibRaw::adjust_maximum()
982 {
983 ushort real_max;
984 float auto_threshold;
985
986 if (O.adjust_maximum_thr < 0.00001)
987 return LIBRAW_SUCCESS;
988 else if (O.adjust_maximum_thr > 0.99999)
989 auto_threshold = LIBRAW_DEFAULT_ADJUST_MAXIMUM_THRESHOLD;
990 else
991 auto_threshold = O.adjust_maximum_thr;
992
993 real_max = C.data_maximum;
994 if (real_max > 0 && real_max < C.maximum && real_max > C.maximum * auto_threshold)
995 {
996 C.maximum = real_max;
997 }
998 return LIBRAW_SUCCESS;
999 }
1000
merror(void * ptr,const char * where)1001 void LibRaw::merror(void *ptr, const char *where)
1002 {
1003 if (ptr)
1004 return;
1005 if (callbacks.mem_cb)
1006 (*callbacks.mem_cb)(
1007 callbacks.memcb_data,
1008 libraw_internal_data.internal_data.input ? libraw_internal_data.internal_data.input->fname() : NULL, where);
1009 throw LIBRAW_EXCEPTION_ALLOC;
1010 }
1011
open_file(const char * fname,INT64 max_buf_size)1012 int LibRaw::open_file(const char *fname, INT64 max_buf_size)
1013 {
1014 #ifndef WIN32
1015 struct stat st;
1016 if (stat(fname, &st))
1017 return LIBRAW_IO_ERROR;
1018 int big = (st.st_size > max_buf_size) ? 1 : 0;
1019 #else
1020 struct _stati64 st;
1021 if (_stati64(fname, &st))
1022 return LIBRAW_IO_ERROR;
1023 int big = (st.st_size > max_buf_size) ? 1 : 0;
1024 #endif
1025
1026 LibRaw_abstract_datastream *stream;
1027 try
1028 {
1029 if (big)
1030 stream = new LibRaw_bigfile_datastream(fname);
1031 else
1032 stream = new LibRaw_file_datastream(fname);
1033 }
1034
1035 catch (std::bad_alloc)
1036 {
1037 recycle();
1038 return LIBRAW_UNSUFFICIENT_MEMORY;
1039 }
1040 if (!stream->valid())
1041 {
1042 delete stream;
1043 return LIBRAW_IO_ERROR;
1044 }
1045 ID.input_internal = 0; // preserve from deletion on error
1046 int ret = open_datastream(stream);
1047 if (ret == LIBRAW_SUCCESS)
1048 {
1049 ID.input_internal = 1; // flag to delete datastream on recycle
1050 }
1051 else
1052 {
1053 delete stream;
1054 ID.input_internal = 0;
1055 }
1056 return ret;
1057 }
1058
1059 #if defined(_WIN32) && !defined(__MINGW32__) && defined(_MSC_VER) && (_MSC_VER > 1310)
open_file(const wchar_t * fname,INT64 max_buf_size)1060 int LibRaw::open_file(const wchar_t *fname, INT64 max_buf_size)
1061 {
1062 struct _stati64 st;
1063 if (_wstati64(fname, &st))
1064 return LIBRAW_IO_ERROR;
1065 int big = (st.st_size > max_buf_size) ? 1 : 0;
1066
1067 LibRaw_abstract_datastream *stream;
1068 try
1069 {
1070 if (big)
1071 stream = new LibRaw_bigfile_datastream(fname);
1072 else
1073 stream = new LibRaw_file_datastream(fname);
1074 }
1075
1076 catch (std::bad_alloc)
1077 {
1078 recycle();
1079 return LIBRAW_UNSUFFICIENT_MEMORY;
1080 }
1081 if (!stream->valid())
1082 {
1083 delete stream;
1084 return LIBRAW_IO_ERROR;
1085 }
1086 ID.input_internal = 0; // preserve from deletion on error
1087 int ret = open_datastream(stream);
1088 if (ret == LIBRAW_SUCCESS)
1089 {
1090 ID.input_internal = 1; // flag to delete datastream on recycle
1091 }
1092 else
1093 {
1094 delete stream;
1095 ID.input_internal = 0;
1096 }
1097 return ret;
1098 }
1099 #endif
1100
open_buffer(void * buffer,size_t size)1101 int LibRaw::open_buffer(void *buffer, size_t size)
1102 {
1103 // this stream will close on recycle()
1104 if (!buffer || buffer == (void *)-1)
1105 return LIBRAW_IO_ERROR;
1106
1107 LibRaw_buffer_datastream *stream;
1108 try
1109 {
1110 stream = new LibRaw_buffer_datastream(buffer, size);
1111 }
1112 catch (std::bad_alloc)
1113 {
1114 recycle();
1115 return LIBRAW_UNSUFFICIENT_MEMORY;
1116 }
1117 if (!stream->valid())
1118 {
1119 delete stream;
1120 return LIBRAW_IO_ERROR;
1121 }
1122 ID.input_internal = 0; // preserve from deletion on error
1123 int ret = open_datastream(stream);
1124 if (ret == LIBRAW_SUCCESS)
1125 {
1126 ID.input_internal = 1; // flag to delete datastream on recycle
1127 }
1128 else
1129 {
1130 delete stream;
1131 ID.input_internal = 0;
1132 }
1133 return ret;
1134 }
1135
open_bayer(unsigned char * buffer,unsigned datalen,ushort _raw_width,ushort _raw_height,ushort _left_margin,ushort _top_margin,ushort _right_margin,ushort _bottom_margin,unsigned char procflags,unsigned char bayer_pattern,unsigned unused_bits,unsigned otherflags,unsigned black_level)1136 int LibRaw::open_bayer(unsigned char *buffer, unsigned datalen, ushort _raw_width, ushort _raw_height,
1137 ushort _left_margin, ushort _top_margin, ushort _right_margin, ushort _bottom_margin,
1138 unsigned char procflags, unsigned char bayer_pattern, unsigned unused_bits, unsigned otherflags,
1139 unsigned black_level)
1140 {
1141 // this stream will close on recycle()
1142 if (!buffer || buffer == (void *)-1)
1143 return LIBRAW_IO_ERROR;
1144
1145 LibRaw_buffer_datastream *stream;
1146 try
1147 {
1148 stream = new LibRaw_buffer_datastream(buffer, datalen);
1149 }
1150 catch (std::bad_alloc)
1151 {
1152 recycle();
1153 return LIBRAW_UNSUFFICIENT_MEMORY;
1154 }
1155 if (!stream->valid())
1156 {
1157 delete stream;
1158 return LIBRAW_IO_ERROR;
1159 }
1160 ID.input = stream;
1161 SET_PROC_FLAG(LIBRAW_PROGRESS_OPEN);
1162 // From identify
1163 initdata();
1164 strcpy(imgdata.idata.make, "BayerDump");
1165 snprintf(imgdata.idata.model, sizeof(imgdata.idata.model) - 1, "%u x %u pixels", _raw_width, _raw_height);
1166 S.flip = procflags >> 2;
1167 libraw_internal_data.internal_output_params.zero_is_bad = procflags & 2;
1168 libraw_internal_data.unpacker_data.data_offset = 0;
1169 S.raw_width = _raw_width;
1170 S.raw_height = _raw_height;
1171 S.left_margin = _left_margin;
1172 S.top_margin = _top_margin;
1173 S.width = S.raw_width - S.left_margin - _right_margin;
1174 S.height = S.raw_height - S.top_margin - _bottom_margin;
1175
1176 imgdata.idata.filters = 0x1010101 * bayer_pattern;
1177 imgdata.idata.colors = 4 - !((imgdata.idata.filters & imgdata.idata.filters >> 1) & 0x5555);
1178 libraw_internal_data.unpacker_data.load_flags = otherflags;
1179 switch (libraw_internal_data.unpacker_data.tiff_bps = (datalen)*8 / (S.raw_width * S.raw_height))
1180 {
1181 case 8:
1182 load_raw = &CLASS eight_bit_load_raw;
1183 break;
1184 case 10:
1185 if ((datalen) / S.raw_height * 3 >= S.raw_width * 4)
1186 {
1187 load_raw = &CLASS android_loose_load_raw;
1188 break;
1189 }
1190 else if (libraw_internal_data.unpacker_data.load_flags & 1)
1191 {
1192 load_raw = &CLASS android_tight_load_raw;
1193 break;
1194 }
1195 case 12:
1196 libraw_internal_data.unpacker_data.load_flags |= 128;
1197 load_raw = &CLASS packed_load_raw;
1198 break;
1199 case 16:
1200 libraw_internal_data.unpacker_data.order = 0x4949 | 0x404 * (libraw_internal_data.unpacker_data.load_flags & 1);
1201 libraw_internal_data.unpacker_data.tiff_bps -= libraw_internal_data.unpacker_data.load_flags >> 4;
1202 libraw_internal_data.unpacker_data.tiff_bps -= libraw_internal_data.unpacker_data.load_flags =
1203 libraw_internal_data.unpacker_data.load_flags >> 1 & 7;
1204 load_raw = &CLASS unpacked_load_raw;
1205 }
1206 C.maximum = (1 << libraw_internal_data.unpacker_data.tiff_bps) - (1 << unused_bits);
1207 C.black = black_level;
1208 S.iwidth = S.width;
1209 S.iheight = S.height;
1210 imgdata.idata.colors = 3;
1211 imgdata.idata.filters |= ((imgdata.idata.filters >> 2 & 0x22222222) | (imgdata.idata.filters << 2 & 0x88888888)) &
1212 imgdata.idata.filters << 1;
1213
1214 imgdata.idata.raw_count = 1;
1215 for (int i = 0; i < 4; i++)
1216 imgdata.color.pre_mul[i] = 1.0;
1217
1218 strcpy(imgdata.idata.cdesc, "RGBG");
1219
1220 ID.input_internal = 1;
1221 SET_PROC_FLAG(LIBRAW_PROGRESS_IDENTIFY);
1222 return LIBRAW_SUCCESS;
1223 }
1224
1225 #ifdef USE_ZLIB
__DNG_HalfToFloat(ushort halfValue)1226 inline unsigned int __DNG_HalfToFloat(ushort halfValue)
1227 {
1228 int sign = (halfValue >> 15) & 0x00000001;
1229 int exponent = (halfValue >> 10) & 0x0000001f;
1230 int mantissa = halfValue & 0x000003ff;
1231 if (exponent == 0)
1232 {
1233 if (mantissa == 0)
1234 {
1235 return (unsigned int)(sign << 31);
1236 }
1237 else
1238 {
1239 while (!(mantissa & 0x00000400))
1240 {
1241 mantissa <<= 1;
1242 exponent -= 1;
1243 }
1244 exponent += 1;
1245 mantissa &= ~0x00000400;
1246 }
1247 }
1248 else if (exponent == 31)
1249 {
1250 if (mantissa == 0)
1251 {
1252 return (unsigned int)((sign << 31) | ((0x1eL + 127 - 15) << 23) | (0x3ffL << 13));
1253 }
1254 else
1255 {
1256 return 0;
1257 }
1258 }
1259 exponent += (127 - 15);
1260 mantissa <<= 13;
1261 return (unsigned int)((sign << 31) | (exponent << 23) | mantissa);
1262 }
1263
__DNG_FP24ToFloat(const unsigned char * input)1264 inline unsigned int __DNG_FP24ToFloat(const unsigned char *input)
1265 {
1266 int sign = (input[0] >> 7) & 0x01;
1267 int exponent = (input[0]) & 0x7F;
1268 int mantissa = (((int)input[1]) << 8) | input[2];
1269 if (exponent == 0)
1270 {
1271 if (mantissa == 0)
1272 {
1273 return (unsigned int)(sign << 31);
1274 }
1275 else
1276 {
1277 while (!(mantissa & 0x00010000))
1278 {
1279 mantissa <<= 1;
1280 exponent -= 1;
1281 }
1282 exponent += 1;
1283 mantissa &= ~0x00010000;
1284 }
1285 }
1286 else if (exponent == 127)
1287 {
1288 if (mantissa == 0)
1289 {
1290 return (unsigned int)((sign << 31) | ((0x7eL + 128 - 64) << 23) | (0xffffL << 7));
1291 }
1292 else
1293 {
1294 // Nan -- Just set to zero.
1295 return 0;
1296 }
1297 }
1298 exponent += (128 - 64);
1299 mantissa <<= 7;
1300 return (uint32_t)((sign << 31) | (exponent << 23) | mantissa);
1301 }
1302
DecodeDeltaBytes(unsigned char * bytePtr,int cols,int channels)1303 inline void DecodeDeltaBytes(unsigned char *bytePtr, int cols, int channels)
1304 {
1305 if (channels == 1)
1306 {
1307 unsigned char b0 = bytePtr[0];
1308 bytePtr += 1;
1309 for (uint32_t col = 1; col < cols; ++col)
1310 {
1311 b0 += bytePtr[0];
1312 bytePtr[0] = b0;
1313 bytePtr += 1;
1314 }
1315 }
1316 else if (channels == 3)
1317 {
1318 unsigned char b0 = bytePtr[0];
1319 unsigned char b1 = bytePtr[1];
1320 unsigned char b2 = bytePtr[2];
1321 bytePtr += 3;
1322 for (int col = 1; col < cols; ++col)
1323 {
1324 b0 += bytePtr[0];
1325 b1 += bytePtr[1];
1326 b2 += bytePtr[2];
1327 bytePtr[0] = b0;
1328 bytePtr[1] = b1;
1329 bytePtr[2] = b2;
1330 bytePtr += 3;
1331 }
1332 }
1333 else if (channels == 4)
1334 {
1335 unsigned char b0 = bytePtr[0];
1336 unsigned char b1 = bytePtr[1];
1337 unsigned char b2 = bytePtr[2];
1338 unsigned char b3 = bytePtr[3];
1339 bytePtr += 4;
1340 for (uint32_t col = 1; col < cols; ++col)
1341 {
1342 b0 += bytePtr[0];
1343 b1 += bytePtr[1];
1344 b2 += bytePtr[2];
1345 b3 += bytePtr[3];
1346 bytePtr[0] = b0;
1347 bytePtr[1] = b1;
1348 bytePtr[2] = b2;
1349 bytePtr[3] = b3;
1350 bytePtr += 4;
1351 }
1352 }
1353 else
1354 {
1355 for (int col = 1; col < cols; ++col)
1356 {
1357 for (int chan = 0; chan < channels; ++chan)
1358 {
1359 bytePtr[chan + channels] += bytePtr[chan];
1360 }
1361 bytePtr += channels;
1362 }
1363 }
1364 }
1365
DecodeFPDelta(unsigned char * input,unsigned char * output,int cols,int channels,int bytesPerSample)1366 static void DecodeFPDelta(unsigned char *input, unsigned char *output, int cols, int channels, int bytesPerSample)
1367 {
1368 DecodeDeltaBytes(input, cols * bytesPerSample, channels);
1369 int32_t rowIncrement = cols * channels;
1370
1371 if (bytesPerSample == 2)
1372 {
1373
1374 #if LibRawBigEndian
1375 const unsigned char *input0 = input;
1376 const unsigned char *input1 = input + rowIncrement;
1377 #else
1378 const unsigned char *input1 = input;
1379 const unsigned char *input0 = input + rowIncrement;
1380 #endif
1381 for (int col = 0; col < rowIncrement; ++col)
1382 {
1383 output[0] = input0[col];
1384 output[1] = input1[col];
1385 output += 2;
1386 }
1387 }
1388 else if (bytesPerSample == 3)
1389 {
1390 const unsigned char *input0 = input;
1391 const unsigned char *input1 = input + rowIncrement;
1392 const unsigned char *input2 = input + rowIncrement * 2;
1393 for (int col = 0; col < rowIncrement; ++col)
1394 {
1395 output[0] = input0[col];
1396 output[1] = input1[col];
1397 output[2] = input2[col];
1398 output += 3;
1399 }
1400 }
1401 else
1402 {
1403 #if LibRawBigEndian
1404 const unsigned char *input0 = input;
1405 const unsigned char *input1 = input + rowIncrement;
1406 const unsigned char *input2 = input + rowIncrement * 2;
1407 const unsigned char *input3 = input + rowIncrement * 3;
1408 #else
1409 const unsigned char *input3 = input;
1410 const unsigned char *input2 = input + rowIncrement;
1411 const unsigned char *input1 = input + rowIncrement * 2;
1412 const unsigned char *input0 = input + rowIncrement * 3;
1413 #endif
1414 for (int col = 0; col < rowIncrement; ++col)
1415 {
1416 output[0] = input0[col];
1417 output[1] = input1[col];
1418 output[2] = input2[col];
1419 output[3] = input3[col];
1420 output += 4;
1421 }
1422 }
1423 }
1424
expandFloats(unsigned char * dst,int tileWidth,int bytesps)1425 static float expandFloats(unsigned char *dst, int tileWidth, int bytesps)
1426 {
1427 float max = 0.f;
1428 if (bytesps == 2)
1429 {
1430 uint16_t *dst16 = (ushort *)dst;
1431 uint32_t *dst32 = (unsigned int *)dst;
1432 float *f32 = (float *)dst;
1433 for (int index = tileWidth - 1; index >= 0; --index)
1434 {
1435 dst32[index] = __DNG_HalfToFloat(dst16[index]);
1436 max = MAX(max, f32[index]);
1437 }
1438 }
1439 else if (bytesps == 3)
1440 {
1441 uint8_t *dst8 = ((unsigned char *)dst) + (tileWidth - 1) * 3;
1442 uint32_t *dst32 = (unsigned int *)dst;
1443 float *f32 = (float *)dst;
1444 for (int index = tileWidth - 1; index >= 0; --index, dst8 -= 3)
1445 {
1446 dst32[index] = __DNG_FP24ToFloat(dst8);
1447 max = MAX(max, f32[index]);
1448 }
1449 }
1450 else if (bytesps == 4)
1451 {
1452 float *f32 = (float *)dst;
1453 for (int index = 0; index < tileWidth; index++)
1454 max = MAX(max, f32[index]);
1455 }
1456 return max;
1457 }
1458
deflate_dng_load_raw()1459 void LibRaw::deflate_dng_load_raw()
1460 {
1461 struct tiff_ifd_t *ifd = &tiff_ifd[0];
1462 while (ifd < &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds] &&
1463 ifd->offset != libraw_internal_data.unpacker_data.data_offset)
1464 ++ifd;
1465 if (ifd == &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds])
1466 {
1467 throw LIBRAW_EXCEPTION_DECODE_RAW;
1468 }
1469
1470 float *float_raw_image = 0;
1471 float max = 0.f;
1472
1473 if (ifd->samples != 1 && ifd->samples != 3 && ifd->samples != 4)
1474 throw LIBRAW_EXCEPTION_DECODE_RAW; // Only float deflated supported
1475
1476 if (libraw_internal_data.unpacker_data.tiff_samples != ifd->samples)
1477 throw LIBRAW_EXCEPTION_DECODE_RAW; // Wrong IFD
1478
1479 size_t tilesH = (imgdata.sizes.raw_width + libraw_internal_data.unpacker_data.tile_width - 1) /
1480 libraw_internal_data.unpacker_data.tile_width;
1481 size_t tilesV = (imgdata.sizes.raw_height + libraw_internal_data.unpacker_data.tile_length - 1) /
1482 libraw_internal_data.unpacker_data.tile_length;
1483 size_t tileCnt = tilesH * tilesV;
1484
1485 if (ifd->sample_format == 3)
1486 { // Floating point data
1487 float_raw_image = (float *)calloc(tileCnt * libraw_internal_data.unpacker_data.tile_length *
1488 libraw_internal_data.unpacker_data.tile_width * ifd->samples,
1489 sizeof(float));
1490 // imgdata.color.maximum = 65535;
1491 // imgdata.color.black = 0;
1492 // memset(imgdata.color.cblack,0,sizeof(imgdata.color.cblack));
1493 }
1494 else
1495 throw LIBRAW_EXCEPTION_DECODE_RAW; // Only float deflated supported
1496
1497 int xFactor;
1498 switch (ifd->predictor)
1499 {
1500 case 3:
1501 default:
1502 xFactor = 1;
1503 break;
1504 case 34894:
1505 xFactor = 2;
1506 break;
1507 case 34895:
1508 xFactor = 4;
1509 break;
1510 }
1511
1512 if (libraw_internal_data.unpacker_data.tile_length < INT_MAX)
1513 {
1514 if (tileCnt < 1 || tileCnt > 1000000)
1515 throw LIBRAW_EXCEPTION_DECODE_RAW;
1516
1517 size_t *tOffsets = (size_t *)malloc(tileCnt * sizeof(size_t));
1518 for (int t = 0; t < tileCnt; ++t)
1519 tOffsets[t] = get4();
1520
1521 size_t *tBytes = (size_t *)malloc(tileCnt * sizeof(size_t));
1522 unsigned long maxBytesInTile = 0;
1523 if (tileCnt == 1)
1524 tBytes[0] = maxBytesInTile = ifd->bytes;
1525 else
1526 {
1527 libraw_internal_data.internal_data.input->seek(ifd->bytes, SEEK_SET);
1528 for (size_t t = 0; t < tileCnt; ++t)
1529 {
1530 tBytes[t] = get4();
1531 maxBytesInTile = MAX(maxBytesInTile, tBytes[t]);
1532 }
1533 }
1534 unsigned tilePixels =
1535 libraw_internal_data.unpacker_data.tile_width * libraw_internal_data.unpacker_data.tile_length;
1536 unsigned pixelSize = sizeof(float) * ifd->samples;
1537 unsigned tileBytes = tilePixels * pixelSize;
1538 unsigned tileRowBytes = libraw_internal_data.unpacker_data.tile_width * pixelSize;
1539
1540 unsigned char *cBuffer = (unsigned char *)malloc(maxBytesInTile);
1541 unsigned char *uBuffer = (unsigned char *)malloc(tileBytes + tileRowBytes); // extra row for decoding
1542
1543 for (size_t y = 0, t = 0; y < imgdata.sizes.raw_height; y += libraw_internal_data.unpacker_data.tile_length)
1544 {
1545 for (size_t x = 0; x < imgdata.sizes.raw_width; x += libraw_internal_data.unpacker_data.tile_width, ++t)
1546 {
1547 libraw_internal_data.internal_data.input->seek(tOffsets[t], SEEK_SET);
1548 libraw_internal_data.internal_data.input->read(cBuffer, 1, tBytes[t]);
1549 unsigned long dstLen = tileBytes;
1550 int err = uncompress(uBuffer + tileRowBytes, &dstLen, cBuffer, tBytes[t]);
1551 if (err != Z_OK)
1552 {
1553 free(tOffsets);
1554 free(tBytes);
1555 free(cBuffer);
1556 free(uBuffer);
1557 throw LIBRAW_EXCEPTION_DECODE_RAW;
1558 return;
1559 }
1560 else
1561 {
1562 int bytesps = ifd->bps >> 3;
1563 size_t rowsInTile = y + libraw_internal_data.unpacker_data.tile_length > imgdata.sizes.raw_height
1564 ? imgdata.sizes.raw_height - y
1565 : libraw_internal_data.unpacker_data.tile_length;
1566 size_t colsInTile = x + libraw_internal_data.unpacker_data.tile_width > imgdata.sizes.raw_width
1567 ? imgdata.sizes.raw_width - x
1568 : libraw_internal_data.unpacker_data.tile_width;
1569
1570 for (size_t row = 0; row < rowsInTile; ++row) // do not process full tile if not needed
1571 {
1572 unsigned char *dst = uBuffer + row * libraw_internal_data.unpacker_data.tile_width * bytesps * ifd->samples;
1573 unsigned char *src = dst + tileRowBytes;
1574 DecodeFPDelta(src, dst, libraw_internal_data.unpacker_data.tile_width / xFactor, ifd->samples * xFactor,
1575 bytesps);
1576 float lmax = expandFloats(dst, libraw_internal_data.unpacker_data.tile_width * ifd->samples, bytesps);
1577 max = MAX(max, lmax);
1578 unsigned char *dst2 =
1579 (unsigned char *)&float_raw_image[((y + row) * imgdata.sizes.raw_width + x) * ifd->samples];
1580 memmove(dst2, dst, colsInTile * ifd->samples * sizeof(float));
1581 }
1582 }
1583 }
1584 }
1585 free(tOffsets);
1586 free(tBytes);
1587 free(cBuffer);
1588 free(uBuffer);
1589 }
1590 imgdata.color.fmaximum = max;
1591
1592 // Set fields according to data format
1593
1594 imgdata.rawdata.raw_alloc = float_raw_image;
1595 if (ifd->samples == 1)
1596 {
1597 imgdata.rawdata.float_image = float_raw_image;
1598 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 4;
1599 }
1600 else if (ifd->samples == 3)
1601 {
1602 imgdata.rawdata.float3_image = (float(*)[3])float_raw_image;
1603 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 12;
1604 }
1605 else if (ifd->samples == 4)
1606 {
1607 imgdata.rawdata.float4_image = (float(*)[4])float_raw_image;
1608 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 16;
1609 }
1610
1611 if (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_CONVERTFLOAT_TO_INT)
1612 convertFloatToInt(); // with default settings
1613 }
1614 #else
deflate_dng_load_raw()1615 void LibRaw::deflate_dng_load_raw() { throw LIBRAW_EXCEPTION_DECODE_RAW; }
1616 #endif
1617
is_floating_point()1618 int LibRaw::is_floating_point()
1619 {
1620 struct tiff_ifd_t *ifd = &tiff_ifd[0];
1621 while (ifd < &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds] &&
1622 ifd->offset != libraw_internal_data.unpacker_data.data_offset)
1623 ++ifd;
1624 if (ifd == &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds])
1625 return 0;
1626
1627 return ifd->sample_format == 3;
1628 }
1629
have_fpdata()1630 int LibRaw::have_fpdata()
1631 {
1632 return imgdata.rawdata.float_image || imgdata.rawdata.float3_image || imgdata.rawdata.float4_image;
1633 }
1634
convertFloatToInt(float dmin,float dmax,float dtarget)1635 void LibRaw::convertFloatToInt(float dmin /* =4096.f */, float dmax /* =32767.f */, float dtarget /*= 16383.f */)
1636 {
1637 int samples = 0;
1638 float *data = 0;
1639 if (imgdata.rawdata.float_image)
1640 {
1641 samples = 1;
1642 data = imgdata.rawdata.float_image;
1643 }
1644 else if (imgdata.rawdata.float3_image)
1645 {
1646 samples = 3;
1647 data = (float *)imgdata.rawdata.float3_image;
1648 }
1649 else if (imgdata.rawdata.float4_image)
1650 {
1651 samples = 4;
1652 data = (float *)imgdata.rawdata.float4_image;
1653 }
1654 else
1655 return;
1656
1657 ushort *raw_alloc = (ushort *)malloc(imgdata.sizes.raw_height * imgdata.sizes.raw_width *
1658 libraw_internal_data.unpacker_data.tiff_samples * sizeof(ushort));
1659 float tmax = MAX(imgdata.color.maximum, 1);
1660 float datamax = imgdata.color.fmaximum;
1661
1662 tmax = MAX(tmax, datamax);
1663 tmax = MAX(tmax, 1.f);
1664
1665 float multip = 1.f;
1666 if (tmax < dmin || tmax > dmax)
1667 {
1668 imgdata.rawdata.color.fnorm = imgdata.color.fnorm = multip = dtarget / tmax;
1669 imgdata.rawdata.color.maximum = imgdata.color.maximum = dtarget;
1670 imgdata.rawdata.color.black = imgdata.color.black = (float)imgdata.color.black * multip;
1671 for (int i = 0; i < sizeof(imgdata.color.cblack) / sizeof(imgdata.color.cblack[0]); i++)
1672 if (i != 4 && i != 5)
1673 imgdata.rawdata.color.cblack[i] = imgdata.color.cblack[i] = (float)imgdata.color.cblack[i] * multip;
1674 }
1675 else
1676 imgdata.rawdata.color.fnorm = imgdata.color.fnorm = 0.f;
1677
1678 for (size_t i = 0;
1679 i < imgdata.sizes.raw_height * imgdata.sizes.raw_width * libraw_internal_data.unpacker_data.tiff_samples; ++i)
1680 {
1681 float val = MAX(data[i], 0.f);
1682 raw_alloc[i] = (ushort)(val * multip);
1683 }
1684
1685 if (samples == 1)
1686 {
1687 imgdata.rawdata.raw_alloc = imgdata.rawdata.raw_image = raw_alloc;
1688 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 2;
1689 }
1690 else if (samples == 3)
1691 {
1692 imgdata.rawdata.raw_alloc = imgdata.rawdata.color3_image = (ushort(*)[3])raw_alloc;
1693 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 6;
1694 }
1695 else if (samples == 4)
1696 {
1697 imgdata.rawdata.raw_alloc = imgdata.rawdata.color4_image = (ushort(*)[4])raw_alloc;
1698 imgdata.rawdata.sizes.raw_pitch = imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 8;
1699 }
1700 free(data); // remove old allocation
1701 imgdata.rawdata.float_image = 0;
1702 imgdata.rawdata.float3_image = 0;
1703 imgdata.rawdata.float4_image = 0;
1704 }
1705
sony_arq_load_raw()1706 void LibRaw::sony_arq_load_raw()
1707 {
1708 int row, col;
1709 read_shorts(imgdata.rawdata.raw_image, imgdata.sizes.raw_width * imgdata.sizes.raw_height * 4);
1710 libraw_internal_data.internal_data.input->seek(-2,SEEK_CUR); // avoid wrong eof error
1711 for (row = 0; row < imgdata.sizes.raw_height; row++)
1712 {
1713 unsigned short(*rowp)[4] = (unsigned short(*)[4]) & imgdata.rawdata.raw_image[row * imgdata.sizes.raw_width * 4];
1714 for (col = 0; col < imgdata.sizes.raw_width; col++)
1715 {
1716 unsigned short g2 = rowp[col][2];
1717 rowp[col][2] = rowp[col][3];
1718 rowp[col][3] = g2;
1719 if (((unsigned)(row - imgdata.sizes.top_margin) < imgdata.sizes.height) &&
1720 ((unsigned)(col - imgdata.sizes.left_margin) < imgdata.sizes.width) &&
1721 (MAX(MAX(rowp[col][0], rowp[col][1]), MAX(rowp[col][2], rowp[col][3])) > imgdata.color.maximum))
1722 derror();
1723 }
1724 }
1725 }
1726
pentax_4shot_load_raw()1727 void LibRaw::pentax_4shot_load_raw()
1728 {
1729 ushort *plane = (ushort *)malloc(imgdata.sizes.raw_width * imgdata.sizes.raw_height * sizeof(ushort));
1730 int alloc_sz = imgdata.sizes.raw_width * (imgdata.sizes.raw_height + 16) * 4 * sizeof(ushort);
1731 ushort(*result)[4] = (ushort(*)[4])malloc(alloc_sz);
1732 struct movement_t
1733 {
1734 int row, col;
1735 } _move[4] = {
1736 {1, 1},
1737 {0, 1},
1738 {0, 0},
1739 {1, 0},
1740 };
1741
1742 int tidx = 0;
1743 for (int i = 0; i < 4; i++)
1744 {
1745 int move_row, move_col;
1746 if (imgdata.params.p4shot_order[i] >= '0' && imgdata.params.p4shot_order[i] <= '3')
1747 {
1748 move_row = (imgdata.params.p4shot_order[i] - '0' & 2) ? 1 : 0;
1749 move_col = (imgdata.params.p4shot_order[i] - '0' & 1) ? 1 : 0;
1750 }
1751 else
1752 {
1753 move_row = _move[i].row;
1754 move_col = _move[i].col;
1755 }
1756 for (; tidx < 16; tidx++)
1757 if (tiff_ifd[tidx].t_width == imgdata.sizes.raw_width && tiff_ifd[tidx].t_height == imgdata.sizes.raw_height &&
1758 tiff_ifd[tidx].bps > 8 && tiff_ifd[tidx].samples == 1)
1759 break;
1760 if (tidx >= 16)
1761 break;
1762 imgdata.rawdata.raw_image = plane;
1763 ID.input->seek(tiff_ifd[tidx].offset, SEEK_SET);
1764 imgdata.idata.filters = 0xb4b4b4b4;
1765 libraw_internal_data.unpacker_data.data_offset = tiff_ifd[tidx].offset;
1766 (this->*pentax_component_load_raw)();
1767 for (int row = 0; row < imgdata.sizes.raw_height - move_row; row++)
1768 {
1769 int colors[2];
1770 for (int c = 0; c < 2; c++)
1771 colors[c] = COLOR(row, c);
1772 ushort *srcrow = &plane[imgdata.sizes.raw_width * row];
1773 ushort(*dstrow)[4] = &result[(imgdata.sizes.raw_width) * (row + move_row) + move_col];
1774 for (int col = 0; col < imgdata.sizes.raw_width - move_col; col++)
1775 dstrow[col][colors[col % 2]] = srcrow[col];
1776 }
1777 tidx++;
1778 }
1779 // assign things back:
1780 imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 8;
1781 imgdata.idata.filters = 0;
1782 imgdata.rawdata.raw_alloc = imgdata.rawdata.color4_image = result;
1783 free(plane);
1784 imgdata.rawdata.raw_image = 0;
1785 }
1786
hasselblad_full_load_raw()1787 void LibRaw::hasselblad_full_load_raw()
1788 {
1789 int row, col;
1790
1791 for (row = 0; row < S.height; row++)
1792 for (col = 0; col < S.width; col++)
1793 {
1794 read_shorts(&imgdata.image[row * S.width + col][2], 1); // B
1795 read_shorts(&imgdata.image[row * S.width + col][1], 1); // G
1796 read_shorts(&imgdata.image[row * S.width + col][0], 1); // R
1797 }
1798 }
1799
unpack7bytesto4x16(unsigned char * src,unsigned short * dest)1800 static inline void unpack7bytesto4x16(unsigned char *src, unsigned short *dest)
1801 {
1802 dest[0] = (src[0] << 6) | (src[1] >> 2);
1803 dest[1] = ((src[1] & 0x3) << 12) | (src[2] << 4) | (src[3] >> 4);
1804 dest[2] = (src[3] & 0xf) << 10 | (src[4] << 2) | (src[5] >> 6);
1805 dest[3] = ((src[5] & 0x3f) << 8) | src[6];
1806 }
1807
unpack28bytesto16x16ns(unsigned char * src,unsigned short * dest)1808 static inline void unpack28bytesto16x16ns(unsigned char *src, unsigned short *dest)
1809 {
1810 dest[0] = (src[3] << 6) | (src[2] >> 2);
1811 dest[1] = ((src[2] & 0x3) << 12) | (src[1] << 4) | (src[0] >> 4);
1812 dest[2] = (src[0] & 0xf) << 10 | (src[7] << 2) | (src[6] >> 6);
1813 dest[3] = ((src[6] & 0x3f) << 8) | src[5];
1814 dest[4] = (src[4] << 6) | (src[11] >> 2);
1815 dest[5] = ((src[11] & 0x3) << 12) | (src[10] << 4) | (src[9] >> 4);
1816 dest[6] = (src[9] & 0xf) << 10 | (src[8] << 2) | (src[15] >> 6);
1817 dest[7] = ((src[15] & 0x3f) << 8) | src[14];
1818 dest[8] = (src[13] << 6) | (src[12] >> 2);
1819 dest[9] = ((src[12] & 0x3) << 12) | (src[19] << 4) | (src[18] >> 4);
1820 dest[10] = (src[18] & 0xf) << 10 | (src[17] << 2) | (src[16] >> 6);
1821 dest[11] = ((src[16] & 0x3f) << 8) | src[23];
1822 dest[12] = (src[22] << 6) | (src[21] >> 2);
1823 dest[13] = ((src[21] & 0x3) << 12) | (src[20] << 4) | (src[27] >> 4);
1824 dest[14] = (src[27] & 0xf) << 10 | (src[26] << 2) | (src[25] >> 6);
1825 dest[15] = ((src[25] & 0x3f) << 8) | src[24];
1826 }
1827
1828 #define swab32(x) \
1829 ((unsigned int)((((unsigned int)(x) & (unsigned int)0x000000ffUL) << 24) | \
1830 (((unsigned int)(x) & (unsigned int)0x0000ff00UL) << 8) | \
1831 (((unsigned int)(x) & (unsigned int)0x00ff0000UL) >> 8) | \
1832 (((unsigned int)(x) & (unsigned int)0xff000000UL) >> 24)))
1833
swab32arr(unsigned * arr,unsigned len)1834 static inline void swab32arr(unsigned *arr, unsigned len)
1835 {
1836 for (unsigned i = 0; i < len; i++)
1837 arr[i] = swab32(arr[i]);
1838 }
1839 #undef swab32
1840
fuji_14bit_load_raw()1841 void LibRaw::fuji_14bit_load_raw()
1842 {
1843 const unsigned linelen = S.raw_width * 7 / 4;
1844 const unsigned pitch = S.raw_pitch ? S.raw_pitch / 2 : S.raw_width;
1845 unsigned char *buf = (unsigned char *)malloc(linelen);
1846 merror(buf, "fuji_14bit_load_raw()");
1847
1848 for (int row = 0; row < S.raw_height; row++)
1849 {
1850 unsigned bytesread = libraw_internal_data.internal_data.input->read(buf, 1, linelen);
1851 unsigned short *dest = &imgdata.rawdata.raw_image[pitch * row];
1852 if (bytesread % 28)
1853 {
1854 swab32arr((unsigned *)buf, bytesread / 4);
1855 for (int sp = 0, dp = 0; dp < pitch - 3 && sp < linelen - 6 && sp < bytesread - 6; sp += 7, dp += 4)
1856 unpack7bytesto4x16(buf + sp, dest + dp);
1857 }
1858 else
1859 for (int sp = 0, dp = 0; dp < pitch - 15 && sp < linelen - 27 && sp < bytesread - 27; sp += 28, dp += 16)
1860 unpack28bytesto16x16ns(buf + sp, dest + dp);
1861 }
1862 free(buf);
1863 }
1864
nikon_load_striped_packed_raw()1865 void LibRaw::nikon_load_striped_packed_raw()
1866 {
1867 int vbits = 0, bwide, rbits, bite, row, col, val, i;
1868
1869 UINT64 bitbuf = 0;
1870 unsigned load_flags = 24; // libraw_internal_data.unpacker_data.load_flags;
1871 unsigned tiff_bps = libraw_internal_data.unpacker_data.tiff_bps;
1872 int tiff_compress = libraw_internal_data.unpacker_data.tiff_compress;
1873
1874 struct tiff_ifd_t *ifd = &tiff_ifd[0];
1875 while (ifd < &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds] &&
1876 ifd->offset != libraw_internal_data.unpacker_data.data_offset)
1877 ++ifd;
1878 if (ifd == &tiff_ifd[libraw_internal_data.identify_data.tiff_nifds])
1879 throw LIBRAW_EXCEPTION_DECODE_RAW;
1880
1881 if (!ifd->rows_per_strip || !ifd->strip_offsets_count)
1882 return; // not unpacked
1883 int stripcnt = 0;
1884
1885 bwide = S.raw_width * tiff_bps / 8;
1886 bwide += bwide & load_flags >> 7;
1887 rbits = bwide * 8 - S.raw_width * tiff_bps;
1888 if (load_flags & 1)
1889 bwide = bwide * 16 / 15;
1890 bite = 8 + (load_flags & 24);
1891 for (row = 0; row < S.raw_height; row++)
1892 {
1893 checkCancel();
1894 if (!(row % ifd->rows_per_strip))
1895 {
1896 if (stripcnt >= ifd->strip_offsets_count)
1897 return; // run out of data
1898 libraw_internal_data.internal_data.input->seek(ifd->strip_offsets[stripcnt], SEEK_SET);
1899 stripcnt++;
1900 }
1901 for (col = 0; col < S.raw_width; col++)
1902 {
1903 for (vbits -= tiff_bps; vbits < 0; vbits += bite)
1904 {
1905 bitbuf <<= bite;
1906 for (i = 0; i < bite; i += 8)
1907 bitbuf |= (unsigned)(libraw_internal_data.internal_data.input->get_char() << i);
1908 }
1909 imgdata.rawdata.raw_image[(row)*S.raw_width + (col)] = bitbuf << (64 - tiff_bps - vbits) >> (64 - tiff_bps);
1910 }
1911 vbits -= rbits;
1912 }
1913 }
1914
1915 struct foveon_data_t
1916 {
1917 const char *make;
1918 const char *model;
1919 const int raw_width, raw_height;
1920 const int white;
1921 const int left_margin, top_margin;
1922 const int width, height;
1923 } foveon_data[] = {
1924 {"Sigma", "SD9", 2304, 1531, 12000, 20, 8, 2266, 1510},
1925 {"Sigma", "SD9", 1152, 763, 12000, 10, 2, 1132, 755},
1926 {"Sigma", "SD10", 2304, 1531, 12000, 20, 8, 2266, 1510},
1927 {"Sigma", "SD10", 1152, 763, 12000, 10, 2, 1132, 755},
1928 {"Sigma", "SD14", 2688, 1792, 14000, 18, 12, 2651, 1767},
1929 {"Sigma", "SD14", 2688, 896, 14000, 18, 6, 2651, 883}, // 2/3
1930 {"Sigma", "SD14", 1344, 896, 14000, 9, 6, 1326, 883}, // 1/2
1931 {"Sigma", "SD15", 2688, 1792, 2900, 18, 12, 2651, 1767},
1932 {"Sigma", "SD15", 2688, 896, 2900, 18, 6, 2651, 883}, // 2/3 ?
1933 {"Sigma", "SD15", 1344, 896, 2900, 9, 6, 1326, 883}, // 1/2 ?
1934 {"Sigma", "DP1", 2688, 1792, 2100, 18, 12, 2651, 1767},
1935 {"Sigma", "DP1", 2688, 896, 2100, 18, 6, 2651, 883}, // 2/3 ?
1936 {"Sigma", "DP1", 1344, 896, 2100, 9, 6, 1326, 883}, // 1/2 ?
1937 {"Sigma", "DP1S", 2688, 1792, 2200, 18, 12, 2651, 1767},
1938 {"Sigma", "DP1S", 2688, 896, 2200, 18, 6, 2651, 883}, // 2/3
1939 {"Sigma", "DP1S", 1344, 896, 2200, 9, 6, 1326, 883}, // 1/2
1940 {"Sigma", "DP1X", 2688, 1792, 3560, 18, 12, 2651, 1767},
1941 {"Sigma", "DP1X", 2688, 896, 3560, 18, 6, 2651, 883}, // 2/3
1942 {"Sigma", "DP1X", 1344, 896, 3560, 9, 6, 1326, 883}, // 1/2
1943 {"Sigma", "DP2", 2688, 1792, 2326, 13, 16, 2651, 1767},
1944 {"Sigma", "DP2", 2688, 896, 2326, 13, 8, 2651, 883}, // 2/3 ??
1945 {"Sigma", "DP2", 1344, 896, 2326, 7, 8, 1325, 883}, // 1/2 ??
1946 {"Sigma", "DP2S", 2688, 1792, 2300, 18, 12, 2651, 1767},
1947 {"Sigma", "DP2S", 2688, 896, 2300, 18, 6, 2651, 883}, // 2/3
1948 {"Sigma", "DP2S", 1344, 896, 2300, 9, 6, 1326, 883}, // 1/2
1949 {"Sigma", "DP2X", 2688, 1792, 2300, 18, 12, 2651, 1767},
1950 {"Sigma", "DP2X", 2688, 896, 2300, 18, 6, 2651, 883}, // 2/3
1951 {"Sigma", "DP2X", 1344, 896, 2300, 9, 6, 1325, 883}, // 1/2
1952 {"Sigma", "SD1", 4928, 3264, 3900, 12, 52, 4807, 3205}, // Full size
1953 {"Sigma", "SD1", 4928, 1632, 3900, 12, 26, 4807, 1603}, // 2/3 size
1954 {"Sigma", "SD1", 2464, 1632, 3900, 6, 26, 2403, 1603}, // 1/2 size
1955 {"Sigma", "SD1 Merrill", 4928, 3264, 3900, 12, 52, 4807, 3205}, // Full size
1956 {"Sigma", "SD1 Merrill", 4928, 1632, 3900, 12, 26, 4807, 1603}, // 2/3 size
1957 {"Sigma", "SD1 Merrill", 2464, 1632, 3900, 6, 26, 2403, 1603}, // 1/2 size
1958 {"Sigma", "DP1 Merrill", 4928, 3264, 3900, 12, 0, 4807, 3205},
1959 {"Sigma", "DP1 Merrill", 2464, 1632, 3900, 12, 0, 2403, 1603}, // 1/2 size
1960 {"Sigma", "DP1 Merrill", 4928, 1632, 3900, 12, 0, 4807, 1603}, // 2/3 size
1961 {"Sigma", "DP2 Merrill", 4928, 3264, 3900, 12, 0, 4807, 3205},
1962 {"Sigma", "DP2 Merrill", 2464, 1632, 3900, 12, 0, 2403, 1603}, // 1/2 size
1963 {"Sigma", "DP2 Merrill", 4928, 1632, 3900, 12, 0, 4807, 1603}, // 2/3 size
1964 {"Sigma", "DP3 Merrill", 4928, 3264, 3900, 12, 0, 4807, 3205},
1965 {"Sigma", "DP3 Merrill", 2464, 1632, 3900, 12, 0, 2403, 1603}, // 1/2 size
1966 {"Sigma", "DP3 Merrill", 4928, 1632, 3900, 12, 0, 4807, 1603}, // 2/3 size
1967 {"Polaroid", "x530", 1440, 1088, 2700, 10, 13, 1419, 1059},
1968 // dp2 Q
1969 {"Sigma", "dp3 Quattro", 5888, 3672, 16383, 204, 24, 5446, 3624}, // full size
1970 {"Sigma", "dp3 Quattro", 2944, 1836, 16383, 102, 12, 2723, 1812}, // half size
1971 {"Sigma", "dp2 Quattro", 5888, 3672, 16383, 204, 24, 5446, 3624}, // full size
1972 {"Sigma", "dp2 Quattro", 2944, 1836, 16383, 102, 12, 2723, 1812}, // half size
1973 {"Sigma", "dp1 Quattro", 5888, 3672, 16383, 204, 24, 5446, 3624}, // full size
1974 {"Sigma", "dp1 Quattro", 2944, 1836, 16383, 102, 12, 2723, 1812}, // half size
1975 {"Sigma", "dp0 Quattro", 5888, 3672, 16383, 204, 24, 5446, 3624}, // full size
1976 {"Sigma", "dp0 Quattro", 2944, 1836, 16383, 102, 12, 2723, 1812}, // half size
1977 // Sigma sd Quattro
1978 {"Sigma", "sd Quattro", 5888, 3776, 16383, 204, 76, 5446, 3624}, // full size
1979 {"Sigma", "sd Quattro", 2944, 1888, 16383, 102, 38, 2723, 1812}, // half size
1980 // Sd Quattro H
1981 {"Sigma", "sd Quattro H", 6656, 4480, 16383, 224, 160, 6208, 4160}, // full size
1982 {"Sigma", "sd Quattro H", 3328, 2240, 16383, 112, 80, 3104, 2080}, // half size
1983 {"Sigma", "sd Quattro H", 5504, 3680, 16383, 0, 4, 5496, 3668}, // full size
1984 {"Sigma", "sd Quattro H", 2752, 1840, 16383, 0, 2, 2748, 1834}, // half size
1985 };
1986 const int foveon_count = sizeof(foveon_data) / sizeof(foveon_data[0]);
1987
open_datastream(LibRaw_abstract_datastream * stream)1988 int LibRaw::open_datastream(LibRaw_abstract_datastream *stream)
1989 {
1990
1991 if (!stream)
1992 return ENOENT;
1993 if (!stream->valid())
1994 return LIBRAW_IO_ERROR;
1995 recycle();
1996 if(callbacks.pre_identify_cb)
1997 {
1998 int r = (callbacks.pre_identify_cb)(this);
1999 if(r == 1) goto final;
2000 }
2001
2002
2003 try
2004 {
2005 ID.input = stream;
2006 SET_PROC_FLAG(LIBRAW_PROGRESS_OPEN);
2007
2008 identify();
2009 if(callbacks.post_identify_cb)
2010 (callbacks.post_identify_cb)(this);
2011
2012
2013 // Linear max from 14-bit camera, but on 12-bit data?
2014 if(( !strcasecmp(imgdata.idata.make, "Sony") /* || !strcasecmp(imgdata.idata.make, "Nikon") */)
2015 && imgdata.color.maximum > 0 && imgdata.color.linear_max[0] > imgdata.color.maximum
2016 && imgdata.color.linear_max[0] <= imgdata.color.maximum*4)
2017 for(int c = 0; c<4; c++)
2018 imgdata.color.linear_max[c] /= 4;
2019
2020 if (!strcasecmp(imgdata.idata.make, "Canon") && (load_raw == &LibRaw::canon_sraw_load_raw) &&
2021 imgdata.sizes.raw_width > 0)
2022 {
2023 float ratio = float(imgdata.sizes.raw_height) / float(imgdata.sizes.raw_width);
2024 if ((ratio < 0.57 || ratio > 0.75) && imgdata.makernotes.canon.SensorHeight > 1 &&
2025 imgdata.makernotes.canon.SensorWidth > 1)
2026 {
2027 imgdata.sizes.raw_width = imgdata.makernotes.canon.SensorWidth;
2028 imgdata.sizes.left_margin = imgdata.makernotes.canon.SensorLeftBorder;
2029 imgdata.sizes.iwidth = imgdata.sizes.width =
2030 imgdata.makernotes.canon.SensorRightBorder - imgdata.makernotes.canon.SensorLeftBorder + 1;
2031 imgdata.sizes.raw_height = imgdata.makernotes.canon.SensorHeight;
2032 imgdata.sizes.top_margin = imgdata.makernotes.canon.SensorTopBorder;
2033 imgdata.sizes.iheight = imgdata.sizes.height =
2034 imgdata.makernotes.canon.SensorBottomBorder - imgdata.makernotes.canon.SensorTopBorder + 1;
2035 libraw_internal_data.unpacker_data.load_flags |= 256; // reset width/height in canon_sraw_load_raw()
2036 imgdata.sizes.raw_pitch = 8 * imgdata.sizes.raw_width;
2037 }
2038 else if (imgdata.sizes.raw_width == 4032 && imgdata.sizes.raw_height == 3402 &&
2039 !strcasecmp(imgdata.idata.model, "EOS 80D")) // 80D hardcoded
2040 {
2041 imgdata.sizes.raw_width = 4536;
2042 imgdata.sizes.left_margin = 28;
2043 imgdata.sizes.iwidth = imgdata.sizes.width = imgdata.sizes.raw_width - imgdata.sizes.left_margin;
2044 imgdata.sizes.raw_height = 3024;
2045 imgdata.sizes.top_margin = 8;
2046 imgdata.sizes.iheight = imgdata.sizes.height = imgdata.sizes.raw_height - imgdata.sizes.top_margin;
2047 libraw_internal_data.unpacker_data.load_flags |= 256;
2048 imgdata.sizes.raw_pitch = 8 * imgdata.sizes.raw_width;
2049 }
2050 }
2051
2052 // XTrans Compressed?
2053 if (!imgdata.idata.dng_version && !strcasecmp(imgdata.idata.make, "Fujifilm") &&
2054 (load_raw == &LibRaw::unpacked_load_raw))
2055 {
2056 if (imgdata.sizes.raw_width * imgdata.sizes.raw_height * 2 != libraw_internal_data.unpacker_data.data_size)
2057 {
2058 if (imgdata.sizes.raw_width * imgdata.sizes.raw_height * 7 / 4 == libraw_internal_data.unpacker_data.data_size)
2059 load_raw = &LibRaw::fuji_14bit_load_raw;
2060 else
2061 parse_fuji_compressed_header();
2062 }
2063 if (imgdata.idata.filters == 9)
2064 {
2065 // Adjust top/left margins for X-Trans
2066 int newtm = imgdata.sizes.top_margin % 6 ? (imgdata.sizes.top_margin / 6 + 1) * 6 : imgdata.sizes.top_margin;
2067 int newlm = imgdata.sizes.left_margin % 6 ? (imgdata.sizes.left_margin / 6 + 1) * 6 : imgdata.sizes.left_margin;
2068 if (newtm != imgdata.sizes.top_margin || newlm != imgdata.sizes.left_margin)
2069 {
2070 imgdata.sizes.height -= (newtm - imgdata.sizes.top_margin);
2071 imgdata.sizes.top_margin = newtm;
2072 imgdata.sizes.width -= (newlm - imgdata.sizes.left_margin);
2073 imgdata.sizes.left_margin = newlm;
2074 for (int c1 = 0; c1 < 6; c1++)
2075 for (int c2 = 0; c2 < 6; c2++)
2076 imgdata.idata.xtrans[c1][c2] = imgdata.idata.xtrans_abs[c1][c2];
2077 }
2078 }
2079 }
2080
2081 // Fix DNG white balance if needed
2082 if (imgdata.idata.dng_version && (imgdata.idata.filters == 0) && imgdata.idata.colors > 1 &&
2083 imgdata.idata.colors < 5)
2084 {
2085 float delta[4] = {0.f, 0.f, 0.f, 0.f};
2086 int black[4];
2087 for (int c = 0; c < 4; c++)
2088 black[c] = imgdata.color.dng_levels.dng_black + imgdata.color.dng_levels.dng_cblack[c];
2089 for (int c = 0; c < imgdata.idata.colors; c++)
2090 delta[c] = imgdata.color.dng_levels.dng_whitelevel[c] - black[c];
2091 float mindelta = delta[0], maxdelta = delta[0];
2092 for (int c = 1; c < imgdata.idata.colors; c++)
2093 {
2094 if (mindelta > delta[c])
2095 mindelta = delta[c];
2096 if (maxdelta < delta[c])
2097 maxdelta = delta[c];
2098 }
2099 if (mindelta > 1 && maxdelta < (mindelta * 20)) // safety
2100 {
2101 for (int c = 0; c < imgdata.idata.colors; c++)
2102 {
2103 imgdata.color.cam_mul[c] /= (delta[c] / maxdelta);
2104 imgdata.color.pre_mul[c] /= (delta[c] / maxdelta);
2105 }
2106 imgdata.color.maximum = imgdata.color.cblack[0] + maxdelta;
2107 }
2108 }
2109
2110 if (imgdata.idata.dng_version &&
2111 ((!strcasecmp(imgdata.idata.make, "Leica") && !strcasecmp(imgdata.idata.model, "D-LUX (Typ 109)")) ||
2112 (!strcasecmp(imgdata.idata.make, "Panasonic") && !strcasecmp(imgdata.idata.model, "LX100"))))
2113 imgdata.sizes.width = 4288;
2114
2115 if (!strncasecmp(imgdata.idata.make, "Sony", 4) && imgdata.idata.dng_version &&
2116 !(imgdata.params.raw_processing_options & LIBRAW_PROCESSING_USE_DNG_DEFAULT_CROP))
2117 {
2118 if (S.raw_width == 3984)
2119 S.width = 3925;
2120 else if (S.raw_width == 4288)
2121 S.width = S.raw_width - 32;
2122 else if (S.raw_width == 4928 && S.height < 3280)
2123 S.width = S.raw_width - 8;
2124 else if (S.raw_width == 5504)
2125 S.width = S.raw_width - (S.height > 3664 ? 8 : 32);
2126 }
2127
2128 if (!strcasecmp(imgdata.idata.make, "Pentax") &&
2129 /*!strcasecmp(imgdata.idata.model,"K-3 II") &&*/ imgdata.idata.raw_count == 4 &&
2130 (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_PENTAX_PS_ALLFRAMES))
2131 {
2132 imgdata.idata.raw_count = 1;
2133 imgdata.idata.filters = 0;
2134 imgdata.idata.colors = 4;
2135 IO.mix_green = 1;
2136 pentax_component_load_raw = load_raw;
2137 load_raw = &LibRaw::pentax_4shot_load_raw;
2138 }
2139
2140 if (!imgdata.idata.dng_version && !strcmp(imgdata.idata.make, "Leaf") && !strcmp(imgdata.idata.model, "Credo 50"))
2141 {
2142 imgdata.color.pre_mul[0] = 1.f / 0.3984f;
2143 imgdata.color.pre_mul[2] = 1.f / 0.7666f;
2144 imgdata.color.pre_mul[1] = imgdata.color.pre_mul[3] = 1.0;
2145 }
2146
2147 // S3Pro DNG patch
2148 if (imgdata.idata.dng_version && !strcmp(imgdata.idata.make, "Fujifilm") && !strcmp(imgdata.idata.model, "S3Pro") &&
2149 imgdata.sizes.raw_width == 4288)
2150 {
2151 imgdata.sizes.left_margin++;
2152 imgdata.sizes.width--;
2153 }
2154 if (imgdata.idata.dng_version && !strcmp(imgdata.idata.make, "Fujifilm") && !strcmp(imgdata.idata.model, "S5Pro") &&
2155 imgdata.sizes.raw_width == 4288)
2156 {
2157 imgdata.sizes.left_margin++;
2158 imgdata.sizes.width--;
2159 }
2160 if (!imgdata.idata.dng_version && !strcmp(imgdata.idata.make, "Fujifilm") &&
2161 (!strncmp(imgdata.idata.model, "S20Pro", 6) || !strncmp(imgdata.idata.model, "F700", 4)))
2162 {
2163 imgdata.sizes.raw_width /= 2;
2164 load_raw = &LibRaw::unpacked_load_raw_fuji_f700s20;
2165 }
2166 if (load_raw == &LibRaw::packed_load_raw && !strcasecmp(imgdata.idata.make, "Nikon") &&
2167 !libraw_internal_data.unpacker_data.load_flags &&
2168 (!strncasecmp(imgdata.idata.model, "D810", 4) || !strcasecmp(imgdata.idata.model, "D4S")) &&
2169 libraw_internal_data.unpacker_data.data_size * 2 == imgdata.sizes.raw_height * imgdata.sizes.raw_width * 3)
2170 {
2171 libraw_internal_data.unpacker_data.load_flags = 80;
2172 }
2173 // Adjust BL for Sony A900/A850
2174 if (load_raw == &LibRaw::packed_load_raw &&
2175 !strcasecmp(imgdata.idata.make, "Sony")) // 12 bit sony, but metadata may be for 14-bit range
2176 {
2177 if (C.maximum > 4095)
2178 C.maximum = 4095;
2179 if (C.black > 256 || C.cblack[0] > 256)
2180 {
2181 C.black /= 4;
2182 for (int c = 0; c < 4; c++)
2183 C.cblack[c] /= 4;
2184 for (int c = 0; c < C.cblack[4] * C.cblack[5]; c++)
2185 C.cblack[6 + c] /= 4;
2186 }
2187 }
2188 if (load_raw == &LibRaw::nikon_yuv_load_raw) // Is it Nikon sRAW?
2189 {
2190 load_raw = &LibRaw::nikon_load_sraw;
2191 C.black = 0;
2192 memset(C.cblack, 0, sizeof(C.cblack));
2193 imgdata.idata.filters = 0;
2194 libraw_internal_data.unpacker_data.tiff_samples = 3;
2195 imgdata.idata.colors = 3;
2196 double beta_1 = -5.79342238397656E-02;
2197 double beta_2 = 3.28163551282665;
2198 double beta_3 = -8.43136004842678;
2199 double beta_4 = 1.03533181861023E+01;
2200 for (int i = 0; i <= 3072; i++)
2201 {
2202 double x = (double)i / 3072.;
2203 double y = (1. - exp(-beta_1 * x - beta_2 * x * x - beta_3 * x * x * x - beta_4 * x * x * x * x));
2204 if (y < 0.)
2205 y = 0.;
2206 imgdata.color.curve[i] = (y * 16383.);
2207 }
2208 for (int i = 0; i < 3; i++)
2209 for (int j = 0; j < 4; j++)
2210 imgdata.color.rgb_cam[i][j] = float(i == j);
2211 }
2212 // Adjust BL for Nikon 12bit
2213 if ((load_raw == &LibRaw::nikon_load_raw || load_raw == &LibRaw::packed_load_raw) &&
2214 !strcasecmp(imgdata.idata.make, "Nikon") &&
2215 strncmp(imgdata.idata.model, "COOLPIX", 7)
2216 // && strncmp(imgdata.idata.model,"1 ",2)
2217 && libraw_internal_data.unpacker_data.tiff_bps == 12)
2218 {
2219 C.maximum = 4095;
2220 C.black /= 4;
2221 for (int c = 0; c < 4; c++)
2222 C.cblack[c] /= 4;
2223 for (int c = 0; c < C.cblack[4] * C.cblack[5]; c++)
2224 C.cblack[6 + c] /= 4;
2225 }
2226
2227 // Adjust Highlight Linearity limit
2228 if (C.linear_max[0] < 0)
2229 {
2230 if (imgdata.idata.dng_version)
2231 {
2232 for (int c = 0; c < 4; c++)
2233 C.linear_max[c] = -1 * C.linear_max[c] + imgdata.color.cblack[c + 6];
2234 }
2235 else
2236 {
2237 for (int c = 0; c < 4; c++)
2238 C.linear_max[c] = -1 * C.linear_max[c] + imgdata.color.cblack[c];
2239 }
2240 }
2241
2242 if (!strcasecmp(imgdata.idata.make, "Nikon") && (!C.linear_max[0]) && (C.maximum > 1024) &&
2243 (load_raw != &LibRaw::nikon_load_sraw))
2244 {
2245 C.linear_max[0] = C.linear_max[1] = C.linear_max[2] = C.linear_max[3] = (long)((float)(C.maximum) / 1.07f);
2246 }
2247
2248 // Correct WB for Samsung GX20
2249 if (!strcasecmp(imgdata.idata.make, "Samsung") && !strcasecmp(imgdata.idata.model, "GX20"))
2250 {
2251 C.WB_Coeffs[LIBRAW_WBI_Daylight][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_Daylight][2]) * 2.56f);
2252 C.WB_Coeffs[LIBRAW_WBI_Shade][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_Shade][2]) * 2.56f);
2253 C.WB_Coeffs[LIBRAW_WBI_Cloudy][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_Cloudy][2]) * 2.56f);
2254 C.WB_Coeffs[LIBRAW_WBI_Tungsten][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_Tungsten][2]) * 2.56f);
2255 C.WB_Coeffs[LIBRAW_WBI_FL_D][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_FL_D][2]) * 2.56f);
2256 C.WB_Coeffs[LIBRAW_WBI_FL_N][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_FL_N][2]) * 2.56f);
2257 C.WB_Coeffs[LIBRAW_WBI_FL_W][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_FL_W][2]) * 2.56f);
2258 C.WB_Coeffs[LIBRAW_WBI_Flash][2] = (int)((float)(C.WB_Coeffs[LIBRAW_WBI_Flash][2]) * 2.56f);
2259 for (int c = 0; c < 64; c++)
2260 {
2261 if (imgdata.color.WBCT_Coeffs[c][0] > 0.0f)
2262 {
2263 imgdata.color.WBCT_Coeffs[c][3] *= 2.56f;
2264 }
2265 }
2266 }
2267
2268 // Adjust BL for Panasonic
2269 if (load_raw == &LibRaw::panasonic_load_raw &&
2270 (!strcasecmp(imgdata.idata.make, "Panasonic") || !strcasecmp(imgdata.idata.make, "Leica") ||
2271 !strcasecmp(imgdata.idata.make, "YUNEEC")) &&
2272 ID.pana_black[0] && ID.pana_black[1] && ID.pana_black[2])
2273 {
2274 if(libraw_internal_data.unpacker_data.pana_encoding == 5)
2275 libraw_internal_data.internal_output_params.zero_is_bad = 0;
2276 C.black = 0;
2277 int add = libraw_internal_data.unpacker_data.pana_encoding == 4?15:0;
2278 C.cblack[0] = ID.pana_black[0]+add;
2279 C.cblack[1] = C.cblack[3] = ID.pana_black[1]+add;
2280 C.cblack[2] = ID.pana_black[2]+add;
2281 int i = C.cblack[3];
2282 for (int c = 0; c < 3; c++)
2283 if (i > C.cblack[c])
2284 i = C.cblack[c];
2285 for (int c = 0; c < 4; c++)
2286 C.cblack[c] -= i;
2287 C.black = i;
2288 }
2289
2290 // Adjust sizes for X3F processing
2291 if (load_raw == &LibRaw::x3f_load_raw)
2292 {
2293 for (int i = 0; i < foveon_count; i++)
2294 if (!strcasecmp(imgdata.idata.make, foveon_data[i].make) &&
2295 !strcasecmp(imgdata.idata.model, foveon_data[i].model) &&
2296 imgdata.sizes.raw_width == foveon_data[i].raw_width &&
2297 imgdata.sizes.raw_height == foveon_data[i].raw_height)
2298 {
2299 imgdata.sizes.top_margin = foveon_data[i].top_margin;
2300 imgdata.sizes.left_margin = foveon_data[i].left_margin;
2301 imgdata.sizes.width = imgdata.sizes.iwidth = foveon_data[i].width;
2302 imgdata.sizes.height = imgdata.sizes.iheight = foveon_data[i].height;
2303 C.maximum = foveon_data[i].white;
2304 break;
2305 }
2306 }
2307 #if 0
2308 size_t bytes = ID.input->size()-libraw_internal_data.unpacker_data.data_offset;
2309 float bpp = float(bytes)/float(S.raw_width)/float(S.raw_height);
2310 float bpp2 = float(bytes)/float(S.width)/float(S.height);
2311 printf("RawSize: %dx%d data offset: %d data size:%d bpp: %g bpp2: %g\n",S.raw_width,S.raw_height,libraw_internal_data.unpacker_data.data_offset,bytes,bpp,bpp2);
2312 if(!strcasecmp(imgdata.idata.make,"Hasselblad") && bpp == 6.0f)
2313 {
2314 load_raw = &LibRaw::hasselblad_full_load_raw;
2315 S.width = S.raw_width;
2316 S.height = S.raw_height;
2317 P1.filters = 0;
2318 P1.colors=3;
2319 P1.raw_count=1;
2320 C.maximum=0xffff;
2321 printf("3 channel hassy found\n");
2322 }
2323 #endif
2324 if (C.profile_length)
2325 {
2326 if (C.profile)
2327 free(C.profile);
2328 C.profile = malloc(C.profile_length);
2329 merror(C.profile, "LibRaw::open_file()");
2330 ID.input->seek(ID.profile_offset, SEEK_SET);
2331 ID.input->read(C.profile, C.profile_length, 1);
2332 }
2333
2334 SET_PROC_FLAG(LIBRAW_PROGRESS_IDENTIFY);
2335 }
2336 catch (LibRaw_exceptions err)
2337 {
2338 EXCEPTION_HANDLER(err);
2339 }
2340 catch (std::exception ee)
2341 {
2342 EXCEPTION_HANDLER(LIBRAW_EXCEPTION_IO_CORRUPT);
2343 }
2344
2345 final:;
2346
2347 if (P1.raw_count < 1)
2348 return LIBRAW_FILE_UNSUPPORTED;
2349
2350 write_fun = &LibRaw::write_ppm_tiff;
2351
2352 if (load_raw == &LibRaw::kodak_ycbcr_load_raw)
2353 {
2354 S.height += S.height & 1;
2355 S.width += S.width & 1;
2356 }
2357
2358 IO.shrink = P1.filters && (O.half_size || ((O.threshold || O.aber[0] != 1 || O.aber[2] != 1)));
2359 if (IO.shrink && P1.filters >= 1000)
2360 {
2361 S.width &= 65534;
2362 S.height &= 65534;
2363 }
2364
2365 S.iheight = (S.height + IO.shrink) >> IO.shrink;
2366 S.iwidth = (S.width + IO.shrink) >> IO.shrink;
2367
2368 // Save color,sizes and internal data into raw_image fields
2369 memmove(&imgdata.rawdata.color, &imgdata.color, sizeof(imgdata.color));
2370 memmove(&imgdata.rawdata.sizes, &imgdata.sizes, sizeof(imgdata.sizes));
2371 memmove(&imgdata.rawdata.iparams, &imgdata.idata, sizeof(imgdata.idata));
2372 memmove(&imgdata.rawdata.ioparams, &libraw_internal_data.internal_output_params,
2373 sizeof(libraw_internal_data.internal_output_params));
2374
2375 SET_PROC_FLAG(LIBRAW_PROGRESS_SIZE_ADJUST);
2376
2377 return LIBRAW_SUCCESS;
2378 }
2379
2380 #ifdef USE_RAWSPEED
fix_after_rawspeed(int bl)2381 void LibRaw::fix_after_rawspeed(int bl)
2382 {
2383 if (load_raw == &LibRaw::lossy_dng_load_raw)
2384 C.maximum = 0xffff;
2385 else if (load_raw == &LibRaw::sony_load_raw)
2386 C.maximum = 0x3ff0;
2387 }
2388 #else
fix_after_rawspeed(int)2389 void LibRaw::fix_after_rawspeed(int) {}
2390 #endif
2391
clearCancelFlag()2392 void LibRaw::clearCancelFlag()
2393 {
2394 #ifdef WIN32
2395 InterlockedExchange(&_exitflag, 0);
2396 #else
2397 __sync_fetch_and_and(&_exitflag, 0);
2398 #endif
2399 #ifdef RAWSPEED_FASTEXIT
2400 if (_rawspeed_decoder)
2401 {
2402 RawDecoder *d = static_cast<RawDecoder *>(_rawspeed_decoder);
2403 d->resumeProcessing();
2404 }
2405 #endif
2406 }
2407
setCancelFlag()2408 void LibRaw::setCancelFlag()
2409 {
2410 #ifdef WIN32
2411 InterlockedExchange(&_exitflag, 1);
2412 #else
2413 __sync_fetch_and_add(&_exitflag, 1);
2414 #endif
2415 #ifdef RAWSPEED_FASTEXIT
2416 if (_rawspeed_decoder)
2417 {
2418 RawDecoder *d = static_cast<RawDecoder *>(_rawspeed_decoder);
2419 d->cancelProcessing();
2420 }
2421 #endif
2422 }
2423
checkCancel()2424 void LibRaw::checkCancel()
2425 {
2426 #ifdef WIN32
2427 if (InterlockedExchange(&_exitflag, 0))
2428 throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
2429 #else
2430 if (__sync_fetch_and_and(&_exitflag, 0))
2431 throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
2432 #endif
2433 }
2434
try_rawspeed()2435 int LibRaw::try_rawspeed()
2436 {
2437 #ifdef USE_RAWSPEED
2438 int ret = LIBRAW_SUCCESS;
2439
2440 int rawspeed_ignore_errors = 0;
2441 if (imgdata.idata.dng_version && imgdata.idata.colors == 3 &&
2442 !strcasecmp(imgdata.idata.software, "Adobe Photoshop Lightroom 6.1.1 (Windows)"))
2443 rawspeed_ignore_errors = 1;
2444
2445 // RawSpeed Supported,
2446 INT64 spos = ID.input->tell();
2447 void *_rawspeed_buffer = 0;
2448 try
2449 {
2450 // printf("Using rawspeed\n");
2451 ID.input->seek(0, SEEK_SET);
2452 INT64 _rawspeed_buffer_sz = ID.input->size() + 32;
2453 _rawspeed_buffer = malloc(_rawspeed_buffer_sz);
2454 if (!_rawspeed_buffer)
2455 throw LIBRAW_EXCEPTION_ALLOC;
2456 ID.input->read(_rawspeed_buffer, _rawspeed_buffer_sz, 1);
2457 FileMap map((uchar8 *)_rawspeed_buffer, _rawspeed_buffer_sz);
2458 RawParser t(&map);
2459 RawDecoder *d = 0;
2460 CameraMetaDataLR *meta = static_cast<CameraMetaDataLR *>(_rawspeed_camerameta);
2461 d = t.getDecoder();
2462 if (!d)
2463 throw "Unable to find decoder";
2464 try
2465 {
2466 d->checkSupport(meta);
2467 }
2468 catch (const RawDecoderException &e)
2469 {
2470 imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_UNSUPPORTED;
2471 throw e;
2472 }
2473 d->interpolateBadPixels = FALSE;
2474 d->applyStage1DngOpcodes = FALSE;
2475 _rawspeed_decoder = static_cast<void *>(d);
2476 d->decodeRaw();
2477 d->decodeMetaData(meta);
2478 RawImage r = d->mRaw;
2479 if (r->errors.size() > 0 && !rawspeed_ignore_errors)
2480 {
2481 delete d;
2482 _rawspeed_decoder = 0;
2483 throw 1;
2484 }
2485 if (r->isCFA)
2486 {
2487 imgdata.rawdata.raw_image = (ushort *)r->getDataUncropped(0, 0);
2488 }
2489 else if (r->getCpp() == 4)
2490 {
2491 imgdata.rawdata.color4_image = (ushort(*)[4])r->getDataUncropped(0, 0);
2492 if (r->whitePoint > 0 && r->whitePoint < 65536)
2493 C.maximum = r->whitePoint;
2494 }
2495 else if (r->getCpp() == 3)
2496 {
2497 imgdata.rawdata.color3_image = (ushort(*)[3])r->getDataUncropped(0, 0);
2498 if (r->whitePoint > 0 && r->whitePoint < 65536)
2499 C.maximum = r->whitePoint;
2500 }
2501 else
2502 {
2503 delete d;
2504 _rawspeed_decoder = 0;
2505 ret = LIBRAW_UNSPECIFIED_ERROR;
2506 }
2507 if (_rawspeed_decoder)
2508 {
2509 // set sizes
2510 iPoint2D rsdim = r->getUncroppedDim();
2511 S.raw_pitch = r->pitch;
2512 S.raw_width = rsdim.x;
2513 S.raw_height = rsdim.y;
2514 // C.maximum = r->whitePoint;
2515 fix_after_rawspeed(r->blackLevel);
2516 }
2517 free(_rawspeed_buffer);
2518 _rawspeed_buffer = 0;
2519 imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_PROCESSED;
2520 }
2521 catch (const RawDecoderException &RDE)
2522 {
2523 imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_PROBLEM;
2524 if (_rawspeed_buffer)
2525 {
2526 free(_rawspeed_buffer);
2527 _rawspeed_buffer = 0;
2528 }
2529 const char *p = RDE.what();
2530 if (!strncmp(RDE.what(), "Decoder canceled", strlen("Decoder canceled")))
2531 throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
2532 ret = LIBRAW_UNSPECIFIED_ERROR;
2533 }
2534 catch (...)
2535 {
2536 // We may get here due to cancellation flag
2537 imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_PROBLEM;
2538 if (_rawspeed_buffer)
2539 {
2540 free(_rawspeed_buffer);
2541 _rawspeed_buffer = 0;
2542 }
2543 ret = LIBRAW_UNSPECIFIED_ERROR;
2544 }
2545 ID.input->seek(spos, SEEK_SET);
2546
2547 return ret;
2548 #else
2549 return LIBRAW_NOT_IMPLEMENTED;
2550 #endif
2551 }
2552
valid_for_dngsdk()2553 int LibRaw::valid_for_dngsdk()
2554 {
2555 #ifndef USE_DNGSDK
2556 return 0;
2557 #else
2558 if (!imgdata.idata.dng_version)
2559 return 0;
2560 if (!imgdata.params.use_dngsdk)
2561 return 0;
2562 if (load_raw == &LibRaw::lossy_dng_load_raw)
2563 return 0;
2564 if (is_floating_point() && (imgdata.params.use_dngsdk & LIBRAW_DNG_FLOAT))
2565 return 1;
2566 if (!imgdata.idata.filters && (imgdata.params.use_dngsdk & LIBRAW_DNG_LINEAR))
2567 return 1;
2568 if (libraw_internal_data.unpacker_data.tiff_bps == 8 && (imgdata.params.use_dngsdk & LIBRAW_DNG_8BIT))
2569 return 1;
2570 if (libraw_internal_data.unpacker_data.tiff_compress == 8 && (imgdata.params.use_dngsdk & LIBRAW_DNG_DEFLATE))
2571 return 1;
2572 if (libraw_internal_data.unpacker_data.tiff_samples == 2)
2573 return 0; // Always deny 2-samples (old fuji superccd)
2574 if (imgdata.idata.filters == 9 && (imgdata.params.use_dngsdk & LIBRAW_DNG_XTRANS))
2575 return 1;
2576 if (is_fuji_rotated())
2577 return 0; // refuse
2578 if (imgdata.params.use_dngsdk & LIBRAW_DNG_OTHER)
2579 return 1;
2580 return 0;
2581 #endif
2582 }
2583
is_curve_linear()2584 int LibRaw::is_curve_linear()
2585 {
2586 for (int i = 0; i < 0x10000; i++)
2587 if (imgdata.color.curve[i] != i)
2588 return 0;
2589 return 1;
2590 }
2591
try_dngsdk()2592 int LibRaw::try_dngsdk()
2593 {
2594 #ifdef USE_DNGSDK
2595 if (!dnghost)
2596 return LIBRAW_UNSPECIFIED_ERROR;
2597
2598 dng_host *host = static_cast<dng_host *>(dnghost);
2599
2600 try
2601 {
2602 libraw_dng_stream stream(libraw_internal_data.internal_data.input);
2603
2604 AutoPtr<dng_negative> negative;
2605 negative.Reset(host->Make_dng_negative());
2606
2607 dng_info info;
2608 info.Parse(*host, stream);
2609 info.PostParse(*host);
2610
2611 if (!info.IsValidDNG())
2612 {
2613 return LIBRAW_DATA_ERROR;
2614 }
2615 negative->Parse(*host, stream, info);
2616 negative->PostParse(*host, stream, info);
2617 negative->ReadStage1Image(*host, stream, info);
2618 dng_simple_image *stage2 = (dng_simple_image *)negative->Stage1Image();
2619 if (stage2->Bounds().W() != S.raw_width || stage2->Bounds().H() != S.raw_height)
2620 {
2621 return LIBRAW_DATA_ERROR;
2622 }
2623
2624 int pplanes = stage2->Planes();
2625 int ptype = stage2->PixelType();
2626
2627 dng_pixel_buffer buffer;
2628 stage2->GetPixelBuffer(buffer);
2629
2630 int pixels = stage2->Bounds().H() * stage2->Bounds().W() * pplanes;
2631 if (ptype == ttByte)
2632 imgdata.rawdata.raw_alloc = malloc(pixels * TagTypeSize(ttShort));
2633 else
2634 imgdata.rawdata.raw_alloc = malloc(pixels * TagTypeSize(ptype));
2635
2636 if (ptype == ttShort && !is_curve_linear())
2637 {
2638 ushort *src = (ushort *)buffer.fData;
2639 ushort *dst = (ushort *)imgdata.rawdata.raw_alloc;
2640 for (int i = 0; i < pixels; i++)
2641 dst[i] = imgdata.color.curve[src[i]];
2642 S.raw_pitch = S.raw_width * pplanes * TagTypeSize(ptype);
2643 }
2644 else if (ptype == ttByte)
2645 {
2646 unsigned char *src = (unsigned char *)buffer.fData;
2647 ushort *dst = (ushort *)imgdata.rawdata.raw_alloc;
2648 if (is_curve_linear())
2649 {
2650 for (int i = 0; i < pixels; i++)
2651 dst[i] = src[i];
2652 }
2653 else
2654 {
2655 for (int i = 0; i < pixels; i++)
2656 dst[i] = imgdata.color.curve[src[i]];
2657 }
2658 S.raw_pitch = S.raw_width * pplanes * TagTypeSize(ttShort);
2659 }
2660 else
2661 {
2662 memmove(imgdata.rawdata.raw_alloc, buffer.fData, pixels * TagTypeSize(ptype));
2663 S.raw_pitch = S.raw_width * pplanes * TagTypeSize(ptype);
2664 }
2665
2666 switch (ptype)
2667 {
2668 case ttFloat:
2669 if (pplanes == 1)
2670 imgdata.rawdata.float_image = (float *)imgdata.rawdata.raw_alloc;
2671 else if (pplanes == 3)
2672 imgdata.rawdata.float3_image = (float(*)[3])imgdata.rawdata.raw_alloc;
2673 else if (pplanes == 4)
2674 imgdata.rawdata.float4_image = (float(*)[4])imgdata.rawdata.raw_alloc;
2675 break;
2676
2677 case ttByte:
2678 case ttShort:
2679 if (pplanes == 1)
2680 imgdata.rawdata.raw_image = (ushort *)imgdata.rawdata.raw_alloc;
2681 else if (pplanes == 3)
2682 imgdata.rawdata.color3_image = (ushort(*)[3])imgdata.rawdata.raw_alloc;
2683 else if (pplanes == 4)
2684 imgdata.rawdata.color4_image = (ushort(*)[4])imgdata.rawdata.raw_alloc;
2685 break;
2686 default:
2687 /* do nothing */
2688 break;
2689 }
2690 }
2691 catch (...)
2692 {
2693 return LIBRAW_UNSPECIFIED_ERROR;
2694 }
2695 return imgdata.rawdata.raw_alloc ? LIBRAW_SUCCESS : LIBRAW_UNSPECIFIED_ERROR;
2696 #else
2697 return LIBRAW_UNSPECIFIED_ERROR;
2698 #endif
2699 }
set_dng_host(void * p)2700 void LibRaw::set_dng_host(void *p)
2701 {
2702 #ifdef USE_DNGSDK
2703 dnghost = p;
2704 #endif
2705 }
2706
unpack(void)2707 int LibRaw::unpack(void)
2708 {
2709 CHECK_ORDER_HIGH(LIBRAW_PROGRESS_LOAD_RAW);
2710 CHECK_ORDER_LOW(LIBRAW_PROGRESS_IDENTIFY);
2711 try
2712 {
2713
2714 if (!libraw_internal_data.internal_data.input)
2715 return LIBRAW_INPUT_CLOSED;
2716
2717 RUN_CALLBACK(LIBRAW_PROGRESS_LOAD_RAW, 0, 2);
2718 if (O.shot_select >= P1.raw_count)
2719 return LIBRAW_REQUEST_FOR_NONEXISTENT_IMAGE;
2720
2721 if (!load_raw)
2722 return LIBRAW_UNSPECIFIED_ERROR;
2723
2724 // already allocated ?
2725 if (imgdata.image)
2726 {
2727 free(imgdata.image);
2728 imgdata.image = 0;
2729 }
2730 if (imgdata.rawdata.raw_alloc)
2731 {
2732 free(imgdata.rawdata.raw_alloc);
2733 imgdata.rawdata.raw_alloc = 0;
2734 }
2735 if (libraw_internal_data.unpacker_data.meta_length)
2736 {
2737 libraw_internal_data.internal_data.meta_data = (char *)malloc(libraw_internal_data.unpacker_data.meta_length);
2738 merror(libraw_internal_data.internal_data.meta_data, "LibRaw::unpack()");
2739 }
2740
2741 libraw_decoder_info_t decoder_info;
2742 get_decoder_info(&decoder_info);
2743
2744 int save_iwidth = S.iwidth, save_iheight = S.iheight, save_shrink = IO.shrink;
2745
2746 int rwidth = S.raw_width, rheight = S.raw_height;
2747 if (!IO.fuji_width)
2748 {
2749 // adjust non-Fuji allocation
2750 if (rwidth < S.width + S.left_margin)
2751 rwidth = S.width + S.left_margin;
2752 if (rheight < S.height + S.top_margin)
2753 rheight = S.height + S.top_margin;
2754 }
2755 if (rwidth > 65535 || rheight > 65535) // No way to make image larger than 64k pix
2756 throw LIBRAW_EXCEPTION_IO_CORRUPT;
2757
2758 imgdata.rawdata.raw_image = 0;
2759 imgdata.rawdata.color4_image = 0;
2760 imgdata.rawdata.color3_image = 0;
2761 imgdata.rawdata.float_image = 0;
2762 imgdata.rawdata.float3_image = 0;
2763
2764 #ifdef USE_DNGSDK
2765 if (imgdata.idata.dng_version && dnghost && imgdata.idata.raw_count == 1 && valid_for_dngsdk() &&
2766 load_raw != &LibRaw::pentax_4shot_load_raw)
2767 {
2768 // Data size check
2769 INT64 pixcount = INT64(MAX(S.width, S.raw_width)) * INT64(MAX(S.height, S.raw_height));
2770 INT64 planecount = (imgdata.idata.filters || P1.colors == 1)?1: LIM(P1.colors,3,4);
2771 INT64 samplesize = is_floating_point()?4:2;
2772 INT64 bytes = pixcount * planecount * samplesize;
2773 if(bytes > LIBRAW_MAX_ALLOC_MB * INT64(1024 * 1024)) throw LIBRAW_EXCEPTION_TOOBIG;
2774
2775 // find ifd to check sample
2776 int rr = try_dngsdk();
2777 }
2778 #endif
2779
2780 #ifdef USE_RAWSPEED
2781 if (!raw_was_read())
2782 {
2783 int rawspeed_enabled = 1;
2784
2785 if (imgdata.idata.dng_version && libraw_internal_data.unpacker_data.tiff_samples == 2)
2786 rawspeed_enabled = 0;
2787
2788 if(libraw_internal_data.unpacker_data.pana_encoding == 5)
2789 rawspeed_enabled = 0;
2790
2791 if (imgdata.idata.raw_count > 1)
2792 rawspeed_enabled = 0;
2793 if (!strncasecmp(imgdata.idata.software, "Magic", 5))
2794 rawspeed_enabled = 0;
2795 // Disable rawspeed for double-sized Oly files
2796 if (!strncasecmp(imgdata.idata.make, "Olympus", 7) &&
2797 ((imgdata.sizes.raw_width > 6000) || !strncasecmp(imgdata.idata.model, "SH-2", 4) ||
2798 !strncasecmp(imgdata.idata.model, "SH-3", 4) || !strncasecmp(imgdata.idata.model, "TG-4", 4) ||
2799 !strncasecmp(imgdata.idata.model, "TG-5", 4)))
2800 rawspeed_enabled = 0;
2801
2802 if (!strncasecmp(imgdata.idata.make, "Canon", 5) && !strcasecmp(imgdata.idata.model, "EOS 6D Mark II"))
2803 rawspeed_enabled = 0;
2804
2805 if (imgdata.idata.dng_version && imgdata.idata.filters == 0 &&
2806 libraw_internal_data.unpacker_data.tiff_bps == 8) // Disable for 8 bit
2807 rawspeed_enabled = 0;
2808
2809 if (load_raw == &LibRaw::packed_load_raw && !strncasecmp(imgdata.idata.make, "Nikon", 5) &&
2810 (!strncasecmp(imgdata.idata.model, "E", 1) || !strncasecmp(imgdata.idata.model, "COOLPIX B", 9)))
2811 rawspeed_enabled = 0;
2812
2813 // RawSpeed Supported,
2814 if (O.use_rawspeed && rawspeed_enabled &&
2815 !(is_sraw() &&
2816 (O.raw_processing_options & (LIBRAW_PROCESSING_SRAW_NO_RGB | LIBRAW_PROCESSING_SRAW_NO_INTERPOLATE))) &&
2817 (decoder_info.decoder_flags & LIBRAW_DECODER_TRYRAWSPEED) && _rawspeed_camerameta)
2818 {
2819 INT64 pixcount = INT64(MAX(S.width, S.raw_width)) * INT64(MAX(S.height, S.raw_height));
2820 INT64 planecount = (imgdata.idata.filters || P1.colors == 1)?1: LIM(P1.colors,3,4);
2821 INT64 bytes = pixcount * planecount * 2; // sample size is always 2 for rawspeed
2822 if(bytes > LIBRAW_MAX_ALLOC_MB * INT64(1024 * 1024)) throw LIBRAW_EXCEPTION_TOOBIG;
2823
2824 int rr = try_rawspeed();
2825 }
2826 }
2827 #endif
2828 if (!raw_was_read()) // RawSpeed failed or not run
2829 {
2830 // Not allocated on RawSpeed call, try call LibRaow
2831 int zero_rawimage = 0;
2832 if (decoder_info.decoder_flags & LIBRAW_DECODER_OWNALLOC)
2833 {
2834 // x3f foveon decoder and DNG float
2835 // Do nothing! Decoder will allocate data internally
2836 }
2837 if (decoder_info.decoder_flags & LIBRAW_DECODER_3CHANNEL)
2838 {
2839 if (INT64(rwidth) * INT64(rheight + 8) * sizeof(imgdata.rawdata.raw_image[0]) * 3 >
2840 LIBRAW_MAX_ALLOC_MB * INT64(1024 * 1024))
2841 throw LIBRAW_EXCEPTION_TOOBIG;
2842
2843 imgdata.rawdata.raw_alloc = malloc(rwidth * (rheight + 8) * sizeof(imgdata.rawdata.raw_image[0]) * 3);
2844 imgdata.rawdata.color3_image = (ushort(*)[3])imgdata.rawdata.raw_alloc;
2845 if (!S.raw_pitch)
2846 S.raw_pitch = S.raw_width * 6;
2847 }
2848 else if (imgdata.idata.filters || P1.colors == 1) // Bayer image or single color -> decode to raw_image
2849 {
2850 if (INT64(rwidth) * INT64(rheight + 8) * sizeof(imgdata.rawdata.raw_image[0]) >
2851 LIBRAW_MAX_ALLOC_MB * INT64(1024 * 1024))
2852 throw LIBRAW_EXCEPTION_TOOBIG;
2853 imgdata.rawdata.raw_alloc = malloc(rwidth * (rheight + 8) * sizeof(imgdata.rawdata.raw_image[0]));
2854 imgdata.rawdata.raw_image = (ushort *)imgdata.rawdata.raw_alloc;
2855 if (!S.raw_pitch)
2856 S.raw_pitch = S.raw_width * 2; // Bayer case, not set before
2857 }
2858 else // NO LEGACY FLAG if (decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
2859 {
2860 if (decoder_info.decoder_flags & LIBRAW_DECODER_ADOBECOPYPIXEL)
2861 {
2862 S.raw_pitch = S.raw_width * 8;
2863 }
2864 else
2865 {
2866 S.iwidth = S.width;
2867 S.iheight = S.height;
2868 IO.shrink = 0;
2869 if (!S.raw_pitch)
2870 S.raw_pitch =
2871 (decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY_WITH_MARGINS) ? S.raw_width * 8 : S.width * 8;
2872 }
2873 // sRAW and old Foveon decoders only, so extra buffer size is just 1/4
2874 // allocate image as temporary buffer, size
2875 if (INT64(MAX(S.width, S.raw_width)) * INT64(MAX(S.height, S.raw_height)+8) * sizeof(*imgdata.image) >
2876 LIBRAW_MAX_ALLOC_MB * INT64(1024 * 1024))
2877 throw LIBRAW_EXCEPTION_TOOBIG;
2878
2879 imgdata.rawdata.raw_alloc = 0;
2880 imgdata.image = (ushort(*)[4])calloc(
2881 unsigned(MAX(S.width, S.raw_width)) * unsigned(MAX(S.height, S.raw_height)+8), sizeof(*imgdata.image));
2882 if (!(decoder_info.decoder_flags & LIBRAW_DECODER_ADOBECOPYPIXEL))
2883 {
2884 imgdata.rawdata.raw_image = (ushort *)imgdata.image;
2885 zero_rawimage = 1;
2886 }
2887 }
2888 ID.input->seek(libraw_internal_data.unpacker_data.data_offset, SEEK_SET);
2889
2890 unsigned m_save = C.maximum;
2891 if (load_raw == &LibRaw::unpacked_load_raw && !strcasecmp(imgdata.idata.make, "Nikon"))
2892 C.maximum = 65535;
2893 (this->*load_raw)();
2894 if (zero_rawimage)
2895 imgdata.rawdata.raw_image = 0;
2896 if (load_raw == &LibRaw::unpacked_load_raw && !strcasecmp(imgdata.idata.make, "Nikon"))
2897 C.maximum = m_save;
2898 if (decoder_info.decoder_flags & LIBRAW_DECODER_OWNALLOC)
2899 {
2900 // x3f foveon decoder only: do nothing
2901 }
2902 else if (!(imgdata.idata.filters || P1.colors == 1)) // legacy decoder, ownalloc handled above
2903 {
2904 // successfully decoded legacy image, attach image to raw_alloc
2905 imgdata.rawdata.raw_alloc = imgdata.image;
2906 imgdata.rawdata.color4_image = (ushort(*)[4])imgdata.rawdata.raw_alloc;
2907 imgdata.image = 0;
2908 // Restore saved values. Note: Foveon have masked frame
2909 // Other 4-color legacy data: no borders
2910 if (!(libraw_internal_data.unpacker_data.load_flags & 256) &&
2911 !(decoder_info.decoder_flags & LIBRAW_DECODER_ADOBECOPYPIXEL) &&
2912 !(decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY_WITH_MARGINS))
2913 {
2914 S.raw_width = S.width;
2915 S.left_margin = 0;
2916 S.raw_height = S.height;
2917 S.top_margin = 0;
2918 }
2919 }
2920 }
2921
2922 if (imgdata.rawdata.raw_image)
2923 crop_masked_pixels(); // calculate black levels
2924
2925 // recover image sizes
2926 S.iwidth = save_iwidth;
2927 S.iheight = save_iheight;
2928 IO.shrink = save_shrink;
2929
2930 // adjust black to possible maximum
2931 unsigned int i = C.cblack[3];
2932 unsigned int c;
2933 for (c = 0; c < 3; c++)
2934 if (i > C.cblack[c])
2935 i = C.cblack[c];
2936 for (c = 0; c < 4; c++)
2937 C.cblack[c] -= i;
2938 C.black += i;
2939
2940 // Save color,sizes and internal data into raw_image fields
2941 memmove(&imgdata.rawdata.color, &imgdata.color, sizeof(imgdata.color));
2942 memmove(&imgdata.rawdata.sizes, &imgdata.sizes, sizeof(imgdata.sizes));
2943 memmove(&imgdata.rawdata.iparams, &imgdata.idata, sizeof(imgdata.idata));
2944 memmove(&imgdata.rawdata.ioparams, &libraw_internal_data.internal_output_params,
2945 sizeof(libraw_internal_data.internal_output_params));
2946
2947 SET_PROC_FLAG(LIBRAW_PROGRESS_LOAD_RAW);
2948 RUN_CALLBACK(LIBRAW_PROGRESS_LOAD_RAW, 1, 2);
2949
2950 return 0;
2951 }
2952 catch (LibRaw_exceptions err)
2953 {
2954 EXCEPTION_HANDLER(err);
2955 }
2956 catch (std::exception ee)
2957 {
2958 EXCEPTION_HANDLER(LIBRAW_EXCEPTION_IO_CORRUPT);
2959 }
2960 }
2961
unpacked_load_raw_fuji_f700s20()2962 void LibRaw::unpacked_load_raw_fuji_f700s20()
2963 {
2964 int base_offset = 0;
2965 int row_size = imgdata.sizes.raw_width * 2; // in bytes
2966 if (imgdata.idata.raw_count == 2 && imgdata.params.shot_select)
2967 {
2968 libraw_internal_data.internal_data.input->seek(-row_size, SEEK_CUR);
2969 base_offset = row_size; // in bytes
2970 }
2971 unsigned char *buffer = (unsigned char *)malloc(row_size * 2);
2972 for (int row = 0; row < imgdata.sizes.raw_height; row++)
2973 {
2974 read_shorts((ushort *)buffer, imgdata.sizes.raw_width * 2);
2975 memmove(&imgdata.rawdata.raw_image[row * imgdata.sizes.raw_pitch / 2], buffer + base_offset, row_size);
2976 }
2977 free(buffer);
2978 }
2979
nikon_load_sraw()2980 void LibRaw::nikon_load_sraw()
2981 {
2982 // We're already seeked to data!
2983 unsigned char *rd = (unsigned char *)malloc(3 * (imgdata.sizes.raw_width + 2));
2984 if (!rd)
2985 throw LIBRAW_EXCEPTION_ALLOC;
2986 try
2987 {
2988 int row, col;
2989 for (row = 0; row < imgdata.sizes.raw_height; row++)
2990 {
2991 checkCancel();
2992 libraw_internal_data.internal_data.input->read(rd, 3, imgdata.sizes.raw_width);
2993 for (col = 0; col < imgdata.sizes.raw_width - 1; col += 2)
2994 {
2995 int bi = col * 3;
2996 ushort bits1 = (rd[bi + 1] & 0xf) << 8 | rd[bi]; // 3,0,1
2997 ushort bits2 = rd[bi + 2] << 4 | ((rd[bi + 1] >> 4) & 0xf); // 452
2998 ushort bits3 = ((rd[bi + 4] & 0xf) << 8) | rd[bi + 3]; // 967
2999 ushort bits4 = rd[bi + 5] << 4 | ((rd[bi + 4] >> 4) & 0xf); // ab8
3000 imgdata.image[row * imgdata.sizes.raw_width + col][0] = bits1;
3001 imgdata.image[row * imgdata.sizes.raw_width + col][1] = bits3;
3002 imgdata.image[row * imgdata.sizes.raw_width + col][2] = bits4;
3003 imgdata.image[row * imgdata.sizes.raw_width + col + 1][0] = bits2;
3004 imgdata.image[row * imgdata.sizes.raw_width + col + 1][1] = 2048;
3005 imgdata.image[row * imgdata.sizes.raw_width + col + 1][2] = 2048;
3006 }
3007 }
3008 }
3009 catch (...)
3010 {
3011 free(rd);
3012 throw;
3013 }
3014 free(rd);
3015 C.maximum = 0xfff; // 12 bit?
3016 if (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_SRAW_NO_INTERPOLATE)
3017 {
3018 return; // no CbCr interpolation
3019 }
3020 // Interpolate CC channels
3021 int row, col;
3022 for (row = 0; row < imgdata.sizes.raw_height; row++)
3023 {
3024 checkCancel(); // will throw out
3025 for (col = 0; col < imgdata.sizes.raw_width; col += 2)
3026 {
3027 int col2 = col < imgdata.sizes.raw_width - 2 ? col + 2 : col;
3028 imgdata.image[row * imgdata.sizes.raw_width + col + 1][1] =
3029 (unsigned short)(int(imgdata.image[row * imgdata.sizes.raw_width + col][1] +
3030 imgdata.image[row * imgdata.sizes.raw_width + col2][1]) /
3031 2);
3032 imgdata.image[row * imgdata.sizes.raw_width + col + 1][2] =
3033 (unsigned short)(int(imgdata.image[row * imgdata.sizes.raw_width + col][2] +
3034 imgdata.image[row * imgdata.sizes.raw_width + col2][2]) /
3035 2);
3036 }
3037 }
3038 if (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_SRAW_NO_RGB)
3039 return;
3040
3041 for (row = 0; row < imgdata.sizes.raw_height; row++)
3042 {
3043 checkCancel(); // will throw out
3044 for (col = 0; col < imgdata.sizes.raw_width; col++)
3045 {
3046 float Y = float(imgdata.image[row * imgdata.sizes.raw_width + col][0]) / 2549.f;
3047 float Ch2 = float(imgdata.image[row * imgdata.sizes.raw_width + col][1] - 1280) / 1536.f;
3048 float Ch3 = float(imgdata.image[row * imgdata.sizes.raw_width + col][2] - 1280) / 1536.f;
3049 if (Y > 1.f)
3050 Y = 1.f;
3051 if (Y > 0.803f)
3052 Ch2 = Ch3 = 0.5f;
3053 float r = Y + 1.40200f * (Ch3 - 0.5f);
3054 if (r < 0.f)
3055 r = 0.f;
3056 if (r > 1.f)
3057 r = 1.f;
3058 float g = Y - 0.34414f * (Ch2 - 0.5f) - 0.71414 * (Ch3 - 0.5f);
3059 if (g > 1.f)
3060 g = 1.f;
3061 if (g < 0.f)
3062 g = 0.f;
3063 float b = Y + 1.77200 * (Ch2 - 0.5f);
3064 if (b > 1.f)
3065 b = 1.f;
3066 if (b < 0.f)
3067 b = 0.f;
3068 imgdata.image[row * imgdata.sizes.raw_width + col][0] = imgdata.color.curve[int(r * 3072.f)];
3069 imgdata.image[row * imgdata.sizes.raw_width + col][1] = imgdata.color.curve[int(g * 3072.f)];
3070 imgdata.image[row * imgdata.sizes.raw_width + col][2] = imgdata.color.curve[int(b * 3072.f)];
3071 }
3072 }
3073 C.maximum = 16383;
3074 }
3075
free_image(void)3076 void LibRaw::free_image(void)
3077 {
3078 if (imgdata.image)
3079 {
3080 free(imgdata.image);
3081 imgdata.image = 0;
3082 imgdata.progress_flags = LIBRAW_PROGRESS_START | LIBRAW_PROGRESS_OPEN | LIBRAW_PROGRESS_IDENTIFY |
3083 LIBRAW_PROGRESS_SIZE_ADJUST | LIBRAW_PROGRESS_LOAD_RAW;
3084 }
3085 }
3086
raw2image_start()3087 void LibRaw::raw2image_start()
3088 {
3089 // restore color,sizes and internal data into raw_image fields
3090 memmove(&imgdata.color, &imgdata.rawdata.color, sizeof(imgdata.color));
3091 memmove(&imgdata.sizes, &imgdata.rawdata.sizes, sizeof(imgdata.sizes));
3092 memmove(&imgdata.idata, &imgdata.rawdata.iparams, sizeof(imgdata.idata));
3093 memmove(&libraw_internal_data.internal_output_params, &imgdata.rawdata.ioparams,
3094 sizeof(libraw_internal_data.internal_output_params));
3095
3096 if (O.user_flip >= 0)
3097 S.flip = O.user_flip;
3098
3099 switch ((S.flip + 3600) % 360)
3100 {
3101 case 270:
3102 S.flip = 5;
3103 break;
3104 case 180:
3105 S.flip = 3;
3106 break;
3107 case 90:
3108 S.flip = 6;
3109 break;
3110 }
3111
3112 // adjust for half mode!
3113 IO.shrink = P1.filters && (O.half_size || ((O.threshold || O.aber[0] != 1 || O.aber[2] != 1)));
3114
3115 S.iheight = (S.height + IO.shrink) >> IO.shrink;
3116 S.iwidth = (S.width + IO.shrink) >> IO.shrink;
3117 }
3118
is_phaseone_compressed()3119 int LibRaw::is_phaseone_compressed()
3120 {
3121 return (load_raw == &LibRaw::phase_one_load_raw_c || load_raw == &LibRaw::phase_one_load_raw);
3122 }
3123
is_canon_600()3124 int LibRaw::is_canon_600() { return load_raw == &LibRaw::canon_600_load_raw; }
3125
raw2image(void)3126 int LibRaw::raw2image(void)
3127 {
3128
3129 CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
3130
3131 try
3132 {
3133 raw2image_start();
3134
3135 if (is_phaseone_compressed())
3136 {
3137 phase_one_allocate_tempbuffer();
3138 int rc = phase_one_subtract_black((ushort *)imgdata.rawdata.raw_alloc, imgdata.rawdata.raw_image);
3139 if (rc == 0)
3140 rc = phase_one_correct();
3141 if (rc != 0)
3142 {
3143 phase_one_free_tempbuffer();
3144 return rc;
3145 }
3146 }
3147
3148 // free and re-allocate image bitmap
3149 if (imgdata.image)
3150 {
3151 imgdata.image = (ushort(*)[4])realloc(imgdata.image, S.iheight * S.iwidth * sizeof(*imgdata.image));
3152 memset(imgdata.image, 0, S.iheight * S.iwidth * sizeof(*imgdata.image));
3153 }
3154 else
3155 imgdata.image = (ushort(*)[4])calloc(S.iheight * S.iwidth, sizeof(*imgdata.image));
3156
3157 merror(imgdata.image, "raw2image()");
3158
3159 libraw_decoder_info_t decoder_info;
3160 get_decoder_info(&decoder_info);
3161
3162 // Move saved bitmap to imgdata.image
3163 if (imgdata.idata.filters || P1.colors == 1)
3164 {
3165 if (IO.fuji_width)
3166 {
3167 unsigned r, c;
3168 int row, col;
3169 for (row = 0; row < S.raw_height - S.top_margin * 2; row++)
3170 {
3171 for (col = 0; col < IO.fuji_width << !libraw_internal_data.unpacker_data.fuji_layout; col++)
3172 {
3173 if (libraw_internal_data.unpacker_data.fuji_layout)
3174 {
3175 r = IO.fuji_width - 1 - col + (row >> 1);
3176 c = col + ((row + 1) >> 1);
3177 }
3178 else
3179 {
3180 r = IO.fuji_width - 1 + row - (col >> 1);
3181 c = row + ((col + 1) >> 1);
3182 }
3183 if (r < S.height && c < S.width)
3184 imgdata.image[((r) >> IO.shrink) * S.iwidth + ((c) >> IO.shrink)][FC(r, c)] =
3185 imgdata.rawdata.raw_image[(row + S.top_margin) * S.raw_pitch / 2 + (col + S.left_margin)];
3186 }
3187 }
3188 }
3189 else
3190 {
3191 int row, col;
3192 for (row = 0; row < S.height; row++)
3193 for (col = 0; col < S.width; col++)
3194 imgdata.image[((row) >> IO.shrink) * S.iwidth + ((col) >> IO.shrink)][fcol(row, col)] =
3195 imgdata.rawdata.raw_image[(row + S.top_margin) * S.raw_pitch / 2 + (col + S.left_margin)];
3196 }
3197 }
3198 else // if(decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
3199 {
3200 if (imgdata.rawdata.color4_image)
3201 {
3202 if (S.width * 8 == S.raw_pitch)
3203 memmove(imgdata.image, imgdata.rawdata.color4_image, S.width * S.height * sizeof(*imgdata.image));
3204 else
3205 {
3206 for (int row = 0; row < S.height; row++)
3207 memmove(&imgdata.image[row * S.width],
3208 &imgdata.rawdata.color4_image[(row + S.top_margin) * S.raw_pitch / 8 + S.left_margin],
3209 S.width * sizeof(*imgdata.image));
3210 }
3211 }
3212 else if (imgdata.rawdata.color3_image)
3213 {
3214 unsigned char *c3image = (unsigned char *)imgdata.rawdata.color3_image;
3215 for (int row = 0; row < S.height; row++)
3216 {
3217 ushort(*srcrow)[3] = (ushort(*)[3]) & c3image[(row + S.top_margin) * S.raw_pitch];
3218 ushort(*dstrow)[4] = (ushort(*)[4]) & imgdata.image[row * S.width];
3219 for (int col = 0; col < S.width; col++)
3220 {
3221 for (int c = 0; c < 3; c++)
3222 dstrow[col][c] = srcrow[S.left_margin + col][c];
3223 dstrow[col][3] = 0;
3224 }
3225 }
3226 }
3227 else
3228 {
3229 // legacy decoder, but no data?
3230 throw LIBRAW_EXCEPTION_DECODE_RAW;
3231 }
3232 }
3233
3234 // Free PhaseOne separate copy allocated at function start
3235 if (is_phaseone_compressed())
3236 {
3237 phase_one_free_tempbuffer();
3238 }
3239 // hack - clear later flags!
3240
3241 if (load_raw == &CLASS canon_600_load_raw && S.width < S.raw_width)
3242 {
3243 canon_600_correct();
3244 }
3245
3246 imgdata.progress_flags = LIBRAW_PROGRESS_START | LIBRAW_PROGRESS_OPEN | LIBRAW_PROGRESS_RAW2_IMAGE |
3247 LIBRAW_PROGRESS_IDENTIFY | LIBRAW_PROGRESS_SIZE_ADJUST | LIBRAW_PROGRESS_LOAD_RAW;
3248 return 0;
3249 }
3250 catch (LibRaw_exceptions err)
3251 {
3252 EXCEPTION_HANDLER(err);
3253 }
3254 }
3255
phase_one_allocate_tempbuffer()3256 void LibRaw::phase_one_allocate_tempbuffer()
3257 {
3258 // Allocate temp raw_image buffer
3259 imgdata.rawdata.raw_image = (ushort *)malloc(S.raw_pitch * S.raw_height);
3260 merror(imgdata.rawdata.raw_image, "phase_one_prepare_to_correct()");
3261 }
phase_one_free_tempbuffer()3262 void LibRaw::phase_one_free_tempbuffer()
3263 {
3264 free(imgdata.rawdata.raw_image);
3265 imgdata.rawdata.raw_image = (ushort *)imgdata.rawdata.raw_alloc;
3266 }
3267
phase_one_subtract_black(ushort * src,ushort * dest)3268 int LibRaw::phase_one_subtract_black(ushort *src, ushort *dest)
3269 {
3270
3271 try
3272 {
3273 if (O.user_black < 0 && O.user_cblack[0] <= -1000000 && O.user_cblack[1] <= -1000000 &&
3274 O.user_cblack[2] <= -1000000 && O.user_cblack[3] <= -1000000)
3275 {
3276 if (!imgdata.rawdata.ph1_cblack || !imgdata.rawdata.ph1_rblack)
3277 {
3278 register int bl = imgdata.color.phase_one_data.t_black;
3279 for (int row = 0; row < S.raw_height; row++)
3280 {
3281 checkCancel();
3282 for (int col = 0; col < S.raw_width; col++)
3283 {
3284 int idx = row * S.raw_width + col;
3285 int val = int(src[idx]) - bl;
3286 dest[idx] = val > 0 ? val : 0;
3287 }
3288 }
3289 }
3290 else
3291 {
3292 register int bl = imgdata.color.phase_one_data.t_black;
3293 for (int row = 0; row < S.raw_height; row++)
3294 {
3295 checkCancel();
3296 for (int col = 0; col < S.raw_width; col++)
3297 {
3298 int idx = row * S.raw_width + col;
3299 int val = int(src[idx]) - bl +
3300 imgdata.rawdata.ph1_cblack[row][col >= imgdata.rawdata.color.phase_one_data.split_col] +
3301 imgdata.rawdata.ph1_rblack[col][row >= imgdata.rawdata.color.phase_one_data.split_row];
3302 dest[idx] = val > 0 ? val : 0;
3303 }
3304 }
3305 }
3306 }
3307 else // black set by user interaction
3308 {
3309 // Black level in cblack!
3310 for (int row = 0; row < S.raw_height; row++)
3311 {
3312 checkCancel();
3313 unsigned short cblk[16];
3314 for (int cc = 0; cc < 16; cc++)
3315 cblk[cc] = C.cblack[fcol(row, cc)];
3316 for (int col = 0; col < S.raw_width; col++)
3317 {
3318 int idx = row * S.raw_width + col;
3319 ushort val = src[idx];
3320 ushort bl = cblk[col & 0xf];
3321 dest[idx] = val > bl ? val - bl : 0;
3322 }
3323 }
3324 }
3325 return 0;
3326 }
3327 catch (LibRaw_exceptions err)
3328 {
3329 return LIBRAW_CANCELLED_BY_CALLBACK;
3330 }
3331 }
3332
copy_fuji_uncropped(unsigned short cblack[4],unsigned short * dmaxp)3333 void LibRaw::copy_fuji_uncropped(unsigned short cblack[4], unsigned short *dmaxp)
3334 {
3335 int row;
3336 #if defined(LIBRAW_USE_OPENMP)
3337 #pragma omp parallel for default(shared)
3338 #endif
3339 for (row = 0; row < S.raw_height - S.top_margin * 2; row++)
3340 {
3341 int col;
3342 unsigned short ldmax = 0;
3343 for (col = 0; col < IO.fuji_width << !libraw_internal_data.unpacker_data.fuji_layout; col++)
3344 {
3345 unsigned r, c;
3346 if (libraw_internal_data.unpacker_data.fuji_layout)
3347 {
3348 r = IO.fuji_width - 1 - col + (row >> 1);
3349 c = col + ((row + 1) >> 1);
3350 }
3351 else
3352 {
3353 r = IO.fuji_width - 1 + row - (col >> 1);
3354 c = row + ((col + 1) >> 1);
3355 }
3356 if (r < S.height && c < S.width)
3357 {
3358 unsigned short val = imgdata.rawdata.raw_image[(row + S.top_margin) * S.raw_pitch / 2 + (col + S.left_margin)];
3359 int cc = FC(r, c);
3360 if (val > cblack[cc])
3361 {
3362 val -= cblack[cc];
3363 if (val > ldmax)
3364 ldmax = val;
3365 }
3366 else
3367 val = 0;
3368 imgdata.image[((r) >> IO.shrink) * S.iwidth + ((c) >> IO.shrink)][cc] = val;
3369 }
3370 }
3371 #if defined(LIBRAW_USE_OPENMP)
3372 #pragma omp critical(dataupdate)
3373 #endif
3374 {
3375 if (*dmaxp < ldmax)
3376 *dmaxp = ldmax;
3377 }
3378 }
3379 }
3380
copy_bayer(unsigned short cblack[4],unsigned short * dmaxp)3381 void LibRaw::copy_bayer(unsigned short cblack[4], unsigned short *dmaxp)
3382 {
3383 // Both cropped and uncropped
3384 int row;
3385
3386 #if defined(LIBRAW_USE_OPENMP)
3387 #pragma omp parallel for default(shared)
3388 #endif
3389 for (row = 0; row < S.height; row++)
3390 {
3391 int col;
3392 unsigned short ldmax = 0;
3393 for (col = 0; col < S.width; col++)
3394 {
3395 unsigned short val = imgdata.rawdata.raw_image[(row + S.top_margin) * S.raw_pitch / 2 + (col + S.left_margin)];
3396 int cc = fcol(row, col);
3397 if (val > cblack[cc])
3398 {
3399 val -= cblack[cc];
3400 if (val > ldmax)
3401 ldmax = val;
3402 }
3403 else
3404 val = 0;
3405 imgdata.image[((row) >> IO.shrink) * S.iwidth + ((col) >> IO.shrink)][cc] = val;
3406 }
3407 #if defined(LIBRAW_USE_OPENMP)
3408 #pragma omp critical(dataupdate)
3409 #endif
3410 {
3411 if (*dmaxp < ldmax)
3412 *dmaxp = ldmax;
3413 }
3414 }
3415 }
3416
raw2image_ex(int do_subtract_black)3417 int LibRaw::raw2image_ex(int do_subtract_black)
3418 {
3419
3420 CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
3421
3422 try
3423 {
3424 raw2image_start();
3425
3426 // Compressed P1 files with bl data!
3427 if (is_phaseone_compressed())
3428 {
3429 phase_one_allocate_tempbuffer();
3430 int rc = phase_one_subtract_black((ushort *)imgdata.rawdata.raw_alloc, imgdata.rawdata.raw_image);
3431 if (rc == 0)
3432 rc = phase_one_correct();
3433 if (rc != 0)
3434 {
3435 phase_one_free_tempbuffer();
3436 return rc;
3437 }
3438 }
3439
3440 // process cropping
3441 int do_crop = 0;
3442 unsigned save_width = S.width;
3443 if (~O.cropbox[2] && ~O.cropbox[3])
3444 {
3445 int crop[4], c, filt;
3446 for (int c = 0; c < 4; c++)
3447 {
3448 crop[c] = O.cropbox[c];
3449 if (crop[c] < 0)
3450 crop[c] = 0;
3451 }
3452
3453 if (IO.fuji_width && imgdata.idata.filters >= 1000)
3454 {
3455 crop[0] = (crop[0] / 4) * 4;
3456 crop[1] = (crop[1] / 4) * 4;
3457 if (!libraw_internal_data.unpacker_data.fuji_layout)
3458 {
3459 crop[2] *= sqrt(2.0);
3460 crop[3] /= sqrt(2.0);
3461 }
3462 crop[2] = (crop[2] / 4 + 1) * 4;
3463 crop[3] = (crop[3] / 4 + 1) * 4;
3464 }
3465 else if (imgdata.idata.filters == 1)
3466 {
3467 crop[0] = (crop[0] / 16) * 16;
3468 crop[1] = (crop[1] / 16) * 16;
3469 }
3470 else if (imgdata.idata.filters == LIBRAW_XTRANS)
3471 {
3472 crop[0] = (crop[0] / 6) * 6;
3473 crop[1] = (crop[1] / 6) * 6;
3474 }
3475 do_crop = 1;
3476
3477 crop[2] = MIN(crop[2], (signed)S.width - crop[0]);
3478 crop[3] = MIN(crop[3], (signed)S.height - crop[1]);
3479 if (crop[2] <= 0 || crop[3] <= 0)
3480 throw LIBRAW_EXCEPTION_BAD_CROP;
3481
3482 // adjust sizes!
3483 S.left_margin += crop[0];
3484 S.top_margin += crop[1];
3485 S.width = crop[2];
3486 S.height = crop[3];
3487
3488 S.iheight = (S.height + IO.shrink) >> IO.shrink;
3489 S.iwidth = (S.width + IO.shrink) >> IO.shrink;
3490 if (!IO.fuji_width && imgdata.idata.filters && imgdata.idata.filters >= 1000)
3491 {
3492 for (filt = c = 0; c < 16; c++)
3493 filt |= FC((c >> 1) + (crop[1]), (c & 1) + (crop[0])) << c * 2;
3494 imgdata.idata.filters = filt;
3495 }
3496 }
3497
3498 int alloc_width = S.iwidth;
3499 int alloc_height = S.iheight;
3500
3501 if (IO.fuji_width && do_crop)
3502 {
3503 int IO_fw = S.width >> !libraw_internal_data.unpacker_data.fuji_layout;
3504 int t_alloc_width = (S.height >> libraw_internal_data.unpacker_data.fuji_layout) + IO_fw;
3505 int t_alloc_height = t_alloc_width - 1;
3506 alloc_height = (t_alloc_height + IO.shrink) >> IO.shrink;
3507 alloc_width = (t_alloc_width + IO.shrink) >> IO.shrink;
3508 }
3509 int alloc_sz = alloc_width * alloc_height;
3510
3511 if (imgdata.image)
3512 {
3513 imgdata.image = (ushort(*)[4])realloc(imgdata.image, alloc_sz * sizeof(*imgdata.image));
3514 memset(imgdata.image, 0, alloc_sz * sizeof(*imgdata.image));
3515 }
3516 else
3517 imgdata.image = (ushort(*)[4])calloc(alloc_sz, sizeof(*imgdata.image));
3518 merror(imgdata.image, "raw2image_ex()");
3519
3520 libraw_decoder_info_t decoder_info;
3521 get_decoder_info(&decoder_info);
3522
3523 // Adjust black levels
3524 unsigned short cblack[4] = {0, 0, 0, 0};
3525 unsigned short dmax = 0;
3526 if (do_subtract_black)
3527 {
3528 adjust_bl();
3529 for (int i = 0; i < 4; i++)
3530 cblack[i] = (unsigned short)C.cblack[i];
3531 }
3532
3533 // Move saved bitmap to imgdata.image
3534 if (imgdata.idata.filters || P1.colors == 1)
3535 {
3536 if (IO.fuji_width)
3537 {
3538 if (do_crop)
3539 {
3540 IO.fuji_width = S.width >> !libraw_internal_data.unpacker_data.fuji_layout;
3541 int IO_fwidth = (S.height >> libraw_internal_data.unpacker_data.fuji_layout) + IO.fuji_width;
3542 int IO_fheight = IO_fwidth - 1;
3543
3544 int row, col;
3545 for (row = 0; row < S.height; row++)
3546 {
3547 for (col = 0; col < S.width; col++)
3548 {
3549 int r, c;
3550 if (libraw_internal_data.unpacker_data.fuji_layout)
3551 {
3552 r = IO.fuji_width - 1 - col + (row >> 1);
3553 c = col + ((row + 1) >> 1);
3554 }
3555 else
3556 {
3557 r = IO.fuji_width - 1 + row - (col >> 1);
3558 c = row + ((col + 1) >> 1);
3559 }
3560
3561 unsigned short val =
3562 imgdata.rawdata.raw_image[(row + S.top_margin) * S.raw_pitch / 2 + (col + S.left_margin)];
3563 int cc = FCF(row, col);
3564 if (val > cblack[cc])
3565 {
3566 val -= cblack[cc];
3567 if (dmax < val)
3568 dmax = val;
3569 }
3570 else
3571 val = 0;
3572 imgdata.image[((r) >> IO.shrink) * alloc_width + ((c) >> IO.shrink)][cc] = val;
3573 }
3574 }
3575 S.height = IO_fheight;
3576 S.width = IO_fwidth;
3577 S.iheight = (S.height + IO.shrink) >> IO.shrink;
3578 S.iwidth = (S.width + IO.shrink) >> IO.shrink;
3579 S.raw_height -= 2 * S.top_margin;
3580 }
3581 else
3582 {
3583 copy_fuji_uncropped(cblack, &dmax);
3584 }
3585 } // end Fuji
3586 else
3587 {
3588 copy_bayer(cblack, &dmax);
3589 }
3590 }
3591 else // if(decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
3592 {
3593 if (imgdata.rawdata.color4_image)
3594 {
3595 if (S.raw_pitch != S.width * 8)
3596 {
3597 for (int row = 0; row < S.height; row++)
3598 memmove(&imgdata.image[row * S.width],
3599 &imgdata.rawdata.color4_image[(row + S.top_margin) * S.raw_pitch / 8 + S.left_margin],
3600 S.width * sizeof(*imgdata.image));
3601 }
3602 else
3603 {
3604 // legacy is always 4channel and not shrinked!
3605 memmove(imgdata.image, imgdata.rawdata.color4_image, S.width * S.height * sizeof(*imgdata.image));
3606 }
3607 }
3608 else if (imgdata.rawdata.color3_image)
3609 {
3610 unsigned char *c3image = (unsigned char *)imgdata.rawdata.color3_image;
3611 for (int row = 0; row < S.height; row++)
3612 {
3613 ushort(*srcrow)[3] = (ushort(*)[3]) & c3image[(row + S.top_margin) * S.raw_pitch];
3614 ushort(*dstrow)[4] = (ushort(*)[4]) & imgdata.image[row * S.width];
3615 for (int col = 0; col < S.width; col++)
3616 {
3617 for (int c = 0; c < 3; c++)
3618 dstrow[col][c] = srcrow[S.left_margin + col][c];
3619 dstrow[col][3] = 0;
3620 }
3621 }
3622 }
3623 else
3624 {
3625 // legacy decoder, but no data?
3626 throw LIBRAW_EXCEPTION_DECODE_RAW;
3627 }
3628 }
3629
3630 // Free PhaseOne separate copy allocated at function start
3631 if (is_phaseone_compressed())
3632 {
3633 phase_one_free_tempbuffer();
3634 }
3635 if (load_raw == &CLASS canon_600_load_raw && S.width < S.raw_width)
3636 {
3637 canon_600_correct();
3638 }
3639
3640 if (do_subtract_black)
3641 {
3642 C.data_maximum = (int)dmax;
3643 C.maximum -= C.black;
3644 // ZERO(C.cblack);
3645 C.cblack[0] = C.cblack[1] = C.cblack[2] = C.cblack[3] = 0;
3646 C.black = 0;
3647 }
3648
3649 // hack - clear later flags!
3650 imgdata.progress_flags = LIBRAW_PROGRESS_START | LIBRAW_PROGRESS_OPEN | LIBRAW_PROGRESS_RAW2_IMAGE |
3651 LIBRAW_PROGRESS_IDENTIFY | LIBRAW_PROGRESS_SIZE_ADJUST | LIBRAW_PROGRESS_LOAD_RAW;
3652 return 0;
3653 }
3654 catch (LibRaw_exceptions err)
3655 {
3656 EXCEPTION_HANDLER(err);
3657 }
3658 }
3659
3660 #if 1
3661
dcraw_make_mem_thumb(int * errcode)3662 libraw_processed_image_t *LibRaw::dcraw_make_mem_thumb(int *errcode)
3663 {
3664 if (!T.thumb)
3665 {
3666 if (!ID.toffset && !(imgdata.thumbnail.tlength > 0 && load_raw == &LibRaw::broadcom_load_raw) // RPi
3667 )
3668 {
3669 if (errcode)
3670 *errcode = LIBRAW_NO_THUMBNAIL;
3671 }
3672 else
3673 {
3674 if (errcode)
3675 *errcode = LIBRAW_OUT_OF_ORDER_CALL;
3676 }
3677 return NULL;
3678 }
3679
3680 if (T.tformat == LIBRAW_THUMBNAIL_BITMAP)
3681 {
3682 libraw_processed_image_t *ret = (libraw_processed_image_t *)::malloc(sizeof(libraw_processed_image_t) + T.tlength);
3683
3684 if (!ret)
3685 {
3686 if (errcode)
3687 *errcode = ENOMEM;
3688 return NULL;
3689 }
3690
3691 memset(ret, 0, sizeof(libraw_processed_image_t));
3692 ret->type = LIBRAW_IMAGE_BITMAP;
3693 ret->height = T.theight;
3694 ret->width = T.twidth;
3695 ret->colors = 3;
3696 ret->bits = 8;
3697 ret->data_size = T.tlength;
3698 memmove(ret->data, T.thumb, T.tlength);
3699 if (errcode)
3700 *errcode = 0;
3701 return ret;
3702 }
3703 else if (T.tformat == LIBRAW_THUMBNAIL_JPEG)
3704 {
3705 ushort exif[5];
3706 int mk_exif = 0;
3707 if (strcmp(T.thumb + 6, "Exif"))
3708 mk_exif = 1;
3709
3710 int dsize = T.tlength + mk_exif * (sizeof(exif) + sizeof(tiff_hdr));
3711
3712 libraw_processed_image_t *ret = (libraw_processed_image_t *)::malloc(sizeof(libraw_processed_image_t) + dsize);
3713
3714 if (!ret)
3715 {
3716 if (errcode)
3717 *errcode = ENOMEM;
3718 return NULL;
3719 }
3720
3721 memset(ret, 0, sizeof(libraw_processed_image_t));
3722
3723 ret->type = LIBRAW_IMAGE_JPEG;
3724 ret->data_size = dsize;
3725
3726 ret->data[0] = 0xff;
3727 ret->data[1] = 0xd8;
3728 if (mk_exif)
3729 {
3730 struct tiff_hdr th;
3731 memcpy(exif, "\xff\xe1 Exif\0\0", 10);
3732 exif[1] = htons(8 + sizeof th);
3733 memmove(ret->data + 2, exif, sizeof(exif));
3734 tiff_head(&th, 0);
3735 memmove(ret->data + (2 + sizeof(exif)), &th, sizeof(th));
3736 memmove(ret->data + (2 + sizeof(exif) + sizeof(th)), T.thumb + 2, T.tlength - 2);
3737 }
3738 else
3739 {
3740 memmove(ret->data + 2, T.thumb + 2, T.tlength - 2);
3741 }
3742 if (errcode)
3743 *errcode = 0;
3744 return ret;
3745 }
3746 else
3747 {
3748 if (errcode)
3749 *errcode = LIBRAW_UNSUPPORTED_THUMBNAIL;
3750 return NULL;
3751 }
3752 }
3753
3754 // jlb
3755 // macros for copying pixels to either BGR or RGB formats
3756 #define FORBGR for (c = P1.colors - 1; c >= 0; c--)
3757 #define FORRGB for (c = 0; c < P1.colors; c++)
3758
get_mem_image_format(int * width,int * height,int * colors,int * bps) const3759 void LibRaw::get_mem_image_format(int *width, int *height, int *colors, int *bps) const
3760
3761 {
3762 if (S.flip & 4)
3763 {
3764 *width = S.height;
3765 *height = S.width;
3766 }
3767 else
3768 {
3769 *width = S.width;
3770 *height = S.height;
3771 }
3772 *colors = P1.colors;
3773 *bps = O.output_bps;
3774 }
3775
copy_mem_image(void * scan0,int stride,int bgr)3776 int LibRaw::copy_mem_image(void *scan0, int stride, int bgr)
3777
3778 {
3779 // the image memory pointed to by scan0 is assumed to be in the format returned by get_mem_image_format
3780 if ((imgdata.progress_flags & LIBRAW_PROGRESS_THUMB_MASK) < LIBRAW_PROGRESS_PRE_INTERPOLATE)
3781 return LIBRAW_OUT_OF_ORDER_CALL;
3782
3783 if (libraw_internal_data.output_data.histogram)
3784 {
3785 int perc, val, total, t_white = 0x2000, c;
3786 perc = S.width * S.height * O.auto_bright_thr;
3787 if (IO.fuji_width)
3788 perc /= 2;
3789 if (!((O.highlight & ~2) || O.no_auto_bright))
3790 for (t_white = c = 0; c < P1.colors; c++)
3791 {
3792 for (val = 0x2000, total = 0; --val > 32;)
3793 if ((total += libraw_internal_data.output_data.histogram[c][val]) > perc)
3794 break;
3795 if (t_white < val)
3796 t_white = val;
3797 }
3798 gamma_curve(O.gamm[0], O.gamm[1], 2, (t_white << 3) / O.bright);
3799 }
3800
3801 int s_iheight = S.iheight;
3802 int s_iwidth = S.iwidth;
3803 int s_width = S.width;
3804 int s_hwight = S.height;
3805
3806 S.iheight = S.height;
3807 S.iwidth = S.width;
3808
3809 if (S.flip & 4)
3810 SWAP(S.height, S.width);
3811 uchar *ppm;
3812 ushort *ppm2;
3813 int c, row, col, soff, rstep, cstep;
3814
3815 soff = flip_index(0, 0);
3816 cstep = flip_index(0, 1) - soff;
3817 rstep = flip_index(1, 0) - flip_index(0, S.width);
3818
3819 for (row = 0; row < S.height; row++, soff += rstep)
3820 {
3821 uchar *bufp = ((uchar *)scan0) + row * stride;
3822 ppm2 = (ushort *)(ppm = bufp);
3823 // keep trivial decisions in the outer loop for speed
3824 if (bgr)
3825 {
3826 if (O.output_bps == 8)
3827 {
3828 for (col = 0; col < S.width; col++, soff += cstep)
3829 FORBGR *ppm++ = imgdata.color.curve[imgdata.image[soff][c]] >> 8;
3830 }
3831 else
3832 {
3833 for (col = 0; col < S.width; col++, soff += cstep)
3834 FORBGR *ppm2++ = imgdata.color.curve[imgdata.image[soff][c]];
3835 }
3836 }
3837 else
3838 {
3839 if (O.output_bps == 8)
3840 {
3841 for (col = 0; col < S.width; col++, soff += cstep)
3842 FORRGB *ppm++ = imgdata.color.curve[imgdata.image[soff][c]] >> 8;
3843 }
3844 else
3845 {
3846 for (col = 0; col < S.width; col++, soff += cstep)
3847 FORRGB *ppm2++ = imgdata.color.curve[imgdata.image[soff][c]];
3848 }
3849 }
3850
3851 // bufp += stride; // go to the next line
3852 }
3853
3854 S.iheight = s_iheight;
3855 S.iwidth = s_iwidth;
3856 S.width = s_width;
3857 S.height = s_hwight;
3858
3859 return 0;
3860 }
3861 #undef FORBGR
3862 #undef FORRGB
3863
dcraw_make_mem_image(int * errcode)3864 libraw_processed_image_t *LibRaw::dcraw_make_mem_image(int *errcode)
3865
3866 {
3867 int width, height, colors, bps;
3868 get_mem_image_format(&width, &height, &colors, &bps);
3869 int stride = width * (bps / 8) * colors;
3870 unsigned ds = height * stride;
3871 libraw_processed_image_t *ret = (libraw_processed_image_t *)::malloc(sizeof(libraw_processed_image_t) + ds);
3872 if (!ret)
3873 {
3874 if (errcode)
3875 *errcode = ENOMEM;
3876 return NULL;
3877 }
3878 memset(ret, 0, sizeof(libraw_processed_image_t));
3879
3880 // metadata init
3881 ret->type = LIBRAW_IMAGE_BITMAP;
3882 ret->height = height;
3883 ret->width = width;
3884 ret->colors = colors;
3885 ret->bits = bps;
3886 ret->data_size = ds;
3887 copy_mem_image(ret->data, stride, 0);
3888
3889 return ret;
3890 }
3891
3892 #undef FORC
3893 #undef FORCC
3894 #undef SWAP
3895 #endif
3896
dcraw_ppm_tiff_writer(const char * filename)3897 int LibRaw::dcraw_ppm_tiff_writer(const char *filename)
3898 {
3899 CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
3900
3901 if (!imgdata.image)
3902 return LIBRAW_OUT_OF_ORDER_CALL;
3903
3904 if (!filename)
3905 return ENOENT;
3906 FILE *f = fopen(filename, "wb");
3907
3908 if (!f)
3909 return errno;
3910
3911 try
3912 {
3913 if (!libraw_internal_data.output_data.histogram)
3914 {
3915 libraw_internal_data.output_data.histogram =
3916 (int(*)[LIBRAW_HISTOGRAM_SIZE])malloc(sizeof(*libraw_internal_data.output_data.histogram) * 4);
3917 merror(libraw_internal_data.output_data.histogram, "LibRaw::dcraw_ppm_tiff_writer()");
3918 }
3919 libraw_internal_data.internal_data.output = f;
3920 write_ppm_tiff();
3921 SET_PROC_FLAG(LIBRAW_PROGRESS_FLIP);
3922 libraw_internal_data.internal_data.output = NULL;
3923 fclose(f);
3924 return 0;
3925 }
3926 catch (LibRaw_exceptions err)
3927 {
3928 fclose(f);
3929 EXCEPTION_HANDLER(err);
3930 }
3931 }
3932
3933 #define THUMB_READ_BEYOND 16384
3934
kodak_thumb_loader()3935 void LibRaw::kodak_thumb_loader()
3936 {
3937 INT64 est_datasize = T.theight * T.twidth / 3; // is 0.3 bytes per pixel good estimate?
3938 if (ID.toffset < 0)
3939 throw LIBRAW_EXCEPTION_IO_CORRUPT;
3940
3941 if (ID.toffset + est_datasize > ID.input->size() + THUMB_READ_BEYOND)
3942 throw LIBRAW_EXCEPTION_IO_EOF;
3943
3944 // some kodak cameras
3945 ushort s_height = S.height, s_width = S.width, s_iwidth = S.iwidth, s_iheight = S.iheight;
3946 ushort s_flags = libraw_internal_data.unpacker_data.load_flags;
3947 libraw_internal_data.unpacker_data.load_flags = 12;
3948 int s_colors = P1.colors;
3949 unsigned s_filters = P1.filters;
3950 ushort(*s_image)[4] = imgdata.image;
3951
3952 S.height = T.theight;
3953 S.width = T.twidth;
3954 P1.filters = 0;
3955
3956 if (thumb_load_raw == &CLASS kodak_ycbcr_load_raw)
3957 {
3958 S.height += S.height & 1;
3959 S.width += S.width & 1;
3960 }
3961
3962 imgdata.image = (ushort(*)[4])calloc(S.iheight * S.iwidth, sizeof(*imgdata.image));
3963 merror(imgdata.image, "LibRaw::kodak_thumb_loader()");
3964
3965 ID.input->seek(ID.toffset, SEEK_SET);
3966 // read kodak thumbnail into T.image[]
3967 try
3968 {
3969 (this->*thumb_load_raw)();
3970 }
3971 catch (...)
3972 {
3973 free(imgdata.image);
3974 imgdata.image = s_image;
3975
3976 T.twidth = 0;
3977 S.width = s_width;
3978
3979 S.iwidth = s_iwidth;
3980 S.iheight = s_iheight;
3981
3982 T.theight = 0;
3983 S.height = s_height;
3984
3985 T.tcolors = 0;
3986 P1.colors = s_colors;
3987
3988 P1.filters = s_filters;
3989 T.tlength = 0;
3990 libraw_internal_data.unpacker_data.load_flags = s_flags;
3991 return;
3992 }
3993
3994 // copy-n-paste from image pipe
3995 #define MIN(a, b) ((a) < (b) ? (a) : (b))
3996 #define MAX(a, b) ((a) > (b) ? (a) : (b))
3997 #define LIM(x, min, max) MAX(min, MIN(x, max))
3998 #ifndef CLIP
3999 #define CLIP(x) LIM(x, 0, 65535)
4000 #endif
4001 #define SWAP(a, b) \
4002 { \
4003 a ^= b; \
4004 a ^= (b ^= a); \
4005 }
4006
4007 // from scale_colors
4008 {
4009 double dmax;
4010 float scale_mul[4];
4011 int c, val;
4012 for (dmax = DBL_MAX, c = 0; c < 3; c++)
4013 if (dmax > C.pre_mul[c])
4014 dmax = C.pre_mul[c];
4015
4016 for (c = 0; c < 3; c++)
4017 scale_mul[c] = (C.pre_mul[c] / dmax) * 65535.0 / C.maximum;
4018 scale_mul[3] = scale_mul[1];
4019
4020 size_t size = S.height * S.width;
4021 for (unsigned i = 0; i < size * 4; i++)
4022 {
4023 val = imgdata.image[0][i];
4024 if (!val)
4025 continue;
4026 val *= scale_mul[i & 3];
4027 imgdata.image[0][i] = CLIP(val);
4028 }
4029 }
4030
4031 // from convert_to_rgb
4032 ushort *img;
4033 int row, col;
4034
4035 int(*t_hist)[LIBRAW_HISTOGRAM_SIZE] = (int(*)[LIBRAW_HISTOGRAM_SIZE])calloc(sizeof(*t_hist), 4);
4036 merror(t_hist, "LibRaw::kodak_thumb_loader()");
4037
4038 float out[3], out_cam[3][4] = {{2.81761312, -1.98369181, 0.166078627, 0},
4039 {-0.111855984, 1.73688626, -0.625030339, 0},
4040 {-0.0379119813, -0.891268849, 1.92918086, 0}};
4041
4042 for (img = imgdata.image[0], row = 0; row < S.height; row++)
4043 for (col = 0; col < S.width; col++, img += 4)
4044 {
4045 out[0] = out[1] = out[2] = 0;
4046 int c;
4047 for (c = 0; c < 3; c++)
4048 {
4049 out[0] += out_cam[0][c] * img[c];
4050 out[1] += out_cam[1][c] * img[c];
4051 out[2] += out_cam[2][c] * img[c];
4052 }
4053 for (c = 0; c < 3; c++)
4054 img[c] = CLIP((int)out[c]);
4055 for (c = 0; c < P1.colors; c++)
4056 t_hist[c][img[c] >> 3]++;
4057 }
4058
4059 // from gamma_lut
4060 int(*save_hist)[LIBRAW_HISTOGRAM_SIZE] = libraw_internal_data.output_data.histogram;
4061 libraw_internal_data.output_data.histogram = t_hist;
4062
4063 // make curve output curve!
4064 ushort(*t_curve) = (ushort *)calloc(sizeof(C.curve), 1);
4065 merror(t_curve, "LibRaw::kodak_thumb_loader()");
4066 memmove(t_curve, C.curve, sizeof(C.curve));
4067 memset(C.curve, 0, sizeof(C.curve));
4068 {
4069 int perc, val, total, t_white = 0x2000, c;
4070
4071 perc = S.width * S.height * 0.01; /* 99th percentile white level */
4072 if (IO.fuji_width)
4073 perc /= 2;
4074 if (!((O.highlight & ~2) || O.no_auto_bright))
4075 for (t_white = c = 0; c < P1.colors; c++)
4076 {
4077 for (val = 0x2000, total = 0; --val > 32;)
4078 if ((total += libraw_internal_data.output_data.histogram[c][val]) > perc)
4079 break;
4080 if (t_white < val)
4081 t_white = val;
4082 }
4083 gamma_curve(O.gamm[0], O.gamm[1], 2, (t_white << 3) / O.bright);
4084 }
4085
4086 libraw_internal_data.output_data.histogram = save_hist;
4087 free(t_hist);
4088
4089 // from write_ppm_tiff - copy pixels into bitmap
4090
4091 int s_flip = imgdata.sizes.flip;
4092 if (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_NO_ROTATE_FOR_KODAK_THUMBNAILS)
4093 imgdata.sizes.flip = 0;
4094
4095 S.iheight = S.height;
4096 S.iwidth = S.width;
4097 if (S.flip & 4)
4098 SWAP(S.height, S.width);
4099
4100 if (T.thumb)
4101 free(T.thumb);
4102 T.thumb = (char *)calloc(S.width * S.height, P1.colors);
4103 merror(T.thumb, "LibRaw::kodak_thumb_loader()");
4104 T.tlength = S.width * S.height * P1.colors;
4105
4106 // from write_tiff_ppm
4107 {
4108 int soff = flip_index(0, 0);
4109 int cstep = flip_index(0, 1) - soff;
4110 int rstep = flip_index(1, 0) - flip_index(0, S.width);
4111
4112 for (int row = 0; row < S.height; row++, soff += rstep)
4113 {
4114 char *ppm = T.thumb + row * S.width * P1.colors;
4115 for (int col = 0; col < S.width; col++, soff += cstep)
4116 for (int c = 0; c < P1.colors; c++)
4117 ppm[col * P1.colors + c] = imgdata.color.curve[imgdata.image[soff][c]] >> 8;
4118 }
4119 }
4120
4121 memmove(C.curve, t_curve, sizeof(C.curve));
4122 free(t_curve);
4123
4124 // restore variables
4125 free(imgdata.image);
4126 imgdata.image = s_image;
4127
4128 if (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_NO_ROTATE_FOR_KODAK_THUMBNAILS)
4129 imgdata.sizes.flip = s_flip;
4130
4131 T.twidth = S.width;
4132 S.width = s_width;
4133
4134 S.iwidth = s_iwidth;
4135 S.iheight = s_iheight;
4136
4137 T.theight = S.height;
4138 S.height = s_height;
4139
4140 T.tcolors = P1.colors;
4141 P1.colors = s_colors;
4142
4143 P1.filters = s_filters;
4144 libraw_internal_data.unpacker_data.load_flags = s_flags;
4145 }
4146 #undef MIN
4147 #undef MAX
4148 #undef LIM
4149 #undef CLIP
4150 #undef SWAP
4151
4152 // ������� thumbnail �� �����, ������ thumb_format � ������������ � ��������
4153
thumbOK(INT64 maxsz)4154 int LibRaw::thumbOK(INT64 maxsz)
4155 {
4156 if (!ID.input)
4157 return 0;
4158 if (!ID.toffset && !(imgdata.thumbnail.tlength > 0 && load_raw == &LibRaw::broadcom_load_raw) // RPi
4159 )
4160 return 0;
4161 INT64 fsize = ID.input->size();
4162 if (fsize > 0x7fffffffU)
4163 return 0; // No thumb for raw > 2Gb
4164 int tsize = 0;
4165 int tcol = (T.tcolors > 0 && T.tcolors < 4) ? T.tcolors : 3;
4166 if (write_thumb == &LibRaw::jpeg_thumb)
4167 tsize = T.tlength;
4168 else if (write_thumb == &LibRaw::ppm_thumb)
4169 tsize = tcol * T.twidth * T.theight;
4170 else if (write_thumb == &LibRaw::ppm16_thumb)
4171 tsize = tcol * T.twidth * T.theight *
4172 ((imgdata.params.raw_processing_options & LIBRAW_PROCESSING_USE_PPM16_THUMBS) ? 2 : 1);
4173 else if (write_thumb == &LibRaw::x3f_thumb_loader)
4174 {
4175 tsize = x3f_thumb_size();
4176 }
4177 else // Kodak => no check
4178 tsize = 1;
4179 if (tsize < 0)
4180 return 0;
4181 if (maxsz > 0 && tsize > maxsz)
4182 return 0;
4183 return (tsize + ID.toffset <= fsize) ? 1 : 0;
4184 }
4185
4186 #ifndef NO_JPEG
4187 struct jpegErrorManager
4188 {
4189 struct jpeg_error_mgr pub;
4190 jmp_buf setjmp_buffer;
4191 };
4192
jpegErrorExit(j_common_ptr cinfo)4193 static void jpegErrorExit(j_common_ptr cinfo)
4194 {
4195 jpegErrorManager *myerr = (jpegErrorManager *)cinfo->err;
4196 longjmp(myerr->setjmp_buffer, 1);
4197 }
4198 #endif
4199
unpack_thumb(void)4200 int LibRaw::unpack_thumb(void)
4201 {
4202 CHECK_ORDER_LOW(LIBRAW_PROGRESS_IDENTIFY);
4203 CHECK_ORDER_BIT(LIBRAW_PROGRESS_THUMB_LOAD);
4204
4205 try
4206 {
4207 if (!libraw_internal_data.internal_data.input)
4208 return LIBRAW_INPUT_CLOSED;
4209
4210 int t_colors = libraw_internal_data.unpacker_data.thumb_misc >> 5 & 7;
4211 int t_bytesps = (libraw_internal_data.unpacker_data.thumb_misc & 31) / 8;
4212
4213 if (!ID.toffset && !(imgdata.thumbnail.tlength > 0 && load_raw == &LibRaw::broadcom_load_raw) // RPi
4214 )
4215 {
4216 return LIBRAW_NO_THUMBNAIL;
4217 }
4218 else if (thumb_load_raw)
4219 {
4220 kodak_thumb_loader();
4221 T.tformat = LIBRAW_THUMBNAIL_BITMAP;
4222 SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
4223 return 0;
4224 }
4225 else
4226 {
4227 if (write_thumb == &LibRaw::x3f_thumb_loader)
4228 {
4229 INT64 tsize = x3f_thumb_size();
4230 if (tsize < 2048 || INT64(ID.toffset) + tsize < 1)
4231 throw LIBRAW_EXCEPTION_IO_CORRUPT;
4232
4233 if (INT64(ID.toffset) + tsize > ID.input->size() + THUMB_READ_BEYOND)
4234 throw LIBRAW_EXCEPTION_IO_EOF;
4235 }
4236 else
4237 {
4238 if (INT64(ID.toffset) + INT64(T.tlength) < 1)
4239 throw LIBRAW_EXCEPTION_IO_CORRUPT;
4240
4241 if (INT64(ID.toffset) + INT64(T.tlength) > ID.input->size() + THUMB_READ_BEYOND)
4242 throw LIBRAW_EXCEPTION_IO_EOF;
4243 }
4244
4245 ID.input->seek(ID.toffset, SEEK_SET);
4246 if (write_thumb == &LibRaw::jpeg_thumb)
4247 {
4248 if (T.thumb)
4249 free(T.thumb);
4250 T.thumb = (char *)malloc(T.tlength);
4251 merror(T.thumb, "jpeg_thumb()");
4252 ID.input->read(T.thumb, 1, T.tlength);
4253 unsigned char *tthumb = (unsigned char *)T.thumb;
4254 tthumb[0] = 0xff;
4255 tthumb[1] = 0xd8;
4256 #ifdef NO_JPEG
4257 T.tcolors = 3;
4258 #else
4259 {
4260 jpegErrorManager jerr;
4261 struct jpeg_decompress_struct cinfo;
4262 cinfo.err = jpeg_std_error(&jerr.pub);
4263 jerr.pub.error_exit = jpegErrorExit;
4264 if (setjmp(jerr.setjmp_buffer))
4265 {
4266 err2:
4267 // Error in original JPEG thumb, read it again because
4268 // original bytes 0-1 was damaged above
4269 jpeg_destroy_decompress(&cinfo);
4270 T.tcolors = 3;
4271 T.tformat = LIBRAW_THUMBNAIL_UNKNOWN;
4272 ID.input->seek(ID.toffset, SEEK_SET);
4273 ID.input->read(T.thumb, 1, T.tlength);
4274 SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
4275 return 0;
4276 }
4277 jpeg_create_decompress(&cinfo);
4278 jpeg_mem_src(&cinfo, (unsigned char *)T.thumb, T.tlength);
4279 int rc = jpeg_read_header(&cinfo, TRUE);
4280 if (rc != 1)
4281 goto err2;
4282 T.tcolors = (cinfo.num_components > 0 && cinfo.num_components <= 3) ? cinfo.num_components : 3;
4283 jpeg_destroy_decompress(&cinfo);
4284 }
4285 #endif
4286 T.tformat = LIBRAW_THUMBNAIL_JPEG;
4287 SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
4288 return 0;
4289 }
4290 else if (write_thumb == &LibRaw::ppm_thumb)
4291 {
4292 if (t_bytesps > 1)
4293 throw LIBRAW_EXCEPTION_IO_CORRUPT; // 8-bit thumb, but parsed for more bits
4294 int t_length = T.twidth * T.theight * t_colors;
4295
4296 if (T.tlength && T.tlength < t_length) // try to find tiff ifd with needed offset
4297 {
4298 int pifd = -1;
4299 for (int ii = 0; ii < libraw_internal_data.identify_data.tiff_nifds && ii < LIBRAW_IFD_MAXCOUNT; ii++)
4300 if (tiff_ifd[ii].offset == libraw_internal_data.internal_data.toffset) // found
4301 {
4302 pifd = ii;
4303 break;
4304 }
4305 if (pifd >= 0 && tiff_ifd[pifd].strip_offsets_count && tiff_ifd[pifd].strip_byte_counts_count)
4306 {
4307 // We found it, calculate final size
4308 unsigned total_size = 0;
4309 for (int i = 0; i < tiff_ifd[pifd].strip_byte_counts_count; i++)
4310 total_size += tiff_ifd[pifd].strip_byte_counts[i];
4311 if (total_size != t_length) // recalculate colors
4312 {
4313 if (total_size == T.twidth * T.tlength * 3)
4314 T.tcolors = 3;
4315 else if (total_size == T.twidth * T.tlength)
4316 T.tcolors = 1;
4317 }
4318 T.tlength = total_size;
4319 if (T.thumb)
4320 free(T.thumb);
4321 T.thumb = (char *)malloc(T.tlength);
4322 merror(T.thumb, "ppm_thumb()");
4323
4324 char *dest = T.thumb;
4325 INT64 pos = ID.input->tell();
4326
4327 for (int i = 0; i < tiff_ifd[pifd].strip_byte_counts_count && i < tiff_ifd[pifd].strip_offsets_count; i++)
4328 {
4329 int remain = T.tlength;
4330 int sz = tiff_ifd[pifd].strip_byte_counts[i];
4331 int off = tiff_ifd[pifd].strip_offsets[i];
4332 if (off >= 0 && off + sz <= ID.input->size() && sz <= remain)
4333 {
4334 ID.input->seek(off, SEEK_SET);
4335 ID.input->read(dest, sz, 1);
4336 remain -= sz;
4337 dest += sz;
4338 }
4339 }
4340 ID.input->seek(pos, SEEK_SET);
4341 T.tformat = LIBRAW_THUMBNAIL_BITMAP;
4342 SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
4343 return 0;
4344 }
4345 }
4346
4347 if (!T.tlength)
4348 T.tlength = t_length;
4349 if (T.thumb)
4350 free(T.thumb);
4351
4352 T.thumb = (char *)malloc(T.tlength);
4353 if (!T.tcolors)
4354 T.tcolors = t_colors;
4355 merror(T.thumb, "ppm_thumb()");
4356
4357 ID.input->read(T.thumb, 1, T.tlength);
4358
4359 T.tformat = LIBRAW_THUMBNAIL_BITMAP;
4360 SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
4361 return 0;
4362 }
4363 else if (write_thumb == &LibRaw::ppm16_thumb)
4364 {
4365 if (t_bytesps > 2)
4366 throw LIBRAW_EXCEPTION_IO_CORRUPT; // 16-bit thumb, but parsed for more bits
4367 int o_bps = (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_USE_PPM16_THUMBS) ? 2 : 1;
4368 int o_length = T.twidth * T.theight * t_colors * o_bps;
4369 int i_length = T.twidth * T.theight * t_colors * 2;
4370 if (!T.tlength)
4371 T.tlength = o_length;
4372 ushort *t_thumb = (ushort *)calloc(i_length, 1);
4373 ID.input->read(t_thumb, 1, i_length);
4374 if ((libraw_internal_data.unpacker_data.order == 0x4949) == (ntohs(0x1234) == 0x1234))
4375 swab((char *)t_thumb, (char *)t_thumb, i_length);
4376
4377 if (T.thumb)
4378 free(T.thumb);
4379 if ((imgdata.params.raw_processing_options & LIBRAW_PROCESSING_USE_PPM16_THUMBS))
4380 {
4381 T.thumb = (char *)t_thumb;
4382 T.tformat = LIBRAW_THUMBNAIL_BITMAP16;
4383 }
4384 else
4385 {
4386 T.thumb = (char *)malloc(o_length);
4387 merror(T.thumb, "ppm_thumb()");
4388 for (int i = 0; i < o_length; i++)
4389 T.thumb[i] = t_thumb[i] >> 8;
4390 free(t_thumb);
4391 T.tformat = LIBRAW_THUMBNAIL_BITMAP;
4392 }
4393 SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
4394 return 0;
4395 }
4396 else if (write_thumb == &LibRaw::x3f_thumb_loader)
4397 {
4398 x3f_thumb_loader();
4399 SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
4400 return 0;
4401 }
4402 else
4403 {
4404 return LIBRAW_UNSUPPORTED_THUMBNAIL;
4405 }
4406 }
4407 // last resort
4408 return LIBRAW_UNSUPPORTED_THUMBNAIL;
4409 }
4410 catch (LibRaw_exceptions err)
4411 {
4412 EXCEPTION_HANDLER(err);
4413 }
4414 }
4415
dcraw_thumb_writer(const char * fname)4416 int LibRaw::dcraw_thumb_writer(const char *fname)
4417 {
4418 // CHECK_ORDER_LOW(LIBRAW_PROGRESS_THUMB_LOAD);
4419
4420 if (!fname)
4421 return ENOENT;
4422
4423 FILE *tfp = fopen(fname, "wb");
4424
4425 if (!tfp)
4426 return errno;
4427
4428 if (!T.thumb)
4429 {
4430 fclose(tfp);
4431 return LIBRAW_OUT_OF_ORDER_CALL;
4432 }
4433
4434 try
4435 {
4436 switch (T.tformat)
4437 {
4438 case LIBRAW_THUMBNAIL_JPEG:
4439 jpeg_thumb_writer(tfp, T.thumb, T.tlength);
4440 break;
4441 case LIBRAW_THUMBNAIL_BITMAP:
4442 fprintf(tfp, "P6\n%d %d\n255\n", T.twidth, T.theight);
4443 fwrite(T.thumb, 1, T.tlength, tfp);
4444 break;
4445 default:
4446 fclose(tfp);
4447 return LIBRAW_UNSUPPORTED_THUMBNAIL;
4448 }
4449 fclose(tfp);
4450 return 0;
4451 }
4452 catch (LibRaw_exceptions err)
4453 {
4454 fclose(tfp);
4455 EXCEPTION_HANDLER(err);
4456 }
4457 }
4458
adjust_sizes_info_only(void)4459 int LibRaw::adjust_sizes_info_only(void)
4460 {
4461 CHECK_ORDER_LOW(LIBRAW_PROGRESS_IDENTIFY);
4462
4463 raw2image_start();
4464 if (O.use_fuji_rotate)
4465 {
4466 if (IO.fuji_width)
4467 {
4468 IO.fuji_width = (IO.fuji_width - 1 + IO.shrink) >> IO.shrink;
4469 S.iwidth = (ushort)(IO.fuji_width / sqrt(0.5));
4470 S.iheight = (ushort)((S.iheight - IO.fuji_width) / sqrt(0.5));
4471 }
4472 else
4473 {
4474 if (S.pixel_aspect < 0.995)
4475 S.iheight = (ushort)(S.iheight / S.pixel_aspect + 0.5);
4476 if (S.pixel_aspect > 1.005)
4477 S.iwidth = (ushort)(S.iwidth * S.pixel_aspect + 0.5);
4478 }
4479 }
4480 SET_PROC_FLAG(LIBRAW_PROGRESS_FUJI_ROTATE);
4481 if (S.flip & 4)
4482 {
4483 unsigned short t = S.iheight;
4484 S.iheight = S.iwidth;
4485 S.iwidth = t;
4486 SET_PROC_FLAG(LIBRAW_PROGRESS_FLIP);
4487 }
4488 return 0;
4489 }
4490
subtract_black()4491 int LibRaw::subtract_black()
4492 {
4493 adjust_bl();
4494 return subtract_black_internal();
4495 }
4496
subtract_black_internal()4497 int LibRaw::subtract_black_internal()
4498 {
4499 CHECK_ORDER_LOW(LIBRAW_PROGRESS_RAW2_IMAGE);
4500
4501 try
4502 {
4503 if (!is_phaseone_compressed() &&
4504 (C.cblack[0] || C.cblack[1] || C.cblack[2] || C.cblack[3] || (C.cblack[4] && C.cblack[5])))
4505 {
4506 #define BAYERC(row, col, c) imgdata.image[((row) >> IO.shrink) * S.iwidth + ((col) >> IO.shrink)][c]
4507 int cblk[4], i;
4508 for (i = 0; i < 4; i++)
4509 cblk[i] = C.cblack[i];
4510
4511 int size = S.iheight * S.iwidth;
4512 #define MIN(a, b) ((a) < (b) ? (a) : (b))
4513 #define MAX(a, b) ((a) > (b) ? (a) : (b))
4514 #define LIM(x, min, max) MAX(min, MIN(x, max))
4515 #define CLIP(x) LIM(x, 0, 65535)
4516 int dmax = 0;
4517 if (C.cblack[4] && C.cblack[5])
4518 {
4519 for (i = 0; i < size * 4; i++)
4520 {
4521 int val = imgdata.image[0][i];
4522 val -= C.cblack[6 + i / 4 / S.iwidth % C.cblack[4] * C.cblack[5] + i / 4 % S.iwidth % C.cblack[5]];
4523 val -= cblk[i & 3];
4524 imgdata.image[0][i] = CLIP(val);
4525 if (dmax < val)
4526 dmax = val;
4527 }
4528 }
4529 else
4530 {
4531 for (i = 0; i < size * 4; i++)
4532 {
4533 int val = imgdata.image[0][i];
4534 val -= cblk[i & 3];
4535 imgdata.image[0][i] = CLIP(val);
4536 if (dmax < val)
4537 dmax = val;
4538 }
4539 }
4540 C.data_maximum = dmax & 0xffff;
4541 #undef MIN
4542 #undef MAX
4543 #undef LIM
4544 #undef CLIP
4545 C.maximum -= C.black;
4546 ZERO(C.cblack); // Yeah, we used cblack[6+] values too!
4547 C.black = 0;
4548 #undef BAYERC
4549 }
4550 else
4551 {
4552 // Nothing to Do, maximum is already calculated, black level is 0, so no change
4553 // only calculate channel maximum;
4554 int idx;
4555 ushort *p = (ushort *)imgdata.image;
4556 int dmax = 0;
4557 for (idx = 0; idx < S.iheight * S.iwidth * 4; idx++)
4558 if (dmax < p[idx])
4559 dmax = p[idx];
4560 C.data_maximum = dmax;
4561 }
4562 return 0;
4563 }
4564 catch (LibRaw_exceptions err)
4565 {
4566 EXCEPTION_HANDLER(err);
4567 }
4568 }
4569
4570 #define TBLN 65535
4571
exp_bef(float shift,float smooth)4572 void LibRaw::exp_bef(float shift, float smooth)
4573 {
4574 // params limits
4575 if (shift > 8)
4576 shift = 8;
4577 if (shift < 0.25)
4578 shift = 0.25;
4579 if (smooth < 0.0)
4580 smooth = 0.0;
4581 if (smooth > 1.0)
4582 smooth = 1.0;
4583
4584 unsigned short *lut = (ushort *)malloc((TBLN + 1) * sizeof(unsigned short));
4585
4586 if (shift <= 1.0)
4587 {
4588 for (int i = 0; i <= TBLN; i++)
4589 lut[i] = (unsigned short)((float)i * shift);
4590 }
4591 else
4592 {
4593 float x1, x2, y1, y2;
4594
4595 float cstops = log(shift) / log(2.0f);
4596 float room = cstops * 2;
4597 float roomlin = powf(2.0f, room);
4598 x2 = (float)TBLN;
4599 x1 = (x2 + 1) / roomlin - 1;
4600 y1 = x1 * shift;
4601 y2 = x2 * (1 + (1 - smooth) * (shift - 1));
4602 float sq3x = powf(x1 * x1 * x2, 1.0f / 3.0f);
4603 float B = (y2 - y1 + shift * (3 * x1 - 3.0f * sq3x)) / (x2 + 2.0f * x1 - 3.0f * sq3x);
4604 float A = (shift - B) * 3.0f * powf(x1 * x1, 1.0f / 3.0f);
4605 float CC = y2 - A * powf(x2, 1.0f / 3.0f) - B * x2;
4606 for (int i = 0; i <= TBLN; i++)
4607 {
4608 float X = (float)i;
4609 float Y = A * powf(X, 1.0f / 3.0f) + B * X + CC;
4610 if (i < x1)
4611 lut[i] = (unsigned short)((float)i * shift);
4612 else
4613 lut[i] = Y < 0 ? 0 : (Y > TBLN ? TBLN : (unsigned short)(Y));
4614 }
4615 }
4616 for (int i = 0; i < S.height * S.width; i++)
4617 {
4618 imgdata.image[i][0] = lut[imgdata.image[i][0]];
4619 imgdata.image[i][1] = lut[imgdata.image[i][1]];
4620 imgdata.image[i][2] = lut[imgdata.image[i][2]];
4621 imgdata.image[i][3] = lut[imgdata.image[i][3]];
4622 }
4623
4624 if (C.data_maximum <= TBLN)
4625 C.data_maximum = lut[C.data_maximum];
4626 if (C.maximum <= TBLN)
4627 C.maximum = lut[C.maximum];
4628 free(lut);
4629 }
4630
4631 #define MIN(a, b) ((a) < (b) ? (a) : (b))
4632 #define MAX(a, b) ((a) > (b) ? (a) : (b))
4633 #define LIM(x, min, max) MAX(min, MIN(x, max))
4634 #define ULIM(x, y, z) ((y) < (z) ? LIM(x, y, z) : LIM(x, z, y))
4635 #define CLIP(x) LIM(x, 0, 65535)
4636
convert_to_rgb_loop(float out_cam[3][4])4637 void LibRaw::convert_to_rgb_loop(float out_cam[3][4])
4638 {
4639 int row, col, c;
4640 float out[3];
4641 ushort *img;
4642 memset(libraw_internal_data.output_data.histogram, 0, sizeof(int) * LIBRAW_HISTOGRAM_SIZE * 4);
4643 for (img = imgdata.image[0], row = 0; row < S.height; row++)
4644 for (col = 0; col < S.width; col++, img += 4)
4645 {
4646 if (!libraw_internal_data.internal_output_params.raw_color)
4647 {
4648 out[0] = out[1] = out[2] = 0;
4649 for (c = 0; c < imgdata.idata.colors; c++)
4650 {
4651 out[0] += out_cam[0][c] * img[c];
4652 out[1] += out_cam[1][c] * img[c];
4653 out[2] += out_cam[2][c] * img[c];
4654 }
4655 for (c = 0; c < 3; c++)
4656 img[c] = CLIP((int)out[c]);
4657 }
4658 for (c = 0; c < imgdata.idata.colors; c++)
4659 libraw_internal_data.output_data.histogram[c][img[c] >> 3]++;
4660 }
4661 }
4662
scale_colors_loop(float scale_mul[4])4663 void LibRaw::scale_colors_loop(float scale_mul[4])
4664 {
4665 unsigned size = S.iheight * S.iwidth;
4666
4667 if (C.cblack[4] && C.cblack[5])
4668 {
4669 int val;
4670 for (unsigned i = 0; i < size * 4; i++)
4671 {
4672 if (!(val = imgdata.image[0][i]))
4673 continue;
4674 val -= C.cblack[6 + i / 4 / S.iwidth % C.cblack[4] * C.cblack[5] + i / 4 % S.iwidth % C.cblack[5]];
4675 val -= C.cblack[i & 3];
4676 val *= scale_mul[i & 3];
4677 imgdata.image[0][i] = CLIP(val);
4678 }
4679 }
4680 else if (C.cblack[0] || C.cblack[1] || C.cblack[2] || C.cblack[3])
4681 {
4682 for (unsigned i = 0; i < size * 4; i++)
4683 {
4684 int val = imgdata.image[0][i];
4685 if (!val)
4686 continue;
4687 val -= C.cblack[i & 3];
4688 val *= scale_mul[i & 3];
4689 imgdata.image[0][i] = CLIP(val);
4690 }
4691 }
4692 else // BL is zero
4693 {
4694 for (unsigned i = 0; i < size * 4; i++)
4695 {
4696 int val = imgdata.image[0][i];
4697 val *= scale_mul[i & 3];
4698 imgdata.image[0][i] = CLIP(val);
4699 }
4700 }
4701 }
4702
adjust_bl()4703 void LibRaw::adjust_bl()
4704 {
4705 int clear_repeat = 0;
4706 if (O.user_black >= 0)
4707 {
4708 C.black = O.user_black;
4709 clear_repeat = 1;
4710 }
4711 for (int i = 0; i < 4; i++)
4712 if (O.user_cblack[i] > -1000000)
4713 {
4714 C.cblack[i] = O.user_cblack[i];
4715 clear_repeat = 1;
4716 }
4717
4718 if (clear_repeat)
4719 C.cblack[4] = C.cblack[5] = 0;
4720
4721 // Add common part to cblack[] early
4722 if (imgdata.idata.filters > 1000 && (C.cblack[4] + 1) / 2 == 1 && (C.cblack[5] + 1) / 2 == 1)
4723 {
4724 int clrs[4];
4725 int lastg = -1, gcnt = 0;
4726 for (int c = 0; c < 4; c++)
4727 {
4728 clrs[c] = FC(c / 2, c % 2);
4729 if (clrs[c] == 1)
4730 {
4731 gcnt++;
4732 lastg = c;
4733 }
4734 }
4735 if (gcnt > 1 && lastg >= 0)
4736 clrs[lastg] = 3;
4737 for (int c = 0; c < 4; c++)
4738 C.cblack[clrs[c]] += C.cblack[6 + c / 2 % C.cblack[4] * C.cblack[5] + c % 2 % C.cblack[5]];
4739 C.cblack[4] = C.cblack[5] = 0;
4740 // imgdata.idata.filters = sfilters;
4741 }
4742 else if (imgdata.idata.filters <= 1000 && C.cblack[4] == 1 && C.cblack[5] == 1) // Fuji RAF dng
4743 {
4744 for (int c = 0; c < 4; c++)
4745 C.cblack[c] += C.cblack[6];
4746 C.cblack[4] = C.cblack[5] = 0;
4747 }
4748 // remove common part from C.cblack[]
4749 int i = C.cblack[3];
4750 int c;
4751 for (c = 0; c < 3; c++)
4752 if (i > C.cblack[c])
4753 i = C.cblack[c];
4754
4755 for (c = 0; c < 4; c++)
4756 C.cblack[c] -= i; // remove common part
4757 C.black += i;
4758
4759 // Now calculate common part for cblack[6+] part and move it to C.black
4760
4761 if (C.cblack[4] && C.cblack[5])
4762 {
4763 i = C.cblack[6];
4764 for (c = 1; c < C.cblack[4] * C.cblack[5]; c++)
4765 if (i > C.cblack[6 + c])
4766 i = C.cblack[6 + c];
4767 // Remove i from cblack[6+]
4768 int nonz = 0;
4769 for (c = 0; c < C.cblack[4] * C.cblack[5]; c++)
4770 {
4771 C.cblack[6 + c] -= i;
4772 if (C.cblack[6 + c])
4773 nonz++;
4774 }
4775 C.black += i;
4776 if (!nonz)
4777 C.cblack[4] = C.cblack[5] = 0;
4778 }
4779 for (c = 0; c < 4; c++)
4780 C.cblack[c] += C.black;
4781 }
4782
dcraw_process(void)4783 int LibRaw::dcraw_process(void)
4784 {
4785 int quality, i;
4786
4787 int iterations = -1, dcb_enhance = 1, noiserd = 0;
4788 float preser = 0;
4789 float expos = 1.0;
4790
4791 CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
4792 // CHECK_ORDER_HIGH(LIBRAW_PROGRESS_PRE_INTERPOLATE);
4793
4794 try
4795 {
4796
4797 int no_crop = 1;
4798
4799 if (~O.cropbox[2] && ~O.cropbox[3])
4800 no_crop = 0;
4801
4802 libraw_decoder_info_t di;
4803 get_decoder_info(&di);
4804
4805 bool is_bayer = (imgdata.idata.filters || P1.colors == 1);
4806 int subtract_inline = !O.bad_pixels && !O.dark_frame && is_bayer && !IO.zero_is_bad;
4807
4808 raw2image_ex(subtract_inline); // allocate imgdata.image and copy data!
4809
4810 // Adjust sizes
4811
4812 int save_4color = O.four_color_rgb;
4813
4814 if (IO.zero_is_bad)
4815 {
4816 remove_zeroes();
4817 SET_PROC_FLAG(LIBRAW_PROGRESS_REMOVE_ZEROES);
4818 }
4819
4820 if (O.bad_pixels && no_crop)
4821 {
4822 bad_pixels(O.bad_pixels);
4823 SET_PROC_FLAG(LIBRAW_PROGRESS_BAD_PIXELS);
4824 }
4825
4826 if (O.dark_frame && no_crop)
4827 {
4828 subtract(O.dark_frame);
4829 SET_PROC_FLAG(LIBRAW_PROGRESS_DARK_FRAME);
4830 }
4831 /* pre subtract black callback: check for it above to disable subtract inline */
4832
4833 if(callbacks.pre_subtractblack_cb)
4834 (callbacks.pre_subtractblack_cb)(this);
4835
4836 quality = 2 + !IO.fuji_width;
4837
4838 if (O.user_qual >= 0)
4839 quality = O.user_qual;
4840
4841 if (!subtract_inline || !C.data_maximum)
4842 {
4843 adjust_bl();
4844 subtract_black_internal();
4845 }
4846
4847 if (!(di.decoder_flags & LIBRAW_DECODER_FIXEDMAXC))
4848 adjust_maximum();
4849
4850 if (O.user_sat > 0)
4851 C.maximum = O.user_sat;
4852
4853 if (P1.is_foveon)
4854 {
4855 if (load_raw == &LibRaw::x3f_load_raw)
4856 {
4857 // Filter out zeroes
4858 for (int i = 0; i < S.height * S.width * 4; i++)
4859 if ((short)imgdata.image[0][i] < 0)
4860 imgdata.image[0][i] = 0;
4861 }
4862 SET_PROC_FLAG(LIBRAW_PROGRESS_FOVEON_INTERPOLATE);
4863 }
4864
4865 if (O.green_matching && !O.half_size)
4866 {
4867 green_matching();
4868 }
4869
4870 if(callbacks.pre_scalecolors_cb)
4871 (callbacks.pre_scalecolors_cb)(this);
4872
4873 if (!O.no_auto_scale)
4874 {
4875 scale_colors();
4876 SET_PROC_FLAG(LIBRAW_PROGRESS_SCALE_COLORS);
4877 }
4878
4879 if(callbacks.pre_preinterpolate_cb)
4880 (callbacks.pre_preinterpolate_cb)(this);
4881
4882 pre_interpolate();
4883
4884 SET_PROC_FLAG(LIBRAW_PROGRESS_PRE_INTERPOLATE);
4885
4886 if (O.dcb_iterations >= 0)
4887 iterations = O.dcb_iterations;
4888 if (O.dcb_enhance_fl >= 0)
4889 dcb_enhance = O.dcb_enhance_fl;
4890 if (O.fbdd_noiserd >= 0)
4891 noiserd = O.fbdd_noiserd;
4892
4893 /* pre-exposure correction callback */
4894
4895 if (O.exp_correc > 0)
4896 {
4897 expos = O.exp_shift;
4898 preser = O.exp_preser;
4899 exp_bef(expos, preser);
4900 }
4901
4902 if(callbacks.pre_interpolate_cb)
4903 (callbacks.pre_interpolate_cb)(this);
4904
4905 /* post-exposure correction fallback */
4906 if (P1.filters && !O.no_interpolation)
4907 {
4908 if (noiserd > 0 && P1.colors == 3 && P1.filters)
4909 fbdd(noiserd);
4910
4911 if (P1.filters > 1000 && callbacks.interpolate_bayer_cb)
4912 (callbacks.interpolate_bayer_cb)(this);
4913 else if (P1.filters == 9 && callbacks.interpolate_xtrans_cb)
4914 (callbacks.interpolate_xtrans_cb)(this);
4915 else if (quality == 0)
4916 lin_interpolate();
4917 else if (quality == 1 || P1.colors > 3)
4918 vng_interpolate();
4919 else if (quality == 2 && P1.filters > 1000)
4920 ppg_interpolate();
4921 else if (P1.filters == LIBRAW_XTRANS)
4922 {
4923 // Fuji X-Trans
4924 xtrans_interpolate(quality > 2 ? 3 : 1);
4925 }
4926 else if (quality == 3)
4927 ahd_interpolate(); // really don't need it here due to fallback op
4928 else if (quality == 4)
4929 dcb(iterations, dcb_enhance);
4930
4931 else if (quality == 11)
4932 dht_interpolate();
4933 else if (quality == 12)
4934 aahd_interpolate();
4935 // fallback to AHD
4936 else
4937 {
4938 ahd_interpolate();
4939 imgdata.process_warnings |= LIBRAW_WARN_FALLBACK_TO_AHD;
4940 }
4941
4942 SET_PROC_FLAG(LIBRAW_PROGRESS_INTERPOLATE);
4943 }
4944 if (IO.mix_green)
4945 {
4946 for (P1.colors = 3, i = 0; i < S.height * S.width; i++)
4947 imgdata.image[i][1] = (imgdata.image[i][1] + imgdata.image[i][3]) >> 1;
4948 SET_PROC_FLAG(LIBRAW_PROGRESS_MIX_GREEN);
4949 }
4950
4951 if(callbacks.post_interpolate_cb)
4952 (callbacks.post_interpolate_cb)(this);
4953 else if (!P1.is_foveon && P1.colors == 3 && O.med_passes > 0)
4954 {
4955 median_filter();
4956 SET_PROC_FLAG(LIBRAW_PROGRESS_MEDIAN_FILTER);
4957 }
4958
4959 if (O.highlight == 2)
4960 {
4961 blend_highlights();
4962 SET_PROC_FLAG(LIBRAW_PROGRESS_HIGHLIGHTS);
4963 }
4964
4965 if (O.highlight > 2)
4966 {
4967 recover_highlights();
4968 SET_PROC_FLAG(LIBRAW_PROGRESS_HIGHLIGHTS);
4969 }
4970
4971 if (O.use_fuji_rotate)
4972 {
4973 fuji_rotate();
4974 SET_PROC_FLAG(LIBRAW_PROGRESS_FUJI_ROTATE);
4975 }
4976
4977 if (!libraw_internal_data.output_data.histogram)
4978 {
4979 libraw_internal_data.output_data.histogram =
4980 (int(*)[LIBRAW_HISTOGRAM_SIZE])malloc(sizeof(*libraw_internal_data.output_data.histogram) * 4);
4981 merror(libraw_internal_data.output_data.histogram, "LibRaw::dcraw_process()");
4982 }
4983 #ifndef NO_LCMS
4984 if (O.camera_profile)
4985 {
4986 apply_profile(O.camera_profile, O.output_profile);
4987 SET_PROC_FLAG(LIBRAW_PROGRESS_APPLY_PROFILE);
4988 }
4989 #endif
4990
4991 if(callbacks.pre_converttorgb_cb)
4992 (callbacks.pre_converttorgb_cb)(this);
4993
4994 convert_to_rgb();
4995 SET_PROC_FLAG(LIBRAW_PROGRESS_CONVERT_RGB);
4996
4997 if(callbacks.post_converttorgb_cb)
4998 (callbacks.post_converttorgb_cb)(this);
4999
5000 if (O.use_fuji_rotate)
5001 {
5002 stretch();
5003 SET_PROC_FLAG(LIBRAW_PROGRESS_STRETCH);
5004 }
5005 O.four_color_rgb = save_4color; // also, restore
5006
5007 return 0;
5008 }
5009 catch (LibRaw_exceptions err)
5010 {
5011 EXCEPTION_HANDLER(err);
5012 }
5013 }
5014
5015 // clang-format off
5016 // Supported cameras:
5017 static const char *static_camera_list[] = {
5018 "Adobe Digital Negative (DNG)",
5019 "AgfaPhoto DC-833m",
5020 "Alcatel 5035D",
5021 "Apple iPad Pro",
5022 "Apple iPhone SE",
5023 "Apple iPhone 6s",
5024 "Apple iPhone 6 plus",
5025 "Apple iPhone 7",
5026 "Apple iPhone 7 plus",
5027 "Apple iPhone 8",
5028 "Apple iPhone 8 plus",
5029 "Apple iPhone X",
5030 "Apple QuickTake 100",
5031 "Apple QuickTake 150",
5032 "Apple QuickTake 200",
5033 "ARRIRAW format",
5034 "AVT F-080C",
5035 "AVT F-145C",
5036 "AVT F-201C",
5037 "AVT F-510C",
5038 "AVT F-810C",
5039 "Baumer TXG14",
5040 "BlackMagic Cinema Camera",
5041 "BlackMagic Micro Cinema Camera",
5042 "BlackMagic Pocket Cinema Camera",
5043 "BlackMagic Production Camera 4k",
5044 "BlackMagic URSA",
5045 "BlackMagic URSA Mini 4k",
5046 "BlackMagic URSA Mini 4.6k",
5047 "BlackMagic URSA Mini Pro 4.6k",
5048 "Canon PowerShot 600",
5049 "Canon PowerShot A5",
5050 "Canon PowerShot A5 Zoom",
5051 "Canon PowerShot A50",
5052 "Canon PowerShot A410 (CHDK hack)",
5053 "Canon PowerShot A460 (CHDK hack)",
5054 "Canon PowerShot A470 (CHDK hack)",
5055 "Canon PowerShot A530 (CHDK hack)",
5056 "Canon PowerShot A540 (CHDK hack)",
5057 "Canon PowerShot A550 (CHDK hack)",
5058 "Canon PowerShot A570 (CHDK hack)",
5059 "Canon PowerShot A590 (CHDK hack)",
5060 "Canon PowerShot A610 (CHDK hack)",
5061 "Canon PowerShot A620 (CHDK hack)",
5062 "Canon PowerShot A630 (CHDK hack)",
5063 "Canon PowerShot A640 (CHDK hack)",
5064 "Canon PowerShot A650 (CHDK hack)",
5065 "Canon PowerShot A710 IS (CHDK hack)",
5066 "Canon PowerShot A720 IS (CHDK hack)",
5067 "Canon PowerShot A3300 IS (CHDK hack)",
5068 "Canon PowerShot D10 (CHDK hack)",
5069 "Canon PowerShot ELPH 130 IS (CHDK hack)",
5070 "Canon PowerShot ELPH 160 IS (CHDK hack)",
5071 "Canon PowerShot Pro70",
5072 "Canon PowerShot Pro90 IS",
5073 "Canon PowerShot Pro1",
5074 "Canon PowerShot G1",
5075 "Canon PowerShot G1 X",
5076 "Canon PowerShot G1 X Mark II",
5077 "Canon PowerShot G1 X Mark III",
5078 "Canon PowerShot G2",
5079 "Canon PowerShot G3",
5080 "Canon PowerShot G3 X",
5081 "Canon PowerShot G5",
5082 "Canon PowerShot G5 X",
5083 "Canon PowerShot G6",
5084 "Canon PowerShot G7 (CHDK hack)",
5085 "Canon PowerShot G7 X",
5086 "Canon PowerShot G7 X Mark II",
5087 "Canon PowerShot G9",
5088 "Canon PowerShot G9 X",
5089 "Canon PowerShot G9 X Mark II",
5090 "Canon PowerShot G10",
5091 "Canon PowerShot G11",
5092 "Canon PowerShot G12",
5093 "Canon PowerShot G15",
5094 "Canon PowerShot G16",
5095 "Canon PowerShot S2 IS (CHDK hack)",
5096 "Canon PowerShot S3 IS (CHDK hack)",
5097 "Canon PowerShot S5 IS (CHDK hack)",
5098 "Canon PowerShot SD300 (CHDK hack)",
5099 "Canon PowerShot SD750 (CHDK hack)",
5100 "Canon PowerShot SD950 (CHDK hack)",
5101 "Canon PowerShot S30",
5102 "Canon PowerShot S40",
5103 "Canon PowerShot S45",
5104 "Canon PowerShot S50",
5105 "Canon PowerShot S60",
5106 "Canon PowerShot S70",
5107 "Canon PowerShot S90",
5108 "Canon PowerShot S95",
5109 "Canon PowerShot S100",
5110 "Canon PowerShot S110",
5111 "Canon PowerShot S120",
5112 "Canon PowerShot SX1 IS",
5113 "Canon PowerShot SX50 HS",
5114 "Canon PowerShot SX60 HS",
5115 "Canon PowerShot SX100 IS (CHDK hack)",
5116 "Canon PowerShot SX110 IS (CHDK hack)",
5117 "Canon PowerShot SX120 IS (CHDK hack)",
5118 "Canon PowerShot SX130 IS (CHDK hack)",
5119 "Canon PowerShot SX160 IS (CHDK hack)",
5120 "Canon PowerShot SX220 HS (CHDK hack)",
5121 "Canon PowerShot SX510 HS (CHDK hack)",
5122 "Canon PowerShot SX10 IS (CHDK hack)",
5123 "Canon PowerShot SX20 IS (CHDK hack)",
5124 "Canon PowerShot SX30 IS (CHDK hack)",
5125 "Canon PowerShot IXUS 160 (CHDK hack)",
5126 "Canon PowerShot IXUS 900Ti (CHDK hack)",
5127 "Canon EOS D30",
5128 "Canon EOS D60",
5129 "Canon EOS 5D",
5130 "Canon EOS 5DS",
5131 "Canon EOS 5DS R",
5132 "Canon EOS 5D Mark II",
5133 "Canon EOS 5D Mark III",
5134 "Canon EOS 5D Mark IV",
5135 "Canon EOS 6D",
5136 "Canon EOS 6D Mark II",
5137 "Canon EOS 7D",
5138 "Canon EOS 7D Mark II",
5139 "Canon EOS 10D",
5140 "Canon EOS 20D",
5141 "Canon EOS 20Da",
5142 "Canon EOS 30D",
5143 "Canon EOS 40D",
5144 "Canon EOS 50D",
5145 "Canon EOS 60D",
5146 "Canon EOS 60Da",
5147 "Canon EOS 70D",
5148 "Canon EOS 77D",
5149 "Canon EOS 80D",
5150 "Canon EOS 200D",
5151 "Canon EOS 300D / Digital Rebel / Kiss Digital",
5152 "Canon EOS 350D / Digital Rebel XT / Kiss Digital N",
5153 "Canon EOS 400D / Digital Rebel XTi / Kiss Digital X",
5154 "Canon EOS 450D / Digital Rebel XSi / Kiss Digital X2",
5155 "Canon EOS 500D / Digital Rebel T1i / Kiss Digital X3",
5156 "Canon EOS 550D / Digital Rebel T2i / Kiss Digital X4",
5157 "Canon EOS 600D / Digital Rebel T3i / Kiss Digital X5",
5158 "Canon EOS 650D / Digital Rebel T4i / Kiss Digital X6i",
5159 "Canon EOS 700D / Digital Rebel T5i",
5160 "Canon EOS 750D / Digital Rebel T6i",
5161 "Canon EOS 760D / Digital Rebel T6S",
5162 "Canon EOS 800D",
5163 "Canon EOS 100D / Digital Rebel SL1",
5164 "Canon EOS 1000D / Digital Rebel XS / Kiss Digital F",
5165 "Canon EOS 1100D / Digital Rebel T3 / Kiss Digital X50",
5166 "Canon EOS 1200D",
5167 "Canon EOS 1300D",
5168 "Canon EOS C500",
5169 "Canon EOS D2000C",
5170 "Canon EOS M",
5171 "Canon EOS M2",
5172 "Canon EOS M3",
5173 "Canon EOS M5",
5174 "Canon EOS M6",
5175 "Canon EOS M10",
5176 "Canon EOS M100",
5177 "Canon EOS-1D",
5178 "Canon EOS-1DS",
5179 "Canon EOS-1D C",
5180 "Canon EOS-1D X",
5181 "Canon EOS-1D Mark II",
5182 "Canon EOS-1D Mark II N",
5183 "Canon EOS-1D Mark III",
5184 "Canon EOS-1D Mark IV",
5185 "Canon EOS-1Ds Mark II",
5186 "Canon EOS-1Ds Mark III",
5187 "Canon EOS-1D X Mark II",
5188 "Casio QV-2000UX",
5189 "Casio QV-3000EX",
5190 "Casio QV-3500EX",
5191 "Casio QV-4000",
5192 "Casio QV-5700",
5193 "Casio QV-R41",
5194 "Casio QV-R51",
5195 "Casio QV-R61",
5196 "Casio EX-F1",
5197 "Casio EX-FC300S",
5198 "Casio EX-FC400S",
5199 "Casio EX-FH20",
5200 "Casio EX-FH25",
5201 "Casio EX-FH100",
5202 "Casio EX-P600",
5203 "Casio EX-S20",
5204 "Casio EX-S100",
5205 "Casio EX-Z4",
5206 "Casio EX-Z50",
5207 "Casio EX-Z500",
5208 "Casio EX-Z55",
5209 "Casio EX-Z60",
5210 "Casio EX-Z75",
5211 "Casio EX-Z750",
5212 "Casio EX-Z8",
5213 "Casio EX-Z850",
5214 "Casio EX-Z1050",
5215 "Casio EX-ZR100",
5216 "Casio EX-Z1080",
5217 "Casio EX-ZR700",
5218 "Casio EX-ZR710",
5219 "Casio EX-ZR750",
5220 "Casio EX-ZR800",
5221 "Casio EX-ZR850",
5222 "Casio EX-ZR1000",
5223 "Casio EX-ZR1100",
5224 "Casio EX-ZR1200",
5225 "Casio EX-ZR1300",
5226 "Casio EX-ZR1500",
5227 "Casio EX-ZR3000",
5228 "Casio EX-ZR4000/5000",
5229 "Casio EX-ZR4100/5100",
5230 "Casio EX-100",
5231 "Casio EX-100F",
5232 "Casio EX-10",
5233 "Casio Exlim Pro 505",
5234 "Casio Exlim Pro 600",
5235 "Casio Exlim Pro 700",
5236 "Contax N Digital",
5237 "Creative PC-CAM 600",
5238 "Digital Bolex D16",
5239 "Digital Bolex D16M",
5240 "DJI 4384x3288",
5241 "DJI Phantom4 Pro/Pro+",
5242 "DJI Zenmuse X5",
5243 "DJI Zenmuse X5R",
5244 "DXO One",
5245 "Epson R-D1",
5246 "Epson R-D1s",
5247 "Epson R-D1x",
5248 "Foculus 531C",
5249 "FujiFilm E505",
5250 "FujiFilm E550",
5251 "FujiFilm E900",
5252 "FujiFilm F700",
5253 "FujiFilm F710",
5254 "FujiFilm F800",
5255 "FujiFilm F810",
5256 "FujiFilm S2Pro",
5257 "FujiFilm S3Pro",
5258 "FujiFilm S5Pro",
5259 "FujiFilm S20Pro",
5260 "FujiFilm S1",
5261 "FujiFilm S100FS",
5262 "FujiFilm S5000",
5263 "FujiFilm S5100/S5500",
5264 "FujiFilm S5200/S5600",
5265 "FujiFilm S6000fd",
5266 "FujiFilm S6500fd",
5267 "FujiFilm S7000",
5268 "FujiFilm S9000/S9500",
5269 "FujiFilm S9100/S9600",
5270 "FujiFilm S200EXR",
5271 "FujiFilm S205EXR",
5272 "FujiFilm SL1000",
5273 "FujiFilm HS10/HS11",
5274 "FujiFilm HS20EXR",
5275 "FujiFilm HS22EXR",
5276 "FujiFilm HS30EXR",
5277 "FujiFilm HS33EXR",
5278 "FujiFilm HS35EXR",
5279 "FujiFilm HS50EXR",
5280 "FujiFilm F505EXR",
5281 "FujiFilm F550EXR",
5282 "FujiFilm F600EXR",
5283 "FujiFilm F605EXR",
5284 "FujiFilm F770EXR",
5285 "FujiFilm F775EXR",
5286 "FujiFilm F800EXR",
5287 "FujiFilm F900EXR",
5288 "FujiFilm GFX 50S",
5289 "FujiFilm X-Pro1",
5290 "FujiFilm X-Pro2",
5291 "FujiFilm X-S1",
5292 "FujiFilm XQ1",
5293 "FujiFilm XQ2",
5294 "FujiFilm X100",
5295 "FujiFilm X100f",
5296 "FujiFilm X100S",
5297 "FujiFilm X100T",
5298 "FujiFilm X10",
5299 "FujiFilm X20",
5300 "FujiFilm X30",
5301 "FujiFilm X70",
5302 "FujiFilm X-A1",
5303 "FujiFilm X-A2",
5304 "FujiFilm X-A3",
5305 "FujiFilm X-A5",
5306 "FujiFilm X-A10",
5307 "FujiFilm X-A20",
5308 "FujiFilm X-E1",
5309 "FujiFilm X-E2",
5310 "FujiFilm X-E2S",
5311 "FujiFilm X-E3",
5312 "FujiFilm X-M1",
5313 "FujiFilm XF1",
5314 "FujiFilm X-H1",
5315 "FujiFilm X-T1",
5316 "FujiFilm X-T1 Graphite Silver",
5317 "FujiFilm X-T2",
5318 "FujiFilm X-T10",
5319 "FujiFilm X-T20",
5320 "FujiFilm IS-1",
5321 "Gione E7",
5322 "GITUP GIT2",
5323 "GITUP GIT2P",
5324 "Google Pixel",
5325 "Google Pixel XL",
5326 "Hasselblad H2D-22",
5327 "Hasselblad H2D-39",
5328 "Hasselblad H3DII-22",
5329 "Hasselblad H3DII-31",
5330 "Hasselblad H3DII-39",
5331 "Hasselblad H3DII-50",
5332 "Hasselblad H3D-22",
5333 "Hasselblad H3D-31",
5334 "Hasselblad H3D-39",
5335 "Hasselblad H4D-60",
5336 "Hasselblad H4D-50",
5337 "Hasselblad H4D-40",
5338 "Hasselblad H4D-31",
5339 "Hasselblad H5D-60",
5340 "Hasselblad H5D-50",
5341 "Hasselblad H5D-50c",
5342 "Hasselblad H5D-40",
5343 "Hasselblad H6D-100c",
5344 "Hasselblad A6D-100c", // Aerial camera
5345 "Hasselblad CFV",
5346 "Hasselblad CFV-50",
5347 "Hasselblad CFH",
5348 "Hasselblad CF-22",
5349 "Hasselblad CF-31",
5350 "Hasselblad CF-39",
5351 "Hasselblad V96C",
5352 "Hasselblad Lusso",
5353 "Hasselblad Lunar",
5354 "Hasselblad True Zoom",
5355 "Hasselblad Stellar",
5356 "Hasselblad Stellar II",
5357 "Hasselblad HV",
5358 "Hasselblad X1D",
5359 "HTC UltraPixel",
5360 "HTC MyTouch 4G",
5361 "HTC One (A9)",
5362 "HTC One (M9)",
5363 "HTC 10",
5364 "Huawei P9 (EVA-L09/AL00)",
5365 "Huawei Honor6a",
5366 "Huawei Honor9",
5367 "Huawei Mate10 (BLA-L29)",
5368 "Imacon Ixpress 96, 96C",
5369 "Imacon Ixpress 384, 384C (single shot only)",
5370 "Imacon Ixpress 132C",
5371 "Imacon Ixpress 528C (single shot only)",
5372 "ISG 2020x1520",
5373 "Ikonoskop A-Cam dII Panchromatic",
5374 "Ikonoskop A-Cam dII",
5375 "Kinefinity KineMINI",
5376 "Kinefinity KineRAW Mini",
5377 "Kinefinity KineRAW S35",
5378 "Kodak DC20",
5379 "Kodak DC25",
5380 "Kodak DC40",
5381 "Kodak DC50",
5382 "Kodak DC120",
5383 "Kodak DCS200",
5384 "Kodak DCS315C",
5385 "Kodak DCS330C",
5386 "Kodak DCS420",
5387 "Kodak DCS460",
5388 "Kodak DCS460A",
5389 "Kodak DCS460D",
5390 "Kodak DCS520C",
5391 "Kodak DCS560C",
5392 "Kodak DCS620C",
5393 "Kodak DCS620X",
5394 "Kodak DCS660C",
5395 "Kodak DCS660M",
5396 "Kodak DCS720X",
5397 "Kodak DCS760C",
5398 "Kodak DCS760M",
5399 "Kodak EOSDCS1",
5400 "Kodak EOSDCS3B",
5401 "Kodak NC2000F",
5402 "Kodak ProBack",
5403 "Kodak PB645C",
5404 "Kodak PB645H",
5405 "Kodak PB645M",
5406 "Kodak DCS Pro 14n",
5407 "Kodak DCS Pro 14nx",
5408 "Kodak DCS Pro SLR/c",
5409 "Kodak DCS Pro SLR/n",
5410 "Kodak C330",
5411 "Kodak C603",
5412 "Kodak P850",
5413 "Kodak P880",
5414 "Kodak S-1",
5415 "Kodak Z980",
5416 "Kodak Z981",
5417 "Kodak Z990",
5418 "Kodak Z1015",
5419 "Kodak KAI-0340",
5420 "Konica KD-400Z",
5421 "Konica KD-510Z",
5422 "Leaf AFi 5",
5423 "Leaf AFi 6",
5424 "Leaf AFi 7",
5425 "Leaf AFi-II 6",
5426 "Leaf AFi-II 7",
5427 "Leaf AFi-II 10",
5428 "Leaf AFi-II 10R",
5429 "Leaf Aptus-II 5",
5430 "Leaf Aptus-II 6",
5431 "Leaf Aptus-II 7",
5432 "Leaf Aptus-II 8",
5433 "Leaf Aptus-II 10",
5434 "Leaf Aptus-II 12",
5435 "Leaf Aptus-II 12R",
5436 "Leaf Aptus 17",
5437 "Leaf Aptus 22",
5438 "Leaf Aptus 54S",
5439 "Leaf Aptus 65",
5440 "Leaf Aptus 65S",
5441 "Leaf Aptus 75",
5442 "Leaf Aptus 75S",
5443 "Leaf Cantare",
5444 "Leaf Cantare XY",
5445 "Leaf CatchLight",
5446 "Leaf CMost",
5447 "Leaf Credo 40",
5448 "Leaf Credo 50",
5449 "Leaf Credo 60",
5450 "Leaf Credo 80 (low compression mode only)",
5451 "Leaf DCB-II",
5452 "Leaf Valeo 6",
5453 "Leaf Valeo 11",
5454 "Leaf Valeo 17",
5455 "Leaf Valeo 17wi",
5456 "Leaf Valeo 22",
5457 "Leaf Valeo 22wi",
5458 "Leaf Volare",
5459 "Lenovo a820",
5460 "Leica C (Typ 112)",
5461 "Leica CL",
5462 "Leica Digilux 2",
5463 "Leica Digilux 3",
5464 "Leica Digital-Modul-R",
5465 "Leica D-LUX2",
5466 "Leica D-LUX3",
5467 "Leica D-LUX4",
5468 "Leica D-LUX5",
5469 "Leica D-LUX6",
5470 "Leica D-Lux (Typ 109)",
5471 "Leica M8",
5472 "Leica M8.2",
5473 "Leica M9",
5474 "Leica M10",
5475 "Leica M (Typ 240)",
5476 "Leica M (Typ 262)",
5477 "Leica Monochrom (Typ 240)",
5478 "Leica Monochrom (Typ 246)",
5479 "Leica M-D (Typ 262)",
5480 "Leica M-E",
5481 "Leica M-P",
5482 "Leica R8",
5483 "Leica Q (Typ 116)",
5484 "Leica S",
5485 "Leica S2",
5486 "Leica S (Typ 007)",
5487 "Leica SL (Typ 601)",
5488 "Leica T (Typ 701)",
5489 "Leica TL",
5490 "Leica TL2",
5491 "Leica X1",
5492 "Leica X (Typ 113)",
5493 "Leica X2",
5494 "Leica X-E (Typ 102)",
5495 "Leica X-U (Typ 113)",
5496 "Leica V-LUX1",
5497 "Leica V-LUX2",
5498 "Leica V-LUX3",
5499 "Leica V-LUX4",
5500 "Leica V-Lux (Typ 114)",
5501 "Leica X VARIO (Typ 107)",
5502 "LG G3",
5503 "LG G4",
5504 "LG V20 (F800K)",
5505 "LG VS995",
5506 "Logitech Fotoman Pixtura",
5507 "Mamiya ZD",
5508 "Matrix 4608x3288",
5509 "Meizy MX4",
5510 "Micron 2010",
5511 "Minolta RD175",
5512 "Minolta DiMAGE 5",
5513 "Minolta DiMAGE 7",
5514 "Minolta DiMAGE 7i",
5515 "Minolta DiMAGE 7Hi",
5516 "Minolta DiMAGE A1",
5517 "Minolta DiMAGE A2",
5518 "Minolta DiMAGE A200",
5519 "Minolta DiMAGE G400",
5520 "Minolta DiMAGE G500",
5521 "Minolta DiMAGE G530",
5522 "Minolta DiMAGE G600",
5523 "Minolta DiMAGE Z2",
5524 "Minolta Alpha/Dynax/Maxxum 5D",
5525 "Minolta Alpha/Dynax/Maxxum 7D",
5526 "Motorola PIXL",
5527 "Nikon D1",
5528 "Nikon D1H",
5529 "Nikon D1X",
5530 "Nikon D2H",
5531 "Nikon D2Hs",
5532 "Nikon D2X",
5533 "Nikon D2Xs",
5534 "Nikon D3",
5535 "Nikon D3s",
5536 "Nikon D3X",
5537 "Nikon D4",
5538 "Nikon D4s",
5539 "Nikon D40",
5540 "Nikon D40X",
5541 "Nikon D5",
5542 "Nikon D50",
5543 "Nikon D60",
5544 "Nikon D70",
5545 "Nikon D70s",
5546 "Nikon D80",
5547 "Nikon D90",
5548 "Nikon D100",
5549 "Nikon D200",
5550 "Nikon D300",
5551 "Nikon D300s",
5552 "Nikon D500",
5553 "Nikon D600",
5554 "Nikon D610",
5555 "Nikon D700",
5556 "Nikon D750",
5557 "Nikon D800",
5558 "Nikon D800E",
5559 "Nikon D810",
5560 "Nikon D810A",
5561 "Nikon D850",
5562 "Nikon D3000",
5563 "Nikon D3100",
5564 "Nikon D3200",
5565 "Nikon D3300",
5566 "Nikon D3400",
5567 "Nikon D5000",
5568 "Nikon D5100",
5569 "Nikon D5200",
5570 "Nikon D5300",
5571 "Nikon D5500",
5572 "Nikon D5600",
5573 "Nikon D7000",
5574 "Nikon D7100",
5575 "Nikon D7200",
5576 "Nikon D7500",
5577 "Nikon Df",
5578 "Nikon 1 AW1",
5579 "Nikon 1 J1",
5580 "Nikon 1 J2",
5581 "Nikon 1 J3",
5582 "Nikon 1 J4",
5583 "Nikon 1 J5",
5584 "Nikon 1 S1",
5585 "Nikon 1 S2",
5586 "Nikon 1 V1",
5587 "Nikon 1 V2",
5588 "Nikon 1 V3",
5589 "Nikon E700 (\"DIAG RAW\" hack)",
5590 "Nikon E800 (\"DIAG RAW\" hack)",
5591 "Nikon E880 (\"DIAG RAW\" hack)",
5592 "Nikon E900 (\"DIAG RAW\" hack)",
5593 "Nikon E950 (\"DIAG RAW\" hack)",
5594 "Nikon E990 (\"DIAG RAW\" hack)",
5595 "Nikon E995 (\"DIAG RAW\" hack)",
5596 "Nikon E2100 (\"DIAG RAW\" hack)",
5597 "Nikon E2500 (\"DIAG RAW\" hack)",
5598 "Nikon E3200 (\"DIAG RAW\" hack)",
5599 "Nikon E3700 (\"DIAG RAW\" hack)",
5600 "Nikon E4300 (\"DIAG RAW\" hack)",
5601 "Nikon E4500 (\"DIAG RAW\" hack)",
5602 "Nikon E5000",
5603 "Nikon E5400",
5604 "Nikon E5700",
5605 "Nikon E8400",
5606 "Nikon E8700",
5607 "Nikon E8800",
5608 "Nikon Coolpix A",
5609 "Nikon Coolpix B700",
5610 "Nikon Coolpix P330",
5611 "Nikon Coolpix P340",
5612 "Nikon Coolpix P6000",
5613 "Nikon Coolpix P7000",
5614 "Nikon Coolpix P7100",
5615 "Nikon Coolpix P7700",
5616 "Nikon Coolpix P7800",
5617 "Nikon Coolpix S6 (\"DIAG RAW\" hack)",
5618 "Nikon Coolscan NEF",
5619 "Nokia N95",
5620 "Nokia X2",
5621 "Nokia 1200x1600",
5622 "Nokia Lumia 950 XL",
5623 "Nokia Lumia 1020",
5624 "Nokia Lumia 1520",
5625 "Olympus AIR A01",
5626 "Olympus C3030Z",
5627 "Olympus C5050Z",
5628 "Olympus C5060Z",
5629 "Olympus C7070WZ",
5630 "Olympus C70Z,C7000Z",
5631 "Olympus C740UZ",
5632 "Olympus C770UZ",
5633 "Olympus C8080WZ",
5634 "Olympus X200,D560Z,C350Z",
5635 "Olympus E-1",
5636 "Olympus E-3",
5637 "Olympus E-5",
5638 "Olympus E-10",
5639 "Olympus E-20",
5640 "Olympus E-30",
5641 "Olympus E-300",
5642 "Olympus E-330",
5643 "Olympus E-400",
5644 "Olympus E-410",
5645 "Olympus E-420",
5646 "Olympus E-450",
5647 "Olympus E-500",
5648 "Olympus E-510",
5649 "Olympus E-520",
5650 "Olympus E-600",
5651 "Olympus E-620",
5652 "Olympus E-P1",
5653 "Olympus E-P2",
5654 "Olympus E-P3",
5655 "Olympus E-P5",
5656 "Olympus E-PL1",
5657 "Olympus E-PL1s",
5658 "Olympus E-PL2",
5659 "Olympus E-PL3",
5660 "Olympus E-PL5",
5661 "Olympus E-PL6",
5662 "Olympus E-PL7",
5663 "Olympus E-PL8",
5664 "Olympus E-PL9",
5665 "Olympus E-PM1",
5666 "Olympus E-PM2",
5667 "Olympus E-M1",
5668 "Olympus E-M1 Mark II",
5669 "Olympus E-M10",
5670 "Olympus E-M10 Mark II",
5671 "Olympus E-M10 Mark III",
5672 "Olympus E-M5",
5673 "Olympus E-M5 Mark II",
5674 "Olympus Pen F",
5675 "Olympus SP310",
5676 "Olympus SP320",
5677 "Olympus SP350",
5678 "Olympus SP500UZ",
5679 "Olympus SP510UZ",
5680 "Olympus SP550UZ",
5681 "Olympus SP560UZ",
5682 "Olympus SP565UZ",
5683 "Olympus SP570UZ",
5684 "Olympus STYLUS1",
5685 "Olympus STYLUS1s",
5686 "Olympus SH-2",
5687 "Olympus SH-3",
5688 "Olympus TG-4",
5689 "Olympus TG-5",
5690 "Olympus XZ-1",
5691 "Olympus XZ-2",
5692 "Olympus XZ-10",
5693 "OmniVision 4688",
5694 "OmniVision OV5647",
5695 "OmniVision OV5648",
5696 "OmniVision OV8850",
5697 "OmniVision 13860",
5698 "OnePlus One",
5699 "OnePlus A3303",
5700 "OnePlus A5000",
5701 "Panasonic DMC-CM1",
5702 "Panasonic DMC-FZ8",
5703 "Panasonic DMC-FZ18",
5704 "Panasonic DMC-FZ28",
5705 "Panasonic DMC-FZ30",
5706 "Panasonic DMC-FZ35/FZ38",
5707 "Panasonic DMC-FZ40",
5708 "Panasonic DMC-FZ45",
5709 "Panasonic DMC-FZ50",
5710 "Panasonic DMC-FZ7",
5711 "Panasonic DMC-FZ70",
5712 "Panasonic DMC-FZ72",
5713 "Panasonic DC-FZ80/82",
5714 "Panasonic DMC-FZ100",
5715 "Panasonic DMC-FZ150",
5716 "Panasonic DMC-FZ200",
5717 "Panasonic DMC-FZ300/330",
5718 "Panasonic DMC-FZ1000",
5719 "Panasonic DMC-FZ2000/2500/FZH1",
5720 "Panasonic DMC-FX150",
5721 "Panasonic DMC-G1",
5722 "Panasonic DMC-G10",
5723 "Panasonic DMC-G2",
5724 "Panasonic DMC-G3",
5725 "Panasonic DMC-G5",
5726 "Panasonic DMC-G6",
5727 "Panasonic DMC-G7/G70",
5728 "Panasonic DMC-G8/80/81/85",
5729 "Panasonic DC-G9",
5730 "Panasonic DMC-GF1",
5731 "Panasonic DMC-GF2",
5732 "Panasonic DMC-GF3",
5733 "Panasonic DMC-GF5",
5734 "Panasonic DMC-GF6",
5735 "Panasonic DMC-GF7",
5736 "Panasonic DC-GF10/GF90",
5737 "Panasonic DMC-GH1",
5738 "Panasonic DMC-GH2",
5739 "Panasonic DMC-GH3",
5740 "Panasonic DMC-GH4",
5741 "Panasonic AG-GH4",
5742 "Panasonic DC-GH5",
5743 "Panasonic DC-GH5S",
5744 "Panasonic DMC-GM1",
5745 "Panasonic DMC-GM1s",
5746 "Panasonic DMC-GM5",
5747 "Panasonic DMC-GX1",
5748 "Panasonic DMC-GX7",
5749 "Panasonic DMC-GX8",
5750 "Panasonic DC-GX9",
5751 "Panasonic DMC-GX80/85",
5752 "Panasonic DC-GX800/850/GF9",
5753 "Panasonic DMC-L1",
5754 "Panasonic DMC-L10",
5755 "Panasonic DMC-LC1",
5756 "Panasonic DMC-LF1",
5757 "Panasonic DMC-LX1",
5758 "Panasonic DMC-LX2",
5759 "Panasonic DMC-LX3",
5760 "Panasonic DMC-LX5",
5761 "Panasonic DMC-LX7",
5762 "Panasonic DMC-LX9/10/15",
5763 "Panasonic DMC-LX100",
5764 "Panasonic DMC-TZ60/61/SZ40",
5765 "Panasonic DMC-TZ70/71/ZS50",
5766 "Panasonic DMC-TZ80/81/85/ZS60",
5767 "Panasonic DC-ZS70 (DC-TZ90/91/92, DC-T93)",
5768 "Panasonic DC-TZ100/101/ZS100",
5769 "Panasonic DC-TZ200/ZS200",
5770 "PARROT Bebop 2",
5771 "PARROT Bebop Drone",
5772 "Pentax *ist D",
5773 "Pentax *ist DL",
5774 "Pentax *ist DL2",
5775 "Pentax *ist DS",
5776 "Pentax *ist DS2",
5777 "Pentax GR",
5778 "Pentax K10D",
5779 "Pentax K20D",
5780 "Pentax K100D",
5781 "Pentax K100D Super",
5782 "Pentax K110D",
5783 "Pentax K200D",
5784 "Pentax K2000/K-m",
5785 "Pentax KP",
5786 "Pentax K-x",
5787 "Pentax K-r",
5788 "Pentax K-01",
5789 "Pentax K-1",
5790 "Pentax K-3",
5791 "Pentax K-3 II",
5792 "Pentax K-30",
5793 "Pentax K-5",
5794 "Pentax K-5 II",
5795 "Pentax K-5 IIs",
5796 "Pentax K-50",
5797 "Pentax K-500",
5798 "Pentax K-7",
5799 "Pentax K-70",
5800 "Pentax K-S1",
5801 "Pentax K-S2",
5802 "Pentax MX-1",
5803 "Pentax Q",
5804 "Pentax Q7",
5805 "Pentax Q10",
5806 "Pentax QS-1",
5807 "Pentax Optio S",
5808 "Pentax Optio S4",
5809 "Pentax Optio 33WR",
5810 "Pentax Optio 750Z",
5811 "Pentax 645D",
5812 "Pentax 645Z",
5813 "PhaseOne IQ140",
5814 "PhaseOne IQ150",
5815 "PhaseOne IQ160",
5816 "PhaseOne IQ180",
5817 "PhaseOne IQ180 IR",
5818 "PhaseOne IQ250",
5819 "PhaseOne IQ260",
5820 "PhaseOne IQ260 Achromatic",
5821 "PhaseOne IQ280",
5822 "PhaseOne IQ3 50MP",
5823 "PhaseOne IQ3 60MP",
5824 "PhaseOne IQ3 80MP",
5825 "PhaseOne IQ3 100MP",
5826 "PhaseOne IQ3 100MP Trichromatic",
5827 "PhaseOne LightPhase",
5828 "PhaseOne Achromatic+",
5829 "PhaseOne H 10",
5830 "PhaseOne H 20",
5831 "PhaseOne H 25",
5832 "PhaseOne P 20",
5833 "PhaseOne P 20+",
5834 "PhaseOne P 21",
5835 "PhaseOne P 25",
5836 "PhaseOne P 25+",
5837 "PhaseOne P 30",
5838 "PhaseOne P 30+",
5839 "PhaseOne P 40+",
5840 "PhaseOne P 45",
5841 "PhaseOne P 45+",
5842 "PhaseOne P 65",
5843 "PhaseOne P 65+",
5844 "Photron BC2-HD",
5845 "Pixelink A782",
5846 "Polaroid x530",
5847 "RaspberryPi Camera",
5848 "RaspberryPi Camera V2",
5849 "Ricoh GR",
5850 "Ricoh GR Digital",
5851 "Ricoh GR Digital II",
5852 "Ricoh GR Digital III",
5853 "Ricoh GR Digital IV",
5854 "Ricoh GR II",
5855 "Ricoh GX100",
5856 "Ricoh GX200",
5857 "Ricoh GXR MOUNT A12",
5858 "Ricoh GXR MOUNT A16 24-85mm F3.5-5.5",
5859 "Ricoh GXR, S10 24-72mm F2.5-4.4 VC",
5860 "Ricoh GXR, GR A12 50mm F2.5 MACRO",
5861 "Ricoh GXR, GR LENS A12 28mm F2.5",
5862 "Ricoh GXR, GXR P10",
5863 #ifndef NO_JASPER
5864 "Redcode R3D format",
5865 #endif
5866 "Rollei d530flex",
5867 "RoverShot 3320af",
5868 "Samsung EX1",
5869 "Samsung EX2F",
5870 "Samsung GX-1L",
5871 "Samsung GX-1S",
5872 "Samsung GX10",
5873 "Samsung GX20",
5874 "Samsung Galaxy Nexus",
5875 "Samsung Galaxy NX (EK-GN120)",
5876 "Samsung Galaxy S3",
5877 "Samsung Galaxy S6 (SM-G920F)",
5878 "Samsung Galaxy S7",
5879 "Samsung Galaxy S7 Edge",
5880 "Samsung Galaxy S8 (SM-G950U)",
5881 "Samsung NX1",
5882 "Samsung NX5",
5883 "Samsung NX10",
5884 "Samsung NX11",
5885 "Samsung NX100",
5886 "Samsung NX1000",
5887 "Samsung NX1100",
5888 "Samsung NX20",
5889 "Samsung NX200",
5890 "Samsung NX210",
5891 "Samsung NX2000",
5892 "Samsung NX30",
5893 "Samsung NX300",
5894 "Samsung NX300M",
5895 "Samsung NX3000",
5896 "Samsung NX500",
5897 "Samsung NX mini",
5898 "Samsung Pro815",
5899 "Samsung WB550",
5900 "Samsung WB2000",
5901 "Samsung S85 (hacked)",
5902 "Samsung S850 (hacked)",
5903 "Sarnoff 4096x5440",
5904 "Seitz 6x17",
5905 "Seitz Roundshot D3",
5906 "Seitz Roundshot D2X",
5907 "Seitz Roundshot D2Xs",
5908 "Sigma SD9 (raw decode only)",
5909 "Sigma SD10 (raw decode only)",
5910 "Sigma SD14 (raw decode only)",
5911 "Sigma SD15 (raw decode only)",
5912 "Sigma SD1",
5913 "Sigma SD1 Merill",
5914 "Sigma DP1",
5915 "Sigma DP1 Merill",
5916 "Sigma DP1S",
5917 "Sigma DP1X",
5918 "Sigma DP2",
5919 "Sigma DP2 Merill",
5920 "Sigma DP2S",
5921 "Sigma DP2X",
5922 "Sigma DP3 Merill",
5923 "Sigma dp0 Quattro",
5924 "Sigma dp1 Quattro",
5925 "Sigma dp2 Quattro",
5926 "Sigma dp3 Quattro",
5927 "Sigma sd Quattro",
5928 "Sigma sd Quattro H",
5929 "Sinar eMotion 22",
5930 "Sinar eMotion 54",
5931 "Sinar eSpirit 65",
5932 "Sinar eMotion 75",
5933 "Sinar eVolution 75",
5934 "Sinar 3072x2048",
5935 "Sinar 4080x4080",
5936 "Sinar 4080x5440",
5937 "Sinar STI format",
5938 "Sinar Sinarback 54",
5939 "SMaL Ultra-Pocket 3",
5940 "SMaL Ultra-Pocket 4",
5941 "SMaL Ultra-Pocket 5",
5942 "Sony A7",
5943 "Sony A7 II",
5944 "Sony A7R",
5945 "Sony A7R II",
5946 "Sony A7R III",
5947 "Sony A7S",
5948 "Sony A7S II",
5949 "Sony A9",
5950 "Sony ILCA-68 (A68)",
5951 "Sony ILCA-77M2 (A77-II)",
5952 "Sony ILCA-99M2 (A99-II)",
5953 "Sony ILCE-3000",
5954 "Sony ILCE-5000",
5955 "Sony ILCE-5100",
5956 "Sony ILCE-6000",
5957 "Sony ILCE-6300",
5958 "Sony ILCE-6500",
5959 "Sony ILCE-QX1",
5960 "Sony DSC-F828",
5961 "Sony DSC-R1",
5962 "Sony DSC-RX0",
5963 "Sony DSC-RX1",
5964 "Sony DSC-RX1R",
5965 "Sony DSC-RX1R II",
5966 "Sony DSC-RX10",
5967 "Sony DSC-RX10II",
5968 "Sony DSC-RX10III",
5969 "Sony DSC-RX10IV",
5970 "Sony DSC-RX100",
5971 "Sony DSC-RX100II",
5972 "Sony DSC-RX100III",
5973 "Sony DSC-RX100IV",
5974 "Sony DSC-RX100V",
5975 "Sony DSC-V3",
5976 "Sony DSLR-A100",
5977 "Sony DSLR-A200",
5978 "Sony DSLR-A230",
5979 "Sony DSLR-A290",
5980 "Sony DSLR-A300",
5981 "Sony DSLR-A330",
5982 "Sony DSLR-A350",
5983 "Sony DSLR-A380",
5984 "Sony DSLR-A390",
5985 "Sony DSLR-A450",
5986 "Sony DSLR-A500",
5987 "Sony DSLR-A550",
5988 "Sony DSLR-A560",
5989 "Sony DSLR-A580",
5990 "Sony DSLR-A700",
5991 "Sony DSLR-A850",
5992 "Sony DSLR-A900",
5993 "Sony NEX-3",
5994 "Sony NEX-3N",
5995 "Sony NEX-5",
5996 "Sony NEX-5N",
5997 "Sony NEX-5R",
5998 "Sony NEX-5T",
5999 "Sony NEX-6",
6000 "Sony NEX-7",
6001 "Sony NEX-C3",
6002 "Sony NEX-F3",
6003 "Sony NEX-VG20",
6004 "Sony NEX-VG30",
6005 "Sony NEX-VG900",
6006 "Sony SLT-A33",
6007 "Sony SLT-A35",
6008 "Sony SLT-A37",
6009 "Sony SLT-A55V",
6010 "Sony SLT-A57",
6011 "Sony SLT-A58",
6012 "Sony SLT-A65V",
6013 "Sony SLT-A77V",
6014 "Sony SLT-A99V",
6015 "Sony XCD-SX910CR",
6016 "Sony IMX135-mipi 13mp",
6017 "Sony IMX135-QCOM",
6018 "Sony IMX072-mipi",
6019 "Sony IMX214",
6020 "Sony IMX219",
6021 "Sony IMX230",
6022 "Sony IMX298-mipi 16mp",
6023 "Sony IMX219-mipi 8mp",
6024 "Sony Xperia L",
6025 "STV680 VGA",
6026 "PtGrey GRAS-50S5C",
6027 "JaiPulnix BB-500CL",
6028 "JaiPulnix BB-500GE",
6029 "SVS SVS625CL",
6030 "Yi M1",
6031 "YUNEEC CGO3",
6032 "YUNEEC CGO3P",
6033 "YUNEEC CGO4",
6034 "Xiaomi MI3",
6035 "Xiaomi RedMi Note3 Pro",
6036 "Xiaoyi YIAC3 (YI 4k)",
6037 NULL
6038 };
6039 // clang-format on
6040
cameraList()6041 const char **LibRaw::cameraList() { return static_camera_list; }
cameraCount()6042 int LibRaw::cameraCount() { return (sizeof(static_camera_list) / sizeof(static_camera_list[0])) - 1; }
6043
strprogress(enum LibRaw_progress p)6044 const char *LibRaw::strprogress(enum LibRaw_progress p)
6045 {
6046 switch (p)
6047 {
6048 case LIBRAW_PROGRESS_START:
6049 return "Starting";
6050 case LIBRAW_PROGRESS_OPEN:
6051 return "Opening file";
6052 case LIBRAW_PROGRESS_IDENTIFY:
6053 return "Reading metadata";
6054 case LIBRAW_PROGRESS_SIZE_ADJUST:
6055 return "Adjusting size";
6056 case LIBRAW_PROGRESS_LOAD_RAW:
6057 return "Reading RAW data";
6058 case LIBRAW_PROGRESS_REMOVE_ZEROES:
6059 return "Clearing zero values";
6060 case LIBRAW_PROGRESS_BAD_PIXELS:
6061 return "Removing dead pixels";
6062 case LIBRAW_PROGRESS_DARK_FRAME:
6063 return "Subtracting dark frame data";
6064 case LIBRAW_PROGRESS_FOVEON_INTERPOLATE:
6065 return "Interpolating Foveon sensor data";
6066 case LIBRAW_PROGRESS_SCALE_COLORS:
6067 return "Scaling colors";
6068 case LIBRAW_PROGRESS_PRE_INTERPOLATE:
6069 return "Pre-interpolating";
6070 case LIBRAW_PROGRESS_INTERPOLATE:
6071 return "Interpolating";
6072 case LIBRAW_PROGRESS_MIX_GREEN:
6073 return "Mixing green channels";
6074 case LIBRAW_PROGRESS_MEDIAN_FILTER:
6075 return "Median filter";
6076 case LIBRAW_PROGRESS_HIGHLIGHTS:
6077 return "Highlight recovery";
6078 case LIBRAW_PROGRESS_FUJI_ROTATE:
6079 return "Rotating Fuji diagonal data";
6080 case LIBRAW_PROGRESS_FLIP:
6081 return "Flipping image";
6082 case LIBRAW_PROGRESS_APPLY_PROFILE:
6083 return "ICC conversion";
6084 case LIBRAW_PROGRESS_CONVERT_RGB:
6085 return "Converting to RGB";
6086 case LIBRAW_PROGRESS_STRETCH:
6087 return "Stretching image";
6088 case LIBRAW_PROGRESS_THUMB_LOAD:
6089 return "Loading thumbnail";
6090 default:
6091 return "Some strange things";
6092 }
6093 }
6094
6095 #undef ID
6096
6097 #include "../internal/libraw_x3f.cpp"
6098
x3f_clear(void * p)6099 void x3f_clear(void *p) { x3f_delete((x3f_t *)p); }
6100
utf2char(utf16_t * str,char * buffer,unsigned bufsz)6101 static void utf2char(utf16_t *str, char *buffer, unsigned bufsz)
6102 {
6103 if(bufsz<1) return;
6104 buffer[bufsz-1] = 0;
6105 char *b = buffer;
6106
6107 while (*str != 0x00 && --bufsz>0)
6108 {
6109 char *chr = (char *)str;
6110 *b++ = *chr;
6111 str++;
6112 }
6113 *b = 0;
6114 }
6115
lr_memmem(const void * l,size_t l_len,const void * s,size_t s_len)6116 static void *lr_memmem(const void *l, size_t l_len, const void *s, size_t s_len)
6117 {
6118 register char *cur, *last;
6119 const char *cl = (const char *)l;
6120 const char *cs = (const char *)s;
6121
6122 /* we need something to compare */
6123 if (l_len == 0 || s_len == 0)
6124 return NULL;
6125
6126 /* "s" must be smaller or equal to "l" */
6127 if (l_len < s_len)
6128 return NULL;
6129
6130 /* special case where s_len == 1 */
6131 if (s_len == 1)
6132 return (void *)memchr(l, (int)*cs, l_len);
6133
6134 /* the last position where its possible to find "s" in "l" */
6135 last = (char *)cl + l_len - s_len;
6136
6137 for (cur = (char *)cl; cur <= last; cur++)
6138 if (cur[0] == cs[0] && memcmp(cur, cs, s_len) == 0)
6139 return cur;
6140 return NULL;
6141 }
6142
parse_x3f()6143 void LibRaw::parse_x3f()
6144 {
6145 x3f_t *x3f = x3f_new_from_file(libraw_internal_data.internal_data.input);
6146 if (!x3f)
6147 return;
6148 _x3f_data = x3f;
6149
6150 x3f_header_t *H = NULL;
6151 x3f_directory_section_t *DS = NULL;
6152
6153 H = &x3f->header;
6154 // Parse RAW size from RAW section
6155 x3f_directory_entry_t *DE = x3f_get_raw(x3f);
6156 if (!DE)
6157 return;
6158 imgdata.sizes.flip = H->rotation;
6159 x3f_directory_entry_header_t *DEH = &DE->header;
6160 x3f_image_data_t *ID = &DEH->data_subsection.image_data;
6161 imgdata.sizes.raw_width = ID->columns;
6162 imgdata.sizes.raw_height = ID->rows;
6163 // Parse other params from property section
6164
6165 DE = x3f_get_prop(x3f);
6166 if ((x3f_load_data(x3f, DE) == X3F_OK))
6167 {
6168 // Parse property list
6169 DEH = &DE->header;
6170 x3f_property_list_t *PL = &DEH->data_subsection.property_list;
6171 utf16_t *datap = (utf16_t*) PL->data;
6172 uint32_t maxitems = PL->data_size/sizeof(utf16_t);
6173 if (PL->property_table.size != 0)
6174 {
6175 int i;
6176 x3f_property_t *P = PL->property_table.element;
6177 for (i = 0; i < PL->num_properties; i++)
6178 {
6179 char name[100], value[100];
6180 int noffset = (P[i].name - datap);
6181 int voffset = (P[i].value - datap);
6182 if(noffset < 0 || noffset>maxitems || voffset<0 || voffset>maxitems)
6183 throw LIBRAW_EXCEPTION_IO_CORRUPT;
6184 int maxnsize = maxitems - (P[i].name - datap);
6185 int maxvsize = maxitems - (P[i].value - datap);
6186 utf2char(P[i].name, name,MIN(maxnsize,sizeof(name)));
6187 utf2char(P[i].value, value,MIN(maxvsize,sizeof(value)));
6188 if (!strcmp(name, "ISO"))
6189 imgdata.other.iso_speed = atoi(value);
6190 if (!strcmp(name, "CAMMANUF"))
6191 strcpy(imgdata.idata.make, value);
6192 if (!strcmp(name, "CAMMODEL"))
6193 strcpy(imgdata.idata.model, value);
6194 if (!strcmp(name, "CAMSERIAL"))
6195 strcpy(imgdata.shootinginfo.BodySerial, value);
6196 if (!strcmp(name, "WB_DESC"))
6197 strcpy(imgdata.color.model2, value);
6198 if (!strcmp(name, "TIME"))
6199 imgdata.other.timestamp = atoi(value);
6200 if (!strcmp(name, "SHUTTER"))
6201 imgdata.other.shutter = atof(value);
6202 if (!strcmp(name, "APERTURE"))
6203 imgdata.other.aperture = atof(value);
6204 if (!strcmp(name, "FLENGTH"))
6205 imgdata.other.focal_len = atof(value);
6206 if (!strcmp(name, "FLEQ35MM"))
6207 imgdata.lens.makernotes.FocalLengthIn35mmFormat = atof(value);
6208 if (!strcmp(name, "IMAGERTEMP"))
6209 imgdata.other.SensorTemperature = atof(value);
6210 if (!strcmp(name, "LENSARANGE"))
6211 {
6212 char *sp;
6213 imgdata.lens.makernotes.MaxAp4CurFocal = imgdata.lens.makernotes.MinAp4CurFocal = atof(value);
6214 sp = strrchr(value, ' ');
6215 if (sp)
6216 {
6217 imgdata.lens.makernotes.MinAp4CurFocal = atof(sp);
6218 if (imgdata.lens.makernotes.MaxAp4CurFocal > imgdata.lens.makernotes.MinAp4CurFocal)
6219 my_swap(float, imgdata.lens.makernotes.MaxAp4CurFocal, imgdata.lens.makernotes.MinAp4CurFocal);
6220 }
6221 }
6222 if (!strcmp(name, "LENSFRANGE"))
6223 {
6224 char *sp;
6225 imgdata.lens.makernotes.MinFocal = imgdata.lens.makernotes.MaxFocal = atof(value);
6226 sp = strrchr(value, ' ');
6227 if (sp)
6228 {
6229 imgdata.lens.makernotes.MaxFocal = atof(sp);
6230 if ((imgdata.lens.makernotes.MaxFocal + 0.17f) < imgdata.lens.makernotes.MinFocal)
6231 my_swap(float, imgdata.lens.makernotes.MaxFocal, imgdata.lens.makernotes.MinFocal);
6232 }
6233 }
6234 if (!strcmp(name, "LENSMODEL"))
6235 {
6236 char *sp;
6237 imgdata.lens.makernotes.LensID = strtol(value, &sp, 16); // atoi(value);
6238 if (imgdata.lens.makernotes.LensID)
6239 imgdata.lens.makernotes.LensMount = Sigma_X3F;
6240 }
6241 }
6242 imgdata.idata.raw_count = 1;
6243 load_raw = &LibRaw::x3f_load_raw;
6244 imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 6;
6245 imgdata.idata.is_foveon = 1;
6246 libraw_internal_data.internal_output_params.raw_color = 1; // Force adobe coeff
6247 imgdata.color.maximum = 0x3fff; // To be reset by color table
6248 libraw_internal_data.unpacker_data.order = 0x4949;
6249 }
6250 }
6251 else
6252 {
6253 // No property list
6254 if (imgdata.sizes.raw_width == 5888 || imgdata.sizes.raw_width == 2944 || imgdata.sizes.raw_width == 6656 ||
6255 imgdata.sizes.raw_width == 3328 || imgdata.sizes.raw_width == 5504 ||
6256 imgdata.sizes.raw_width == 2752) // Quattro
6257 {
6258 imgdata.idata.raw_count = 1;
6259 load_raw = &LibRaw::x3f_load_raw;
6260 imgdata.sizes.raw_pitch = imgdata.sizes.raw_width * 6;
6261 imgdata.idata.is_foveon = 1;
6262 libraw_internal_data.internal_output_params.raw_color = 1; // Force adobe coeff
6263 libraw_internal_data.unpacker_data.order = 0x4949;
6264 strcpy(imgdata.idata.make, "SIGMA");
6265 #if 1
6266 // Try to find model number in first 2048 bytes;
6267 int pos = libraw_internal_data.internal_data.input->tell();
6268 libraw_internal_data.internal_data.input->seek(0, SEEK_SET);
6269 unsigned char buf[2048];
6270 libraw_internal_data.internal_data.input->read(buf, 2048, 1);
6271 libraw_internal_data.internal_data.input->seek(pos, SEEK_SET);
6272 unsigned char *fnd = (unsigned char *)lr_memmem(buf, 2048, "SIGMA dp", 8);
6273 unsigned char *fndsd = (unsigned char *)lr_memmem(buf, 2048, "sd Quatt", 8);
6274 if (fnd)
6275 {
6276 unsigned char *nm = fnd + 8;
6277 snprintf(imgdata.idata.model, 64, "dp%c Quattro", *nm <= '9' && *nm >= '0' ? *nm : '2');
6278 }
6279 else if (fndsd)
6280 {
6281 snprintf(imgdata.idata.model, 64, "%s", fndsd);
6282 }
6283 else
6284 #endif
6285 if (imgdata.sizes.raw_width == 6656 || imgdata.sizes.raw_width == 3328)
6286 strcpy(imgdata.idata.model, "sd Quattro H");
6287 else
6288 strcpy(imgdata.idata.model, "dp2 Quattro");
6289 }
6290 // else
6291 }
6292 // Try to get thumbnail data
6293 LibRaw_thumbnail_formats format = LIBRAW_THUMBNAIL_UNKNOWN;
6294 if ((DE = x3f_get_thumb_jpeg(x3f)))
6295 {
6296 format = LIBRAW_THUMBNAIL_JPEG;
6297 }
6298 else if ((DE = x3f_get_thumb_plain(x3f)))
6299 {
6300 format = LIBRAW_THUMBNAIL_BITMAP;
6301 }
6302 if (DE)
6303 {
6304 x3f_directory_entry_header_t *DEH = &DE->header;
6305 x3f_image_data_t *ID = &DEH->data_subsection.image_data;
6306 imgdata.thumbnail.twidth = ID->columns;
6307 imgdata.thumbnail.theight = ID->rows;
6308 imgdata.thumbnail.tcolors = 3;
6309 imgdata.thumbnail.tformat = format;
6310 libraw_internal_data.internal_data.toffset = DE->input.offset;
6311 write_thumb = &LibRaw::x3f_thumb_loader;
6312 }
6313 }
6314
x3f_thumb_size()6315 INT64 LibRaw::x3f_thumb_size()
6316 {
6317 try
6318 {
6319 x3f_t *x3f = (x3f_t *)_x3f_data;
6320 if (!x3f)
6321 return -1; // No data pointer set
6322 x3f_directory_entry_t *DE = x3f_get_thumb_jpeg(x3f);
6323 if (!DE)
6324 DE = x3f_get_thumb_plain(x3f);
6325 if (!DE)
6326 return -1;
6327 int64_t p = x3f_load_data_size(x3f, DE);
6328 if (p < 0 || p > 0xffffffff)
6329 return -1;
6330 return p;
6331 }
6332 catch (...)
6333 {
6334 return -1;
6335 }
6336 }
6337
x3f_thumb_loader()6338 void LibRaw::x3f_thumb_loader()
6339 {
6340 try
6341 {
6342 x3f_t *x3f = (x3f_t *)_x3f_data;
6343 if (!x3f)
6344 return; // No data pointer set
6345 x3f_directory_entry_t *DE = x3f_get_thumb_jpeg(x3f);
6346 if (!DE)
6347 DE = x3f_get_thumb_plain(x3f);
6348 if (!DE)
6349 return;
6350 if (X3F_OK != x3f_load_data(x3f, DE))
6351 throw LIBRAW_EXCEPTION_IO_CORRUPT;
6352 x3f_directory_entry_header_t *DEH = &DE->header;
6353 x3f_image_data_t *ID = &DEH->data_subsection.image_data;
6354 imgdata.thumbnail.twidth = ID->columns;
6355 imgdata.thumbnail.theight = ID->rows;
6356 imgdata.thumbnail.tcolors = 3;
6357 if (imgdata.thumbnail.tformat == LIBRAW_THUMBNAIL_JPEG)
6358 {
6359 imgdata.thumbnail.thumb = (char *)malloc(ID->data_size);
6360 merror(imgdata.thumbnail.thumb, "LibRaw::x3f_thumb_loader()");
6361 memmove(imgdata.thumbnail.thumb, ID->data, ID->data_size);
6362 imgdata.thumbnail.tlength = ID->data_size;
6363 }
6364 else if (imgdata.thumbnail.tformat == LIBRAW_THUMBNAIL_BITMAP)
6365 {
6366 imgdata.thumbnail.tlength = ID->columns * ID->rows * 3;
6367 imgdata.thumbnail.thumb = (char *)malloc(ID->columns * ID->rows * 3);
6368 merror(imgdata.thumbnail.thumb, "LibRaw::x3f_thumb_loader()");
6369 char *src0 = (char *)ID->data;
6370 for (int row = 0; row < ID->rows; row++)
6371 {
6372 int offset = row * ID->row_stride;
6373 if (offset + ID->columns * 3 > ID->data_size)
6374 break;
6375 char *dest = &imgdata.thumbnail.thumb[row * ID->columns * 3];
6376 char *src = &src0[offset];
6377 memmove(dest, src, ID->columns * 3);
6378 }
6379 }
6380 }
6381 catch (...)
6382 {
6383 // do nothing
6384 }
6385 }
6386
_clampbits(int x,uint32_t n)6387 static inline uint32_t _clampbits(int x, uint32_t n)
6388 {
6389 uint32_t _y_temp;
6390 if ((_y_temp = x >> n))
6391 x = ~_y_temp >> (32 - n);
6392 return x;
6393 }
6394
x3f_dpq_interpolate_rg()6395 void LibRaw::x3f_dpq_interpolate_rg()
6396 {
6397 int w = imgdata.sizes.raw_width / 2;
6398 int h = imgdata.sizes.raw_height / 2;
6399 unsigned short *image = (ushort *)imgdata.rawdata.color3_image;
6400
6401 for (int color = 0; color < 2; color++)
6402 {
6403 for (int y = 2; y < (h - 2); y++)
6404 {
6405 uint16_t *row0 = &image[imgdata.sizes.raw_width * 3 * (y * 2) + color]; // dst[1]
6406 uint16_t row0_3 = row0[3];
6407 uint16_t *row1 = &image[imgdata.sizes.raw_width * 3 * (y * 2 + 1) + color]; // dst1[1]
6408 uint16_t row1_3 = row1[3];
6409 for (int x = 2; x < (w - 2); x++)
6410 {
6411 row1[0] = row1[3] = row0[3] = row0[0];
6412 row0 += 6;
6413 row1 += 6;
6414 }
6415 }
6416 }
6417 }
6418
6419 #define _ABS(a) ((a) < 0 ? -(a) : (a))
6420
6421 #undef CLIP
6422 #define CLIP(value, high) ((value) > (high) ? (high) : (value))
6423
x3f_dpq_interpolate_af(int xstep,int ystep,int scale)6424 void LibRaw::x3f_dpq_interpolate_af(int xstep, int ystep, int scale)
6425 {
6426 unsigned short *image = (ushort *)imgdata.rawdata.color3_image;
6427 unsigned int rowpitch = imgdata.rawdata.sizes.raw_pitch / 2; // in 16-bit words
6428 // Interpolate single pixel
6429 for (int y = 0; y < imgdata.rawdata.sizes.height + imgdata.rawdata.sizes.top_margin; y += ystep)
6430 {
6431 if (y < imgdata.rawdata.sizes.top_margin)
6432 continue;
6433 if (y < scale)
6434 continue;
6435 if (y > imgdata.rawdata.sizes.raw_height - scale)
6436 break;
6437 uint16_t *row0 = &image[imgdata.sizes.raw_width * 3 * y]; // Наша строка
6438 uint16_t *row_minus = &image[imgdata.sizes.raw_width * 3 * (y - scale)]; // Строка выше
6439 uint16_t *row_plus = &image[imgdata.sizes.raw_width * 3 * (y + scale)]; // Строка ниже
6440 for (int x = 0; x < imgdata.rawdata.sizes.width + imgdata.rawdata.sizes.left_margin; x += xstep)
6441 {
6442 if (x < imgdata.rawdata.sizes.left_margin)
6443 continue;
6444 if (x < scale)
6445 continue;
6446 if (x > imgdata.rawdata.sizes.raw_width - scale)
6447 break;
6448 uint16_t *pixel0 = &row0[x * 3];
6449 uint16_t *pixel_top = &row_minus[x * 3];
6450 uint16_t *pixel_bottom = &row_plus[x * 3];
6451 uint16_t *pixel_left = &row0[(x - scale) * 3];
6452 uint16_t *pixel_right = &row0[(x + scale) * 3];
6453 uint16_t *pixf = pixel_top;
6454 if (_ABS(pixf[2] - pixel0[2]) > _ABS(pixel_bottom[2] - pixel0[2]))
6455 pixf = pixel_bottom;
6456 if (_ABS(pixf[2] - pixel0[2]) > _ABS(pixel_left[2] - pixel0[2]))
6457 pixf = pixel_left;
6458 if (_ABS(pixf[2] - pixel0[2]) > _ABS(pixel_right[2] - pixel0[2]))
6459 pixf = pixel_right;
6460 int blocal = pixel0[2], bnear = pixf[2];
6461 if (blocal < imgdata.color.black + 16 || bnear < imgdata.color.black + 16)
6462 {
6463 if (pixel0[0] < imgdata.color.black)
6464 pixel0[0] = imgdata.color.black;
6465 if (pixel0[1] < imgdata.color.black)
6466 pixel0[1] = imgdata.color.black;
6467 pixel0[0] = CLIP((pixel0[0] - imgdata.color.black) * 4 + imgdata.color.black, 16383);
6468 pixel0[1] = CLIP((pixel0[1] - imgdata.color.black) * 4 + imgdata.color.black, 16383);
6469 }
6470 else
6471 {
6472 float multip = float(bnear - imgdata.color.black) / float(blocal - imgdata.color.black);
6473 if (pixel0[0] < imgdata.color.black)
6474 pixel0[0] = imgdata.color.black;
6475 if (pixel0[1] < imgdata.color.black)
6476 pixel0[1] = imgdata.color.black;
6477 float pixf0 = pixf[0];
6478 if (pixf0 < imgdata.color.black)
6479 pixf0 = imgdata.color.black;
6480 float pixf1 = pixf[1];
6481 if (pixf1 < imgdata.color.black)
6482 pixf1 = imgdata.color.black;
6483
6484 pixel0[0] = CLIP(((float(pixf0 - imgdata.color.black) * multip + imgdata.color.black) +
6485 ((pixel0[0] - imgdata.color.black) * 3.75 + imgdata.color.black)) /
6486 2,
6487 16383);
6488 pixel0[1] = CLIP(((float(pixf1 - imgdata.color.black) * multip + imgdata.color.black) +
6489 ((pixel0[1] - imgdata.color.black) * 3.75 + imgdata.color.black)) /
6490 2,
6491 16383);
6492 // pixel0[1] = float(pixf[1]-imgdata.color.black)*multip + imgdata.color.black;
6493 }
6494 }
6495 }
6496 }
6497
x3f_dpq_interpolate_af_sd(int xstart,int ystart,int xend,int yend,int xstep,int ystep,int scale)6498 void LibRaw::x3f_dpq_interpolate_af_sd(int xstart, int ystart, int xend, int yend, int xstep, int ystep, int scale)
6499 {
6500 unsigned short *image = (ushort *)imgdata.rawdata.color3_image;
6501 unsigned int rowpitch = imgdata.rawdata.sizes.raw_pitch / 2; // in 16-bit words
6502 // Interpolate single pixel
6503 for (int y = ystart; y < yend && y < imgdata.rawdata.sizes.height + imgdata.rawdata.sizes.top_margin; y += ystep)
6504 {
6505 uint16_t *row0 = &image[imgdata.sizes.raw_width * 3 * y]; // Наша строка
6506 uint16_t *row1 = &image[imgdata.sizes.raw_width * 3 * (y + 1)]; // Следующая строка
6507 uint16_t *row_minus = &image[imgdata.sizes.raw_width * 3 * (y - scale)]; // Строка выше
6508 uint16_t *row_plus =
6509 &image[imgdata.sizes.raw_width * 3 * (y + scale)]; // Строка ниже AF-point (scale=2 -> ниже row1
6510 uint16_t *row_minus1 = &image[imgdata.sizes.raw_width * 3 * (y - 1)];
6511 for (int x = xstart; x < xend && x < imgdata.rawdata.sizes.width + imgdata.rawdata.sizes.left_margin; x += xstep)
6512 {
6513 uint16_t *pixel00 = &row0[x * 3]; // Current pixel
6514 float sumR = 0.f, sumG = 0.f;
6515 float cnt = 0.f;
6516 for (int xx = -scale; xx <= scale; xx += scale)
6517 {
6518 sumR += row_minus[(x + xx) * 3];
6519 sumR += row_plus[(x + xx) * 3];
6520 sumG += row_minus[(x + xx) * 3 + 1];
6521 sumG += row_plus[(x + xx) * 3 + 1];
6522 cnt += 1.f;
6523 if (xx)
6524 {
6525 cnt += 1.f;
6526 sumR += row0[(x + xx) * 3];
6527 sumG += row0[(x + xx) * 3 + 1];
6528 }
6529 }
6530 pixel00[0] = sumR / 8.f;
6531 pixel00[1] = sumG / 8.f;
6532
6533 if (scale == 2)
6534 {
6535 uint16_t *pixel0B = &row0[x * 3 + 3]; // right pixel
6536 uint16_t *pixel1B = &row1[x * 3 + 3]; // right pixel
6537 float sumG0 = 0, sumG1 = 0.f;
6538 float cnt = 0.f;
6539 for (int xx = -scale; xx <= scale; xx += scale)
6540 {
6541 sumG0 += row_minus1[(x + xx) * 3 + 2];
6542 sumG1 += row_plus[(x + xx) * 3 + 2];
6543 cnt += 1.f;
6544 if (xx)
6545 {
6546 sumG0 += row0[(x + xx) * 3 + 2];
6547 sumG1 += row1[(x + xx) * 3 + 2];
6548 cnt += 1.f;
6549 }
6550 }
6551 pixel0B[2] = sumG0 / cnt;
6552 pixel1B[2] = sumG1 / cnt;
6553 }
6554
6555 // uint16_t* pixel10 = &row1[x*3]; // Pixel below current
6556 // uint16_t* pixel_bottom = &row_plus[x*3];
6557 }
6558 }
6559 }
6560
x3f_load_raw()6561 void LibRaw::x3f_load_raw()
6562 {
6563 // already in try/catch
6564 int raise_error = 0;
6565 x3f_t *x3f = (x3f_t *)_x3f_data;
6566 if (!x3f)
6567 return; // No data pointer set
6568 if (X3F_OK == x3f_load_data(x3f, x3f_get_raw(x3f)))
6569 {
6570 x3f_directory_entry_t *DE = x3f_get_raw(x3f);
6571 x3f_directory_entry_header_t *DEH = &DE->header;
6572 x3f_image_data_t *ID = &DEH->data_subsection.image_data;
6573 if (!ID)
6574 throw LIBRAW_EXCEPTION_IO_CORRUPT;
6575 x3f_quattro_t *Q = ID->quattro;
6576 x3f_huffman_t *HUF = ID->huffman;
6577 x3f_true_t *TRU = ID->tru;
6578 uint16_t *data = NULL;
6579 if (ID->rows != S.raw_height || ID->columns != S.raw_width)
6580 {
6581 raise_error = 1;
6582 goto end;
6583 }
6584 if (HUF != NULL)
6585 data = HUF->x3rgb16.data;
6586 if (TRU != NULL)
6587 data = TRU->x3rgb16.data;
6588 if (data == NULL)
6589 {
6590 raise_error = 1;
6591 goto end;
6592 }
6593
6594 size_t datasize = S.raw_height * S.raw_width * 3 * sizeof(unsigned short);
6595 S.raw_pitch = S.raw_width * 3 * sizeof(unsigned short);
6596 if (!(imgdata.rawdata.raw_alloc = malloc(datasize)))
6597 throw LIBRAW_EXCEPTION_ALLOC;
6598
6599 imgdata.rawdata.color3_image = (ushort(*)[3])imgdata.rawdata.raw_alloc;
6600 if (HUF)
6601 memmove(imgdata.rawdata.raw_alloc, data, datasize);
6602 else if (TRU && (!Q || !Q->quattro_layout))
6603 memmove(imgdata.rawdata.raw_alloc, data, datasize);
6604 else if (TRU && Q)
6605 {
6606 // Move quattro data in place
6607 // R/B plane
6608 for (int prow = 0; prow < TRU->x3rgb16.rows && prow < S.raw_height / 2; prow++)
6609 {
6610 ushort(*destrow)[3] =
6611 (unsigned short(*)[3]) & imgdata.rawdata.color3_image[prow * 2 * S.raw_pitch / 3 / sizeof(ushort)][0];
6612 ushort(*srcrow)[3] = (unsigned short(*)[3]) & data[prow * TRU->x3rgb16.row_stride];
6613 for (int pcol = 0; pcol < TRU->x3rgb16.columns && pcol < S.raw_width / 2; pcol++)
6614 {
6615 destrow[pcol * 2][0] = srcrow[pcol][0];
6616 destrow[pcol * 2][1] = srcrow[pcol][1];
6617 }
6618 }
6619 for (int row = 0; row < Q->top16.rows && row < S.raw_height; row++)
6620 {
6621 ushort(*destrow)[3] =
6622 (unsigned short(*)[3]) & imgdata.rawdata.color3_image[row * S.raw_pitch / 3 / sizeof(ushort)][0];
6623 ushort(*srcrow) = (unsigned short *)&Q->top16.data[row * Q->top16.columns];
6624 for (int col = 0; col < Q->top16.columns && col < S.raw_width; col++)
6625 destrow[col][2] = srcrow[col];
6626 }
6627 }
6628
6629 #if 1
6630 if (TRU && Q && (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_DP2Q_INTERPOLATEAF))
6631 {
6632 if (imgdata.sizes.raw_width == 5888 && imgdata.sizes.raw_height == 3672) // dpN Quattro normal
6633 {
6634 x3f_dpq_interpolate_af(32, 8, 2);
6635 }
6636 else if (imgdata.sizes.raw_width == 5888 && imgdata.sizes.raw_height == 3776) // sd Quattro normal raw
6637 {
6638 x3f_dpq_interpolate_af_sd(216, 464, imgdata.sizes.raw_width - 1, 3312, 16, 32, 2);
6639 }
6640 else if (imgdata.sizes.raw_width == 6656 && imgdata.sizes.raw_height == 4480) // sd Quattro H normal raw
6641 {
6642 x3f_dpq_interpolate_af_sd(232, 592, imgdata.sizes.raw_width - 1, 3920, 16, 32, 2);
6643 }
6644 else if (imgdata.sizes.raw_width == 3328 && imgdata.sizes.raw_height == 2240) // sd Quattro H half size
6645 {
6646 x3f_dpq_interpolate_af_sd(116, 296, imgdata.sizes.raw_width - 1, 2200, 8, 16, 1);
6647 }
6648 else if (imgdata.sizes.raw_width == 5504 && imgdata.sizes.raw_height == 3680) // sd Quattro H APS-C raw
6649 {
6650 x3f_dpq_interpolate_af_sd(8, 192, imgdata.sizes.raw_width - 1, 3185, 16, 32, 2);
6651 }
6652 else if (imgdata.sizes.raw_width == 2752 && imgdata.sizes.raw_height == 1840) // sd Quattro H APS-C half size
6653 {
6654 x3f_dpq_interpolate_af_sd(4, 96, imgdata.sizes.raw_width - 1, 1800, 8, 16, 1);
6655 }
6656 else if (imgdata.sizes.raw_width == 2944 && imgdata.sizes.raw_height == 1836) // dpN Quattro small raw
6657 {
6658 x3f_dpq_interpolate_af(16, 4, 1);
6659 }
6660 else if (imgdata.sizes.raw_width == 2944 && imgdata.sizes.raw_height == 1888) // sd Quattro small
6661 {
6662 x3f_dpq_interpolate_af_sd(108, 232, imgdata.sizes.raw_width - 1, 1656, 8, 16, 1);
6663 }
6664 }
6665 #endif
6666 if (TRU && Q && Q->quattro_layout && (imgdata.params.raw_processing_options & LIBRAW_PROCESSING_DP2Q_INTERPOLATERG))
6667 x3f_dpq_interpolate_rg();
6668 }
6669 else
6670 raise_error = 1;
6671 end:
6672 if (raise_error)
6673 throw LIBRAW_EXCEPTION_IO_CORRUPT;
6674 }
6675