www.pudn.com > cximage602_full.rar > ximapng.cpp

/* 
 * File:	ximapng.cpp 
 * Purpose:	Platform Independent PNG Image Class Loader and Writer 
 * 07/Aug/2001 Davide Pizzolato - www.xdp.it 
 * CxImage version 6.0.0 02/Feb/2008 
 */ 
 
#include "ximapng.h" 
 
#if CXIMAGE_SUPPORT_PNG 
 
#include "ximaiter.h" 
 
//////////////////////////////////////////////////////////////////////////////// 
void CxImagePNG::ima_png_error(png_struct *png_ptr, char *message) 
{ 
	strcpy(info.szLastError,message); 
	longjmp(png_ptr->jmpbuf, 1); 
} 
//////////////////////////////////////////////////////////////////////////////// 
#if CXIMAGE_SUPPORT_DECODE 
//////////////////////////////////////////////////////////////////////////////// 
void CxImagePNG::expand2to4bpp(BYTE* prow) 
{ 
	BYTE *psrc,*pdst; 
	BYTE pos,idx; 
	for(long x=head.biWidth-1;x>=0;x--){ 
		psrc = prow + ((2*x)>>3); 
		pdst = prow + ((4*x)>>3); 
		pos = (BYTE)(2*(3-x%4)); 
		idx = (BYTE)((*psrc & (0x03<>pos); 
		pos = (BYTE)(4*(1-x%2)); 
		*pdst &= ~(0x0F<jmpbuf)) { 
		/* Free all of the memory associated with the png_ptr and info_ptr */ 
		delete [] row_pointers; 
		png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL); 
		cx_throw(""); 
	} 
 
	// use custom I/O functions 
    png_set_read_fn(png_ptr, hFile, /*(png_rw_ptr)*/user_read_data); 
	png_set_error_fn(png_ptr,info.szLastError,/*(png_error_ptr)*/user_error_fn,NULL); 
 
	/* read the file information */ 
	png_read_info(png_ptr, info_ptr); 
 
	if (info.nEscape == -1){ 
		head.biWidth = info_ptr->width; 
		head.biHeight= info_ptr->height; 
		info.dwType = CXIMAGE_FORMAT_PNG; 
		longjmp(png_ptr->jmpbuf, 1); 
	} 
 
	/* calculate new number of channels */ 
	int channels=0; 
	switch(info_ptr->color_type){ 
	case PNG_COLOR_TYPE_GRAY: 
	case PNG_COLOR_TYPE_PALETTE: 
		channels = 1; 
		break; 
	case PNG_COLOR_TYPE_GRAY_ALPHA: 
		channels = 2; 
		break; 
	case PNG_COLOR_TYPE_RGB: 
		channels = 3; 
		break; 
	case PNG_COLOR_TYPE_RGB_ALPHA: 
		channels = 4; 
		break; 
	default: 
		strcpy(info.szLastError,"unknown PNG color type"); 
		longjmp(png_ptr->jmpbuf, 1); 
	} 
 
	//find the right pixel depth used for cximage 
	int pixel_depth = info_ptr->pixel_depth; 
	if (channels == 1 && pixel_depth>8) pixel_depth=8; 
	if (channels == 2) pixel_depth=8; 
	if (channels >= 3) pixel_depth=24; 
 
	if (!Create(info_ptr->width, info_ptr->height, pixel_depth, CXIMAGE_FORMAT_PNG)){ 
		longjmp(png_ptr->jmpbuf, 1); 
	} 
 
	/* get metrics */ 
	switch (info_ptr->phys_unit_type) 
	{ 
	case PNG_RESOLUTION_UNKNOWN: 
		SetXDPI(info_ptr->x_pixels_per_unit); 
		SetYDPI(info_ptr->y_pixels_per_unit); 
		break; 
	case PNG_RESOLUTION_METER: 
		SetXDPI((long)floor(info_ptr->x_pixels_per_unit * 254.0 / 10000.0 + 0.5)); 
		SetYDPI((long)floor(info_ptr->y_pixels_per_unit * 254.0 / 10000.0 + 0.5)); 
		break; 
	} 
 
	if (info_ptr->num_palette>0){ 
		SetPalette((rgb_color*)info_ptr->palette,info_ptr->num_palette); 
		SetClrImportant(info_ptr->num_palette); 
	} else if (info_ptr->bit_depth ==2) { // needed for 2 bpp grayscale PNGs 
		SetPaletteColor(0,0,0,0); 
		SetPaletteColor(1,85,85,85); 
		SetPaletteColor(2,170,170,170); 
		SetPaletteColor(3,255,255,255); 
	} else SetGrayPalette(); // needed for grayscale PNGs 
	 
	int nshift = max(0,(info_ptr->bit_depth>>3)-1)<<3; 
 
	if (info_ptr->num_trans!=0){ //palette transparency 
		if (info_ptr->num_trans==1){ 
			if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE){ 
				info.nBkgndIndex = info_ptr->trans_values.index; 
			} else{ 
				info.nBkgndIndex = info_ptr->trans_values.gray>>nshift; 
			} 
		} 
		if (info_ptr->num_trans>1){ 
			RGBQUAD* pal=GetPalette(); 
			if (pal){ 
				DWORD ip; 
				for (ip=0;ipnum_trans);ip++) 
					pal[ip].rgbReserved=info_ptr->trans[ip]; 
				for (ip=info_ptr->num_trans;iptrans_values.red>>nshift); 
			info.nBkgndColor.rgbGreen = (BYTE)(info_ptr->trans_values.green>>nshift); 
			info.nBkgndColor.rgbBlue  = (BYTE)(info_ptr->trans_values.blue>>nshift); 
			info.nBkgndColor.rgbReserved = 0; 
			info.nBkgndIndex = 0; 
		} 
	} 
 
	int alpha_present = (channels - 1) % 2; 
	if (alpha_present){ 
#if CXIMAGE_SUPPORT_ALPHA	//  
		AlphaCreate(); 
#else 
		png_set_strip_alpha(png_ptr); 
#endif //CXIMAGE_SUPPORT_ALPHA 
	} 
 
	//  - flip the RGB pixels to BGR (or RGBA to BGRA) 
	if (info_ptr->color_type & PNG_COLOR_MASK_COLOR){ 
		png_set_bgr(png_ptr); 
	} 
 
	//  - handle cancel 
	if (info.nEscape) longjmp(png_ptr->jmpbuf, 1); 
 
	// row_bytes is the width x number of channels x (bit-depth / 8) 
	row_pointers = new BYTE[info_ptr->rowbytes + 8]; 
 
	// turn on interlace handling 
	int number_passes = png_set_interlace_handling(png_ptr); 
 
	if (number_passes>1){ 
		SetCodecOption(1); 
	} else { 
		SetCodecOption(0); 
	} 
 
	int chan_offset = info_ptr->bit_depth >> 3; 
	int pixel_offset = info_ptr->pixel_depth >> 3; 
 
	for (int pass=0; pass < number_passes; pass++) { 
		iter.Upset(); 
		int y=0; 
		do	{ 
 
			//  - handle cancel 
			if (info.nEscape) longjmp(png_ptr->jmpbuf, 1); 
 
#if CXIMAGE_SUPPORT_ALPHA	//  
			if (AlphaIsValid()) { 
 
				//compute the correct position of the line 
				long ax,ay; 
				ay = head.biHeight-1-y; 
				BYTE* prow= iter.GetRow(ay); 
 
				//recover data from previous scan 
				if (info_ptr->interlace_type && pass>0 && pass!=7){ 
					for(ax=0;ax RGB + A 
				for(ax=0;axinterlace_type && pass>0){ 
					iter.GetRow(row_pointers, info_ptr->rowbytes); 
					//re-expand buffer for images with bit depth > 8 
					if (info_ptr->bit_depth > 8){ 
						for(long ax=(head.biWidth*channels-1);ax>=0;ax--) 
							row_pointers[ax*chan_offset] = row_pointers[ax]; 
					} 
				} 
 
				//read next row 
				png_read_row(png_ptr, row_pointers, NULL); 
 
				//shrink 16 bit depth images down to 8 bits 
				if (info_ptr->bit_depth > 8){ 
					for(long ax=0;ax<(head.biWidth*channels);ax++) 
						row_pointers[ax] = row_pointers[ax*chan_offset]; 
				} 
 
				//copy the pixels 
				iter.SetRow(row_pointers, info_ptr->rowbytes); 
				// expand 2 bpp images only in the last pass 
				if (info_ptr->bit_depth==2 && pass==(number_passes-1)) 
					expand2to4bpp(iter.GetRow()); 
 
				//go on 
				iter.PrevRow(); 
			} 
 
			y++; 
		} while(yjmpbuf)){ 
		/* If we get here, we had a problem reading the file */ 
		if (info_ptr->palette) free(info_ptr->palette); 
		png_destroy_write_struct(&png_ptr,  (png_infopp)&info_ptr); 
		cx_throw("Error saving PNG file"); 
	} 
             
	/* set up the output control */ 
	//png_init_io(png_ptr, hFile); 
 
	// use custom I/O functions 
    png_set_write_fn(png_ptr,hFile,/*(png_rw_ptr)*/user_write_data,/*(png_flush_ptr)*/user_flush_data); 
 
	/* set the file information here */ 
	info_ptr->width = GetWidth(); 
	info_ptr->height = GetHeight(); 
	info_ptr->pixel_depth = (BYTE)GetBpp(); 
	info_ptr->channels = (GetBpp()>8) ? (BYTE)3: (BYTE)1; 
	info_ptr->bit_depth = (BYTE)(GetBpp()/info_ptr->channels); 
	info_ptr->compression_type = info_ptr->filter_type = 0; 
	info_ptr->valid = 0; 
 
	switch(GetCodecOption(CXIMAGE_FORMAT_PNG)){ 
	case 1: 
		info_ptr->interlace_type = PNG_INTERLACE_ADAM7; 
		break; 
	default: 
		info_ptr->interlace_type = PNG_INTERLACE_NONE; 
	} 
 
	/* set compression level */ 
	//png_set_compression_level(png_ptr, Z_BEST_COMPRESSION); 
 
	bool bGrayScale = IsGrayScale(); 
 
	if (GetNumColors()){ 
		if (bGrayScale){ 
			info_ptr->color_type = PNG_COLOR_TYPE_GRAY; 
		} else { 
			info_ptr->color_type = PNG_COLOR_TYPE_PALETTE; 
		} 
	} else { 
		info_ptr->color_type = PNG_COLOR_TYPE_RGB; 
	} 
#if CXIMAGE_SUPPORT_ALPHA 
	if (AlphaIsValid()){ 
		info_ptr->color_type |= PNG_COLOR_MASK_ALPHA; 
		info_ptr->channels++; 
		info_ptr->bit_depth = 8; 
		info_ptr->pixel_depth += 8; 
	} 
#endif 
 
	/* set background */ 
	png_color_16 image_background={ 0, 255, 255, 255, 0 }; 
	RGBQUAD tc = GetTransColor(); 
	if (info.nBkgndIndex>=0) { 
		image_background.blue  = tc.rgbBlue; 
		image_background.green = tc.rgbGreen; 
		image_background.red   = tc.rgbRed; 
	} 
	png_set_bKGD(png_ptr, info_ptr, &image_background); 
 
	/* set metrics */ 
	png_set_pHYs(png_ptr, info_ptr, head.biXPelsPerMeter, head.biYPelsPerMeter, PNG_RESOLUTION_METER); 
 
	png_set_IHDR(png_ptr, info_ptr, info_ptr->width, info_ptr->height, info_ptr->bit_depth, 
				info_ptr->color_type, info_ptr->interlace_type, 
				PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE); 
 
	// simple transparency 
	if (info.nBkgndIndex >= 0){ 
		info_ptr->num_trans = 1; 
		info_ptr->valid |= PNG_INFO_tRNS; 
		info_ptr->trans = trans; 
		info_ptr->trans_values.index = (BYTE)info.nBkgndIndex; 
		info_ptr->trans_values.red   = tc.rgbRed; 
		info_ptr->trans_values.green = tc.rgbGreen; 
		info_ptr->trans_values.blue  = tc.rgbBlue; 
		info_ptr->trans_values.gray  = info_ptr->trans_values.index; 
 
		// the transparency indexes start from 0 for non grayscale palette 
		if (!bGrayScale && head.biClrUsed && info.nBkgndIndex) 
			SwapIndex(0,(BYTE)info.nBkgndIndex); 
	} 
 
	/* set the palette if there is one */ 
	if (GetPalette()){ 
		if (!bGrayScale){ 
			info_ptr->valid |= PNG_INFO_PLTE; 
		} 
 
		int nc = GetClrImportant(); 
		if (nc==0) nc = GetNumColors(); 
 
		if (info.bAlphaPaletteEnabled){ 
			for(WORD ip=0; ipnum_trans = (WORD)nc; 
			info_ptr->valid |= PNG_INFO_tRNS; 
			info_ptr->trans = trans; 
		} 
 
		// copy the palette colors 
		info_ptr->palette = new png_color[nc]; 
		info_ptr->num_palette = (png_uint_16) nc; 
		for (int i=0; ipalette[i].red, &info_ptr->palette[i].green, &info_ptr->palette[i].blue); 
	}   
 
#if CXIMAGE_SUPPORT_ALPHA	//  
	//Merge the transparent color with the alpha channel 
	if (AlphaIsValid() && head.biBitCount==24 && info.nBkgndIndex>=0){ 
		for(long y=0; y < head.biHeight; y++){ 
			for(long x=0; x < head.biWidth ; x++){ 
				RGBQUAD c=GetPixelColor(x,y,false); 
				if (*(long*)&c==*(long*)&tc) 
					AlphaSet(x,y,0); 
	}	}	} 
#endif // CXIMAGE_SUPPORT_ALPHA	//  
 
	int row_size = max(info.dwEffWidth, info_ptr->width*info_ptr->channels*(info_ptr->bit_depth/8)); 
	info_ptr->rowbytes = row_size; 
	BYTE *row_pointers = new BYTE[row_size]; 
 
	/* write the file information */ 
	png_write_info(png_ptr, info_ptr); 
 
	//interlace handling 
	int num_pass = png_set_interlace_handling(png_ptr); 
	for (int pass = 0; pass < num_pass; pass++){ 
		//write image 
		iter.Upset(); 
		long ay=head.biHeight-1; 
		RGBQUAD c; 
		do	{ 
#if CXIMAGE_SUPPORT_ALPHA	//  
			if (AlphaIsValid()){ 
				for (long ax=head.biWidth-1; ax>=0;ax--){ 
					c = BlindGetPixelColor(ax,ay); 
					int px = ax * info_ptr->channels; 
					if (!bGrayScale){ 
						row_pointers[px++]=c.rgbRed; 
						row_pointers[px++]=c.rgbGreen; 
					} 
					row_pointers[px++]=c.rgbBlue; 
					row_pointers[px] = AlphaGet(ax,ay); 
				} 
				png_write_row(png_ptr, row_pointers); 
				ay--; 
			} 
			else 
#endif //CXIMAGE_SUPPORT_ALPHA	//  
			{ 
				iter.GetRow(row_pointers, row_size); 
				if (info_ptr->color_type == PNG_COLOR_TYPE_RGB) //HACK BY OP 
					RGBtoBGR(row_pointers, row_size); 
				png_write_row(png_ptr, row_pointers); 
			} 
		} while(iter.PrevRow()); 
	} 
 
	delete [] row_pointers; 
 
	//if necessary, restore the original palette 
	if (!bGrayScale && head.biClrUsed && info.nBkgndIndex>0) 
		SwapIndex((BYTE)info.nBkgndIndex,0); 
 
	/* It is REQUIRED to call this to finish writing the rest of the file */ 
	png_write_end(png_ptr, info_ptr); 
 
	/* if you malloced the palette, free it here */ 
	if (info_ptr->palette){ 
		delete [] (info_ptr->palette); 
		info_ptr->palette = NULL; 
	} 
 
	/* clean up after the write, and free any memory allocated */ 
	png_destroy_write_struct(&png_ptr, (png_infopp)&info_ptr); 
 
  } cx_catch { 
	if (strcmp(message,"")) strncpy(info.szLastError,message,255); 
	return FALSE; 
  } 
	/* that's it */ 
	return TRUE; 
} 
//////////////////////////////////////////////////////////////////////////////// 
#endif // CXIMAGE_SUPPORT_ENCODE 
//////////////////////////////////////////////////////////////////////////////// 
#endif // CXIMAGE_SUPPORT_PNG