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

/** * Freeimage format to Indielib format. * @param pHandle		the FIBITMAP that is used for calculation */int FreeImageHelper::calculateINDFormat(FIBITMAP* pHandle) {	FREE_IMAGE_TYPE imgType = FreeImage_GetImageType(pHandle);	//Bitmap type (most common)	if (FIT_BITMAP == imgType) {		//Depending on the freeimage color type analysis, we determine our IND_ColorFormat		FREE_IMAGE_COLOR_TYPE colorType = FreeImage_GetColorType(pHandle);							if (FIC_MINISBLACK == colorType || FIC_MINISWHITE == colorType) {			return IND_LUMINANCE;		} else if (FIC_PALETTE == colorType) {			return IND_COLOUR_INDEX;		} else if (FIC_RGB == colorType) {			//HACK: This is because when converting to 32 bits, even though there is alpha channel,			//the color analysis function returns FIC_RGB, as alpha is opaque. We rely on that to know			//if we have alpha channel so it's not good.			if (FreeImage_GetBPP(pHandle) == 32) {				return IND_RGBA;			} else {				return IND_RGB;			}		} else if (FIC_RGBALPHA == colorType) {			return IND_RGBA;		}	}	//TODO: OTHER IMAGE TYPES	//Failure	return IND_UNKNOWN;}

voidFreeImageStack::loadImage(unsigned int iSlice, npp::ImageNPP_8u_C1 & rImage)const{    NPP_ASSERT_MSG(iSlice < slices(), "Slice index exceeded number of slices in stack.");    FIBITMAP * pBitmap = FreeImage_LockPage(pImageStack_, iSlice);    NPP_ASSERT_NOT_NULL(pBitmap);            // make sure this is an 8-bit single channel image    NPP_DEBUG_ASSERT(FreeImage_GetColorType(pBitmap) == FIC_MINISBLACK);    NPP_DEBUG_ASSERT(FreeImage_GetBPP(pBitmap) == 8);        NPP_DEBUG_ASSERT(FreeImage_GetWidth(pBitmap) == nWidth_);    NPP_DEBUG_ASSERT(FreeImage_GetHeight(pBitmap) == nHeight_);    unsigned int    nSrcPitch = FreeImage_GetPitch(pBitmap);    unsigned char * pSrcData  = FreeImage_GetBits(pBitmap);        if (rImage.width() == nWidth_ && rImage.height() == nHeight_)    {        NPP_CHECK_CUDA(cudaMemcpy2D(rImage.data(), rImage.pitch(), pSrcData, nSrcPitch,                                     nWidth_, nHeight_, cudaMemcpyHostToDevice));    }    else    {                // create new NPP image        npp::ImageNPP_8u_C1 oImage(nWidth_, nHeight_);                // transfer slice data into new device image        NPP_CHECK_CUDA(cudaMemcpy2D(oImage.data(), oImage.pitch(), pSrcData, nSrcPitch,                                     nWidth_, nHeight_, cudaMemcpyHostToDevice));                // swap the result image with the reference passed into this method        rImage.swap(oImage);    }                // release locked slice    FreeImage_UnlockPage(pImageStack_, pBitmap, FALSE);}

FreeImageStack::FreeImageStack(const std::string & rFileName): sFileName_(rFileName)                                                             , pImageStack_(0)                                                             , nWidth_(0)                                                             , nHeight_(0)                                                             , pBitmap_32f_(0)                                                             , nMaxXY_(0)                                                             , nMaxOffset_(0){            // open the bitmap    pImageStack_ = FreeImage_OpenMultiBitmap(FIF_TIFF, (sFileName_ + ".tif").c_str(),                                              FALSE, // create new                                             TRUE,  // open read-only                                             FALSE, // keep all slices in memory                                             TIFF_DEFAULT);    NPP_ASSERT_NOT_NULL(pImageStack_);    NPP_ASSERT_NOT_NULL(slices());    FIBITMAP * pBitmap = FreeImage_LockPage(pImageStack_, 0);            // store away the size of the first image            // this information is later used to insure that all slices            // accessed are of the same size. if they are not an exception            // is thrown when such a deviating slice is being accessed    nWidth_  = FreeImage_GetWidth(pBitmap);    nHeight_ = FreeImage_GetHeight(pBitmap);    NPP_ASSERT(FreeImage_GetColorType(pBitmap) == FIC_MINISBLACK);    NPP_ASSERT(FreeImage_GetBPP(pBitmap) == 8);    FreeImage_UnlockPage(pImageStack_, pBitmap, FALSE);}

/** @brief Inverts each pixel data.@param src Input image to be processed.@return Returns TRUE if successful, FALSE otherwise.*/BOOL DLL_CALLCONV FreeImage_Invert(FIBITMAP *src) {	unsigned i, x, y, k;	BYTE *bits;	if (!src) return FALSE;	int bpp = FreeImage_GetBPP(src);		switch(bpp) {        case 1 :		case 4 :		case 8 :		{			// if the dib has a colormap, just invert it			// else, keep the linear grayscale			if (FreeImage_GetColorType(src) == FIC_PALETTE) {				RGBQUAD *pal = FreeImage_GetPalette(src);				for(i = 0; i < FreeImage_GetColorsUsed(src); i++) {					pal[i].rgbRed	= 255 - pal[i].rgbRed;					pal[i].rgbGreen = 255 - pal[i].rgbGreen;					pal[i].rgbBlue	= 255 - pal[i].rgbBlue;				}			} else {				for(y = 0; y < FreeImage_GetHeight(src); y++) {					bits = FreeImage_GetScanLine(src, y);					for (x = 0; x < FreeImage_GetLine(src); x++) {						bits[x] = ~bits[x];					}				}			}			break;		}				case 24 :		case 32 :		{			unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);			for(y = 0; y < FreeImage_GetHeight(src); y++) {				bits =  FreeImage_GetScanLine(src, y);				for(x = 0; x < FreeImage_GetWidth(src); x++) {					for(k = 0; k < bytespp; k++) {						bits[k] = ~bits[k];					}					bits += bytespp;				}			}			break;		}	}	return TRUE;}

void putBmpIntoPixels(FIBITMAP * bmp, ofPixels_<PixelType> &pix, bool swapForLittleEndian = true) {	// convert to correct type depending on type of input bmp and PixelType	FIBITMAP* bmpConverted = NULL;	FREE_IMAGE_TYPE imgType = FreeImage_GetImageType(bmp);	if(sizeof(PixelType)==1 &&		(FreeImage_GetColorType(bmp) == FIC_PALETTE || FreeImage_GetBPP(bmp) < 8		||  imgType!=FIT_BITMAP)) {		if(FreeImage_IsTransparent(bmp)) {			bmpConverted = FreeImage_ConvertTo32Bits(bmp);		} else {			bmpConverted = FreeImage_ConvertTo24Bits(bmp);		}		bmp = bmpConverted;	}else if(sizeof(PixelType)==2 && imgType!=FIT_UINT16 && imgType!=FIT_RGB16 && imgType!=FIT_RGBA16){		if(FreeImage_IsTransparent(bmp)) {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBA16);		} else {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGB16);		}		bmp = bmpConverted;	}else if(sizeof(PixelType)==4 && imgType!=FIT_FLOAT && imgType!=FIT_RGBF && imgType!=FIT_RGBAF){		if(FreeImage_IsTransparent(bmp)) {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBAF);		} else {			bmpConverted = FreeImage_ConvertToType(bmp,FIT_RGBF);		}		bmp = bmpConverted;	}	unsigned int width = FreeImage_GetWidth(bmp);	unsigned int height = FreeImage_GetHeight(bmp);	unsigned int bpp = FreeImage_GetBPP(bmp);	unsigned int channels = (bpp / sizeof(PixelType)) / 8;	unsigned int pitch = FreeImage_GetPitch(bmp);	// ofPixels are top left, FIBITMAP is bottom left	FreeImage_FlipVertical(bmp);		unsigned char* bmpBits = FreeImage_GetBits(bmp);	if(bmpBits != NULL) {		pix.setFromAlignedPixels((PixelType*) bmpBits, width, height, channels, pitch);	} else {		ofLogError("ofImage") << "putBmpIntoPixels(): unable to set ofPixels from FIBITMAP";	}		if(bmpConverted != NULL) {		FreeImage_Unload(bmpConverted);	}#ifdef TARGET_LITTLE_ENDIAN	if(swapForLittleEndian && sizeof(PixelType) == 1) {		pix.swapRgb();	}#endif}

const Texture* Texture::load(const std::string& fileName){	if (sTextureMap.find(fileName) != sTextureMap.end()) {		unload(sTextureMap[fileName]);	}	const std::string path = sBasePath + fileName;	FREE_IMAGE_FORMAT fif = FreeImage_GetFileType(path.c_str(), 0);	if (fif == FIF_UNKNOWN) {		fif = FreeImage_GetFIFFromFilename(path.c_str());	}	if (fif == FIF_UNKNOWN) {		return nullptr;	}	FIBITMAP* dib = nullptr;	if (FreeImage_FIFSupportsReading(fif)) {		dib = FreeImage_Load(fif, path.c_str());	}	if (!dib) {		return nullptr;	}	BYTE* bits = FreeImage_GetBits(dib);	unsigned int width = FreeImage_GetWidth(dib);	unsigned int height = FreeImage_GetHeight(dib);	if (bits == 0 || width == 0 || height == 0) {		return nullptr;	}	FREE_IMAGE_COLOR_TYPE colorType = FreeImage_GetColorType(dib);	FREE_IMAGE_TYPE imageType = FreeImage_GetImageType(dib);	GLenum glFormat = getGLFormat(colorType);	Texture tex;	tex.mName = fileName;	glGenTextures(1, &tex.mId);	assert(tex.mId);	glBindTexture(GL_TEXTURE_2D, tex.mId);	glTexImage2D(GL_TEXTURE_2D, 0, glFormat, width, height, 0, glFormat, GL_UNSIGNED_BYTE, bits);	glGenerateMipmap(GL_TEXTURE_2D);	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);	sTextureMap[fileName] = tex;	FreeImage_Unload(dib);	return &sTextureMap[fileName];}

BOOL DLL_CALLCONVFreeImage_IsTransparent(FIBITMAP *dib) {	if(dib) {		if(FreeImage_GetBPP(dib) == 32) {			if(FreeImage_GetColorType(dib) == FIC_RGBALPHA) {				return TRUE;			}		} else {			return ((FREEIMAGEHEADER *)dib->data)->transparent ? TRUE : FALSE;		}	}	return FALSE;}

std::ostream &operator <<(std::ostream &rOutputStream, const FIBITMAP &rBitmap){    unsigned int nImageWidth    = FreeImage_GetWidth(const_cast<FIBITMAP *>(&rBitmap));    unsigned int nImageHeight   = FreeImage_GetHeight(const_cast<FIBITMAP *>(&rBitmap));    unsigned int nPitch         = FreeImage_GetPitch(const_cast<FIBITMAP *>(&rBitmap));    unsigned int nBPP           = FreeImage_GetBPP(const_cast<FIBITMAP *>(&rBitmap));    FREE_IMAGE_COLOR_TYPE eType = FreeImage_GetColorType(const_cast<FIBITMAP *>(&rBitmap));    BITMAPINFO *pInfo          = FreeImage_GetInfo(const_cast<FIBITMAP *>(&rBitmap));    rOutputStream << "Size  (" << FreeImage_GetWidth(const_cast<FIBITMAP *>(&rBitmap)) << ", "                  << FreeImage_GetHeight(const_cast<FIBITMAP *>(&rBitmap)) << ")/n";    rOutputStream << "Pitch "  << FreeImage_GetPitch(const_cast<FIBITMAP *>(&rBitmap)) << "/n";    rOutputStream << "Type  ";    switch (eType)    {        case FIC_MINISWHITE:            rOutputStream << "FIC_MINISWHITE/n";            break;        case FIC_MINISBLACK:            rOutputStream << "FIC_MINISBLACK/n";            break;        case FIC_RGB:            rOutputStream << "FIC_RGB/n";            break;        case FIC_PALETTE:            rOutputStream << "FIC_PALETTE/n";            break;        case FIC_RGBALPHA:            rOutputStream << "FIC_RGBALPHA/n";            break;        case FIC_CMYK:            rOutputStream << "FIC_CMYK/n";            break;        default:            rOutputStream << "Unknown pixel format./n";    }    rOutputStream << "BPP   " << nBPP << std::endl;    return rOutputStream;}

Types::ColorTypes ImageLoaderFreeImage::colorDataType() const{    Types::ColorTypes colorDatatype = Types::ColorTypeRGB;    const FREE_IMAGE_COLOR_TYPE imageColorType = FreeImage_GetColorType(m_bitmap);    if (imageColorType == FIC_MINISBLACK || imageColorType == FIC_MINISWHITE) {        colorDatatype = bitsPerPixel() == 1 ? Types::ColorTypeMonochrome : Types::ColorTypeGreyscale;    } else {        colorDatatype =            imageColorType == FIC_PALETTE ? Types::ColorTypePalette            : imageColorType == FIC_RGB ? Types::ColorTypeRGB            : imageColorType == FIC_RGBALPHA ? Types::ColorTypeRGBA            : /* imageColorType == FIC_CMYK ? */ Types::ColorTypeCMYK;    }    return colorDatatype;}

//----------------------------------------------------void putBmpIntoPixels(FIBITMAP * bmp, ofPixels &pix, bool swapForLittleEndian = true){	int width			= FreeImage_GetWidth(bmp);	int height			= FreeImage_GetHeight(bmp);	int bpp				= FreeImage_GetBPP(bmp);	FIBITMAP * bmpTemp = NULL;	switch (bpp){		case 8:			if (FreeImage_GetColorType(bmp) == FIC_PALETTE) {				bmpTemp = FreeImage_ConvertTo24Bits(bmp);				bmp = bmpTemp;				bpp = FreeImage_GetBPP(bmp);			} else {			// do nothing we are grayscale			}		break;		case 24:			// do nothing we are color		break;		case 32:			// do nothing we are colorAlpha		break;		default:			bmpTemp = FreeImage_ConvertTo24Bits(bmp);			bmp = bmpTemp;			bpp = FreeImage_GetBPP(bmp);		break;	}	int bytesPerPixel	= bpp / 8;	pix.allocate(width, height, bpp);	FreeImage_ConvertToRawBits(pix.getPixels(), bmp, width*bytesPerPixel, bpp, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK, true);  // get bits	if (bmpTemp != NULL) FreeImage_Unload(bmpTemp);	#ifdef TARGET_LITTLE_ENDIAN		if(swapForLittleEndian)			pix.swapRgb();	#endif}

/** @brief Determines, whether a palletized image is visually greyscale or not.  Unlike with FreeImage_GetColorType, which returns either FIC_MINISBLACK or FIC_MINISWHITE for a greyscale image with a linear ramp palette, the return   value of this function does not depend on the palette's order, but only on the palette's individual colors. @param dib The image to be tested. @return Returns TRUE if the palette of the image specified contains only greyscales, FALSE otherwise. */static BOOLIsVisualGreyscaleImage(FIBITMAP *dib) {	switch (FreeImage_GetBPP(dib)) {		case 1:		case 4:		case 8: {			unsigned ncolors = FreeImage_GetColorsUsed(dib);			RGBQUAD *rgb = FreeImage_GetPalette(dib);			for (unsigned i = 0; i< ncolors; i++) {				if ((rgb->rgbRed != rgb->rgbGreen) || (rgb->rgbRed != rgb->rgbBlue)) {					return FALSE;				}			}			return TRUE;		}		default: {			return (FreeImage_GetColorType(dib) == FIC_MINISBLACK);		}	}}

    /// Load a gray-scale image from disk.    void     loadImage(const std::string & rFileName, ImageCPU_8u_C1 & rImage)    {	            // set your own FreeImage error handler	    FreeImage_SetOutputMessage(FreeImageErrorHandler);        FREE_IMAGE_FORMAT eFormat = FreeImage_GetFileType(rFileName.c_str());                // no signature? try to guess the file format from the file extension        if (eFormat == FIF_UNKNOWN)            eFormat = FreeImage_GetFIFFromFilename(rFileName.c_str());        NPP_ASSERT(eFormat != FIF_UNKNOWN);                // check that the plugin has reading capabilities ...        FIBITMAP * pBitmap;        if (FreeImage_FIFSupportsReading(eFormat))             pBitmap = FreeImage_Load(eFormat, rFileName.c_str());        NPP_ASSERT(pBitmap != 0);                // make sure this is an 8-bit single channel image        NPP_ASSERT(FreeImage_GetColorType(pBitmap) == FIC_MINISBLACK);        NPP_ASSERT(FreeImage_GetBPP(pBitmap) == 8);                        // create an ImageCPU to receive the loaded image data        ImageCPU_8u_C1 oImage(FreeImage_GetWidth(pBitmap), FreeImage_GetHeight(pBitmap));                        // Copy the FreeImage data into the new ImageCPU        unsigned int nSrcPitch = FreeImage_GetPitch(pBitmap);        const Npp8u * pSrcLine = FreeImage_GetBits(pBitmap) + nSrcPitch * (FreeImage_GetHeight(pBitmap) -1);        Npp8u * pDstLine = oImage.data();        unsigned int nDstPitch = oImage.pitch();        for (size_t iLine = 0; iLine < oImage.height(); ++iLine)        {            memcpy(pDstLine, pSrcLine, oImage.width() * sizeof(Npp8u));            pSrcLine -= nSrcPitch;            pDstLine += nDstPitch;        }                        // swap the user given image with our result image, effecively                // moving our newly loaded image data into the user provided shell        oImage.swap(rImage);    }

void putBmpIntoPixels(FIBITMAP * bmp, ofPixels_<PixelType> &pix, bool swapForLittleEndian = true) {	// some images use a palette, or <8 bpp, so convert them to raster 8-bit channels	FIBITMAP* bmpConverted = NULL;	if(FreeImage_GetColorType(bmp) == FIC_PALETTE || FreeImage_GetBPP(bmp) < 8) {		if(FreeImage_IsTransparent(bmp)) {			bmpConverted = FreeImage_ConvertTo32Bits(bmp);		} else {			bmpConverted = FreeImage_ConvertTo24Bits(bmp);		}		bmp = bmpConverted;	}	unsigned int width = FreeImage_GetWidth(bmp);	unsigned int height = FreeImage_GetHeight(bmp);	unsigned int bpp = FreeImage_GetBPP(bmp);	unsigned int channels = (bpp / sizeof(PixelType)) / 8;	unsigned int pitch = FreeImage_GetPitch(bmp);	// ofPixels are top left, FIBITMAP is bottom left	FreeImage_FlipVertical(bmp);		unsigned char* bmpBits = FreeImage_GetBits(bmp);	if(bmpBits != NULL) {		pix.setFromAlignedPixels((PixelType*) bmpBits, width, height, channels, pitch);	} else {		ofLogError() << "ofImage::putBmpIntoPixels() unable to set ofPixels from FIBITMAP";	}		if(bmpConverted != NULL) {		FreeImage_Unload(bmpConverted);	}#ifdef TARGET_LITTLE_ENDIAN	if(swapForLittleEndian && sizeof(PixelType) == 1) {		pix.swapRgb();	}#endif}

BOOL DLL_CALLCONVFreeImage_IsTransparent(FIBITMAP *dib) {	if(dib) {		FREE_IMAGE_TYPE image_type = FreeImage_GetImageType(dib);		switch(image_type) {			case FIT_BITMAP:				if(FreeImage_GetBPP(dib) == 32) {					if(FreeImage_GetColorType(dib) == FIC_RGBALPHA) {						return TRUE;					}				} else {					return ((FREEIMAGEHEADER *)dib->data)->transparent ? TRUE : FALSE;				}				break;			case FIT_RGBA16:			case FIT_RGBAF:				return TRUE;			default:				break;		}	}	return FALSE;}

FREE_IMAGE_COLOR_TYPE fipImage::getColorType() const { 	return FreeImage_GetColorType(_dib);}

	virtual bool load(const std::string& filename, Array &lat) {		FREE_IMAGE_FORMAT type = FreeImage_GetFIFFromFilename(filename.c_str());		if(type == FIF_UNKNOWN) {			AL_WARN("image format not recognized: %s", filename.c_str());			return false;		}		if(!FreeImage_FIFSupportsReading(type)) {			AL_WARN("image format not supported: %s", filename.c_str());			return false;		}				destroy();		mImage = FreeImage_Load(type, filename.c_str(), 0);		if (mImage == NULL) {			AL_WARN("image failed to load: %s", filename.c_str());			return false;		}				FREE_IMAGE_COLOR_TYPE colorType = FreeImage_GetColorType(mImage);		switch(colorType) {			case FIC_MINISBLACK:			case FIC_MINISWHITE: {					FIBITMAP *res = FreeImage_ConvertToGreyscale(mImage);					FreeImage_Unload(mImage);					mImage = res;				}				break;			case FIC_PALETTE: {					if(FreeImage_IsTransparent(mImage)) {						FIBITMAP *res = FreeImage_ConvertTo32Bits(mImage);						FreeImage_Unload(mImage);						mImage = res;					}					else {						FIBITMAP *res = FreeImage_ConvertTo24Bits(mImage);						FreeImage_Unload(mImage);						mImage = res;					}				}				break;			case FIC_CMYK: {					AL_WARN("CMYK images currently not supported");					return false;				}				break;			default:				break;		}		// flip vertical for OpenGL:		//FreeImage_FlipVertical(mImage);				//Freeimage is not tightly packed, so we use		//a custom method instead of one of the Matrix		//utility methods		int planes = getPlanes();		AlloTy ty = getDataType();		int w, h;		getDim(w, h);		lat.format(planes, ty, w, h);				Image::Format format = Image::getFormat(planes);		switch(format) {			case Image::LUMINANCE: {				char *o_pix = (char *)(lat.data.ptr);				int rowstride = lat.header.stride[1];				for(unsigned j = 0; j < lat.header.dim[1]; ++j) {					char *pix = (char *)FreeImage_GetScanLine(mImage, j);					memcpy(o_pix, pix, rowstride);					o_pix += rowstride;				}			}			break;						case Image::RGB: {				switch(lat.header.type) {					case AlloUInt8Ty: {						char *bp = (char *)(lat.data.ptr);						int rowstride = lat.header.stride[1];						for(unsigned j = 0; j < lat.header.dim[1]; ++j) {							RGBTRIPLE * pix = (RGBTRIPLE *)FreeImage_GetScanLine(mImage, j);							Image::RGBPix<uint8_t> *o_pix = (Image::RGBPix<uint8_t> *)(bp + j*rowstride);							for(unsigned i=0; i < lat.header.dim[0]; ++i) {								o_pix->r = pix->rgbtRed;								o_pix->g = pix->rgbtGreen;								o_pix->b = pix->rgbtBlue;								++pix;								++o_pix;							}						}					}					break;					case AlloFloat32Ty: {						char *o_pix = (char *)(lat.data.ptr);						int rowstride = lat.header.stride[1];//.........这里部分代码省略.........

//.........这里部分代码省略.........				for (int count = 0; count < used_colors; count++) {					FILE_BGR bgr;					io->read_proc(&bgr, sizeof(FILE_BGR), 1, handle);										pal[count].rgbRed = bgr.r;					pal[count].rgbGreen = bgr.g;					pal[count].rgbBlue = bgr.b;				}				// Skip over the optional palette 				// A 24 or 32 bit DIB may contain a palette for faster color reduction				io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);								// read the pixel data				if (height > 0) {					io->read_proc((void *)FreeImage_GetBits(dib), height * pitch, 1, handle);				} else {					for (int c = 0; c < abs(height); ++c) {						io->read_proc((void *)FreeImage_GetScanLine(dib, height - c - 1), pitch, 1, handle);													}				}										return dib;			}			case 16 :			{				dib = FreeImage_Allocate(width, height, bit_count, FI16_555_RED_MASK, FI16_555_GREEN_MASK, FI16_555_BLUE_MASK);				if (dib == NULL)					throw "DIB allocation failed";										BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);				pInfoHeader->biXPelsPerMeter = 0;				pInfoHeader->biYPelsPerMeter = 0;				io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);#ifdef FREEIMAGE_BIGENDIAN				for(int y = 0; y < FreeImage_GetHeight(dib); y++) {					WORD *pixel = (WORD *)FreeImage_GetScanLine(dib, y);					for(int x = 0; x < FreeImage_GetWidth(dib); x++) {						SwapShort(pixel);						pixel++;					}				}#endif				return dib;			}			case 24 :			case 32 :			{				if( bit_count == 32 ) {					dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);				} else {					dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);				}				if (dib == NULL)					throw "DIB allocation failed";										BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);				pInfoHeader->biXPelsPerMeter = 0;				pInfoHeader->biYPelsPerMeter = 0;				// Skip over the optional palette 				// A 24 or 32 bit DIB may contain a palette for faster color reduction				io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);#ifdef FREEIMAGE_BIGENDIAN				for(int y = 0; y < FreeImage_GetHeight(dib); y++) {					BYTE *pixel = FreeImage_GetScanLine(dib, y);					for(int x = 0; x < FreeImage_GetWidth(dib); x++) {						INPLACESWAP(pixel[0], pixel[2]);						pixel += (bit_count>>3);					}				}#endif				// check if the bitmap contains transparency, if so enable it in the header				FreeImage_SetTransparent(dib, (FreeImage_GetColorType(dib) == FIC_RGBALPHA));				return dib;			}		}	} catch(const char *message) {			if(dib)			FreeImage_Unload(dib);		FreeImage_OutputMessageProc(s_format_id, message);	}	return NULL;}

//.........这里部分代码省略.........									break;							};						}						break;					}					default :								throw "compression type not supported";				}										break;			}			case 16 :			{				if (bih.biCompression == 3) {					DWORD bitfields[3];					io->read_proc(bitfields, 3 * sizeof(DWORD), 1, handle);					dib = FreeImage_Allocate(width, height, bit_count, bitfields[0], bitfields[1], bitfields[2]);				} else {					dib = FreeImage_Allocate(width, height, bit_count, FI16_555_RED_MASK, FI16_555_GREEN_MASK, FI16_555_BLUE_MASK);				}				if (dib == NULL)					throw "DIB allocation failed";										BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);				pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;				pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;				if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))					io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);				io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);#ifdef FREEIMAGE_BIGENDIAN				for(int y = 0; y < FreeImage_GetHeight(dib); y++) {					WORD *pixel = (WORD *)FreeImage_GetScanLine(dib, y);					for(int x = 0; x < FreeImage_GetWidth(dib); x++) {						SwapShort(pixel);						pixel++;					}				}#endif				return dib;			}			case 24 :			case 32 :			{				if( bit_count == 32 ) {					dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);				} else {					dib = FreeImage_Allocate(width, height, bit_count, FI_RGBA_RED_MASK, FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);				}				if (dib == NULL)					throw "DIB allocation failed";								BITMAPINFOHEADER *pInfoHeader = FreeImage_GetInfoHeader(dib);				pInfoHeader->biXPelsPerMeter = bih.biXPelsPerMeter;				pInfoHeader->biYPelsPerMeter = bih.biYPelsPerMeter;				// Skip over the optional palette 				// A 24 or 32 bit DIB may contain a palette for faster color reduction				if (bitmap_bits_offset > (sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + (used_colors * 3)))					io->seek_proc(handle, bitmap_bits_offset, SEEK_SET);								// read in the bitmap bits				io->read_proc(FreeImage_GetBits(dib), height * pitch, 1, handle);#ifdef FREEIMAGE_BIGENDIAN				for(int y = 0; y < FreeImage_GetHeight(dib); y++) {					BYTE *pixel = FreeImage_GetScanLine(dib, y);					for(int x = 0; x < FreeImage_GetWidth(dib); x++) {						INPLACESWAP(pixel[0], pixel[2]);						pixel += (bit_count>>3);					}				}#endif				// check if the bitmap contains transparency, if so enable it in the header				FreeImage_SetTransparent(dib, (FreeImage_GetColorType(dib) == FIC_RGBALPHA));				return dib;			}		}	} catch(const char *message) {		if(dib)			FreeImage_Unload(dib);		FreeImage_OutputMessageProc(s_format_id, message);	}	return NULL;}

void ofxGifDecoder::processFrame(FIBITMAP * bmp, int _frameNum){    
C++ FreeImage_GetFIFFromFilename函数代码示例
C++ FreeImage_GetBits函数代码示例