static int
szm_do_scale_png(char *in, int in_len, uint8_t scale, char **out, int *out_len)
{
gdImagePtr im_in, im_out;
int x, y, new_x, new_y;
im_in = gdImageCreateFromPngPtr(in_len, in);
if (!im_in)
return -SZM_ERR_IMGFMT;
x = gdImageSX(im_in);
y = gdImageSY(im_in);
new_x = x / scale;
new_y = y / scale;
if (new_x == 0)
new_x = 1;
if (new_y == 0)
new_y = 1;
im_out = gdImageCreateTrueColor(new_x, new_y);
if (!im_out) {
gdImageDestroy(im_in);
return -SZM_ERR_IMGPROC;
}
gdImageCopyResized(im_out, im_in, 0, 0, 0, 0,
im_out->sx, im_out->sy, im_in->sx, im_in->sy);
*out = gdImagePngPtr(im_out, out_len);
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return 0;
}
static void *resizeImage( const char *buf, int bufLen, int width, int height, MyData *myData, int *size )
{
char *ptr;
gdImagePtr dest, src;
if ( myData->IMAGE_TYPE == HTTP_IMG_JPEG )
src = gdImageCreateFromJpegPtr( bufLen, (void *)buf );
else if ( myData->IMAGE_TYPE == HTTP_IMG_GIF )
src = gdImageCreateFromGifPtr( bufLen, (void *)buf );
else if ( myData->IMAGE_TYPE == HTTP_IMG_PNG )
src = gdImageCreateFromPngPtr( bufLen, (void *)buf );
else
return NULL;
if ( !width && !height )
return NULL;
else if ( !width )
width = height * src->sx / src->sy;
else if ( !height )
height = width * src->sy / src->sx;
dest = gdImageCreateTrueColor( width, height );
gdImageCopyResampled( dest, src, 0, 0, 0, 0,
width, height,
src->sx, src->sy );
if ( myData->IMAGE_TYPE == HTTP_IMG_JPEG )
ptr = gdImageJpegPtr( dest, size, 50 );
else if ( myData->IMAGE_TYPE == HTTP_IMG_GIF )
ptr = gdImageGifPtr( dest, size );
else if ( myData->IMAGE_TYPE == HTTP_IMG_PNG )
ptr = gdImagePngPtr( dest, size );
return ptr;
}
EF_Error ef_video_load_texture_memory(uint8_t *bytes, size_t size,
GLuint id,
int build_mipmaps)
{
if(size < 4)
return EF_ERROR_IMAGE_DATA;
gdImagePtr image = NULL;
if((bytes[0] == 0x89) &&
(bytes[1] == 'P') &&
(bytes[2] == 'N') &&
(bytes[3] == 'G'))
{
image = gdImageCreateFromPngPtr(size, bytes);
} else if((bytes[0] == 'G') &&
(bytes[1] == 'I') &&
(bytes[2] == 'F') &&
(bytes[3] == '8'))
{
image = gdImageCreateFromGifPtr(size, bytes);
} else if((bytes[0] == 0xFF) &&
(bytes[1] == 0xD8))
{
image = gdImageCreateFromJpegPtr(size, bytes);
}
if(!image) {
return EF_ERROR_IMAGE_DATA;
}
EF_Error result = ef_internal_video_load_texture_gd_image(image, id, build_mipmaps);
gdImageDestroy(image);
return result;
}
static gdImagePtr
ngx_http_image_source(ngx_http_request_t *r, ngx_http_image_filter_ctx_t *ctx)
{
char *failed;
gdImagePtr img;
img = NULL;
switch (ctx->type)
{
case NGX_HTTP_IMAGE_JPEG:
img = gdImageCreateFromJpegPtr(ctx->length, ctx->image);
failed = "gdImageCreateFromJpegPtr() failed";
break;
case NGX_HTTP_IMAGE_GIF:
img = gdImageCreateFromGifPtr(ctx->length, ctx->image);
failed = "gdImageCreateFromGifPtr() failed";
break;
case NGX_HTTP_IMAGE_PNG:
img = gdImageCreateFromPngPtr(ctx->length, ctx->image);
failed = "gdImageCreateFromPngPtr() failed";
break;
default:
failed = "unknown image type";
break;
}
if (img == NULL)
{
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed);
}
return img;
}
static void water_image_from(void * conf)
{
int size = 0;
void * buffer;
char * water_file;
ngx_image_conf_t *info = conf;
info->water_im = NULL;
water_file = (char *)info->water_image.data;
info->water_im_type = get_ext_header(water_file);
if((read_img(&water_file,&size,&buffer)) == 0)
{
switch(info->water_im_type)
{
case NGX_IMAGE_GIF:
info->water_im = gdImageCreateFromGifPtr(size,buffer);
break;
case NGX_IMAGE_JPEG:
info->water_im = gdImageCreateFromJpegPtr(size,buffer);
break;
case NGX_IMAGE_PNG:
info->water_im = gdImageCreateFromPngPtr(size,buffer);
break;
}
free(buffer);
return;
}
}
int
Texture::open(const char* _filename)
{
sprintf(filename, "%s", _filename);
fprintf(stdout, "filename = %s\n", filename);
// open the png file and create gd image
FILE* fp = 0;
fp = fopen(filename, "rb");
if(!fp)
{
perror("Texture::open()");
return -1;
}
// load the data to memory
fseek(fp, 0, SEEK_END);
int fileLen = ftell(fp);
fseek(fp, 0, SEEK_SET);
unsigned char srcdata[fileLen];
fread(srcdata, 1, fileLen, fp);
fclose(fp);
// the format should be .jpg, .JPG, .png, .PNG
char *pFormat = strrchr(filename, '.');
if(!pFormat)
{
perror("Texture::open()");
return -1;
}
if(identifyFileFormat(pFormat)==JPG)
{
im = gdImageCreateFromJpegPtr(fileLen, srcdata);
if(!im) {
perror("Texture::open()");
return -1;
}
w = im->sx;
h = im->sy;
}
else if(identifyFileFormat(pFormat)==PNG)
{
im = gdImageCreateFromPngPtr(fileLen, srcdata);
if(!im) {
perror("Texture::open()");
return -1;
}
w = im->sx;
h = im->sy;
}
else
{
fprintf(stderr, "unknown file format (%s).\n", pFormat);
return -1;
}
return 0;
}
void GuiImageData::LoadPNG(const u8 *img, int imgSize)
{
gdImagePtr gdImg = gdImageCreateFromPngPtr(imgSize, (u8*) img);
if(gdImg == 0)
return;
data = GDImageToRGBA8(&gdImg, &width, &height);
gdImageDestroy(gdImg);
}
gdImagePtr ImgLoadGd(const char *filename, unsigned int *filesize) {
FILE *file;
gdImagePtr img;
char blah[4], *tmp;
uint16_t sig16;
uint32_t sig32;
long filelen;
if (!filename)
return NULL;
file = NULL;
tmp = NULL;
img = NULL;
file = fopen(filename, "rb");
if (!file)
return NULL;
if (!fread(blah, 4, 1, file))
goto done;
fseek(file, 0, SEEK_END);
filelen = ftell(file);
rewind(file);
if (filesize)
*filesize = filelen;
tmp = malloc(filelen);
if (!fread(tmp, filelen, 1, file))
goto done;
sig16 = LE16(*(uint16_t *)blah);
sig32 = LE32(*(uint32_t *)blah);
if (sig16 == 0xD8FF) {
img = gdImageCreateFromJpegPtr(filelen, tmp);
} else if (sig32 == 'GNP\x89') {
img = gdImageCreateFromPngPtr(filelen, tmp);
} else if (sig32 == '8FIG') {
img = gdImageCreateFromGifPtr(filelen, tmp);
} else if (sig16 == 'MB') {
img = gdImageCreateFromWBMPPtr(filelen, tmp);
} else {
fprintf(stderr, "WARNING: %s is an unsupported image format\n", filename);
}
done:
if (file)
fclose(file);
if (tmp)
free(tmp);
return img;
}
gdImagePtr cgi_create_image(int pic_type, int size, void* data)
{
switch (pic_type) {
case jpg:
return gdImageCreateFromJpegPtr(size, data);
case png:
return gdImageCreateFromPngPtr(size, data);
case gif:
return gdImageCreateFromGifPtr(size, data);
default:
CGI_ERROR_LOG("bad pic type\t[%u]", pic_type);
return NULL;
}
}
static int
szm_do_box_png(char *in, int in_len, uint16_t boxsize, char **out, int *out_len)
{
int x, y;
int new_x, new_y;
gdImagePtr im_in, im_out;
im_in = gdImageCreateFromPngPtr(in_len, in);
if (!im_in)
return -SZM_ERR_IMGFMT;
x = gdImageSX(im_in);
y = gdImageSY(im_in);
if (x == 0)
x = 1;
if (y == 0)
y = 1;
if (x <= boxsize && y <= boxsize) {
*out = gdImagePngPtr(im_in, out_len);
gdImageDestroy(im_in);
return 0;
}
if (x > y) {
new_y = boxsize * y / x;
new_x = boxsize;
} else {
new_x = x * boxsize / y;
new_y = boxsize;
}
if (new_x == 0)
new_x = 1;
if (new_y == 0)
new_y = 1;
im_out = gdImageCreateTrueColor(new_x, new_y);
if (!im_out) {
gdImageDestroy(im_in);
return -SZM_ERR_IMGPROC;
}
gdImageCopyResized(im_out, im_in, 0, 0, 0, 0,
im_out->sx, im_out->sy, im_in->sx, im_in->sy);
*out = gdImagePngPtr(im_out, out_len);
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return 0;
}
static gdImagePtr puzzle_create_gdimage_from_mem(const void * const mem, const size_t size)
{
gdImagePtr gdimage = NULL;
PuzzleImageTypeCode image_type_code = puzzle_get_image_type_from_header(mem);
switch (image_type_code) {
case PUZZLE_IMAGE_TYPE_JPEG:
gdimage = gdImageCreateFromJpegPtr(size, (void *)mem);
break;
case PUZZLE_IMAGE_TYPE_PNG:
gdimage = gdImageCreateFromPngPtr(size, (void *)mem);
break;
case PUZZLE_IMAGE_TYPE_GIF:
gdimage = gdImageCreateFromGifPtr(size, (void *)mem);
break;
default:
gdimage = NULL;
}
return gdimage;
}
static gdImagePtr ngx_http_small_light_gd_src(ngx_http_small_light_gd_ctx_t *ictx)
{
gdImagePtr src = NULL;
switch (ictx->type) {
case NGX_HTTP_SMALL_LIGHT_IMAGE_JPEG:
src = gdImageCreateFromJpegPtr(ictx->image_len, ictx->image);
break;
case NGX_HTTP_SMALL_LIGHT_IMAGE_GIF:
src = gdImageCreateFromGifPtr(ictx->image_len, ictx->image);
break;
case NGX_HTTP_SMALL_LIGHT_IMAGE_PNG:
src = gdImageCreateFromPngPtr(ictx->image_len, ictx->image);
break;
default:
break;
}
return src;
}
int fswc_add_image_png(src_t *src, avgbmp_t *abitmap)
{
uint32_t x, y;
gdImage *im;
im = gdImageCreateFromPngPtr(src->length, src->img);
if(!im) return(-1);
for(y = 0; y < src->height; y++)
for(x = 0; x < src->width; x++)
{
int c = gdImageGetPixel(im, x, y);
*(abitmap++) += (c & 0xFF0000) >> 16;
*(abitmap++) += (c & 0x00FF00) >> 8;
*(abitmap++) += (c & 0x0000FF);
}
gdImageDestroy(im);
return(0);
}
static void image_from(void * conf)
{
int size = 0;
void * buffer;
ngx_image_conf_t *info = conf;
info->src_im = NULL;
if((read_img(&info->source_file,&size,&buffer)) == 0)
{
switch(info->src_type)
{
case NGX_IMAGE_GIF:
info->src_im = gdImageCreateFromGifPtr(size,buffer);
break;
case NGX_IMAGE_JPEG:
info->src_im = gdImageCreateFromJpegPtr(size,buffer);
break;
case NGX_IMAGE_PNG:
info->src_im = gdImageCreateFromPngPtr(size,buffer);
break;
}
free(buffer);
return;
}
}
int ThumbCacheGet(int nitems, unsigned int *offsets,
LPTCENTRY *entries, gdImagePtr *thumbs) {
unsigned char *thumbdata, *thumbbuf;
LPTCENTRY ptcent;
TCENTRY tcent;
int i, nsuccess;
FILE *file;
if (!offsets || !entries || !thumbs)
return 0;
nsuccess = 0;
if (burstmode) {
for (i = 0; i != nitems; i++) {
ptcent = (LPTCENTRY)((char *)cachemap.addr + offsets[i]);
thumbdata = (unsigned char *)ptcent + sizeof(TCENTRY) + ptcent->fnlen + 1;
if (ptcent->thumbfsize >= THUMB_MAX_SIZE) {
entries[i] = NULL;
thumbs[i] = NULL;
fprintf(stderr, "WARNING: thumb filesize too big, ignoring\n");
continue;
}
thumbs[i] = gdImageCreateFromPngPtr(ptcent->thumbfsize, thumbdata);
if (!thumbs[i]) {
entries[i] = NULL;
continue;
}
entries[i] = ptcent;
nsuccess++;
}
} else {
file = fopen(thumb_cache_fn, "rb");
if (!file)
return 0;
nsuccess = 0;
for (i = 0; i != nitems; i++) {
thumbs[i] = NULL;
entries[i] = NULL;
if (fseek(file, offsets[i], SEEK_SET))
continue;
fread(&tcent, sizeof(TCENTRY), 1, file);
if (ferror(file))
continue;
if (tcent.thumbfsize >= THUMB_MAX_SIZE) {
fprintf(stderr, "WARNING: thumb filesize too big, ignoring\n");
continue;
}
ptcent = malloc(sizeof(TCENTRY) + tcent.fnlen + 1);
memcpy(ptcent, &tcent, sizeof(TCENTRY));
fread(ptcent->filename, 1, tcent.fnlen + 1, file);
if (ferror(file)) {
free(ptcent);
continue;
}
thumbbuf = malloc(tcent.thumbfsize);
fread(thumbbuf, tcent.thumbfsize, 1, file);
if (ferror(file)) {
free(ptcent);
free(thumbbuf);
continue;
}
thumbs[i] = gdImageCreateFromPngPtr(tcent.thumbfsize, thumbbuf);
free(thumbbuf);
if (!thumbs[i]) {
free(ptcent);
continue;
}
entries[i] = ptcent;
nsuccess++;
}
fclose(file);
}
return nsuccess;
}
int main(int argc, char **argv)
{
gdImagePtr ptr;
char* buffer;
int size;
int res;
if (argc<2)
{
printf("Usage: %s <input_file>\n", argv[0]);
return 0;
}
size = read_file(argv[1], &buffer);
if (size <= 0)
{
return 0;
}
char ext[6];
res = read_extenstion(buffer, size, ext);
if (res < 0)
{
//printf("ext: %s\n", ext);
//printf("extention not correct\n");
exit(0);
}
switch (res)
{
case 1:
//open png
printf("openning png\n");
ptr = gdImageCreateFromPngPtr(size-5, (void *)buffer);
break;
case 2:
//open gif
printf("openning gif\n");
ptr = gdImageCreateFromGifPtr(size-5, (void *)buffer);
break;
case 3:
//open jpg
printf("openning jpg\n");
ptr = gdImageCreateFromJpegPtr(size-5, (void *)buffer);
break;
case 4:
//open tga
printf("openning tga\n");
ptr = gdImageCreateFromTgaPtr(size-5, (void *)buffer);
break;
case 5:
//open tiff
printf("openning tiff\n");
ptr = gdImageCreateFromTiffPtr(size-5, (void *)buffer);
break;
// case 6:
// //open webp
// printf("openning webp\n");
// exit(0);
// //gdImageWebpPtr()
// break;
default:
printf("error!\n");
exit(0);
}
printf("ptr: %p\n", ptr);
//gdImagePtr ptr2;
int new_size;
FILE *output;
output = fopen("/dev/null", "wb");
gdImageWebp(ptr, output);
return 0;
// char * filename = argv[1];
// printf("opening: %s\n", filename);
// FILE *in;
// in = fopen(filename, "r");
// if (in!=NULL)
// {
// im = gdImageCreateFromPng(in);
// printf("imageptr: %p\n", im);
// }
//printf("Main\n");
return 0;
}
result_t Image::load(Buffer_base *data)
{
std::string strBuf;
data->toString(strBuf);
if (strBuf.length() < 2)
return CHECK_ERROR(CALL_E_INVALIDARG);
int32_t format;
unsigned char ch1 = (unsigned char) strBuf[0];
unsigned char ch2 = (unsigned char) strBuf[1];
if (ch1 == 0x47 && ch2 == 0x49)
format = gd_base::_GIF;
else if (ch1 == 0x89 && ch2 == 0x50)
format = gd_base::_PNG;
else if (ch1 == 0xff && ch2 == 0xd8)
format = gd_base::_JPEG;
else if ((ch1 == 0x49 && ch2 == 0x49) || (ch1 == 0x4d && ch2 == 0x4d))
format = gd_base::_TIFF;
else if (ch1 == 0x42 && ch2 == 0x4d)
format = gd_base::_BMP;
else if (ch1 == 0x52 && ch2 == 0x49)
format = gd_base::_WEBP;
else
return CHECK_ERROR(CALL_E_INVALID_DATA);
switch (format)
{
case gd_base::_GIF:
m_image = gdImageCreateFromGifPtr((int32_t) strBuf.length(),
(void *) strBuf.c_str());
break;
case gd_base::_PNG:
m_image = gdImageCreateFromPngPtr((int32_t) strBuf.length(),
(void *) strBuf.c_str());
break;
case gd_base::_JPEG:
m_image = gdImageCreateFromJpegPtr((int32_t) strBuf.length(),
(void *) strBuf.c_str());
if (m_image != NULL)
{
EXIFInfo result;
result.parseFrom((const unsigned char *) strBuf.c_str(),
(uint32_t)strBuf.length());
switch (result.Orientation)
{
case 2:
gdImageFlipHorizontal(m_image);
break;
case 3:
gdImageFlipBoth(m_image);
break;
case 4:
gdImageFlipVertical(m_image);
break;
case 5:
gdImageFlipVertical(m_image);
case 6:
rotate(gd_base::_RIGHT);
break;
case 7:
gdImageFlipVertical(m_image);
case 8:
rotate(gd_base::_LEFT);
break;
}
}
break;
case gd_base::_TIFF:
m_image = gdImageCreateFromTiffPtr((int32_t) strBuf.length(),
(void *) strBuf.c_str());
break;
case gd_base::_BMP:
m_image = gdImageCreateFromBmpPtr((int32_t) strBuf.length(),
(void *) strBuf.c_str());
break;
case gd_base::_WEBP:
m_image = gdImageCreateFromWebpPtr((int32_t) strBuf.length(),
(void *) strBuf.c_str());
break;
}
if (m_image == NULL)
return CHECK_ERROR(CALL_E_INVALIDARG);
setExtMemory();
m_type = format;
return 0;
}
static ngx_buf_t *
ngx_http_pngquant_quantize(ngx_http_request_t *r, ngx_http_pngquant_ctx_t *ctx)
{
u_char *out;
ngx_buf_t *b;
ngx_pool_cleanup_t *cln;
ngx_http_pngquant_conf_t *conf;
gdImagePtr img;
int size;
ngx_int_t rc;
ngx_temp_file_t *tf;
ssize_t n;
ngx_ext_rename_file_t ext;
ngx_str_t dest;
ngx_str_t value;
img = gdImageCreateFromPngPtr(ctx->length, ctx->image);
if (img == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gdImageCreateFromPngPtr() failed");
return NULL;
}
conf = ngx_http_get_module_loc_conf(r, ngx_http_pngquant_module);
/*
* gdImageTrueColorToPaletteSetMethod(img, GD_QUANT_LIQ, conf->speed);
* gdImageTrueColorToPalette(img, conf->dither, conf->colors);
*/
ngx_pngquant_gd_image(img, conf->dither, conf->colors, conf->speed);
out = gdImagePngPtr(img, &size);
gdImageDestroy(img);
ngx_pfree(r->pool, ctx->image);
if (out == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"gdImagePngPtr() failed");
return NULL;
}
if (conf->store) {
if(ngx_http_complex_value(r, conf->store, &value) != NGX_OK) {
goto failed;
}
dest.len = value.len + 1;
dest.data = ngx_pnalloc(r->pool, dest.len);
if (dest.data == NULL) {
goto failed;
}
ngx_memzero(dest.data, dest.len);
ngx_memcpy(dest.data, value.data, value.len);
ngx_log_debug(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
"pngquant_store (%s)", dest.data);
tf = ngx_pcalloc(r->pool, sizeof(ngx_temp_file_t));
if (tf == NULL) {
goto failed;
}
tf->file.fd = NGX_INVALID_FILE;
tf->file.log = r->connection->log;
tf->path = conf->temp_path;
tf->pool = r->pool;
tf->persistent = 1;
rc = ngx_create_temp_file(&tf->file, tf->path, tf->pool, tf->persistent,
tf->clean, tf->access);
if (rc != NGX_OK) {
goto failed;
}
n = ngx_write_fd(tf->file.fd, out, size);
if (n == NGX_FILE_ERROR) {
ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
ngx_write_fd_n " \"%s\" failed", tf->file.name.data);
goto failed;
}
if ((int) n != size) {
ngx_log_error(NGX_LOG_ALERT, r->connection->log, ngx_errno,
ngx_write_fd_n " has written only %z of %uz bytes",
n, size);
goto failed;
}
ext.access = conf->store_access;
ext.path_access = conf->store_access;
ext.time = -1;
ext.create_path = 1;
ext.delete_file = 1;
ext.log = r->connection->log;
rc = ngx_ext_rename_file(&tf->file.name, &dest, &ext);
if (rc != NGX_OK) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
"ngx_ext_rename_file() failed");
goto failed;
}
}
cln = ngx_pool_cleanup_add(r->pool, 0);
if (cln == NULL) {
goto failed;
}
b = ngx_pcalloc(r->pool, sizeof(ngx_buf_t));
if (b == NULL) {
goto failed;
}
cln->handler = ngx_http_pngquant_cleanup;
cln->data = out;
b->pos = out;
b->last = out + size;
b->memory = 1;
b->last_buf = 1;
ngx_http_pngquant_length(r, b);
#if defined(nginx_version) && (nginx_version >= 1007003)
ngx_http_weak_etag(r);
#endif
return b;
failed:
gdFree(out);
return NULL;
}
static int
put_file_func (CameraFilesystem *fs, const char *folder, const char *name,
CameraFileType type, CameraFile *file, void *data, GPContext *context)
{
#ifdef HAVE_GD
Camera *camera = data;
char *c, *in_name, *out_name, *filedata = NULL;
int ret, in_width, in_height, in_x, in_y;
size_t inc, outc;
double aspect_in, aspect_out;
#ifdef HAVE_ICONV
char *in, *out;
#endif
unsigned long filesize = 0;
gdImagePtr rotated, im_out, im_in = NULL;
if (strcmp (folder, "/"))
return GP_ERROR_DIRECTORY_NOT_FOUND;
inc = strlen (name);
in_name = strdup (name);
outc = inc;
out_name = malloc (outc + 1);
if (!in_name || !out_name) {
free (in_name);
free (out_name);
return GP_ERROR_NO_MEMORY;
}
/* Convert name to ASCII */
#ifdef HAVE_ICONV
in = in_name;
out = out_name;
if (iconv (camera->pl->cd, &in, &inc, &out, &outc) == -1) {
free (in_name);
free (out_name);
gp_log (GP_LOG_ERROR, "iconv",
"Failed to convert filename to ASCII");
return GP_ERROR_OS_FAILURE;
}
outc = out - out_name;
out_name[outc] = 0;
#else
for (i = 0; i < inc; i++) {
if ((uint8_t)in_name[i] < 0x20 || (uint8_t)in_name[i] > 0x7E)
out_name[i] = '?';
else
out_name[i] = in_name[i];
}
out_name[i] = 0;
#endif
free (in_name);
/* Remove file extension, and if necessary truncate the name */
c = strrchr (out_name, '.');
if (c)
*c = 0;
if (outc > ST2205_FILENAME_LENGTH)
out_name[ST2205_FILENAME_LENGTH] = 0;
ret = gp_file_get_data_and_size (file, (const char **)&filedata,
&filesize);
if (ret < 0) { free (out_name); return ret; }
/* Try loading the file using gd, starting with the most often
used types first */
/* gdImageCreateFromJpegPtr is chatty on error, don't call it on
non JPEG files */
if (filesize > 2 &&
(uint8_t)filedata[0] == 0xff && (uint8_t)filedata[1] == 0xd8)
im_in = gdImageCreateFromJpegPtr(filesize, filedata);
if (im_in == NULL)
im_in = gdImageCreateFromPngPtr(filesize, filedata);
if (im_in == NULL)
im_in = gdImageCreateFromGifPtr(filesize, filedata);
if (im_in == NULL)
im_in = gdImageCreateFromWBMPPtr(filesize, filedata);
if (im_in == NULL) {
gp_log (GP_LOG_ERROR, "st2205",
"Unrecognized file format for file: %s%s",
folder, name);
free (out_name);
return GP_ERROR_BAD_PARAMETERS;
}
if (needs_rotation (camera)) {
rotated = gdImageCreateTrueColor (im_in->sy, im_in->sx);
if (rotated == NULL) {
gdImageDestroy (im_in);
free (out_name);
return GP_ERROR_NO_MEMORY;
}
rotate90 (im_in, rotated);
gdImageDestroy (im_in);
im_in = rotated;
}
im_out = gdImageCreateTrueColor(camera->pl->width, camera->pl->height);
if (im_out == NULL) {
gdImageDestroy (im_in);
free (out_name);
return GP_ERROR_NO_MEMORY;
}
/* Keep aspect */
aspect_in = (double)im_in->sx / im_in->sy;
aspect_out = (double)im_out->sx / im_out->sy;
if (aspect_in > aspect_out) {
/* Reduce in width (crop left and right) */
in_width = (im_in->sx / aspect_in) * aspect_out;
in_x = (im_in->sx - in_width) / 2;
in_height = im_in->sy;
in_y = 0;
} else {
/* Reduce in height (crop top and bottom) */
in_width = im_in->sx;
in_x = 0;
in_height = (im_in->sy * aspect_in) / aspect_out;
in_y = (im_in->sy - in_height) / 2;
}
gdImageCopyResampled (im_out, im_in, 0, 0, in_x, in_y,
im_out->sx, im_out->sy,
in_width, in_height);
if (im_in->sx != im_out->sx ||
im_in->sy != im_out->sy)
gdImageSharpen(im_out, 100);
ret = st2205_write_file (camera, out_name, im_out->tpixels);
if (ret >= 0) {
/* Add to our filenames list */
ST2205_SET_FILENAME(camera->pl->filenames[ret], out_name, ret);
/* And commit the changes to the device */
ret = st2205_commit(camera);
}
gdImageDestroy (im_in);
gdImageDestroy (im_out);
free (out_name);
return ret;
#else
gp_log(GP_LOG_ERROR,"st2205", "GD compression not supported - no libGD present during build");
return GP_ERROR_NOT_SUPPORTED;
#endif
}
static int
put_file_func (CameraFilesystem *fs, const char *folder, CameraFile *file,
void *data, GPContext *context)
{
#ifdef HAVE_GD
Camera *camera = data;
char *filedata = NULL;
const char *name;
int ret, in_width, in_height, in_x, in_y;
double aspect_in, aspect_out;
unsigned long filesize = 0;
gdImagePtr im_out, im_in = NULL;
if (strcmp (folder, "/"))
return GP_ERROR_DIRECTORY_NOT_FOUND;
CHECK (gp_file_get_name (file, &name))
CHECK (gp_file_get_data_and_size (file, (const char **)&filedata,
&filesize))
/* Try loading the file using gd, starting with the most often
used types first */
/* gdImageCreateFromJpegPtr is chatty on error, don't call it on
non JPEG files */
if (filesize > 2 &&
(uint8_t)filedata[0] == 0xff && (uint8_t)filedata[1] == 0xd8)
im_in = gdImageCreateFromJpegPtr(filesize, filedata);
if (im_in == NULL)
im_in = gdImageCreateFromPngPtr(filesize, filedata);
if (im_in == NULL)
im_in = gdImageCreateFromGifPtr(filesize, filedata);
if (im_in == NULL)
im_in = gdImageCreateFromWBMPPtr(filesize, filedata);
if (im_in == NULL) {
gp_log (GP_LOG_ERROR, "tp6801",
"Unrecognized file format for file: %s%s",
folder, name);
return GP_ERROR_BAD_PARAMETERS;
}
im_out = gdImageCreateTrueColor(camera->pl->width, camera->pl->height);
if (im_out == NULL) {
gdImageDestroy (im_in);
return GP_ERROR_NO_MEMORY;
}
/* Keep aspect */
aspect_in = (double)im_in->sx / im_in->sy;
aspect_out = (double)im_out->sx / im_out->sy;
if (aspect_in > aspect_out) {
/* Reduce in width (crop left and right) */
in_width = (im_in->sx / aspect_in) * aspect_out;
in_x = (im_in->sx - in_width) / 2;
in_height = im_in->sy;
in_y = 0;
} else {
/* Reduce in height (crop top and bottom) */
in_width = im_in->sx;
in_x = 0;
in_height = (im_in->sy * aspect_in) / aspect_out;
in_y = (im_in->sy - in_height) / 2;
}
gdImageCopyResampled (im_out, im_in, 0, 0, in_x, in_y,
im_out->sx, im_out->sy,
in_width, in_height);
if (im_in->sx != im_out->sx ||
im_in->sy != im_out->sy)
gdImageSharpen(im_out, 100);
ret = tp6801_write_file (camera, im_out->tpixels);
if (ret >= 0) {
/* Commit the changes to the device */
ret = tp6801_commit(camera);
}
gdImageDestroy (im_in);
gdImageDestroy (im_out);
return ret;
#else
gp_log(GP_LOG_ERROR,"tp6801", "GD compression not supported - no libGD present during build");
return GP_ERROR_NOT_SUPPORTED;
#endif
}
void ThumbCacheEnumerate(int level) {
LPTCHEADER ptchdr;
LPTCENTRY ptcent;
unsigned char *thumbdata;
unsigned int pos;
gdImagePtr thumb;
int nentries = 0, ndelentries = 0;
if (!ThumbCacheBurstReadBegin(0)) {
fprintf(stderr, "ERROR: failed to open cache for mapping\n");
return;
}
if (level >= TC_DUMP_IMGS) {
if (!outpath[0]) {
fprintf(stderr, "ERROR: must specify an output path\n");
return;
}
if (createdir(outpath) == -1 && errno != EEXIST) {
perror("mkdir");
return;
}
if (chdir(outpath) == -1) {
perror("chdir");
return;
}
}
ptchdr = (LPTCHEADER)cachemap.addr;
if (level >= TC_DUMP_INFO) {
printf("Directory last modified: %s"
"Thumb cache entries:\n"
"file "
"thumb key\tthumb len\tlast modified\n",
asctime(localtime(&ptchdr->lastupdate)));
}
pos = sizeof(TCHEADER);
while (pos < cachemap.maplen) {
ptcent = (LPTCENTRY)((char *)cachemap.addr + pos);
if (ptcent->mtime != TC_MTIME_DELETED) {
if (level >= TC_DUMP_INFO) {
printf("%-26s%f\t%d\t%s", ptcent->filename, ptcent->thumbkey,
ptcent->thumbfsize, asctime(localtime(&ptcent->mtime)));
}
if (level >= TC_DUMP_IMGS) {
thumbdata = (unsigned char *)ptcent + sizeof(TCENTRY) + ptcent->fnlen + 1;
thumb = gdImageCreateFromPngPtr(ptcent->thumbfsize, thumbdata);
if (!thumb) {
fprintf(stderr, "ERROR: failed to create image from thumbcache\n");
continue;
}
if (!ImgSavePng(ptcent->filename, thumb)) {
if (errno == ENOENT) {
if (verbose)
printf("creating directory structure for %s\n", ptcent->filename);
if (!BuildPath(ptcent->filename)) {
fprintf(stderr, "ERROR: failed to build "
"directory to %s\n", ptcent->filename);
gdImageDestroy(thumb);
continue;
}
if (!ImgSavePng(ptcent->filename, thumb)) {
fprintf(stderr, "ERROR: failed to save %s after "
"building directory\n", ptcent->filename);
gdImageDestroy(thumb);
continue;
}
} else {
fprintf(stderr, "ERROR: failed to save %s\n", ptcent->filename);
gdImageDestroy(thumb);
continue;
}
}
gdImageDestroy(thumb);
}
nentries++;
} else {
ndelentries++;
}
pos += sizeof(TCENTRY) + ptcent->fnlen + 1 + ptcent->thumbfsize;
}
if (level >= TC_DUMP_IMGS && chdir(workdir) == -1) {
perror("chdir");
return;
}
printf("Number of thumb cache entries: %d\n"
"Number of deleted thumb cache entries: %d\n",
nentries, ndelentries);
ThumbCacheBurstReadEnd();
}
int
main (int argc, char **argv)
{
#ifdef HAVE_LIBPNG
gdImagePtr im, ref, im2, im3;
FILE *in, *out;
void *iptr;
int sz;
char of[256];
int colRed, colBlu;
gdSource imgsrc;
gdSink imgsnk;
int foreground;
int i;
if (argc != 2)
{
fprintf (stderr, "Usage: gdtest filename.png\n");
exit (1);
}
in = fopen (argv[1], "rb");
if (!in)
{
fprintf (stderr, "Input file does not exist!\n");
exit (1);
}
im = gdImageCreateFromPng (in);
rewind (in);
ref = gdImageCreateFromPng (in);
fclose (in);
printf ("Reference File has %d Palette entries\n", ref->colorsTotal);
CompareImages ("Initial Versions", ref, im);
/* */
/* Send to PNG File then Ptr */
/* */
#ifdef VMS
sprintf (of, "%s-png", argv[1]);
#else
sprintf (of, "%s.png", argv[1]);
#endif
out = fopen (of, "wb");
gdImagePng (im, out);
fclose (out);
in = fopen (of, "rb");
if (!in)
{
fprintf (stderr, "PNG Output file does not exist!\n");
exit (1);
}
im2 = gdImageCreateFromPng (in);
fclose (in);
CompareImages ("GD->PNG File->GD", ref, im2);
unlink (of);
gdImageDestroy (im2);
/* 2.0.21: use the new From*Ptr functions */
iptr = gdImagePngPtr (im, &sz);
im2 = gdImageCreateFromPngPtr (sz, iptr);
gdFree (iptr);
CompareImages ("GD->PNG ptr->GD", ref, im2);
gdImageDestroy (im2);
/* */
/* Send to GD2 File then Ptr */
/* */
#ifdef VMS
sprintf (of, "%s-gd2", argv[1]);
#else
sprintf (of, "%s.gd2", argv[1]);
#endif
out = fopen (of, "wb");
gdImageGd2 (im, out, 128, 2);
fclose (out);
in = fopen (of, "rb");
if (!in)
{
fprintf (stderr, "GD2 Output file does not exist!\n");
exit (1);
}
im2 = gdImageCreateFromGd2 (in);
fclose (in);
CompareImages ("GD->GD2 File->GD", ref, im2);
unlink (of);
gdImageDestroy (im2);
iptr = gdImageGd2Ptr (im, 128, 2, &sz);
/*printf("Got ptr %d (size %d)\n",iptr, sz); */
im2 = gdImageCreateFromGd2Ptr (sz, iptr);
gdFree (iptr);
/*printf("Got img2 %d\n",im2); */
CompareImages ("GD->GD2 ptr->GD", ref, im2);
gdImageDestroy (im2);
/* */
/* Send to GD File then Ptr */
/* */
#ifdef VMS
sprintf (of, "%s-gd", argv[1]);
#else
sprintf (of, "%s.gd", argv[1]);
#endif
out = fopen (of, "wb");
gdImageGd (im, out);
fclose (out);
in = fopen (of, "rb");
if (!in)
{
fprintf (stderr, "GD Output file does not exist!\n");
exit (1);
}
im2 = gdImageCreateFromGd (in);
fclose (in);
CompareImages ("GD->GD File->GD", ref, im2);
unlink (of);
gdImageDestroy (im2);
iptr = gdImageGdPtr (im, &sz);
/*printf("Got ptr %d (size %d)\n",iptr, sz); */
im2 = gdImageCreateFromGdPtr (sz, iptr);
gdFree (iptr);
/*printf("Got img2 %d\n",im2); */
CompareImages ("GD->GD ptr->GD", ref, im2);
gdImageDestroy (im2);
/*
* Test gdImageCreateFromPngSource'
*/
in = fopen (argv[1], "rb");
imgsrc.source = freadWrapper;
imgsrc.context = in;
im2 = gdImageCreateFromPngSource (&imgsrc);
fclose (in);
if (im2 == NULL)
{
printf
("GD Source: ERROR Null returned by gdImageCreateFromPngSource\n");
}
else
{
CompareImages ("GD Source", ref, im2);
gdImageDestroy (im2);
};
/*
* Test gdImagePngToSink'
*/
#ifdef VMS
sprintf (of, "%s-snk", argv[1]);
#else
sprintf (of, "%s.snk", argv[1]);
#endif
out = fopen (of, "wb");
imgsnk.sink = fwriteWrapper;
imgsnk.context = out;
gdImagePngToSink (im, &imgsnk);
fclose (out);
in = fopen (of, "rb");
if (!in)
{
fprintf (stderr,
"GD Sink: ERROR - GD Sink Output file does not exist!\n");
}
else
{
im2 = gdImageCreateFromPng (in);
fclose (in);
CompareImages ("GD Sink", ref, im2);
gdImageDestroy (im2);
};
unlink (of);
/* */
/* Test Extraction */
/* */
in = fopen ("test/gdtest_200_300_150_100.png", "rb");
if (!in)
{
fprintf (stderr, "gdtest_200_300_150_100.png does not exist!\n");
exit (1);
}
im2 = gdImageCreateFromPng (in);
fclose (in);
in = fopen ("test/gdtest.gd2", "rb");
if (!in)
{
fprintf (stderr, "gdtest.gd2 does not exist!\n");
exit (1);
}
im3 = gdImageCreateFromGd2Part (in, 200, 300, 150, 100);
fclose (in);
CompareImages ("GD2Part (gdtest_200_300_150_100.png, gdtest.gd2(part))",
im2, im3);
gdImageDestroy (im2);
gdImageDestroy (im3);
/* */
/* Copy Blend */
/* */
in = fopen ("test/gdtest.png", "rb");
if (!in)
{
fprintf (stderr, "gdtest.png does not exist!\n");
exit (1);
}
im2 = gdImageCreateFromPng (in);
fclose (in);
im3 = gdImageCreate (100, 60);
colRed = gdImageColorAllocate (im3, 255, 0, 0);
colBlu = gdImageColorAllocate (im3, 0, 0, 255);
gdImageFilledRectangle (im3, 0, 0, 49, 30, colRed);
gdImageFilledRectangle (im3, 50, 30, 99, 59, colBlu);
gdImageCopyMerge (im2, im3, 150, 200, 10, 10, 90, 50, 50);
gdImageCopyMerge (im2, im3, 180, 70, 10, 10, 90, 50, 50);
gdImageCopyMergeGray (im2, im3, 250, 160, 10, 10, 90, 50, 50);
gdImageCopyMergeGray (im2, im3, 80, 70, 10, 10, 90, 50, 50);
gdImageDestroy (im3);
in = fopen ("test/gdtest_merge.png", "rb");
if (!in)
{
fprintf (stderr, "gdtest_merge.png does not exist!\n");
exit (1);
}
im3 = gdImageCreateFromPng (in);
fclose (in);
printf ("[Merged Image has %d colours]\n", im2->colorsTotal);
CompareImages ("Merged (gdtest.png, gdtest_merge.png)", im2, im3);
gdImageDestroy (im2);
gdImageDestroy (im3);
#ifdef HAVE_LIBJPEG
out = fopen ("test/gdtest.jpg", "wb");
if (!out)
{
fprintf (stderr, "Can't create file test/gdtest.jpg.\n");
exit (1);
}
gdImageJpeg (im, out, -1);
fclose (out);
in = fopen ("test/gdtest.jpg", "rb");
if (!in)
{
fprintf (stderr, "Can't open file test/gdtest.jpg.\n");
exit (1);
}
im2 = gdImageCreateFromJpeg (in);
fclose (in);
if (!im2)
{
fprintf (stderr, "gdImageCreateFromJpeg failed.\n");
exit (1);
}
gdImageDestroy (im2);
printf ("Created test/gdtest.jpg successfully. Compare this image\n"
"to the input image manually. Some difference must be\n"
"expected as JPEG is a lossy file format.\n");
#endif /* HAVE_LIBJPEG */
/* Assume the color closest to black is the foreground
color for the B&W wbmp image. */
fprintf (stderr,
"NOTE: the WBMP output image will NOT match the original unless the original\n"
"is also black and white. This is OK!\n");
foreground = gdImageColorClosest (im, 0, 0, 0);
fprintf (stderr, "Foreground index is %d\n", foreground);
if (foreground == -1)
{
fprintf (stderr, "Source image has no colors, skipping wbmp test.\n");
}
else
{
out = fopen ("test/gdtest.wbmp", "wb");
if (!out)
{
fprintf (stderr, "Can't create file test/gdtest.wbmp.\n");
exit (1);
}
gdImageWBMP (im, foreground, out);
fclose (out);
in = fopen ("test/gdtest.wbmp", "rb");
if (!in)
{
fprintf (stderr, "Can't open file test/gdtest.wbmp.\n");
exit (1);
}
im2 = gdImageCreateFromWBMP (in);
fprintf (stderr, "WBMP has %d colors\n", gdImageColorsTotal (im2));
fprintf (stderr, "WBMP colors are:\n");
for (i = 0; (i < gdImageColorsTotal (im2)); i++)
{
fprintf (stderr, "%02X%02X%02X\n",
gdImageRed (im2, i),
gdImageGreen (im2, i), gdImageBlue (im2, i));
}
fclose (in);
if (!im2)
{
fprintf (stderr, "gdImageCreateFromWBMP failed.\n");
exit (1);
}
CompareImages ("WBMP test (gdtest.png, gdtest.wbmp)", ref, im2);
out = fopen ("test/gdtest_wbmp_to_png.png", "wb");
if (!out)
{
fprintf (stderr,
"Can't create file test/gdtest_wbmp_to_png.png.\n");
exit (1);
}
gdImagePng (im2, out);
fclose (out);
gdImageDestroy (im2);
}
gdImageDestroy (im);
gdImageDestroy (ref);
#else
fprintf (stderr, "No PNG library support.\n");
#endif /* HAVE_LIBPNG */
return 0;
}
gdImagePtr ImageRead( struct ImageLibrary *im, File *rootDev, const char *path )
{
gdImagePtr img = NULL;
FHandler *fh = rootDev->f_FSys;
File *rfp = (File *)fh->FileOpen( rootDev, path, "rb" );
if( rfp != NULL )
{
BufString *bs = BufStringNew( );
char buffer[ 20048 ];
int len = 0;
while( ( len = fh->FileRead( rfp, buffer, 20048 ) ) > 0 )
{
BufStringAddSize( bs, buffer, len );
}
img = gdImageCreateFromJpegPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
if( img == NULL )
{
if( img == NULL )
{
img = gdImageCreateFromBmpPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
if( img == NULL )
{
img = gdImageCreateFromGifPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
if( img == NULL )
{
img = gdImageCreateFromPngPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
if( img == NULL )
{
img = gdImageCreateFromTgaPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
if( img == NULL )
{
img = gdImageCreateFromTiffPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
if( img == NULL )
{
img = gdImageCreateFromWBMPPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
if( img == NULL )
{
img = gdImageCreateFromWebpPtr( bs->bs_Size, (void *)bs->bs_Buffer ) ;
}
}
}
}
}
}
}
}
if( img == NULL )
{
ERROR("Graphics format not recognized\n");
}
BufStringDelete( bs );
fh->FileClose( rootDev, rfp );
}
else
{
ERROR("Cannot open file: %s to read\n", path );
}
return img;
}
