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; }