3
* Copyright 2008-2010 LibRaw LLC (info@libraw.org)
4
* Created: Sat Mar 8 , 2008
6
* LibRaw C++ interface (implementation)
8
LibRaw is free software; you can redistribute it and/or modify
9
it under the terms of the one of three licenses as you choose:
11
1. GNU LESSER GENERAL PUBLIC LICENSE version 2.1
12
(See file LICENSE.LGPL provided in LibRaw distribution archive for details).
14
2. COMMON DEVELOPMENT AND DISTRIBUTION LICENSE (CDDL) Version 1.0
15
(See file LICENSE.CDDL provided in LibRaw distribution archive for details).
17
3. LibRaw Software License 27032010
18
(See file LICENSE.LibRaw.pdf provided in LibRaw distribution archive for details).
27
#include <sys/types.h>
30
#include <netinet/in.h>
34
#define LIBRAW_LIBRARY_BUILD
35
#include "libraw/libraw.h"
36
#include "internal/defines.h"
42
void default_memory_callback(void *,const char *file,const char *where)
44
fprintf (stderr,"%s: Out of memory in %s\n", file?file:"unknown file", where);
47
void default_data_callback(void*,const char *file, const int offset)
50
fprintf (stderr,"%s: Unexpected end of file\n", file?file:"unknown file");
52
fprintf (stderr,"%s: data corrupted at %d\n",file?file:"unknown file",offset);
54
const char *libraw_strerror(int e)
56
enum LibRaw_errors errorcode = (LibRaw_errors)e;
61
case LIBRAW_UNSPECIFIED_ERROR:
62
return "Unspecified error";
63
case LIBRAW_FILE_UNSUPPORTED:
64
return "Unsupported file format or not RAW file";
65
case LIBRAW_REQUEST_FOR_NONEXISTENT_IMAGE:
66
return "Request for nonexisting image number";
67
case LIBRAW_OUT_OF_ORDER_CALL:
68
return "Out of order call of libraw function";
69
case LIBRAW_NO_THUMBNAIL:
70
return "No thumbnail in file";
71
case LIBRAW_UNSUPPORTED_THUMBNAIL:
72
return "Unsupported thumbnail format";
73
case LIBRAW_UNSUFFICIENT_MEMORY:
74
return "Unsufficient memory";
75
case LIBRAW_DATA_ERROR:
76
return "Corrupted data or unexpected EOF";
78
return "Input/output error";
79
case LIBRAW_CANCELLED_BY_CALLBACK:
80
return "Cancelled by user callback";
82
return "Bad crop box";
84
return "Unknown error code";
93
const double LibRaw_constants::xyz_rgb[3][3] =
95
{ 0.412453, 0.357580, 0.180423 },
96
{ 0.212671, 0.715160, 0.072169 },
97
{ 0.019334, 0.119193, 0.950227 }
100
const float LibRaw_constants::d65_white[3] = { 0.950456f, 1.0f, 1.088754f };
102
#define P1 imgdata.idata
103
#define S imgdata.sizes
104
#define O imgdata.params
105
#define C imgdata.color
106
#define T imgdata.thumbnail
107
#define IO libraw_internal_data.internal_output_params
108
#define ID libraw_internal_data.internal_data
110
#define EXCEPTION_HANDLER(e) do{ \
111
/* fprintf(stderr,"Exception %d caught\n",e);*/ \
114
case LIBRAW_EXCEPTION_ALLOC: \
116
return LIBRAW_UNSUFFICIENT_MEMORY; \
117
case LIBRAW_EXCEPTION_DECODE_RAW: \
118
case LIBRAW_EXCEPTION_DECODE_JPEG: \
120
return LIBRAW_DATA_ERROR; \
121
case LIBRAW_EXCEPTION_DECODE_JPEG2000: \
123
return LIBRAW_DATA_ERROR; \
124
case LIBRAW_EXCEPTION_IO_EOF: \
125
case LIBRAW_EXCEPTION_IO_CORRUPT: \
127
return LIBRAW_IO_ERROR; \
128
case LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK:\
130
return LIBRAW_CANCELLED_BY_CALLBACK; \
131
case LIBRAW_EXCEPTION_BAD_CROP: \
133
return LIBRAW_BAD_CROP; \
135
return LIBRAW_UNSPECIFIED_ERROR; \
139
const char* LibRaw::version() { return LIBRAW_VERSION_STR;}
140
int LibRaw::versionNumber() { return LIBRAW_VERSION; }
141
const char* LibRaw::strerror(int p) { return libraw_strerror(p);}
144
void LibRaw::derror()
146
if (!libraw_internal_data.unpacker_data.data_error && libraw_internal_data.internal_data.input)
148
if (libraw_internal_data.internal_data.input->eof())
150
if(callbacks.data_cb)(*callbacks.data_cb)(callbacks.datacb_data,
151
libraw_internal_data.internal_data.input->fname(),-1);
152
throw LIBRAW_EXCEPTION_IO_EOF;
156
if(callbacks.data_cb)(*callbacks.data_cb)(callbacks.datacb_data,
157
libraw_internal_data.internal_data.input->fname(),
158
libraw_internal_data.internal_data.input->tell());
159
throw LIBRAW_EXCEPTION_IO_CORRUPT;
162
libraw_internal_data.unpacker_data.data_error++;
165
void LibRaw::dcraw_clear_mem(libraw_processed_image_t* p)
170
#define ZERO(a) memset(&a,0,sizeof(a))
173
LibRaw:: LibRaw(unsigned int flags)
175
double aber[4] = {1,1,1,1};
176
double gamm[6] = { 0.45,4.5,0,0,0,0 };
177
unsigned greybox[4] = { 0, 0, UINT_MAX, UINT_MAX };
178
unsigned cropbox[4] = { 0, 0, UINT_MAX, UINT_MAX };
185
ZERO(libraw_internal_data);
187
callbacks.mem_cb = (flags & LIBRAW_OPIONS_NO_MEMERR_CALLBACK) ? NULL: &default_memory_callback;
188
callbacks.data_cb = (flags & LIBRAW_OPIONS_NO_DATAERR_CALLBACK)? NULL : &default_data_callback;
189
memmove(&imgdata.params.aber,&aber,sizeof(aber));
190
memmove(&imgdata.params.gamm,&gamm,sizeof(gamm));
191
memmove(&imgdata.params.greybox,&greybox,sizeof(greybox));
192
memmove(&imgdata.params.cropbox,&cropbox,sizeof(cropbox));
194
imgdata.params.bright=1;
195
imgdata.params.use_camera_matrix=-1;
196
imgdata.params.user_flip=-1;
197
imgdata.params.user_black=-1;
198
imgdata.params.user_sat=-1;
199
imgdata.params.user_qual=-1;
200
imgdata.params.output_color=1;
201
imgdata.params.output_bps=8;
202
imgdata.params.use_fuji_rotate=1;
203
imgdata.params.exp_shift = 1.0;
204
imgdata.params.auto_bright_thr = LIBRAW_DEFAULT_AUTO_BRIGHTNESS_THRESHOLD;
205
imgdata.params.adjust_maximum_thr= LIBRAW_DEFAULT_ADJUST_MAXIMUM_THRESHOLD;
206
imgdata.params.green_matching = 0;
207
imgdata.parent_class = this;
208
imgdata.progress_flags = 0;
209
tls = new LibRaw_TLS;
214
void* LibRaw:: malloc(size_t t)
216
void *p = memmgr.malloc(t);
219
void* LibRaw:: realloc(void *q,size_t t)
221
void *p = memmgr.realloc(q,t);
226
void* LibRaw:: calloc(size_t n,size_t t)
228
void *p = memmgr.calloc(n,t);
231
void LibRaw:: free(void *p)
237
int LibRaw:: fc (int row, int col)
239
static const char filter[16][16] =
240
{ { 2,1,1,3,2,3,2,0,3,2,3,0,1,2,1,0 },
241
{ 0,3,0,2,0,1,3,1,0,1,1,2,0,3,3,2 },
242
{ 2,3,3,2,3,1,1,3,3,1,2,1,2,0,0,3 },
243
{ 0,1,0,1,0,2,0,2,2,0,3,0,1,3,2,1 },
244
{ 3,1,1,2,0,1,0,2,1,3,1,3,0,1,3,0 },
245
{ 2,0,0,3,3,2,3,1,2,0,2,0,3,2,2,1 },
246
{ 2,3,3,1,2,1,2,1,2,1,1,2,3,0,0,1 },
247
{ 1,0,0,2,3,0,0,3,0,3,0,3,2,1,2,3 },
248
{ 2,3,3,1,1,2,1,0,3,2,3,0,2,3,1,3 },
249
{ 1,0,2,0,3,0,3,2,0,1,1,2,0,1,0,2 },
250
{ 0,1,1,3,3,2,2,1,1,3,3,0,2,1,3,2 },
251
{ 2,3,2,0,0,1,3,0,2,0,1,2,3,0,1,0 },
252
{ 1,3,1,2,3,2,3,2,0,2,0,1,1,0,3,0 },
253
{ 0,2,0,3,1,0,0,1,1,3,3,2,3,2,2,1 },
254
{ 2,1,3,2,3,1,2,1,0,3,0,2,0,2,0,2 },
255
{ 0,3,1,0,0,2,0,3,2,1,3,1,1,3,1,3 } };
257
if (imgdata.idata.filters != 1) return FC(row,col);
258
return filter[(row+imgdata.sizes.top_margin) & 15][(col+imgdata.sizes.left_margin) & 15];
261
void LibRaw:: recycle()
263
if(libraw_internal_data.internal_data.input && libraw_internal_data.internal_data.input_internal)
265
delete libraw_internal_data.internal_data.input;
266
libraw_internal_data.internal_data.input = NULL;
268
libraw_internal_data.internal_data.input_internal = 0;
269
#define FREE(a) do { if(a) { free(a); a = NULL;} }while(0)
272
FREE(imgdata.thumbnail.thumb);
273
FREE(libraw_internal_data.internal_data.meta_data);
274
FREE(libraw_internal_data.output_data.histogram);
275
FREE(libraw_internal_data.output_data.oprof);
276
FREE(imgdata.color.profile);
277
FREE(imgdata.rawdata.ph1_black);
278
FREE(imgdata.rawdata.raw_alloc);
280
ZERO(imgdata.rawdata);
283
ZERO(libraw_internal_data);
285
imgdata.thumbnail.tformat = LIBRAW_THUMBNAIL_UNKNOWN;
286
imgdata.progress_flags = 0;
291
const char * LibRaw::unpack_function_name()
293
libraw_decoder_info_t decoder_info;
294
get_decoder_info(&decoder_info);
295
return decoder_info.decoder_name;
298
int LibRaw::get_decoder_info(libraw_decoder_info_t* d_info)
300
if(!d_info) return LIBRAW_UNSPECIFIED_ERROR;
301
if(!load_raw) return LIBRAW_OUT_OF_ORDER_CALL;
303
d_info->decoder_flags = LIBRAW_DECODER_NOTSET;
305
// sorted names order
306
if (load_raw == &LibRaw::adobe_dng_load_raw_lj)
309
d_info->decoder_name = "adobe_dng_load_raw_lj()";
310
d_info->decoder_flags = imgdata.idata.filters ? LIBRAW_DECODER_FLATFIELD : LIBRAW_DECODER_4COMPONENT ;
311
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
313
else if (load_raw == &LibRaw::adobe_dng_load_raw_nc)
316
d_info->decoder_name = "adobe_dng_load_raw_nc()";
317
d_info->decoder_flags = imgdata.idata.filters ? LIBRAW_DECODER_FLATFIELD : LIBRAW_DECODER_4COMPONENT;
318
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
320
else if (load_raw == &LibRaw::canon_600_load_raw)
322
d_info->decoder_name = "canon_600_load_raw()";
323
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD; // WB set within decoder, no need to load raw
325
else if (load_raw == &LibRaw::canon_compressed_load_raw)
327
d_info->decoder_name = "canon_compressed_load_raw()";
328
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
330
else if (load_raw == &LibRaw::canon_sraw_load_raw)
332
d_info->decoder_name = "canon_sraw_load_raw()";
333
d_info->decoder_flags = LIBRAW_DECODER_LEGACY;
335
else if (load_raw == &LibRaw::eight_bit_load_raw )
337
d_info->decoder_name = "eight_bit_load_raw()";
338
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
339
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
341
else if (load_raw == &LibRaw::foveon_load_raw )
343
d_info->decoder_name = "foveon_load_raw()";
344
d_info->decoder_flags = LIBRAW_DECODER_LEGACY;
346
else if (load_raw == &LibRaw::fuji_load_raw )
348
d_info->decoder_name = "fuji_load_raw()";
349
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
351
else if (load_raw == &LibRaw::hasselblad_load_raw )
353
d_info->decoder_name = "hasselblad_load_raw()";
354
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
356
else if (load_raw == &LibRaw::imacon_full_load_raw )
358
d_info->decoder_name = "imacon_full_load_raw()";
359
d_info->decoder_flags = LIBRAW_DECODER_4COMPONENT;
361
else if (load_raw == &LibRaw::kodak_262_load_raw )
363
d_info->decoder_name = "kodak_262_load_raw()"; // UNTESTED!
364
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
365
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
367
else if (load_raw == &LibRaw::kodak_65000_load_raw )
369
d_info->decoder_name = "kodak_65000_load_raw()";
370
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
371
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
373
else if (load_raw == &LibRaw::kodak_dc120_load_raw )
375
d_info->decoder_name = "kodak_dc120_load_raw()";
376
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
378
else if (load_raw == &LibRaw::kodak_jpeg_load_raw )
381
d_info->decoder_name = "kodak_jpeg_load_raw()";
382
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
384
else if (load_raw == &LibRaw::kodak_radc_load_raw )
386
d_info->decoder_name = "kodak_radc_load_raw()";
387
d_info->decoder_flags = LIBRAW_DECODER_4COMPONENT;
389
else if (load_raw == &LibRaw::kodak_rgb_load_raw )
392
d_info->decoder_name = "kodak_rgb_load_raw()";
393
d_info->decoder_flags = LIBRAW_DECODER_4COMPONENT;
395
else if (load_raw == &LibRaw::kodak_yrgb_load_raw )
397
d_info->decoder_name = "kodak_yrgb_load_raw()";
398
d_info->decoder_flags = LIBRAW_DECODER_4COMPONENT;
399
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
401
else if (load_raw == &LibRaw::kodak_ycbcr_load_raw )
404
d_info->decoder_name = "kodak_ycbcr_load_raw()";
405
d_info->decoder_flags = LIBRAW_DECODER_4COMPONENT;
406
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
408
else if (load_raw == &LibRaw::leaf_hdr_load_raw )
410
d_info->decoder_name = "leaf_hdr_load_raw()";
411
d_info->decoder_flags = imgdata.idata.filters ? LIBRAW_DECODER_FLATFIELD : LIBRAW_DECODER_4COMPONENT;
413
else if (load_raw == &LibRaw::lossless_jpeg_load_raw)
416
d_info->decoder_name = "lossless_jpeg_load_raw()";
417
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD | LIBRAW_DECODER_HASCURVE;
419
else if (load_raw == &LibRaw::minolta_rd175_load_raw )
422
d_info->decoder_name = "minolta_rd175_load_raw()";
423
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
425
else if (load_raw == &LibRaw::nikon_compressed_load_raw)
428
d_info->decoder_name = "nikon_compressed_load_raw()";
429
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
431
else if (load_raw == &LibRaw::nokia_load_raw )
434
d_info->decoder_name = "nokia_load_raw()";
435
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
437
else if (load_raw == &LibRaw::olympus_load_raw )
439
d_info->decoder_name = "olympus_load_raw()";
440
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
442
else if (load_raw == &LibRaw::packed_load_raw )
444
d_info->decoder_name = "packed_load_raw()";
445
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
447
else if (load_raw == &LibRaw::panasonic_load_raw )
449
d_info->decoder_name = "panasonic_load_raw()";
450
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
452
else if (load_raw == &LibRaw::pentax_load_raw )
454
d_info->decoder_name = "pentax_load_raw()";
455
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
457
else if (load_raw == &LibRaw::phase_one_load_raw )
459
d_info->decoder_name = "phase_one_load_raw()";
460
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
462
else if (load_raw == &LibRaw::phase_one_load_raw_c )
464
d_info->decoder_name = "phase_one_load_raw_c()";
465
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
467
else if (load_raw == &LibRaw::quicktake_100_load_raw )
470
d_info->decoder_name = "quicktake_100_load_raw()";
471
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
473
else if (load_raw == &LibRaw::rollei_load_raw )
476
d_info->decoder_name = "rollei_load_raw()";
477
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
479
else if (load_raw == &LibRaw::sinar_4shot_load_raw )
482
d_info->decoder_name = "sinar_4shot_load_raw()";
483
d_info->decoder_flags = LIBRAW_DECODER_4COMPONENT;
485
else if (load_raw == &LibRaw::smal_v6_load_raw )
488
d_info->decoder_name = "smal_v6_load_raw()";
489
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
491
else if (load_raw == &LibRaw::smal_v9_load_raw )
494
d_info->decoder_name = "smal_v9_load_raw()";
495
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
497
else if (load_raw == &LibRaw::sony_load_raw )
499
d_info->decoder_name = "sony_load_raw()";
500
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
502
else if (load_raw == &LibRaw::sony_arw_load_raw )
504
d_info->decoder_name = "sony_arw_load_raw()";
505
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
507
else if (load_raw == &LibRaw::sony_arw2_load_raw )
509
d_info->decoder_name = "sony_arw2_load_raw()";
510
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
511
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
513
else if (load_raw == &LibRaw::unpacked_load_raw )
515
d_info->decoder_name = "unpacked_load_raw()";
516
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD | LIBRAW_DECODER_USEBAYER2;
518
else if (load_raw == &LibRaw::redcine_load_raw)
520
d_info->decoder_name = "redcine_load_raw()";
521
d_info->decoder_flags = LIBRAW_DECODER_FLATFIELD;
522
d_info->decoder_flags |= LIBRAW_DECODER_HASCURVE;
526
d_info->decoder_name = "Unknown unpack function";
527
d_info->decoder_flags = LIBRAW_DECODER_NOTSET;
529
return LIBRAW_SUCCESS;
532
int LibRaw::adjust_maximum()
536
float auto_threshold;
538
if(O.adjust_maximum_thr < 0.00001)
539
return LIBRAW_SUCCESS;
540
else if (O.adjust_maximum_thr > 0.99999)
541
auto_threshold = LIBRAW_DEFAULT_ADJUST_MAXIMUM_THRESHOLD;
543
auto_threshold = O.adjust_maximum_thr;
546
real_max = C.channel_maximum[0];
547
for(i = 1; i< 4; i++)
548
if(real_max < C.channel_maximum[i])
549
real_max = C.channel_maximum[i];
551
if (real_max > 0 && real_max < C.maximum && real_max > C.maximum* auto_threshold)
553
C.maximum = real_max;
555
return LIBRAW_SUCCESS;
559
void LibRaw:: merror (void *ptr, const char *where)
562
if(callbacks.mem_cb)(*callbacks.mem_cb)(callbacks.memcb_data,
563
libraw_internal_data.internal_data.input
564
?libraw_internal_data.internal_data.input->fname()
567
throw LIBRAW_EXCEPTION_ALLOC;
572
int LibRaw::open_file(const char *fname, INT64 max_buf_size)
577
return LIBRAW_IO_ERROR;
578
int big = (st.st_size > max_buf_size)?1:0;
581
if(_stati64(fname,&st))
582
return LIBRAW_IO_ERROR;
583
int big = (st.st_size > max_buf_size)?1:0;
586
LibRaw_abstract_datastream *stream;
589
stream = new LibRaw_bigfile_datastream(fname);
591
stream = new LibRaw_file_datastream(fname);
594
catch (std::bad_alloc)
597
return LIBRAW_UNSUFFICIENT_MEMORY;
602
return LIBRAW_IO_ERROR;
604
ID.input_internal = 0; // preserve from deletion on error
605
int ret = open_datastream(stream);
606
if (ret == LIBRAW_SUCCESS)
608
ID.input_internal =1 ; // flag to delete datastream on recycle
613
ID.input_internal = 0;
618
int LibRaw::open_buffer(void *buffer, size_t size)
620
// this stream will close on recycle()
621
if(!buffer || buffer==(void*)-1)
622
return LIBRAW_IO_ERROR;
624
LibRaw_buffer_datastream *stream;
626
stream = new LibRaw_buffer_datastream(buffer,size);
628
catch (std::bad_alloc)
631
return LIBRAW_UNSUFFICIENT_MEMORY;
636
return LIBRAW_IO_ERROR;
638
ID.input_internal = 0; // preserve from deletion on error
639
int ret = open_datastream(stream);
640
if (ret == LIBRAW_SUCCESS)
642
ID.input_internal =1 ; // flag to delete datastream on recycle
647
ID.input_internal = 0;
653
int LibRaw::open_datastream(LibRaw_abstract_datastream *stream)
659
return LIBRAW_IO_ERROR;
664
SET_PROC_FLAG(LIBRAW_PROGRESS_OPEN);
666
if (O.use_camera_matrix < 0)
667
O.use_camera_matrix = O.use_camera_wb;
674
IO.fheight = S.height;
675
S.iwidth = S.width = IO.fuji_width << (int)(!libraw_internal_data.unpacker_data.fuji_layout);
676
S.iheight = S.height = S.raw_height;
677
S.raw_height += 2*S.top_margin;
682
if(C.profile) free(C.profile);
683
C.profile = malloc(C.profile_length);
684
merror(C.profile,"LibRaw::open_file()");
685
ID.input->seek(ID.profile_offset,SEEK_SET);
686
ID.input->read(C.profile,C.profile_length,1);
689
SET_PROC_FLAG(LIBRAW_PROGRESS_IDENTIFY);
691
catch ( LibRaw_exceptions err) {
692
EXCEPTION_HANDLER(err);
694
catch (std::exception ee) {
695
EXCEPTION_HANDLER(LIBRAW_EXCEPTION_IO_CORRUPT);
699
return LIBRAW_FILE_UNSUPPORTED;
702
write_fun = &LibRaw::write_ppm_tiff;
704
if (load_raw == &LibRaw::kodak_ycbcr_load_raw)
706
S.height += S.height & 1;
707
S.width += S.width & 1;
710
IO.shrink = P1.filters && (O.half_size ||
711
((O.threshold || O.aber[0] != 1 || O.aber[2] != 1) ));
713
S.iheight = (S.height + IO.shrink) >> IO.shrink;
714
S.iwidth = (S.width + IO.shrink) >> IO.shrink;
716
// Save color,sizes and internal data into raw_image fields
717
memmove(&imgdata.rawdata.color,&imgdata.color,sizeof(imgdata.color));
718
memmove(&imgdata.rawdata.sizes,&imgdata.sizes,sizeof(imgdata.sizes));
719
memmove(&imgdata.rawdata.iparams,&imgdata.idata,sizeof(imgdata.idata));
720
memmove(&imgdata.rawdata.ioparams,&libraw_internal_data.internal_output_params,sizeof(libraw_internal_data.internal_output_params));
722
SET_PROC_FLAG(LIBRAW_PROGRESS_SIZE_ADJUST);
725
return LIBRAW_SUCCESS;
728
int LibRaw::unpack(void)
730
CHECK_ORDER_HIGH(LIBRAW_PROGRESS_LOAD_RAW);
731
CHECK_ORDER_LOW(LIBRAW_PROGRESS_IDENTIFY);
734
RUN_CALLBACK(LIBRAW_PROGRESS_LOAD_RAW,0,2);
735
if (O.shot_select >= P1.raw_count)
736
return LIBRAW_REQUEST_FOR_NONEXISTENT_IMAGE;
739
return LIBRAW_UNSPECIFIED_ERROR;
741
if (O.use_camera_matrix && C.cmatrix[0][0] > 0.25)
743
memcpy (C.rgb_cam, C.cmatrix, sizeof (C.cmatrix));
746
// already allocated ?
753
if (libraw_internal_data.unpacker_data.meta_length)
755
libraw_internal_data.internal_data.meta_data =
756
(char *) malloc (libraw_internal_data.unpacker_data.meta_length);
757
merror (libraw_internal_data.internal_data.meta_data, "LibRaw::unpack()");
759
ID.input->seek(libraw_internal_data.unpacker_data.data_offset, SEEK_SET);
760
int save_document_mode = O.document_mode;
763
libraw_decoder_info_t decoder_info;
764
get_decoder_info(&decoder_info);
766
int save_iwidth = S.iwidth, save_iheight = S.iheight, save_shrink = IO.shrink;
768
int rwidth = S.raw_width, rheight = S.raw_height;
771
// adjust non-Fuji allocation
772
if(rwidth < S.width + S.left_margin)
773
rwidth = S.width + S.left_margin;
774
if(rheight < S.height + S.top_margin)
775
rheight = S.height + S.top_margin;
778
if(decoder_info.decoder_flags & LIBRAW_DECODER_FLATFIELD)
780
imgdata.rawdata.raw_alloc = malloc(rwidth*rheight*sizeof(imgdata.rawdata.raw_image[0]));
781
imgdata.rawdata.raw_image = (ushort*) imgdata.rawdata.raw_alloc;
783
else if (decoder_info.decoder_flags & LIBRAW_DECODER_4COMPONENT)
788
imgdata.rawdata.raw_alloc = calloc(rwidth*rheight,sizeof(*imgdata.rawdata.color_image));
789
imgdata.rawdata.color_image = (ushort(*)[4]) imgdata.rawdata.raw_alloc;
791
else if (decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
793
// sRAW and Foveon only, so extra buffer size is just 1/4
794
// Legacy converters does not supports half mode!
798
// allocate image as temporary buffer, size
799
imgdata.rawdata.raw_alloc = calloc(S.iwidth*S.iheight,sizeof(*imgdata.image));
800
imgdata.image = (ushort (*)[4]) imgdata.rawdata.raw_alloc;
808
if( decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
811
imgdata.rawdata.color_image = (ushort (*)[4]) imgdata.rawdata.raw_alloc;
814
// calculate channel maximum
816
for(int c=0;c<4;c++) C.channel_maximum[c] = 0;
817
if(decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
819
for(int rc = 0; rc < S.iwidth*S.iheight; rc++)
821
if(C.channel_maximum[0]<imgdata.rawdata.color_image[rc][0])
822
C.channel_maximum[0]=imgdata.rawdata.color_image[rc][0];
823
if(C.channel_maximum[1]<imgdata.rawdata.color_image[rc][1])
824
C.channel_maximum[1]=imgdata.rawdata.color_image[rc][1];
825
if(C.channel_maximum[2]<imgdata.rawdata.color_image[rc][2])
826
C.channel_maximum[2]=imgdata.rawdata.color_image[rc][2];
827
if(C.channel_maximum[3]<imgdata.rawdata.color_image[rc][3])
828
C.channel_maximum[3]=imgdata.rawdata.color_image[rc][3];
831
else if(decoder_info.decoder_flags & LIBRAW_DECODER_4COMPONENT)
833
for(int row = S.top_margin; row < S.height+S.top_margin; row++)
834
for(int col = S.left_margin; col < S.width+S.left_margin; col++)
836
int rc = row*S.raw_width+col;
837
if(C.channel_maximum[0]<imgdata.rawdata.color_image[rc][0])
838
C.channel_maximum[0]=imgdata.rawdata.color_image[rc][0];
839
if(C.channel_maximum[1]<imgdata.rawdata.color_image[rc][1])
840
C.channel_maximum[1]=imgdata.rawdata.color_image[rc][1];
841
if(C.channel_maximum[2]<imgdata.rawdata.color_image[rc][2])
842
C.channel_maximum[2]=imgdata.rawdata.color_image[rc][2];
843
if(C.channel_maximum[3]<imgdata.rawdata.color_image[rc][3])
844
C.channel_maximum[3]=imgdata.rawdata.color_image[rc][4];
847
else if (decoder_info.decoder_flags & LIBRAW_DECODER_FLATFIELD)
849
for(int row = 0; row < S.height; row++)
852
for (int xx=0;xx<4;xx++)
853
colors[xx] = COLOR(row,xx);
854
for(int col = 0; col < S.width; col++)
856
int cc = colors[col&3];
857
if(C.channel_maximum[cc]
858
< imgdata.rawdata.raw_image[(row+S.top_margin)*S.raw_width
859
+(col+S.left_margin)])
860
C.channel_maximum[cc] =
861
imgdata.rawdata.raw_image[(row+S.top_margin)*S.raw_width
862
+(col+S.left_margin)];
867
// recover image sizes
868
S.iwidth = save_iwidth;
869
S.iheight = save_iheight;
870
IO.shrink = save_shrink;
873
if(imgdata.rawdata.ph1_black)
874
C.ph1_black = imgdata.rawdata.ph1_black;
875
O.document_mode = save_document_mode;
877
// adjust black to possible maximum
878
unsigned int i = C.cblack[3];
881
if (i > C.cblack[c]) i = C.cblack[c];
887
// Save color,sizes and internal data into raw_image fields
888
memmove(&imgdata.rawdata.color,&imgdata.color,sizeof(imgdata.color));
889
memmove(&imgdata.rawdata.sizes,&imgdata.sizes,sizeof(imgdata.sizes));
890
memmove(&imgdata.rawdata.iparams,&imgdata.idata,sizeof(imgdata.idata));
891
memmove(&imgdata.rawdata.ioparams,&libraw_internal_data.internal_output_params,sizeof(libraw_internal_data.internal_output_params));
893
SET_PROC_FLAG(LIBRAW_PROGRESS_LOAD_RAW);
894
RUN_CALLBACK(LIBRAW_PROGRESS_LOAD_RAW,1,2);
898
catch ( LibRaw_exceptions err) {
899
EXCEPTION_HANDLER(err);
901
catch (std::exception ee) {
902
EXCEPTION_HANDLER(LIBRAW_EXCEPTION_IO_CORRUPT);
906
void LibRaw::free_image(void)
912
imgdata.progress_flags
913
= LIBRAW_PROGRESS_START|LIBRAW_PROGRESS_OPEN
914
|LIBRAW_PROGRESS_IDENTIFY|LIBRAW_PROGRESS_SIZE_ADJUST|LIBRAW_PROGRESS_LOAD_RAW;
919
void LibRaw::raw2image_start()
921
// restore color,sizes and internal data into raw_image fields
922
memmove(&imgdata.color,&imgdata.rawdata.color,sizeof(imgdata.color));
923
memmove(&imgdata.sizes,&imgdata.rawdata.sizes,sizeof(imgdata.sizes));
924
memmove(&imgdata.idata,&imgdata.rawdata.iparams,sizeof(imgdata.idata));
925
memmove(&libraw_internal_data.internal_output_params,&imgdata.rawdata.ioparams,sizeof(libraw_internal_data.internal_output_params));
927
if (O.user_flip >= 0)
928
S.flip = O.user_flip;
930
switch ((S.flip+3600) % 360)
932
case 270: S.flip = 5; break;
933
case 180: S.flip = 3; break;
934
case 90: S.flip = 6; break;
937
// adjust for half mode!
938
IO.shrink = P1.filters && (O.half_size ||
939
((O.threshold || O.aber[0] != 1 || O.aber[2] != 1) ));
941
S.iheight = (S.height + IO.shrink) >> IO.shrink;
942
S.iwidth = (S.width + IO.shrink) >> IO.shrink;
944
if (O.user_black >= 0)
945
C.black = O.user_black;
948
// Same as raw2image, but
949
// 1) Do raw2image and rotate_fuji_raw in one pass
950
// 2) Do raw2image and cropping in one pass
952
#define MIN(a,b) ((a) < (b) ? (a) : (b))
954
int LibRaw::raw2image_ex(void)
956
CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
962
unsigned save_filters = imgdata.idata.filters;
963
unsigned save_width = S.width;
964
if (~O.cropbox[2] && ~O.cropbox[3])
969
crop[c] = O.cropbox[c];
975
crop[0] = (crop[0]/4)*4;
976
crop[1] = (crop[1]/4)*4;
979
crop[2] = MIN (crop[2], (signed) S.width-crop[0]);
980
crop[3] = MIN (crop[3], (signed) S.height-crop[1]);
981
if (crop[2] <= 0 || crop[3] <= 0)
982
throw LIBRAW_EXCEPTION_BAD_CROP;
985
S.left_margin+=crop[0];
986
S.top_margin+=crop[1];
990
S.iheight = (S.height + IO.shrink) >> IO.shrink;
991
S.iwidth = (S.width + IO.shrink) >> IO.shrink;
992
if(!IO.fwidth && imgdata.idata.filters)
994
for (filt=c=0; c < 16; c++)
995
filt |= FC((c >> 1)+(crop[1]),
996
(c & 1)+(crop[0])) << c*2;
997
imgdata.idata.filters = filt;
1003
ushort fiwidth,fiheight;
1006
IO.fuji_width = S.width >> !libraw_internal_data.unpacker_data.fuji_layout;
1007
IO.fwidth = (S.height >> libraw_internal_data.unpacker_data.fuji_layout) + IO.fuji_width;
1008
IO.fheight = IO.fwidth - 1;
1011
fiheight = (IO.fheight + IO.shrink) >> IO.shrink;
1012
fiwidth = (IO.fwidth + IO.shrink) >> IO.shrink;
1015
imgdata.image = (ushort (*)[4])realloc(imgdata.image,fiheight*fiwidth*sizeof (*imgdata.image));
1016
memset(imgdata.image,0,fiheight*fiwidth *sizeof (*imgdata.image));
1019
imgdata.image = (ushort (*)[4]) calloc (fiheight*fiwidth, sizeof (*imgdata.image));
1020
merror (imgdata.image, "raw2image_ex()");
1024
cblk[i] = C.cblack[i]+C.black;
1025
ZERO(C.channel_maximum);
1028
for(row=0;row<S.height;row++)
1030
for(col=0;col<S.width;col++)
1033
if (libraw_internal_data.unpacker_data.fuji_layout) {
1034
r = IO.fuji_width - 1 - col + (row >> 1);
1035
c = col + ((row+1) >> 1);
1037
r = IO.fuji_width - 1 + row - (col >> 1);
1038
c = row + ((col+1) >> 1);
1041
int val = imgdata.rawdata.raw_image[(row+S.top_margin)*S.raw_width
1042
+(col+S.left_margin)];
1043
int cc = FCF(row,col);
1048
imgdata.image[((r) >> IO.shrink)*fiwidth + ((c) >> IO.shrink)][cc] = val;
1049
if(C.channel_maximum[cc] < val) C.channel_maximum[cc] = val;
1052
C.maximum -= C.black;
1056
// restore fuji sizes!
1057
S.height = IO.fheight;
1058
S.width = IO.fwidth;
1059
S.iheight = (S.height + IO.shrink) >> IO.shrink;
1060
S.iwidth = (S.width + IO.shrink) >> IO.shrink;
1061
S.raw_height -= 2*S.top_margin;
1068
imgdata.image = (ushort (*)[4]) realloc (imgdata.image,S.iheight*S.iwidth
1069
*sizeof (*imgdata.image));
1070
memset(imgdata.image,0,S.iheight*S.iwidth *sizeof (*imgdata.image));
1073
imgdata.image = (ushort (*)[4]) calloc (S.iheight*S.iwidth, sizeof (*imgdata.image));
1075
merror (imgdata.image, "raw2image_ex()");
1077
libraw_decoder_info_t decoder_info;
1078
get_decoder_info(&decoder_info);
1081
if(decoder_info.decoder_flags & LIBRAW_DECODER_FLATFIELD)
1083
if(decoder_info.decoder_flags & LIBRAW_DECODER_USEBAYER2)
1084
#if defined(LIBRAW_USE_OPENMP)
1085
#pragma omp parallel for default(shared)
1087
for(int row = 0; row < S.height; row++)
1088
for(int col = 0; col < S.width; col++)
1089
imgdata.image[(row >> IO.shrink)*S.iwidth + (col>>IO.shrink)][fc(row,col)]
1090
= imgdata.rawdata.raw_image[(row+S.top_margin)*S.raw_width
1091
+(col+S.left_margin)];
1093
#if defined(LIBRAW_USE_OPENMP)
1094
#pragma omp parallel for default(shared)
1096
for(int row = 0; row < S.height; row++)
1099
for (int xx=0;xx<2;xx++)
1100
colors[xx] = COLOR(row,xx);
1101
for(int col = 0; col < S.width; col++)
1103
int cc = colors[col&1];
1104
imgdata.image[(row >> IO.shrink)*S.iwidth + (col>>IO.shrink)][cc] =
1105
imgdata.rawdata.raw_image[(row+S.top_margin)*S.raw_width
1106
+(col+S.left_margin)];
1110
else if (decoder_info.decoder_flags & LIBRAW_DECODER_4COMPONENT)
1112
#define FC0(row,col) (save_filters >> ((((row) << 1 & 14) + ((col) & 1)) << 1) & 3)
1114
#if defined(LIBRAW_USE_OPENMP)
1115
#pragma omp parallel for default(shared)
1117
for(int row = 0; row < S.height; row++)
1118
for(int col = 0; col < S.width; col++)
1119
imgdata.image[(row >> IO.shrink)*S.iwidth + (col>>IO.shrink)][FC(row,col)]
1120
= imgdata.rawdata.color_image[(row+S.top_margin)*S.raw_width
1122
[FC0(row+S.top_margin,col+S.left_margin)];
1125
#if defined(LIBRAW_USE_OPENMP)
1126
#pragma omp parallel for default(shared)
1128
for(int row = 0; row < S.height; row++)
1129
memmove(&imgdata.image[row*S.width],
1130
&imgdata.rawdata.color_image[(row+S.top_margin)*S.raw_width+S.left_margin],
1131
S.width*sizeof(*imgdata.image));
1133
else if(decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
1136
#if defined(LIBRAW_USE_OPENMP)
1137
#pragma omp parallel for default(shared)
1139
for(int row = 0; row < S.height; row++)
1140
memmove(&imgdata.image[row*S.width],
1141
&imgdata.rawdata.color_image[(row+S.top_margin)*save_width+S.left_margin],
1142
S.width*sizeof(*imgdata.image));
1145
memmove(imgdata.image,imgdata.rawdata.color_image,
1146
S.width*S.height*sizeof(*imgdata.image));
1149
if(imgdata.rawdata.use_ph1_correct) // Phase one unpacked!
1150
phase_one_correct();
1152
return LIBRAW_SUCCESS;
1160
int LibRaw::raw2image(void)
1163
CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
1168
// free and re-allocate image bitmap
1171
imgdata.image = (ushort (*)[4]) realloc (imgdata.image,S.iheight*S.iwidth *sizeof (*imgdata.image));
1172
memset(imgdata.image,0,S.iheight*S.iwidth *sizeof (*imgdata.image));
1175
imgdata.image = (ushort (*)[4]) calloc (S.iheight*S.iwidth, sizeof (*imgdata.image));
1177
merror (imgdata.image, "raw2image()");
1179
libraw_decoder_info_t decoder_info;
1180
get_decoder_info(&decoder_info);
1182
// Move saved bitmap to imgdata.image
1183
if(decoder_info.decoder_flags & LIBRAW_DECODER_FLATFIELD)
1185
if(decoder_info.decoder_flags & LIBRAW_DECODER_USEBAYER2)
1187
for(int row = 0; row < S.height; row++)
1188
for(int col = 0; col < S.width; col++)
1189
imgdata.image[(row >> IO.shrink)*S.iwidth + (col>>IO.shrink)][fc(row,col)]
1190
= imgdata.rawdata.raw_image[(row+S.top_margin)*S.raw_width
1191
+(col+S.left_margin)];
1195
for(int row = 0; row < S.height; row++)
1198
for (int xx=0;xx<4;xx++)
1199
colors[xx] = COLOR(row,xx);
1200
for(int col = 0; col < S.width; col++)
1202
int cc = colors[col&3];
1203
imgdata.image[(row >> IO.shrink)*S.iwidth + (col>>IO.shrink)][cc] =
1204
imgdata.rawdata.raw_image[(row+S.top_margin)*S.raw_width+(col
1210
else if (decoder_info.decoder_flags & LIBRAW_DECODER_4COMPONENT)
1214
for(int row = 0; row < S.height; row++)
1215
for(int col = 0; col < S.width; col++)
1217
int cc = FC(row,col);
1218
imgdata.image[(row >> IO.shrink)*S.iwidth + (col>>IO.shrink)][cc]
1219
= imgdata.rawdata.color_image[(row+S.top_margin)*S.raw_width
1220
+S.left_margin+col][cc];
1224
for(int row = 0; row < S.height; row++)
1225
memmove(&imgdata.image[row*S.width],
1226
&imgdata.rawdata.color_image[(row+S.top_margin)*S.raw_width+S.left_margin],
1227
S.width*sizeof(*imgdata.image));
1229
else if(decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
1231
// legacy is always 4channel and not shrinked!
1232
memmove(imgdata.image,imgdata.rawdata.color_image,S.width*S.height*sizeof(*imgdata.image));
1235
if(imgdata.rawdata.use_ph1_correct) // Phase one unpacked!
1236
phase_one_correct();
1238
// hack - clear later flags!
1239
imgdata.progress_flags
1240
= LIBRAW_PROGRESS_START|LIBRAW_PROGRESS_OPEN
1241
|LIBRAW_PROGRESS_IDENTIFY|LIBRAW_PROGRESS_SIZE_ADJUST|LIBRAW_PROGRESS_LOAD_RAW;
1244
catch ( LibRaw_exceptions err) {
1245
EXCEPTION_HANDLER(err);
1250
int LibRaw::dcraw_document_mode_processing(void)
1252
// CHECK_ORDER_HIGH(LIBRAW_PROGRESS_PRE_INTERPOLATE);
1253
CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
1259
if (~O.cropbox[2] && ~O.cropbox[3])
1262
raw2image_ex(); // raw2image+crop+rotate_fuji_raw
1267
SET_PROC_FLAG(LIBRAW_PROGRESS_REMOVE_ZEROES);
1273
O.document_mode = 2;
1277
// filter image data for foveon document mode
1278
short *iptr = (short *)imgdata.image;
1279
for (int i=0; i < S.height*S.width*4; i++)
1281
if ((short) iptr[i] < 0)
1284
SET_PROC_FLAG(LIBRAW_PROGRESS_FOVEON_INTERPOLATE);
1287
O.use_fuji_rotate = 0;
1289
if(O.bad_pixels && no_crop)
1291
bad_pixels(O.bad_pixels);
1292
SET_PROC_FLAG(LIBRAW_PROGRESS_BAD_PIXELS);
1294
if (O.dark_frame && no_crop)
1296
subtract (O.dark_frame);
1297
SET_PROC_FLAG(LIBRAW_PROGRESS_DARK_FRAME);
1304
C.maximum = O.user_sat;
1307
SET_PROC_FLAG(LIBRAW_PROGRESS_PRE_INTERPOLATE);
1309
if (libraw_internal_data.internal_output_params.mix_green)
1312
for (P1.colors=3, i=0; i < S.height*S.width; i++)
1313
imgdata.image[i][1] = (imgdata.image[i][1] + imgdata.image[i][3]) >> 1;
1315
SET_PROC_FLAG(LIBRAW_PROGRESS_MIX_GREEN);
1317
if (!P1.is_foveon && P1.colors == 3)
1319
SET_PROC_FLAG(LIBRAW_PROGRESS_MEDIAN_FILTER);
1321
if (!P1.is_foveon && O.highlight == 2)
1324
if (!P1.is_foveon && O.highlight > 2)
1325
recover_highlights();
1326
SET_PROC_FLAG(LIBRAW_PROGRESS_HIGHLIGHTS);
1328
if (O.use_fuji_rotate)
1330
SET_PROC_FLAG(LIBRAW_PROGRESS_FUJI_ROTATE);
1332
if(O.camera_profile)
1334
apply_profile(O.camera_profile,O.output_profile);
1335
SET_PROC_FLAG(LIBRAW_PROGRESS_APPLY_PROFILE);
1338
if(!libraw_internal_data.output_data.histogram)
1340
libraw_internal_data.output_data.histogram = (int (*)[LIBRAW_HISTOGRAM_SIZE]) malloc(sizeof(*libraw_internal_data.output_data.histogram)*4);
1341
merror(libraw_internal_data.output_data.histogram,"LibRaw::dcraw_document_mode_processing()");
1344
SET_PROC_FLAG(LIBRAW_PROGRESS_CONVERT_RGB);
1346
if (O.use_fuji_rotate)
1348
SET_PROC_FLAG(LIBRAW_PROGRESS_STRETCH);
1352
catch ( LibRaw_exceptions err) {
1353
EXCEPTION_HANDLER(err);
1360
libraw_processed_image_t * LibRaw::dcraw_make_mem_thumb(int *errcode)
1366
if(errcode) *errcode= LIBRAW_NO_THUMBNAIL;
1370
if(errcode) *errcode= LIBRAW_OUT_OF_ORDER_CALL;
1375
if (T.tformat == LIBRAW_THUMBNAIL_BITMAP)
1377
libraw_processed_image_t * ret =
1378
(libraw_processed_image_t *)::malloc(sizeof(libraw_processed_image_t)+T.tlength);
1382
if(errcode) *errcode= ENOMEM;
1386
memset(ret,0,sizeof(libraw_processed_image_t));
1387
ret->type = LIBRAW_IMAGE_BITMAP;
1388
ret->height = T.theight;
1389
ret->width = T.twidth;
1392
ret->data_size = T.tlength;
1393
memmove(ret->data,T.thumb,T.tlength);
1394
if(errcode) *errcode= 0;
1397
else if (T.tformat == LIBRAW_THUMBNAIL_JPEG)
1401
if(strcmp(T.thumb+6,"Exif")) mk_exif = 1;
1403
int dsize = T.tlength + mk_exif * (sizeof(exif)+sizeof(tiff_hdr));
1405
libraw_processed_image_t * ret =
1406
(libraw_processed_image_t *)::malloc(sizeof(libraw_processed_image_t)+dsize);
1410
if(errcode) *errcode= ENOMEM;
1414
memset(ret,0,sizeof(libraw_processed_image_t));
1416
ret->type = LIBRAW_IMAGE_JPEG;
1417
ret->data_size = dsize;
1419
ret->data[0] = 0xff;
1420
ret->data[1] = 0xd8;
1424
memcpy (exif, "\xff\xe1 Exif\0\0", 10);
1425
exif[1] = htons (8 + sizeof th);
1426
memmove(ret->data+2,exif,sizeof(exif));
1428
memmove(ret->data+(2+sizeof(exif)),&th,sizeof(th));
1429
memmove(ret->data+(2+sizeof(exif)+sizeof(th)),T.thumb+2,T.tlength-2);
1433
memmove(ret->data+2,T.thumb+2,T.tlength-2);
1435
if(errcode) *errcode= 0;
1441
if(errcode) *errcode= LIBRAW_UNSUPPORTED_THUMBNAIL;
1450
// macros for copying pixels to either BGR or RGB formats
1451
#define FORBGR for(c=P1.colors-1; c >=0 ; c--)
1452
#define FORRGB for(c=0; c < P1.colors ; c++)
1454
void LibRaw::get_mem_image_format(int* width, int* height, int* colors, int* bps) const
1465
*colors = P1.colors;
1466
*bps = O.output_bps;
1469
int LibRaw::copy_mem_image(void* scan0, int stride, int bgr)
1472
// the image memory pointed to by scan0 is assumed to be in the format returned by get_mem_image_format
1473
if((imgdata.progress_flags & LIBRAW_PROGRESS_THUMB_MASK) < LIBRAW_PROGRESS_PRE_INTERPOLATE)
1474
return LIBRAW_OUT_OF_ORDER_CALL;
1476
if(libraw_internal_data.output_data.histogram)
1478
int perc, val, total, t_white=0x2000,c;
1479
perc = S.width * S.height * 0.01; /* 99th percentile white level */
1480
if (IO.fuji_width) perc /= 2;
1481
if (!((O.highlight & ~2) || O.no_auto_bright))
1482
for (t_white=c=0; c < P1.colors; c++) {
1483
for (val=0x2000, total=0; --val > 32; )
1484
if ((total += libraw_internal_data.output_data.histogram[c][val]) > perc) break;
1485
if (t_white < val) t_white = val;
1487
gamma_curve (O.gamm[0], O.gamm[1], 2, (t_white << 3)/O.bright);
1490
int s_iheight = S.iheight;
1491
int s_iwidth = S.iwidth;
1492
int s_width = S.width;
1493
int s_hwight = S.height;
1495
S.iheight = S.height;
1498
if (S.flip & 4) SWAP(S.height,S.width);
1501
int c, row, col, soff, rstep, cstep;
1503
soff = flip_index (0, 0);
1504
cstep = flip_index (0, 1) - soff;
1505
rstep = flip_index (1, 0) - flip_index (0, S.width);
1507
for (row=0; row < S.height; row++, soff += rstep)
1509
uchar *bufp = ((uchar*)scan0)+row*stride;
1510
ppm2 = (ushort*) (ppm = bufp);
1511
// keep trivial decisions in the outer loop for speed
1513
if (O.output_bps == 8) {
1514
for (col=0; col < S.width; col++, soff += cstep)
1515
FORBGR *ppm++ = imgdata.color.curve[imgdata.image[soff][c]]>>8;
1518
for (col=0; col < S.width; col++, soff += cstep)
1519
FORBGR *ppm2++ = imgdata.color.curve[imgdata.image[soff][c]];
1523
if (O.output_bps == 8) {
1524
for (col=0; col < S.width; col++, soff += cstep)
1525
FORRGB *ppm++ = imgdata.color.curve[imgdata.image[soff][c]]>>8;
1528
for (col=0; col < S.width; col++, soff += cstep)
1529
FORRGB *ppm2++ = imgdata.color.curve[imgdata.image[soff][c]];
1533
// bufp += stride; // go to the next line
1536
S.iheight = s_iheight;
1537
S.iwidth = s_iwidth;
1539
S.height = s_hwight;
1550
libraw_processed_image_t *LibRaw::dcraw_make_mem_image(int *errcode)
1553
int width, height, colors, bps;
1554
get_mem_image_format(&width, &height, &colors, &bps);
1555
int stride = width * (bps/8) * colors;
1556
unsigned ds = height * stride;
1557
libraw_processed_image_t *ret = (libraw_processed_image_t*)::malloc(sizeof(libraw_processed_image_t)+ds);
1560
if(errcode) *errcode= ENOMEM;
1563
memset(ret,0,sizeof(libraw_processed_image_t));
1566
ret->type = LIBRAW_IMAGE_BITMAP;
1567
ret->height = height;
1569
ret->colors = colors;
1571
ret->data_size = ds;
1572
copy_mem_image(ret->data, stride, 0);
1583
int LibRaw::dcraw_ppm_tiff_writer(const char *filename)
1585
CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
1588
return LIBRAW_OUT_OF_ORDER_CALL;
1592
FILE *f = fopen(filename,"wb");
1598
if(!libraw_internal_data.output_data.histogram)
1600
libraw_internal_data.output_data.histogram =
1601
(int (*)[LIBRAW_HISTOGRAM_SIZE]) malloc(sizeof(*libraw_internal_data.output_data.histogram)*4);
1602
merror(libraw_internal_data.output_data.histogram,"LibRaw::dcraw_ppm_tiff_writer()");
1604
libraw_internal_data.internal_data.output = f;
1606
SET_PROC_FLAG(LIBRAW_PROGRESS_FLIP);
1607
libraw_internal_data.internal_data.output = NULL;
1611
catch ( LibRaw_exceptions err) {
1613
EXCEPTION_HANDLER(err);
1617
void LibRaw::kodak_thumb_loader()
1619
// some kodak cameras
1620
ushort s_height = S.height, s_width = S.width,s_iwidth = S.iwidth,s_iheight=S.iheight;
1621
int s_colors = P1.colors;
1622
unsigned s_filters = P1.filters;
1623
ushort (*s_image)[4] = imgdata.image;
1626
S.height = T.theight;
1630
if (thumb_load_raw == &CLASS kodak_ycbcr_load_thumb)
1632
S.height += S.height & 1;
1633
S.width += S.width & 1;
1636
imgdata.image = (ushort (*)[4]) calloc (S.iheight*S.iwidth, sizeof (*imgdata.image));
1637
merror (imgdata.image, "LibRaw::kodak_thumb_loader()");
1639
ID.input->seek(ID.toffset, SEEK_SET);
1640
// read kodak thumbnail into T.image[]
1641
(this->*thumb_load_raw)();
1643
// copy-n-paste from image pipe
1644
#define MIN(a,b) ((a) < (b) ? (a) : (b))
1645
#define MAX(a,b) ((a) > (b) ? (a) : (b))
1646
#define LIM(x,min,max) MAX(min,MIN(x,max))
1647
#define CLIP(x) LIM(x,0,65535)
1648
#define SWAP(a,b) { a ^= b; a ^= (b ^= a); }
1650
// from scale_colors
1655
for (dmax=DBL_MAX, c=0; c < 3; c++)
1656
if (dmax > C.pre_mul[c])
1657
dmax = C.pre_mul[c];
1659
for( c=0; c< 3; c++)
1660
scale_mul[c] = (C.pre_mul[c] / dmax) * 65535.0 / C.maximum;
1661
scale_mul[3] = scale_mul[1];
1663
size_t size = S.height * S.width;
1664
for (unsigned i=0; i < size*4 ; i++)
1666
val = imgdata.image[0][i];
1668
val *= scale_mul[i & 3];
1669
imgdata.image[0][i] = CLIP(val);
1673
// from convert_to_rgb
1677
int (*t_hist)[LIBRAW_HISTOGRAM_SIZE] = (int (*)[LIBRAW_HISTOGRAM_SIZE]) calloc(sizeof(*t_hist),4);
1678
merror (t_hist, "LibRaw::kodak_thumb_loader()");
1683
{2.81761312, -1.98369181, 0.166078627, 0},
1684
{-0.111855984, 1.73688626, -0.625030339, 0},
1685
{-0.0379119813, -0.891268849, 1.92918086, 0}
1688
for (img=imgdata.image[0], row=0; row < S.height; row++)
1689
for (col=0; col < S.width; col++, img+=4)
1691
out[0] = out[1] = out[2] = 0;
1695
out[0] += out_cam[0][c] * img[c];
1696
out[1] += out_cam[1][c] * img[c];
1697
out[2] += out_cam[2][c] * img[c];
1700
img[c] = CLIP((int) out[c]);
1701
for(c=0; c<P1.colors;c++)
1702
t_hist[c][img[c] >> 3]++;
1707
int (*save_hist)[LIBRAW_HISTOGRAM_SIZE] = libraw_internal_data.output_data.histogram;
1708
libraw_internal_data.output_data.histogram = t_hist;
1710
// make curve output curve!
1711
ushort (*t_curve) = (ushort*) calloc(sizeof(C.curve),1);
1712
merror (t_curve, "LibRaw::kodak_thumb_loader()");
1713
memmove(t_curve,C.curve,sizeof(C.curve));
1714
memset(C.curve,0,sizeof(C.curve));
1716
int perc, val, total, t_white=0x2000,c;
1718
perc = S.width * S.height * 0.01; /* 99th percentile white level */
1719
if (IO.fuji_width) perc /= 2;
1720
if (!((O.highlight & ~2) || O.no_auto_bright))
1721
for (t_white=c=0; c < P1.colors; c++) {
1722
for (val=0x2000, total=0; --val > 32; )
1723
if ((total += libraw_internal_data.output_data.histogram[c][val]) > perc) break;
1724
if (t_white < val) t_white = val;
1726
gamma_curve (O.gamm[0], O.gamm[1], 2, (t_white << 3)/O.bright);
1729
libraw_internal_data.output_data.histogram = save_hist;
1732
// from write_ppm_tiff - copy pixels into bitmap
1734
S.iheight = S.height;
1736
if (S.flip & 4) SWAP(S.height,S.width);
1738
if(T.thumb) free(T.thumb);
1739
T.thumb = (char*) calloc (S.width * S.height, P1.colors);
1740
merror (T.thumb, "LibRaw::kodak_thumb_loader()");
1741
T.tlength = S.width * S.height * P1.colors;
1743
// from write_tiff_ppm
1745
int soff = flip_index (0, 0);
1746
int cstep = flip_index (0, 1) - soff;
1747
int rstep = flip_index (1, 0) - flip_index (0, S.width);
1749
for (int row=0; row < S.height; row++, soff += rstep)
1751
char *ppm = T.thumb + row*S.width*P1.colors;
1752
for (int col=0; col < S.width; col++, soff += cstep)
1753
for(int c = 0; c < P1.colors; c++)
1754
ppm [col*P1.colors+c] = imgdata.color.curve[imgdata.image[soff][c]]>>8;
1758
memmove(C.curve,t_curve,sizeof(C.curve));
1761
// restore variables
1762
free(imgdata.image);
1763
imgdata.image = s_image;
1768
S.iwidth = s_iwidth;
1769
S.iheight = s_iheight;
1771
T.theight = S.height;
1772
S.height = s_height;
1774
T.tcolors = P1.colors;
1775
P1.colors = s_colors;
1777
P1.filters = s_filters;
1788
// ������� thumbnail �� �����, ������ thumb_format � ������������ � ��������
1789
int LibRaw::unpack_thumb(void)
1791
CHECK_ORDER_LOW(LIBRAW_PROGRESS_IDENTIFY);
1792
CHECK_ORDER_BIT(LIBRAW_PROGRESS_THUMB_LOAD);
1797
return LIBRAW_NO_THUMBNAIL;
1799
else if (thumb_load_raw)
1801
kodak_thumb_loader();
1802
T.tformat = LIBRAW_THUMBNAIL_BITMAP;
1803
SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
1808
ID.input->seek(ID.toffset, SEEK_SET);
1809
if ( write_thumb == &LibRaw::jpeg_thumb)
1811
if(T.thumb) free(T.thumb);
1812
T.thumb = (char *) malloc (T.tlength);
1813
merror (T.thumb, "jpeg_thumb()");
1814
ID.input->read (T.thumb, 1, T.tlength);
1816
T.tformat = LIBRAW_THUMBNAIL_JPEG;
1817
SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
1820
else if (write_thumb == &LibRaw::ppm_thumb)
1822
T.tlength = T.twidth * T.theight*3;
1823
if(T.thumb) free(T.thumb);
1825
T.thumb = (char *) malloc (T.tlength);
1826
merror (T.thumb, "ppm_thumb()");
1828
ID.input->read(T.thumb, 1, T.tlength);
1830
T.tformat = LIBRAW_THUMBNAIL_BITMAP;
1831
SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
1835
else if (write_thumb == &LibRaw::foveon_thumb)
1837
foveon_thumb_loader();
1838
// may return with error, so format is set in
1839
// foveon thumb loader itself
1840
SET_PROC_FLAG(LIBRAW_PROGRESS_THUMB_LOAD);
1843
// else if -- all other write_thumb cases!
1846
return LIBRAW_UNSUPPORTED_THUMBNAIL;
1850
return LIBRAW_UNSUPPORTED_THUMBNAIL;
1852
catch ( LibRaw_exceptions err) {
1853
EXCEPTION_HANDLER(err);
1858
int LibRaw::dcraw_thumb_writer(const char *fname)
1860
// CHECK_ORDER_LOW(LIBRAW_PROGRESS_THUMB_LOAD);
1865
FILE *tfp = fopen(fname,"wb");
1873
return LIBRAW_OUT_OF_ORDER_CALL;
1879
case LIBRAW_THUMBNAIL_JPEG:
1880
jpeg_thumb_writer (tfp,T.thumb,T.tlength);
1882
case LIBRAW_THUMBNAIL_BITMAP:
1883
fprintf (tfp, "P6\n%d %d\n255\n", T.twidth, T.theight);
1884
fwrite (T.thumb, 1, T.tlength, tfp);
1888
return LIBRAW_UNSUPPORTED_THUMBNAIL;
1893
catch ( LibRaw_exceptions err) {
1895
EXCEPTION_HANDLER(err);
1899
int LibRaw::adjust_sizes_info_only(void)
1901
CHECK_ORDER_LOW(LIBRAW_PROGRESS_IDENTIFY);
1904
if (O.use_fuji_rotate)
1908
// restore saved values
1911
S.height = IO.fheight;
1912
S.width = IO.fwidth;
1913
S.iheight = (S.height + IO.shrink) >> IO.shrink;
1914
S.iwidth = (S.width + IO.shrink) >> IO.shrink;
1915
S.raw_height -= 2*S.top_margin;
1916
IO.fheight = IO.fwidth = 0; // prevent repeated calls
1919
IO.fuji_width = (IO.fuji_width - 1 + IO.shrink) >> IO.shrink;
1920
S.iwidth = (ushort)(IO.fuji_width / sqrt(0.5));
1921
S.iheight = (ushort)( (S.iheight - IO.fuji_width) / sqrt(0.5));
1925
if (S.pixel_aspect < 1) S.iheight = (ushort)( S.iheight / S.pixel_aspect + 0.5);
1926
if (S.pixel_aspect > 1) S.iwidth = (ushort) (S.iwidth * S.pixel_aspect + 0.5);
1929
SET_PROC_FLAG(LIBRAW_PROGRESS_FUJI_ROTATE);
1932
unsigned short t = S.iheight;
1935
SET_PROC_FLAG(LIBRAW_PROGRESS_FLIP);
1941
void LibRaw::subtract_black()
1944
#define BAYERC(row,col,c) imgdata.image[((row) >> IO.shrink)*S.iwidth + ((col) >> IO.shrink)][c]
1948
// Phase One compressed format
1950
for(row=0;row<S.height;row++)
1951
for(col=0;col<S.width;col++)
1954
val = BAYERC(row,col,cc)
1955
- C.phase_one_data.t_black
1956
+ C.ph1_black[row+S.top_margin][(col + S.left_margin)
1957
>=C.phase_one_data.split_col];
1959
BAYERC(row,col,cc) = val;
1961
C.maximum -= C.black;
1962
phase_one_correct();
1963
// recalculate channel maximum
1964
ZERO(C.channel_maximum);
1965
for(row=0;row<S.height;row++)
1966
for(col=0;col<S.width;col++)
1969
val = BAYERC(row,col,cc);
1970
if(C.channel_maximum[cc] > val) C.channel_maximum[cc] = val;
1972
// clear P1 black level data
1973
imgdata.color.phase_one_data.t_black = 0;
1978
else if((C.black || C.cblack[0] || C.cblack[1] || C.cblack[2] || C.cblack[3]))
1980
int cblk[4],i,row,col,val,cc;
1982
cblk[i] = C.cblack[i]+C.black;
1983
ZERO(C.channel_maximum);
1985
for(row=0;row<S.height;row++)
1986
for(col=0;col<S.width;col++)
1989
val = BAYERC(row,col,cc);
1994
if(C.channel_maximum[cc] < val) C.channel_maximum[cc] = val;
1995
BAYERC(row,col,cc) = val;
1997
C.maximum -= C.black;
2003
// only calculate channel maximum;
2005
ZERO(C.channel_maximum);
2006
for(row=0;row<S.height;row++)
2007
for(col=0;col<S.width;col++)
2008
for(cc = 0; cc< 4; cc++)
2010
int val = BAYERC(row,col,cc);
2011
if(C.channel_maximum[cc] < val) C.channel_maximum[cc] = val;
2019
void LibRaw::exp_bef(float shift, float smooth)
2022
if(shift>8) shift = 8;
2023
if(shift<0.25) shift = 0.25;
2024
if(smooth < 0.0) smooth = 0.0;
2025
if(smooth > 1.0) smooth = 1.0;
2027
unsigned short *lut = (ushort*)malloc((TBLN+1)*sizeof(unsigned short));
2031
for(int i=0;i<=TBLN;i++)
2032
lut[i] = (unsigned short)((float)i*shift);
2038
float cstops = log(shift)/log(2.0f);
2039
float room = cstops*2;
2040
float roomlin = powf(2.0f,room);
2042
x1 = (x2+1)/roomlin-1;
2044
y2 = x2*(1+(1-smooth)*(shift-1));
2045
float sq3x=powf(x1*x1*x2,1.0f/3.0f);
2046
float B = (y2-y1+shift*(3*x1-3.0f*sq3x)) / (x2+2.0f*x1-3.0f*sq3x);
2047
float A = (shift - B)*3.0f*powf(x1*x1,1.0f/3.0f);
2048
float CC = y2 - A*powf(x2,1.0f/3.0f)-B*x2;
2049
for(int i=0;i<=TBLN;i++)
2052
float Y = A*powf(X,1.0f/3.0f)+B*X+CC;
2054
lut[i] = (unsigned short)((float)i*shift);
2056
lut[i] = Y<0?0:(Y>TBLN?TBLN:(unsigned short)(Y));
2059
for(int i=0; i< S.height*S.width; i++)
2061
imgdata.image[i][0] = lut[imgdata.image[i][0]];
2062
imgdata.image[i][1] = lut[imgdata.image[i][1]];
2063
imgdata.image[i][2] = lut[imgdata.image[i][2]];
2064
imgdata.image[i][3] = lut[imgdata.image[i][3]];
2066
for(int i=0;i<4;i++)
2067
C.channel_maximum[i] = lut[C.channel_maximum[i]];
2068
C.maximum = lut[C.maximum];
2069
// no need to adjust the minumum, black is already subtracted
2072
int LibRaw::dcraw_process(void)
2076
int iterations=-1, dcb_enhance=1, noiserd=0;
2077
int eeci_refine_fl=0, es_med_passes_fl=0;
2078
float cared=0,cablue=0;
2080
float lclean=0,cclean=0;
2086
CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
2087
// CHECK_ORDER_HIGH(LIBRAW_PROGRESS_PRE_INTERPOLATE);
2093
if (~O.cropbox[2] && ~O.cropbox[3])
2096
raw2image_ex(); // raw2image+crop+rotate_fuji_raw + subtract_black for fuji
2098
int save_4color = O.four_color_rgb;
2103
SET_PROC_FLAG(LIBRAW_PROGRESS_REMOVE_ZEROES);
2106
if(!IO.fuji_width) // PhaseOne only, all other cases handled at raw2image_ex()
2110
O.four_color_rgb = 1;
2112
if(O.bad_pixels && no_crop)
2114
bad_pixels(O.bad_pixels);
2115
SET_PROC_FLAG(LIBRAW_PROGRESS_BAD_PIXELS);
2118
if (O.dark_frame && no_crop)
2120
subtract (O.dark_frame);
2121
SET_PROC_FLAG(LIBRAW_PROGRESS_DARK_FRAME);
2125
quality = 2 + !IO.fuji_width;
2127
if (O.user_qual >= 0) quality = O.user_qual;
2131
if (O.user_sat > 0) C.maximum = O.user_sat;
2133
if (P1.is_foveon && !O.document_mode)
2135
foveon_interpolate();
2136
SET_PROC_FLAG(LIBRAW_PROGRESS_FOVEON_INTERPOLATE);
2139
if (O.green_matching && !O.half_size)
2144
if (!P1.is_foveon && O.document_mode < 2)
2147
SET_PROC_FLAG(LIBRAW_PROGRESS_SCALE_COLORS);
2152
SET_PROC_FLAG(LIBRAW_PROGRESS_PRE_INTERPOLATE);
2154
if (O.dcb_iterations >= 0) iterations = O.dcb_iterations;
2155
if (O.dcb_enhance_fl >=0 ) dcb_enhance = O.dcb_enhance_fl;
2156
if (O.fbdd_noiserd >=0 ) noiserd = O.fbdd_noiserd;
2157
if (O.eeci_refine >=0 ) eeci_refine_fl = O.eeci_refine;
2158
if (O.es_med_passes >0 ) es_med_passes_fl = O.es_med_passes;
2160
// LIBRAW_DEMOSAIC_PACK_GPL3
2162
if (!O.half_size && O.cfa_green >0) {thresh=O.green_thresh ;green_equilibrate(thresh);}
2163
if (O.exp_correc >0) {expos=O.exp_shift ; preser=O.exp_preser; exp_bef(expos,preser);}
2164
if (O.ca_correc >0 ) {cablue=O.cablue; cared=O.cared; CA_correct_RT(cablue, cared);}
2165
if (O.cfaline >0 ) {linenoise=O.linenoise; cfa_linedn(linenoise);}
2166
if (O.cfa_clean >0 ) {lclean=O.lclean; cclean=O.cclean; cfa_impulse_gauss(lclean,cclean);}
2168
if (P1.filters && !O.document_mode)
2170
if (noiserd>0 && P1.colors==3 && P1.filters) fbdd(noiserd);
2174
else if (quality == 1 || P1.colors > 3)
2176
else if (quality == 2)
2179
else if (quality == 3)
2180
ahd_interpolate(); // really don't need it here due to fallback op
2182
else if (quality == 4)
2183
dcb(iterations, dcb_enhance);
2185
// LIBRAW_DEMOSAIC_PACK_GPL2
2186
else if (quality == 5)
2187
ahd_interpolate_mod();
2188
else if (quality == 6)
2189
afd_interpolate_pl(2,1);
2190
else if (quality == 7)
2192
else if (quality == 8)
2193
vcd_interpolate(12);
2194
else if (quality == 9)
2195
lmmse_interpolate(1);
2197
// LIBRAW_DEMOSAIC_PACK_GPL3
2198
else if (quality == 10)
2199
amaze_demosaic_RT();
2204
SET_PROC_FLAG(LIBRAW_PROGRESS_INTERPOLATE);
2208
for (P1.colors=3, i=0; i < S.height * S.width; i++)
2209
imgdata.image[i][1] = (imgdata.image[i][1] + imgdata.image[i][3]) >> 1;
2210
SET_PROC_FLAG(LIBRAW_PROGRESS_MIX_GREEN);
2220
if (eeci_refine_fl == 1) refinement();
2221
if (O.med_passes > 0) median_filter_new();
2222
if (es_med_passes_fl > 0) es_median_filter();
2227
SET_PROC_FLAG(LIBRAW_PROGRESS_MEDIAN_FILTER);
2231
if (O.highlight == 2)
2234
SET_PROC_FLAG(LIBRAW_PROGRESS_HIGHLIGHTS);
2237
if (O.highlight > 2)
2239
recover_highlights();
2240
SET_PROC_FLAG(LIBRAW_PROGRESS_HIGHLIGHTS);
2243
if (O.use_fuji_rotate)
2246
SET_PROC_FLAG(LIBRAW_PROGRESS_FUJI_ROTATE);
2249
if(!libraw_internal_data.output_data.histogram)
2251
libraw_internal_data.output_data.histogram = (int (*)[LIBRAW_HISTOGRAM_SIZE]) malloc(sizeof(*libraw_internal_data.output_data.histogram)*4);
2252
merror(libraw_internal_data.output_data.histogram,"LibRaw::dcraw_process()");
2255
if(O.camera_profile)
2257
apply_profile(O.camera_profile,O.output_profile);
2258
SET_PROC_FLAG(LIBRAW_PROGRESS_APPLY_PROFILE);
2263
SET_PROC_FLAG(LIBRAW_PROGRESS_CONVERT_RGB);
2265
if (O.use_fuji_rotate)
2268
SET_PROC_FLAG(LIBRAW_PROGRESS_STRETCH);
2270
O.four_color_rgb = save_4color; // also, restore
2274
catch ( LibRaw_exceptions err) {
2275
EXCEPTION_HANDLER(err);
2279
// Supported cameras:
2280
static const char *static_camera_list[] =
2282
"Adobe Digital Negative (DNG)",
2283
"AgfaPhoto DC-833m",
2284
"Apple QuickTake 100",
2285
"Apple QuickTake 150",
2286
"Apple QuickTake 200",
2293
"Canon PowerShot 600",
2294
"Canon PowerShot A5",
2295
"Canon PowerShot A5 Zoom",
2296
"Canon PowerShot A50",
2297
"Canon PowerShot A460 (CHDK hack)",
2298
"Canon PowerShot A470 (CHDK hack)",
2299
"Canon PowerShot A530 (CHDK hack)",
2300
"Canon PowerShot A570 (CHDK hack)",
2301
"Canon PowerShot A590 (CHDK hack)",
2302
"Canon PowerShot A610 (CHDK hack)",
2303
"Canon PowerShot A620 (CHDK hack)",
2304
"Canon PowerShot A630 (CHDK hack)",
2305
"Canon PowerShot A640 (CHDK hack)",
2306
"Canon PowerShot A650 (CHDK hack)",
2307
"Canon PowerShot A710 IS (CHDK hack)",
2308
"Canon PowerShot A720 IS (CHDK hack)",
2309
"Canon PowerShot Pro70",
2310
"Canon PowerShot Pro90 IS",
2311
"Canon PowerShot Pro1",
2312
"Canon PowerShot G1",
2313
"Canon PowerShot G1 X",
2314
"Canon PowerShot G2",
2315
"Canon PowerShot G3",
2316
"Canon PowerShot G5",
2317
"Canon PowerShot G6",
2318
"Canon PowerShot G7 (CHDK hack)",
2319
"Canon PowerShot G9",
2320
"Canon PowerShot G10",
2321
"Canon PowerShot G11",
2322
"Canon PowerShot G12",
2323
"Canon PowerShot S2 IS (CHDK hack)",
2324
"Canon PowerShot S3 IS (CHDK hack)",
2325
"Canon PowerShot S5 IS (CHDK hack)",
2326
"Canon PowerShot SD300 (CHDK hack)",
2327
"Canon PowerShot S30",
2328
"Canon PowerShot S40",
2329
"Canon PowerShot S45",
2330
"Canon PowerShot S50",
2331
"Canon PowerShot S60",
2332
"Canon PowerShot S70",
2333
"Canon PowerShot S90",
2334
"Canon PowerShot S95",
2335
"Canon PowerShot S100",
2336
"Canon PowerShot SX1 IS",
2337
"Canon PowerShot SX110 IS (CHDK hack)",
2338
"Canon PowerShot SX120 IS (CHDK hack)",
2339
"Canon PowerShot SX20 IS (CHDK hack)",
2340
"Canon PowerShot SX220 HS (CHDK hack)",
2341
"Canon PowerShot SX30 IS (CHDK hack)",
2345
"Canon EOS 5D Mark II",
2346
"Canon EOS 5D Mark III",
2354
"Canon EOS 300D / Digital Rebel / Kiss Digital",
2355
"Canon EOS 350D / Digital Rebel XT / Kiss Digital N",
2356
"Canon EOS 400D / Digital Rebel XTi / Kiss Digital X",
2357
"Canon EOS 450D / Digital Rebel XSi / Kiss Digital X2",
2358
"Canon EOS 500D / Digital Rebel T1i / Kiss Digital X3",
2359
"Canon EOS 550D / Digital Rebel T2i / Kiss Digital X4",
2360
"Canon EOS 600D / Digital Rebel T3i / Kiss Digital X5",
2361
"Canon EOS 1000D / Digital Rebel XS / Kiss Digital F",
2362
"Canon EOS 1100D / Digital Rebel T3 / Kiss Digital X50",
2367
"Canon EOS-1D Mark II",
2368
"Canon EOS-1D Mark II N",
2369
"Canon EOS-1D Mark III",
2370
"Canon EOS-1D Mark IV",
2371
"Canon EOS-1Ds Mark II",
2372
"Canon EOS-1Ds Mark III",
2394
"Casio Exlim Pro 505",
2395
"Casio Exlim Pro 600",
2396
"Casio Exlim Pro 700",
2398
"Creative PC-CAM 600",
2401
"Fuji FinePix E550",
2402
"Fuji FinePix E900",
2403
"Fuji FinePix F700",
2404
"Fuji FinePix F710",
2405
"Fuji FinePix F800",
2406
"Fuji FinePix F810",
2407
"Fuji FinePix S2Pro",
2408
"Fuji FinePix S3Pro",
2409
"Fuji FinePix S5Pro",
2410
"Fuji FinePix S20Pro",
2411
"Fuji FinePix S100FS",
2412
"Fuji FinePix S5000",
2413
"Fuji FinePix S5100/S5500",
2414
"Fuji FinePix S5200/S5600",
2415
"Fuji FinePix S6000fd",
2416
"Fuji FinePix S7000",
2417
"Fuji FinePix S9000/S9500",
2418
"Fuji FinePix S9100/S9600",
2419
"Fuji FinePix S200EXR",
2420
"Fuji FinePix HS10/HS11",
2421
"Fuji FinePix HS20EXR",
2422
"Fuji FinePix HS30EXR",
2423
"Fuji FinePix F550EXR",
2424
"Fuji FinePix F600EXR",
2425
"Fuji FinePix X-S1",
2426
"Fuji FinePix X100",
2433
"Imacon Ixpress 16-megapixel",
2434
"Imacon Ixpress 22-megapixel",
2435
"Imacon Ixpress 39-megapixel",
2441
"Kodak DC120 (also try kdc2tiff)",
2464
"Kodak DCS Pro 14n",
2465
"Kodak DCS Pro 14nx",
2466
"Kodak DCS Pro SLR/c",
2467
"Kodak DCS Pro SLR/n",
2511
"Logitech Fotoman Pixtura",
2517
"Minolta DiMAGE 7i",
2518
"Minolta DiMAGE 7Hi",
2519
"Minolta DiMAGE A1",
2520
"Minolta DiMAGE A2",
2521
"Minolta DiMAGE A200",
2522
"Minolta DiMAGE G400",
2523
"Minolta DiMAGE G500",
2524
"Minolta DiMAGE G530",
2525
"Minolta DiMAGE G600",
2526
"Minolta DiMAGE Z2",
2527
"Minolta Alpha/Dynax/Maxxum 5D",
2528
"Minolta Alpha/Dynax/Maxxum 7D",
2563
"Nikon E700 (\"DIAG RAW\" hack)",
2564
"Nikon E800 (\"DIAG RAW\" hack)",
2565
"Nikon E880 (\"DIAG RAW\" hack)",
2566
"Nikon E900 (\"DIAG RAW\" hack)",
2567
"Nikon E950 (\"DIAG RAW\" hack)",
2568
"Nikon E990 (\"DIAG RAW\" hack)",
2569
"Nikon E995 (\"DIAG RAW\" hack)",
2570
"Nikon E2100 (\"DIAG RAW\" hack)",
2571
"Nikon E2500 (\"DIAG RAW\" hack)",
2572
"Nikon E3200 (\"DIAG RAW\" hack)",
2573
"Nikon E3700 (\"DIAG RAW\" hack)",
2574
"Nikon E4300 (\"DIAG RAW\" hack)",
2575
"Nikon E4500 (\"DIAG RAW\" hack)",
2582
"Nikon Coolpix P6000",
2583
"Nikon Coolpix P7000",
2584
"Nikon Coolpix P7100",
2585
"Nikon Coolpix S6 (\"DIAG RAW\" hack)",
2592
"Olympus C70Z,C7000Z",
2596
"Olympus X200,D560Z,C350Z",
2630
"Panasonic DMC-FZ8",
2631
"Panasonic DMC-FZ18",
2632
"Panasonic DMC-FZ28",
2633
"Panasonic DMC-FZ30",
2634
"Panasonic DMC-FZ35/FZ38",
2635
"Panasonic DMC-FZ40",
2636
"Panasonic DMC-FZ50",
2637
"Panasonic DMC-FZ100",
2638
"Panasonic DMC-FZ150",
2639
"Panasonic DMC-FX150",
2641
"Panasonic DMC-G10",
2644
"Panasonic DMC-GF1",
2645
"Panasonic DMC-GF2",
2646
"Panasonic DMC-GF3",
2647
"Panasonic DMC-GF5",
2648
"Panasonic DMC-GH1",
2649
"Panasonic DMC-GH2",
2650
"Panasonic DMC-GX1",
2652
"Panasonic DMC-L10",
2653
"Panasonic DMC-LC1",
2654
"Panasonic DMC-LX1",
2655
"Panasonic DMC-LX2",
2656
"Panasonic DMC-LX3",
2657
"Panasonic DMC-LX5",
2666
"Pentax K100D Super",
2675
"Pentax Optio 33WR",
2676
"Pentax Optio 750Z",
2678
"Phase One LightPhase",
2689
#ifdef LIBRAW_DEMOSAIC_PACK_GPL2
2693
"Redcode R3D format",
2709
"Samsung S85 (hacked)",
2710
"Samsung S850 (hacked)",
2711
"Sarnoff 4096x5440",
2712
#ifdef LIBRAW_DEMOSAIC_PACK_GPL2
2721
"SMaL Ultra-Pocket 3",
2722
"SMaL Ultra-Pocket 4",
2723
"SMaL Ultra-Pocket 5",
2761
const char** LibRaw::cameraList() { return static_camera_list;}
2762
int LibRaw::cameraCount() { return (sizeof(static_camera_list)/sizeof(static_camera_list[0]))-1; }
2765
const char * LibRaw::strprogress(enum LibRaw_progress p)
2769
case LIBRAW_PROGRESS_START:
2771
case LIBRAW_PROGRESS_OPEN :
2772
return "Opening file";
2773
case LIBRAW_PROGRESS_IDENTIFY :
2774
return "Reading metadata";
2775
case LIBRAW_PROGRESS_SIZE_ADJUST:
2776
return "Adjusting size";
2777
case LIBRAW_PROGRESS_LOAD_RAW:
2778
return "Reading RAW data";
2779
case LIBRAW_PROGRESS_REMOVE_ZEROES:
2780
return "Clearing zero values";
2781
case LIBRAW_PROGRESS_BAD_PIXELS :
2782
return "Removing dead pixels";
2783
case LIBRAW_PROGRESS_DARK_FRAME:
2784
return "Subtracting dark frame data";
2785
case LIBRAW_PROGRESS_FOVEON_INTERPOLATE:
2786
return "Interpolating Foveon sensor data";
2787
case LIBRAW_PROGRESS_SCALE_COLORS:
2788
return "Scaling colors";
2789
case LIBRAW_PROGRESS_PRE_INTERPOLATE:
2790
return "Pre-interpolating";
2791
case LIBRAW_PROGRESS_INTERPOLATE:
2792
return "Interpolating";
2793
case LIBRAW_PROGRESS_MIX_GREEN :
2794
return "Mixing green channels";
2795
case LIBRAW_PROGRESS_MEDIAN_FILTER :
2796
return "Median filter";
2797
case LIBRAW_PROGRESS_HIGHLIGHTS:
2798
return "Highlight recovery";
2799
case LIBRAW_PROGRESS_FUJI_ROTATE :
2800
return "Rotating Fuji diagonal data";
2801
case LIBRAW_PROGRESS_FLIP :
2802
return "Flipping image";
2803
case LIBRAW_PROGRESS_APPLY_PROFILE:
2804
return "ICC conversion";
2805
case LIBRAW_PROGRESS_CONVERT_RGB:
2806
return "Converting to RGB";
2807
case LIBRAW_PROGRESS_STRETCH:
2808
return "Stretching image";
2809
case LIBRAW_PROGRESS_THUMB_LOAD:
2810
return "Loading thumbnail";
2812
return "Some strange things";