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

TextureManager::~TextureManager() {// call this ONLY when linking with FreeImage as a static library#ifdef FREEIMAGE_LIB  FreeImage_DeInitialise();#endif  UnloadAllTextures();  m_inst = 0;}

int main(int argc, char** argv) {	DLL_API void DLL_CALLCONV FreeImage_Initialise(BOOL load_local_plugins_only FI_DEFAULT(FALSE));	for(int i = 1; i < argc; i++)	{		fileRead(argv[i]);	}	FreeImage_DeInitialise();	return 0;};

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 version : %s", FreeImage_GetVersion());	printf("/n");	printf(FreeImage_GetCopyrightMessage());	printf("/n");	if(argc != 3) {		printf("Usage : CreateAlpha <input file name> <output file name>/n");		return 0;	}	// Load the source image	FIBITMAP *src = GenericLoader(argv[1], 0);	if(src) {		// Create a transparent image from the lightness image of src		FIBITMAP *dst = CreateAlphaFromLightness(src);		if(dst) {			// Save the destination image			bool bSuccess = GenericWriter(dst, argv[2], 0);			if(!bSuccess) {				printf("/nUnable to save %s file", argv[2]);				printf("/nThis format does not support 32-bit images");			}			// Free dst			FreeImage_Unload(dst);		}		// Free src		FreeImage_Unload(src);	}	// call this ONLY when linking with FreeImage as a static library#ifdef FREEIMAGE_LIB	FreeImage_DeInitialise();#endif // FREEIMAGE_LIB	return 0;}

//----------------------------------------------------------// static variable for freeImage initialization:void ofInitFreeImage(bool deinit=false){	// need a new bool to avoid c++ "deinitialization order fiasco":	// http://www.parashift.com/c++-faq-lite/ctors.html#faq-10.15	static bool	* bFreeImageInited = new bool(false);	if(!bFreeImageInited && !deinit){		FreeImage_Initialise();		*bFreeImageInited = true;	}	if(bFreeImageInited && deinit){		FreeImage_DeInitialise();	}}

	//---------------------------------------------------------------------	void FreeImageCodec::shutdown(void)	{		FreeImage_DeInitialise();		for (RegisteredCodecList::iterator i = msCodecList.begin();			i != msCodecList.end(); ++i)		{			Codec::unRegisterCodec(*i);			OGRE_DELETE *i;		}		msCodecList.clear();	}

/** * destructor */fipImage::~fipImage(){		if ( pImageData ){		FreeImage_Unload( pImageData );	}		ulImageInstances--;	if ( ( ulImageInstances == 0 ) && bFreeImageInitialised ){		FreeImage_DeInitialise();		bFreeImageInitialised = false;	}	}

int main(int argc, char *argv[]) {	unsigned width  = 512;	unsigned height = 512;#if defined(_DEBUG) && defined(WIN32)	// check for memory leaks at program exit (after the 'return 0')	// through a call to _CrtDumpMemoryLeaks 	// note that in debug mode, objects allocated with the new operator 	// may be destroyed *after* the end of the main function. 	_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF|_CRTDBG_ALLOC_MEM_DF);#endif#if defined(FREEIMAGE_LIB) || !defined(WIN32)	FreeImage_Initialise();#endif	// initialize our own FreeImage error handler	FreeImage_SetOutputMessage(FreeImageErrorHandler);	// test plugins capabilities	showPlugins();	// test the clone function	testAllocateCloneUnload("exif.jpg");	// test internal image types	testImageType(width, height);	// test loading / saving / converting image types using the TIFF plugin	testImageTypeTIFF(width, height);	// test multipage creation	testBuildMPage("sample.png", "sample.ico", FIF_ICO, 24);	testBuildMPage("sample.png", "sample.tif", FIF_TIFF, 24);	//testBuildMPage("sample.png", "sample.gif", FIF_GIF, 8);	// test multipage cache	testMPageCache("sample.png");	// test memory IO	testMemIO("sample.png");	// test JPEG lossless transform & cropping	testJPEG();	#if defined(FREEIMAGE_LIB) || !defined(WIN32)	FreeImage_DeInitialise();#endif	return 0;}

App::~App(){	m_pluginManager.UnloadAll();	m_commandLineParser.DisposeCommands();	for (IdeType* type : m_ides)	{		delete type;	}	m_ides.clear();		FreeImage_DeInitialise();}

Client::~Client(){    enet_host_destroy(m_client);    delete m_mainPlayer;    // call this ONLY when linking with FreeImage as a static library#ifdef FREEIMAGE_LIB    FreeImage_DeInitialise();#endif    SDL_DestroyWindow(m_window);    SDL_Quit();}

BOOL CBigle3DApp::InitInstance(){    AfxEnableControlContainer();    // Standard initialization    // If you are not using these features and wish to reduce the size    //  of your final executable, you should remove from the following    //  the specific initialization routines you do not need.    // call this ONLY when linking with FreeImage as a static library    //FreeImage_Initialise();    // initialize your own FreeImage error handler    FreeImage_SetOutputMessage(MyMessageFunc);    CStartPP pp1;    CFondPP pp2;    CReliefPP pp3;    CCreateImgPP pp4;    CAboutPP pp5;    pp1.m_psp.dwFlags -= PSP_HASHELP;    pp2.m_psp.dwFlags -= PSP_HASHELP;    pp3.m_psp.dwFlags -= PSP_HASHELP;    pp4.m_psp.dwFlags -= PSP_HASHELP;    pp5.m_psp.dwFlags -= PSP_HASHELP;    m_ps.AddPage( &pp1 );    m_ps.AddPage( &pp2 );    m_ps.AddPage( &pp3 );    m_ps.AddPage( &pp4 );    m_ps.AddPage( &pp5 );    m_ps.SetWizardMode();    m_pMainWnd = &m_ps;    int nResponse = (int)m_ps.DoModal();    if (nResponse == IDOK)    {        // TODO: Place code here to handle when the dialog is        //  dismissed with OK    }    else if (nResponse == IDCANCEL)    {        // TODO: Place code here to handle when the dialog is        //  dismissed with Cancel    }    FreeImage_DeInitialise();    // Since the dialog has been closed, return FALSE so that we exit the    //  application, rather than start the application's message pump.    return FALSE;}

int main() {#if defined(FREEIMAGE_LIB) || !defined(WIN32)	FreeImage_Initialise();#endif	fipImage img;	img.load("img.png");	std::cout << img.getWidth() << "x" << img.getHeight() << std::endl;#if defined(FREEIMAGE_LIB) || !defined(WIN32)	FreeImage_DeInitialise();#endif	return 0;}

void ThinLens::render_scene(World& w) {	RGBColor L;	Ray ray;	ViewPlane vp(w.vp);	FreeImage_Initialise();	FIBITMAP* bitmap = FreeImage_Allocate(vp.hres, vp.vres, 24);	RGBQUAD color;	int depth = 0;	Point2D sp;	Point2D pp;	Point2D dp;	Point2D lp;	vp.s /= zoom;	for(int r = 0; r < vp.vres; r++)		for(int c = 0 ; c < vp.hres; c++) {			L = black;			for(int n = 0; n < vp.num_samples; n++) {				sp = vp.sampler_ptr -> sample_unit_square();				pp.x = vp.s * (c - vp.hres / 2.0 + sp.x);				pp.y = vp.s * (r - vp.vres / 2.0 + sp.y);				dp = sampler_ptr -> sample_unit_disk();				lp = dp * lens_radius;				ray.o = eye + lp.x * u + lp.y * v;				ray.d = ray_direction(pp, lp);				L += w.tracer_ptr -> trace_ray(ray);			}			L /= vp.num_samples;			L *= exposure_time;			w.display_pixel(r, c, L);			color.rgbRed = (int)(L.r*255);			color.rgbGreen = (int)(L.g*255);			color.rgbBlue = (int)(L.b*255);			FreeImage_SetPixelColor(bitmap, c, r, &color);		}	if (FreeImage_Save(FIF_PNG, bitmap, "test.png", 0))		std::cout << "Image Successfully Saved!" << std::endl;	FreeImage_DeInitialise();}

void Scene::saveImage(int t){    FreeImage_Initialise();    BYTE* pixels = new BYTE[ 3 * WIDTH * HEIGHT];    glReadPixels(0, 0, WIDTH, HEIGHT, GL_BGR, GL_UNSIGNED_BYTE, pixels);    FIBITMAP* image = FreeImage_ConvertFromRawBits(pixels, WIDTH, HEIGHT, 3 * WIDTH, 24, 0x0000FF, 0xFF0000, 0x00FF00, false);    // get a string to concat with an int    stringstream nameStream;    nameStream << "test" << t << ".png";    string name = nameStream.str();    char *a = new char[name.size() + 1];    a[name.size()] = 0;    memcpy(a, name.c_str(), name.size());    if(FreeImage_Save(FIF_BMP, image, a, 0))        cout << "Image " << t << " successfully saved! " << endl ;    FreeImage_DeInitialise(); //Cleanup !}

BOOL APIENTRYDllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) {	switch (ul_reason_for_call) {		case DLL_PROCESS_ATTACH :			FreeImage_Initialise(FALSE);			break;		case DLL_PROCESS_DETACH :			FreeImage_DeInitialise();			break;		case DLL_THREAD_ATTACH :		case DLL_THREAD_DETACH :			break;    }    return TRUE;}

void Film::WriteImage(std::string fname){	/*Before you use FreeImage, call FreeImage_Initialise(). 	To record the colors for each pixel, use an array of one byte elements. 	Then convert this array to a FIBITMAP object as follows, assuming the bytes are in RGB order:*/	FreeImage_Initialise();	int pix = width * height;	BYTE *pixels = new BYTE[3 * pix];	memcpy((void *)pixels, (void *)colorbuffer, width * height * 3);	FIBITMAP *img = FreeImage_ConvertFromRawBits(pixels, width, height, width * 3, 24, 0xFF0000, 0x00FF00, 0x0000FF, false);	std::cout << "Saving screenshot: " << fname << "/n";	FreeImage_Save(FIF_PNG, img, fname.c_str(), 0);		delete pixels;	FreeImage_DeInitialise();}

void Fisheye::render_scene(World& w) {	RGBColor L;	ViewPlane vp(w.vp);	FreeImage_Initialise();	FIBITMAP* bitmap = FreeImage_Allocate(vp.hres, vp.vres, 24);	RGBQUAD color;	int hres = vp.hres;	int vres = vp.vres;	float s = vp.s;	Ray ray;	int depth = 0;	Point2D sp;	Point2D pp;	float r_squared;	ray.o  = eye;	for(int r = 0; r < vres; r++)		for(int c = 0; c < hres; c++) {			L = black;			for(int j = 0; j < vp.num_samples; j++) {				sp = vp.sampler_ptr -> sample_unit_square();				pp.x = s * (c - hres / 2.0 + sp.x);				pp.y = s * (r - vres / 2.0 + sp.y);				ray.d = ray_direction(pp, hres, vres, s, r_squared);				if(r_squared <= 1.0)					L += w.tracer_ptr -> trace_ray(ray);			}			L /= vp.num_samples;			L *= exposure_time;			w.display_pixel(r, c, L);			color.rgbRed = (int)(L.r*255);			color.rgbGreen = (int)(L.g*255);			color.rgbBlue = (int)(L.b*255);			FreeImage_SetPixelColor(bitmap, c, r, &color);		}	if (FreeImage_Save(FIF_PNG, bitmap, "test.png", 0))		std::cout << "Image Successfully Saved!" << std::endl;	FreeImage_DeInitialise();}

int main(int argc, const char **argv) {	if (argc == 5) {		doingTransfer = true;	}	else {		doingTransfer = false;	}	if (argc != 3 && argc != 5) {		std::cerr << "usage: " << argv[0] << " <src> <dst> <src-crsp> <dst-crsp> " << std::endl;		return 2;	}	blockHeight = 64;	blockWidth = 64;	numIterations = 1;	vertOverlapAmount = 10;	horizOverlapAmount = 10;	FreeImage_Initialise(true);	const int rows = 8;	const int cols = 8;	Image * const src = new Image();	src->load(argv[1]);	Image * const dst = allocate(rows, cols);	srand(time(NULL));	Image * const src_crsp = doingTransfer ? new Image() : NULL;	Image * const dst_crsp = doingTransfer ? new Image() : NULL;	if (doingTransfer) {		src_crsp->load(argv[3]);		dst_crsp->load(argv[4]);	}	quilt(dst, dst_crsp, rows, cols, src, src_crsp);	dst->save(argv[2]);	delete dst;	delete src;	delete dst_crsp;	delete src_crsp;	FreeImage_DeInitialise();}

void Globals::CleanUp(){	SAFE_RELEASE(gEntityFactory);	SAFE_RELEASE(timer);	SAFE_RELEASE(gWorld);	SAFE_RELEASE(gKeyControl);	SAFE_DELETE(gFpsCamera);	SAFE_DELETE(gFollowCamera);	SAFE_DELETE(gRTSCamera);	gCurrentCamera = 0;	gAIControl = 0;	if (gDeleteAIPtr)		gDeleteAIPtr();	if (m_dll)		FreeModule(m_dll);	SAFE_DELETE(gFxEffectManager);	SAFE_DELETE(gRender);	SAFE_DELETE(gUI);	FreeImage_DeInitialise();}

int main(int argc, char *argv[]){	if (argc != 3)	{		printf("Usage : cworld2img input_filename.bin output_filename.png/n/n");		return 0;	}	FreeImage_Initialise();	FIBITMAP *bitmap = FreeImage_Allocate(WORLD_WIDTH, WORLD_HEIGHT, 32);	if(!bitmap)	{		printf("Error while allocating image. Aborting");		return -1;	}	FILE *fd = fopen(argv[1], "rb");	fread(c_world.solids, sizeof(block), WORLD_HEIGHT * WORLD_WIDTH, fd);	fclose(fd);	for(int i = 0; i < WORLD_HEIGHT; i++)	{		for(int j = 0; j < WORLD_WIDTH; j++)		{			switch(c_world.solids[WORLD_WIDTH * i + j])			{			case BLCK_AIR:				FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_air);break;			case BLCK_DIRT:				FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_dirt);break;			default:				FreeImage_SetPixelColor(bitmap, j, WORLD_HEIGHT - i, &qpixel_unknown);break;			}		}	}	if(!FreeImage_Save(FIF_PNG, bitmap, argv[2], 0))	{		printf("Error while saving image. Aborting");		return -1;	}	FreeImage_DeInitialise();	return 0;}

//----------------------------------------------------------------------------------------------------------------------////----------------------------------------------------------------------------------------------------------------------void azImage::Initialize(){	azSz szFilePath = azL("F://Dev//Aztec//Bin//Debug//Test.png");	FreeImage_Initialise();	fipImage oFreeImage;#ifdef UNICODE	azBool bLoaded = (0 != oFreeImage.loadU(szFilePath));#else // UNICODE    azBool bLoaded = (0 != oFreeImage.load(szFilePath));#endif // UNICODE	azAssert(bLoaded, "Image extension or format not supported");	azAssert(oFreeImage.getBitsPerPixel() <= 32, "More than 32 BPP images not yet supported, there will be some data loss");	// Always convert to RGBA 32 bits	azBool bConverted = (0 != oFreeImage.convertTo32Bits());	azAssert(bConverted, "Image recognized but we failed to convert it to 32 BPP");	m_uWidth = oFreeImage.getWidth();	m_uHeight = oFreeImage.getHeight();	m_uBpp = oFreeImage.getBitsPerPixel();	azAssert(m_uBpp == 32, "Convert didn't work properly");	azUInt uBufferSize = GetBufferSize();	m_abData = azNewArray(azByte, uBufferSize);	// There is no C++ wrapping for this method.    FreeImage_ConvertToRawBits(m_abData,		oFreeImage,		oFreeImage.getScanWidth(),		m_uBpp,		FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK,		true);  		oFreeImage.clear();	FreeImage_DeInitialise();}

  unsigned char* Texture::loadTexture( const char* fileName_,                                       unsigned int &width_,                                       unsigned int &height_ )  {    FreeImage_Initialise(TRUE);    FREE_IMAGE_FORMAT format = FreeImage_GetFileType(fileName_, 0);    if (format == FIF_UNKNOWN)      format = FreeImage_GetFIFFromFilename(fileName_);    if ((format == FIF_UNKNOWN) || !FreeImage_FIFSupportsReading(format))      return NULL;    FIBITMAP* img = FreeImage_Load(format, fileName_);    if (img == NULL)      return NULL;    FIBITMAP* tempImg = img;    img = FreeImage_ConvertTo32Bits(img);    FreeImage_Unload(tempImg);    width_ = FreeImage_GetWidth(img);    height_ = FreeImage_GetHeight(img);    //BGRA a RGBA    unsigned char * map = new unsigned char[4 * width_*height_];    char *buff = (char*)FreeImage_GetBits(img);    for (unsigned int j = 0; j<width_*height_; j++){      map[j * 4 + 0] = buff[j * 4 + 2];      map[j * 4 + 1] = buff[j * 4 + 1];      map[j * 4 + 2] = buff[j * 4 + 0];      map[j * 4 + 3] = buff[j * 4 + 3];    }    FreeImage_Unload(img);    FreeImage_DeInitialise();    return map;  }

Image::Image(const char *image_path, GLuint textureUnit, bool& success) {	success = true;	FreeImage_Initialise();	texture_unit = textureUnit;	// Load Texture	FREE_IMAGE_FORMAT image_format = FreeImage_GetFileType(image_path,0);	FIBITMAP* image_bgr = FreeImage_Load(image_format, image_path);	if (!image_bgr) {		fprintf(stdout, "Failed to load image %s", image_path);		success = false;	}	FIBITMAP* temp = image_bgr;	image_bgr = FreeImage_ConvertTo32Bits(image_bgr);	FreeImage_Unload(temp);	im_width = FreeImage_GetWidth(image_bgr);	im_height = FreeImage_GetHeight(image_bgr);	GLubyte* image_texture = new GLubyte[4*im_width*im_height];	char* image_pixeles = (char*)FreeImage_GetBits(image_bgr);	//FreeImage loads in BGR format, so you need to swap some bytes(Or use GL_BGR).	for(int j= 0; j<im_width*im_height; j++){		image_texture[j*4+0]= image_pixeles[j*4+2];		image_texture[j*4+1]= image_pixeles[j*4+1];		image_texture[j*4+2]= image_pixeles[j*4+0];		image_texture[j*4+3]= image_pixeles[j*4+3];	}	FreeImage_DeInitialise();	// Create one OpenGL texture	glGenTextures(1, &texture_handle);	glActiveTexture(GL_TEXTURE0 + textureUnit);	glBindTexture(GL_TEXTURE_2D, texture_handle);	glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA, im_width, im_height, 0, GL_RGBA,GL_UNSIGNED_BYTE,(GLvoid*)image_texture );	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); 	glGenerateMipmap(GL_TEXTURE_2D);	glBindTexture(GL_TEXTURE_2D,0);}

GLuint scene::Loadtexture(const char* pFilename) {    FreeImage_Initialise();    GLuint texObject = 0;    glGenTextures(1, &texObject);    int error = glGetError();    FIBITMAP* pImage = FreeImage_Load(FreeImage_GetFileType(pFilename, 0), pFilename);    FIBITMAP *p32BitsImage = FreeImage_ConvertTo32Bits(pImage);    int iWidth = FreeImage_GetWidth(p32BitsImage);    int iHeight = FreeImage_GetHeight(p32BitsImage);    glBindTexture(GL_TEXTURE_2D, texObject);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, iWidth, iHeight,                 0, GL_BGRA, GL_UNSIGNED_BYTE, (void*)FreeImage_GetBits(p32BitsImage));    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);    FreeImage_Unload(p32BitsImage);    FreeImage_Unload(pImage);    glBindTexture(GL_TEXTURE_CUBE_MAP, 0);    return texObject;    FreeImage_DeInitialise();}

int main(int argc,char* argv[]) {	//Initialize GLUT	FreeImage_Initialise();	glutInit(&argc,argv);	glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);	glutCreateWindow("HW1: Transformations");	GLenum err = glewInit() ; 	if (GLEW_OK != err) { 		std::cerr << "Error: " << glewGetString(err) << std::endl; 	} 	init();	glutDisplayFunc(display);	glutSpecialFunc(specialKey);	glutKeyboardFunc(keyboard);	glutReshapeFunc(reshape);	glutReshapeWindow(w,h);	if(argc > 1) {		allowGrader = true;		grader.init(argv[1]);		grader.loadCommands(argv[1]);		grader.bindDisplayFunc(display);		grader.bindSpecialFunc(specialKey);		grader.bindKeyboardFunc(keyboard);		grader.bindScreenshotFunc(saveScreenshot);	}	printHelp();	glutMainLoop();		FreeImage_DeInitialise();	return 0;}

void pre_lzw_mp::do_lzw(QString n){    QString job = n;    QString images_src = src + "//" +n;    QString write_dst = dst + "//" + n;    QString image_name, saved_name;    int dot_pos;    QString image_path;    QDir images_dir(images_src);    QDir write_dir(dst);    write_dir.mkdir(job);    qDebug()<<images_src;    qDebug()<<write_dst;    QFileInfoList images_info_list = images_dir.entryInfoList();    QList<QFileInfo>::iterator image_iter = images_info_list.begin();    FreeImage_Initialise(true);    for(; image_iter < images_info_list.end(); ++image_iter){        if((*image_iter).isDir()){//            qDebug()<<(*image_iter).fileName();            continue;        }        image_name = (*image_iter).fileName();        dot_pos = image_name.indexOf(".");        saved_name = write_dst + "//" + image_name.left(dot_pos) + "_c.tif";        image_path = (*image_iter).absoluteFilePath();        FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(image_path.toStdString().c_str(), 0);        if(fif == FIF_UNKNOWN){            fif = FreeImage_GetFIFFromFilename(image_path.toStdString().c_str());        }        if((fif != FIF_UNKNOWN) && FreeImage_FIFSupportsReading(fif)){            FIBITMAP *image = FreeImage_Load(fif, image_path.toStdString().c_str());            FreeImage_Save(FIF_TIFF, image, saved_name.toStdString().c_str(), TIFF_LZW);            FreeImage_Unload(image);        }            }    FreeImage_DeInitialise();}

 void Texture::shutdownTextureSystem() {   freeimage_init_lock_.lock();   FreeImage_DeInitialise();   freeimage_init_ = false;   freeimage_init_lock_.unlock(); }

void releaseFreeImage() {  FreeImage_DeInitialise();}

FreeImage::~FreeImage() {  FreeImage_DeInitialise();}

int main(int argc, char *argv[]) {	const char *input_dir = "d://images//";	FIBITMAP *dib = NULL;	int id = 1;	// 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");	// open the log file	FILE *log_file = fopen("log_file.txt", "w");	// batch convert all supported bitmaps	_finddata_t finddata;	long handle;	char image_path[MAX_PATH];	// scan all files	strcpy(image_path, input_dir);	strcat(image_path, "*.*");	if ((handle = _findfirst(image_path, &finddata)) != -1) {		do {			// make a path to a directory			char *directory = new char[MAX_PATH];			strcpy(directory, input_dir);			strcat(directory, finddata.name);			// make a unique filename			char *unique = new char[128];			itoa(id, unique, 10);			strcat(unique, ".png");			// open and load the file using the default load option			dib = GenericLoader(directory, 0);			if (dib != NULL) {				// save the file as PNG				bool bSuccess = GenericWriter(dib, unique, PNG_DEFAULT);				// free the dib				FreeImage_Unload(dib);				if(bSuccess) {					fwrite(unique, strlen(unique), 1, log_file);				} else {					strcpy(unique, "FAILED");					fwrite(unique, strlen(unique), 1, log_file);				}				fwrite(" >> ", 4, 1, log_file);				fwrite(directory, strlen(directory), 1, log_file);				fwrite("/n", 1, 1, log_file);				id++;			}			delete [] unique;			delete [] directory;		} while (_findnext(handle, &finddata) == 0);		_findclose(handle);	}	fclose(log_file);	// call this ONLY when linking with FreeImage as a static library#ifdef FREEIMAGE_LIB	FreeImage_DeInitialise();#endif // FREEIMAGE_LIB	return 0;}