int libraw_dcraw_thumb_writer(libraw_data_t* lr,const char *fname)
{
if(!lr) return EINVAL;
LibRaw *ip = (LibRaw*) lr->parent_class;
return ip->dcraw_thumb_writer(fname);
}
int libraw_dcraw_document_mode_processing(libraw_data_t* lr)
{
if(!lr) return EINVAL;
LibRaw *ip = (LibRaw*) lr->parent_class;
return ip->dcraw_document_mode_processing();
}
void libraw_set_progress_handler(libraw_data_t* lr, progress_callback cb,void *data)
{
if(!lr) return;
LibRaw *ip = (LibRaw*) lr->parent_class;
ip->set_progress_handler(cb,data);
}
void libraw_set_memerror_handler(libraw_data_t* lr, memory_callback cb,void *data)
{
if(!lr) return;
LibRaw *ip = (LibRaw*) lr->parent_class;
ip->set_memerror_handler(cb,data);
}
Image ImageLoader_raw_p::loadMaster ()
{
/**
* Custom raw import:
* half_size = 1
* document_mode = 2
* gamma[0] gamma[1] = 1
*/
// Skip debayer for now
m_rawProcessor.imgdata.params.half_size = 0;
m_rawProcessor.imgdata.params.document_mode = 0;
m_rawProcessor.imgdata.params.use_camera_wb = 1;
m_rawProcessor.imgdata.params.use_auto_wb = 0;
m_rawProcessor.imgdata.params.med_passes = 0;
m_rawProcessor.imgdata.params.no_auto_bright = 1;
m_rawProcessor.imgdata.params.output_color = 1; // sRGB
m_rawProcessor.imgdata.params.output_bps = 16; // 16 bits
m_rawProcessor.unpack();
// Use AHC bayer interpolation
m_rawProcessor.imgdata.params.user_qual = 1;
m_rawProcessor.imgdata.params.threshold = 100;
if (m_rawProcessor.imgdata.other.iso_speed)
m_rawProcessor.imgdata.params.threshold = m_rawProcessor.imgdata.other.iso_speed / 8; // TODO /8 beter?
m_rawProcessor.dcraw_process();
int mem_height = 0;
int mem_width = 0;
int mem_channels = 0;
int mem_bits_per_pixel = 0;
m_rawProcessor.get_mem_image_format(&mem_width, &mem_height, &mem_channels, &mem_bits_per_pixel);
QSize size (mem_width, mem_height);
qDebug () << "Create rawprocessor image:";
qDebug () << mem_width << mem_height << mem_channels << mem_bits_per_pixel;
Image image (size, mem_channels, size.width() * mem_channels * mem_bits_per_pixel, mem_bits_per_pixel);
// image.setMaxValue( m_rawProcessor.imgdata.color.maximum );
m_rawProcessor.copy_mem_image(image.pixels(), image.step(), 0);
return image;
}
int main(int argc, char const *argv[])
{
LibRaw rawProcessor;
rawProcessor.open_file(argv[argc-1]);
rawProcessor.unpack();
// Use 16-bit input.
buffer_t input_buf = {0};
input_buf.host = (uint8_t *)rawProcessor.imgdata.rawdata.raw_image;
input_buf.stride[0] = 1;
input_buf.stride[1] = rawProcessor.imgdata.sizes.width;
input_buf.extent[0] = rawProcessor.imgdata.sizes.width;
input_buf.extent[1] = rawProcessor.imgdata.sizes.height;
input_buf.elem_size = sizeof(*rawProcessor.imgdata.rawdata.raw_image);
// Allocate WxH 16-bit, 3 channel output buffer.
buffer_t output_buf = {0};
output_buf.stride[0] = 1;
output_buf.stride[1] = rawProcessor.imgdata.sizes.width;
output_buf.stride[2] = rawProcessor.imgdata.sizes.width * rawProcessor.imgdata.sizes.height;
output_buf.stride[3] = rawProcessor.imgdata.sizes.width * rawProcessor.imgdata.sizes.height * 3;
output_buf.extent[0] = rawProcessor.imgdata.sizes.width;
output_buf.extent[1] = rawProcessor.imgdata.sizes.height;
output_buf.extent[2] = 3;
output_buf.elem_size = 2;
uint8_t *output_data = new uint8_t[sizeof(uint16_t) * rawProcessor.imgdata.sizes.width * rawProcessor.imgdata.sizes.height * 3];
output_buf.host = output_data;
output_buf.host_dirty = false;
output_buf.dev_dirty = false;
output_buf.dev = 0;
for (int i = 0; i<20; i++) {
igd_demosaic(&input_buf, 0, &output_buf);
}
//Image<uint16_t> output_image = Image<uint16_t>(&output_buf, "output");
//output_image.copy_to_host();
//Tools::save_image(output_image, "test.png");
return 0;
}
bool KDcraw::loadEmbeddedPreview(QByteArray& imgData, const QBuffer& buffer)
{
QString rawFilesExt(KDcrawIface::KDcraw::rawFiles());
LibRaw raw;
QByteArray inData = buffer.data();
int ret = raw.open_buffer((void*) inData.data(), (size_t) inData.size());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_buffer: " << libraw_strerror(ret);
raw.recycle();
return false;
}
return (Private::loadEmbeddedPreview(imgData, raw));
}
int main(int ac, char *av[])
{
int i, ret;
LibRaw RawProcessor;
if(ac<2)
{
printf(
"multirender_test - LibRaw %s sample. Performs 4 different renderings of one file\n"
" %d cameras supported\n"
"Usage: %s raw-files....\n"
,LibRaw::version(), LibRaw::cameraCount(),
av[0]);
return 0;
}
for (i=1;i<ac;i++)
{
printf("Processing file %s\n",av[i]);
if( (ret = RawProcessor.open_file(av[i])) != LIBRAW_SUCCESS)
{
fprintf(stderr,"Cannot open_file %s: %s\n",av[i],libraw_strerror(ret));
continue; // no recycle b/c open file will recycle itself
}
if( (ret = RawProcessor.unpack() ) != LIBRAW_SUCCESS)
{
fprintf(stderr,"Cannot unpack %s: %s\n",av[i],libraw_strerror(ret));
continue;
}
process_once(RawProcessor,0,0,0,1,-1,av[i]); // default flip
process_once(RawProcessor,1,0,1,2,-1,av[i]);
process_once(RawProcessor,1,1,0,3,-1,av[i]); // default flip
process_once(RawProcessor,1,1,0,4,1,av[i]); // flip 1
process_once(RawProcessor,1,1,0,5,3,av[i]); // flip 3
process_once(RawProcessor,1,1,0,6,1,av[i]); // 1 again same as 4
process_once(RawProcessor,1,1,0,7,-1,av[i]); // default again, same as 3
process_once(RawProcessor,0,0,0,8,-1,av[i]); // same as 1
RawProcessor.recycle(); // just for show this call
}
return 0;
}
static BOOL DLL_CALLCONV
Validate(FreeImageIO *io, fi_handle handle) {
LibRaw RawProcessor;
BOOL bSuccess = TRUE;
// wrap the input datastream
LibRaw_freeimage_datastream datastream(io, handle);
// open the datastream
if(RawProcessor.open_datastream(&datastream) != LIBRAW_SUCCESS) {
bSuccess = FALSE; // LibRaw : failed to open input stream (unknown format)
}
// clean-up internal memory allocations
RawProcessor.recycle();
return bSuccess;
}
bool KDcraw::rawFileIdentify(DcrawInfoContainer& identify, const QString& path)
{
QFileInfo fileInfo(path);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
identify.isDecodable = false;
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
LibRaw raw;
int ret = raw.open_file((const char*)(QFile::encodeName(path)).constData());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
raw.recycle();
return false;
}
ret = raw.adjust_sizes_info_only();
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run adjust_sizes_info_only: " << libraw_strerror(ret);
raw.recycle();
return false;
}
Private::fillIndentifyInfo(&raw, identify);
raw.recycle();
return true;
}
bool KDcraw::loadEmbeddedPreview(QByteArray& imgData, const QString& path)
{
QFileInfo fileInfo(path);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
LibRaw raw;
int ret = raw.open_file((const char*)(QFile::encodeName(path)).constData());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
raw.recycle();
return false;
}
return (Private::loadEmbeddedPreview(imgData, raw));
}
extern "C" JNIEXPORT jshortArray JNICALL Java_com_androsz_andslr_LibRaw_getThumbnailDimensions(JNIEnv * env, jobject obj, jstring jfilename)
{
LibRaw raw;
jboolean bIsCopy;
const char* strFilename = (env)->GetStringUTFChars(jfilename , &bIsCopy);
// Open the file and read the metadata
raw.open_file(strFilename);
(env)->ReleaseStringUTFChars(jfilename, strFilename);// release jstring
// Let us unpack the image
raw.unpack_thumb();
jshortArray js = (env)->NewShortArray(sizeof(jshort)*2);
//env->SetShortArrayRegion(js,0,sizeof(jshort),(jshort*)raw.imgdata.thumbnail.theight);
//env->SetShortArrayRegion(js,sizeof(jshort),sizeof(jshort)*2,(jshort*)raw.imgdata.thumbnail.twidth);
raw.recycle();
return js;
}
bool KDcraw::loadHalfPreview(QImage& image, const QString& path)
{
QFileInfo fileInfo(path);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
qCDebug(LIBKDCRAW_LOG) << "Try to use reduced RAW picture extraction";
LibRaw raw;
raw.imgdata.params.use_auto_wb = 1; // Use automatic white balance.
raw.imgdata.params.use_camera_wb = 1; // Use camera white balance, if possible.
raw.imgdata.params.half_size = 1; // Half-size color image (3x faster than -q).
int ret = raw.open_file((const char*)(QFile::encodeName(path)).constData());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if(!Private::loadHalfPreview(image, raw))
{
qCDebug(LIBKDCRAW_LOG) << "Failed to get half preview from LibRaw!";
return false;
}
qCDebug(LIBKDCRAW_LOG) << "Using reduced RAW picture extraction";
return true;
}
extern "C" JNIEXPORT jbyteArray JNICALL Java_com_androsz_andslr_LibRaw_unpackThumbnailBytesToFit(JNIEnv * env, jobject obj, jstring jfilename, jshort height, jshort width)
{
LibRaw raw;
jboolean bIsCopy;
const char* strFilename = (env)->GetStringUTFChars(jfilename , &bIsCopy);
// Open the file and read the metadata
raw.open_file(strFilename);
(env)->ReleaseStringUTFChars(jfilename, strFilename);// release jstring
// Let us unpack the image
raw.unpack_thumb();
jsize length = raw.imgdata.thumbnail.tlength;
jbyteArray jb = (env)->NewByteArray(length);
env->SetByteArrayRegion(jb,0,length,(jbyte *)raw.imgdata.thumbnail.thumb);
// Finally, let us free the image processor for work with the next image
raw.recycle();
return jb;
}
int process_once(LibRaw& RawProcessor, int half_mode, int camera_wb, int auto_wb, int suffix, int user_flip,char *fname)
{
char outfn[1024];
RawProcessor.imgdata.params.half_size = half_mode;
RawProcessor.imgdata.params.use_camera_wb = camera_wb;
RawProcessor.imgdata.params.use_auto_wb = auto_wb;
RawProcessor.imgdata.params.user_flip = user_flip;
int ret = RawProcessor.dcraw_process();
if(LIBRAW_SUCCESS !=ret)
{
fprintf(stderr,"Cannot do postpocessing on %s: %s\n",
fname,libraw_strerror(ret));
return ret;
}
snprintf(outfn,sizeof(outfn),"%s.%d.%s", fname, suffix, (RawProcessor.imgdata.idata.colors>1?"ppm":"pgm"));
printf("Writing file %s\n",outfn);
if( LIBRAW_SUCCESS != (ret = RawProcessor.dcraw_ppm_tiff_writer(outfn)))
fprintf(stderr,"Cannot write %s: %s\n",outfn,libraw_strerror(ret));
return ret;
}
Image ImageLoader_raw_p::loadPreview ()
{
m_rawProcessor.unpack_thumb();
QSize size (m_rawProcessor.imgdata.thumbnail.twidth, m_rawProcessor.imgdata.thumbnail.theight);
Image result;
if (m_rawProcessor.imgdata.thumbnail.tlength)
{
QImage image;
image.loadFromData(
reinterpret_cast <unsigned char*> (m_rawProcessor.imgdata.thumbnail.thumb),
m_rawProcessor.imgdata.thumbnail.tlength,
"JPG");
result = Image::fromQImage( image );
}
return result;
}
Image ImageLoader_raw_p::loadThumbnail ()
{
m_rawProcessor.unpack_thumb();
QSize size (m_rawProcessor.imgdata.thumbnail.twidth, m_rawProcessor.imgdata.thumbnail.theight);
QImage image;
image.loadFromData(
reinterpret_cast <unsigned char*> (m_rawProcessor.imgdata.thumbnail.thumb),
m_rawProcessor.imgdata.thumbnail.tlength,
"JPG");
int scale = 1;
while ((image.size().width() >> scale) > 480)
scale++;
QSize scaled_size( size.width() / scale,
size.height() / scale);
QImage scaled_image = image.scaled (scaled_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
return Image::fromQImage( scaled_image );
}
bool RawIOHandlerPrivate::load(QIODevice *device)
{
if (device == 0) return false;
if (raw != 0) return true;
stream = new Datastream(device);
raw = new LibRaw;
if (raw->open_datastream(stream) != LIBRAW_SUCCESS) {
delete raw;
raw = 0;
delete stream;
stream = 0;
return false;
}
defaultSize = QSize(raw->imgdata.sizes.width,
raw->imgdata.sizes.height);
if (raw->imgdata.sizes.flip == 5 || raw->imgdata.sizes.flip == 6) {
defaultSize.transpose();
}
return true;
}
void libraw_subtract_black(libraw_data_t* lr)
{
if(!lr) return;
LibRaw *ip = (LibRaw*) lr->parent_class;
ip->subtract_black();
}
static FIBITMAP * DLL_CALLCONV
Load(FreeImageIO *io, fi_handle handle, int page, int flags, void *data) {
FIBITMAP *dib = NULL;
LibRaw RawProcessor;
BOOL header_only = (flags & FIF_LOAD_NOPIXELS) == FIF_LOAD_NOPIXELS;
try {
// wrap the input datastream
LibRaw_freeimage_datastream datastream(io, handle);
// open the datastream
if(RawProcessor.open_datastream(&datastream) != LIBRAW_SUCCESS) {
throw "LibRaw : failed to open input stream (unknown format)";
}
if(header_only) {
// header only mode
dib = FreeImage_AllocateHeaderT(header_only, FIT_RGB16, RawProcessor.imgdata.sizes.width, RawProcessor.imgdata.sizes.height);
// try to get JPEG embedded Exif metadata
if(dib) {
FIBITMAP *metadata_dib = libraw_LoadEmbeddedPreview(RawProcessor, FIF_LOAD_NOPIXELS);
if(metadata_dib) {
FreeImage_CloneMetadata(dib, metadata_dib);
FreeImage_Unload(metadata_dib);
}
}
}
else if((flags & RAW_PREVIEW) == RAW_PREVIEW) {
// try to get the embedded JPEG
dib = libraw_LoadEmbeddedPreview(RawProcessor, 0);
if(!dib) {
// no JPEG preview: try to load as 8-bit/sample (i.e. RGB 24-bit)
dib = libraw_LoadRawData(RawProcessor, 8);
}
}
else if((flags & RAW_DISPLAY) == RAW_DISPLAY) {
// load raw data as 8-bit/sample (i.e. RGB 24-bit)
dib = libraw_LoadRawData(RawProcessor, 8);
}
else {
// default: load raw data as linear 16-bit/sample (i.e. RGB 48-bit)
dib = libraw_LoadRawData(RawProcessor, 16);
}
// save ICC profile if present
if(NULL != RawProcessor.imgdata.color.profile) {
FreeImage_CreateICCProfile(dib, RawProcessor.imgdata.color.profile, RawProcessor.imgdata.color.profile_length);
}
// try to get JPEG embedded Exif metadata
if(dib && !((flags & RAW_PREVIEW) == RAW_PREVIEW) ) {
FIBITMAP *metadata_dib = libraw_LoadEmbeddedPreview(RawProcessor, FIF_LOAD_NOPIXELS);
if(metadata_dib) {
FreeImage_CloneMetadata(dib, metadata_dib);
FreeImage_Unload(metadata_dib);
}
}
// clean-up internal memory allocations
RawProcessor.recycle();
return dib;
} catch(const char *text) {
if(dib) {
FreeImage_Unload(dib);
}
RawProcessor.recycle();
FreeImage_OutputMessageProc(s_format_id, text);
}
return NULL;
}
int libraw_get_decoder_info(libraw_data_t* lr,libraw_decoder_info_t *d)
{
if(!lr || !d) return EINVAL;
LibRaw *ip = (LibRaw*) lr->parent_class;
return ip->get_decoder_info(d);
}
void libraw_recycle(libraw_data_t* lr)
{
if(!lr) return;
LibRaw *ip = (LibRaw*) lr->parent_class;
ip->recycle();
}
int libraw_unpack_thumb(libraw_data_t* lr)
{
if(!lr) return EINVAL;
LibRaw *ip = (LibRaw*) lr->parent_class;
return ip->unpack_thumb();
}
int libraw_open_buffer(libraw_data_t* lr, void *buffer, size_t size)
{
if(!lr) return EINVAL;
LibRaw *ip = (LibRaw*) lr->parent_class;
return ip->open_buffer(buffer,size);
}
int libraw_open_file_ex(libraw_data_t* lr, const char *file,INT64 sz)
{
if(!lr) return EINVAL;
LibRaw *ip = (LibRaw*) lr->parent_class;
return ip->open_file(file,sz);
}
int main(int ac, char *av[])
{
int i, ret, verbose=0, output_thumbs=0;
// don't use fixed size buffers in real apps!
char outfn[1024],thumbfn[1024];
LibRaw RawProcessor;
if(ac<2)
{
printf(
"simple_dcraw - LibRaw %s sample. Emulates dcraw [-D] [-T] [-v] [-e] [-E]\n"
" %d cameras supported\n"
"Usage: %s [-D] [-T] [-v] [-e] raw-files....\n"
"\t-D - document mode emulation\n"
"\t-4 - 16-bit mode\n"
"\t-v - verbose output\n"
"\t-T - output TIFF files instead of .pgm/ppm\n"
"\t-e - extract thumbnails (same as dcraw -e in separate run)\n",LibRaw::version(),
LibRaw::cameraCount(),
av[0]);
return 0;
}
putenv ((char*)"TZ=UTC"); // dcraw compatibility, affects TIFF datestamp field
#define P1 RawProcessor.imgdata.idata
#define S RawProcessor.imgdata.sizes
#define C RawProcessor.imgdata.color
#define T RawProcessor.imgdata.thumbnail
#define P2 RawProcessor.imgdata.other
#define OUT RawProcessor.imgdata.params
for (i=1;i<ac;i++)
{
if(av[i][0]=='-')
{
if(av[i][1]=='T' && av[i][2]==0)
OUT.output_tiff=1;
if(av[i][1]=='v' && av[i][2]==0)
verbose++;
if(av[i][1]=='e' && av[i][2]==0)
output_thumbs++;
if(av[i][1]=='D' && av[i][2]==0)
OUT.document_mode=2;
if(av[i][1]=='4' && av[i][2]==0)
OUT.output_bps=16;
if(av[i][1]=='C' && av[i][2]==0)
RawProcessor.set_progress_handler(my_progress_callback,NULL);
continue;
}
if(verbose) printf("Processing file %s\n",av[i]);
if( (ret = RawProcessor.open_file(av[i])) != LIBRAW_SUCCESS)
{
fprintf(stderr,"Cannot open_file %s: %s\n",av[i],libraw_strerror(ret));
continue; // no recycle b/c open file will recycle itself
}
if( (ret = RawProcessor.unpack() ) != LIBRAW_SUCCESS)
{
fprintf(stderr,"Cannot unpack %s: %s\n",av[i],libraw_strerror(ret));
continue;
}
// thumbnail unpacking and output in the middle of main
// image processing - for test purposes!
if(output_thumbs)
{
if( (ret = RawProcessor.unpack_thumb() ) != LIBRAW_SUCCESS)
{
fprintf(stderr,"Cannot unpack_thumb %s: %s\n",av[i],libraw_strerror(ret));
if(LIBRAW_FATAL_ERROR(ret))
continue; // skip to next file
}
else
{
snprintf(thumbfn,sizeof(thumbfn),"%s.%s",
av[i],T.tformat == LIBRAW_THUMBNAIL_JPEG ? "thumb.jpg" : "thumb.ppm");
if(verbose) printf("Writing thumbnail file %s\n",thumbfn);
if( LIBRAW_SUCCESS != (ret = RawProcessor.dcraw_thumb_writer(thumbfn)))
{
fprintf(stderr,"Cannot write %s: %s\n",thumbfn,libraw_strerror(ret));
if(LIBRAW_FATAL_ERROR(ret))
continue;
}
}
}
if(OUT.document_mode)
ret = RawProcessor.dcraw_document_mode_processing();
else
ret = RawProcessor.dcraw_process();
if(LIBRAW_SUCCESS !=ret)
{
fprintf(stderr,"Cannot do postpocessing on %s: %s\n",
av[i],libraw_strerror(ret));
if(LIBRAW_FATAL_ERROR(ret))
continue;
}
snprintf(outfn,sizeof(outfn),
"%s.%s",
av[i], OUT.output_tiff ? "tiff" : (P1.colors>1?"ppm":"pgm"));
if(verbose) printf("Writing file %s\n",outfn);
if( LIBRAW_SUCCESS != (ret = RawProcessor.dcraw_ppm_tiff_writer(outfn)))
fprintf(stderr,"Cannot write %s: %s\n",outfn,libraw_strerror(ret));
RawProcessor.recycle(); // just for show this call
}
return 0;
}
const char* libraw_unpack_function_name(libraw_data_t* lr)
{
if(!lr) return "NULL parameter passed";
LibRaw *ip = (LibRaw*) lr->parent_class;
return ip->unpack_function_name();
}
bool KDcraw::extractRAWData(const QString& filePath, QByteArray& rawData, DcrawInfoContainer& identify, unsigned int shotSelect)
{
QFileInfo fileInfo(filePath);
QString rawFilesExt(rawFiles());
QString ext = fileInfo.suffix().toUpper();
identify.isDecodable = false;
if (!fileInfo.exists() || ext.isEmpty() || !rawFilesExt.toUpper().contains(ext))
return false;
if (m_cancel)
return false;
d->setProgress(0.1);
LibRaw raw;
// Set progress call back function.
raw.set_progress_handler(callbackForLibRaw, d);
int ret = raw.open_file((const char*)(QFile::encodeName(filePath)).constData());
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run open_file: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.3);
raw.imgdata.params.output_bps = 16;
raw.imgdata.params.shot_select = shotSelect;
ret = raw.unpack();
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run unpack: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.4);
ret = raw.raw2image();
if (ret != LIBRAW_SUCCESS)
{
qCDebug(LIBKDCRAW_LOG) << "LibRaw: failed to run raw2image: " << libraw_strerror(ret);
raw.recycle();
return false;
}
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.6);
Private::fillIndentifyInfo(&raw, identify);
if (m_cancel)
{
raw.recycle();
return false;
}
d->setProgress(0.8);
rawData = QByteArray();
if (raw.imgdata.idata.filters == 0)
{
rawData.resize((int)(raw.imgdata.sizes.iwidth * raw.imgdata.sizes.iheight * raw.imgdata.idata.colors * sizeof(unsigned short)));
unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
for (unsigned int row = 0; row < raw.imgdata.sizes.iheight; row++)
{
for (unsigned int col = 0; col < raw.imgdata.sizes.iwidth; col++)
{
for (int color = 0; color < raw.imgdata.idata.colors; color++)
{
*output = raw.imgdata.image[raw.imgdata.sizes.iwidth*row + col][color];
output++;
}
}
}
}
else
{
rawData.resize((int)(raw.imgdata.sizes.iwidth * raw.imgdata.sizes.iheight * sizeof(unsigned short)));
unsigned short* output = reinterpret_cast<unsigned short*>(rawData.data());
for (uint row = 0; row < raw.imgdata.sizes.iheight; row++)
{
for (uint col = 0; col < raw.imgdata.sizes.iwidth; col++)
{
*output = raw.imgdata.image[raw.imgdata.sizes.iwidth*row + col][raw.COLOR(row, col)];
output++;
}
}
}
raw.recycle();
d->setProgress(1.0);
return true;
}
JNIEXPORT jobject JNICALL Java_com_cateye_core_jni_RawImageLoader_loadImageDescriptionFromFile
(JNIEnv * env, jobject, jstring filename)
{
// Getting the classes
jclass imageDescription_class = env->FindClass("Lcom/cateye/core/jni/RawImageDescription;");
jclass previewBitmap_class = env->FindClass("Lcom/cateye/core/jni/PreviewBitmap;");
// jclass date_class = env->FindClass("Ljava/util/Date;");
// Getting the methods
jmethodID previewBitmap_init = env->GetMethodID(previewBitmap_class, "<init>", "()V");
jmethodID imageDescription_init = env->GetMethodID(imageDescription_class, "<init>", "()V");
// jmethodID date_init = env->GetMethodID(date_class, "<init>", "(J)V");
// Getting the field ids
jfieldID thumbnail_id = env->GetFieldID(imageDescription_class, "thumbnail", "Lcom/cateye/core/IPreviewBitmap;"),
flip_id = env->GetFieldID(imageDescription_class, "flip", "I"),
isoSpeed_id = env->GetFieldID(imageDescription_class, "isoSpeed", "F"),
shutter_id = env->GetFieldID(imageDescription_class, "shutter", "F"),
aperture_id = env->GetFieldID(imageDescription_class, "aperture", "F"),
focalLength_id = env->GetFieldID(imageDescription_class, "focalLength", "F"),
timeStamp_id = env->GetFieldID(imageDescription_class, "timeStamp", "J"),
shotOrder_id = env->GetFieldID(imageDescription_class, "shotOrder", "I"),
description_id = env->GetFieldID(imageDescription_class, "description", "Ljava/lang/String;"),
artist_id = env->GetFieldID(imageDescription_class, "artist", "Ljava/lang/String;"),
cameraMaker_id = env->GetFieldID(imageDescription_class, "cameraMaker", "Ljava/lang/String;"),
cameraModel_id = env->GetFieldID(imageDescription_class, "cameraModel", "Ljava/lang/String;");
jobject previewBitmap;
jobject timestamp = NULL;
jobject imageDescription;
const char* fn;
long time_con;
int ret;
LibRaw* RawProcessor = NULL;
libraw_processed_image_t *image = NULL;
DEBUG_INFO fn = env->GetStringUTFChars(filename, NULL);
if (fn == NULL) {
printf("Error: NULL string!\n");
return NULL;
}
DEBUG_INFO RawProcessor = new LibRaw();
DEBUG_INFO ret = RawProcessor->open_file(fn, RAWPROCESSOR_OPEN_BUFFER);
if (ret != LIBRAW_SUCCESS)
{
goto end;
}
DEBUG_INFO if ((ret = RawProcessor->unpack_thumb()) != LIBRAW_SUCCESS)
{
goto end;
}
DEBUG_INFO imageDescription = env->NewObject(imageDescription_class, imageDescription_init);
// Setting fields
printf("[Native] flip = %d\n", RawProcessor->imgdata.sizes.flip);
DEBUG_INFO env->SetIntField(imageDescription, flip_id, RawProcessor->imgdata.sizes.flip); // 0 - no rotation; 3 - 180-deg rotation; 5 - 90-deg counterclockwise, 6 - 90-deg clockwise
printf("[Native] iso speed = %f\n", RawProcessor->imgdata.other.iso_speed);
env->SetFloatField(imageDescription, isoSpeed_id, RawProcessor->imgdata.other.iso_speed);
printf("[Native] shutter = %f\n", RawProcessor->imgdata.other.shutter);
env->SetFloatField(imageDescription, shutter_id, RawProcessor->imgdata.other.shutter);
printf("[Native] aperture = %f\n", RawProcessor->imgdata.other.aperture);
env->SetFloatField(imageDescription, aperture_id, RawProcessor->imgdata.other.aperture);
printf("[Native] focal length = %f\n", RawProcessor->imgdata.other.focal_len);
env->SetFloatField(imageDescription, focalLength_id, RawProcessor->imgdata.other.focal_len);
printf("[Native] shot order = %d\n", RawProcessor->imgdata.other.shot_order);
env->SetIntField(imageDescription, shotOrder_id, RawProcessor->imgdata.other.shot_order);
DEBUG_INFO time_con = RawProcessor->imgdata.other.timestamp;
printf("[Native] timestamp = %d\n", time_con);
//timestamp = env->NewObject(date_class, date_init, time_con);
//env->SetObjectField(imageDescription, timeStamp_id, timestamp);
DEBUG_INFO env->SetLongField(imageDescription, timeStamp_id, time_con);
printf("[Native] description = %s\n", RawProcessor->imgdata.other.desc);
env->SetObjectField(imageDescription, description_id, env->NewStringUTF(RawProcessor->imgdata.other.desc));
printf("[Native] artist = %s\n", RawProcessor->imgdata.other.artist);
env->SetObjectField(imageDescription, artist_id, env->NewStringUTF(RawProcessor->imgdata.other.artist));
printf("[Native] camera maker = %s\n", RawProcessor->imgdata.idata.make);
env->SetObjectField(imageDescription, cameraMaker_id, env->NewStringUTF(RawProcessor->imgdata.idata.make));
printf("[Native] camera model = %s\n", RawProcessor->imgdata.idata.model);
env->SetObjectField(imageDescription, cameraModel_id, env->NewStringUTF(RawProcessor->imgdata.idata.model));
DEBUG_INFO
fflush(stdout);
DEBUG_INFO previewBitmap = env->NewObject(previewBitmap_class, previewBitmap_init);
// Getting bitmap field ids
jfieldID r_id, g_id, b_id, width_id, height_id;
r_id = env->GetFieldID(previewBitmap_class, "r", "J");
g_id = env->GetFieldID(previewBitmap_class, "g", "J");
b_id = env->GetFieldID(previewBitmap_class, "b", "J");
width_id = env->GetFieldID(previewBitmap_class, "width", "I");
height_id = env->GetFieldID(previewBitmap_class, "height", "I");
PreviewBitmap thumb;
// Extracting and saving the thumbnail picture
DEBUG_INFO image = RawProcessor->dcraw_make_mem_thumb(&ret);
if (image == 0)
{
goto end;
}
printf("[Native] Image type: %s\n", (image->type == LIBRAW_IMAGE_JPEG) ? "jpeg" : "bitmap");
if (image->type == LIBRAW_IMAGE_JPEG)
{
decode_jpeg(thumb, image->data, image->data_size);
}
else
{
decode_plain(thumb, image->width, image->height, image->data, image->data_size);
}
DEBUG_INFO
// Setting field values
env->SetIntField(previewBitmap, width_id, thumb.width);
env->SetIntField(previewBitmap, height_id, thumb.height);
env->SetLongField(previewBitmap, r_id, (jlong)(thumb.r));
env->SetLongField(previewBitmap, g_id, (jlong)(thumb.g));
env->SetLongField(previewBitmap, b_id, (jlong)(thumb.b));
env->SetObjectField(imageDescription, thumbnail_id, previewBitmap);
DEBUG_INFO
RawProcessor->recycle(); // just for show this call...
// use it if you want to load something else
end:
DEBUG_INFO if (image != NULL) LibRaw::dcraw_clear_mem(image);
DEBUG_INFO if (RawProcessor != NULL) delete RawProcessor;
DEBUG_INFO env->ReleaseStringUTFChars(filename, fn);
DEBUG_INFO if (ret != LIBRAW_SUCCESS)
{
DEBUG_INFO throw_libraw_exception(env, ret);
}
DEBUG_INFO return imageDescription;
}
void libraw_set_dataerror_handler(libraw_data_t* lr,data_callback func,void *data)
{
if(!lr) return;
LibRaw *ip = (LibRaw*) lr->parent_class;
ip->set_dataerror_handler(func,data);
}
