//---------------------------------------------------------------------
DataStreamPtr FreeImageCodec::code(MemoryDataStreamPtr& input, Codec::CodecDataPtr& pData) const
{
FIBITMAP* fiBitmap = encode(input, pData);
// open memory chunk allocated by FreeImage
FIMEMORY* mem = FreeImage_OpenMemory();
// write data into memory
FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)mFreeImageType, fiBitmap, mem);
// Grab data information
BYTE* data;
DWORD size;
FreeImage_AcquireMemory(mem, &data, &size);
// Copy data into our own buffer
BYTE* ourData = new BYTE[size];
memcpy(ourData, data, size);
// Wrap data in stream, tell it to free on close
DataStreamPtr outstream(new MemoryDataStream(ourData, size, true));
// Now free FreeImage memory buffers
FreeImage_CloseMemory(mem);
// Unload bitmap
FreeImage_Unload(fiBitmap);
return outstream;
}
//---------------------------------------------------------------------
DataStreamPtr FreeImageCodec::code(MemoryDataStreamPtr& input, Codec::CodecDataPtr& pData) const
{
// Set error handler
FreeImage_SetOutputMessage(FreeImageSaveErrorHandler);
FIBITMAP* fiBitmap = encode(input, pData);
// open memory chunk allocated by FreeImage
FIMEMORY* mem = FreeImage_OpenMemory();
// write data into memory
FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)mFreeImageType, fiBitmap, mem);
// Grab data information
BYTE* data;
DWORD size;
FreeImage_AcquireMemory(mem, &data, &size);
// Copy data into our own buffer
// Because we're asking MemoryDataStream to free this, must create in a compatible way
BYTE* ourData = OGRE_ALLOC_T(BYTE, size, MEMCATEGORY_GENERAL);
memcpy(ourData, data, size);
// Wrap data in stream, tell it to free on close
DataStreamPtr outstream(OGRE_NEW MemoryDataStream(ourData, size, true));
// Now free FreeImage memory buffers
FreeImage_CloseMemory(mem);
// Unload bitmap
FreeImage_Unload(fiBitmap);
return outstream;
}
// 独立函数，读取gif图片，写白背景，转为PNG并写入缓存，返回缓存地址
FOX_DLL FIMEMORY * gif2png_bufopen(char *gifpath, BYTE ** buffpointeraddr, DWORD * bufflenaddr)
{
FIBITMAP * hImage ;
RGBQUAD * pal ;
FIMEMORY * hMemory = NULL ;
BYTE *mem_buffer = NULL ;
DWORD size_in_bytes = 0 ;
hImage = FreeImage_Load(FIF_GIF, gifpath, 0);
pal = FreeImage_GetPalette(hImage);
pal[70].rgbRed = 255 ;
pal[70].rgbGreen = 255 ;
pal[70].rgbBlue = 255 ;
FreeImage_SetTransparent(hImage, false);
hMemory = FreeImage_OpenMemory() ;
FreeImage_SaveToMemory(FIF_PNG, hImage, hMemory, PNG_DEFAULT) ;
FreeImage_Unload(hImage) ;
FreeImage_AcquireMemory(hMemory, &mem_buffer, &size_in_bytes);
*buffpointeraddr = mem_buffer ;
*bufflenaddr = size_in_bytes ;
return hMemory ;
// FreeImage_CloseMemory(hMemory) ; // 使用完缓存记得要释放
}
static BlockReference*
FreeImage_SavePageToBlock(MULTIBITMAPHEADER *header, FIBITMAP *data) {
if (header->read_only || !header->locked_pages.empty())
return NULL;
DWORD compressed_size = 0;
BYTE *compressed_data = NULL;
// compress the bitmap data
// open a memory handle
FIMEMORY *hmem = FreeImage_OpenMemory();
if(hmem==NULL) return NULL;
// save the file to memory
if(!FreeImage_SaveToMemory(header->cache_fif, data, hmem, 0)) {
FreeImage_CloseMemory(hmem);
return NULL;
}
// get the buffer from the memory stream
if(!FreeImage_AcquireMemory(hmem, &compressed_data, &compressed_size)) {
FreeImage_CloseMemory(hmem);
return NULL;
}
// write the compressed data to the cache
int ref = header->m_cachefile->writeFile(compressed_data, compressed_size);
// get rid of the compressed data
FreeImage_CloseMemory(hmem);
return new(std::nothrow) BlockReference(ref, compressed_size);
}
void testAcquireMemIO(const char *lpszPathName) {
FIMEMORY *hmem = NULL;
// load a regular file
FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(lpszPathName);
FIBITMAP *dib = FreeImage_Load(fif, lpszPathName, 0);
// open and allocate a memory stream
hmem = FreeImage_OpenMemory();
// save the file to memory
FreeImage_SaveToMemory(FIF_PNG, dib, hmem, PNG_DEFAULT);
FreeImage_Unload(dib);
// get the buffer from the memory stream
BYTE *mem_buffer = NULL;
DWORD size_in_bytes = 0;
FreeImage_AcquireMemory(hmem, &mem_buffer, &size_in_bytes);
// save the buffer in a file stream
FILE *stream = fopen("buffer.png", "wb");
if(stream) {
fwrite(mem_buffer, sizeof(BYTE), size_in_bytes, stream);
fclose(stream);
}
// close and free the memory stream
FreeImage_CloseMemory(hmem);
}
// Takes an image from the frame buffer and compresses it
int writeFrame(FIMEMORY *fiBuffer, FIBITMAP *fiImage, unsigned char imageType) {
/*
char msg[1024];
sprintf_s(msg, 1024, "imageType: %i", imageType);
MessageBox(NULL,msg,"ADES DEBUG", MB_OK);
*/
imageType = 2;
int errStatus = 1;
u_short imageWidth, imageHeight;
unsigned width, height, pitch, line;
BYTE *bits;
// Package image using correct compression
switch(imageType) {
case 0: // Send a raw frame
// Get image characteristics
width = FreeImage_GetWidth(fiImage);
height = FreeImage_GetHeight(fiImage);
pitch = FreeImage_GetPitch(fiImage);
line = FreeImage_GetLine(fiImage);
// Write out width and height
errStatus = FreeImage_SeekMemory(fiBuffer, 0, SEEK_SET);
if (errStatus != 1) break;
imageWidth = htons(width);
errStatus = FreeImage_WriteMemory( &imageWidth, 2, 1, fiBuffer );
if (errStatus != 1) break;
imageHeight = htons(height);
errStatus = FreeImage_WriteMemory( &imageHeight, 2, 1, fiBuffer );
if (errStatus != 1) break;
// Write out image (convert the bitmap to raw bits, top-left pixel first)
bits = (BYTE*)malloc(height * pitch);
FreeImage_ConvertToRawBits(bits, fiImage, pitch, 24,
FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, TRUE);
errStatus = FreeImage_WriteMemory( bits, height*pitch*sizeof(BYTE), 1, fiBuffer );
free(bits);
if (errStatus != 1) break;
break;
default: // Send a jpg frame
errStatus = FreeImage_SeekMemory(fiBuffer, 0, SEEK_SET);
if (errStatus != 1) break;
errStatus = FreeImage_SaveToMemory(FIF_JPEG, fiImage, fiBuffer, convertToJpegFlag(imageType));
if (errStatus != 1) break;
break;
}
// Clean up and exit
return errStatus;
}
void DLL_CALLCONV
FreeImage_UnlockPage(FIMULTIBITMAP *bitmap, FIBITMAP *page, BOOL changed) {
if ((bitmap) && (page)) {
MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
// find out if the page we try to unlock is actually locked...
if (header->locked_pages.find(page) != header->locked_pages.end()) {
// store the bitmap compressed in the cache for later writing
if (changed && !header->read_only) {
header->changed = TRUE;
// cut loose the block from the rest
BlockListIterator i = FreeImage_FindBlock(bitmap, header->locked_pages[page]);
// compress the data
DWORD compressed_size = 0;
BYTE *compressed_data = NULL;
// open a memory handle
FIMEMORY *hmem = FreeImage_OpenMemory();
// save the page to memory
FreeImage_SaveToMemory(header->cache_fif, page, hmem, 0);
// get the buffer from the memory stream
FreeImage_AcquireMemory(hmem, &compressed_data, &compressed_size);
// write the data to the cache
if (i->m_type == BLOCK_REFERENCE) {
header->m_cachefile.deleteFile(i->getReference());
}
int iPage = header->m_cachefile.writeFile(compressed_data, compressed_size);
*i = PageBlock(BLOCK_REFERENCE, iPage, compressed_size);
// get rid of the compressed data
FreeImage_CloseMemory(hmem);
}
// reset the locked page so that another page can be locked
FreeImage_Unload(page);
header->locked_pages.erase(page);
}
}
}
FIMEMORY* FreeImage_SaveToMem(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, fiio_mem_handle *handle, int flags)
{
if (handle) {
FIMEMORY *hmem = FreeImage_OpenMemory(NULL, 0);
if(fif == FIF_UNKNOWN)
fif = FIF_BMP;
handle->curpos = 0;
FreeImage_SaveToMemory(fif, dib, hmem, flags);
FreeImage_AcquireMemory(hmem, (BYTE **)&handle->data, (DWORD *)&handle->datalen);
return hmem;
}
return NULL;
}
void DLL_CALLCONV
FreeImage_InsertPage(FIMULTIBITMAP *bitmap, int page, FIBITMAP *data) {
if ((bitmap) && (data)) {
if (page < FreeImage_GetPageCount(bitmap)) {
MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
if ((!header->read_only) && (header->locked_pages.empty())) {
DWORD compressed_size = 0;
BYTE *compressed_data = NULL;
// compress the bitmap data
// open a memory handle
FIMEMORY *hmem = FreeImage_OpenMemory();
// save the file to memory
FreeImage_SaveToMemory(header->cache_fif, data, hmem, 0);
// get the buffer from the memory stream
FreeImage_AcquireMemory(hmem, &compressed_data, &compressed_size);
// write the compressed data to the cache
int ref = header->m_cachefile->writeFile(compressed_data, compressed_size);
// add a block
if (page > 0) {
BlockListIterator block_source = FreeImage_FindBlock(bitmap, page);
BlockReference *block = new BlockReference(ref, compressed_size);
header->m_blocks.insert(block_source, (BlockTypeS *)block);
} else {
BlockReference *block = new BlockReference(ref, compressed_size);
header->m_blocks.push_front((BlockTypeS *)block);
}
// get rid of the compressed buffer
FreeImage_CloseMemory(hmem);
header->changed = TRUE;
header->page_count = -1;
}
}
}
}
void testSaveMemIO(const char *lpszPathName) {
FIMEMORY *hmem = NULL;
// load a regular file
FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(lpszPathName);
FIBITMAP *dib = FreeImage_Load(fif, lpszPathName, 0);
// open a memory handle
hmem = FreeImage_OpenMemory();
// save the file to memory
FreeImage_SaveToMemory(fif, dib, hmem, 0);
// at this point, hmem contains the entire PNG data in memory.
// the amount of space used by the memory is equal to file_size
long file_size = FreeImage_TellMemory(hmem);
printf("File size : %ld\n", file_size);
// its easy load an image from memory as well
// seek to the start of the memory stream
FreeImage_SeekMemory(hmem, 0L, SEEK_SET);
// get the file type
FREE_IMAGE_FORMAT mem_fif = FreeImage_GetFileTypeFromMemory(hmem, 0);
// load an image from the memory handle
FIBITMAP *check = FreeImage_LoadFromMemory(mem_fif, hmem, 0);
// save as a regular file
FreeImage_Save(FIF_PNG, check, "dump.png", PNG_DEFAULT);
// make sure to free the data since FreeImage_SaveToMemory
// will cause it to be malloc'd
FreeImage_CloseMemory(hmem);
FreeImage_Unload(check);
FreeImage_Unload(dib);
}
static PageBlock
FreeImage_SavePageToBlock(MULTIBITMAPHEADER *header, FIBITMAP *data) {
PageBlock res;
if (header->read_only || !header->locked_pages.empty()) {
return res;
}
DWORD compressed_size = 0;
BYTE *compressed_data = NULL;
// compress the bitmap data
// open a memory handle
FIMEMORY *hmem = FreeImage_OpenMemory();
if(hmem==NULL) {
return res;
}
// save the file to memory
if(!FreeImage_SaveToMemory(header->cache_fif, data, hmem, 0)) {
FreeImage_CloseMemory(hmem);
return res;
}
// get the buffer from the memory stream
if(!FreeImage_AcquireMemory(hmem, &compressed_data, &compressed_size)) {
FreeImage_CloseMemory(hmem);
return res;
}
// write the compressed data to the cache
int ref = header->m_cachefile.writeFile(compressed_data, compressed_size);
// get rid of the compressed data
FreeImage_CloseMemory(hmem);
res = PageBlock(BLOCK_REFERENCE, ref, compressed_size);
return res;
}
void DLL_CALLCONV
FreeImage_AppendPage(FIMULTIBITMAP *bitmap, FIBITMAP *data) {
if ((bitmap) && (data)) {
MULTIBITMAPHEADER *header = FreeImage_GetMultiBitmapHeader(bitmap);
if ((!header->read_only) && (header->locked_pages.empty())) {
DWORD compressed_size = 0;
BYTE *compressed_data = NULL;
// compress the bitmap data
// open a memory handle
FIMEMORY *hmem = FreeImage_OpenMemory();
// save the file to memory
FreeImage_SaveToMemory(header->cache_fif, data, hmem, 0);
// get the buffer from the memory stream
FreeImage_AcquireMemory(hmem, &compressed_data, &compressed_size);
// write the compressed data to the cache
int ref = header->m_cachefile->writeFile(compressed_data, compressed_size);
BlockReference *block = new BlockReference(ref, compressed_size);
// get rid of the compressed data
FreeImage_CloseMemory(hmem);
// add the block
header->m_blocks.push_back((BlockTypeS *)block);
header->changed = TRUE;
header->page_count = -1;
}
}
}
BOOL fipMemoryIO::save(FREE_IMAGE_FORMAT fif, FIBITMAP *dib, int flags) {
return FreeImage_SaveToMemory(fif, dib, _hmem, flags);
}
GXBOOL RenderTargetImpl::SaveToMemory(clstd::MemBuffer* pBuffer, GXLPCSTR pImageFormat)
{
GXSIZE sDimension;
GXBOOL bval = TRUE;
GXFormat format = m_pColorTexture->GetFormat();
m_pColorTexture->GetDimension(&sDimension);
Texture* pReadBackTexture = NULL;
GetColorTexture(&pReadBackTexture, GXResUsage::Read);
Texture::MAPPED mapped;
if(pReadBackTexture->Map(&mapped, GXResMap::Read))
{
GXUINT bpp = GetBytesOfGraphicsFormat(format);
GXLPVOID pSourceBits = mapped.pBits;
GXINT nSourcePitch = mapped.Pitch;
clstd::Image temp_image;
FREE_IMAGE_TYPE fit = FIT_BITMAP;
switch(format)
{
case Format_R8G8B8A8:
temp_image.Set(sDimension.cx, sDimension.cy, "RGBA", 8, pSourceBits, nSourcePitch);
break;
case Format_B8G8R8X8:
temp_image.Set(sDimension.cx, sDimension.cy, "BGRX", 8, pSourceBits, nSourcePitch);
break;
case Format_B8G8R8:
temp_image.Set(sDimension.cx, sDimension.cy, "BGRX", 8, pSourceBits, nSourcePitch);
break;
case Format_R8:
temp_image.Set(sDimension.cx, sDimension.cy, "R", 8, pSourceBits, nSourcePitch);
break;
case Format_R8G8:
temp_image.Set(sDimension.cx, sDimension.cy, "RG", 8, pSourceBits, nSourcePitch);
break;
case Format_R32G32B32A32_Float:
fit = FIT_RGBAF;
break;
case Format_R32:
fit = FIT_FLOAT;
break;
}
if(temp_image.GetDataSize() > 0)
{
temp_image.SetFormat("BGRA");
pSourceBits = temp_image.GetLine(0);
nSourcePitch = temp_image.GetPitch();
bpp = temp_image.GetChannels();
}
FIBITMAP* fibmp = (fit == FIT_BITMAP)
? FreeImage_Allocate(sDimension.cx, sDimension.cy, bpp * 8)
: FreeImage_AllocateT(fit, sDimension.cx, sDimension.cy, bpp * 8);
BYTE* pDest = FreeImage_GetBits(fibmp);
GXINT nDestPitch = FreeImage_GetPitch(fibmp);
pDest += nDestPitch * (sDimension.cy - 1);
for(int y = 0; y < sDimension.cy; y++)
{
memcpy(pDest, pSourceBits, clMin(nDestPitch, nSourcePitch));
pDest -= nDestPitch;
pSourceBits = reinterpret_cast<GXLPVOID>(reinterpret_cast<size_t>(pSourceBits) + nSourcePitch);
}
pReadBackTexture->Unmap();
FREE_IMAGE_FORMAT fi_format = FIF_UNKNOWN;
clStringA strFormat = pImageFormat;
strFormat.MakeUpper();
if(strFormat == "PNG") {
fi_format = FIF_PNG;
}
else if(strFormat == "JPEG" || strFormat == "JPG") {
fi_format = FIF_JPEG;
}
else if(strFormat == "TIF" || strFormat == "TIFF") {
fi_format = FIF_TIFF;
}
else if(strFormat == "TGA") {
fi_format = FIF_TARGA;
}
else if(strFormat == "BMP") {
fi_format = FIF_BMP;
}
else if(strFormat == "EXR") {
fi_format = FIF_EXR;
}
if(fi_format != FIF_UNKNOWN)
{
FIMEMORY* fimemory = FreeImage_OpenMemory();
if(FreeImage_SaveToMemory(fi_format, fibmp, fimemory))
{
BYTE *pData;
DWORD size_in_bytes;
if(FreeImage_AcquireMemory(fimemory, &pData, &size_in_bytes))
{
pBuffer->Resize(0, FALSE);
pBuffer->Append(pData, size_in_bytes);
}
else
{
bval = FALSE;
}
}
else
{
bval = FALSE;
}
FreeImage_CloseMemory(fimemory);
}
else
{
bval = FALSE;
}
FreeImage_Unload(fibmp);
}
SAFE_RELEASE(pReadBackTexture);
return bval;
}
static void saveImage(ofPixels_<PixelType> & pix, ofBuffer & buffer, ofImageFormat format, ofImageQualityType qualityLevel) {
//thanks to alvaro casinelli for the implementation
ofInitFreeImage();
if (pix.isAllocated() == false){
ofLog(OF_LOG_ERROR,"error saving image - pixels aren't allocated");
return;
}
#ifdef TARGET_LITTLE_ENDIAN
if(sizeof(PixelType) == 1) {
pix.swapRgb();
}
#endif
FIBITMAP * bmp = getBmpFromPixels(pix);
#ifdef TARGET_LITTLE_ENDIAN
if(sizeof(PixelType) == 1) {
pix.swapRgb();
}
#endif
if (bmp) // bitmap successfully created
{
// (b) open a memory stream to compress the image onto mem_buffer:
//
FIMEMORY *hmem = FreeImage_OpenMemory();
// (c) encode and save the image to the memory (on dib FIBITMAP image):
//
if(FREE_IMAGE_FORMAT(format) == FIF_JPEG) {
int quality = JPEG_QUALITYSUPERB;
switch(qualityLevel) {
case OF_IMAGE_QUALITY_WORST: quality = JPEG_QUALITYBAD; break;
case OF_IMAGE_QUALITY_LOW: quality = JPEG_QUALITYAVERAGE; break;
case OF_IMAGE_QUALITY_MEDIUM: quality = JPEG_QUALITYNORMAL; break;
case OF_IMAGE_QUALITY_HIGH: quality = JPEG_QUALITYGOOD; break;
case OF_IMAGE_QUALITY_BEST: quality = JPEG_QUALITYSUPERB; break;
}
FreeImage_SaveToMemory(FIF_JPEG, bmp, hmem, quality);
}else{
FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)format, bmp, hmem);
}
/*
NOTE: at this point, hmem contains the entire data in memory stored in fif format. the
amount of space used by the memory is equal to file_size:
long file_size = FreeImage_TellMemory(hmem);
but can also be retrieved by FreeImage_AcquireMemory that retrieves both the
length of the buffer, and the buffer memory address.
*/
#ifdef TARGET_WIN32
DWORD size_in_bytes = 0;
#else
uint32_t size_in_bytes = 0;
#endif
// Save compressed data on mem_buffer
// note: FreeImage_AquireMemory allocates space for aux_mem_buffer):
//
unsigned char *mem_buffer = NULL;
if (!FreeImage_AcquireMemory(hmem, &mem_buffer, &size_in_bytes))
cout << "Error aquiring compressed image from memory" << endl;
/*
Now, before closing the memory stream, copy the content of mem_buffer
to an auxiliary buffer
*/
buffer.set((char*)mem_buffer,size_in_bytes);
// Finally, close the FIBITMAP object, or we will get a memory leak:
FreeImage_Unload(bmp);
// Close the memory stream (otherwise we may get a memory leak).
FreeImage_CloseMemory(hmem);
}
}
static bool saveImage(const ofPixels_<PixelType> & _pix, ofBuffer & buffer, ofImageFormat format, ofImageQualityType qualityLevel) {
// thanks to alvaro casinelli for the implementation
ofInitFreeImage();
if (_pix.isAllocated() == false){
ofLogError("ofImage","saveImage(): couldn't save to ofBuffer, pixels are not allocated");
return false;
}
if(format==OF_IMAGE_FORMAT_JPEG && (_pix.getNumChannels()==4 || _pix.getBitsPerChannel() > 8)){
ofPixels pix3 = _pix;
pix3.setNumChannels(3);
return saveImage(pix3,buffer,format,qualityLevel);
}
FIBITMAP * bmp = nullptr;
#ifdef TARGET_LITTLE_ENDIAN
if(sizeof(PixelType) == 1 && (_pix.getPixelFormat()==OF_PIXELS_RGB || _pix.getPixelFormat()==OF_PIXELS_RGBA)) { // Make a local copy.
ofPixels_<PixelType> pix = _pix;
pix.swapRgb();
bmp = getBmpFromPixels(pix);
}else{
#endif
bmp = getBmpFromPixels(_pix);
#ifdef TARGET_LITTLE_ENDIAN
}
#endif
if (bmp) // bitmap successfully created
{
bool returnValue;
// (b) open a memory stream to compress the image onto mem_buffer:
//
FIMEMORY *hmem = FreeImage_OpenMemory();
// (c) encode and save the image to the memory (on dib FIBITMAP image):
//
if(FREE_IMAGE_FORMAT(format) == FIF_JPEG) {
int quality = JPEG_QUALITYSUPERB;
switch(qualityLevel) {
case OF_IMAGE_QUALITY_WORST: quality = JPEG_QUALITYBAD; break;
case OF_IMAGE_QUALITY_LOW: quality = JPEG_QUALITYAVERAGE; break;
case OF_IMAGE_QUALITY_MEDIUM: quality = JPEG_QUALITYNORMAL; break;
case OF_IMAGE_QUALITY_HIGH: quality = JPEG_QUALITYGOOD; break;
case OF_IMAGE_QUALITY_BEST: quality = JPEG_QUALITYSUPERB; break;
}
returnValue = FreeImage_SaveToMemory(FIF_JPEG, bmp, hmem, quality);
}else{
returnValue = FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)format, bmp, hmem);
}
/*
NOTE: at this point, hmem contains the entire data in memory stored in fif format. the
amount of space used by the memory is equal to file_size:
long file_size = FreeImage_TellMemory(hmem);
but can also be retrieved by FreeImage_AcquireMemory that retrieves both the
length of the buffer, and the buffer memory address.
*/
#ifdef TARGET_WIN32
DWORD size_in_bytes = 0;
#else
std::uint32_t size_in_bytes = 0;
#endif
// Save compressed data on mem_buffer
// note: FreeImage_AquireMemory allocates space for aux_mem_buffer):
//
unsigned char *mem_buffer = nullptr;
if (!FreeImage_AcquireMemory(hmem, &mem_buffer, &size_in_bytes)){
ofLogError("ofImage") << "saveImage(): couldn't save to ofBuffer, aquiring compressed image from memory failed";
return false;
}
/*
Now, before closing the memory stream, copy the content of mem_buffer
to an auxiliary buffer
*/
buffer.set((char*)mem_buffer,size_in_bytes);
// Finally, close the FIBITMAP object, or we will get a memory leak:
FreeImage_Unload(bmp);
// Close the memory stream (otherwise we may get a memory leak).
FreeImage_CloseMemory(hmem);
return returnValue;
}else{
return false;
}
}
/**
Write a FIBITMAP to a JNG stream
@param format_id ID of the caller
@param io Stream i/o functions
@param dib Image to be saved
@param handle Stream handle
@param flags Saving flags
@return Returns TRUE if successful, returns FALSE otherwise
*/
BOOL
mng_WriteJNG(int format_id, FreeImageIO *io, FIBITMAP *dib, fi_handle handle, int flags) {
DWORD jng_width = 0;
DWORD jng_height = 0;
BYTE jng_color_type = 0;
BYTE jng_image_sample_depth = 8;
BYTE jng_image_compression_method = 8; // 8: ISO-10918-1 Huffman-coded baseline JPEG.
BYTE jng_image_interlace_method = 0;
BYTE jng_alpha_sample_depth = 0;
BYTE jng_alpha_compression_method = 0;
BYTE jng_alpha_filter_method = 0;
BYTE jng_alpha_interlace_method = 0;
BYTE buffer[16];
FIMEMORY *hJngMemory = NULL;
FIMEMORY *hJpegMemory = NULL;
FIMEMORY *hPngMemory = NULL;
FIBITMAP *dib_rgb = NULL;
FIBITMAP *dib_alpha = NULL;
if(!dib || (FreeImage_GetImageType(dib) != FIT_BITMAP)) {
return FALSE;
}
unsigned bpp = FreeImage_GetBPP(dib);
switch(bpp) {
case 8:
if(FreeImage_GetColorType(dib) == FIC_MINISBLACK) {
dib_rgb = dib;
jng_color_type = MNG_COLORTYPE_JPEGGRAY;
} else {
// JPEG plugin will convert other types (FIC_MINISWHITE, FIC_PALETTE) to 24-bit on the fly
//dib_rgb = FreeImage_ConvertTo24Bits(dib);
dib_rgb = dib;
jng_color_type = MNG_COLORTYPE_JPEGCOLOR;
}
break;
case 24:
dib_rgb = dib;
jng_color_type = MNG_COLORTYPE_JPEGCOLOR;
break;
case 32:
dib_rgb = FreeImage_ConvertTo24Bits(dib);
jng_color_type = MNG_COLORTYPE_JPEGCOLORA;
jng_alpha_sample_depth = 8;
break;
default:
return FALSE;
}
jng_width = (DWORD)FreeImage_GetWidth(dib);
jng_height = (DWORD)FreeImage_GetHeight(dib);
try {
hJngMemory = FreeImage_OpenMemory();
// --- write JNG file signature ---
FreeImage_WriteMemory(g_jng_signature, 1, 8, hJngMemory);
// --- write a JHDR chunk ---
SwapLong(&jng_width);
SwapLong(&jng_height);
memcpy(&buffer[0], &jng_width, 4);
memcpy(&buffer[4], &jng_height, 4);
SwapLong(&jng_width);
SwapLong(&jng_height);
buffer[8] = jng_color_type;
buffer[9] = jng_image_sample_depth;
buffer[10] = jng_image_compression_method;
buffer[11] = jng_image_interlace_method;
buffer[12] = jng_alpha_sample_depth;
buffer[13] = jng_alpha_compression_method;
buffer[14] = jng_alpha_filter_method;
buffer[15] = jng_alpha_interlace_method;
mng_WriteChunk(mng_JHDR, &buffer[0], 16, hJngMemory);
// --- write a sequence of JDAT chunks ---
hJpegMemory = FreeImage_OpenMemory();
flags |= JPEG_BASELINE;
if(!FreeImage_SaveToMemory(FIF_JPEG, dib_rgb, hJpegMemory, flags)) {
throw (const char*)NULL;
}
if(dib_rgb != dib) {
FreeImage_Unload(dib_rgb);
dib_rgb = NULL;
}
{
BYTE *jpeg_data = NULL;
DWORD size_in_bytes = 0;
// get a pointer to the stream buffer
FreeImage_AcquireMemory(hJpegMemory, &jpeg_data, &size_in_bytes);
// write chunks
for(DWORD k = 0; k < size_in_bytes;) {
DWORD bytes_left = size_in_bytes - k;
DWORD chunk_size = MIN(JPEG_CHUNK_SIZE, bytes_left);
mng_WriteChunk(mng_JDAT, &jpeg_data[k], chunk_size, hJngMemory);
k += chunk_size;
}
}
FreeImage_CloseMemory(hJpegMemory);
hJpegMemory = NULL;
// --- write alpha layer as a sequence of IDAT chunk ---
if((bpp == 32) && (jng_color_type == MNG_COLORTYPE_JPEGCOLORA)) {
dib_alpha = FreeImage_GetChannel(dib, FICC_ALPHA);
hPngMemory = FreeImage_OpenMemory();
if(!FreeImage_SaveToMemory(FIF_PNG, dib_alpha, hPngMemory, PNG_DEFAULT)) {
throw (const char*)NULL;
}
FreeImage_Unload(dib_alpha);
dib_alpha = NULL;
// get the IDAT chunk
{
BOOL bResult = FALSE;
DWORD start_pos = 0;
DWORD next_pos = 0;
long offset = 8;
do {
// find the next IDAT chunk from 'offset' position
bResult = mng_FindChunk(hPngMemory, mng_IDAT, offset, &start_pos, &next_pos);
if(!bResult) break;
BYTE *png_data = NULL;
DWORD size_in_bytes = 0;
// get a pointer to the stream buffer
FreeImage_AcquireMemory(hPngMemory, &png_data, &size_in_bytes);
// write the IDAT chunk
mng_WriteChunk(mng_IDAT, &png_data[start_pos+8], next_pos - start_pos - 12, hJngMemory);
offset = next_pos;
} while(bResult);
}
FreeImage_CloseMemory(hPngMemory);
hPngMemory = NULL;
}
// --- write a IEND chunk ---
mng_WriteChunk(mng_IEND, NULL, 0, hJngMemory);
// write the JNG on output stream
{
BYTE *jng_data = NULL;
DWORD size_in_bytes = 0;
FreeImage_AcquireMemory(hJngMemory, &jng_data, &size_in_bytes);
io->write_proc(jng_data, 1, size_in_bytes, handle);
}
FreeImage_CloseMemory(hJngMemory);
FreeImage_CloseMemory(hJpegMemory);
FreeImage_CloseMemory(hPngMemory);
return TRUE;
} catch(const char *text) {
FreeImage_CloseMemory(hJngMemory);
FreeImage_CloseMemory(hJpegMemory);
FreeImage_CloseMemory(hPngMemory);
if(dib_rgb && (dib_rgb != dib)) {
FreeImage_Unload(dib_rgb);
}
FreeImage_Unload(dib_alpha);
if(text) {
FreeImage_OutputMessageProc(format_id, text);
}
return FALSE;
}
}
bool IPLFileIO::saveFile(const std::string path, IPLImage* image, int format, int flags, IPLImage* result, bool preview)
{
int width = image->width();
int height = image->height();
FIBITMAP *dib = FreeImage_Allocate(width, height, 24);
if(image->type() == IPLData::IMAGE_COLOR)
{
for(int y = 0; y < height; y++)
{
for(int x = 0; x < width; x++)
{
RGBQUAD rgb;
rgb.rgbRed = static_cast<BYTE>(image->plane(0)->p(x, y) * FACTOR_TO_UCHAR); // R
rgb.rgbGreen = static_cast<BYTE>(image->plane(1)->p(x, y) * FACTOR_TO_UCHAR); // G
rgb.rgbBlue = static_cast<BYTE>(image->plane(2)->p(x, y) * FACTOR_TO_UCHAR); // B
FreeImage_SetPixelColor(dib, x, y, &rgb);
}
}
}
else
{
for(int y = 0; y < height; y++)
{
for(int x = 0; x < width; x++)
{
unsigned char value = image->plane(0)->p(x, y) * FACTOR_TO_UCHAR;
RGBQUAD rgb;
rgb.rgbRed = value; // R
rgb.rgbGreen = value; // G
rgb.rgbBlue = value; // B
FreeImage_SetPixelColor(dib, x, y, &rgb);
}
}
}
// all files need to be flipped
FreeImage_FlipVertical(dib);
bool success = false;
if(preview)
{
// only save to memory for preview
FIMEMORY* hmem = NULL;
// open and allocate a memory stream
hmem = FreeImage_OpenMemory();
success = FreeImage_SaveToMemory((FREE_IMAGE_FORMAT)format, dib, hmem, flags) != 0;
// write to result
if(result)
{
loadMemory((void*)hmem, result);
}
//FreeImage_CloseMemory(hmem);
}
else
{
// actually save file
success = FreeImage_Save((FREE_IMAGE_FORMAT)format, dib, path.c_str(), flags) != 0;
// write to result
if(result)
{
std::string information;
loadFile(path, result, information);
}
}
// free temporary memory
FreeImage_Unload(dib);
return success;
}