/* * Bueno, vamos a ver si podemos obtener la pieza * */ int tipojuego_get_tpieza_png( Tipojuego* tj, char* color, char* tpieza, int flags, void** png, int* width, int* height ){ #if GRAPH_ENABLED Tipopieza* tp = tj->tipo_piezas->data[ GETTIPOPIEZA(tj,tpieza) ]; int col = GETCOLOR(tj,color); gdImagePtr gd = graph_tpieza_get_gd( tp, col ); int size = 0; if( flags == GETPNG_PIEZA_CAPTURADA ){ gdImagePtr gd2 = gdImageCreate( gdImageSX( gd ) / 2, gdImageSY( gd ) / 2 ); int transp = gdImageColorAllocate( gd2, 0, 255, 0 ); gdImageColorTransparent( gd2, transp ); gdImageFill( gd2, 0, 0 , transp ); gdImageCopyResized( gd2, gd, 0, 0, 0, 0, gdImageSX(gd2), gdImageSY(gd2), gdImageSX(gd), gdImageSY(gd) ); if( png ) *png = gdImagePngPtr( gd2, &size ); if( width ) *width = gdImageSX( gd2 ); if( height ) *height = gdImageSY( gd2 ); gdImageDestroy( gd2 ); return size; } else { if( png ) *png = gdImagePngPtr( gd, &size ); if( width ) *width = gdImageSX( gd ); if( height ) *height = gdImageSY( gd ); return size; } #endif LOGPRINT( 2, "No compilado con el modulo GD tpieza = %s", tpieza ); return 0; }
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; }
int ImageWrite( struct ImageLibrary *im, File *rootDev, gdImagePtr img, const char *path ) { FHandler *fh = rootDev->f_FSys; File *rfp = (File *)fh->FileOpen( rootDev, path, "wb" ); if( rfp != NULL ) { char *buffer = NULL; int length = 0; int psize = strlen( path ); if( psize > 3 ) //we are checking if file have extension { char ext[ 4 ]; strcpy( ext, &(path[ psize-4 ]) ); ext[ 0 ] = toupper( ext[ 0 ] ); ext[ 1 ] = toupper( ext[ 1 ] ); ext[ 2 ] = toupper( ext[ 2 ] ); if( CHECK_EXT( ext, 'P','N','G' ) ) { buffer = gdImagePngPtr( img, &length ); }else if( CHECK_EXT( ext, 'J','P','G' ) ){ buffer = gdImageJpegPtr( img, &length, 100 ); }else if( CHECK_EXT( ext, 'G','I','F' ) ){ buffer = gdImageGifPtr( img, &length ); }else if( CHECK_EXT( ext, 'W','E','B' ) ){ buffer = gdImageWebpPtr( img, &length ); }else if( CHECK_EXT( ext, 'I','I','F' ) ){ buffer = gdImageTiffPtr( img, &length ); }else if( CHECK_EXT( ext, 'B','M','P' ) ){ buffer = gdImageBmpPtr( img, &length, 100 ); } if( buffer == NULL ) { fh->FileClose( rootDev, rfp ); ERROR("Cannot save picture, GD couldnt create buffer from image\n"); return 2; } else { fh->FileWrite( rfp, buffer, length ); } } else { ERROR("Extension name is too short, file format not recognized\n"); } fh->FileClose( rootDev, rfp ); } else { ERROR("Cannot open file: %s to write\n", path ); return 1; } return 0; }
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; }
value ImagePngData(value img) { ImageData _img = getImage(img); int size; void *ptr = gdImagePngPtr(imageImage(_img),&size); buffer ret = alloc_buffer(NULL); buffer_append_sub(ret,ptr,size); gdFree(ptr); return buffer_to_string(ret); }
static u_char * ngx_http_image_out(ngx_http_request_t *r, ngx_uint_t type, gdImagePtr img, int *size) { char *failed; u_char *out; ngx_int_t jq; ngx_http_image_filter_conf_t *conf; out = NULL; switch (type) { case NGX_HTTP_IMAGE_JPEG: conf = ngx_http_get_module_loc_conf(r, ngx_http_image_filter_module); jq = ngx_http_image_filter_get_value(r, conf->jqcv, conf->jpeg_quality); if (jq <= 0) { return NULL; } out = gdImageJpegPtr(img, size, jq); failed = "gdImageJpegPtr() failed"; break; case NGX_HTTP_IMAGE_GIF: out = gdImageGifPtr(img, size); failed = "gdImageGifPtr() failed"; break; case NGX_HTTP_IMAGE_PNG: out = gdImagePngPtr(img, size); failed = "gdImagePngPtr() failed"; break; case NGX_HTTP_IMAGE_BMP: out = gdImageBmpPtr(img, size, -1); failed = "gdImageBmpPtr() failed"; break; default: failed = "unknown image type"; break; } if (out == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed); } return out; }
/*本函数将code指定的字符写入图片中,将图片大小存储在pic_size中,返回该图片所在的内存地址 写入成功时,返回的内存指针非空 写入失败时,返回的内存指针为空 */ void * sslvpn_write_string_to_pic(s8 *code, s32 *pic_size) { /* Declare color indexes */ s32 black = 0; s32 white = 0; s32 randcolor = 0; s32 i = 0; /* img pointer */ gdImagePtr im; /* Font ptr */ gdFontPtr ftptr=gdFontGetGiant(); /*Picture buffer pointer*/ void *pic_buf_ptr; /* Allocate the image: SSLVPN_VALID_PIC_WIDTH pixels across by SSLVPN_VALID_PIC_HEIGHTS pixels tall */ im = gdImageCreate(SSLVPN_VALID_PIC_WIDTH, SSLVPN_VALID_PIC_HEIGHT); /* Allocate the color white (red, green and blue all maximum). */ /* Since this is the first color in a new image, it will * be the background color. */ white = gdImageColorAllocate(im, 255, 255, 255); /* Allocate the color black (red, green and blue all minimum). */ black = gdImageColorAllocate(im, 0, 0, 0); /* Draw a centered string. */ gdImageString(im, ftptr, (im->sx) / 2 - (strlen(code) * (ftptr->w) / 2), (im->sy) / 2 - ftptr->h / 2, (u8*)code, black); /* Some disturbing points */ for(i = 0; i < SSLVPN_VALID_DISTURB_POINTS; i++) { randcolor = gdImageColorAllocate(im, sslvpn_getRandom(255), sslvpn_getRandom(255), sslvpn_getRandom(255)); gdImageSetPixel(im, sslvpn_getRandom(SSLVPN_VALID_PIC_WIDTH), sslvpn_getRandom(SSLVPN_VALID_PIC_HEIGHT), randcolor); } /* Output the image to buf and asign the length of buf to pic_size. */ pic_buf_ptr = gdImagePngPtr(im, pic_size); /* Destroy the image in memory. */ gdImageDestroy(im); return pic_buf_ptr; }
int ThumbCacheAdd(FILE *tc, const char *filename, time_t mtime) { gdImagePtr thumb = NULL; unsigned int thumbsize, imgsize, offset; void *thumbdata; TCENTRY tcent; int status = 0, closetc = 0; if (!filename) return 0; if (!tc) { closetc = 1; tc = fopen(thumb_cache_fn, "rb+"); if (!tc) goto end; if (fseek(tc, 0, SEEK_END)) goto end; } thumb = ThumbCreate(filename, &imgsize); if (!thumb) goto end; thumbdata = gdImagePngPtr(thumb, (int *)&thumbsize); if (!thumbdata) goto end; tcent.mtime = mtime; tcent.thumbfsize = thumbsize; tcent.thumbkey = _ThumbCalcKey(thumb->tpixels); offset = _ThumbCacheWriteEntry(tc, &tcent, filename, thumbdata); if (!offset) goto end; status = _ThumbCacheUpdateStructures(filename, &tcent, offset, 0); end: if (thumb) gdImageDestroy(thumb); if (thumbdata) gdFree(thumbdata); if (tc && closetc) fclose(tc); return status; }
int main() { gdImagePtr im; void *data; int size = 0; im = gdImageCreate(100, 100); gdTestAssert(im != NULL); data = gdImagePngPtr(im, &size); gdTestAssert(data == NULL); gdImageDestroy(im); return gdNumFailures(); }
int tipojuego_get_tablero_png( Tipojuego* tj, int board_number, int flags, void** png, int*width, int* height ){ #if GRAPH_ENABLED int size; if( board_number == BOARD_ACTUAL ) return tipojuego_get_tablero_png( tj, tj->tablero_actual, flags, png, width, height ); gdImagePtr gd = graph_get_tablero_png( tj, board_number, flags ); if( !gd ) return 0; if( png ) *png = gdImagePngPtr( gd, &size ); if( width ) *width = gdImageSX( gd ); if( height ) *height = gdImageSY( gd ); return size; #else LOGPRINT( 2, "No compilado con el modulo GD board = %d", board_number ); return 0; #endif }
static void thumb_to_string(void *conf) { ngx_image_conf_t *info = conf; switch(info->dest_type) { case NGX_IMAGE_PNG: info->img_data = gdImagePngPtr(info->dst_im,&info->img_size); break; case NGX_IMAGE_GIF: info->img_data = gdImageGifPtr(info->dst_im,&info->img_size); break; case NGX_IMAGE_JPEG: info->img_data = gdImageJpegPtr(info->dst_im,&info->img_size,info->jpeg_quality); break; } gdImageDestroy(info->dst_im); }
void plD_eop_png(PLStream *pls) { png_Dev *dev=(png_Dev *)pls->dev; int im_size=0; void *im_ptr=NULL; if (pls->family || pls->page == 1) { if (dev->optimise) { #if GD2_VERS >= 2 if ( ( (((dev->truecolour>0) && (dev->palette>0)) || /* In an EXTREMELY convaluted */ ((dev->truecolour==0) && (dev->palette==0))) && /* manner, all this is just */ ((pls->ncol1+pls->ncol0)<=256) ) || /* asking the question, do we */ ( ((dev->palette>0)&&(dev->truecolour==0)) ) ) /* want truecolour or not ? */ { #endif plD_gd_optimise(pls); #if GD2_VERS >= 2 } #endif } /* image is written to output file by the driver since if the gd.dll is linked to a different c lib a crash occurs - this fix works also in Linux */ /* gdImagePng(dev->im_out, pls->OutFile); */ #if GD2_VERS >= 2 im_ptr = gdImagePngPtrEx (dev->im_out, &im_size, pls->dev_compression >9 ? (pls->dev_compression/10) : pls->dev_compression); #else im_ptr = gdImagePngPtr(dev->im_out, &im_size); #endif if( im_ptr ) { fwrite(im_ptr, sizeof(char), im_size, pls->OutFile); gdFree(im_ptr); } gdImageDestroy(dev->im_out); dev->im_out = NULL; } }
int mySavePng(char *filename, gdImagePtr im) { FILE *out; int size; int iRet = OK; char *data = NULL; out = fopen(filename, "wb"); if (!out) { /* Error */ printf(" Error: Cannot open destination image '%s' for writing.\n", filename); iRet = FAILURE; } else { data = (char *) gdImagePngPtr(im, &size); if (!data) { printf(" Error: Cannot read data from gdImagePng structure.\n"); iRet = FAILURE; /* Error */ } else { if (fwrite(data, 1, size, out) != (size_t)size) { /* Error */ printf(" Error: Cannot write image into file.\n"); iRet = FAILURE; } gdFree(data); } if (fclose(out) != 0) { /* Error */ printf(" Error: Cannot close image.\n"); iRet = FAILURE; } if(iRet != OK) { printf("\n"); } } return iRet; }
int main() { gdImagePtr im; FILE *fp; void *data; int size = 0; fp = gdTestFileOpen2("png", "bug00381_2.gd"); gdTestAssert(fp != NULL); im = gdImageCreateFromGd(fp); gdTestAssert(im != NULL); fclose(fp); data = gdImagePngPtr(im, &size); gdTestAssert(data == NULL); gdImageDestroy(im); return gdNumFailures(); }
int partida_get_png( Partida* par, int flags, int movida, void** png ){ #if GRAPH_ENABLED int i; Posicion* pos; Movida* mov; if( movida == 0 ){ pos = par->tjuego->inicial ; mov = NULL; } else if ( movida == LAST_MOVE ) { pos = par->pos; mov = par->movimientos && par->movimientos->entradas ? par->movimientos->data[par->movimientos->entradas-1] : NULL; } else if ( !par->movimientos ){ LOGPRINT( 2, "Movida pedida %d. No hay movimientos. Partida %s", movida, par->id ); return 0; } else if ( movida > par->movimientos->entradas ){ LOGPRINT( 2, "Movida pedida %d. Cantidad movimientos %d. Partida %s", movida, par->movimientos->entradas, par->id ); return 0; } else if ( movida == par->movimientos->entradas ) { pos = par->pos; mov = par->movimientos->data[movida-1]; } else { mov = (Movida*) par->movimientos->data[movida]; pos = mov->pos; mov = (Movida*) par->movimientos->data[movida-1]; } int size = 0; gdImagePtr gd = graph_dibujar_posicion( par->tjuego, flags, pos, mov ); if( !gd ) return 0; if( png ) *png = gdImagePngPtr( gd, &size ); gdImageDestroy( gd ); return size; #else LOGPRINT( 2, "No compilado con el modulo GD partida = %s", par->id ); return 0; #endif }
int ImgSavePng(const char *filename, gdImagePtr im) { FILE *out; int size; char *data; out = fopen(filename, "wb"); if (!out) return 0; data = (char *)gdImagePngPtr(im, &size); if (!data) { fclose(out); return 0; } fwrite(data, 1, size, out); fclose(out); gdFree(data); return 1; }
void GDasStringPNG(void) { Proto proto; Proto blob; Proto newObj; gdImagePtr imgPtr; char * p; char * buff; int size; proto = (Proto) stackAt(Cpu, 2); objectGetSlot(proto, stringToAtom("_gdp"), &blob); p = (char *) objectPointerValue(blob); memcpy(&imgPtr, p, sizeof(imgPtr)); buff = gdImagePngPtr(imgPtr, &size); newObj = createString(buff, size); gdFree(buff); VMReturn(Cpu, (unsigned int) newObj, 3); }
static u_char *ngx_http_small_light_gd_out(gdImagePtr img, ngx_int_t type, int *size, double q) { u_char *out = NULL; switch (type) { case NGX_HTTP_SMALL_LIGHT_IMAGE_JPEG: out = gdImageJpegPtr(img, size, (int)q); break; case NGX_HTTP_SMALL_LIGHT_IMAGE_GIF: out = gdImageGifPtr(img, size); break; case NGX_HTTP_SMALL_LIGHT_IMAGE_PNG: out = gdImagePngPtr(img, size); break; case NGX_HTTP_SMALL_LIGHT_IMAGE_WEBP: #ifdef NGX_HTTP_SMALL_LIGHT_GD_WEBP_ENABLED out = gdImageWebpPtrEx(img, size, (int)q); #endif break; default: break; } return out; }
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; }
int ThumbCacheReplace(FILE *tc, const char *filename, LPTCRECORD ptcrec, time_t mtime) { void *thumbdata; gdImagePtr thumb = NULL; unsigned int origoffset, offset; uint32_t thumbsize; int status = 0, closetc = 0; if (!filename || !ptcrec) return 0; if (!thumbbpt) { thumbbpt = BptOpen(thumb_btree_fn); if (!thumbbpt) return 0; } if (BptRemove(thumbbpt, ptcrec->ent.thumbkey) <= 0) goto fail; thumb = ThumbCreate(filename, NULL); if (!thumb) goto fail; thumbdata = gdImagePngPtr(thumb, (int *)&thumbsize); if (!thumbdata) goto fail; if (!tc) { closetc = 1; tc = fopen(thumb_cache_fn, "rb+"); if (!tc) goto fail; } origoffset = ftell(tc); if (thumbsize <= ptcrec->ent.thumbfsize) { if (fseek(tc, ptcrec->offset, SEEK_SET)) goto fail; } else { if (fseek(tc, 0, SEEK_END)) goto fail; ptcrec->offset = ftell(tc); } ptcrec->ent.mtime = mtime; ptcrec->ent.thumbfsize = thumbsize; ptcrec->ent.thumbkey = _ThumbCalcKey(thumb->tpixels); offset = _ThumbCacheWriteEntry(tc, &ptcrec->ent, filename, thumbdata); if (!offset) goto fail; status = _ThumbCacheUpdateStructures(filename, &ptcrec->ent, offset, 1); fail: if (tc) { if (closetc) fclose(tc); else fseek(tc, origoffset, SEEK_SET); } if (thumb) gdImageDestroy(thumb); if (thumbdata) gdFree(thumbdata); return status; }
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 ngx_int_t ngx_http_qrcode_handler(ngx_http_request_t* r) { ngx_http_qrcode_loc_conf_t *qlcf; ngx_int_t code_size; ngx_int_t img_margin, img_width; ngx_int_t fg_color, bg_color; ngx_int_t x, y, posx, posy; int img_stream_len; u_char *encoded_txt; ngx_int_t rc; qlcf = ngx_http_get_module_loc_conf(r, ngx_http_qrcode_module); /* compile args */ rc = ngx_http_qrcode_compile_args(r, qlcf); if (rc != NGX_OK) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to compile args."); return NGX_HTTP_INTERNAL_SERVER_ERROR; } encoded_txt = ngx_pcalloc(r->pool, qlcf->txt.len + 1); ngx_sprintf(encoded_txt, "%V", &qlcf->txt); QRcode *code; code = QRcode_encodeString((char*)encoded_txt, qlcf->version, qlcf->level, qlcf->hint, qlcf->casesensitive); if(code == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to encode content.exception raised by libqrencode: %s", strerror(errno)); return NGX_HTTP_INTERNAL_SERVER_ERROR; } code_size = ((qlcf->size > 2048) ? 1024 : qlcf->size) / code->width; code_size = (code_size == 0) ? 1 : code_size; img_margin = qlcf->margin; img_width = code->width * code_size + 2 * img_margin; gdImagePtr img; img = gdImageCreate(img_width, img_width); fg_color = gdImageColorAllocate(img, qlcf->fg_color[0], qlcf->fg_color[1], qlcf->fg_color[2]); bg_color = gdImageColorAllocate(img, qlcf->bg_color[0], qlcf->bg_color[1], qlcf->bg_color[2]); gdImageFill(img, 0, 0, bg_color); u_char *p = code->data; for (y = 0; y < code->width; y++) { for (x = 0; x < code->width; x++) { if (*p & 1) { posx = x * code_size + img_margin; posy = y * code_size + img_margin; gdImageFilledRectangle(img, posx, posy, posx + code_size, posy + code_size, fg_color); } p++; } } u_char *img_stream; img_stream = gdImagePngPtr(img, &img_stream_len); gdImageDestroy(img); QRcode_free(code); r->headers_out.status = NGX_HTTP_OK; r->headers_out.content_length_n = img_stream_len; ngx_str_set(&r->headers_out.content_type, "image/png"); ngx_http_send_header(r); ngx_buf_t* buffer; buffer = ngx_pcalloc(r->pool, sizeof(ngx_buf_t)); if (buffer == NULL) { ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, "Failed to allocate response buffer"); return NGX_HTTP_INTERNAL_SERVER_ERROR; } //set up the buffer chain ngx_chain_t out; buffer->pos = img_stream; buffer->last = img_stream + img_stream_len; buffer->memory = 1; buffer->last_buf = 1; out.buf = buffer; out.next = NULL; return ngx_http_output_filter(r, &out); }
int tipojuego_get_logo( Tipojuego* tj, void** png, int* width, int* height ){ #if GRAPH_ENABLED Graphdef* g = NULL; gdImagePtr gd = NULL; int i; if( tj->graphdefs ){ for( i = 0; i < tj->graphdefs->entradas; i ++ ){ Graphdef* g2 = tj->graphdefs->data[i]; if( g2->tipo == TIPOGRAPH_LOGO ){ g = g2; break; } } } if( !g ){ LOGPRINT( 5, "Tipojuego %s no tiene definido logo ... va posicion inicial", tj->nombre ); g = malloc( sizeof( Graphdef ) ); memset( g, 0, sizeof( Graphdef ) ); if( !tj->graphdefs ) tj->graphdefs = list_nueva( NULL ); g->tipo = TIPOGRAPH_LOGO; list_agrega( tj->graphdefs, g ); } if( g->gd ){ gd = g->gd; } else { if( !g->cus ){ gd = graph_dibujar_posicion( tj, 0, tj->inicial, NULL ); g->gd = gdImageCreate( LOGO_WIDTH, LOGO_HEIGHT ); gdImageCopyResized( g->gd, gd, 0, 0, 0, 0, LOGO_WIDTH, LOGO_HEIGHT, gdImageSX(gd), gdImageSY(gd) ); gdImageDestroy( gd ); gd = g->gd; } else if ( g->std == STANDARD_FROM_PGN ) { Partida* pp = partida_new( tj, "from_logo" ); partida_mover_serie( pp, g->cus ); gd = graph_dibujar_posicion( tj, 0, pp->pos, partida_ultimo_movimiento( pp ) ); g->gd = gdImageCreate( LOGO_WIDTH, LOGO_HEIGHT ); gdImageCopyResized( g->gd, gd, 0, 0, 0, 0, LOGO_WIDTH, LOGO_HEIGHT, gdImageSX(gd), gdImageSY(gd) ); gdImageDestroy( gd ); gd = g->gd; } else { FILE* fpng = fopen( g->cus, "r" ); if( !fpng ){ LOGPRINT( 2, "No puede abrir %s", g->cus ); return 0; } gd = gdImageCreateFromPng( fpng ); g->gd = gd; fclose( fpng ); } } if( !gd ){ LOGPRINT( 2, "No puede generarse logo para %s", tj->nombre ); return 0; } int size = 0; if( png ) *png = gdImagePngPtr( gd, &size ); if( width ) *width = gdImageSX( gd ); if( height ) *height = gdImageSY( gd ); return size; #else LOGPRINT( 2, "No compilado con el modulo GD tjuego = %s", tj->nombre ); return 0; #endif }
result_t Image::getData(int32_t format, int32_t quality, obj_ptr<Buffer_base> &retVal, AsyncEvent *ac) { if (!m_image) return CHECK_ERROR(CALL_E_INVALID_CALL); if (!ac) return CHECK_ERROR(CALL_E_NOSYNC); int32_t size = 0; void *data = NULL; int32_t sx = gdImageSX(m_image); int32_t sy = gdImageSY(m_image); int32_t i, j; int32_t trans = -1; if (gdImageTrueColor(m_image)) { for (i = 0; i < sx && trans == -1; i ++) for (j = 0; j < sy && trans == -1; j++) if ((gdImageGetPixel(m_image, i, j) & 0xff000000) != 0) trans = 0; } else trans = gdImageGetTransparent(m_image); gdImagePtr nowImage = m_image; if (trans != -1) { if (format != gd_base::_PNG) { if (gdImageTrueColor(m_image)) nowImage = gdImageCreateTrueColor(sx, sy); else { nowImage = gdImageCreate(sx, sy); gdImagePaletteCopy(nowImage, m_image); } gdImageFilledRectangle(nowImage, 0, 0, sx, sy, gdImageColorAllocate(nowImage, 255, 255, 255)); gdImageCopy(nowImage, m_image, 0, 0, 0, 0, sx, sy); } else if (gdImageTrueColor(m_image)) gdImageSaveAlpha(m_image, 1); } switch (format) { case gd_base::_GIF: data = gdImageGifPtr(nowImage, &size); break; case gd_base::_PNG: data = gdImagePngPtr(nowImage, &size); break; case gd_base::_JPEG: { unsigned char *ed_data = NULL; uint32_t ed_size = 0; data = gdImageJpegPtr(nowImage, &size, quality, ed_data, ed_size); if (ed_data) free(ed_data); break; } case gd_base::_TIFF: data = gdImageTiffPtr(nowImage, &size); break; case gd_base::_BMP: data = gdImageBmpPtr(nowImage, &size, 1); break; case gd_base::_WEBP: data = gdImageWebpPtrEx(nowImage, &size, quality); break; } if (nowImage != m_image) gdImageDestroy(nowImage); if (data == NULL) return CHECK_ERROR(CALL_E_INVALIDARG); retVal = new Buffer(std::string((char *) data, size)); gdFree(data); 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; }