---
name: "SDL::GFX::ImageFilter"
section: "3pm"
platform: "linux"
package: "libsdl-perl"
version: "2.548-5+b1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/SDL::GFX::ImageFilter"
---

# SDL::GFX::ImageFilter(3pm)

image filtering functions

## NAME

SDL::GFX::ImageFilter - image filtering functions

## CATEGORY

TODO, GFX

## METHODS

### MMX\_detect

int **gfx\_image\_MMX\_detect()**\
 	CODE:\
 		**SDL\_imageFilterMMXdetect()**;

### MMX\_off

void **gfx\_image\_MMX\_off()**\
 	CODE:\
 		**SDL\_imageFilterMMXoff()**;

### MMX\_on

void **gfx\_image\_MMX\_on()**\
 	CODE:\
 		**SDL\_imageFilterMMXon()**;

### add

int gfx\_image\_add(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterAdd(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### mean

int gfx\_image\_mean(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterMean(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### sub

int gfx\_image\_sub(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterSub(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### abs\_diff

int gfx\_image\_abs\_diff(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterAbsDiff(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### mult

int gfx\_image\_mult(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterMult(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### mult\_nor

int gfx\_image\_mult\_nor(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterMultNor(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### mult\_div\_by\_2

int gfx\_image\_mult\_div\_by\_2(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterMultDivby2(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### mult\_div\_by\_4

int gfx\_image\_mult\_div\_by\_4(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterMultDivby4(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### bit\_and

int gfx\_image\_bit\_and(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterBitAnd(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### bit\_or

int gfx\_image\_bit\_or(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterBitOr(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### div

int gfx\_image\_div(Src1, Src2, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Src2\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterDiv(Src1, Src2, Dest, length);\
 	OUTPUT:\
 		RETVAL

### bit\_negation

int gfx\_image\_bit\_negation(Src1, Dest, length)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	CODE:\
 		RETVAL = SDL\_imageFilterBitNegation(Src1, Dest, length);\
 	OUTPUT:\
 		RETVAL

### add\_byte

int gfx\_image\_add\_byte(Src1, Dest, length, C)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char C\
 	CODE:\
 		RETVAL = SDL\_imageFilterAddByte(Src1, Dest, length, C);\
 	OUTPUT:\
 		RETVAL

### add\_uint

int gfx\_image\_add\_uint(Src1, Dest, length, C)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned int C\
 	CODE:\
 		RETVAL = SDL\_imageFilterAddUint(Src1, Dest, length, C);\
 	OUTPUT:\
 		RETVAL

### add\_byte\_to\_half

int gfx\_image\_add\_byte\_to\_half(Src1, Dest, length, C)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char C\
 	CODE:\
 		RETVAL = SDL\_imageFilterAddByteToHalf(Src1, Dest, length, C);\
 	OUTPUT:\
 		RETVAL

### sub\_byte

int gfx\_image\_sub\_byte(Src1, Dest, length, C)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char C\
 	CODE:\
 		RETVAL = SDL\_imageFilterSubByte(Src1, Dest, length, C);\
 	OUTPUT:\
 		RETVAL

### sub\_uint

int gfx\_image\_sub\_uint(Src1, Dest, length, C)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned int C\
 	CODE:\
 		RETVAL = SDL\_imageFilterSubUint(Src1, Dest, length, C);\
 	OUTPUT:\
 		RETVAL

### shift\_right

int gfx\_image\_shift\_right(Src1, Dest, length, N)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char N\
 	CODE:\
 		RETVAL = SDL\_imageFilterShiftRight(Src1, Dest, length, N);\
 	OUTPUT:\
 		RETVAL

### shift\_right\_uint

int gfx\_image\_shift\_right\_uint(Src1, Dest, length, N)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char N\
 	CODE:\
 		RETVAL = SDL\_imageFilterShiftRightUint(Src1, Dest, length, N);\
 	OUTPUT:\
 		RETVAL

### mult\_by\_byte

int gfx\_image\_mult\_by\_byte(Src1, Dest, length, C)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char C\
 	CODE:\
 		RETVAL = SDL\_imageFilterMultByByte(Src1, Dest, length, C);\
 	OUTPUT:\
 		RETVAL

### shift\_right\_and\_mult\_by\_byte

int gfx\_image\_shift\_right\_and\_mult\_by\_byte(Src1, Dest, length, N, C)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char N\
 	unsigned char C\
 	CODE:\
 		RETVAL = SDL\_imageFilterShiftRightAndMultByByte(Src1, Dest, length, N, C);\
 	OUTPUT:\
 		RETVAL

### shift\_left\_byte

int gfx\_image\_shift\_left\_byte(Src1, Dest, length, N)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char N\
 	CODE:\
 		RETVAL = SDL\_imageFilterShiftLeftByte(Src1, Dest, length, N);\
 	OUTPUT:\
 		RETVAL

### shift\_left\_uint

int gfx\_image\_shift\_left\_uint(Src1, Dest, length, N)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char N\
 	CODE:\
 		RETVAL = SDL\_imageFilterShiftLeftUint(Src1, Dest, length, N);\
 	OUTPUT:\
 		RETVAL

### shift\_left

int gfx\_image\_shift\_left(Src1, Dest, length, N)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char N\
 	CODE:\
 		RETVAL = SDL\_imageFilterShiftLeft(Src1, Dest, length, N);\
 	OUTPUT:\
 		RETVAL

### binarize\_using\_threshold

int gfx\_image\_binarize\_using\_threshold(Src1, Dest, length, T)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char T\
 	CODE:\
 		RETVAL = SDL\_imageFilterBinarizeUsingThreshold(Src1, Dest, length, T);\
 	OUTPUT:\
 		RETVAL

### clip\_to\_range

int gfx\_image\_clip\_to\_range(Src1, Dest, length, Tmin, Tmax)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	unsigned char Tmin\
 	unsigned char Tmax\
 	CODE:\
 		RETVAL = SDL\_imageFilterClipToRange(Src1, Dest, length, Tmin, Tmax);\
 	OUTPUT:\
 		RETVAL

### normalize\_linear

int gfx\_image\_normalize\_linear(Src1, Dest, length, Cmin, Cmax, Nmin, Nmax)\
 	unsigned char \*Src1\
 	unsigned char \*Dest\
 	int length\
 	int Cmin\
 	int Cmax\
 	int Nmin\
 	int Nmax\
 	CODE:\
 		RETVAL = SDL\_imageFilterNormalizeLinear(Src1, Dest, length, Cmin, Cmax, Nmin, Nmax);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_3x3\_divide

int gfx\_image\_convolve\_kernel\_3x3\_divide(Src, Dest, rows, columns, Kernel, Divisor)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char Divisor\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel3x3Divide(Src, Dest, rows, columns, Kernel, Divisor);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_5x5\_divide

int gfx\_image\_convolve\_kernel\_5x5\_divide(Src, Dest, rows, columns, Kernel, Divisor)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char Divisor\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel5x5Divide(Src, Dest, rows, columns, Kernel, Divisor);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_7x7\_divide

int gfx\_image\_convolve\_kernel\_7x7\_divide(Src, Dest, rows, columns, Kernel, Divisor)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char Divisor\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel7x7Divide(Src, Dest, rows, columns, Kernel, Divisor);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_9x9\_divide

int gfx\_image\_convolve\_kernel\_9x9\_divide(Src, Dest, rows, columns, Kernel, Divisor)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char Divisor\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel9x9Divide(Src, Dest, rows, columns, Kernel, Divisor);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_3x3\_shift\_right

int gfx\_image\_convolve\_kernel\_3x3\_shift\_right(Src, Dest, rows, columns, Kernel, NRightShift)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char NRightShift\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel3x3ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_5x5\_shift\_right

int gfx\_image\_convolve\_kernel\_5x5\_shift\_right(Src, Dest, rows, columns, Kernel, NRightShift)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char NRightShift\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel5x5ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_7x7\_shift\_right

int gfx\_image\_convolve\_kernel\_7x7\_shift\_right(Src, Dest, rows, columns, Kernel, NRightShift)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char NRightShift\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel7x7ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);\
 	OUTPUT:\
 		RETVAL

### convolve\_kernel\_9x9\_shift\_right

int gfx\_image\_convolve\_kernel\_9x9\_shift\_right(Src, Dest, rows, columns, Kernel, NRightShift)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	Sint16 \*Kernel\
 	unsigned char NRightShift\
 	CODE:\
 		RETVAL = SDL\_imageFilterConvolveKernel9x9ShiftRight(Src, Dest, rows, columns, Kernel, NRightShift);\
 	OUTPUT:\
 		RETVAL

### sobel\_x

int gfx\_image\_sobel\_x(Src, Dest, rows, columns)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	CODE:\
 		RETVAL = SDL\_imageFilterSobelX(Src, Dest, rows, columns);\
 	OUTPUT:\
 		RETVAL

### sobel\_x\_shift\_right

int gfx\_image\_sobel\_x\_shift\_right(Src, Dest, rows, columns, NRightShift)\
 	unsigned char \*Src\
 	unsigned char \*Dest\
 	int rows\
 	int columns\
 	unsigned char NRightShift\
 	CODE:\
 		RETVAL = SDL\_imageFilterSobelXShiftRight(Src, Dest, rows, columns, NRightShift);\
 	OUTPUT:\
 		RETVAL

### align\_stack

void **gfx\_image\_align\_stack()**\
 	CODE:\
 		**SDL\_imageFilterAlignStack()**;

### restore\_stack

void **gfx\_image\_restore\_stack()**\
 	CODE:\
 		**SDL\_imageFilterRestoreStack()**;

## AUTHORS

See "AUTHORS" in SDL.
