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; } }
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 *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; }
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; }
int main(void) { gdImagePtr im; if ( ( im = gdImageCreateFromGifPtr(157, (char*) &gifdata[0]) ) != NULL) { fprintf(stderr, "success!\n"); gdImageDestroy(im); } else { fprintf(stderr, "failed!\n"); } return 0; }
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 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; }
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 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 main() { gdImagePtr src, dst; int r, g, b; void *p; int size = 0; int status = 0; CuTestImageResult result = {0, 0}; src = gdImageCreate(100, 100); if (src == NULL) { printf("could not create src\n"); return 1; } r = gdImageColorAllocate(src, 0xFF, 0, 0); g = gdImageColorAllocate(src, 0, 0xFF, 0); b = gdImageColorAllocate(src, 0, 0, 0xFF); gdImageFilledRectangle(src, 0, 0, 99, 99, r); gdImageRectangle(src, 20, 20, 79, 79, g); gdImageEllipse(src, 70, 25, 30, 20, b); #define OUTPUT_GIF(name) do { \ FILE *fp; \ \ fp = fopen("gif_im2im_" #name ".gif", "wb"); \ if (fp) { \ gdImageGif(name, fp); \ fclose(fp); \ } \ } while (0) OUTPUT_GIF(src); p = gdImageGifPtr(src, &size); if (p == NULL) { status = 1; printf("p is null\n"); goto door0; } if (size <= 0) { status = 1; printf("size is non-positive\n"); goto door1; } dst = gdImageCreateFromGifPtr(size, p); if (dst == NULL) { status = 1; printf("could not create dst\n"); goto door1; } OUTPUT_GIF(dst); gdTestImageDiff(src, dst, NULL, &result); if (result.pixels_changed > 0) { status = 1; printf("pixels changed: %d\n", result.pixels_changed); } gdImageDestroy(dst); door1: gdFree(p); door0: gdImageDestroy(src); return status; }
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; }
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 }
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; }
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; }