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