void GuiImageData::LoadBMP(const u8 *img, int imgSize)
{
gdImagePtr gdImg = gdImageCreateFromBmpPtr(imgSize, (u8*) img);
if(gdImg == 0)
return;
data = GDImageToRGBA8(&gdImg, &width, &height);
gdImageDestroy(gdImg);
}
static int
szm_do_box_bmp(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 = gdImageCreateFromBmpPtr(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 = gdImageJpegPtr(im_in, out_len, -1);
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 = gdImageJpegPtr(im_out, out_len, -1);
gdImageDestroy(im_in);
gdImageDestroy(im_out);
return 0;
return 0;
}
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;
case NGX_HTTP_IMAGE_BMP:
img = gdImageCreateFromBmpPtr(ctx->length, ctx->image);
failed = "gdImageCreateFromBmpPtr() failed";
break;
default:
failed = "unknown image type";
break;
}
if (img == NULL) {
ngx_log_error(NGX_LOG_ERR, r->connection->log, 0, failed);
}
return img;
}
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;
}
