[pcsx_rearmed.git] / deps / libretro-common / formats / png / rpng_encode.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (rpng_encode.c).
 * ---------------------------------------------------------------------------------------
 *
 * Permission is hereby granted, free of charge,
 * to any person obtaining a copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libretro.h>
#include <encodings/crc32.h>
#include <streams/interface_stream.h>
#include <streams/trans_stream.h>

#include "rpng_internal.h"

#undef GOTO_END_ERROR
#define GOTO_END_ERROR() do { \
   fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__); \
   ret = false; \
   goto end; \
} while (0)

double DEFLATE_PADDING = 1.1;
int PNG_ROUGH_HEADER = 100;

static void dword_write_be(uint8_t *buf, uint32_t val)
{
   *buf++ = (uint8_t)(val >> 24);
   *buf++ = (uint8_t)(val >> 16);
   *buf++ = (uint8_t)(val >>  8);
   *buf++ = (uint8_t)(val >>  0);
}

static bool png_write_crc_string(intfstream_t *intf_s, const uint8_t *data, size_t size)
{
   uint8_t crc_raw[4] = {0};
   uint32_t crc       = encoding_crc32(0, data, size);

   dword_write_be(crc_raw, crc);
   return intfstream_write(intf_s, crc_raw, sizeof(crc_raw)) == sizeof(crc_raw);
}

static bool png_write_ihdr_string(intfstream_t *intf_s, const struct png_ihdr *ihdr)
{
   uint8_t ihdr_raw[21];

   ihdr_raw[0]  = '0';                 /* Size */
   ihdr_raw[1]  = '0';
   ihdr_raw[2]  = '0';
   ihdr_raw[3]  = '0';
   ihdr_raw[4]  = 'I';
   ihdr_raw[5]  = 'H';
   ihdr_raw[6]  = 'D';
   ihdr_raw[7]  = 'R';
   ihdr_raw[8]  =   0;                 /* Width */
   ihdr_raw[9]  =   0;
   ihdr_raw[10] =   0;
   ihdr_raw[11] =   0;
   ihdr_raw[12] =   0;                 /* Height */
   ihdr_raw[13] =   0;
   ihdr_raw[14] =   0;
   ihdr_raw[15] =   0;
   ihdr_raw[16] =   ihdr->depth;       /* Depth */
   ihdr_raw[17] =   ihdr->color_type;
   ihdr_raw[18] =   ihdr->compression;
   ihdr_raw[19] =   ihdr->filter;
   ihdr_raw[20] =   ihdr->interlace;

   dword_write_be(ihdr_raw +  0, sizeof(ihdr_raw) - 8);
   dword_write_be(ihdr_raw +  8, ihdr->width);
   dword_write_be(ihdr_raw + 12, ihdr->height);
   if (intfstream_write(intf_s, ihdr_raw, sizeof(ihdr_raw)) != sizeof(ihdr_raw))
      return false;

   return png_write_crc_string(intf_s, ihdr_raw + sizeof(uint32_t),
         sizeof(ihdr_raw) - sizeof(uint32_t));
}

static bool png_write_idat_string(intfstream_t* intf_s, const uint8_t *data, size_t size)
{
   if (intfstream_write(intf_s, data, size) != (ssize_t)size)
      return false;

   return png_write_crc_string(intf_s, data + sizeof(uint32_t), size - sizeof(uint32_t));
}

static bool png_write_iend_string(intfstream_t* intf_s)
{
   const uint8_t data[] = {
      0, 0, 0, 0,
      'I', 'E', 'N', 'D',
   };

   if (intfstream_write(intf_s, data, sizeof(data)) != sizeof(data))
      return false;

   return png_write_crc_string(intf_s, data + sizeof(uint32_t),
         sizeof(data) - sizeof(uint32_t));
}

static void copy_argb_line(uint8_t *dst, const uint32_t *src, unsigned width)
{
   unsigned i;
   for (i = 0; i < width; i++)
   {
      uint32_t col = src[i];
      *dst++ = (uint8_t)(col >> 16);
      *dst++ = (uint8_t)(col >>  8);
      *dst++ = (uint8_t)(col >>  0);
      *dst++ = (uint8_t)(col >> 24);
   }
}

static void copy_bgr24_line(uint8_t *dst, const uint8_t *src, unsigned width)
{
   unsigned i;
   for (i = 0; i < width; i++, dst += 3, src += 3)
   {
      dst[2] = src[0];
      dst[1] = src[1];
      dst[0] = src[2];
   }
}

static unsigned count_sad(const uint8_t *data, size_t size)
{
   size_t i;
   unsigned cnt = 0;
   for (i = 0; i < size; i++)
   {
      if (data[i])
         cnt += abs((int8_t)data[i]);
   }
   return cnt;
}

static unsigned filter_up(uint8_t *target, const uint8_t *line,
      const uint8_t *prev, unsigned width, unsigned bpp)
{
   unsigned i;
   width *= bpp;
   for (i = 0; i < width; i++)
      target[i] = line[i] - prev[i];

   return count_sad(target, width);
}

static unsigned filter_sub(uint8_t *target, const uint8_t *line,
      unsigned width, unsigned bpp)
{
   unsigned i;
   width *= bpp;
   for (i = 0; i < bpp; i++)
      target[i] = line[i];
   for (i = bpp; i < width; i++)
      target[i] = line[i] - line[i - bpp];

   return count_sad(target, width);
}

static unsigned filter_avg(uint8_t *target, const uint8_t *line,
      const uint8_t *prev, unsigned width, unsigned bpp)
{
   unsigned i;
   width *= bpp;
   for (i = 0; i < bpp; i++)
      target[i] = line[i] - (prev[i] >> 1);
   for (i = bpp; i < width; i++)
      target[i] = line[i] - ((line[i - bpp] + prev[i]) >> 1);

   return count_sad(target, width);
}

static unsigned filter_paeth(uint8_t *target,
      const uint8_t *line, const uint8_t *prev,
      unsigned width, unsigned bpp)
{
   unsigned i;
   width *= bpp;
   for (i = 0; i < bpp; i++)
      target[i] = line[i] - paeth(0, prev[i], 0);
   for (i = bpp; i < width; i++)
      target[i] = line[i] - paeth(line[i - bpp], prev[i], prev[i - bpp]);

   return count_sad(target, width);
}

bool rpng_save_image_stream(const uint8_t *data, intfstream_t* intf_s,
      unsigned width, unsigned height, signed pitch, unsigned bpp)
{
   unsigned h;
   struct png_ihdr ihdr = {0};
   bool ret = true;
   const struct trans_stream_backend *stream_backend = NULL;
   size_t encode_buf_size  = 0;
   uint8_t *encode_buf     = NULL;
   uint8_t *deflate_buf    = NULL;
   uint8_t *rgba_line      = NULL;
   uint8_t *up_filtered    = NULL;
   uint8_t *sub_filtered   = NULL;
   uint8_t *avg_filtered   = NULL;
   uint8_t *paeth_filtered = NULL;
   uint8_t *prev_encoded   = NULL;
   uint8_t *encode_target  = NULL;
   void *stream            = NULL;
   uint32_t total_in       = 0;
   uint32_t total_out      = 0;
   
   if (!intf_s)
      GOTO_END_ERROR();

   stream_backend = trans_stream_get_zlib_deflate_backend();

   if (intfstream_write(intf_s, png_magic, sizeof(png_magic)) != sizeof(png_magic))
      GOTO_END_ERROR();

   ihdr.width = width;
   ihdr.height = height;
   ihdr.depth = 8;
   ihdr.color_type = bpp == sizeof(uint32_t) ? 6 : 2; /* RGBA or RGB */
   if (!png_write_ihdr_string(intf_s, &ihdr))
      GOTO_END_ERROR();

   encode_buf_size = (width * bpp + 1) * height;
   encode_buf      = (uint8_t*)malloc(encode_buf_size);
   if (!encode_buf)
      GOTO_END_ERROR();

   prev_encoded = (uint8_t*)calloc(1, width * bpp);
   if (!prev_encoded)
      GOTO_END_ERROR();

   rgba_line      = (uint8_t*)malloc(width * bpp);
   up_filtered    = (uint8_t*)malloc(width * bpp);
   sub_filtered   = (uint8_t*)malloc(width * bpp);
   avg_filtered   = (uint8_t*)malloc(width * bpp);
   paeth_filtered = (uint8_t*)malloc(width * bpp);
   if (!rgba_line || !up_filtered || !sub_filtered || !avg_filtered || !paeth_filtered)
      GOTO_END_ERROR();

   encode_target = encode_buf;
   for (h = 0; h < height;
         h++, encode_target += width * bpp, data += pitch)
   {
      if (bpp == sizeof(uint32_t))
         copy_argb_line(rgba_line, (const uint32_t*)data, width);
      else
         copy_bgr24_line(rgba_line, data, width);

      /* Try every filtering method, and choose the method
       * which has most entries as zero.
       *
       * This is probably not very optimal, but it's very
       * simple to implement.
       */
      {
         unsigned none_score  = count_sad(rgba_line, width * bpp);
         unsigned up_score    = filter_up(up_filtered, rgba_line, prev_encoded, width, bpp);
         unsigned sub_score   = filter_sub(sub_filtered, rgba_line, width, bpp);
         unsigned avg_score   = filter_avg(avg_filtered, rgba_line, prev_encoded, width, bpp);
         unsigned paeth_score = filter_paeth(paeth_filtered, rgba_line, prev_encoded, width, bpp);

         uint8_t filter       = 0;
         unsigned min_sad     = none_score;
         const uint8_t *chosen_filtered = rgba_line;

         if (sub_score < min_sad)
         {
            filter = 1;
            chosen_filtered = sub_filtered;
            min_sad = sub_score;
         }

         if (up_score < min_sad)
         {
            filter = 2;
            chosen_filtered = up_filtered;
            min_sad = up_score;
         }

         if (avg_score < min_sad)
         {
            filter = 3;
            chosen_filtered = avg_filtered;
            min_sad = avg_score;
         }

         if (paeth_score < min_sad)
         {
            filter = 4;
            chosen_filtered = paeth_filtered;
         }

         *encode_target++ = filter;
         memcpy(encode_target, chosen_filtered, width * bpp);

         memcpy(prev_encoded, rgba_line, width * bpp);
      }
   }

   deflate_buf = (uint8_t*)malloc(encode_buf_size * 2); /* Just to be sure. */
   if (!deflate_buf)
      GOTO_END_ERROR();

   stream = stream_backend->stream_new();

   if (!stream)
      GOTO_END_ERROR();

   stream_backend->set_in(
         stream,
         encode_buf,
         (unsigned)encode_buf_size);
   stream_backend->set_out(
         stream,
         deflate_buf + 8,
         (unsigned)(encode_buf_size * 2));

   if (!stream_backend->trans(stream, true, &total_in, &total_out, NULL))
      GOTO_END_ERROR();

   memcpy(deflate_buf + 4, "IDAT", 4);
   dword_write_be(deflate_buf + 0,        ((uint32_t)total_out));
   if (!png_write_idat_string(intf_s, deflate_buf, ((size_t)total_out + 8)))
      GOTO_END_ERROR();

   if (!png_write_iend_string(intf_s))
      GOTO_END_ERROR();
end:
   free(encode_buf);
   free(deflate_buf);
   free(rgba_line);
   free(prev_encoded);
   free(up_filtered);
   free(sub_filtered);
   free(avg_filtered);
   free(paeth_filtered);

   if (stream_backend)
   {
      if (stream)
      {
         if (stream_backend->stream_free)
            stream_backend->stream_free(stream);
      }
   }
   return ret;
}

bool rpng_save_image_argb(const char *path, const uint32_t *data,
      unsigned width, unsigned height, unsigned pitch)
{
   bool ret                      = false;
   intfstream_t* intf_s          = NULL;
   
   intf_s = intfstream_open_file(path, 
         RETRO_VFS_FILE_ACCESS_WRITE,
         RETRO_VFS_FILE_ACCESS_HINT_NONE);

   ret = rpng_save_image_stream((const uint8_t*) data, intf_s,
                                width, height,
                                (signed) pitch, sizeof(uint32_t));
   intfstream_close(intf_s);
   free(intf_s);
   return ret;
}

bool rpng_save_image_bgr24(const char *path, const uint8_t *data,
      unsigned width, unsigned height, unsigned pitch)
{
   bool ret                      = false;
   intfstream_t* intf_s          = NULL;
   
   intf_s = intfstream_open_file(path, 
         RETRO_VFS_FILE_ACCESS_WRITE,
         RETRO_VFS_FILE_ACCESS_HINT_NONE);
   ret = rpng_save_image_stream(data, intf_s, width, height, 
                                (signed) pitch, 3);
   intfstream_close(intf_s);
   free(intf_s);
   return ret;
}


uint8_t* rpng_save_image_bgr24_string(const uint8_t *data,
      unsigned width, unsigned height, signed pitch, uint64_t* bytes)
{
   bool ret                    = false;
   uint8_t* buf                = NULL;
   uint8_t* output             = NULL;
   int buf_length              = 0;
   intfstream_t* intf_s        = NULL;

   buf_length = (int)(width*height*3*DEFLATE_PADDING)+PNG_ROUGH_HEADER;
   buf        = (uint8_t*)malloc(buf_length*sizeof(uint8_t));
   if (!buf)
      GOTO_END_ERROR(); 

   intf_s = intfstream_open_writable_memory(buf, 
         RETRO_VFS_FILE_ACCESS_WRITE,
         RETRO_VFS_FILE_ACCESS_HINT_NONE,
         buf_length);

   ret = rpng_save_image_stream((const uint8_t*)data, 
            intf_s, width, height, pitch, 3);

   *bytes = intfstream_get_ptr(intf_s);
   intfstream_rewind(intf_s);
   output = (uint8_t*)malloc((size_t)((*bytes)*sizeof(uint8_t)));
   if (!output)
      GOTO_END_ERROR();
   intfstream_read(intf_s, output, *bytes);

end:
   if (buf)
      free(buf);
   if (intf_s)
   {
      intfstream_close(intf_s);
      free(intf_s);
   }
   if (ret == false)
   {
      if (output)
         free(output);
      return NULL;
   }
   return output;
}
Commit	Line	Data
3719602c PC	1	/* Copyright (C) 2010-2020 The RetroArch team
	2	*
	3	* ---------------------------------------------------------------------------------------
	4	* The following license statement only applies to this file (rpng_encode.c).
	5	* ---------------------------------------------------------------------------------------
	6	*
	7	* Permission is hereby granted, free of charge,
	8	* to any person obtaining a copy of this software and associated documentation files (the "Software"),
	9	* to deal in the Software without restriction, including without limitation the rights to
	10	* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
	11	* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
	14	*
	15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
	16	* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	18	* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
	19	* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	20	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
	21	*/
	22
	23	#include <stdio.h>
	24	#include <stdlib.h>
	25	#include <string.h>
	26
	27	#include <libretro.h>
	28	#include <encodings/crc32.h>
	29	#include <streams/interface_stream.h>
	30	#include <streams/trans_stream.h>
	31
	32	#include "rpng_internal.h"
	33
	34	#undef GOTO_END_ERROR
	35	#define GOTO_END_ERROR() do { \
	36	fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__); \
	37	ret = false; \
	38	goto end; \
	39	} while (0)
	40
	41	double DEFLATE_PADDING = 1.1;
	42	int PNG_ROUGH_HEADER = 100;
	43
	44	static void dword_write_be(uint8_t *buf, uint32_t val)
	45	{
	46	*buf++ = (uint8_t)(val >> 24);
	47	*buf++ = (uint8_t)(val >> 16);
	48	*buf++ = (uint8_t)(val >> 8);
	49	*buf++ = (uint8_t)(val >> 0);
	50	}
	51
	52	static bool png_write_crc_string(intfstream_t intf_s, const uint8_t data, size_t size)
	53	{
	54	uint8_t crc_raw[4] = {0};
	55	uint32_t crc = encoding_crc32(0, data, size);
	56
	57	dword_write_be(crc_raw, crc);
	58	return intfstream_write(intf_s, crc_raw, sizeof(crc_raw)) == sizeof(crc_raw);
	59	}
	60
	61	static bool png_write_ihdr_string(intfstream_t intf_s, const struct png_ihdr ihdr)
	62	{
	63	uint8_t ihdr_raw[21];
	64
65	ihdr_raw[0] = '0'; /* Size */
66	ihdr_raw[1] = '0';
67	ihdr_raw[2] = '0';
68	ihdr_raw[3] = '0';
69	ihdr_raw[4] = 'I';
70	ihdr_raw[5] = 'H';
71	ihdr_raw[6] = 'D';
72	ihdr_raw[7] = 'R';
73	ihdr_raw[8] = 0; /* Width */
74	ihdr_raw[9] = 0;
75	ihdr_raw[10] = 0;
76	ihdr_raw[11] = 0;
77	ihdr_raw[12] = 0; /* Height */
78	ihdr_raw[13] = 0;
79	ihdr_raw[14] = 0;
80	ihdr_raw[15] = 0;
81	ihdr_raw[16] = ihdr->depth; /* Depth */
82	ihdr_raw[17] = ihdr->color_type;
83	ihdr_raw[18] = ihdr->compression;
84	ihdr_raw[19] = ihdr->filter;
85	ihdr_raw[20] = ihdr->interlace;
86
87	dword_write_be(ihdr_raw + 0, sizeof(ihdr_raw) - 8);
88	dword_write_be(ihdr_raw + 8, ihdr->width);
89	dword_write_be(ihdr_raw + 12, ihdr->height);
90	if (intfstream_write(intf_s, ihdr_raw, sizeof(ihdr_raw)) != sizeof(ihdr_raw))
91	return false;
92
93	return png_write_crc_string(intf_s, ihdr_raw + sizeof(uint32_t),
94	sizeof(ihdr_raw) - sizeof(uint32_t));
95	}
96
97	static bool png_write_idat_string(intfstream_t* intf_s, const uint8_t *data, size_t size)
98	{
99	if (intfstream_write(intf_s, data, size) != (ssize_t)size)
100	return false;
101
102	return png_write_crc_string(intf_s, data + sizeof(uint32_t), size - sizeof(uint32_t));
103	}
104
105	static bool png_write_iend_string(intfstream_t* intf_s)
106	{
107	const uint8_t data[] = {
108	0, 0, 0, 0,
109	'I', 'E', 'N', 'D',
110	};
111
112	if (intfstream_write(intf_s, data, sizeof(data)) != sizeof(data))
113	return false;
114
115	return png_write_crc_string(intf_s, data + sizeof(uint32_t),
116	sizeof(data) - sizeof(uint32_t));
117	}
118
119	static void copy_argb_line(uint8_t dst, const uint32_t src, unsigned width)
120	{
121	unsigned i;
122	for (i = 0; i < width; i++)
123	{
124	uint32_t col = src[i];
125	*dst++ = (uint8_t)(col >> 16);
126	*dst++ = (uint8_t)(col >> 8);
127	*dst++ = (uint8_t)(col >> 0);
128	*dst++ = (uint8_t)(col >> 24);
129	}
130	}
131
132	static void copy_bgr24_line(uint8_t dst, const uint8_t src, unsigned width)
133	{
134	unsigned i;
135	for (i = 0; i < width; i++, dst += 3, src += 3)
136	{
137	dst[2] = src[0];
138	dst[1] = src[1];
139	dst[0] = src[2];
140	}
141	}
142
143	static unsigned count_sad(const uint8_t *data, size_t size)
144	{
145	size_t i;
146	unsigned cnt = 0;
147	for (i = 0; i < size; i++)
148	{
149	if (data[i])
150	cnt += abs((int8_t)data[i]);
151	}
152	return cnt;
153	}
154
155	static unsigned filter_up(uint8_t target, const uint8_t line,
156	const uint8_t *prev, unsigned width, unsigned bpp)
157	{
158	unsigned i;
159	width *= bpp;
160	for (i = 0; i < width; i++)
161	target[i] = line[i] - prev[i];
162
163	return count_sad(target, width);
164	}
165
166	static unsigned filter_sub(uint8_t target, const uint8_t line,
167	unsigned width, unsigned bpp)
168	{
169	unsigned i;
170	width *= bpp;
171	for (i = 0; i < bpp; i++)
172	target[i] = line[i];
173	for (i = bpp; i < width; i++)
174	target[i] = line[i] - line[i - bpp];
175
176	return count_sad(target, width);
177	}
178
179	static unsigned filter_avg(uint8_t target, const uint8_t line,
180	const uint8_t *prev, unsigned width, unsigned bpp)
181	{
182	unsigned i;
183	width *= bpp;
184	for (i = 0; i < bpp; i++)
185	target[i] = line[i] - (prev[i] >> 1);
186	for (i = bpp; i < width; i++)
187	target[i] = line[i] - ((line[i - bpp] + prev[i]) >> 1);
188
189	return count_sad(target, width);
190	}
191
192	static unsigned filter_paeth(uint8_t *target,
193	const uint8_t line, const uint8_t prev,
194	unsigned width, unsigned bpp)
195	{
196	unsigned i;
197	width *= bpp;
198	for (i = 0; i < bpp; i++)
199	target[i] = line[i] - paeth(0, prev[i], 0);
200	for (i = bpp; i < width; i++)
201	target[i] = line[i] - paeth(line[i - bpp], prev[i], prev[i - bpp]);
202
203	return count_sad(target, width);
204	}
205
206	bool rpng_save_image_stream(const uint8_t data, intfstream_t intf_s,
207	unsigned width, unsigned height, signed pitch, unsigned bpp)
208	{
209	unsigned h;
210	struct png_ihdr ihdr = {0};
211	bool ret = true;
212	const struct trans_stream_backend *stream_backend = NULL;
213	size_t encode_buf_size = 0;
214	uint8_t *encode_buf = NULL;
215	uint8_t *deflate_buf = NULL;
216	uint8_t *rgba_line = NULL;
217	uint8_t *up_filtered = NULL;
218	uint8_t *sub_filtered = NULL;
219	uint8_t *avg_filtered = NULL;
220	uint8_t *paeth_filtered = NULL;
221	uint8_t *prev_encoded = NULL;
222	uint8_t *encode_target = NULL;
223	void *stream = NULL;
224	uint32_t total_in = 0;
225	uint32_t total_out = 0;
226
227	if (!intf_s)
228	GOTO_END_ERROR();
229
230	stream_backend = trans_stream_get_zlib_deflate_backend();
231
232	if (intfstream_write(intf_s, png_magic, sizeof(png_magic)) != sizeof(png_magic))
233	GOTO_END_ERROR();
234
235	ihdr.width = width;
236	ihdr.height = height;
237	ihdr.depth = 8;
238	ihdr.color_type = bpp == sizeof(uint32_t) ? 6 : 2; /* RGBA or RGB */
239	if (!png_write_ihdr_string(intf_s, &ihdr))
240	GOTO_END_ERROR();
241
242	encode_buf_size = (width * bpp + 1) * height;
243	encode_buf = (uint8_t*)malloc(encode_buf_size);
244	if (!encode_buf)
245	GOTO_END_ERROR();
246
247	prev_encoded = (uint8_t)calloc(1, width bpp);
248	if (!prev_encoded)
249	GOTO_END_ERROR();
250
251	rgba_line = (uint8_t)malloc(width bpp);
252	up_filtered = (uint8_t)malloc(width bpp);
253	sub_filtered = (uint8_t)malloc(width bpp);
254	avg_filtered = (uint8_t)malloc(width bpp);
255	paeth_filtered = (uint8_t)malloc(width bpp);
256	if (!rgba_line \|\| !up_filtered \|\| !sub_filtered \|\| !avg_filtered \|\| !paeth_filtered)
257	GOTO_END_ERROR();
258
259	encode_target = encode_buf;
260	for (h = 0; h < height;
261	h++, encode_target += width * bpp, data += pitch)
262	{
263	if (bpp == sizeof(uint32_t))
264	copy_argb_line(rgba_line, (const uint32_t*)data, width);
265	else
266	copy_bgr24_line(rgba_line, data, width);
267
268	/* Try every filtering method, and choose the method
269	* which has most entries as zero.
270	*
271	* This is probably not very optimal, but it's very
272	* simple to implement.
273	*/
274	{
275	unsigned none_score = count_sad(rgba_line, width * bpp);
276	unsigned up_score = filter_up(up_filtered, rgba_line, prev_encoded, width, bpp);
277	unsigned sub_score = filter_sub(sub_filtered, rgba_line, width, bpp);
278	unsigned avg_score = filter_avg(avg_filtered, rgba_line, prev_encoded, width, bpp);
279	unsigned paeth_score = filter_paeth(paeth_filtered, rgba_line, prev_encoded, width, bpp);
280
281	uint8_t filter = 0;
282	unsigned min_sad = none_score;
283	const uint8_t *chosen_filtered = rgba_line;
284
285	if (sub_score < min_sad)
286	{
287	filter = 1;
288	chosen_filtered = sub_filtered;
289	min_sad = sub_score;
290	}
291
292	if (up_score < min_sad)
293	{
294	filter = 2;
295	chosen_filtered = up_filtered;
296	min_sad = up_score;
297	}
298
299	if (avg_score < min_sad)
300	{
301	filter = 3;
302	chosen_filtered = avg_filtered;
303	min_sad = avg_score;
304	}
305
306	if (paeth_score < min_sad)
307	{
308	filter = 4;
309	chosen_filtered = paeth_filtered;
310	}
311
312	*encode_target++ = filter;
313	memcpy(encode_target, chosen_filtered, width * bpp);
314
315	memcpy(prev_encoded, rgba_line, width * bpp);
316	}
317	}
318
319	deflate_buf = (uint8_t)malloc(encode_buf_size 2); /* Just to be sure. */
320	if (!deflate_buf)
321	GOTO_END_ERROR();
322
323	stream = stream_backend->stream_new();
324
325	if (!stream)
326	GOTO_END_ERROR();
327
328	stream_backend->set_in(
329	stream,
330	encode_buf,
331	(unsigned)encode_buf_size);
332	stream_backend->set_out(
333	stream,
334	deflate_buf + 8,
335	(unsigned)(encode_buf_size * 2));
336
337	if (!stream_backend->trans(stream, true, &total_in, &total_out, NULL))
338	GOTO_END_ERROR();
339
340	memcpy(deflate_buf + 4, "IDAT", 4);
341	dword_write_be(deflate_buf + 0, ((uint32_t)total_out));
342	if (!png_write_idat_string(intf_s, deflate_buf, ((size_t)total_out + 8)))
343	GOTO_END_ERROR();
344
345	if (!png_write_iend_string(intf_s))
346	GOTO_END_ERROR();
347	end:
348	free(encode_buf);
349	free(deflate_buf);
350	free(rgba_line);
351	free(prev_encoded);
352	free(up_filtered);
353	free(sub_filtered);
354	free(avg_filtered);
355	free(paeth_filtered);
356
357	if (stream_backend)
358	{
359	if (stream)
360	{
361	if (stream_backend->stream_free)
362	stream_backend->stream_free(stream);
363	}
364	}
365	return ret;
366	}
367
368	bool rpng_save_image_argb(const char path, const uint32_t data,
369	unsigned width, unsigned height, unsigned pitch)
370	{
371	bool ret = false;
372	intfstream_t* intf_s = NULL;
373
374	intf_s = intfstream_open_file(path,
375	RETRO_VFS_FILE_ACCESS_WRITE,
376	RETRO_VFS_FILE_ACCESS_HINT_NONE);
377
378	ret = rpng_save_image_stream((const uint8_t*) data, intf_s,
379	width, height,
380	(signed) pitch, sizeof(uint32_t));
381	intfstream_close(intf_s);
382	free(intf_s);
383	return ret;
384	}
385
386	bool rpng_save_image_bgr24(const char path, const uint8_t data,
387	unsigned width, unsigned height, unsigned pitch)
388	{
389	bool ret = false;
390	intfstream_t* intf_s = NULL;
391
392	intf_s = intfstream_open_file(path,
393	RETRO_VFS_FILE_ACCESS_WRITE,
394	RETRO_VFS_FILE_ACCESS_HINT_NONE);
395	ret = rpng_save_image_stream(data, intf_s, width, height,
396	(signed) pitch, 3);
397	intfstream_close(intf_s);
398	free(intf_s);
399	return ret;
400	}
401
402
403	uint8_t* rpng_save_image_bgr24_string(const uint8_t *data,
404	unsigned width, unsigned height, signed pitch, uint64_t* bytes)
405	{
406	bool ret = false;
407	uint8_t* buf = NULL;
408	uint8_t* output = NULL;
409	int buf_length = 0;
410	intfstream_t* intf_s = NULL;
411
412	buf_length = (int)(widthheight3*DEFLATE_PADDING)+PNG_ROUGH_HEADER;
413	buf = (uint8_t)malloc(buf_lengthsizeof(uint8_t));
414	if (!buf)
415	GOTO_END_ERROR();
416
417	intf_s = intfstream_open_writable_memory(buf,
418	RETRO_VFS_FILE_ACCESS_WRITE,
419	RETRO_VFS_FILE_ACCESS_HINT_NONE,
420	buf_length);
421
422	ret = rpng_save_image_stream((const uint8_t*)data,
423	intf_s, width, height, pitch, 3);
424
425	*bytes = intfstream_get_ptr(intf_s);
426	intfstream_rewind(intf_s);
427	output = (uint8_t)malloc((size_t)((bytes)*sizeof(uint8_t)));
428	if (!output)
429	GOTO_END_ERROR();
430	intfstream_read(intf_s, output, *bytes);
431
432	end:
433	if (buf)
434	free(buf);
435	if (intf_s)
436	{
437	intfstream_close(intf_s);
438	free(intf_s);
439	}
440	if (ret == false)
441	{
442	if (output)
443	free(output);
444	return NULL;
445	}
446	return output;
447	}
448