WebSVN - shark - Blame - Rev 294 - /shark/tags/rel_1

Rev	Author	Line No.	Line
96	giacomo	1
		2	/* pngwrite.c - general routines to write a PNG file
		3	*
		4	* libpng 1.2.5 - October 3, 2002
		5	* For conditions of distribution and use, see copyright notice in png.h
		6	* Copyright (c) 1998-2002 Glenn Randers-Pehrson
		7	* (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
		8	* (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
		9	*/
		10
		11	/* get internal access to png.h */
		12	#define PNG_INTERNAL
		13	#include "png.h"
		14	#ifdef PNG_WRITE_SUPPORTED
		15
		16	/* Writes all the PNG information. This is the suggested way to use the
		17	* library. If you have a new chunk to add, make a function to write it,
		18	* and put it in the correct location here. If you want the chunk written
		19	* after the image data, put it in png_write_end(). I strongly encourage
		20	* you to supply a PNG_INFO_ flag, and check info_ptr->valid before writing
		21	* the chunk, as that will keep the code from breaking if you want to just
		22	* write a plain PNG file. If you have long comments, I suggest writing
		23	* them in png_write_end(), and compressing them.
		24	*/
		25	void PNGAPI
		26	png_write_info_before_PLTE(png_structp png_ptr, png_infop info_ptr)
		27	{
		28	png_debug(1, "in png_write_info_before_PLTE\n");
		29	if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
		30	{
		31	png_write_sig(png_ptr); /* write PNG signature */
		32	#if defined(PNG_MNG_FEATURES_SUPPORTED)
		33	if((png_ptr->mode&PNG_HAVE_PNG_SIGNATURE)&&(png_ptr->mng_features_permitted))
		34	{
		35	png_warning(png_ptr,"MNG features are not allowed in a PNG datastream\n");
		36	png_ptr->mng_features_permitted=0;
		37	}
		38	#endif
		39	/* write IHDR information. */
		40	png_write_IHDR(png_ptr, info_ptr->width, info_ptr->height,
		41	info_ptr->bit_depth, info_ptr->color_type, info_ptr->compression_type,
		42	info_ptr->filter_type,
		43	#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
		44	info_ptr->interlace_type);
		45	#else
		46	0);
		47	#endif
		48	/* the rest of these check to see if the valid field has the appropriate
		49	flag set, and if it does, writes the chunk. */
		50	#if defined(PNG_WRITE_gAMA_SUPPORTED)
		51	if (info_ptr->valid & PNG_INFO_gAMA)
		52	{
		53	# ifdef PNG_FLOATING_POINT_SUPPORTED
		54	png_write_gAMA(png_ptr, info_ptr->gamma);
		55	#else
		56	#ifdef PNG_FIXED_POINT_SUPPORTED
		57	png_write_gAMA_fixed(png_ptr, info_ptr->int_gamma);
		58	# endif
		59	#endif
		60	}
		61	#endif
		62	#if defined(PNG_WRITE_sRGB_SUPPORTED)
		63	if (info_ptr->valid & PNG_INFO_sRGB)
		64	png_write_sRGB(png_ptr, (int)info_ptr->srgb_intent);
		65	#endif
		66	#if defined(PNG_WRITE_iCCP_SUPPORTED)
		67	if (info_ptr->valid & PNG_INFO_iCCP)
		68	png_write_iCCP(png_ptr, info_ptr->iccp_name, PNG_COMPRESSION_TYPE_BASE,
		69	info_ptr->iccp_profile, (int)info_ptr->iccp_proflen);
		70	#endif
		71	#if defined(PNG_WRITE_sBIT_SUPPORTED)
		72	if (info_ptr->valid & PNG_INFO_sBIT)
		73	png_write_sBIT(png_ptr, &(info_ptr->sig_bit), info_ptr->color_type);
		74	#endif
		75	#if defined(PNG_WRITE_cHRM_SUPPORTED)
		76	if (info_ptr->valid & PNG_INFO_cHRM)
		77	{
		78	#ifdef PNG_FLOATING_POINT_SUPPORTED
		79	png_write_cHRM(png_ptr,
		80	info_ptr->x_white, info_ptr->y_white,
		81	info_ptr->x_red, info_ptr->y_red,
		82	info_ptr->x_green, info_ptr->y_green,
		83	info_ptr->x_blue, info_ptr->y_blue);
		84	#else
		85	# ifdef PNG_FIXED_POINT_SUPPORTED
		86	png_write_cHRM_fixed(png_ptr,
		87	info_ptr->int_x_white, info_ptr->int_y_white,
		88	info_ptr->int_x_red, info_ptr->int_y_red,
		89	info_ptr->int_x_green, info_ptr->int_y_green,
		90	info_ptr->int_x_blue, info_ptr->int_y_blue);
		91	# endif
		92	#endif
		93	}
		94	#endif
		95	#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
		96	if (info_ptr->unknown_chunks_num)
		97	{
		98	png_unknown_chunk *up;
		99
		100	png_debug(5, "writing extra chunks\n");
		101
		102	for (up = info_ptr->unknown_chunks;
		103	up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
		104	up++)
		105	{
		106	int keep=png_handle_as_unknown(png_ptr, up->name);
		107	if (keep != HANDLE_CHUNK_NEVER &&
		108	up->location && (!(up->location & PNG_HAVE_PLTE)) &&
		109	((up->name[3] & 0x20) \|\| keep == HANDLE_CHUNK_ALWAYS \|\|
		110	(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
		111	{
		112	png_write_chunk(png_ptr, up->name, up->data, up->size);
		113	}
		114	}
		115	}
		116	#endif
		117	png_ptr->mode \|= PNG_WROTE_INFO_BEFORE_PLTE;
		118	}
		119	}
		120
		121	void PNGAPI
		122	png_write_info(png_structp png_ptr, png_infop info_ptr)
		123	{
		124	#if defined(PNG_WRITE_TEXT_SUPPORTED) \|\| defined(PNG_WRITE_sPLT_SUPPORTED)
		125	int i;
		126	#endif
		127
		128	png_debug(1, "in png_write_info\n");
		129
		130	png_write_info_before_PLTE(png_ptr, info_ptr);
		131
		132	if (info_ptr->valid & PNG_INFO_PLTE)
		133	png_write_PLTE(png_ptr, info_ptr->palette,
		134	(png_uint_32)info_ptr->num_palette);
		135	else if (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		136	png_error(png_ptr, "Valid palette required for paletted images\n");
		137
		138	#if defined(PNG_WRITE_tRNS_SUPPORTED)
		139	if (info_ptr->valid & PNG_INFO_tRNS)
		140	{
		141	#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
		142	/* invert the alpha channel (in tRNS) */
		143	if ((png_ptr->transformations & PNG_INVERT_ALPHA) &&
		144	info_ptr->color_type == PNG_COLOR_TYPE_PALETTE)
		145	{
		146	int j;
		147	for (j=0; j<(int)info_ptr->num_trans; j++)
		148	info_ptr->trans[j] = (png_byte)(255 - info_ptr->trans[j]);
		149	}
		150	#endif
		151	png_write_tRNS(png_ptr, info_ptr->trans, &(info_ptr->trans_values),
		152	info_ptr->num_trans, info_ptr->color_type);
		153	}
		154	#endif
		155	#if defined(PNG_WRITE_bKGD_SUPPORTED)
		156	if (info_ptr->valid & PNG_INFO_bKGD)
		157	png_write_bKGD(png_ptr, &(info_ptr->background), info_ptr->color_type);
		158	#endif
		159	#if defined(PNG_WRITE_hIST_SUPPORTED)
		160	if (info_ptr->valid & PNG_INFO_hIST)
		161	png_write_hIST(png_ptr, info_ptr->hist, info_ptr->num_palette);
		162	#endif
		163	#if defined(PNG_WRITE_oFFs_SUPPORTED)
		164	if (info_ptr->valid & PNG_INFO_oFFs)
		165	png_write_oFFs(png_ptr, info_ptr->x_offset, info_ptr->y_offset,
		166	info_ptr->offset_unit_type);
		167	#endif
		168	#if defined(PNG_WRITE_pCAL_SUPPORTED)
		169	if (info_ptr->valid & PNG_INFO_pCAL)
		170	png_write_pCAL(png_ptr, info_ptr->pcal_purpose, info_ptr->pcal_X0,
		171	info_ptr->pcal_X1, info_ptr->pcal_type, info_ptr->pcal_nparams,
		172	info_ptr->pcal_units, info_ptr->pcal_params);
		173	#endif
		174	#if defined(PNG_WRITE_sCAL_SUPPORTED)
		175	if (info_ptr->valid & PNG_INFO_sCAL)
		176	#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO)
		177	png_write_sCAL(png_ptr, (int)info_ptr->scal_unit,
		178	info_ptr->scal_pixel_width, info_ptr->scal_pixel_height);
		179	#else
		180	#ifdef PNG_FIXED_POINT_SUPPORTED
		181	png_write_sCAL_s(png_ptr, (int)info_ptr->scal_unit,
		182	info_ptr->scal_s_width, info_ptr->scal_s_height);
		183	#else
		184	png_warning(png_ptr,
		185	"png_write_sCAL not supported; sCAL chunk not written.\n");
		186	#endif
		187	#endif
		188	#endif
		189	#if defined(PNG_WRITE_pHYs_SUPPORTED)
		190	if (info_ptr->valid & PNG_INFO_pHYs)
		191	png_write_pHYs(png_ptr, info_ptr->x_pixels_per_unit,
		192	info_ptr->y_pixels_per_unit, info_ptr->phys_unit_type);
		193	#endif
		194	#if defined(PNG_WRITE_tIME_SUPPORTED)
		195	if (info_ptr->valid & PNG_INFO_tIME)
		196	{
		197	png_write_tIME(png_ptr, &(info_ptr->mod_time));
		198	png_ptr->mode \|= PNG_WROTE_tIME;
		199	}
		200	#endif
		201	#if defined(PNG_WRITE_sPLT_SUPPORTED)
		202	if (info_ptr->valid & PNG_INFO_sPLT)
		203	for (i = 0; i < (int)info_ptr->splt_palettes_num; i++)
		204	png_write_sPLT(png_ptr, info_ptr->splt_palettes + i);
		205	#endif
		206	#if defined(PNG_WRITE_TEXT_SUPPORTED)
		207	/* Check to see if we need to write text chunks */
		208	for (i = 0; i < info_ptr->num_text; i++)
		209	{
		210	png_debug2(2, "Writing header text chunk %d, type %d\n", i,
		211	info_ptr->text[i].compression);
		212	/* an internationalized chunk? */
		213	if (info_ptr->text[i].compression > 0)
		214	{
		215	#if defined(PNG_WRITE_iTXt_SUPPORTED)
		216	/* write international chunk */
		217	png_write_iTXt(png_ptr,
		218	info_ptr->text[i].compression,
		219	info_ptr->text[i].key,
		220	info_ptr->text[i].lang,
		221	info_ptr->text[i].lang_key,
		222	info_ptr->text[i].text);
		223	#else
		224	png_warning(png_ptr, "Unable to write international text\n");
		225	#endif
		226	/* Mark this chunk as written */
		227	info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
		228	}
		229	/* If we want a compressed text chunk */
		230	else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_zTXt)
		231	{
		232	#if defined(PNG_WRITE_zTXt_SUPPORTED)
		233	/* write compressed chunk */
		234	png_write_zTXt(png_ptr, info_ptr->text[i].key,
		235	info_ptr->text[i].text, 0,
		236	info_ptr->text[i].compression);
		237	#else
		238	png_warning(png_ptr, "Unable to write compressed text\n");
		239	#endif
		240	/* Mark this chunk as written */
		241	info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
		242	}
		243	else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
		244	{
		245	#if defined(PNG_WRITE_tEXt_SUPPORTED)
		246	/* write uncompressed chunk */
		247	png_write_tEXt(png_ptr, info_ptr->text[i].key,
		248	info_ptr->text[i].text,
		249	0);
		250	#else
		251	png_warning(png_ptr, "Unable to write uncompressed text\n");
		252	#endif
		253	/* Mark this chunk as written */
		254	info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
		255	}
		256	}
		257	#endif
		258	#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
		259	if (info_ptr->unknown_chunks_num)
		260	{
		261	png_unknown_chunk *up;
		262
		263	png_debug(5, "writing extra chunks\n");
		264
		265	for (up = info_ptr->unknown_chunks;
		266	up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
		267	up++)
		268	{
		269	int keep=png_handle_as_unknown(png_ptr, up->name);
		270	if (keep != HANDLE_CHUNK_NEVER &&
		271	up->location && (up->location & PNG_HAVE_PLTE) &&
		272	!(up->location & PNG_HAVE_IDAT) &&
		273	((up->name[3] & 0x20) \|\| keep == HANDLE_CHUNK_ALWAYS \|\|
		274	(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
		275	{
		276	png_write_chunk(png_ptr, up->name, up->data, up->size);
		277	}
		278	}
		279	}
		280	#endif
		281	}
		282
		283	/* Writes the end of the PNG file. If you don't want to write comments or
		284	* time information, you can pass NULL for info. If you already wrote these
		285	* in png_write_info(), do not write them again here. If you have long
		286	* comments, I suggest writing them here, and compressing them.
		287	*/
		288	void PNGAPI
		289	png_write_end(png_structp png_ptr, png_infop info_ptr)
		290	{
		291	png_debug(1, "in png_write_end\n");
		292	if (!(png_ptr->mode & PNG_HAVE_IDAT))
		293	png_error(png_ptr, "No IDATs written into file");
		294
		295	/* see if user wants us to write information chunks */
		296	if (info_ptr != NULL)
		297	{
		298	#if defined(PNG_WRITE_TEXT_SUPPORTED)
		299	int i; /* local index variable */
		300	#endif
		301	#if defined(PNG_WRITE_tIME_SUPPORTED)
		302	/* check to see if user has supplied a time chunk */
		303	if ((info_ptr->valid & PNG_INFO_tIME) &&
		304	!(png_ptr->mode & PNG_WROTE_tIME))
		305	png_write_tIME(png_ptr, &(info_ptr->mod_time));
		306	#endif
		307	#if defined(PNG_WRITE_TEXT_SUPPORTED)
		308	/* loop through comment chunks */
		309	for (i = 0; i < info_ptr->num_text; i++)
		310	{
		311	png_debug2(2, "Writing trailer text chunk %d, type %d\n", i,
		312	info_ptr->text[i].compression);
		313	/* an internationalized chunk? */
		314	if (info_ptr->text[i].compression > 0)
		315	{
		316	#if defined(PNG_WRITE_iTXt_SUPPORTED)
		317	/* write international chunk */
		318	png_write_iTXt(png_ptr,
		319	info_ptr->text[i].compression,
		320	info_ptr->text[i].key,
		321	info_ptr->text[i].lang,
		322	info_ptr->text[i].lang_key,
		323	info_ptr->text[i].text);
		324	#else
		325	png_warning(png_ptr, "Unable to write international text\n");
		326	#endif
		327	/* Mark this chunk as written */
		328	info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
		329	}
		330	else if (info_ptr->text[i].compression >= PNG_TEXT_COMPRESSION_zTXt)
		331	{
		332	#if defined(PNG_WRITE_zTXt_SUPPORTED)
		333	/* write compressed chunk */
		334	png_write_zTXt(png_ptr, info_ptr->text[i].key,
		335	info_ptr->text[i].text, 0,
		336	info_ptr->text[i].compression);
		337	#else
		338	png_warning(png_ptr, "Unable to write compressed text\n");
		339	#endif
		340	/* Mark this chunk as written */
		341	info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_zTXt_WR;
		342	}
		343	else if (info_ptr->text[i].compression == PNG_TEXT_COMPRESSION_NONE)
		344	{
		345	#if defined(PNG_WRITE_tEXt_SUPPORTED)
		346	/* write uncompressed chunk */
		347	png_write_tEXt(png_ptr, info_ptr->text[i].key,
		348	info_ptr->text[i].text, 0);
		349	#else
		350	png_warning(png_ptr, "Unable to write uncompressed text\n");
		351	#endif
		352
		353	/* Mark this chunk as written */
		354	info_ptr->text[i].compression = PNG_TEXT_COMPRESSION_NONE_WR;
		355	}
		356	}
		357	#endif
		358	#if defined(PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED)
		359	if (info_ptr->unknown_chunks_num)
		360	{
		361	png_unknown_chunk *up;
		362
		363	png_debug(5, "writing extra chunks\n");
		364
		365	for (up = info_ptr->unknown_chunks;
		366	up < info_ptr->unknown_chunks + info_ptr->unknown_chunks_num;
		367	up++)
		368	{
		369	int keep=png_handle_as_unknown(png_ptr, up->name);
		370	if (keep != HANDLE_CHUNK_NEVER &&
		371	up->location && (up->location & PNG_AFTER_IDAT) &&
		372	((up->name[3] & 0x20) \|\| keep == HANDLE_CHUNK_ALWAYS \|\|
		373	(png_ptr->flags & PNG_FLAG_KEEP_UNSAFE_CHUNKS)))
		374	{
		375	png_write_chunk(png_ptr, up->name, up->data, up->size);
		376	}
		377	}
		378	}
		379	#endif
		380	}
		381
		382	png_ptr->mode \|= PNG_AFTER_IDAT;
		383
		384	/* write end of PNG file */
		385	png_write_IEND(png_ptr);
		386	#if 0
		387	/* This flush, added in libpng-1.0.8, causes some applications to crash
		388	because they do not set png_ptr->output_flush_fn */
		389	png_flush(png_ptr);
		390	#endif
		391	}
		392
		393	#if defined(PNG_WRITE_tIME_SUPPORTED)
		394	#if !defined(_WIN32_WCE)
		395	/* "time.h" functions are not supported on WindowsCE */
		396	void PNGAPI
		397	png_convert_from_struct_tm(png_timep ptime, struct tm FAR * ttime)
		398	{
		399	png_debug(1, "in png_convert_from_struct_tm\n");
		400	ptime->year = (png_uint_16)(1900 + ttime->tm_year);
		401	ptime->month = (png_byte)(ttime->tm_mon + 1);
		402	ptime->day = (png_byte)ttime->tm_mday;
		403	ptime->hour = (png_byte)ttime->tm_hour;
		404	ptime->minute = (png_byte)ttime->tm_min;
		405	ptime->second = (png_byte)ttime->tm_sec;
		406	}
		407
		408	void PNGAPI
		409	png_convert_from_time_t(png_timep ptime, time_t ttime)
		410	{
		411	struct tm *tbuf;
		412
		413	png_debug(1, "in png_convert_from_time_t\n");
		414	tbuf = gmtime(&ttime);
		415	png_convert_from_struct_tm(ptime, tbuf);
		416	}
		417	#endif
		418	#endif
		419
		420	/* Initialize png_ptr structure, and allocate any memory needed */
		421	png_structp PNGAPI
		422	png_create_write_struct(png_const_charp user_png_ver, png_voidp error_ptr,
		423	png_error_ptr error_fn, png_error_ptr warn_fn)
		424	{
		425	#ifdef PNG_USER_MEM_SUPPORTED
		426	return (png_create_write_struct_2(user_png_ver, error_ptr, error_fn,
		427	warn_fn, png_voidp_NULL, png_malloc_ptr_NULL, png_free_ptr_NULL));
		428	}
		429
		430	/* Alternate initialize png_ptr structure, and allocate any memory needed */
		431	png_structp PNGAPI
		432	png_create_write_struct_2(png_const_charp user_png_ver, png_voidp error_ptr,
		433	png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr,
		434	png_malloc_ptr malloc_fn, png_free_ptr free_fn)
		435	{
		436	#endif /* PNG_USER_MEM_SUPPORTED */
		437	png_structp png_ptr;
		438	#ifdef PNG_SETJMP_SUPPORTED
		439	#ifdef USE_FAR_KEYWORD
		440	jmp_buf jmpbuf;
		441	#endif
		442	#endif
		443	int i;
		444	png_debug(1, "in png_create_write_struct\n");
		445	#ifdef PNG_USER_MEM_SUPPORTED
		446	png_ptr = (png_structp)png_create_struct_2(PNG_STRUCT_PNG,
		447	(png_malloc_ptr)malloc_fn, (png_voidp)mem_ptr);
		448	#else
		449	png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
		450	#endif /* PNG_USER_MEM_SUPPORTED */
		451	if (png_ptr == NULL)
		452	return (NULL);
		453
		454	#if !defined(PNG_1_0_X)
		455	#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
		456	png_init_mmx_flags(png_ptr); /* 1.2.0 addition */
		457	#endif
		458	#endif /* PNG_1_0_X */
		459
		460	#ifdef PNG_SETJMP_SUPPORTED
		461	#ifdef USE_FAR_KEYWORD
		462	if (setjmp(jmpbuf))
		463	#else
		464	if (setjmp(png_ptr->jmpbuf))
		465	#endif
		466	{
		467	png_free(png_ptr, png_ptr->zbuf);
		468	png_ptr->zbuf=NULL;
		469	png_destroy_struct(png_ptr);
		470	return (NULL);
		471	}
		472	#ifdef USE_FAR_KEYWORD
		473	png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
		474	#endif
		475	#endif
		476
		477	#ifdef PNG_USER_MEM_SUPPORTED
		478	png_set_mem_fn(png_ptr, mem_ptr, malloc_fn, free_fn);
		479	#endif /* PNG_USER_MEM_SUPPORTED */
		480	png_set_error_fn(png_ptr, error_ptr, error_fn, warn_fn);
		481
		482	i=0;
		483	do
		484	{
		485	if(user_png_ver[i] != png_libpng_ver[i])
		486	png_ptr->flags \|= PNG_FLAG_LIBRARY_MISMATCH;
		487	} while (png_libpng_ver[i++]);
		488
		489	if (png_ptr->flags & PNG_FLAG_LIBRARY_MISMATCH)
		490	{
		491	/* Libpng 0.90 and later are binary incompatible with libpng 0.89, so
		492	* we must recompile any applications that use any older library version.
		493	* For versions after libpng 1.0, we will be compatible, so we need
		494	* only check the first digit.
		495	*/
		496	if (user_png_ver == NULL \|\| user_png_ver[0] != png_libpng_ver[0] \|\|
		497	(user_png_ver[0] == '1' && user_png_ver[2] != png_libpng_ver[2]) \|\|
		498	(user_png_ver[0] == '0' && user_png_ver[2] < '9'))
		499	{
		500	#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
		501	char msg[80];
		502	if (user_png_ver)
		503	{
		504	sprintf(msg, "Application was compiled with png.h from libpng-%.20s",
		505	user_png_ver);
		506	png_warning(png_ptr, msg);
		507	}
		508	sprintf(msg, "Application is running with png.c from libpng-%.20s",
		509	png_libpng_ver);
		510	png_warning(png_ptr, msg);
		511	#endif
		512	#ifdef PNG_ERROR_NUMBERS_SUPPORTED
		513	png_ptr->flags=0;
		514	#endif
		515	png_error(png_ptr,
		516	"Incompatible libpng version in application and library");
		517	}
		518	}
		519
		520	/* initialize zbuf - compression buffer */
		521	png_ptr->zbuf_size = PNG_ZBUF_SIZE;
		522	png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
		523	(png_uint_32)png_ptr->zbuf_size);
		524
		525	png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
		526	png_flush_ptr_NULL);
		527
		528	#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
		529	png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
		530	1, png_doublep_NULL, png_doublep_NULL);
		531	#endif
		532
		533	#ifdef PNG_SETJMP_SUPPORTED
		534	/* Applications that neglect to set up their own setjmp() and then encounter
		535	a png_error() will longjmp here. Since the jmpbuf is then meaningless we
		536	abort instead of returning. */
		537	#ifdef USE_FAR_KEYWORD
		538	if (setjmp(jmpbuf))
		539	PNG_ABORT();
		540	png_memcpy(png_ptr->jmpbuf,jmpbuf,sizeof(jmp_buf));
		541	#else
		542	if (setjmp(png_ptr->jmpbuf))
		543	PNG_ABORT();
		544	#endif
		545	#endif
		546	return (png_ptr);
		547	}
		548
		549	/* Initialize png_ptr structure, and allocate any memory needed */
		550	#undef png_write_init
		551	void PNGAPI
		552	png_write_init(png_structp png_ptr)
		553	{
		554	/* We only come here via pre-1.0.7-compiled applications */
		555	png_write_init_2(png_ptr, "1.0.6 or earlier", 0, 0);
		556	}
		557
		558	void PNGAPI
		559	png_write_init_2(png_structp png_ptr, png_const_charp user_png_ver,
		560	png_size_t png_struct_size, png_size_t png_info_size)
		561	{
		562	/* We only come here via pre-1.0.12-compiled applications */
		563	#if !defined(PNG_NO_STDIO) && !defined(_WIN32_WCE)
		564	if(sizeof(png_struct) > png_struct_size \|\| sizeof(png_info) > png_info_size)
		565	{
		566	char msg[80];
		567	png_ptr->warning_fn=NULL;
		568	if (user_png_ver)
		569	{
		570	sprintf(msg, "Application was compiled with png.h from libpng-%.20s",
		571	user_png_ver);
		572	png_warning(png_ptr, msg);
		573	}
		574	sprintf(msg, "Application is running with png.c from libpng-%.20s",
		575	png_libpng_ver);
		576	png_warning(png_ptr, msg);
		577	}
		578	#endif
		579	if(sizeof(png_struct) > png_struct_size)
		580	{
		581	png_ptr->error_fn=NULL;
		582	#ifdef PNG_ERROR_NUMBERS_SUPPORTED
		583	png_ptr->flags=0;
		584	#endif
		585	png_error(png_ptr,
		586	"The png struct allocated by the application for writing is too small.");
		587	}
		588	if(sizeof(png_info) > png_info_size)
		589	{
		590	png_ptr->error_fn=NULL;
		591	#ifdef PNG_ERROR_NUMBERS_SUPPORTED
		592	png_ptr->flags=0;
		593	#endif
		594	png_error(png_ptr,
		595	"The info struct allocated by the application for writing is too small.");
		596	}
		597	png_write_init_3(&png_ptr, user_png_ver, png_struct_size);
		598	}
		599
		600
		601	void PNGAPI
		602	png_write_init_3(png_structpp ptr_ptr, png_const_charp user_png_ver,
		603	png_size_t png_struct_size)
		604	{
		605	png_structp png_ptr=*ptr_ptr;
		606	#ifdef PNG_SETJMP_SUPPORTED
		607	jmp_buf tmp_jmp; /* to save current jump buffer */
		608	#endif
		609	int i = 0;
		610	do
		611	{
		612	if (user_png_ver[i] != png_libpng_ver[i])
		613	{
		614	#ifdef PNG_LEGACY_SUPPORTED
		615	png_ptr->flags \|= PNG_FLAG_LIBRARY_MISMATCH;
		616	#else
		617	png_ptr->warning_fn=NULL;
		618	png_warning(png_ptr,
		619	"Application uses deprecated png_write_init() and should be recompiled.");
		620	break;
		621	#endif
		622	}
		623	} while (png_libpng_ver[i++]);
		624
		625	png_debug(1, "in png_write_init_3\n");
		626
		627	#ifdef PNG_SETJMP_SUPPORTED
		628	/* save jump buffer and error functions */
		629	png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
		630	#endif
		631
		632	if (sizeof(png_struct) > png_struct_size)
		633	{
		634	png_destroy_struct(png_ptr);
		635	png_ptr = (png_structp)png_create_struct(PNG_STRUCT_PNG);
		636	*ptr_ptr = png_ptr;
		637	}
		638
		639	/* reset all variables to 0 */
		640	png_memset(png_ptr, 0, sizeof (png_struct));
		641
		642	#if !defined(PNG_1_0_X)
		643	#ifdef PNG_ASSEMBLER_CODE_SUPPORTED
		644	png_init_mmx_flags(png_ptr); /* 1.2.0 addition */
		645	#endif
		646	#endif /* PNG_1_0_X */
		647
		648	#ifdef PNG_SETJMP_SUPPORTED
		649	/* restore jump buffer */
		650	png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
		651	#endif
		652
		653	png_set_write_fn(png_ptr, png_voidp_NULL, png_rw_ptr_NULL,
		654	png_flush_ptr_NULL);
		655
		656	/* initialize zbuf - compression buffer */
		657	png_ptr->zbuf_size = PNG_ZBUF_SIZE;
		658	png_ptr->zbuf = (png_bytep)png_malloc(png_ptr,
		659	(png_uint_32)png_ptr->zbuf_size);
		660
		661	#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
		662	png_set_filter_heuristics(png_ptr, PNG_FILTER_HEURISTIC_DEFAULT,
		663	1, png_doublep_NULL, png_doublep_NULL);
		664	#endif
		665	}
		666
		667	/* Write a few rows of image data. If the image is interlaced,
		668	* either you will have to write the 7 sub images, or, if you
		669	* have called png_set_interlace_handling(), you will have to
		670	* "write" the image seven times.
		671	*/
		672	void PNGAPI
		673	png_write_rows(png_structp png_ptr, png_bytepp row,
		674	png_uint_32 num_rows)
		675	{
		676	png_uint_32 i; /* row counter */
		677	png_bytepp rp; /* row pointer */
		678
		679	png_debug(1, "in png_write_rows\n");
		680	/* loop through the rows */
		681	for (i = 0, rp = row; i < num_rows; i++, rp++)
		682	{
		683	png_write_row(png_ptr, *rp);
		684	}
		685	}
		686
		687	/* Write the image. You only need to call this function once, even
		688	* if you are writing an interlaced image.
		689	*/
		690	void PNGAPI
		691	png_write_image(png_structp png_ptr, png_bytepp image)
		692	{
		693	png_uint_32 i; /* row index */
		694	int pass, num_pass; /* pass variables */
		695	png_bytepp rp; /* points to current row */
		696
		697	png_debug(1, "in png_write_image\n");
		698	#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
		699	/* intialize interlace handling. If image is not interlaced,
		700	this will set pass to 1 */
		701	num_pass = png_set_interlace_handling(png_ptr);
		702	#else
		703	num_pass = 1;
		704	#endif
		705	/* loop through passes */
		706	for (pass = 0; pass < num_pass; pass++)
		707	{
		708	/* loop through image */
		709	for (i = 0, rp = image; i < png_ptr->height; i++, rp++)
		710	{
		711	png_write_row(png_ptr, *rp);
		712	}
		713	}
		714	}
		715
		716	/* called by user to write a row of image data */
		717	void PNGAPI
		718	png_write_row(png_structp png_ptr, png_bytep row)
		719	{
		720	png_debug2(1, "in png_write_row (row %ld, pass %d)\n",
		721	png_ptr->row_number, png_ptr->pass);
		722	/* initialize transformations and other stuff if first time */
		723	if (png_ptr->row_number == 0 && png_ptr->pass == 0)
		724	{
		725	/* make sure we wrote the header info */
		726	if (!(png_ptr->mode & PNG_WROTE_INFO_BEFORE_PLTE))
		727	png_error(png_ptr,
		728	"png_write_info was never called before png_write_row.");
		729
		730	/* check for transforms that have been set but were defined out */
		731	#if !defined(PNG_WRITE_INVERT_SUPPORTED) && defined(PNG_READ_INVERT_SUPPORTED)
		732	if (png_ptr->transformations & PNG_INVERT_MONO)
		733	png_warning(png_ptr, "PNG_WRITE_INVERT_SUPPORTED is not defined.");
		734	#endif
		735	#if !defined(PNG_WRITE_FILLER_SUPPORTED) && defined(PNG_READ_FILLER_SUPPORTED)
		736	if (png_ptr->transformations & PNG_FILLER)
		737	png_warning(png_ptr, "PNG_WRITE_FILLER_SUPPORTED is not defined.");
		738	#endif
		739	#if !defined(PNG_WRITE_PACKSWAP_SUPPORTED) && defined(PNG_READ_PACKSWAP_SUPPORTED)
		740	if (png_ptr->transformations & PNG_PACKSWAP)
		741	png_warning(png_ptr, "PNG_WRITE_PACKSWAP_SUPPORTED is not defined.");
		742	#endif
		743	#if !defined(PNG_WRITE_PACK_SUPPORTED) && defined(PNG_READ_PACK_SUPPORTED)
		744	if (png_ptr->transformations & PNG_PACK)
		745	png_warning(png_ptr, "PNG_WRITE_PACK_SUPPORTED is not defined.");
		746	#endif
		747	#if !defined(PNG_WRITE_SHIFT_SUPPORTED) && defined(PNG_READ_SHIFT_SUPPORTED)
		748	if (png_ptr->transformations & PNG_SHIFT)
		749	png_warning(png_ptr, "PNG_WRITE_SHIFT_SUPPORTED is not defined.");
		750	#endif
		751	#if !defined(PNG_WRITE_BGR_SUPPORTED) && defined(PNG_READ_BGR_SUPPORTED)
		752	if (png_ptr->transformations & PNG_BGR)
		753	png_warning(png_ptr, "PNG_WRITE_BGR_SUPPORTED is not defined.");
		754	#endif
		755	#if !defined(PNG_WRITE_SWAP_SUPPORTED) && defined(PNG_READ_SWAP_SUPPORTED)
		756	if (png_ptr->transformations & PNG_SWAP_BYTES)
		757	png_warning(png_ptr, "PNG_WRITE_SWAP_SUPPORTED is not defined.");
		758	#endif
		759
		760	png_write_start_row(png_ptr);
		761	}
		762
		763	#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
		764	/* if interlaced and not interested in row, return */
		765	if (png_ptr->interlaced && (png_ptr->transformations & PNG_INTERLACE))
		766	{
		767	switch (png_ptr->pass)
		768	{
		769	case 0:
		770	if (png_ptr->row_number & 0x07)
		771	{
		772	png_write_finish_row(png_ptr);
		773	return;
		774	}
		775	break;
		776	case 1:
		777	if ((png_ptr->row_number & 0x07) \|\| png_ptr->width < 5)
		778	{
		779	png_write_finish_row(png_ptr);
		780	return;
		781	}
		782	break;
		783	case 2:
		784	if ((png_ptr->row_number & 0x07) != 4)
		785	{
		786	png_write_finish_row(png_ptr);
		787	return;
		788	}
		789	break;
		790	case 3:
		791	if ((png_ptr->row_number & 0x03) \|\| png_ptr->width < 3)
		792	{
		793	png_write_finish_row(png_ptr);
		794	return;
		795	}
		796	break;
		797	case 4:
		798	if ((png_ptr->row_number & 0x03) != 2)
		799	{
		800	png_write_finish_row(png_ptr);
		801	return;
		802	}
		803	break;
		804	case 5:
		805	if ((png_ptr->row_number & 0x01) \|\| png_ptr->width < 2)
		806	{
		807	png_write_finish_row(png_ptr);
		808	return;
		809	}
		810	break;
		811	case 6:
		812	if (!(png_ptr->row_number & 0x01))
		813	{
		814	png_write_finish_row(png_ptr);
		815	return;
		816	}
		817	break;
		818	}
		819	}
		820	#endif
		821
		822	/* set up row info for transformations */
		823	png_ptr->row_info.color_type = png_ptr->color_type;
		824	png_ptr->row_info.width = png_ptr->usr_width;
		825	png_ptr->row_info.channels = png_ptr->usr_channels;
		826	png_ptr->row_info.bit_depth = png_ptr->usr_bit_depth;
		827	png_ptr->row_info.pixel_depth = (png_byte)(png_ptr->row_info.bit_depth *
		828	png_ptr->row_info.channels);
		829
		830	png_ptr->row_info.rowbytes = ((png_ptr->row_info.width *
		831	(png_uint_32)png_ptr->row_info.pixel_depth + 7) >> 3);
		832
		833	png_debug1(3, "row_info->color_type = %d\n", png_ptr->row_info.color_type);
		834	png_debug1(3, "row_info->width = %lu\n", png_ptr->row_info.width);
		835	png_debug1(3, "row_info->channels = %d\n", png_ptr->row_info.channels);
		836	png_debug1(3, "row_info->bit_depth = %d\n", png_ptr->row_info.bit_depth);
		837	png_debug1(3, "row_info->pixel_depth = %d\n", png_ptr->row_info.pixel_depth);
		838	png_debug1(3, "row_info->rowbytes = %lu\n", png_ptr->row_info.rowbytes);
		839
		840	/* Copy user's row into buffer, leaving room for filter byte. */
		841	png_memcpy_check(png_ptr, png_ptr->row_buf + 1, row,
		842	png_ptr->row_info.rowbytes);
		843
		844	#if defined(PNG_WRITE_INTERLACING_SUPPORTED)
		845	/* handle interlacing */
		846	if (png_ptr->interlaced && png_ptr->pass < 6 &&
		847	(png_ptr->transformations & PNG_INTERLACE))
		848	{
		849	png_do_write_interlace(&(png_ptr->row_info),
		850	png_ptr->row_buf + 1, png_ptr->pass);
		851	/* this should always get caught above, but still ... */
		852	if (!(png_ptr->row_info.width))
		853	{
		854	png_write_finish_row(png_ptr);
		855	return;
		856	}
		857	}
		858	#endif
		859
		860	/* handle other transformations */
		861	if (png_ptr->transformations)
		862	png_do_write_transformations(png_ptr);
		863
		864	#if defined(PNG_MNG_FEATURES_SUPPORTED)
		865	/* Write filter_method 64 (intrapixel differencing) only if
		866	* 1. Libpng was compiled with PNG_MNG_FEATURES_SUPPORTED and
		867	* 2. Libpng did not write a PNG signature (this filter_method is only
		868	* used in PNG datastreams that are embedded in MNG datastreams) and
		869	* 3. The application called png_permit_mng_features with a mask that
		870	* included PNG_FLAG_MNG_FILTER_64 and
		871	* 4. The filter_method is 64 and
		872	* 5. The color_type is RGB or RGBA
		873	*/
		874	if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
		875	(png_ptr->filter_type == PNG_INTRAPIXEL_DIFFERENCING))
		876	{
		877	/* Intrapixel differencing */
		878	png_do_write_intrapixel(&(png_ptr->row_info), png_ptr->row_buf + 1);
		879	}
		880	#endif
		881
		882	/* Find a filter if necessary, filter the row and write it out. */
		883	png_write_find_filter(png_ptr, &(png_ptr->row_info));
		884
		885	if (png_ptr->write_row_fn != NULL)
		886	(*(png_ptr->write_row_fn))(png_ptr, png_ptr->row_number, png_ptr->pass);
		887	}
		888
		889	#if defined(PNG_WRITE_FLUSH_SUPPORTED)
		890	/* Set the automatic flush interval or 0 to turn flushing off */
		891	void PNGAPI
		892	png_set_flush(png_structp png_ptr, int nrows)
		893	{
		894	png_debug(1, "in png_set_flush\n");
		895	png_ptr->flush_dist = (nrows < 0 ? 0 : nrows);
		896	}
		897
		898	/* flush the current output buffers now */
		899	void PNGAPI
		900	png_write_flush(png_structp png_ptr)
		901	{
		902	int wrote_IDAT;
		903
		904	png_debug(1, "in png_write_flush\n");
		905	/* We have already written out all of the data */
		906	if (png_ptr->row_number >= png_ptr->num_rows)
		907	return;
		908
		909	do
		910	{
		911	int ret;
		912
		913	/* compress the data */
		914	ret = deflate(&png_ptr->zstream, Z_SYNC_FLUSH);
		915	wrote_IDAT = 0;
		916
		917	/* check for compression errors */
		918	if (ret != Z_OK)
		919	{
		920	if (png_ptr->zstream.msg != NULL)
		921	png_error(png_ptr, png_ptr->zstream.msg);
		922	else
		923	png_error(png_ptr, "zlib error");
		924	}
		925
		926	if (!(png_ptr->zstream.avail_out))
		927	{
		928	/* write the IDAT and reset the zlib output buffer */
		929	png_write_IDAT(png_ptr, png_ptr->zbuf,
		930	png_ptr->zbuf_size);
		931	png_ptr->zstream.next_out = png_ptr->zbuf;
		932	png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
		933	wrote_IDAT = 1;
		934	}
		935	} while(wrote_IDAT == 1);
		936
		937	/* If there is any data left to be output, write it into a new IDAT */
		938	if (png_ptr->zbuf_size != png_ptr->zstream.avail_out)
		939	{
		940	/* write the IDAT and reset the zlib output buffer */
		941	png_write_IDAT(png_ptr, png_ptr->zbuf,
		942	png_ptr->zbuf_size - png_ptr->zstream.avail_out);
		943	png_ptr->zstream.next_out = png_ptr->zbuf;
		944	png_ptr->zstream.avail_out = (uInt)png_ptr->zbuf_size;
		945	}
		946	png_ptr->flush_rows = 0;
		947	png_flush(png_ptr);
		948	}
		949	#endif /* PNG_WRITE_FLUSH_SUPPORTED */
		950
		951	/* free all memory used by the write */
		952	void PNGAPI
		953	png_destroy_write_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)
		954	{
		955	png_structp png_ptr = NULL;
		956	png_infop info_ptr = NULL;
		957	#ifdef PNG_USER_MEM_SUPPORTED
		958	png_free_ptr free_fn = NULL;
		959	png_voidp mem_ptr = NULL;
		960	#endif
		961
		962	png_debug(1, "in png_destroy_write_struct\n");
		963	if (png_ptr_ptr != NULL)
		964	{
		965	png_ptr = *png_ptr_ptr;
		966	#ifdef PNG_USER_MEM_SUPPORTED
		967	free_fn = png_ptr->free_fn;
		968	mem_ptr = png_ptr->mem_ptr;
		969	#endif
		970	}
		971
		972	if (info_ptr_ptr != NULL)
		973	info_ptr = *info_ptr_ptr;
		974
		975	if (info_ptr != NULL)
		976	{
		977	png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
		978
		979	#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED)
		980	if (png_ptr->num_chunk_list)
		981	{
		982	png_free(png_ptr, png_ptr->chunk_list);
		983	png_ptr->chunk_list=NULL;
		984	png_ptr->num_chunk_list=0;
		985	}
		986	#endif
		987
		988	#ifdef PNG_USER_MEM_SUPPORTED
		989	png_destroy_struct_2((png_voidp)info_ptr, (png_free_ptr)free_fn,
		990	(png_voidp)mem_ptr);
		991	#else
		992	png_destroy_struct((png_voidp)info_ptr);
		993	#endif
		994	*info_ptr_ptr = NULL;
		995	}
		996
		997	if (png_ptr != NULL)
		998	{
		999	png_write_destroy(png_ptr);
		1000	#ifdef PNG_USER_MEM_SUPPORTED
		1001	png_destroy_struct_2((png_voidp)png_ptr, (png_free_ptr)free_fn,
		1002	(png_voidp)mem_ptr);
		1003	#else
		1004	png_destroy_struct((png_voidp)png_ptr);
		1005	#endif
		1006	*png_ptr_ptr = NULL;
		1007	}
		1008	}
		1009
		1010
		1011	/* Free any memory used in png_ptr struct (old method) */
		1012	void /* PRIVATE */
		1013	png_write_destroy(png_structp png_ptr)
		1014	{
		1015	#ifdef PNG_SETJMP_SUPPORTED
		1016	jmp_buf tmp_jmp; /* save jump buffer */
		1017	#endif
		1018	png_error_ptr error_fn;
		1019	png_error_ptr warning_fn;
		1020	png_voidp error_ptr;
		1021	#ifdef PNG_USER_MEM_SUPPORTED
		1022	png_free_ptr free_fn;
		1023	#endif
		1024
		1025	png_debug(1, "in png_write_destroy\n");
		1026	/* free any memory zlib uses */
		1027	deflateEnd(&png_ptr->zstream);
		1028
		1029	/* free our memory. png_free checks NULL for us. */
		1030	png_free(png_ptr, png_ptr->zbuf);
		1031	png_free(png_ptr, png_ptr->row_buf);
		1032	png_free(png_ptr, png_ptr->prev_row);
		1033	png_free(png_ptr, png_ptr->sub_row);
		1034	png_free(png_ptr, png_ptr->up_row);
		1035	png_free(png_ptr, png_ptr->avg_row);
		1036	png_free(png_ptr, png_ptr->paeth_row);
		1037
		1038	#if defined(PNG_TIME_RFC1123_SUPPORTED)
		1039	png_free(png_ptr, png_ptr->time_buffer);
		1040	#endif
		1041
		1042	#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED)
		1043	png_free(png_ptr, png_ptr->prev_filters);
		1044	png_free(png_ptr, png_ptr->filter_weights);
		1045	png_free(png_ptr, png_ptr->inv_filter_weights);
		1046	png_free(png_ptr, png_ptr->filter_costs);
		1047	png_free(png_ptr, png_ptr->inv_filter_costs);
		1048	#endif
		1049
		1050	#ifdef PNG_SETJMP_SUPPORTED
		1051	/* reset structure */
		1052	png_memcpy(tmp_jmp, png_ptr->jmpbuf, sizeof (jmp_buf));
		1053	#endif
		1054
		1055	error_fn = png_ptr->error_fn;
		1056	warning_fn = png_ptr->warning_fn;
		1057	error_ptr = png_ptr->error_ptr;
		1058	#ifdef PNG_USER_MEM_SUPPORTED
		1059	free_fn = png_ptr->free_fn;
		1060	#endif
		1061
		1062	png_memset(png_ptr, 0, sizeof (png_struct));
		1063
		1064	png_ptr->error_fn = error_fn;
		1065	png_ptr->warning_fn = warning_fn;
		1066	png_ptr->error_ptr = error_ptr;
		1067	#ifdef PNG_USER_MEM_SUPPORTED
		1068	png_ptr->free_fn = free_fn;
		1069	#endif
		1070
		1071	#ifdef PNG_SETJMP_SUPPORTED
		1072	png_memcpy(png_ptr->jmpbuf, tmp_jmp, sizeof (jmp_buf));
		1073	#endif
		1074	}
		1075
		1076	/* Allow the application to select one or more row filters to use. */
		1077	void PNGAPI
		1078	png_set_filter(png_structp png_ptr, int method, int filters)
		1079	{
		1080	png_debug(1, "in png_set_filter\n");
		1081	#if defined(PNG_MNG_FEATURES_SUPPORTED)
		1082	if((png_ptr->mng_features_permitted & PNG_FLAG_MNG_FILTER_64) &&
		1083	(method == PNG_INTRAPIXEL_DIFFERENCING))
		1084	method = PNG_FILTER_TYPE_BASE;
		1085	#endif
		1086	if (method == PNG_FILTER_TYPE_BASE)
		1087	{
		1088	switch (filters & (PNG_ALL_FILTERS \| 0x07))
		1089	{
		1090	case 5:
		1091	case 6:
		1092	case 7: png_warning(png_ptr, "Unknown row filter for method 0");
		1093	case PNG_FILTER_VALUE_NONE: png_ptr->do_filter=PNG_FILTER_NONE; break;
		1094	case PNG_FILTER_VALUE_SUB: png_ptr->do_filter=PNG_FILTER_SUB; break;
		1095	case PNG_FILTER_VALUE_UP: png_ptr->do_filter=PNG_FILTER_UP; break;
		1096	case PNG_FILTER_VALUE_AVG: png_ptr->do_filter=PNG_FILTER_AVG; break;
		1097	case PNG_FILTER_VALUE_PAETH: png_ptr->do_filter=PNG_FILTER_PAETH;break;
		1098	default: png_ptr->do_filter = (png_byte)filters; break;
		1099	}
		1100
		1101	/* If we have allocated the row_buf, this means we have already started
		1102	* with the image and we should have allocated all of the filter buffers
		1103	* that have been selected. If prev_row isn't already allocated, then
		1104	* it is too late to start using the filters that need it, since we
		1105	* will be missing the data in the previous row. If an application
		1106	* wants to start and stop using particular filters during compression,
		1107	* it should start out with all of the filters, and then add and
		1108	* remove them after the start of compression.
		1109	*/
		1110	if (png_ptr->row_buf != NULL)
		1111	{
		1112	if ((png_ptr->do_filter & PNG_FILTER_SUB) && png_ptr->sub_row == NULL)
		1113	{
		1114	png_ptr->sub_row = (png_bytep)png_malloc(png_ptr,
		1115	(png_ptr->rowbytes + 1));
		1116	png_ptr->sub_row[0] = PNG_FILTER_VALUE_SUB;
		1117	}
		1118
		1119	if ((png_ptr->do_filter & PNG_FILTER_UP) && png_ptr->up_row == NULL)
		1120	{
		1121	if (png_ptr->prev_row == NULL)
		1122	{
		1123	png_warning(png_ptr, "Can't add Up filter after starting");
		1124	png_ptr->do_filter &= ~PNG_FILTER_UP;
		1125	}
		1126	else
		1127	{
		1128	png_ptr->up_row = (png_bytep)png_malloc(png_ptr,
		1129	(png_ptr->rowbytes + 1));
		1130	png_ptr->up_row[0] = PNG_FILTER_VALUE_UP;
		1131	}
		1132	}
		1133
		1134	if ((png_ptr->do_filter & PNG_FILTER_AVG) && png_ptr->avg_row == NULL)
		1135	{
		1136	if (png_ptr->prev_row == NULL)
		1137	{
		1138	png_warning(png_ptr, "Can't add Average filter after starting");
		1139	png_ptr->do_filter &= ~PNG_FILTER_AVG;
		1140	}
		1141	else
		1142	{
		1143	png_ptr->avg_row = (png_bytep)png_malloc(png_ptr,
		1144	(png_ptr->rowbytes + 1));
		1145	png_ptr->avg_row[0] = PNG_FILTER_VALUE_AVG;
		1146	}
		1147	}
		1148
		1149	if ((png_ptr->do_filter & PNG_FILTER_PAETH) &&
		1150	png_ptr->paeth_row == NULL)
		1151	{
		1152	if (png_ptr->prev_row == NULL)
		1153	{
		1154	png_warning(png_ptr, "Can't add Paeth filter after starting");
		1155	png_ptr->do_filter &= (png_byte)(~PNG_FILTER_PAETH);
		1156	}
		1157	else
		1158	{
		1159	png_ptr->paeth_row = (png_bytep)png_malloc(png_ptr,
		1160	(png_ptr->rowbytes + 1));
		1161	png_ptr->paeth_row[0] = PNG_FILTER_VALUE_PAETH;
		1162	}
		1163	}
		1164
		1165	if (png_ptr->do_filter == PNG_NO_FILTERS)
		1166	png_ptr->do_filter = PNG_FILTER_NONE;
		1167	}
		1168	}
		1169	else
		1170	png_error(png_ptr, "Unknown custom filter method");
		1171	}
		1172
		1173	/* This allows us to influence the way in which libpng chooses the "best"
		1174	* filter for the current scanline. While the "minimum-sum-of-absolute-
		1175	* differences metric is relatively fast and effective, there is some
		1176	* question as to whether it can be improved upon by trying to keep the
		1177	* filtered data going to zlib more consistent, hopefully resulting in
		1178	* better compression.
		1179	*/
		1180	#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* GRR 970116 */
		1181	void PNGAPI
		1182	png_set_filter_heuristics(png_structp png_ptr, int heuristic_method,
		1183	int num_weights, png_doublep filter_weights,
		1184	png_doublep filter_costs)
		1185	{
		1186	int i;
		1187
		1188	png_debug(1, "in png_set_filter_heuristics\n");
		1189	if (heuristic_method >= PNG_FILTER_HEURISTIC_LAST)
		1190	{
		1191	png_warning(png_ptr, "Unknown filter heuristic method");
		1192	return;
		1193	}
		1194
		1195	if (heuristic_method == PNG_FILTER_HEURISTIC_DEFAULT)
		1196	{
		1197	heuristic_method = PNG_FILTER_HEURISTIC_UNWEIGHTED;
		1198	}
		1199
		1200	if (num_weights < 0 \|\| filter_weights == NULL \|\|
		1201	heuristic_method == PNG_FILTER_HEURISTIC_UNWEIGHTED)
		1202	{
		1203	num_weights = 0;
		1204	}
		1205
		1206	png_ptr->num_prev_filters = (png_byte)num_weights;
		1207	png_ptr->heuristic_method = (png_byte)heuristic_method;
		1208
		1209	if (num_weights > 0)
		1210	{
		1211	if (png_ptr->prev_filters == NULL)
		1212	{
		1213	png_ptr->prev_filters = (png_bytep)png_malloc(png_ptr,
		1214	(png_uint_32)(sizeof(png_byte) * num_weights));
		1215
		1216	/* To make sure that the weighting starts out fairly */
		1217	for (i = 0; i < num_weights; i++)
		1218	{
		1219	png_ptr->prev_filters[i] = 255;
		1220	}
		1221	}
		1222
		1223	if (png_ptr->filter_weights == NULL)
		1224	{
		1225	png_ptr->filter_weights = (png_uint_16p)png_malloc(png_ptr,
		1226	(png_uint_32)(sizeof(png_uint_16) * num_weights));
		1227
		1228	png_ptr->inv_filter_weights = (png_uint_16p)png_malloc(png_ptr,
		1229	(png_uint_32)(sizeof(png_uint_16) * num_weights));
		1230	for (i = 0; i < num_weights; i++)
		1231	{
		1232	png_ptr->inv_filter_weights[i] =
		1233	png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
		1234	}
		1235	}
		1236
		1237	for (i = 0; i < num_weights; i++)
		1238	{
		1239	if (filter_weights[i] < 0.0)
		1240	{
		1241	png_ptr->inv_filter_weights[i] =
		1242	png_ptr->filter_weights[i] = PNG_WEIGHT_FACTOR;
		1243	}
		1244	else
		1245	{
		1246	png_ptr->inv_filter_weights[i] =
		1247	(png_uint_16)((double)PNG_WEIGHT_FACTOR*filter_weights[i]+0.5);
		1248	png_ptr->filter_weights[i] =
		1249	(png_uint_16)((double)PNG_WEIGHT_FACTOR/filter_weights[i]+0.5);
		1250	}
		1251	}
		1252	}
		1253
		1254	/* If, in the future, there are other filter methods, this would
		1255	* need to be based on png_ptr->filter.
		1256	*/
		1257	if (png_ptr->filter_costs == NULL)
		1258	{
		1259	png_ptr->filter_costs = (png_uint_16p)png_malloc(png_ptr,
		1260	(png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
		1261
		1262	png_ptr->inv_filter_costs = (png_uint_16p)png_malloc(png_ptr,
		1263	(png_uint_32)(sizeof(png_uint_16) * PNG_FILTER_VALUE_LAST));
		1264
		1265	for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
		1266	{
		1267	png_ptr->inv_filter_costs[i] =
		1268	png_ptr->filter_costs[i] = PNG_COST_FACTOR;
		1269	}
		1270	}
		1271
		1272	/* Here is where we set the relative costs of the different filters. We
		1273	* should take the desired compression level into account when setting
		1274	* the costs, so that Paeth, for instance, has a high relative cost at low
		1275	* compression levels, while it has a lower relative cost at higher
		1276	* compression settings. The filter types are in order of increasing
		1277	* relative cost, so it would be possible to do this with an algorithm.
		1278	*/
		1279	for (i = 0; i < PNG_FILTER_VALUE_LAST; i++)
		1280	{
		1281	if (filter_costs == NULL \|\| filter_costs[i] < 0.0)
		1282	{
		1283	png_ptr->inv_filter_costs[i] =
		1284	png_ptr->filter_costs[i] = PNG_COST_FACTOR;
		1285	}
		1286	else if (filter_costs[i] >= 1.0)
		1287	{
		1288	png_ptr->inv_filter_costs[i] =
		1289	(png_uint_16)((double)PNG_COST_FACTOR / filter_costs[i] + 0.5);
		1290	png_ptr->filter_costs[i] =
		1291	(png_uint_16)((double)PNG_COST_FACTOR * filter_costs[i] + 0.5);
		1292	}
		1293	}
		1294	}
		1295	#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */
		1296
		1297	void PNGAPI
		1298	png_set_compression_level(png_structp png_ptr, int level)
		1299	{
		1300	png_debug(1, "in png_set_compression_level\n");
		1301	png_ptr->flags \|= PNG_FLAG_ZLIB_CUSTOM_LEVEL;
		1302	png_ptr->zlib_level = level;
		1303	}
		1304
		1305	void PNGAPI
		1306	png_set_compression_mem_level(png_structp png_ptr, int mem_level)
		1307	{
		1308	png_debug(1, "in png_set_compression_mem_level\n");
		1309	png_ptr->flags \|= PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL;
		1310	png_ptr->zlib_mem_level = mem_level;
		1311	}
		1312
		1313	void PNGAPI
		1314	png_set_compression_strategy(png_structp png_ptr, int strategy)
		1315	{
		1316	png_debug(1, "in png_set_compression_strategy\n");
		1317	png_ptr->flags \|= PNG_FLAG_ZLIB_CUSTOM_STRATEGY;
		1318	png_ptr->zlib_strategy = strategy;
		1319	}
		1320
		1321	void PNGAPI
		1322	png_set_compression_window_bits(png_structp png_ptr, int window_bits)
		1323	{
		1324	if (window_bits > 15)
		1325	png_warning(png_ptr, "Only compression windows <= 32k supported by PNG");
		1326	else if (window_bits < 8)
		1327	png_warning(png_ptr, "Only compression windows >= 256 supported by PNG");
		1328	#ifndef WBITS_8_OK
		1329	/* avoid libpng bug with 256-byte windows */
		1330	if (window_bits == 8)
		1331	{
		1332	png_warning(png_ptr, "Compression window is being reset to 512");
		1333	window_bits=9;
		1334	}
		1335	#endif
		1336	png_ptr->flags \|= PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS;
		1337	png_ptr->zlib_window_bits = window_bits;
		1338	}
		1339
		1340	void PNGAPI
		1341	png_set_compression_method(png_structp png_ptr, int method)
		1342	{
		1343	png_debug(1, "in png_set_compression_method\n");
		1344	if (method != 8)
		1345	png_warning(png_ptr, "Only compression method 8 is supported by PNG");
		1346	png_ptr->flags \|= PNG_FLAG_ZLIB_CUSTOM_METHOD;
		1347	png_ptr->zlib_method = method;
		1348	}
		1349
		1350	void PNGAPI
		1351	png_set_write_status_fn(png_structp png_ptr, png_write_status_ptr write_row_fn)
		1352	{
		1353	png_ptr->write_row_fn = write_row_fn;
		1354	}
		1355
		1356	#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED)
		1357	void PNGAPI
		1358	png_set_write_user_transform_fn(png_structp png_ptr, png_user_transform_ptr
		1359	write_user_transform_fn)
		1360	{
		1361	png_debug(1, "in png_set_write_user_transform_fn\n");
		1362	png_ptr->transformations \|= PNG_USER_TRANSFORM;
		1363	png_ptr->write_user_transform_fn = write_user_transform_fn;
		1364	}
		1365	#endif
		1366
		1367
		1368	#if defined(PNG_INFO_IMAGE_SUPPORTED)
		1369	void PNGAPI
		1370	png_write_png(png_structp png_ptr, png_infop info_ptr,
		1371	int transforms, voidp params)
		1372	{
		1373	#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED)
		1374	/* invert the alpha channel from opacity to transparency */
		1375	if (transforms & PNG_TRANSFORM_INVERT_ALPHA)
		1376	png_set_invert_alpha(png_ptr);
		1377	#endif
		1378
		1379	/* Write the file header information. */
		1380	png_write_info(png_ptr, info_ptr);
		1381
		1382	/* ------ these transformations don't touch the info structure ------- */
		1383
		1384	#if defined(PNG_WRITE_INVERT_SUPPORTED)
		1385	/* invert monochrome pixels */
		1386	if (transforms & PNG_TRANSFORM_INVERT_MONO)
		1387	png_set_invert_mono(png_ptr);
		1388	#endif
		1389
		1390	#if defined(PNG_WRITE_SHIFT_SUPPORTED)
		1391	/* Shift the pixels up to a legal bit depth and fill in
		1392	* as appropriate to correctly scale the image.
		1393	*/
		1394	if ((transforms & PNG_TRANSFORM_SHIFT)
		1395	&& (info_ptr->valid & PNG_INFO_sBIT))
		1396	png_set_shift(png_ptr, &info_ptr->sig_bit);
		1397	#endif
		1398
		1399	#if defined(PNG_WRITE_PACK_SUPPORTED)
		1400	/* pack pixels into bytes */
		1401	if (transforms & PNG_TRANSFORM_PACKING)
		1402	png_set_packing(png_ptr);
		1403	#endif
		1404
		1405	#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED)
		1406	/* swap location of alpha bytes from ARGB to RGBA */
		1407	if (transforms & PNG_TRANSFORM_SWAP_ALPHA)
		1408	png_set_swap_alpha(png_ptr);
		1409	#endif
		1410
		1411	#if defined(PNG_WRITE_FILLER_SUPPORTED)
		1412	/* Get rid of filler (OR ALPHA) bytes, pack XRGB/RGBX/ARGB/RGBA into
		1413	* RGB (4 channels -> 3 channels). The second parameter is not used.
		1414	*/
		1415	if (transforms & PNG_TRANSFORM_STRIP_FILLER)
		1416	png_set_filler(png_ptr, 0, PNG_FILLER_BEFORE);
		1417	#endif
		1418
		1419	#if defined(PNG_WRITE_BGR_SUPPORTED)
		1420	/* flip BGR pixels to RGB */
		1421	if (transforms & PNG_TRANSFORM_BGR)
		1422	png_set_bgr(png_ptr);
		1423	#endif
		1424
		1425	#if defined(PNG_WRITE_SWAP_SUPPORTED)
		1426	/* swap bytes of 16-bit files to most significant byte first */
		1427	if (transforms & PNG_TRANSFORM_SWAP_ENDIAN)
		1428	png_set_swap(png_ptr);
		1429	#endif
		1430
		1431	#if defined(PNG_WRITE_PACKSWAP_SUPPORTED)
		1432	/* swap bits of 1, 2, 4 bit packed pixel formats */
		1433	if (transforms & PNG_TRANSFORM_PACKSWAP)
		1434	png_set_packswap(png_ptr);
		1435	#endif
		1436
		1437	/* ----------------------- end of transformations ------------------- */
		1438
		1439	/* write the bits */
		1440	if (info_ptr->valid & PNG_INFO_IDAT)
		1441	png_write_image(png_ptr, info_ptr->row_pointers);
		1442
		1443	/* It is REQUIRED to call this to finish writing the rest of the file */
		1444	png_write_end(png_ptr, info_ptr);
		1445
		1446	if(transforms == 0 \|\| params == NULL)
		1447	/* quiet compiler warnings */ return;
		1448	}
		1449	#endif
		1450	#endif /* PNG_WRITE_SUPPORTED */

Subversion Repositories shark

(root)/shark/tags/rel_1_2/ports/png/pngwrite.c @ 378 - Rev 294