GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  PODS::SDL::GFX::IMAGEFILTER (3)

.ds Aq ’

NAME

SDL::GFX::ImageFilter - image filtering functions

CONTENTS

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.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 PODS::SDL::GFX::IMAGEFILTER (3) 2016-04-05

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.