mirror/The-Powder-Toy
1
0
Fork 0
mirror of https://github.com/The-Powder-Toy/The-Powder-Toy.git synced 2025-04-05 06:52:36 +02:00
Code Issues Projects Releases Wiki Activity

Very high quality image resampling code curtesy of imageresampler (http://code.google.com/p/imageresampler/), will replace current shitty linear interpolation for SSE2 and renderer builds.

Browse Source
This commit is contained in:
Simon Robertshaw 2012-12-15 01:04:17 +00:00
parent a1af662b8f
commit b4475ae96f
5 changed files with 1525 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/Config.h
View File

@ -44,6 +44,10 @@
//#define IGNORE_UPDATES //uncomment this for mods, to not get any update notifications
#if defined(DEBUG) || defined(RENDERER) || defined(X86_SSE2)
#define HIGH_QUALITY_RESAMPLE //High quality image resampling, slower but much higher quality than my terribad linear interpolation
#endif
#if defined(SNAPSHOT)
#define IDENT_RELTYPE "S"
#elif defined(BETA)

91
src/graphics/Graphics.cpp
View File

@ -7,6 +7,9 @@
#include "Graphics.h"
#define INCLUDE_FONTDATA
#include "font.h"
#ifdef HIGH_QUALITY_RESAMPLE
#include "resampler/resampler.h"
#endif
VideoBuffer::VideoBuffer(int width, int height):
Width(width),
@ -291,6 +294,93 @@ pixel *Graphics::resample_img_nn(pixel * src, int sw, int sh, int rw, int rh)
pixel *Graphics::resample_img(pixel *src, int sw, int sh, int rw, int rh)
{
#ifdef HIGH_QUALITY_RESAMPLE
unsigned char * source = (unsigned char*)src;
int sourceWidth = sw, sourceHeight = sh;
int resultWidth = rw, resultHeight = rh;
int sourcePitch = sourceWidth*PIXELSIZE, resultPitch = resultWidth*PIXELSIZE;
// Filter scale - values < 1.0 cause aliasing, but create sharper looking mips.
const float filter_scale = 0.75f;
const char* pFilter = "lanczos12";
Resampler * resamplers[PIXELCHANNELS];
float * samples[PIXELCHANNELS];
//Resampler for each colour channel
resamplers[0] = new Resampler(sourceWidth, sourceHeight, resultWidth, resultHeight, Resampler::BOUNDARY_CLAMP, 0.0f, 1.0f, pFilter, NULL, NULL, filter_scale, filter_scale);
samples[0] = new float[sourceWidth];
for (int i = 1; i < PIXELCHANNELS; i++)
{
resamplers[i] = new Resampler(sourceWidth, sourceHeight, resultWidth, resultHeight, Resampler::BOUNDARY_CLAMP, 0.0f, 1.0f, pFilter, resamplers[0]->get_clist_x(), resamplers[0]->get_clist_y(), filter_scale, filter_scale);
samples[i] = new float[sourceWidth];
}
unsigned char * resultImage = new unsigned char[resultHeight * resultPitch];
std::fill(resultImage, resultImage + (resultHeight*resultPitch), 0);
//Resample time
int resultY = 0;
for (int sourceY = 0; sourceY < sourceHeight; sourceY++)
{
unsigned char * sourcePixel = &source[sourceY * sourcePitch];
//Move pixel components into channel samples
for (int c = 0; c < PIXELCHANNELS; c++)
{
for (int x = 0; x < sourceWidth; x++)
{
samples[c][x] = sourcePixel[(x*PIXELSIZE)+c] * (1.0f/255.0f);
}
}
//Put channel sample data into resampler
for (int c = 0; c < PIXELCHANNELS; c++)
{
if (!resamplers[c]->put_line(&samples[c][0]))
{
printf("Out of memory!\n");
return NULL;
}
}
//Perform resample and Copy components from resampler result samples to image buffer
for ( ; ; )
{
int comp_index;
for (comp_index = 0; comp_index < PIXELCHANNELS; comp_index++)
{
const float* resultSamples = resamplers[comp_index]->get_line();
if (!resultSamples)
break;
unsigned char * resultPixel = &resultImage[(resultY * resultPitch) + comp_index];
for (int x = 0; x < resultWidth; x++)
{
int c = (int)(255.0f * resultSamples[x] + .5f);
if (c < 0) c = 0; else if (c > 255) c = 255;
*resultPixel = (unsigned char)c;
resultPixel += PIXELSIZE;
}
}
if (comp_index < PIXELCHANNELS)
break;
resultY++;
}
}
//Clean up
for(int i = 0; i < PIXELCHANNELS; i++)
{
delete resamplers[i];
delete[] samples[i];
}
return (pixel*)resultImage;
#else
#ifdef DEBUG
std::cout << "Resampling " << sw << "x" << sh << " to " << rw << "x" << rh << std::endl;
#endif
@ -402,6 +492,7 @@ pixel *Graphics::resample_img(pixel *src, int sw, int sh, int rw, int rh)
}
}
return q;
#endif
}
pixel *Graphics::rescale_img(pixel *src, int sw, int sh, int *qw, int *qh, int f)

18
src/graphics/Graphics.h
View File

@ -11,38 +11,40 @@
#include "Config.h"
//#include "powder.h"
#define PIXELCHANNELS 3
#ifdef PIX16
#define PIXELSIZE 2
#define PIXPACK(x) ((((x)>>8)&0xF800)|(((x)>>5)&0x07E0)|(((x)>>3)&0x001F))
#define PIXPACK(x) ((((x)>>8)&0xF800)|(((x)>>5)&0x07E0)|(((x)>>3)&0x001F)) //16bit RGB in 16bit int: ????
#define PIXRGB(r,g,b) ((((r)<<8)&0xF800)|(((g)<<3)&0x07E0)|(((b)>>3)&0x001F))
#define PIXR(x) (((x)>>8)&0xF8)
#define PIXG(x) (((x)>>3)&0xFC)
#define PIXB(x) (((x)<<3)&0xF8)
#else
#define PIXELSIZE 4
#ifdef PIX32BGR
#define PIXPACK(x) ((((x)>>16)&0x0000FF)|((x)&0x00FF00)|(((x)<<16)&0xFF0000))
#ifdef PIX32BGRA
#define PIXPACK(x) ((((x)>>16)&0x0000FF)|((x)&0x00FF00)|(((x)<<16)&0xFF0000)) //24bit BGR in 32bit int: 00BBGGRR
#define PIXRGB(r,g,b) (((b)<<16)|((g)<<8)|((r)))// (((b)<<16)|((g)<<8)|(r))
#define PIXR(x) ((x)&0xFF)
#define PIXG(x) (((x)>>8)&0xFF)
#define PIXB(x) ((x)>>16)
#else
#ifdef PIX32BGRA
#define PIXPACK(x) ((((x)>>8)&0x0000FF00)|(((x)<<8)&0x00FF0000)|(((x)<<24)&0xFF000000))
#define PIXPACK(x) ((((x)>>8)&0x0000FF00)|(((x)<<8)&0x00FF0000)|(((x)<<24)&0xFF000000)) //32bit BGRA in 32bit int: BBGGRRAA
#define PIXRGB(r,g,b) (((b)<<24)|((g)<<16)|((r)<<8))
#define PIXR(x) (((x)>>8)&0xFF)
#define PIXG(x) (((x)>>16)&0xFF)
#define PIXB(x) (((x)>>24))
#elif defined(PIX32OGL)
#define PIXPACK(x) (0xFF000000|((x)&0xFFFFFF))
#define PIXRGB(r,g,b) (0xFF000000|((r)<<16)|((g)<<8)|((b)))// (((b)<<16)|((g)<<8)|(r))
#define PIXRGBA(r,g,b,a) (((a)<<24)|((r)<<16)|((g)<<8)|((b)))// (((b)<<16)|((g)<<8)|(r))
#define PIXELCHANNELS 4
#define PIXPACK(x) (0xFF000000|((x)&0xFFFFFF)) //32bit ARGB in 32bit int: AARRGGBB
#define PIXRGB(r,g,b) (0xFF000000|((r)<<16)|((g)<<8)|((b)))
#define PIXRGBA(r,g,b,a) (((a)<<24)|((r)<<16)|((g)<<8)|((b)))
#define PIXA(x) (((x)>>24)&0xFF)
#define PIXR(x) (((x)>>16)&0xFF)
#define PIXG(x) (((x)>>8)&0xFF)
#define PIXB(x) ((x)&0xFF)
#else
#define PIXPACK(x) (x)
#define PIXPACK(x) (x) //24bit RGB in 32bit int: 00RRGGBB.
#define PIXRGB(r,g,b) (((r)<<16)|((g)<<8)|(b))
#define PIXR(x) ((x)>>16)
#define PIXG(x) (((x)>>8)&0xFF)

1223
src/resampler/resampler.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

197
src/resampler/resampler.h Normal file
View File

@ -0,0 +1,197 @@
// http://code.google.com/p/imageresampler/
// resampler.h, Separable filtering image rescaler v2.21, Rich Geldreich - richgel99@gmail.com
// See unlicense.org text at the bottom of this file.
#ifndef __RESAMPLER_H__
#define __RESAMPLER_H__
#define RESAMPLER_DEBUG_OPS 0
#define RESAMPLER_DEFAULT_FILTER "lanczos4"
#define RESAMPLER_MAX_DIMENSION 16384
// float or double
typedef float Resample_Real;
class Resampler
{
public:
typedef Resample_Real Sample;
struct Contrib
{
Resample_Real weight;
unsigned short pixel;
};
struct Contrib_List
{
unsigned short n;
Contrib* p;
};
enum Boundary_Op
{
BOUNDARY_WRAP = 0,
BOUNDARY_REFLECT = 1,
BOUNDARY_CLAMP = 2
};
enum Status
{
STATUS_OKAY = 0,
STATUS_OUT_OF_MEMORY = 1,
STATUS_BAD_FILTER_NAME = 2,
STATUS_SCAN_BUFFER_FULL = 3
};
// src_x/src_y - Input dimensions
// dst_x/dst_y - Output dimensions
// boundary_op - How to sample pixels near the image boundaries
// sample_low/sample_high - Clamp output samples to specified range, or disable clamping if sample_low >= sample_high
// Pclist_x/Pclist_y - Optional pointers to contributor lists from another instance of a Resampler
// src_x_ofs/src_y_ofs - Offset input image by specified amount (fractional values okay)
Resampler(
int src_x, int src_y,
int dst_x, int dst_y,
Boundary_Op boundary_op = BOUNDARY_CLAMP,
Resample_Real sample_low = 0.0f, Resample_Real sample_high = 0.0f,
const char* Pfilter_name = RESAMPLER_DEFAULT_FILTER,
Contrib_List* Pclist_x = NULL,
Contrib_List* Pclist_y = NULL,
Resample_Real filter_x_scale = 1.0f,
Resample_Real filter_y_scale = 1.0f,
Resample_Real src_x_ofs = 0.0f,
Resample_Real src_y_ofs = 0.0f);
~Resampler();
// Reinits resampler so it can handle another frame.
void restart();
// false on out of memory.
bool put_line(const Sample* Psrc);
// NULL if no scanlines are currently available (give the resampler more scanlines!)
const Sample* get_line();
Status status() const { return m_status; }
// Returned contributor lists can be shared with another Resampler.
void get_clists(Contrib_List** ptr_clist_x, Contrib_List** ptr_clist_y);
Contrib_List* get_clist_x() const { return m_Pclist_x; }
Contrib_List* get_clist_y() const { return m_Pclist_y; }
// Filter accessors.
static int get_filter_num();
static char* get_filter_name(int filter_num);
private:
Resampler();
Resampler(const Resampler& o);
Resampler& operator= (const Resampler& o);
#ifdef RESAMPLER_DEBUG_OPS
int total_ops;
#endif
int m_intermediate_x;
int m_resample_src_x;
int m_resample_src_y;
int m_resample_dst_x;
int m_resample_dst_y;
Boundary_Op m_boundary_op;
Sample* m_Pdst_buf;
Sample* m_Ptmp_buf;
Contrib_List* m_Pclist_x;
Contrib_List* m_Pclist_y;
bool m_clist_x_forced;
bool m_clist_y_forced;
bool m_delay_x_resample;
int* m_Psrc_y_count;
unsigned char* m_Psrc_y_flag;
// The maximum number of scanlines that can be buffered at one time.
enum { MAX_SCAN_BUF_SIZE = RESAMPLER_MAX_DIMENSION };
struct Scan_Buf
{
int scan_buf_y[MAX_SCAN_BUF_SIZE];
Sample* scan_buf_l[MAX_SCAN_BUF_SIZE];
};
Scan_Buf* m_Pscan_buf;
int m_cur_src_y;
int m_cur_dst_y;
Status m_status;
void resample_x(Sample* Pdst, const Sample* Psrc);
void scale_y_mov(Sample* Ptmp, const Sample* Psrc, Resample_Real weight, int dst_x);
void scale_y_add(Sample* Ptmp, const Sample* Psrc, Resample_Real weight, int dst_x);
void clamp(Sample* Pdst, int n);
void resample_y(Sample* Pdst);
int reflect(const int j, const int src_x, const Boundary_Op boundary_op);
Contrib_List* make_clist(
int src_x, int dst_x, Boundary_Op boundary_op,
Resample_Real (*Pfilter)(Resample_Real),
Resample_Real filter_support,
Resample_Real filter_scale,
Resample_Real src_ofs);
inline int count_ops(Contrib_List* Pclist, int k)
{
int i, t = 0;
for (i = 0; i < k; i++)
t += Pclist[i].n;
return (t);
}
Resample_Real m_lo;
Resample_Real m_hi;
inline Resample_Real clamp_sample(Resample_Real f) const
{
if (f < m_lo)
f = m_lo;
else if (f > m_hi)
f = m_hi;
return f;
}
};
#endif // __RESAMPLER_H__
// This is free and unencumbered software released into the public domain.
//
// Anyone is free to copy, modify, publish, use, compile, sell, or
// distribute this software, either in source code form or as a compiled
// binary, for any purpose, commercial or non-commercial, and by any
// means.
//
// In jurisdictions that recognize copyright laws, the author or authors
// of this software dedicate any and all copyright interest in the
// software to the public domain. We make this dedication for the benefit
// of the public at large and to the detriment of our heirs and
// successors. We intend this dedication to be an overt act of
// relinquishment in perpetuity of all present and future rights to this
// software under copyright law.
//
// 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 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.
//
// For more information, please refer to <http://unlicense.org/>