Alien-FreeImage
view release on metacpan or search on metacpan
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
if (!strncmp(RDE.what(), "Decoder canceled", strlen("Decoder canceled")))
throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK;
}
catch (...)
{
// We may get here due to cancellation flag
imgdata.process_warnings |= LIBRAW_WARN_RAWSPEED_PROBLEM;
if(_rawspeed_buffer)
{
free(_rawspeed_buffer);
_rawspeed_buffer = 0;
}
}
ID.input->seek(spos,SEEK_SET);
}
#endif
if(!imgdata.rawdata.raw_image && !imgdata.rawdata.color4_image && !imgdata.rawdata.color3_image) //RawSpeed failed!
{
// Not allocated on RawSpeed call, try call LibRaw
if(decoder_info.decoder_flags & LIBRAW_DECODER_OWNALLOC)
{
// x3f foveon decoder
// Do nothing! Decoder will allocate data internally
}
else if(imgdata.idata.filters || P1.colors == 1) // Bayer image or single color -> decode to raw_image
{
imgdata.rawdata.raw_alloc = malloc(rwidth*(rheight+8)*sizeof(imgdata.rawdata.raw_image[0]));
imgdata.rawdata.raw_image = (ushort*) imgdata.rawdata.raw_alloc;
if(!S.raw_pitch)
S.raw_pitch = S.raw_width*2; // Bayer case, not set before
}
else // NO LEGACY FLAG if (decoder_info.decoder_flags & LIBRAW_DECODER_LEGACY)
{
// sRAW and old Foveon decoders only, so extra buffer size is just 1/4
S.iwidth = S.width;
S.iheight= S.height;
IO.shrink = 0;
S.raw_pitch = S.width*8;
// allocate image as temporary buffer, size
imgdata.rawdata.raw_alloc = 0;
imgdata.image = (ushort (*)[4]) calloc(S.iwidth*S.iheight,sizeof(*imgdata.image));
}
ID.input->seek(libraw_internal_data.unpacker_data.data_offset, SEEK_SET);
unsigned m_save = C.maximum;
if(load_raw == &LibRaw::unpacked_load_raw && !strcasecmp(imgdata.idata.make,"Nikon"))
C.maximum=65535;
(this->*load_raw)();
if(load_raw == &LibRaw::unpacked_load_raw && !strcasecmp(imgdata.idata.make,"Nikon"))
C.maximum = m_save;
if(decoder_info.decoder_flags & LIBRAW_DECODER_OWNALLOC)
{
// x3f foveon decoder only: do nothing
}
else if (!(imgdata.idata.filters || P1.colors == 1))
{
// successfully decoded legacy image, attach image to raw_alloc
imgdata.rawdata.raw_alloc = imgdata.image;
imgdata.image = 0;
// Restore saved values. Note: Foveon have masked frame
// Other 4-color legacy data: no borders
S.raw_width = S.width;
S.left_margin = 0;
S.raw_height = S.height;
S.top_margin = 0;
}
}
if(imgdata.rawdata.raw_image)
crop_masked_pixels(); // calculate black levels
// recover saved
if( !(imgdata.idata.filters || P1.colors == 1) && !imgdata.rawdata.color4_image)
{
imgdata.image = 0;
imgdata.rawdata.color4_image = (ushort (*)[4]) imgdata.rawdata.raw_alloc;
}
// recover image sizes
S.iwidth = save_iwidth;
S.iheight = save_iheight;
IO.shrink = save_shrink;
// adjust black to possible maximum
unsigned int i = C.cblack[3];
unsigned int c;
for(c=0;c<3;c++)
if (i > C.cblack[c]) i = C.cblack[c];
for (c=0;c<4;c++)
C.cblack[c] -= i;
C.black += i;
// Save color,sizes and internal data into raw_image fields
memmove(&imgdata.rawdata.color,&imgdata.color,sizeof(imgdata.color));
memmove(&imgdata.rawdata.sizes,&imgdata.sizes,sizeof(imgdata.sizes));
memmove(&imgdata.rawdata.iparams,&imgdata.idata,sizeof(imgdata.idata));
memmove(&imgdata.rawdata.ioparams,&libraw_internal_data.internal_output_params,sizeof(libraw_internal_data.internal_output_params));
SET_PROC_FLAG(LIBRAW_PROGRESS_LOAD_RAW);
RUN_CALLBACK(LIBRAW_PROGRESS_LOAD_RAW,1,2);
return 0;
}
catch ( LibRaw_exceptions err) {
EXCEPTION_HANDLER(err);
}
catch (std::exception ee) {
EXCEPTION_HANDLER(LIBRAW_EXCEPTION_IO_CORRUPT);
}
}
void LibRaw::nikon_load_sraw()
{
// We're already seeked to data!
unsigned char *rd = (unsigned char *)malloc(3*(imgdata.sizes.raw_width+2));
if(!rd) throw LIBRAW_EXCEPTION_ALLOC;
try {
int row,col;
for(row = 0; row < imgdata.sizes.raw_height; row++)
{
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
C.cblack[c] += C.cblack[6];
C.cblack[4]=C.cblack[5]=0;
}
// remove common part from C.cblack[]
int i = C.cblack[3];
int c;
for(c=0;c<3;c++) if (i > C.cblack[c]) i = C.cblack[c];
for(c=0;c<4;c++) C.cblack[c] -= i; // remove common part
C.black += i;
// Now calculate common part for cblack[6+] part and move it to C.black
if(C.cblack[4] && C.cblack[5])
{
i = C.cblack[6];
for(c=1; c<C.cblack[4]*C.cblack[5]; c++)
if(i>C.cblack[6+c]) i = C.cblack[6+c];
// Remove i from cblack[6+]
int nonz=0;
for(c=0; c<C.cblack[4]*C.cblack[5]; c++)
{
C.cblack[6+c]-=i;
if(C.cblack[6+c])nonz++;
}
C.black +=i;
if(!nonz)
C.cblack[4] = C.cblack[5] = 0;
}
for(c=0;c<4;c++) C.cblack[c] += C.black;
}
int LibRaw::dcraw_process(void)
{
int quality,i;
int iterations=-1, dcb_enhance=1, noiserd=0;
int eeci_refine_fl=0, es_med_passes_fl=0;
float cared=0,cablue=0;
float linenoise=0;
float lclean=0,cclean=0;
float thresh=0;
float preser=0;
float expos=1.0;
CHECK_ORDER_LOW(LIBRAW_PROGRESS_LOAD_RAW);
// CHECK_ORDER_HIGH(LIBRAW_PROGRESS_PRE_INTERPOLATE);
try {
int no_crop = 1;
if (~O.cropbox[2] && ~O.cropbox[3])
no_crop=0;
libraw_decoder_info_t di;
get_decoder_info(&di);
bool is_bayer = (imgdata.idata.filters || P1.colors == 1);
int subtract_inline = !O.bad_pixels && !O.dark_frame && !O.wf_debanding && is_bayer && !IO.zero_is_bad;
raw2image_ex(subtract_inline); // allocate imgdata.image and copy data!
// Adjust sizes
int save_4color = O.four_color_rgb;
if (IO.zero_is_bad)
{
remove_zeroes();
SET_PROC_FLAG(LIBRAW_PROGRESS_REMOVE_ZEROES);
}
if(O.bad_pixels && no_crop)
{
bad_pixels(O.bad_pixels);
SET_PROC_FLAG(LIBRAW_PROGRESS_BAD_PIXELS);
}
if (O.dark_frame && no_crop)
{
subtract (O.dark_frame);
SET_PROC_FLAG(LIBRAW_PROGRESS_DARK_FRAME);
}
if (O.wf_debanding)
{
wf_remove_banding();
}
quality = 2 + !IO.fuji_width;
if (O.user_qual >= 0) quality = O.user_qual;
if(!subtract_inline || !C.data_maximum)
{
adjust_bl();
subtract_black_internal();
}
if(!(di.decoder_flags & LIBRAW_DECODER_FIXEDMAXC))
adjust_maximum();
if (O.user_sat > 0) C.maximum = O.user_sat;
if (P1.is_foveon)
{
if(load_raw == &LibRaw::x3f_load_raw)
{
// Filter out zeroes
for (int i=0; i < S.height*S.width*4; i++)
if ((short) imgdata.image[0][i] < 0) imgdata.image[0][i] = 0;
}
#ifdef LIBRAW_DEMOSAIC_PACK_GPL2
else if(load_raw == &LibRaw::foveon_dp_load_raw)
{
for (int i=0; i < S.height*S.width*4; i++)
if ((short) imgdata.image[0][i] < 0) imgdata.image[0][i] = 0;
}
else
{
foveon_interpolate();
}
#endif
SET_PROC_FLAG(LIBRAW_PROGRESS_FOVEON_INTERPOLATE);
}
if (O.green_matching && !O.half_size)
{
green_matching();
}
if (
#ifdef LIBRAW_DEMOSAIC_PACK_GPL2
(!P1.is_foveon || O.force_foveon_x3f) &&
#endif
!O.no_auto_scale)
{
scale_colors();
SET_PROC_FLAG(LIBRAW_PROGRESS_SCALE_COLORS);
}
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
"Sony DSLR-A700",
"Sony DSLR-A850",
"Sony DSLR-A900",
"Sony NEX-3",
"Sony NEX-3N",
"Sony NEX-5",
"Sony NEX-5N",
"Sony NEX-5R",
"Sony NEX-5T",
"Sony NEX-6",
"Sony NEX-7",
"Sony NEX-C3",
"Sony NEX-F3",
"Sony NEX-VG20",
"Sony NEX-VG30",
"Sony NEX-VG900",
"Sony SLT-A33",
"Sony SLT-A35",
"Sony SLT-A37",
"Sony SLT-A55V",
"Sony SLT-A57",
"Sony SLT-A58",
"Sony SLT-A65V",
"Sony SLT-A77V",
"Sony SLT-A99V",
"Sony XCD-SX910CR",
"Sony IMX135-mipi 13mp",
"Sony IMX135-QCOM",
"Sony IMX072-mipi",
"STV680 VGA",
"ptGrey GRAS-50S5C",
"JaiPulnix BB-500CL",
"JaiPulnix BB-500GE",
"SVS SVS625CL",
NULL
};
const char** LibRaw::cameraList() { return static_camera_list;}
int LibRaw::cameraCount() { return (sizeof(static_camera_list)/sizeof(static_camera_list[0]))-1; }
const char * LibRaw::strprogress(enum LibRaw_progress p)
{
switch(p)
{
case LIBRAW_PROGRESS_START:
return "Starting";
case LIBRAW_PROGRESS_OPEN :
return "Opening file";
case LIBRAW_PROGRESS_IDENTIFY :
return "Reading metadata";
case LIBRAW_PROGRESS_SIZE_ADJUST:
return "Adjusting size";
case LIBRAW_PROGRESS_LOAD_RAW:
return "Reading RAW data";
case LIBRAW_PROGRESS_REMOVE_ZEROES:
return "Clearing zero values";
case LIBRAW_PROGRESS_BAD_PIXELS :
return "Removing dead pixels";
case LIBRAW_PROGRESS_DARK_FRAME:
return "Subtracting dark frame data";
case LIBRAW_PROGRESS_FOVEON_INTERPOLATE:
return "Interpolating Foveon sensor data";
case LIBRAW_PROGRESS_SCALE_COLORS:
return "Scaling colors";
case LIBRAW_PROGRESS_PRE_INTERPOLATE:
return "Pre-interpolating";
case LIBRAW_PROGRESS_INTERPOLATE:
return "Interpolating";
case LIBRAW_PROGRESS_MIX_GREEN :
return "Mixing green channels";
case LIBRAW_PROGRESS_MEDIAN_FILTER :
return "Median filter";
case LIBRAW_PROGRESS_HIGHLIGHTS:
return "Highlight recovery";
case LIBRAW_PROGRESS_FUJI_ROTATE :
return "Rotating Fuji diagonal data";
case LIBRAW_PROGRESS_FLIP :
return "Flipping image";
case LIBRAW_PROGRESS_APPLY_PROFILE:
return "ICC conversion";
case LIBRAW_PROGRESS_CONVERT_RGB:
return "Converting to RGB";
case LIBRAW_PROGRESS_STRETCH:
return "Stretching image";
case LIBRAW_PROGRESS_THUMB_LOAD:
return "Loading thumbnail";
default:
return "Some strange things";
}
}
#undef ID
#include "../internal/libraw_x3f.cpp"
void x3f_clear(void *p)
{
x3f_delete((x3f_t*)p);
}
static char *utf2char(utf16_t *str, char *buffer)
{
char *b = buffer;
while (*str != 0x00) {
char *chr = (char *)str;
*b++ = *chr;
str++;
}
*b = 0;
return buffer;
}
static void *lr_memmem(const void *l, size_t l_len, const void *s, size_t s_len)
{
register char *cur, *last;
const char *cl = (const char *)l;
const char *cs = (const char *)s;
( run in 0.879 second using v1.01-cache-2.11-cpan-df04353d9ac )