Alien-FreeImage
view release on metacpan or search on metacpan
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
};
const float LibRaw_constants::d65_white[3] = { 0.950456f, 1.0f, 1.088754f };
#define P1 imgdata.idata
#define S imgdata.sizes
#define O imgdata.params
#define C imgdata.color
#define T imgdata.thumbnail
#define IO libraw_internal_data.internal_output_params
#define ID libraw_internal_data.internal_data
#define EXCEPTION_HANDLER(e) do{ \
/* fprintf(stderr,"Exception %d caught\n",e);*/ \
switch(e) \
{ \
case LIBRAW_EXCEPTION_ALLOC: \
recycle(); \
return LIBRAW_UNSUFFICIENT_MEMORY; \
case LIBRAW_EXCEPTION_DECODE_RAW: \
case LIBRAW_EXCEPTION_DECODE_JPEG: \
recycle(); \
return LIBRAW_DATA_ERROR; \
case LIBRAW_EXCEPTION_DECODE_JPEG2000: \
recycle(); \
return LIBRAW_DATA_ERROR; \
case LIBRAW_EXCEPTION_IO_EOF: \
case LIBRAW_EXCEPTION_IO_CORRUPT: \
recycle(); \
return LIBRAW_IO_ERROR; \
case LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK: \
recycle(); \
return LIBRAW_CANCELLED_BY_CALLBACK; \
case LIBRAW_EXCEPTION_BAD_CROP: \
recycle(); \
return LIBRAW_BAD_CROP; \
default: \
return LIBRAW_UNSPECIFIED_ERROR; \
} \
}while(0)
const char* LibRaw::version() { return LIBRAW_VERSION_STR;}
int LibRaw::versionNumber() { return LIBRAW_VERSION; }
const char* LibRaw::strerror(int p) { return libraw_strerror(p);}
LibRaw_colormatrix_type LibRaw::camera_color_type()
{
if(C.cmatrix[0][0] <= 0.125) return LIBRAW_CMATRIX_NONE;
if(P1.dng_version) return LIBRAW_CMATRIX_DNG;
if(C.digitalBack_color) return LIBRAW_CMATRIX_DIGBACK;
return LIBRAW_CMATRIX_OTHER;
}
void LibRaw::derror()
{
if (!libraw_internal_data.unpacker_data.data_error && libraw_internal_data.internal_data.input)
{
if (libraw_internal_data.internal_data.input->eof())
{
if(callbacks.data_cb)(*callbacks.data_cb)(callbacks.datacb_data,
libraw_internal_data.internal_data.input->fname(),-1);
throw LIBRAW_EXCEPTION_IO_EOF;
}
else
{
if(callbacks.data_cb)(*callbacks.data_cb)(callbacks.datacb_data,
libraw_internal_data.internal_data.input->fname(),
libraw_internal_data.internal_data.input->tell());
//throw LIBRAW_EXCEPTION_IO_CORRUPT;
}
}
libraw_internal_data.unpacker_data.data_error++;
}
void LibRaw::dcraw_clear_mem(libraw_processed_image_t* p)
{
if(p) ::free(p);
}
int LibRaw::is_sraw() { return load_raw == &LibRaw::canon_sraw_load_raw || load_raw == &LibRaw::nikon_load_sraw ; }
int LibRaw::is_coolscan_nef() { return load_raw == &LibRaw::nikon_coolscan_load_raw;}
int LibRaw::is_nikon_sraw(){
return load_raw == &LibRaw::nikon_load_sraw;
}
int LibRaw::sraw_midpoint() {
if (load_raw == &LibRaw::canon_sraw_load_raw) return 8192;
else if (load_raw == &LibRaw::nikon_load_sraw) return 2048;
else return 0;
}
#ifdef USE_RAWSPEED
using namespace RawSpeed;
class CameraMetaDataLR : public CameraMetaData
{
public:
CameraMetaDataLR() : CameraMetaData() {}
CameraMetaDataLR(char *filename) : CameraMetaData(filename){}
CameraMetaDataLR(char *data, int sz);
};
CameraMetaDataLR::CameraMetaDataLR(char *data, int sz) : CameraMetaData() {
ctxt = xmlNewParserCtxt();
if (ctxt == NULL) {
ThrowCME("CameraMetaData:Could not initialize context.");
}
xmlResetLastError();
doc = xmlCtxtReadMemory(ctxt, data,sz, "", NULL, XML_PARSE_DTDVALID);
if (doc == NULL) {
ThrowCME("CameraMetaData: XML Document could not be parsed successfully. Error was: %s", ctxt->lastError.message);
}
if (ctxt->valid == 0) {
if (ctxt->lastError.code == 0x5e) {
// printf("CameraMetaData: Unable to locate DTD, attempting to ignore.");
} else {
ThrowCME("CameraMetaData: XML file does not validate. DTD Error was: %s", ctxt->lastError.message);
}
}
xmlNodePtr cur;
cur = xmlDocGetRootElement(doc);
if (xmlStrcmp(cur->name, (const xmlChar *) "Cameras")) {
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
#define RAWSPEED_DATA_COUNT (sizeof(_rawspeed_data_xml)/sizeof(_rawspeed_data_xml[0]))
static CameraMetaDataLR* make_camera_metadata()
{
int len = 0,i;
for(i=0;i<RAWSPEED_DATA_COUNT;i++)
if(_rawspeed_data_xml[i])
{
len+=strlen(_rawspeed_data_xml[i]);
}
char *rawspeed_xml = (char*)calloc(len+1,sizeof(_rawspeed_data_xml[0][0]));
if(!rawspeed_xml) return NULL;
int offt = 0;
for(i=0;i<RAWSPEED_DATA_COUNT;i++)
if(_rawspeed_data_xml[i])
{
int ll = strlen(_rawspeed_data_xml[i]);
if(offt+ll>len) break;
memmove(rawspeed_xml+offt,_rawspeed_data_xml[i],ll);
offt+=ll;
}
rawspeed_xml[offt]=0;
CameraMetaDataLR *ret=NULL;
try {
ret = new CameraMetaDataLR(rawspeed_xml,offt);
} catch (...) {
// Mask all exceptions
}
free(rawspeed_xml);
return ret;
}
#endif
#define ZERO(a) memset(&a,0,sizeof(a))
static void cleargps(libraw_gps_info_t*q)
{
for (int i = 0; i < 3; i++)
q->latitude[i] = q->longtitude[i] = q->gpstimestamp[i] = 0.f;
q->altitude = 0.f;
q->altref = q->latref = q->longref = q->gpsstatus = q->gpsparsed = 0;
}
LibRaw:: LibRaw(unsigned int flags)
{
double aber[4] = {1,1,1,1};
double gamm[6] = { 0.45,4.5,0,0,0,0 };
unsigned greybox[4] = { 0, 0, UINT_MAX, UINT_MAX };
unsigned cropbox[4] = { 0, 0, UINT_MAX, UINT_MAX };
#ifdef DCRAW_VERBOSE
verbose = 1;
#else
verbose = 0;
#endif
ZERO(imgdata);
imgdata.lens.makernotes.CanonFocalUnits = 1;
imgdata.lens.makernotes.LensID = 0xffffffffffffffffULL;
cleargps(&imgdata.other.parsed_gps);
ZERO(libraw_internal_data);
ZERO(callbacks);
_rawspeed_camerameta = _rawspeed_decoder = NULL;
_x3f_data = NULL;
#ifdef USE_RAWSPEED
CameraMetaDataLR *camerameta = make_camera_metadata(); // May be NULL in case of exception in make_camera_metadata()
_rawspeed_camerameta = static_cast<void*>(camerameta);
#endif
callbacks.mem_cb = (flags & LIBRAW_OPIONS_NO_MEMERR_CALLBACK) ? NULL: &default_memory_callback;
callbacks.data_cb = (flags & LIBRAW_OPIONS_NO_DATAERR_CALLBACK)? NULL : &default_data_callback;
callbacks.exif_cb = NULL; // no default callback
memmove(&imgdata.params.aber,&aber,sizeof(aber));
memmove(&imgdata.params.gamm,&gamm,sizeof(gamm));
memmove(&imgdata.params.greybox,&greybox,sizeof(greybox));
memmove(&imgdata.params.cropbox,&cropbox,sizeof(cropbox));
imgdata.params.bright=1;
imgdata.params.use_camera_matrix=1;
imgdata.params.user_flip=-1;
imgdata.params.user_black=-1;
imgdata.params.user_cblack[0]=imgdata.params.user_cblack[1]=imgdata.params.user_cblack[2]=imgdata.params.user_cblack[3]=-1000001;
imgdata.params.user_sat=-1;
imgdata.params.user_qual=-1;
imgdata.params.output_color=1;
imgdata.params.output_bps=8;
imgdata.params.use_fuji_rotate=1;
imgdata.params.exp_shift = 1.0;
imgdata.params.auto_bright_thr = LIBRAW_DEFAULT_AUTO_BRIGHTNESS_THRESHOLD;
imgdata.params.adjust_maximum_thr= LIBRAW_DEFAULT_ADJUST_MAXIMUM_THRESHOLD;
imgdata.params.use_rawspeed = 1;
imgdata.params.no_auto_scale = 0;
imgdata.params.no_interpolation = 0;
imgdata.params.sraw_ycc = 0;
imgdata.params.force_foveon_x3f = 0;
imgdata.params.x3f_flags = LIBRAW_DP2Q_INTERPOLATERG|LIBRAW_DP2Q_INTERPOLATEAF;
imgdata.params.sony_arw2_options = 0;
imgdata.params.sony_arw2_posterization_thr = 0;
imgdata.params.green_matching = 0;
imgdata.params.coolscan_nef_gamma = 1.0f;
imgdata.parent_class = this;
imgdata.progress_flags = 0;
imgdata.color.baseline_exposure = -999.f;
_exitflag = 0;
tls = new LibRaw_TLS;
tls->init();
}
int LibRaw::set_rawspeed_camerafile(char *filename)
{
#ifdef USE_RAWSPEED
try
{
CameraMetaDataLR *camerameta = new CameraMetaDataLR(filename);
if(_rawspeed_camerameta)
{
CameraMetaDataLR *d = static_cast<CameraMetaDataLR*>(_rawspeed_camerameta);
delete d;
}
_rawspeed_camerameta = static_cast<void*>(camerameta);
}
catch (...)
{
//just return error code
return -1;
}
#endif
return 0;
}
LibRaw::~LibRaw()
{
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
d_info->decoder_name = "smal_v6_load_raw()";
}
else if (load_raw == &LibRaw::smal_v9_load_raw )
{
// UNTESTED
d_info->decoder_name = "smal_v9_load_raw()";
}
else if (load_raw == &LibRaw::redcine_load_raw)
{
d_info->decoder_name = "redcine_load_raw()";
d_info->decoder_flags = LIBRAW_DECODER_HASCURVE;
}
else if (load_raw == &LibRaw::x3f_load_raw )
{
d_info->decoder_name = "x3f_load_raw()";
d_info->decoder_flags = LIBRAW_DECODER_OWNALLOC;
}
#ifdef LIBRAW_DEMOSAIC_PACK_GPL2
else if (load_raw == &LibRaw::foveon_sd_load_raw )
{
d_info->decoder_name = "foveon_sd_load_raw()";
}
else if (load_raw == &LibRaw::foveon_dp_load_raw )
{
d_info->decoder_name = "foveon_dp_load_raw()";
}
#endif
else
{
d_info->decoder_name = "Unknown unpack function";
d_info->decoder_flags = LIBRAW_DECODER_NOTSET;
}
return LIBRAW_SUCCESS;
}
int LibRaw::adjust_maximum()
{
ushort real_max;
float auto_threshold;
if(O.adjust_maximum_thr < 0.00001)
return LIBRAW_SUCCESS;
else if (O.adjust_maximum_thr > 0.99999)
auto_threshold = LIBRAW_DEFAULT_ADJUST_MAXIMUM_THRESHOLD;
else
auto_threshold = O.adjust_maximum_thr;
real_max = C.data_maximum;
if (real_max > 0 && real_max < C.maximum && real_max > C.maximum* auto_threshold)
{
C.maximum = real_max;
}
return LIBRAW_SUCCESS;
}
void LibRaw:: merror (void *ptr, const char *where)
{
if (ptr) return;
if(callbacks.mem_cb)(*callbacks.mem_cb)(callbacks.memcb_data,
libraw_internal_data.internal_data.input
?libraw_internal_data.internal_data.input->fname()
:NULL,
where);
throw LIBRAW_EXCEPTION_ALLOC;
}
int LibRaw::open_file(const char *fname, INT64 max_buf_size)
{
#ifndef WIN32
struct stat st;
if(stat(fname,&st))
return LIBRAW_IO_ERROR;
int big = (st.st_size > max_buf_size)?1:0;
#else
struct _stati64 st;
if(_stati64(fname,&st))
return LIBRAW_IO_ERROR;
int big = (st.st_size > max_buf_size)?1:0;
#endif
LibRaw_abstract_datastream *stream;
try {
if(big)
stream = new LibRaw_bigfile_datastream(fname);
else
stream = new LibRaw_file_datastream(fname);
}
catch (std::bad_alloc)
{
recycle();
return LIBRAW_UNSUFFICIENT_MEMORY;
}
if(!stream->valid())
{
delete stream;
return LIBRAW_IO_ERROR;
}
ID.input_internal = 0; // preserve from deletion on error
int ret = open_datastream(stream);
if (ret == LIBRAW_SUCCESS)
{
ID.input_internal =1 ; // flag to delete datastream on recycle
}
else
{
delete stream;
ID.input_internal = 0;
}
return ret;
}
#if defined(_WIN32) && !defined(__MINGW32__) && defined(_MSC_VER) && (_MSC_VER > 1310)
int LibRaw::open_file(const wchar_t *fname, INT64 max_buf_size)
{
struct _stati64 st;
if(_wstati64(fname,&st))
( run in 1.449 second using v1.01-cache-2.11-cpan-63c85eba8c4 )