adam/cobm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup: removed unused graphics/sdl/rndzoom.c

Browse Source 
git-svn-id: svn://svn.code.sf.net/p/sc2/code/trunk@3440 8092fc87-c524-0410-9efc-e669fe64eaf9
This commit is contained in:
avolkov
2009-12-18 23:20:29 +00:00
parent 08c678908c
commit cb4a6d964c
3 changed files with 1 additions and 560 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sc2/build/msvc6/UrQuanMasters.dsp
-4
View File
@@ -372,10 +372,6 @@ SOURCE=..\..\src\libs\graphics\sdl\pure.h
# End Source File
# Begin Source File
SOURCE=..\..\src\libs\graphics\sdl\rndzoom.c
# End Source File
# Begin Source File
SOURCE=..\..\src\libs\graphics\sdl\rotozoom.c
# End Source File
# Begin Source File
sc2/src/libs/graphics/sdl/Makeinfo
+1 -1
View File
@@ -1,6 +1,6 @@
uqm_CFILES="3do_blt.c 3do_funcs.c 3do_getbody.c dcqueue.c opengl.c
palette.c
primitives.c pure.c rndzoom.c sdl_common.c
primitives.c pure.c sdl_common.c
scalers.c 2xscalers.c
2xscalers_mmx.c 2xscalers_sse.c 2xscalers_3dnow.c
nearest2x.c bilinear2x.c biadv2x.c triscan2x.c hq2x.c
sc2/src/libs/graphics/sdl/rndzoom.c
-555
View File
@@ -1,555 +0,0 @@
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
The adjustments are as follows:
BLUR_TYPE:
0: No blur
1: A fast but very blurry convolution
2: A fast implementation of gaussian_blur with R0 = 0.8
3: Full 7x7 gaussian blur. use R0 to control how blurry to get
larger R0 numbers == more blurry.
RANDOM_METHOD:
0: Use standard RotoZoom without interpolation
1: Use standard RotoZoom with interpolationn
2: Choose at random from nearest neighors
3: Choose from nearest-neighbors with probability based on
distance from each pixel
4: Use the 'smart' random method, which gaurantees a path of
constant color from a given pixel to one of the nearest
neighbors. Randomization is based on a weighted average of
distance to each nearest neighbor.
*/
#define BLUR_TYPE 2
#define R0 0.8
#define RANDOM_METHOD 3
#ifdef GFXMODULE_SDL
#ifdef WIN32
#include <io.h>
#endif
#include <fcntl.h>
#include "sdl_common.h"
#include "primitives.h"
#include "libs/log.h"
#ifndef MAX
#define MAX(x,y) ((x) < (y) ? (y) : (x))
#endif
#ifndef MIN
#define MIN(x,y) ((x) > (y) ? (y) : (x))
#endif
#if 0
int MAX(int x, int y)
{
return ((x) < (y) ? (y) : (x));
}
int MIN (int x, int y)
{
return ((x) > (y) ? (y) : (x));
}
#endif
void blurSurface32 (SDL_Surface *src)
{
typedef struct
{
Uint32 r, g, b;
} color;
GetPixelFn getpix;
Uint32 *ptr;
int y, x, yy, xx;
Uint32 i, offset, ypos, yof;
#if BLUR_TYPE == 1
#define MWID 3
#define ARRAY_SIZE 4
#define BLUR_NORM(f) MIN (255, (f) >> 2)
#define BLUR_SHIFT(x,f) ((x) << shift[f])
#define NEED_ZERO_SHIFT
unsigned char idx[MWID * MWID] =
{
0, 1, 0,
1, 1, 1,
0, 1, 0
};
int shift[ARRAY_SIZE] = {0, 0, 1, 3};
color *blur_array[ARRAY_SIZE];
#elif BLUR_TYPE == 2
#define MWID 3
#define ARRAY_SIZE 3
#define BLUR_NORM(f) MIN (255, (f) >> 9)
#define BLUR_SHIFT(x,f) ((x) * shift[f])
unsigned char idx[MWID * MWID] =
{
0, 1, 0,
1, 2, 1,
0, 1, 0
};
int shift[ARRAY_SIZE] = {21, 62, 182};
color *blur_array[ARRAY_SIZE];
#elif BLUR_TYPE == 3
#define MWID 7
#define BLUR_NORM(f) MIN (255, (int)((f) / sum))
#define BLUR_SHIFT(x,f) ((Uint32)((x) * shift[f]))
// array-size is the triangular number of (MWID+1)/2
#define ARRAY_SIZE ((((MWID + 1) >> 1) * (((MWID + 1) >> 1) + 1)) >> 1)
float sum = 0.0;
float shift[ARRAY_SIZE];
color *blur_array[ARRAY_SIZE];
unsigned char idx[MWID * MWID];
{
// Build th eidx and shift arrays using the gaussian function
unsigned int i, j, k = 0;
unsigned int r_2;
for (i = 0; i <= (MWID >> 1); i++)
{
for (j = 0; j <= i; j++)
{
r_2 = i * i + j * j;
shift[k] = 1000 * (float)exp (- log (2) * r_2 / (R0 * R0));
if (i == 0 && j == 0)
sum += shift[k];
else if (j == 0 || i == j)
sum += 4 * shift[k];
else
sum += 8 * shift[k];
y = (MWID >> 1) - i;
x = (MWID >> 1) - j;
idx[y * MWID + x] = k;
idx[y * MWID + MWID - x - 1] = k;
idx[(MWID - y - 1) * MWID + x] = k;
idx[(MWID - y - 1) * MWID + MWID - x - 1] = k;
idx[x * MWID + y] = k;
idx[x * MWID + MWID - y - 1] = k;
idx[(MWID - x - 1) * MWID + y] = k;
idx[(MWID - x - 1) * MWID + MWID - y - 1] = k;
k++;
}
}
// printf ("sum is: %f\n", sum);
// i = 0;
// for(y = 0; y < MWID; y++)
// {
// for (x = 0; x< MWID; x++)
// printf(" %f", shift[idx[i++]]);
// printf("\n");
// }
}
#else
#define MWID 3
#define ARRAY_SIZE 1
#define BLUR_NORM(f) MIN (255, (f) >> 2)
#define BLUR_SHIFT(x,f) ((x) << shift[f])
unsigned char idx[1];
int shift[1];
color *blur_array[1];
return;
#endif
if (src->format->BitsPerPixel != 32)
{
log_add (log_Debug, "blurSurface32 requires a 32bit Surface, but surface is %d bits!\n",
src->format->BitsPerPixel);
return;
}
SDL_LockSurface (src);
getpix = getpixel_for (src);
// Make ARRAY_SIZE copies of the surface, each multiplied by a constant in 'shift'
for(i = 0; i < ARRAY_SIZE; i++)
blur_array[i] = (color *)HMalloc (sizeof(color) *
(src->w + MWID - 1) * (src->h + MWID - 1));
offset = 0;
ptr = src->pixels;
// the blur_array matrices are larger than the target surface by MWID - 1
// this is to allow convolving to work at the image edges.
// note that the convolution 'wraps' around on the x coordinate, butnot the y
for (y = -(MWID >> 1); y < src->h + (MWID >> 1); y++)
{
for (x = - (MWID >> 1); x < src->w + (MWID >> 1); x++)
{
unsigned char r, g, b;
Uint32 pixel;
i = 0;
if (x < 0)
pixel = getpix (src, x + src->w, MIN (src->h - 1, MAX (0, y)));
else if (x >= src->w)
pixel = getpix (src, x - src->w, MIN (src->h - 1, MAX (0, y)));
else if (y < 0 || y >= src->h)
pixel = getpix (src, x, MIN (src->h - 1, MAX (0, y)));
else
pixel = *ptr++;
SDL_GetRGB (pixel, src->format, &r, &g, &b);
#ifdef NEED_ZERO_SHIFT
blur_array[i][offset].r = 0;
blur_array[i][offset].g = 0;
blur_array[i][offset].b = 0;
i++;
#endif
for (; i < ARRAY_SIZE; i++) {
blur_array[i][offset].r = BLUR_SHIFT((Uint32)r,i);
blur_array[i][offset].g = BLUR_SHIFT((Uint32)g,i);
blur_array[i][offset].b = BLUR_SHIFT((Uint32)b,i);
}
offset++;
}
}
ptr = src->pixels;
ypos =0;
// actually do theconvolving here.
for (y = 0; y < src->h; y++, ypos += src->w + (MWID - 1))
{
for (x = 0; x < src->w; x++)
{
Uint32 pixel;
Uint32 bluroff, idxoff;
color p;
p.r =0;
p.g =0;
p.b =0;
idxoff = 0;
yof = ypos;
for (yy = - (MWID >> 1); yy <= (MWID >> 1); yy++)
{
bluroff = yof + x;
for (xx = - (MWID >> 1); xx <= (MWID >> 1); xx++)
{
p.r+=blur_array[idx[idxoff]][bluroff].r;
p.g+=blur_array[idx[idxoff]][bluroff].g;
p.b+=blur_array[idx[idxoff]][bluroff].b;
idxoff++;
bluroff++;
}
yof += src->w + (MWID - 1);
}
p.r = BLUR_NORM(p.r);
p.g = BLUR_NORM(p.g);
p.b = BLUR_NORM(p.b);
pixel = SDL_MapRGB (src->format, (Uint8)p.r, (Uint8)p.g, (Uint8)p.b);
*ptr++ = pixel;
}
}
SDL_UnlockSurface (src);
for(i = 0; i < ARRAY_SIZE; i++)
HFree (blur_array[i]);
}
/* the rZF_nearestneighbor method fills the 'dst' image with the 'src' image
(performing a 16x zoom). The interior points are generated by randomly choosing
the color of one of the 4 nearest neighbors. The randomization method is either
an even probability i.e 1/4, or a weighted probabliliity based on the distance
from each of the neighbors
*/
void rZF_nearestneighbor (SDL_Surface *src, SDL_Surface *dst, int use_weight)
{
int x, y;
Uint32 p00, p01, p10, p11;
Uint32 *yptr, *y1ptr, *dstptr;
UBYTE rand2;
UWORD prob_even[] = {64, 128, 192};
UWORD prob_weight[] = {
256, 256, 256, 144, 178, 127, 88, 127, 215, 48, 76, 220,
144, 192, 226, 114, 165, 216, 79, 127, 206, 51, 89, 203,
88, 176, 215, 79, 158, 206, 64, 128, 192, 48, 96, 175,
48, 192, 220, 51, 165, 203, 48, 127, 175, 38, 89, 140
};
UWORD *pry = prob_weight, *pr;
if (!use_weight)
pr = prob_even;
yptr = src->pixels;
y1ptr= yptr + src->w;
dstptr = dst->pixels;
for (y = 0; y < dst->h; y++)
{
if (y)
{
if (!(y & 0x03))
{
yptr += src->w;
if (y >> 2 < src->h - 1)
y1ptr += src->w;
if (use_weight)
pry = prob_weight;
}
else if (use_weight)
pry += 12;
}
for (x = 0; x < dst->w; x++)
{
Uint32 p;
if (! (x & 0x03))
{
int x0 = x >> 2;
p00 = *(yptr + x0);
p01 = *(y1ptr + x0);
if(x0 < src->w - 1)
{
p10 = *(yptr + x0 + 1);
p11 = *(y1ptr + x0 + 1);
}
else
{
p10 = *yptr;
p11 = *y1ptr;
}
if (use_weight)
pr = pry;
}
else
{
if (use_weight)
pr += 3;
}
rand2 = rand() & 0xff;
if (rand2 < pr[0])
p =p00;
else if (rand2 < pr[1])
p = p01;
else if (rand2 < pr[2])
p = p10;
else
p = p11;
*dstptr++ = p;
}
}
}
/* the rZF_continuous method fills the 'dst' image with the 'src' image
(performing a 16x zoom). The interior points are generated by randomly choosing
the color of one of the 4 nearest neighbors. However, it is gauranteed that there
will bbe a path of constant color from the current pixel to the nearest-neighbor
that was chosen. The randomization function is biased by the pixel's distance
fromit's neighbors
*/
void rZF_continuous (SDL_Surface *src, SDL_Surface *dst)
{
int rnd[] = {192, 171, 128, 0};
GetPixelFn getpix;
PutPixelFn putpix;
int rand2, dx, dy;
Uint32 pnew;
int x, y, x1, y1;
Uint32 p01, p10, p11;
int rand1;
getpix = getpixel_for (src);
putpix = putpixel_for (dst);
putpix (dst, 0, 0, getpix (src, 0, 0));
for (y = 0; y < src->h; y++)
{
p10 = getpix (src, 0, y);
if (y == src->h - 1)
p11 = getpix (src, 0, y);
else
p11 = getpix (src, 0, y + 1);
for (y1 = 0; y1 < 4; y1++)
{
dy = (y << 2) + y1;
rand1 = rand () & 0xff;
if (rand1 < rnd[y1])
pnew = p10;
else
{
pnew = p11;
p10 = p11;
}
putpix (dst, 0, dy, pnew);
}
}
for (x = 0; x < src->w; x++)
{
p10 = getpix (src, x, 0);
if (x == src->w - 1)
p11 = getpix (src, 0, 0);
else
p11 = getpix (src, x + 1, 0);
for (x1 = 0; x1 < 4; x1++)
{
dx = (x << 2) + x1;
rand1 = rand () & 0xff;
if (rand1 < rnd[x1])
pnew = p10;
else
{
pnew = p11;
p10 = p11;
}
putpix (dst, dx, 0, pnew);
}
}
for (y = 1; y <= src->h; y++)
{
int fromy, fromy4;
if (y == src->h)
fromy = y - 1;
else
fromy = y;
fromy4 = fromy << 2;
for(x = 1; x <= src->w; x++)
{
int fromx, fromx4;
int dy1;
Uint32 p00;
char cpl[3][3] = {{0,0,0},{0,0,0},{0,0,0}};
if (x == src->w)
fromx = 0;
else
fromx = x;
fromx4 = fromx << 2;
dx = x << 2;
p00 = getpix (src, x - 1, y - 1);
p10 = getpix (src, fromx, y - 1);
p01 = getpix (src, x - 1, fromy);
p11 = getpix (src, fromx, fromy);
if (x != src->w) {
for (y1 = 0; y1 < 4; y1++)
{
if (y == src->h && y1 == 3)
continue;
dy = ((y - 1) << 2) + y1 + 1;
rand1 = rand () & 0xff;
if (rand1 < rnd[y1])
pnew = p01;
else
{
pnew = p11;
p01 = p11;
}
putpix (dst, dx, dy, pnew);
}
}
if (y != src->h)
{
dy = y << 2;
for (x1 = 0; x1 < 3; x1++)
{
dx = ((x - 1) << 2) + x1 + 1;
rand1 = rand () & 0xff;
if (rand1 < rnd[x1])
pnew = p10;
else
{
pnew = p11;
p10 = p11;
}
putpix (dst, dx, dy, pnew);
}
}
for (y1 = 0; y1 < 3; y1++)
{
for (x1 = 0; x1 < 3; x1++)
{
int dxx, dyy;
if (cpl[x1][y1])
continue;
dyy=dy = ((y - 1) << 2) + y1 + 1;
dxx=dx = ((x - 1) << 2) + x1 + 1;
rand1 = rand () & 0xff;
rand2 = rand () & 0xff;
if (rand1 < 128)
{
if (rand2 < rnd[x1])
{
putpix (dst, dx, dy, getpix (dst, dx - 1, dy));
}
else
{
p00 = getpix (dst, fromx4, dy);
while (dx < x <<2)
{
putpix (dst, dx, dy, p00);
dx++;
x1++;
}
}
}
else
{
if (rand2 < rnd[y1])
{
putpix (dst, dx, dy, getpix (dst, dx, dy - 1));
}
else
{
p00 = getpix (dst, dx, fromy4);
dy1 = y1;
while (dy < y << 2)
{
putpix (dst, dx, dy, p00);
dy++;
cpl[x1][dy1] = 1;
dy1++;
}
}
}
if(getpix(dst,dxx,dyy) == 0)
printf ("wtf\n");
}
}
}
}
}
/* perform a 16x zoom, and then apply a blur filter to the result */
void random16xZoomSurfaceRGBA (SDL_Surface *src, SDL_Surface *dst)
{
/*
* Alloc space to completely contain the zoomed surface
*/
SDL_LockSurface (src);
SDL_LockSurface (dst);
#if RANDOM_METHOD == 0
zoomSurfaceRGBA (src, dst, 0);
#elif RANDOM_METHOD == 1
zoomSurfaceRGBA (src, dst, 1);
#elif RANDOM_METHOD == 2
rZF_nearestneighbor (src, dst, 0);
#elif RANDOM_METHOD == 3
rZF_nearestneighbor (src, dst, 1);
#else
rZF_continuous(src, dst);
#endif
SDL_UnlockSurface (src);
SDL_UnlockSurface (dst);
SDL_SetAlpha(dst, SDL_SRCALPHA, 255);
blurSurface32 (dst);
}
FRAME scale16xRandomizeFrame (FRAME NewFrame, FRAME FramePtr)
{
TFB_Image *origImg, *newImg;
CREATE_FLAGS flags;
if (NewFrame == NULL)
{
flags = GetFrameParentDrawable (FramePtr)->Flags;
NewFrame = CaptureDrawable (
CreateDrawable (flags,
GetFrameWidth (FramePtr) << 2,
GetFrameHeight (FramePtr) << 2, 1));
}
newImg = NewFrame->image;
origImg = FramePtr->image;
LockMutex (origImg->mutex);
random16xZoomSurfaceRGBA (origImg->NormalImg, newImg->NormalImg);
UnlockMutex (origImg->mutex);
return (NewFrame);
}
#endif