FREE_IMAGE_FORMAT fipImage::identifyFIFFromHandle(FreeImageIO *io, fi_handle handle) { if(io && handle) { // check the file signature and get its format return FreeImage_GetFileTypeFromHandle(io, handle, 16); } return FIF_UNKNOWN; }
bool ImageImporter::load(QIODevice *device) { d->deleteBitmap(); FreeImage_SetOutputMessage(outputMessage); FreeImageIO io; io.read_proc = readFromQIODevice; io.write_proc = 0; io.seek_proc = seekQIODevice; io.tell_proc = tellQIODevice; auto format = FreeImage_GetFileTypeFromHandle(&io, device); if (format != FIF_UNKNOWN) { int flags = 0; if (format == FIF_JPEG) flags = JPEG_ACCURATE; d->bitmap = FreeImage_LoadFromHandle(format, &io, device, flags); } if (d->bitmap) { int w = FreeImage_GetWidth(d->bitmap); int h = FreeImage_GetHeight(d->bitmap); d->size = QSize(w, h); } return d->bitmap; }
void CContent::init() { //just load one image for now, testing only FILE * file = fopen("Resources\\Sprites\\zfgc.png", "rb"); FreeImageIO io; //load the image data io.read_proc = _readProc; io.write_proc = _writeProc; io.seek_proc = _seekProc; io.tell_proc = _tellProc; FREE_IMAGE_FORMAT format = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)file, 0); if (format != FIF_PNG) return; FIBITMAP * dib = FreeImage_LoadFromHandle(format, &io, (fi_handle)file, 0); fclose(file); _sprites.insert(std::pair<std::string, FIBITMAP *>("test", dib)); }
FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size) { FreeImageIO io; SetMemoryIO(&io); if (stream != NULL) { return FreeImage_GetFileTypeFromHandle(&io, (fi_handle)stream, size); } return FIF_UNKNOWN; }
static BOOL openStdIOU(const wchar_t* src_file, const wchar_t* dst_file, FreeImageIO* dst_io, fi_handle* src_handle, fi_handle* dst_handle) { #ifdef _WIN32 *src_handle = NULL; *dst_handle = NULL; FreeImageIO io; SetDefaultIO (&io); const BOOL isSameFile = (dst_file && (wcscmp(src_file, dst_file) == 0)) ? TRUE : FALSE; FILE* srcp = NULL; FILE* dstp = NULL; if(isSameFile) { srcp = _wfopen(src_file, L"r+b"); dstp = srcp; } else { srcp = _wfopen(src_file, L"rb"); if(dst_file) { dstp = _wfopen(dst_file, L"wb"); } } if(!srcp || (dst_file && !dstp)) { if(!srcp) { FreeImage_OutputMessageProc(FIF_JPEG, "Cannot open source file for reading"); } else { FreeImage_OutputMessageProc(FIF_JPEG, "Cannot open destination file for writing"); } closeStdIO(srcp, dstp); return FALSE; } if(FreeImage_GetFileTypeFromHandle(&io, srcp) != FIF_JPEG) { FreeImage_OutputMessageProc(FIF_JPEG, " Source file is not jpeg"); closeStdIO(srcp, dstp); return FALSE; } *dst_io = io; *src_handle = srcp; *dst_handle = dstp; return TRUE; #else return FALSE; #endif // _WIN32 }
static BOOL openStdIO(const char* src_file, const char* dst_file, FreeImageIO* dst_io, fi_handle* src_handle, fi_handle* dst_handle) { *src_handle = NULL; *dst_handle = NULL; FreeImageIO io; SetDefaultIO (&io); const BOOL isSameFile = (dst_file && (strcmp(src_file, dst_file) == 0)) ? TRUE : FALSE; FILE* srcp = NULL; FILE* dstp = NULL; if(isSameFile) { srcp = fopen(src_file, "r+b"); dstp = srcp; } else { srcp = fopen(src_file, "rb"); if(dst_file) { dstp = fopen(dst_file, "wb"); } } if(!srcp || (dst_file && !dstp)) { if(!srcp) { FreeImage_OutputMessageProc(FIF_JPEG, "Cannot open \"%s\" for reading", src_file); } else { FreeImage_OutputMessageProc(FIF_JPEG, "Cannot open \"%s\" for writing", dst_file); } closeStdIO(srcp, dstp); return FALSE; } if(FreeImage_GetFileTypeFromHandle(&io, srcp) != FIF_JPEG) { FreeImage_OutputMessageProc(FIF_JPEG, " Source file \"%s\" is not jpeg", src_file); closeStdIO(srcp, dstp); return FALSE; } *dst_io = io; *src_handle = srcp; *dst_handle = dstp; return TRUE; }
FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileType(const char *filename, int size) { FreeImageIO io; SetDefaultIO(&io); FILE *handle = fopen(filename, "rb"); if (handle != NULL) { FREE_IMAGE_FORMAT format = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)handle, size); fclose(handle); return format; } return FIF_UNKNOWN; }
FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeU(const wchar_t *filename, int size) { #ifdef WIN32 FreeImageIO io; SetDefaultIO(&io); FILE *handle = _wfopen(filename, L"rb"); if (handle != NULL) { FREE_IMAGE_FORMAT format = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)handle, size); fclose(handle); return format; } #endif return FIF_UNKNOWN; }
BOOL fipImage::loadFromHandle(FreeImageIO *io, fi_handle handle, int flag) { FREE_IMAGE_FORMAT fif = FIF_UNKNOWN; // check the file signature and get its format fif = FreeImage_GetFileTypeFromHandle(io, handle, 16); if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)) { // Free the previous dib if(_dib) { FreeImage_Unload(_dib); } // Load the file _dib = FreeImage_LoadFromHandle(fif, io, handle, flag); _bHasChanged = TRUE; if(_dib == NULL) return FALSE; return TRUE; } return FALSE; }
Auto<Resource> Texture2DLoader::LoadResource(ResourceManager& resourceManager, istream& inputStream, const std::string& internalName) { FreeImageIO io; fi_handle handle = (fi_handle)(&inputStream); io.read_proc = [] (void *buffer, unsigned size, unsigned count, fi_handle handle) { istream* input = (istream*)handle; unsigned bytes = size * count; unsigned totalRead = 0; unsigned loopRead = 0; do { input->read((char*)buffer + totalRead, bytes - totalRead); loopRead = (unsigned)input->gcount(); totalRead += loopRead; } while (loopRead > 0 && totalRead < bytes); unsigned result = totalRead / size; unsigned overRead = totalRead % size; if (overRead > 0) { input->seekg(-(int)overRead, ios_base::cur); } return result; }; io.write_proc = NULL; io.seek_proc = [] (fi_handle handle, long offset, int origin) { istream* input = (istream*)handle; ios_base::seekdir seekDir = (origin == SEEK_END) ? ios_base::end : ( (origin == SEEK_CUR) ? ios_base::cur : ios_base::beg); try { input->seekg(offset, seekDir); return (int)(input->fail() ? 1 : 0); } catch (ios_base::failure&) { return (int)1; } }; io.tell_proc = [](fi_handle handle) { istream* input = (istream*)handle; return (long)input->tellg(); }; FREE_IMAGE_FORMAT imageFormat = FreeImage_GetFileTypeFromHandle(&io, handle, 0); if (imageFormat == FIF_UNKNOWN) { throw FormatException("Unrecogized image format"); } FIBITMAP* bitmap = FreeImage_LoadFromHandle(imageFormat, &io, handle, 0); FREE_IMAGE_TYPE dataType = FreeImage_GetImageType(bitmap); DataFormat::Type formatType; size_t channelCount = 0; vector<unsigned char> textureData; Vector2i size(FreeImage_GetWidth(bitmap), FreeImage_GetHeight(bitmap)); if (dataType == FIT_BITMAP) { formatType = DataFormat::Int8UNorm; channelCount = 4; FIBITMAP* bitmap32Bit = FreeImage_ConvertTo32Bits(bitmap); FreeImage_Unload(bitmap); bitmap = bitmap32Bit; textureData.resize(FreeImage_GetPitch(bitmap) * size.y); SwapChannels<unsigned char>(FreeImage_GetBits(bitmap), &textureData.front(), 0, 2, size.x * size.y, 4); } else { throw FormatException("Unsupported depth format"); } Auto<Texture2D> result = resourceManager.GetGraphics()->CreateTexture2D(size, DataFormat(formatType, channelCount)); result->LoadMemory(&textureData.front()); result->GenerateMipmaps(); if (bitmap != NULL) { FreeImage_Unload(bitmap); bitmap = NULL; } return result; }
bool Image::load (const char* fname) { release () ; // createTestData () ; // return true ; char buf[256] ; sprintf_s (buf, sizeof (buf), "image\\%s", fname) ; // fname = "image\\avatar000.png" ; FILE* pFile = NULL ; fopen_s (&pFile, buf, "rb") ; if (pFile == NULL) return false ; FreeImageIO io; io.read_proc = myReadProc; io.write_proc = myWriteProc; io.seek_proc = mySeekProc; io.tell_proc = myTellProc; // find the buffer format FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)pFile, 0); if(fif == FIF_UNKNOWN) { /* Close the file */ fclose(pFile); return false ; } // load from the file handle FIBITMAP *dib = FreeImage_LoadFromHandle(fif, &io, (fi_handle)pFile, 0); BYTE* pPixelData = FreeImage_GetBits(dib) ; int width, height,pitch ; width = FreeImage_GetWidth(dib); height = FreeImage_GetHeight(dib); pitch = FreeImage_GetPitch(dib); int bpp = FreeImage_GetBPP(dib) ; assert (bpp == 32) ; FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib) ; assert (image_type == FIT_BITMAP) ; // /* //轉換rgba(因為rgba,的順序不同) RGBQUAD rgba ; BYTE* pBit = pPixelData ; for (int i = 0 ; i<height; i++) { BYTE* pPixel = pBit ; for (int m = 0; m<width; m++) { if (FreeImage_GetPixelColor(dib, m, i, &rgba)) { BYTE tmp = rgba.rgbBlue ; rgba.rgbBlue = rgba.rgbRed ; rgba.rgbRed = tmp ; FreeImage_SetPixelColor (dib, m, i, &rgba) ; } } pBit += pitch ; } // */ //--------------------------------------------------- //把pixel copy給 //最大記憶體 if (pPixelData != NULL) { assert (textureID == NO_TEXTURE_ID) ; if (textureID == NO_TEXTURE_ID) { //空的要先建立 // Allocates one texture handle glGenTextures(1, &textureID); } assert (textureID != NO_TEXTURE_ID) ; // Binds this texture handle so we can load the data into it glBindTexture(GL_TEXTURE_2D, textureID); glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pPixelData); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR ); // free the loaded FIBITMAP FreeImage_Unload(dib); } return true ; }
int main(int argc, char *argv[]) { // call this ONLY when linking with FreeImage as a static library #ifdef FREEIMAGE_LIB FreeImage_Initialise(); #endif // FREEIMAGE_LIB // initialize your own FreeImage error handler FreeImage_SetOutputMessage(FreeImageErrorHandler); // print version & copyright infos printf(FreeImage_GetVersion()); printf("\n"); printf(FreeImage_GetCopyrightMessage()); printf("\n"); if(argc != 2) { printf("Usage : LoadFromHandle <input file name>\n"); return 0; } // initialize your own IO functions FreeImageIO io; io.read_proc = myReadProc; io.write_proc = myWriteProc; io.seek_proc = mySeekProc; io.tell_proc = myTellProc; FILE *file = fopen(argv[1], "rb"); if (file != NULL) { // find the buffer format FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)file, 0); if(fif != FIF_UNKNOWN) { // load from the file handle FIBITMAP *dib = FreeImage_LoadFromHandle(fif, &io, (fi_handle)file, 0); // save the bitmap as a PNG ... const char *output_filename = "test.png"; // first, check the output format from the file name or file extension FREE_IMAGE_FORMAT out_fif = FreeImage_GetFIFFromFilename(output_filename); if(out_fif != FIF_UNKNOWN) { // then save the file FreeImage_Save(out_fif, dib, output_filename, 0); } // free the loaded FIBITMAP FreeImage_Unload(dib); } fclose(file); } // call this ONLY when linking with FreeImage as a static library #ifdef FREEIMAGE_LIB FreeImage_DeInitialise(); #endif // FREEIMAGE_LIB return 0; }
bool M_loadImage(const char * filename, void * data, void * arg) { if(! filename) return false; if(! data) return false; // freeimage io FreeImageIO io; io.read_proc = (FI_ReadProc)readProc; io.write_proc = (FI_WriteProc)writeProc; io.tell_proc = (FI_TellProc)tellProc; io.seek_proc = (FI_SeekProc)seekProc; // read file buffer MFile * fp = M_fopen(filename, "rb"); if(! fp) { printf("Error : can't read file %s\n", filename); return false; } // read freeimage FREE_IMAGE_FORMAT format = FreeImage_GetFileTypeFromHandle(&io, (fi_handle)fp, 0); if(format == FIF_UNKNOWN) { printf("Error : unknow format %s\n", filename); M_fclose(fp); return false; } FIBITMAP * dib = FreeImage_LoadFromHandle(format, &io, (fi_handle)fp); if(! dib) { printf("Error : unknow dib %s\n", filename); M_fclose(fp); return false; } BYTE * bits = FreeImage_GetBits(dib); unsigned int width = FreeImage_GetWidth(dib); unsigned int height = FreeImage_GetHeight(dib); unsigned int bpp = FreeImage_GetBPP(dib); FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib); if((bits == 0) || (width == 0) || (height == 0)) { FreeImage_Unload(dib); M_fclose(fp); return false; } // flip FreeImage_FlipVertical(dib); // create image MImage * image = (MImage *)data; switch(image_type) { case FIT_BITMAP: switch(bpp) { case 8: image->create(M_UBYTE, width, height, 1); for(unsigned int y=0; y<height; y++) { unsigned char * dest = (unsigned char *)image->getData() + width*y; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*sizeof(char)); } break; case 24: SwapRedBlue32(dib); image->create(M_UBYTE, width, height, 3); for(unsigned int y=0; y<height; y++) { unsigned char * dest = (unsigned char *)image->getData() + width*y*3; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*3*sizeof(char)); } break; case 32: SwapRedBlue32(dib); image->create(M_UBYTE, width, height, 4); for(unsigned int y=0; y<height; y++) { unsigned char * dest = (unsigned char *)image->getData() + width*y*4; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*4*sizeof(char)); } break; default: break; } break; case FIT_RGB16: image->create(M_USHORT, width, height, 3); for(unsigned int y=0; y<height; y++) { unsigned short * dest = (unsigned short *)image->getData() + width*y*3; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*3*sizeof(short)); } break; case FIT_RGBA16: image->create(M_USHORT, width, height, 4); for(unsigned int y=0; y<height; y++) { unsigned short * dest = (unsigned short *)image->getData() + width*y*4; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*4*sizeof(short)); } break; case FIT_FLOAT: image->create(M_FLOAT, width, height, 1); for(unsigned int y=0; y<height; y++) { float * dest = (float *)image->getData() + width*y; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*sizeof(float)); } break; case FIT_RGBF: image->create(M_FLOAT, width, height, 3); for(unsigned int y=0; y<height; y++) { float * dest = (float *)image->getData() + width*y*3; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*3*sizeof(float)); } break; case FIT_RGBAF: image->create(M_FLOAT, width, height, 4); for(unsigned int y=0; y<height; y++) { float * dest = (float *)image->getData() + width*y*4; bits = FreeImage_GetScanLine(dib, y); memcpy(dest, bits, width*4*sizeof(float)); } break; default: break; } // clean FreeImage_Unload(dib); M_fclose(fp); return true; }
// This is what does the work in the background thread UINT CHexEditDoc::RunPreviewThread() { // Keep looping until we are told to die for (;;) { // Signal that we are waiting then wait for start_preview_event_ to be pulsed { CSingleLock sl(&docdata_, TRUE); preview_state_ = WAITING; } TRACE1("+++ BGPreview: waiting for %p\n", this); DWORD wait_status = ::WaitForSingleObject(HANDLE(start_preview_event_), INFINITE); docdata_.Lock(); preview_state_ = SCANNING; docdata_.Unlock(); start_preview_event_.ResetEvent(); ASSERT(wait_status == WAIT_OBJECT_0); TRACE1("+++ BGPreview: got event for %p\n", this); if (PreviewProcessStop()) continue; // Reset for new scan docdata_.Lock(); preview_fin_ = false; preview_address_ = 0; if (preview_dib_ != NULL) { FreeImage_Unload(preview_dib_); preview_dib_ = NULL; } docdata_.Unlock(); FREE_IMAGE_FORMAT fif = FreeImage_GetFileTypeFromHandle(&fi_funcs, this); FIBITMAP * dib; // Catch FreeImage_Load exceptions since it has been known to have memory access violations on bad data try { dib = FreeImage_LoadFromHandle(fif, &fi_funcs, this); } catch (...) { dib = NULL; } int bpp = FreeImage_GetBPP(dib); unsigned width = FreeImage_GetWidth(dib); unsigned height = FreeImage_GetHeight(dib); TRACE1("+++ BGPreview: finished load for %p\n", this); docdata_.Lock(); preview_fin_ = true; preview_address_ = 0; preview_dib_ = dib; // Save info about the bitmap just loaded preview_fif_ = fif; preview_bpp_ = bpp; preview_width_ = width; preview_height_ = height; docdata_.Unlock(); } return 0; // never reached }