static int get_file_func (CameraFilesystem *fs, const char *folder,
const char *filename, CameraFileType type,
CameraFile *file, void *user_data, GPContext *context)
{
Camera *camera = user_data;
int image_no, result;
image_no = gp_filesystem_number(camera->fs, folder, filename, context);
if(image_no < 0)
return image_no;
gp_file_set_name (file, filename);
gp_file_set_mime_type (file, GP_MIME_PNM);
switch (type) {
case GP_FILE_TYPE_NORMAL:
result = stv0680_get_image (camera->port, image_no, file);
break;
case GP_FILE_TYPE_RAW:
result = stv0680_get_image_raw (camera->port, image_no, file);
break;
case GP_FILE_TYPE_PREVIEW:
result = stv0680_get_image_preview (camera->port, image_no, file);
break;
default:
return (GP_ERROR_NOT_SUPPORTED);
}
return result;
}
/**
* Captures a preview that won't be stored on the camera but returned in
* supplied file.
*
* @param camera a #Camera
* @param file a #CameraFile
* @param context a #GPContext
* @return a gphoto2 error code
*
* For example, you could use gp_capture_preview() for taking some sample
* pictures before calling gp_capture().
*
**/
int
gp_camera_capture_preview (Camera *camera, CameraFile *file, GPContext *context)
{
char *xname;
C_PARAMS (camera && file);
CHECK_INIT (camera, context);
CR (camera, gp_file_clean (file), context);
if (!camera->functions->capture_preview) {
gp_context_error (context, _("This camera can "
"not capture previews."));
CAMERA_UNUSED (camera, context);
return (GP_ERROR_NOT_SUPPORTED);
}
CHECK_RESULT_OPEN_CLOSE (camera, camera->functions->capture_preview (
camera, file, context), context);
gp_file_get_name_by_type (file, "capture_preview", GP_FILE_TYPE_NORMAL, &xname);
/* FIXME: Marcus ... will go away, just keep compatible now. */
gp_file_set_name (file, xname);
free (xname);
CAMERA_UNUSED (camera, context);
return (GP_OK);
}
static int
get_file_func (CameraFilesystem *fs, const char *folder,
const char *filename, CameraFileType type,
CameraFile *file, void *user_data, GPContext *context)
{
Camera *camera = user_data;
int number, filetype;
CHECK (number = gp_filesystem_number (camera->fs, folder, filename,
context));
switch (type) {
case GP_FILE_TYPE_NORMAL:
CHECK (gsmart300_request_file (camera->pl, file, number));
break;
case GP_FILE_TYPE_PREVIEW:
CHECK (gsmart300_request_thumbnail
(camera->pl, file, number, &filetype));
if (filetype == GSMART_FILE_TYPE_IMAGE) {
CHECK (gp_file_set_mime_type (file, GP_MIME_BMP));
}
break;
default:
return GP_ERROR_NOT_SUPPORTED;
}
CHECK (gp_file_set_name (file, filename));
return GP_OK;
}
char gpi_jpeg_write(CameraFile *file, const char *filename, jpeg *myjpeg)
{
int x;
CHECK_RESULT (gp_file_set_name (file, filename));
CHECK_RESULT (gp_file_set_mime_type(file, GP_MIME_JPEG));
for (x=0; x<myjpeg->count; x++)
CHECK_RESULT (gp_file_append(file, (char*)myjpeg->marker[x]->data, myjpeg->marker[x]->size));
return 1;
}
static int
camera_capture (Camera* camera, CameraCaptureType type, CameraFilePath* path,
GPContext *context)
{
int r;
CameraFile *file = NULL;
CameraFileInfo info;
KncCamRes cr;
KncCntrlRes cntrl_res;
KncImageInfo i;
C_NULL (camera && path);
/* We only support capturing of images */
if (type != GP_CAPTURE_IMAGE) return (GP_ERROR_NOT_SUPPORTED);
/* Stop the timeout, take the picture, and restart the timeout. */
gp_camera_stop_timeout (camera, camera->pl->timeout);
gp_file_new (&file);
knc_cntrl_set_func_data (camera->pl->c, data_func, file);
cntrl_res = knc_take_picture (camera->pl->c, &cr, KNC_SOURCE_CARD, &i);
camera->pl->timeout = gp_camera_start_timeout (camera, PING_TIMEOUT,
timeout_func);
if (cntrl_res) gp_file_unref (file);
CR (cntrl_res, context);
sprintf (path->name, "%06i.jpeg", (int) i.id);
strcpy (path->folder, "/");
r = gp_filesystem_append (camera->fs, path->folder,
path->name, context);
if (r < 0) {
gp_file_unref (file);
return r;
}
info.preview.fields = GP_FILE_INFO_SIZE | GP_FILE_INFO_TYPE;
gp_file_get_data_and_size (file, NULL, &info.preview.size);
strcpy (info.preview.type, GP_MIME_JPEG);
info.file.fields = GP_FILE_INFO_SIZE | GP_FILE_INFO_PERMISSIONS |
GP_FILE_INFO_TYPE | GP_FILE_INFO_NAME;
info.file.size = i.size;
info.file.permissions = GP_FILE_PERM_READ;
if (!i.prot) info.file.permissions |= GP_FILE_PERM_DELETE;
strcpy (info.file.type, GP_MIME_JPEG);
snprintf (info.file.name, sizeof (info.file.name),
"%06i.jpeg", (int) i.id);
gp_filesystem_set_info_noop (camera->fs, path->folder, info, context);
gp_file_set_name (file, info.file.name);
gp_file_set_mime_type (file, GP_MIME_JPEG);
gp_file_set_type (file, GP_FILE_TYPE_EXIF);
gp_filesystem_set_file_noop (camera->fs, path->folder, file, context);
gp_file_unref (file);
return (GP_OK);
}
static int get_file_func (CameraFilesystem *fs, const char *folder,
const char *filename, CameraFileType type,
CameraFile *file, void *data, GPContext *context)
{
Camera *camera = data;
int file_number=0, result;
char buffer[128];
file_number = gp_filesystem_number(fs, folder, filename, context);
if (file_number < 0)
return (file_number);
switch (type) {
case GP_FILE_TYPE_NORMAL:
gp_file_set_mime_type (file, GP_MIME_JPEG);
gp_file_set_name (file, filename);
result = dimagev_get_picture (camera->pl, file_number + 1, file);
break;
case GP_FILE_TYPE_PREVIEW:
gp_file_set_mime_type (file, GP_MIME_PPM);
#if defined HAVE_SNPRINTF
snprintf(buffer, sizeof(buffer), DIMAGEV_THUMBNAIL_FMT, ( file_number + 1) );
#else
sprintf(buffer, DIMAGEV_THUMBNAIL_FMT, ( file_number + 1) );
#endif
gp_file_set_name (file, buffer);
result = dimagev_get_thumbnail (camera->pl, file_number + 1, file);
break;
default:
return (GP_ERROR_NOT_SUPPORTED);
}
if (result < 0) {
GP_DEBUG( "camera_file_get::unable to retrieve image file");
return result;
}
sleep(2);
return GP_OK;
}
static int camera_capture_preview (Camera *camera, CameraFile *file, GPContext *context)
{
char *data;
int size, result;
result = stv0680_capture_preview (camera->port, &data, &size);
if (result < 0)
return result;
gp_file_set_name (file, "capture.pnm");
gp_file_set_mime_type (file, GP_MIME_PNM);
gp_file_set_data_and_size (file, data, size);
return (GP_OK);
}
static int
get_info (Camera *camera, unsigned int n, CameraFileInfo *info,
CameraFile *file, GPContext *context)
{
unsigned char *buffer = NULL;
KncCamRes cr;
KncCntrlRes cntrl_res;
KncImageInfo i;
/*
* Remove the timeout, get the information and restart the
* timeout afterwards.
*/
gp_camera_stop_timeout (camera, camera->pl->timeout);
knc_cntrl_set_func_data (camera->pl->c, data_func, file);
cntrl_res = knc_get_image_info (camera->pl->c, &cr, n, &i);
camera->pl->timeout = gp_camera_start_timeout (camera, PING_TIMEOUT,
timeout_func);
CR (cntrl_res, context);
info->audio.fields = GP_FILE_INFO_NONE;
info->preview.fields = GP_FILE_INFO_TYPE;
strcpy (info->preview.type, GP_MIME_JPEG);
info->file.fields = GP_FILE_INFO_SIZE | GP_FILE_INFO_PERMISSIONS |
GP_FILE_INFO_TYPE | GP_FILE_INFO_NAME;
info->file.size = i.size * 1000;
info->file.permissions = GP_FILE_PERM_READ;
if (!i.prot) info->file.permissions |= GP_FILE_PERM_DELETE;
strcpy (info->file.type, GP_MIME_JPEG);
snprintf (info->file.name, sizeof (info->file.name),
"%06i.jpeg", (int) i.id);
if (file) {
gp_file_set_type (file, GP_FILE_TYPE_EXIF);
gp_file_set_name (file, info->file.name);
} else
free (buffer);
return (GP_OK);
}
static int get_file_func (CameraFilesystem *fs, const char *folder,
const char *filename, CameraFileType type,
CameraFile *file, void *user_data,
GPContext *context)
{
Camera *camera = user_data;
unsigned char *data = NULL;
int size,ret,index;
size = 0;
index = gp_filesystem_number(fs, folder, filename, context);
if (index < 0)
return index;
switch(type)
{
case GP_FILE_TYPE_NORMAL:
ret=camera_get_file(camera, context, index, &data, &size);
break;
default:
return GP_ERROR_NOT_SUPPORTED;
}
gp_file_set_data_and_size(file, data, size);
gp_file_set_name (file, filename);
return GP_OK;
}
static int
get_file_func (CameraFilesystem *fs, const char *folder, const char *filename,
CameraFileType type, CameraFile *file, void *data,
GPContext *context)
{
Camera *camera = data;
int idx, size;
#ifdef HAVE_GD
int ret;
gdImagePtr im, rotated;
void *gdpng;
#endif
idx = get_file_idx(camera->pl, folder, filename);
if (idx < 0)
return idx;
if (type == GP_FILE_TYPE_RAW) {
unsigned char *raw;
size = st2205_read_raw_file (camera, idx, &raw);
if (size < 0) return size;
gp_file_set_mime_type (file, GP_MIME_RAW);
gp_file_set_name (file, filename);
gp_file_set_data_and_size (file, (char *)raw, size);
return GP_OK;
}
#ifdef HAVE_GD
if (type != GP_FILE_TYPE_NORMAL)
return GP_ERROR_NOT_SUPPORTED;
im = gdImageCreateTrueColor(camera->pl->width, camera->pl->height);
if (im == NULL)
return GP_ERROR_NO_MEMORY;
ret = st2205_read_file(camera, idx, im->tpixels);
if (ret < 0) {
gdImageDestroy (im);
return ret;
}
if (needs_rotation (camera)) {
rotated = gdImageCreateTrueColor (im->sy, im->sx);
if (rotated == NULL) {
gdImageDestroy (im);
return GP_ERROR_NO_MEMORY;
}
rotate270 (im, rotated);
gdImageDestroy (im);
im = rotated;
}
gdpng = gdImagePngPtr(im, &size);
gdImageDestroy (im);
if (gdpng == NULL)
return GP_ERROR_NO_MEMORY;
ret = gp_file_set_mime_type (file, GP_MIME_PNG);
if (ret < 0) { gdFree (gdpng); return ret; }
ret = gp_file_set_name (file, filename);
if (ret < 0) { gdFree (gdpng); return ret; }
ret = gp_file_append (file, gdpng, size);
gdFree (gdpng);
return ret;
#else
gp_log(GP_LOG_ERROR,"st2205", "GD decompression not supported - no libGD present during build");
return GP_ERROR_NOT_SUPPORTED;
#endif
}
static int
get_file_func (CameraFilesystem *fs, const char *folder, const char *filename,
CameraFileType type, CameraFile *file, void *user_data,
GPContext *context)
{
Camera *camera = user_data;
int status = GP_OK;
int w, h = 0, k;
int i,j;
int b = 0;
int compressed = 0;
unsigned char header[5] = "\xff\xff\xff\xff\x55";
unsigned int size;
unsigned char *data;
unsigned char *image_start;
unsigned char *p_data=NULL;
unsigned char *ppm=NULL, *ptr=NULL;
unsigned char gtable[256];
unsigned char temp;
GP_DEBUG ("Downloading pictures!\n");
/* These are cheap cameras. There ain't no EXIF data. So kill this. */
if (GP_FILE_TYPE_EXIF == type) return GP_ERROR_FILE_EXISTS;
/* Get the number of the photo on the camera */
k = gp_filesystem_number (camera->fs, "/", filename, context);
GP_DEBUG ("Filesystem number is %i\n",k);
b = jl2005a_get_pic_data_size(camera->port, k);
GP_DEBUG("b = %i = 0x%x bytes\n", b,b);
w = jl2005a_get_pic_width(camera->port);
GP_DEBUG ("width is %i\n", w);
h = jl2005a_get_pic_height(camera->port);
GP_DEBUG ("height is %i\n", h);
/* Image data to be downloaded contains header and footer bytes */
data = malloc (b+14);
if (!data) return GP_ERROR_NO_MEMORY;
jl2005a_read_picture_data (camera, camera->port, data, b+14);
if (memcmp(header,data,5) != 0)
/* Image data is corrupted! Repeat the operation. */
jl2005a_read_picture_data (camera, camera->port, data, b+14);
if (GP_FILE_TYPE_RAW == type) {
gp_file_set_mime_type(file, GP_MIME_RAW);
gp_file_set_name(file, filename);
gp_file_set_data_and_size(file, (char *)data , b+14 );
return GP_OK;
}
/* Now get ready to put the data into a PPM image file. */
p_data = malloc( w*h );
if (!p_data) {
status = GP_ERROR_NO_MEMORY;
goto end;
}
image_start=data+5;
if (w == 176) {
for (i=1; i < h; i +=4){
for (j=1; j< w; j ++){
temp=image_start[i*w+j];
image_start[i*w+j] = image_start[(i+1)*w+j];
image_start[(i+1)*w+j] = temp;
}
}
if (h == 72) {
compressed = 1;
h = 144;
}
} else
if (h == 144) {
compressed = 1;
h = 288;
}
p_data = malloc( w*h );
if (!p_data) {
status = GP_ERROR_NO_MEMORY;
goto end;
}
if (compressed)
jl2005a_decompress (image_start, p_data, w, h);
else
memcpy(p_data, image_start, w*h);
ppm = malloc (w * h * 3 + 256); /* room for data and header */
if (!ppm) {
status = GP_ERROR_NO_MEMORY;
goto end;
}
sprintf ((char *)ppm,
"P6\n"
"# CREATOR: gphoto2, JL2005A library\n"
"%d %d\n"
"255\n", w, h);
size = strlen ((char *)ppm);
ptr = ppm + size;
size = size + (w * h * 3);
GP_DEBUG ("size = %i\n", size);
gp_ahd_decode (p_data, w , h, ptr, BAYER_TILE_BGGR);
free(p_data);
gp_gamma_fill_table (gtable, .65);
gp_gamma_correct_single (gtable, ptr, w * h);
gp_file_set_mime_type (file, GP_MIME_PPM);
gp_file_set_name (file, filename);
gp_file_set_data_and_size (file, (char *)ppm, size);
end:
free(data);
return status;
return GP_OK;
}
bool GPCamera::uploadItem(const QString& folder, const QString& itemName, const QString& localFile, CamItemInfo& itemInfo)
{
#ifdef HAVE_GPHOTO2
int errorCode;
CameraFile* cfile = 0;
errorCode = gp_file_new(&cfile);
d->status->cancel = false;
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to init new camera file instance!";
printGphotoErrorDescription(errorCode);
return false;
}
errorCode = gp_file_open(cfile, QFile::encodeName(localFile).constData());
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to open file!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
errorCode = gp_file_set_name(cfile, QFile::encodeName(itemName).constData());
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to rename item from camera!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
#ifdef HAVE_GPHOTO25
errorCode = gp_camera_folder_put_file(d->camera,
QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(),
GP_FILE_TYPE_NORMAL,
cfile,
d->status->context);
#else
errorCode = gp_camera_folder_put_file(d->camera,
QFile::encodeName(folder).constData(),
cfile,
d->status->context);
#endif
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to upload item to camera!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
// Get new camera item information.
itemInfo.name = itemName;
itemInfo.folder = folder;
CameraFileInfo info;
errorCode = gp_camera_file_get_info(d->camera, QFile::encodeName(folder).constData(),
QFile::encodeName(itemName).constData(), &info, d->status->context);
if (errorCode != GP_OK)
{
qCDebug(DIGIKAM_IMPORTUI_LOG) << "Failed to get camera item information!";
printGphotoErrorDescription(errorCode);
gp_file_unref(cfile);
return false;
}
itemInfo.ctime = QDateTime();
itemInfo.mime = QString();
itemInfo.size = -1;
itemInfo.width = -1;
itemInfo.height = -1;
itemInfo.downloaded = CamItemInfo::DownloadUnknown;
itemInfo.readPermissions = -1;
itemInfo.writePermissions = -1;
/* The mime type returned by Gphoto2 is dummy with all RAW files.
if (info.file.fields & GP_FILE_INFO_TYPE)
itemInfo.mime = info.file.type;
*/
itemInfo.mime = mimeType(itemInfo.name.section(QLatin1Char('.'), -1).toLower());
if (info.file.fields & GP_FILE_INFO_MTIME)
{
itemInfo.ctime = QDateTime::fromTime_t(info.file.mtime);
}
if (info.file.fields & GP_FILE_INFO_SIZE)
{
itemInfo.size = info.file.size;
}
if (info.file.fields & GP_FILE_INFO_WIDTH)
{
itemInfo.width = info.file.width;
}
if (info.file.fields & GP_FILE_INFO_HEIGHT)
{
itemInfo.height = info.file.height;
}
if (info.file.fields & GP_FILE_INFO_STATUS)
{
if (info.file.status == GP_FILE_STATUS_DOWNLOADED)
{
itemInfo.downloaded = CamItemInfo::DownloadedYes;
}
else
{
itemInfo.downloaded = CamItemInfo::DownloadedNo;
}
}
if (info.file.fields & GP_FILE_INFO_PERMISSIONS)
{
if (info.file.permissions & GP_FILE_PERM_READ)
{
itemInfo.readPermissions = 1;
}
else
{
itemInfo.readPermissions = 0;
}
if (info.file.permissions & GP_FILE_PERM_DELETE)
{
itemInfo.writePermissions = 1;
}
else
{
itemInfo.writePermissions = 0;
}
}
gp_file_unref(cfile);
return true;
#else
Q_UNUSED(folder);
Q_UNUSED(itemName);
Q_UNUSED(localFile);
Q_UNUSED(itemInfo);
return false;
#endif /* HAVE_GPHOTO2 */
}
static int
get_file_func (CameraFilesystem *fs, const char *folder,
const char *filename, CameraFileType type,
CameraFile *file, void *user_data, GPContext *context)
{
Camera *camera = user_data;
unsigned char *data = NULL;
int size, number, filetype, flash_file_count = 0;
CHECK (number =
gp_filesystem_number (camera->fs, folder, filename, context));
if (cam_has_flash(camera->pl) || cam_has_card(camera->pl) ) {
CHECK (spca50x_flash_get_filecount
(camera->pl, &flash_file_count));
}
switch (type) {
case GP_FILE_TYPE_NORMAL:
if ( number < flash_file_count) {
CHECK (spca50x_flash_get_file (camera->pl,
context, &data, &size,
number, 0));
CHECK (gp_file_set_mime_type
(file, GP_MIME_JPEG));
} else {
CHECK (spca50x_sdram_request_file
(camera->pl, &data, &size,
number-flash_file_count,
&filetype));
if (filetype == SPCA50X_FILE_TYPE_IMAGE) {
CHECK (gp_file_set_mime_type
(file, GP_MIME_JPEG));
} else if (filetype == SPCA50X_FILE_TYPE_AVI) {
CHECK (gp_file_set_mime_type
(file, GP_MIME_AVI));
}
}
break;
case GP_FILE_TYPE_PREVIEW:
if ( number < flash_file_count) {
CHECK (spca50x_flash_get_file (camera->pl,
context, &data, &size,
number, 1));
CHECK (gp_file_set_mime_type (file,
GP_MIME_BMP));
} else {
CHECK (spca50x_sdram_request_thumbnail
(camera->pl, &data, &size,
number-flash_file_count,
&filetype));
if (filetype == SPCA50X_FILE_TYPE_IMAGE) {
CHECK (gp_file_set_mime_type
(file, GP_MIME_BMP));
} else if (filetype == SPCA50X_FILE_TYPE_AVI) {
CHECK (gp_file_set_mime_type
(file, GP_MIME_JPEG));
}
}
break;
default:
return GP_ERROR_NOT_SUPPORTED;
}
if (!data)
return GP_ERROR;
CHECK (gp_file_set_data_and_size (file, data, size));
CHECK (gp_file_set_name (file, filename));
return GP_OK;
}
static int
get_file_func (CameraFilesystem *fs, const char *folder, const char *filename,
CameraFileType type, CameraFile *file, void *user_data,
GPContext *context)
{
int status = GP_OK;
Camera *camera = user_data;
int w, h, b;
int k, next;
unsigned char comp_ratio;
unsigned char lighting;
unsigned char *data = NULL;
unsigned char *p_data = NULL;
unsigned char *ppm;
unsigned char *ptr;
unsigned char gtable[256];
int size;
if(!camera->pl->init_done)
digi_init (camera->port, camera->pl);
/* Get the entry number of the photo on the camera */
k = gp_filesystem_number (camera->fs, "/", filename, context);
if (GP_FILE_TYPE_EXIF ==type) return GP_ERROR_FILE_EXISTS;
if (GP_FILE_TYPE_RAW!=type && GP_FILE_TYPE_NORMAL
!=type && GP_FILE_TYPE_PREVIEW!=type) {
return GP_ERROR_NOT_SUPPORTED;
}
next = camera->pl->last_fetched_entry +1;
while (next < k) {
b = digi_get_data_size (camera->pl, next);
data = malloc(b);
if(!data) return GP_ERROR_NO_MEMORY;
digi_read_picture_data (camera->port, data, b, next);
free(data);
next ++;
}
comp_ratio = digi_get_comp_ratio (camera->pl, k);
w = digi_get_picture_width (camera->pl, k);
switch (w) {
case 176: h = 144; break;
case 640: h = 480; break;
case 320: h = 240; break;
default: h = 288; break;
}
lighting = camera->pl->catalog[k*0x10+0x0b];
b = digi_get_data_size (camera->pl, k);
if (!b) {
GP_DEBUG("Photo number %i deleted?\n",k+1);
camera->pl->last_fetched_entry = k;
return GP_OK;
}
data = malloc (w*h);
if(!data) return GP_ERROR_NO_MEMORY;
GP_DEBUG("Fetch entry %i\n", k);
digi_read_picture_data (camera->port, data, b, k);
camera->pl->last_fetched_entry = k;
if (GP_FILE_TYPE_RAW == type) { /* type is GP_FILE_TYPE_RAW */
size = b;
gp_file_set_mime_type (file, GP_MIME_RAW);
gp_file_set_name (file, filename);
gp_file_append(file, (char *)data, size);
/* Save photo's catalog entry as a footer for the raw file */
gp_file_append(file, (char *)camera->pl->catalog + k*0x10, 0x10);
/* Reset camera when done, for more graceful exit. */
if (k +1 == camera->pl->nb_entries) {
digi_rewind (camera->port, camera->pl);
}
free(data);
return(GP_OK);
}
/*
* Now put the data into a PPM image file.
*/
ppm = malloc (w * h * 3 + 256); /* room for data + header */
if (!ppm) {
status = GP_ERROR_NO_MEMORY;
goto end;
}
snprintf ((char *)ppm, 64,
"P6\n"
"# CREATOR: gphoto2, SQ905C library\n"
"%d %d\n"
"255\n", w, h);
size = strlen ((char *)ppm);
ptr = ppm + size;
size = size + (w * h * 3);
GP_DEBUG ("size = %i\n", size);
p_data = malloc( w*h );
if (!p_data) {
status = GP_ERROR_NO_MEMORY;
goto end;
}
if(comp_ratio) {
digi_decompress (p_data, data, w, h);
} else
memcpy(p_data, data, w*h);
gp_ahd_decode (p_data, w , h , ptr, BAYER_TILE_BGGR);
free(p_data);
digi_postprocess (w, h, ptr);
if (lighting < 0x40) {
GP_DEBUG(
"Low light condition. Using default gamma. \
No white balance.\n");
gp_gamma_fill_table (gtable, .65);
gp_gamma_correct_single(gtable,ptr,w*h);
} else