自学教程：C++ FreeImage_OpenMemory函数代码示例

// Transmits an entire frame of imagery to the clientint sendFullFrame(SOCKET &clientSocket) {	int status = 0;	FIBITMAP *fiImage;	FIMEMORY *fiBuffer;	// Signal that a new frame is required and wait for frame	InterlockedExchange( &g_lRequestFlag, TRUE );	g_pRequestEvent->waitFor();		// Enter critical section for frame buffer from UT2004	// and copy new raw image to local buffer	EnterCriticalSection( &g_CriticalSection );	{		fiImage = FreeImage_ConvertTo24Bits(g_fiImage);	} 	LeaveCriticalSection( &g_CriticalSection );	// Create memory reference	fiBuffer = FreeImage_OpenMemory();	// Convert a raw frame to a useful image	status = writeFrame( fiBuffer, fiImage, g_iImageType );	if (status != 1) status = 0; // TODO: handle error here		// Transmit frame over socket	status = transmitFrame( fiBuffer, clientSocket, g_iImageType );	// Delete memory references	FreeImage_Unload( fiImage );	FreeImage_CloseMemory( fiBuffer );	return status;}

FIBITMAP *GraphicsHelps::loadImageRC(const char *file){    unsigned char *memory = nullptr;    size_t fileSize = 0;    SDL_assert_release(RES_getMem(file, memory, fileSize));    //{        //pLogCritical("Resource file /"%s/" is not found!", file);        //return nullptr;    //}    FIMEMORY *imgMEM = FreeImage_OpenMemory(memory, static_cast<FI_DWORD>(fileSize));    FREE_IMAGE_FORMAT formato = FreeImage_GetFileTypeFromMemory(imgMEM);    if(formato == FIF_UNKNOWN)        return nullptr;    FIBITMAP *img = FreeImage_LoadFromMemory(formato, imgMEM, 0);    FreeImage_CloseMemory(imgMEM);    if(!img)        return nullptr;    FIBITMAP *temp;    temp = FreeImage_ConvertTo32Bits(img);    if(!temp)        return nullptr;    FreeImage_Unload(img);    img = temp;    return img;}

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

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

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);}

// 独立函数，读取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) ; // 使用完缓存记得要释放}

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);}

unsigned char * HVSTGFX::loadImageFile(CFileData *image, HVSTGFX::IMAGEFILE *imgFile, GLuint &texture){	FREE_IMAGE_FORMAT fif = FreeImage_GetFIFFromFilename(image->getName().c_str());	FIMEMORY * stream = 0;	unsigned char tempRGB;	GLuint tempTex = 0;	GLenum errCode;	bool error = false;	stream = FreeImage_OpenMemory(image->getData());	if(FreeImage_FIFSupportsReading(fif))	imgFile->dib = FreeImage_LoadFromMemory(fif, stream);	if(!imgFile->dib)	{		glbl->debugger->writeString("failed to open sprite " + image->getName());		return NULL;	}	//pointer to image data	unsigned char* bits;	bits = FreeImage_GetBits(imgFile->dib);	imgFile->width = FreeImage_GetWidth(imgFile->dib); imgFile->height = FreeImage_GetHeight(imgFile->dib);	imgFile->size = sizeof(bits);	int size = imgFile->width*imgFile->height;//(FreeImage_GetWidth(dib) * FreeImage_GetHeight(dib));	for (int imageIDx = 0; imageIDx < size * 4; imageIDx += 4)	{		tempRGB = bits[imageIDx];		bits[imageIDx] = bits[imageIDx + 2];		bits[imageIDx + 2] = tempRGB;	}		glGenTextures(1, &tempTex);	texture = tempTex;		errCode = glGetError();	if (errCode != GL_NO_ERROR)	{		MessageBox(NULL, _T("Unable to detect OpenGL support. Check if you have your graphics driver installed, or if your graphics card supports OpenGL."), NULL, NULL);	}	glBindTexture(GL_TEXTURE_2D, texture);		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, imgFile->width, imgFile->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, bits);		//FreeImage_Unload(dib);	#ifdef _DEBUG	if (!error)		glbl->debugger->writeString("successfully loaded sprite " + image->getName() + "/n");#endif	return bits;}

Ogre::TexturePtr textureFromBytes(const QByteArray &ba,                                  const std::string &name) {  static bool fi_init = false;  if (!fi_init) {    FreeImage_Initialise();  }  void *data = const_cast<char *>(ba.data());  FIMEMORY *mem =      FreeImage_OpenMemory(reinterpret_cast<BYTE *>(data), ba.size());  FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(mem, 0);  if (fif == FIF_UNKNOWN) {    FreeImage_CloseMemory(mem);    throw std::runtime_error("Image format is not supported for loading");  }  FIBITMAP *bmp = FreeImage_LoadFromMemory(fif, mem, 0);  FreeImage_CloseMemory(mem);  if (!bmp) {    throw std::runtime_error("Failed to decode image");  }  FIBITMAP *converted = FreeImage_ConvertTo24Bits(bmp);  FreeImage_Unload(bmp);  if (!converted) {    throw std::runtime_error("Failed to convert image to 24 bit");  }  const unsigned w = FreeImage_GetWidth(converted);  const unsigned h = FreeImage_GetHeight(converted);  const unsigned data_size = w * h * 3;  BYTE *image_data = FreeImage_GetBits(converted);  ROS_INFO("Loading a %u x %u texture", w, h);  //  create texture  Ogre::TexturePtr texture;  try {    Ogre::DataStreamPtr data_stream;    data_stream.bind(new Ogre::MemoryDataStream(image_data, data_size));    const Ogre::String res_group =        Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME;    Ogre::TextureManager &texture_manager =        Ogre::TextureManager::getSingleton();    texture =        texture_manager.loadRawData(name, res_group, data_stream, w, h,                                    Ogre::PF_R8G8B8, Ogre::TEX_TYPE_2D, 0);  }  catch (...) {    //  clean up FreeImage before re-throwing    FreeImage_Unload(converted);    throw;  }  return texture;}

	bool isThisFormat(MemChunk& mc)	{		FIMEMORY*         mem = FreeImage_OpenMemory((BYTE*)mc.getData(), mc.getSize());		FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(mem, 0);		FreeImage_CloseMemory(mem);		if (fif == FIF_UNKNOWN)			return false;		else			return true;	}

FIBITMAP* FreeImage_LoadFromMem(FREE_IMAGE_FORMAT fif, fiio_mem_handle *handle, int flags){	if (handle && handle->data) {		FIMEMORY *hmem = FreeImage_OpenMemory((BYTE *)handle->data, handle->datalen);		FREE_IMAGE_FORMAT _fif = (fif != FIF_UNKNOWN) ? fif : FreeImage_GetFileTypeFromMemory(hmem, 0);		FIBITMAP *dib = FreeImage_LoadFromMemory(_fif, hmem, flags);		FreeImage_CloseMemory(hmem);	}	return NULL;}

void FI(loadImageFile)(Bitmap& bitmap, Gosu::Reader input){    // Read all available input    std::vector<BYTE> data(input.resource().size() - input.position());    input.read(&data[0], data.size());    FIMEMORY* fim = FreeImage_OpenMemory(&data[0], data.size());    FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(fim);    FIBITMAP* fib = FreeImage_LoadFromMemory(fif, fim, GOSU_FIFLAGS);    checkForFreeImageErrors(fib != 0);    fibToBitmap(bitmap, fib, fif);}

/** Get the embedded JPEG preview image from RAW picture with included Exif Data. @param RawProcessor Libraw handle@param flags JPEG load flags@return Returns the loaded dib if successfull, returns NULL otherwise*/static FIBITMAP * libraw_LoadEmbeddedPreview(LibRaw *RawProcessor, int flags) {	FIBITMAP *dib = NULL;	libraw_processed_image_t *thumb_image = NULL;		try {		// unpack data		if(RawProcessor->unpack_thumb() != LIBRAW_SUCCESS) {			// run silently "LibRaw : failed to run unpack_thumb"			return NULL;		}		// retrieve thumb image		int error_code = 0;		thumb_image = RawProcessor->dcraw_make_mem_thumb(&error_code);		if(thumb_image) {			if(thumb_image->type != LIBRAW_IMAGE_BITMAP) {				// attach the binary data to a memory stream				FIMEMORY *hmem = FreeImage_OpenMemory((BYTE*)thumb_image->data, (DWORD)thumb_image->data_size);				// get the file type				FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem, 0);				if(fif == FIF_JPEG) {					// rotate according to Exif orientation					flags |= JPEG_EXIFROTATE;				}				// load an image from the memory stream				dib = FreeImage_LoadFromMemory(fif, hmem, flags);				// close the stream				FreeImage_CloseMemory(hmem);			} else if((flags & FIF_LOAD_NOPIXELS) != FIF_LOAD_NOPIXELS) {				// convert processed data to output dib				dib = libraw_ConvertProcessedImageToDib(thumb_image);			}		} else {			throw "LibRaw : failed to run dcraw_make_mem_thumb";		}		// clean-up and return		RawProcessor->dcraw_clear_mem(thumb_image);		return dib;	} catch(const char *text) {		// clean-up and return		if(thumb_image) {			RawProcessor->dcraw_clear_mem(thumb_image);		}		if(text != NULL) {			FreeImage_OutputMessageProc(s_format_id, text);		}	}	return NULL;}

int CPropertiesFiles::previewWndProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam) {	static bool fDowned=false;	switch (uMsg) {		case WM_INITDIALOG:			if (!fiBitmap) {				FIMEMORY* fiMemory=FreeImage_OpenMemory((BYTE*)lParam,bitmapInfo->unc_size);				RECT rect;				POINT pt={0,0};				if (fiBitmap=FreeImage_LoadFromMemory(_tcsicmp(bitmapInfo->name+_tcslen(bitmapInfo->name)-4,".tga")?_tcsicmp(bitmapInfo->name+_tcslen(bitmapInfo->name)-4,".bmp")?FIF_JPEG:FIF_BMP:FIF_TARGA,fiMemory)) {					::GetWindowRect(hwndDlg,&rect);					::ClientToScreen(hwndDlg,&pt);					rect.right=FreeImage_GetWidth(fiBitmap)+(pt.x-rect.left);					rect.bottom=FreeImage_GetHeight(fiBitmap)+(pt						.y-rect.top);;					::MoveWindow(hwndDlg,rect.left,rect.top,rect.right,rect.bottom,FALSE);					FreeImage_CloseMemory(fiMemory);					::SetWindowText(hwndDlg,_tcsrchr(bitmapInfo->name,'/')+1);					fDowned=false;				} else {					fDowned=true;					::EndDialog(hwndDlg,0);				}			}			break;		case WM_LBUTTONDOWN:		case WM_RBUTTONDOWN:			fDowned=true;			break;		case WM_CLOSE:			fDowned=true;		case WM_LBUTTONUP:		case WM_RBUTTONUP:			if (fDowned) {				FreeImage_Unload(fiBitmap);				fiBitmap=NULL;				::EndDialog(hwndDlg,0);			}			break;		case WM_PAINT:			{				HDC hDC=::GetDC(hwndDlg);				::SetStretchBltMode(hDC, COLORONCOLOR);				::StretchDIBits(hDC, 0,0,FreeImage_GetWidth(fiBitmap), FreeImage_GetHeight(fiBitmap), 					0, 0, FreeImage_GetWidth(fiBitmap), FreeImage_GetHeight(fiBitmap),					FreeImage_GetBits(fiBitmap), FreeImage_GetInfo(fiBitmap), DIB_RGB_COLORS, SRCCOPY);				::ReleaseDC(hwndDlg,hDC);			}	}	return FALSE;}

void TextureManager::loadTexture2DMem(unsigned char* imageData,long length) {    FIMEMORY* hmem = FreeImage_OpenMemory(imageData,length);    FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);    FIBITMAP* image = FreeImage_LoadFromMemory(fif, hmem, 0);    FIBITMAP* temp = image;    image = FreeImage_ConvertTo32Bits(image);    FreeImage_Unload(temp);    FreeImage_CloseMemory(hmem);    int w = FreeImage_GetWidth(image);    int h = FreeImage_GetHeight(image);    printf("[Texture Manager] Image loaded from memory, is %d x %d/n",w,h);    GLubyte* textureBytes = new GLubyte[4*w*h];    char* pixels = (char*)FreeImage_GetBits(image);    //FreeImage loads in BGR format, so we need to swap some bytes(Or use GL_BGR)    for(int j= 0; j<w*h; j++) {        textureBytes[j*4+0]= pixels[j*4+2];        textureBytes[j*4+1]= pixels[j*4+1];        textureBytes[j*4+2]= pixels[j*4+0];        textureBytes[j*4+3]= pixels[j*4+3];    }    glGenTextures(1, &(textInt));    glBindTexture(GL_TEXTURE_2D, textInt);    glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA, w, h, 0, GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid*)textureBytes );    Textures.push_back(textInt);    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );    glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);    GLenum errorLoading = glGetError();    if(errorLoading) {        cout<<"There was an error loading the texture: "<<errorLoading<<endl;    }}

void DLL_CALLCONVFreeImage_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;}

//----------------------------------------------------bool ofImage::loadImageFromMemory(const ofBuffer & buffer, ofPixels &pix){	int					width, height, bpp;	bool bLoaded		= false;	FIBITMAP * bmp		= NULL;	FIMEMORY *hmem		= NULL;		printf("loadImageFromMemory/n");	hmem = FreeImage_OpenMemory((unsigned char*)buffer.getBuffer(), buffer.size());	if (hmem == NULL){		ofLog(OF_LOG_ERROR,"couldn't create memory handle! /n");		return false;	}	//get the file type!	FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);	if( fif == -1 ){		ofLog(OF_LOG_ERROR,"unable to guess format", fif);		return false;		FreeImage_CloseMemory(hmem);	}	//make the image!!	bmp = FreeImage_LoadFromMemory(fif, hmem, 0);		if( bmp != NULL ){		bLoaded = true;		ofLog(OF_LOG_VERBOSE,"FreeImage_LoadFromMemory worked!/n");	}		//-----------------------------	if (bLoaded){		putBmpIntoPixels(bmp,pix);	} else {		width = height = bpp = 0;	}	if (bmp != NULL){		FreeImage_Unload(bmp);	}		if( hmem != NULL ){		FreeImage_CloseMemory(hmem);	}	return bLoaded;}

static bool loadImage(ofPixels_<PixelType> & pix, const ofBuffer & buffer, const ofImageLoadSettings &settings){	ofInitFreeImage();	bool bLoaded = false;	FIBITMAP* bmp = nullptr;	FIMEMORY* hmem = nullptr;		hmem = FreeImage_OpenMemory((unsigned char*) buffer.getData(), buffer.size());	if (hmem == nullptr){		ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, opening FreeImage memory failed";		return false;	}	//get the file type!	FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);	if( fif == -1 ){		ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, unable to guess image format from memory";		FreeImage_CloseMemory(hmem);		return false;	}	//make the image!!	if(fif == FIF_JPEG) {		int option = getJpegOptionFromImageLoadSetting(settings);		bmp = FreeImage_LoadFromMemory(fif, hmem, option);	} else {		bmp = FreeImage_LoadFromMemory(fif, hmem, 0);	}		if( bmp != nullptr ){		bLoaded = true;	}		//-----------------------------		if (bLoaded){		putBmpIntoPixels(bmp,pix);	}	if (bmp != nullptr){		FreeImage_Unload(bmp);	}		if( hmem != nullptr ){		FreeImage_CloseMemory(hmem);	}	return bLoaded;}

void DLL_CALLCONVFreeImage_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;			}		}	}}

static bool loadImage(ofPixels_<PixelType> & pix, const ofBuffer & buffer){	ofInitFreeImage();	bool bLoaded = false;	FIBITMAP* bmp = NULL;	FIMEMORY* hmem = NULL;		hmem = FreeImage_OpenMemory((unsigned char*) buffer.getBinaryBuffer(), buffer.size());	if (hmem == NULL){		ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, opening FreeImage memory failed";		return false;	}	//get the file type!	FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);	if( fif == -1 ){		ofLogError("ofImage") << "loadImage(): couldn't load image from ofBuffer, unable to guess image format from memory";		return false;		FreeImage_CloseMemory(hmem);	}	//make the image!!	bmp = FreeImage_LoadFromMemory(fif, hmem, 0);		if( bmp != NULL ){		bLoaded = true;	}		//-----------------------------		if (bLoaded){		putBmpIntoPixels(bmp,pix);	}	if (bmp != NULL){		FreeImage_Unload(bmp);	}		if( hmem != NULL ){		FreeImage_CloseMemory(hmem);	}	return bLoaded;}

/**Write a metadata model as a TIF IFD, returns the IFD as a buffer.The buffer is allocated by the function and must be freed by the caller, using 'free'.@param dib Input FIBITMAP@param md_model Metadata model to write@param ppbProfile Returned buffer@param uProfileLength Returned buffer size@return Returns TRUE if successful, FALSE otherwise@see tiff_write_ifd*/BOOLtiff_get_ifd_profile(FIBITMAP *dib, FREE_IMAGE_MDMODEL md_model, BYTE **ppbProfile, unsigned *uProfileLength) {	FIMEMORY *hmem = NULL;	try {		// open a memory stream		hmem = FreeImage_OpenMemory(NULL, 0);		if(!hmem) {			throw(1);		}		// write the metadata model as a TIF IFD		BOOL bResult = tiff_write_ifd(dib, md_model, hmem);		if(bResult) {			BYTE *data = NULL;			DWORD size_in_bytes = 0;			// get a pointer to the stream buffer			FreeImage_AcquireMemory(hmem, &data, &size_in_bytes);						// (re-)allocate output buffer			BYTE *pbProfile = *ppbProfile;			pbProfile = (BYTE*)realloc(pbProfile, size_in_bytes);			if(!pbProfile) {				throw(1);			} else {				// copy IFD				memcpy(pbProfile, data, size_in_bytes);				*ppbProfile = pbProfile;				*uProfileLength = size_in_bytes;			}		}		// free the memory stream		FreeImage_CloseMemory(hmem);		return bResult;	} catch(int) {		FreeImage_CloseMemory(hmem);		return FALSE;	}}

static bool loadImage(ofPixels_<PixelType> & pix, const ofBuffer & buffer){	ofInitFreeImage();	bool bLoaded = false;	FIBITMAP* bmp = NULL;	FIMEMORY* hmem = NULL;		hmem = FreeImage_OpenMemory((unsigned char*) buffer.getBinaryBuffer(), buffer.size());	if (hmem == NULL){		ofLog(OF_LOG_ERROR, "couldn't create memory handle!");		return false;	}	//get the file type!	FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(hmem);	if( fif == -1 ){		ofLog(OF_LOG_ERROR, "unable to guess format", fif);		return false;		FreeImage_CloseMemory(hmem);	}	//make the image!!	bmp = FreeImage_LoadFromMemory(fif, hmem, 0);		if( bmp != NULL ){		bLoaded = true;	}		//-----------------------------		if (bLoaded){		putBmpIntoPixels(bmp,pix);	}	if (bmp != NULL){		FreeImage_Unload(bmp);	}		if( hmem != NULL ){		FreeImage_CloseMemory(hmem);	}	return bLoaded;}

static INT_PTR serviceLoadFromMem(WPARAM wParam, LPARAM lParam){	IMGSRVC_MEMIO *mio = (IMGSRVC_MEMIO *)wParam;	if(mio->iLen == 0 || mio->pBuf == NULL)		return 0;	FIMEMORY *hmem = FreeImage_OpenMemory((BYTE *)mio->pBuf, mio->iLen);	FREE_IMAGE_FORMAT fif = (mio->fif != FIF_UNKNOWN) ? mio->fif : mio->fif = FreeImage_GetFileTypeFromMemory(hmem, 0);	FIBITMAP *dib = FreeImage_LoadFromMemory(fif, hmem, mio->flags);	FreeImage_CloseMemory(hmem);	if(dib == NULL || (lParam & IMGL_RETURNDIB))		return (INT_PTR)dib;	HBITMAP hbm = FreeImage_CreateHBITMAPFromDIB(dib);	FreeImage_Unload(dib);	return (INT_PTR)hbm;}

std::shared_ptr<FIBITMAP> load_png_from_memory(const void* memory_location, size_t size){	FREE_IMAGE_FORMAT fif = FIF_PNG;	auto memory = std::unique_ptr<FIMEMORY, decltype(&FreeImage_CloseMemory)>(			FreeImage_OpenMemory(static_cast<BYTE*>(const_cast<void*>(memory_location)), size),			FreeImage_CloseMemory);	auto bitmap = std::shared_ptr<FIBITMAP>(FreeImage_LoadFromMemory(fif, memory.get(), 0), FreeImage_Unload);	if (FreeImage_GetBPP(bitmap.get()) != 32)	{		bitmap = std::shared_ptr<FIBITMAP>(FreeImage_ConvertTo32Bits(bitmap.get()), FreeImage_Unload);		if (!bitmap)			BOOST_THROW_EXCEPTION(invalid_argument() << msg_info("Unsupported image format."));	}	return bitmap;}

    //---------------------------------------------------------------------    String FreeImageCodec::magicNumberToFileExt(const char *magicNumberPtr, size_t maxbytes) const    {        FIMEMORY* fiMem =            FreeImage_OpenMemory((BYTE*)magicNumberPtr, static_cast<DWORD>(maxbytes));        FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(fiMem, (int)maxbytes);        FreeImage_CloseMemory(fiMem);        if (fif != FIF_UNKNOWN)        {            String ext(FreeImage_GetFormatFromFIF(fif));            StringUtil::toLowerCase(ext);            return ext;        }        else        {            return StringUtil::BLANK;        }    }

bool FreeImageLoader::canLoad(OS::IStream* file){	if(m_isDummy)		return false;	if(file->isStream())		return false;	byte* data = new byte[file->length()];	FIMEMORY* fiMem = FreeImage_OpenMemory((BYTE*)data, static_cast<DWORD>(file->length()));	file->read(data, file->length());	FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromMemory(fiMem, (int)file->length());	FreeImage_CloseMemory(fiMem);	delete[] data;	//image format//	FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;	//check the file signature and deduce its format//	fif = FreeImage_GetFileTypeFromMemory((FIMEMORY*)data,file->length());	if(fif == FIF_UNKNOWN)		return false;	return fif==m_FTType;}

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);}

VALUE rb_graffik_from_memory(VALUE self, VALUE rb_data) {  FREE_IMAGE_FORMAT fif = FIF_UNKNOWN;  Check_Type(rb_data, T_STRING);    // Get info about our in-memory image  BYTE *data_ptr = (BYTE *) RSTRING_PTR(rb_data);  DWORD data_length = RSTRING_LEN(rb_data);    // Open up the memory stream  FIMEMORY *stream = FreeImage_OpenMemory(data_ptr, data_length);    // Make sure the stream was open  if (stream == NULL) {    rb_raise(rb_eTypeError, "Unable to read image from memory");  }    fif = FreeImage_GetFileTypeFromMemory(stream, 0);  if ((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) {    int flags = ((fif == FIF_JPEG) ? JPEG_ACCURATE : 0);    // Load the image from disk    FIBITMAP *image = FreeImage_LoadFromMemory(fif, stream, flags);    // Release memory    FreeImage_CloseMemory(stream);    // Develop an instance for Ruby    VALUE instance = Data_Wrap_Struct(self, NULL, NULL, image);    // Store the image type as a FixNum    rb_iv_set(instance, "@file_type", INT2FIX(fif));        // If a block is given, yield to it, if not, return the instance    if (rb_block_given_p()) {      return rb_ensure(rb_yield, instance, rb_graffik_close, instance);    } else {      return instance;    }  }    // If we couldn't load it, throw and error  rb_raise(rb_eTypeError, "Unknown file format");}