[pcsx_rearmed.git] / deps / libretro-common / gfx / scaler / scaler_filter.c

/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (scaler_filter.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 <string.h>

#include <gfx/scaler/filter.h>
#include <gfx/scaler/scaler_int.h>
#include <retro_inline.h>
#include <filters.h>
#include <retro_math.h>

#define FILTER_UNITY (1 << 14)

static INLINE void gen_filter_point_sub(struct scaler_filter *filter,
      int len, int pos, int step)
{
   int i;
   for (i = 0; i < len; i++, pos += step)
   {
      filter->filter_pos[i] = pos >> 16;
      filter->filter[i]     = FILTER_UNITY;
   }
}

static INLINE void gen_filter_bilinear_sub(struct scaler_filter *filter,
      int len, int pos, int step)
{
   int i;
   for (i = 0; i < len; i++, pos += step)
   {
      filter->filter_pos[i]     = pos >> 16;
      filter->filter[i * 2 + 1] = (pos & 0xffff) >> 2;
      filter->filter[i * 2 + 0] = FILTER_UNITY - filter->filter[i * 2 + 1];
   }
}

static INLINE void gen_filter_sinc_sub(struct scaler_filter *filter,
      int len, int pos, int step, double phase_mul)
{
   int i, j;
   const int sinc_size = filter->filter_len;

   for (i = 0; i < len; i++, pos += step)
   {
      filter->filter_pos[i] = pos >> 16;

      for (j = 0; j < sinc_size; j++)
      {
         double sinc_phase    = M_PI * ((double)((sinc_size << 15) + (pos & 0xffff)) / 0x10000 - j);
         double lanczos_phase = sinc_phase / ((sinc_size >> 1));
         int16_t sinc_val     = FILTER_UNITY * sinc(sinc_phase * phase_mul) * sinc(lanczos_phase) * phase_mul;

         filter->filter[i * sinc_size + j] = sinc_val;
      }
   }
}

static bool validate_filter(struct scaler_ctx *ctx)
{
   int i;
   int max_h_pos;
   int max_w_pos = ctx->in_width - ctx->horiz.filter_len;

   for (i = 0; i < ctx->out_width; i++)
   {
      if (ctx->horiz.filter_pos[i] > max_w_pos || ctx->horiz.filter_pos[i] < 0)
      {
#ifndef NDEBUG
         fprintf(stderr, "Out X = %d => In X = %d\n", i, ctx->horiz.filter_pos[i]);
#endif
         return false;
      }
   }

   max_h_pos = ctx->in_height - ctx->vert.filter_len;

   for (i = 0; i < ctx->out_height; i++)
   {
      if (ctx->vert.filter_pos[i] > max_h_pos || ctx->vert.filter_pos[i] < 0)
      {
#ifndef NDEBUG
         fprintf(stderr, "Out Y = %d => In Y = %d\n", i, ctx->vert.filter_pos[i]);
#endif
         return false;
      }
   }

   return true;
}

static void fixup_filter_sub(struct scaler_filter *filter,
      int out_len, int in_len)
{
   int i;
   int max_pos = in_len - filter->filter_len;

   for (i = 0; i < out_len; i++)
   {
      int postsample =  filter->filter_pos[i] - max_pos;
      int presample  = -filter->filter_pos[i];

      if (postsample > 0)
      {
         int16_t *base_filter   = NULL;

         filter->filter_pos[i] -= postsample;

         base_filter            = filter->filter + i * filter->filter_stride;

         if (postsample > (int)filter->filter_len)
            memset(base_filter, 0, filter->filter_len * sizeof(int16_t));
         else
         {
            memmove(base_filter + postsample, base_filter,
                  (filter->filter_len - postsample) * sizeof(int16_t));
            memset(base_filter, 0, postsample * sizeof(int16_t));
         }
      }

      if (presample > 0)
      {
         int16_t *base_filter   = NULL;

         filter->filter_pos[i] += presample;
         base_filter            = filter->filter + i * filter->filter_stride;

         if (presample > (int)filter->filter_len)
            memset(base_filter, 0, filter->filter_len * sizeof(int16_t));
         else
         {
            memmove(base_filter, base_filter + presample,
                  (filter->filter_len - presample) * sizeof(int16_t));
            memset(base_filter + (filter->filter_len - presample),
                  0, presample * sizeof(int16_t));
         }
      }
   }
}

bool scaler_gen_filter(struct scaler_ctx *ctx)
{
   int x_pos, x_step, y_pos, y_step;
   int sinc_size = 0;

   switch (ctx->scaler_type)
   {
      case SCALER_TYPE_POINT:
         ctx->horiz.filter_len    = 1;
         ctx->horiz.filter_stride = 1;
         ctx->vert.filter_len     = 1;
         ctx->vert.filter_stride  = 1;
         break;
      case SCALER_TYPE_BILINEAR:
         ctx->horiz.filter_len    = 2;
         ctx->horiz.filter_stride = 2;
         ctx->vert.filter_len     = 2;
         ctx->vert.filter_stride  = 2;
         break;
      case SCALER_TYPE_SINC:
         sinc_size                = 8 * ((ctx->in_width > ctx->out_width)
               ? next_pow2(ctx->in_width / ctx->out_width) : 1);
         ctx->horiz.filter_len    = sinc_size;
         ctx->horiz.filter_stride = sinc_size;
         ctx->vert.filter_len     = sinc_size;
         ctx->vert.filter_stride  = sinc_size;
         break;
      case SCALER_TYPE_UNKNOWN:
      default:
         return false;
   }

   ctx->horiz.filter     = (int16_t*)calloc(sizeof(int16_t), ctx->horiz.filter_stride * ctx->out_width);
   ctx->horiz.filter_pos = (int*)calloc(sizeof(int), ctx->out_width);

   ctx->vert.filter      = (int16_t*)calloc(sizeof(int16_t), ctx->vert.filter_stride * ctx->out_height);
   ctx->vert.filter_pos  = (int*)calloc(sizeof(int), ctx->out_height);

   if (!ctx->horiz.filter || !ctx->vert.filter)
      return false;

   x_step = (1 << 16) * ctx->in_width / ctx->out_width;
   y_step = (1 << 16) * ctx->in_height / ctx->out_height;

   switch (ctx->scaler_type)
   {
      case SCALER_TYPE_POINT:
         x_pos  = (1 << 15) * ctx->in_width / ctx->out_width   - (1 << 15);
         y_pos  = (1 << 15) * ctx->in_height / ctx->out_height - (1 << 15);

         gen_filter_point_sub(&ctx->horiz, ctx->out_width,  x_pos, x_step);
         gen_filter_point_sub(&ctx->vert,  ctx->out_height, y_pos, y_step);

         ctx->scaler_special = scaler_argb8888_point_special;
         break;

      case SCALER_TYPE_BILINEAR:
         x_pos  = (1 << 15) * ctx->in_width / ctx->out_width   - (1 << 15);
         y_pos  = (1 << 15) * ctx->in_height / ctx->out_height - (1 << 15);

         gen_filter_bilinear_sub(&ctx->horiz, ctx->out_width,  x_pos, x_step);
         gen_filter_bilinear_sub(&ctx->vert,  ctx->out_height, y_pos, y_step);
         break;

      case SCALER_TYPE_SINC:
         /* Need to expand the filter when downsampling
          * to get a proper low-pass effect. */

         x_pos  = (1 << 15) * ctx->in_width  / ctx->out_width  - (1 << 15) - (sinc_size << 15);
         y_pos  = (1 << 15) * ctx->in_height / ctx->out_height - (1 << 15) - (sinc_size << 15);

         gen_filter_sinc_sub(&ctx->horiz, ctx->out_width, x_pos, x_step,
               ctx->in_width  > ctx->out_width  ? (double)ctx->out_width  / ctx->in_width  : 1.0);
         gen_filter_sinc_sub(&ctx->vert, ctx->out_height, y_pos, y_step,
               ctx->in_height > ctx->out_height ? (double)ctx->out_height / ctx->in_height : 1.0
               );
         break;
      case SCALER_TYPE_UNKNOWN:
         break;
   }

   /* Makes sure that we never sample outside our rectangle. */
   fixup_filter_sub(&ctx->horiz, ctx->out_width, ctx->in_width);
   fixup_filter_sub(&ctx->vert,  ctx->out_height, ctx->in_height);

   return validate_filter(ctx);
}
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 (scaler_filter.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 <string.h>
	25
	26	#include <gfx/scaler/filter.h>
	27	#include <gfx/scaler/scaler_int.h>
	28	#include <retro_inline.h>
	29	#include <filters.h>
	30	#include <retro_math.h>
	31
	32	#define FILTER_UNITY (1 << 14)
	33
	34	static INLINE void gen_filter_point_sub(struct scaler_filter *filter,
	35	int len, int pos, int step)
	36	{
	37	int i;
	38	for (i = 0; i < len; i++, pos += step)
	39	{
	40	filter->filter_pos[i] = pos >> 16;
	41	filter->filter[i] = FILTER_UNITY;
	42	}
	43	}
	44
	45	static INLINE void gen_filter_bilinear_sub(struct scaler_filter *filter,
	46	int len, int pos, int step)
	47	{
	48	int i;
	49	for (i = 0; i < len; i++, pos += step)
	50	{
	51	filter->filter_pos[i] = pos >> 16;
	52	filter->filter[i * 2 + 1] = (pos & 0xffff) >> 2;
	53	filter->filter[i * 2 + 0] = FILTER_UNITY - filter->filter[i * 2 + 1];
	54	}
	55	}
	56
	57	static INLINE void gen_filter_sinc_sub(struct scaler_filter *filter,
	58	int len, int pos, int step, double phase_mul)
	59	{
	60	int i, j;
	61	const int sinc_size = filter->filter_len;
	62
	63	for (i = 0; i < len; i++, pos += step)
	64	{
65	filter->filter_pos[i] = pos >> 16;
66
67	for (j = 0; j < sinc_size; j++)
68	{
69	double sinc_phase = M_PI * ((double)((sinc_size << 15) + (pos & 0xffff)) / 0x10000 - j);
70	double lanczos_phase = sinc_phase / ((sinc_size >> 1));
71	int16_t sinc_val = FILTER_UNITY * sinc(sinc_phase * phase_mul) * sinc(lanczos_phase) * phase_mul;
72
73	filter->filter[i * sinc_size + j] = sinc_val;
74	}
75	}
76	}
77
78	static bool validate_filter(struct scaler_ctx *ctx)
79	{
80	int i;
81	int max_h_pos;
82	int max_w_pos = ctx->in_width - ctx->horiz.filter_len;
83
84	for (i = 0; i < ctx->out_width; i++)
85	{
86	if (ctx->horiz.filter_pos[i] > max_w_pos \|\| ctx->horiz.filter_pos[i] < 0)
87	{
88	#ifndef NDEBUG
89	fprintf(stderr, "Out X = %d => In X = %d\n", i, ctx->horiz.filter_pos[i]);
90	#endif
91	return false;
92	}
93	}
94
95	max_h_pos = ctx->in_height - ctx->vert.filter_len;
96
97	for (i = 0; i < ctx->out_height; i++)
98	{
99	if (ctx->vert.filter_pos[i] > max_h_pos \|\| ctx->vert.filter_pos[i] < 0)
100	{
101	#ifndef NDEBUG
102	fprintf(stderr, "Out Y = %d => In Y = %d\n", i, ctx->vert.filter_pos[i]);
103	#endif
104	return false;
105	}
106	}
107
108	return true;
109	}
110
111	static void fixup_filter_sub(struct scaler_filter *filter,
112	int out_len, int in_len)
113	{
114	int i;
115	int max_pos = in_len - filter->filter_len;
116
117	for (i = 0; i < out_len; i++)
118	{
119	int postsample = filter->filter_pos[i] - max_pos;
120	int presample = -filter->filter_pos[i];
121
122	if (postsample > 0)
123	{
124	int16_t *base_filter = NULL;
125
126	filter->filter_pos[i] -= postsample;
127
128	base_filter = filter->filter + i * filter->filter_stride;
129
130	if (postsample > (int)filter->filter_len)
131	memset(base_filter, 0, filter->filter_len * sizeof(int16_t));
132	else
133	{
134	memmove(base_filter + postsample, base_filter,
135	(filter->filter_len - postsample) * sizeof(int16_t));
136	memset(base_filter, 0, postsample * sizeof(int16_t));
137	}
138	}
139
140	if (presample > 0)
141	{
142	int16_t *base_filter = NULL;
143
144	filter->filter_pos[i] += presample;
145	base_filter = filter->filter + i * filter->filter_stride;
146
147	if (presample > (int)filter->filter_len)
148	memset(base_filter, 0, filter->filter_len * sizeof(int16_t));
149	else
150	{
151	memmove(base_filter, base_filter + presample,
152	(filter->filter_len - presample) * sizeof(int16_t));
153	memset(base_filter + (filter->filter_len - presample),
154	0, presample * sizeof(int16_t));
155	}
156	}
157	}
158	}
159
160	bool scaler_gen_filter(struct scaler_ctx *ctx)
161	{
162	int x_pos, x_step, y_pos, y_step;
163	int sinc_size = 0;
164
165	switch (ctx->scaler_type)
166	{
167	case SCALER_TYPE_POINT:
168	ctx->horiz.filter_len = 1;
169	ctx->horiz.filter_stride = 1;
170	ctx->vert.filter_len = 1;
171	ctx->vert.filter_stride = 1;
172	break;
173	case SCALER_TYPE_BILINEAR:
174	ctx->horiz.filter_len = 2;
175	ctx->horiz.filter_stride = 2;
176	ctx->vert.filter_len = 2;
177	ctx->vert.filter_stride = 2;
178	break;
179	case SCALER_TYPE_SINC:
180	sinc_size = 8 * ((ctx->in_width > ctx->out_width)
181	? next_pow2(ctx->in_width / ctx->out_width) : 1);
182	ctx->horiz.filter_len = sinc_size;
183	ctx->horiz.filter_stride = sinc_size;
184	ctx->vert.filter_len = sinc_size;
185	ctx->vert.filter_stride = sinc_size;
186	break;
187	case SCALER_TYPE_UNKNOWN:
188	default:
189	return false;
190	}
191
192	ctx->horiz.filter = (int16_t)calloc(sizeof(int16_t), ctx->horiz.filter_stride ctx->out_width);
193	ctx->horiz.filter_pos = (int*)calloc(sizeof(int), ctx->out_width);
194
195	ctx->vert.filter = (int16_t)calloc(sizeof(int16_t), ctx->vert.filter_stride ctx->out_height);
196	ctx->vert.filter_pos = (int*)calloc(sizeof(int), ctx->out_height);
197
198	if (!ctx->horiz.filter \|\| !ctx->vert.filter)
199	return false;
200
201	x_step = (1 << 16) * ctx->in_width / ctx->out_width;
202	y_step = (1 << 16) * ctx->in_height / ctx->out_height;
203
204	switch (ctx->scaler_type)
205	{
206	case SCALER_TYPE_POINT:
207	x_pos = (1 << 15) * ctx->in_width / ctx->out_width - (1 << 15);
208	y_pos = (1 << 15) * ctx->in_height / ctx->out_height - (1 << 15);
209
210	gen_filter_point_sub(&ctx->horiz, ctx->out_width, x_pos, x_step);
211	gen_filter_point_sub(&ctx->vert, ctx->out_height, y_pos, y_step);
212
213	ctx->scaler_special = scaler_argb8888_point_special;
214	break;
215
216	case SCALER_TYPE_BILINEAR:
217	x_pos = (1 << 15) * ctx->in_width / ctx->out_width - (1 << 15);
218	y_pos = (1 << 15) * ctx->in_height / ctx->out_height - (1 << 15);
219
220	gen_filter_bilinear_sub(&ctx->horiz, ctx->out_width, x_pos, x_step);
221	gen_filter_bilinear_sub(&ctx->vert, ctx->out_height, y_pos, y_step);
222	break;
223
224	case SCALER_TYPE_SINC:
225	/* Need to expand the filter when downsampling
226	* to get a proper low-pass effect. */
227
228	x_pos = (1 << 15) * ctx->in_width / ctx->out_width - (1 << 15) - (sinc_size << 15);
229	y_pos = (1 << 15) * ctx->in_height / ctx->out_height - (1 << 15) - (sinc_size << 15);
230
231	gen_filter_sinc_sub(&ctx->horiz, ctx->out_width, x_pos, x_step,
232	ctx->in_width > ctx->out_width ? (double)ctx->out_width / ctx->in_width : 1.0);
233	gen_filter_sinc_sub(&ctx->vert, ctx->out_height, y_pos, y_step,
234	ctx->in_height > ctx->out_height ? (double)ctx->out_height / ctx->in_height : 1.0
235	);
236	break;
237	case SCALER_TYPE_UNKNOWN:
238	break;
239	}
240
241	/* Makes sure that we never sample outside our rectangle. */
242	fixup_filter_sub(&ctx->horiz, ctx->out_width, ctx->in_width);
243	fixup_filter_sub(&ctx->vert, ctx->out_height, ctx->in_height);
244
245	return validate_filter(ctx);
246	}