liboil.h   liboil.h 
/* liboil - Library of Optimized Inner Loops /*
* Copyright (C) 2003 David A. Schleef <ds@schleef.org> * LIBOIL - Library of Optimized Inner Loops
* Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
* All rights reserved.
* *
* This library is free software; you can redistribute it and/or * Redistribution and use in source and binary forms, with or without
* modify it under the terms of version 2.1 of the GNU Lesser General * modification, are permitted provided that the following conditions
* Public License as published by the Free Software Foundation. * are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* *
* This library is distributed in the hope that it will be useful, * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* but WITHOUT ANY WARRANTY; without even the implied warranty of * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* Library General Public License for more details. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* You should have received a copy of the GNU Lesser General Public * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* License along with this library; if not, write to the * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* Boston, MA 02111-1307 USA. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef _LIBOIL_H_ #ifndef _LIBOIL_H_
#define _LIBOIL_H_ #define _LIBOIL_H_
#include <stdint.h> #include <stdint.h>
#include <liboil/liboilcpu.h>
#include <liboil/liboildebug.h>
#include <liboil/liboilfunction.h>
#include <liboil/liboilfuncs.h> #include <liboil/liboilfuncs.h>
void oil_init (void);
#define oil_memcpy(dest,src,n_bytes) \
oil_copy_u8((void *)(dest),(void *)(src),(n_bytes))
#define oil_trans8x8_s16(dest, dstr, src, sstr) \
oil_trans8x8_u16((uint16_t *)dest, dstr, (uint16_t *)src, sstr)
#endif #endif
 End of changes. 5 change blocks. 
18 lines changed or deleted 31 lines changed or added


 liboilcpu.h   liboilcpu.h 
/* liboil - Library of Optimized Inner Loops /*
* Copyright (C) 2003 David A. Schleef <ds@schleef.org> * LIBOIL - Library of Optimized Inner Loops
* Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
* All rights reserved.
* *
* This library is free software; you can redistribute it and/or * Redistribution and use in source and binary forms, with or without
* modify it under the terms of version 2.1 of the GNU Lesser General * modification, are permitted provided that the following conditions
* Public License as published by the Free Software Foundation. * are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* *
* This library is distributed in the hope that it will be useful, * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* but WITHOUT ANY WARRANTY; without even the implied warranty of * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* Library General Public License for more details. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* You should have received a copy of the GNU Lesser General Public * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* License along with this library; if not, write to the * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* Boston, MA 02111-1307 USA. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef _LIBOIL_CPU_H_ #ifndef _LIBOIL_CPU_H_
#define _LIBOIL_CPU_H_ #define _LIBOIL_CPU_H_
extern unsigned long oil_cpu_flags;
void _oil_cpu_init (void); void _oil_cpu_init (void);
unsigned int oil_cpu_get_flags (void);
void oil_cpu_fault_check_enable (void);
void oil_cpu_fault_check_disable (void);
int oil_cpu_fault_check_try (void (*func)(void *), void *priv);
double oil_cpu_get_ticks_per_second (void);
#endif #endif
 End of changes. 5 change blocks. 
16 lines changed or deleted 31 lines changed or added


 liboildebug.h   liboildebug.h 
/* liboil - Library of Optimized Inner Loops /*
* Copyright (C) 2003 David A. Schleef <ds@schleef.org> * LIBOIL - Library of Optimized Inner Loops
* Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
* All rights reserved.
* *
* This library is free software; you can redistribute it and/or * Redistribution and use in source and binary forms, with or without
* modify it under the terms of version 2.1 of the GNU Lesser General * modification, are permitted provided that the following conditions
* Public License as published by the Free Software Foundation. * are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* *
* This library is distributed in the hope that it will be useful, * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* but WITHOUT ANY WARRANTY; without even the implied warranty of * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* Library General Public License for more details. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* You should have received a copy of the GNU Lesser General Public * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* License along with this library; if not, write to the * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* Boston, MA 02111-1307 USA. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef _LIBOIL_DEBUG_H_ #ifndef _LIBOIL_DEBUG_H_
#define _LIBOIL_DEBUG_H_ #define _LIBOIL_DEBUG_H_
enum { #include <stdarg.h>
typedef void (*OilDebugPrintFunc) (int level, const char *file,
const char *func, int line, const char *format, va_list varargs);
typedef enum {
OIL_DEBUG_NONE = 0, OIL_DEBUG_NONE = 0,
OIL_DEBUG_ERROR, OIL_DEBUG_ERROR,
OIL_DEBUG_WARNING, OIL_DEBUG_WARNING,
OIL_DEBUG_INFO, OIL_DEBUG_INFO,
OIL_DEBUG_DEBUG, OIL_DEBUG_DEBUG,
OIL_DEBUG_LOG OIL_DEBUG_LOG
}; } OilDebugLevel;
#define OIL_ERROR(...) OIL_DEBUG_PRINT(OIL_DEBUG_ERROR, __VA_ARGS__) #define OIL_ERROR(...) OIL_DEBUG_PRINT(OIL_DEBUG_ERROR, __VA_ARGS__)
#define OIL_WARNING(...) OIL_DEBUG_PRINT(OIL_DEBUG_WARNING, __VA_ARGS__) #define OIL_WARNING(...) OIL_DEBUG_PRINT(OIL_DEBUG_WARNING, __VA_ARGS__)
#define OIL_INFO(...) OIL_DEBUG_PRINT(OIL_DEBUG_INFO, __VA_ARGS__) #define OIL_INFO(...) OIL_DEBUG_PRINT(OIL_DEBUG_INFO, __VA_ARGS__)
#define OIL_DEBUG(...) OIL_DEBUG_PRINT(OIL_DEBUG_DEBUG, __VA_ARGS__) #define OIL_DEBUG(...) OIL_DEBUG_PRINT(OIL_DEBUG_DEBUG, __VA_ARGS__)
#define OIL_LOG(...) OIL_DEBUG_PRINT(OIL_DEBUG_LOG, __VA_ARGS__) #define OIL_LOG(...) OIL_DEBUG_PRINT(OIL_DEBUG_LOG, __VA_ARGS__)
#ifndef __PRETTY_FUNCTION__ #if defined (__GNUC__) || defined (__PRETTY_FUNCTION__)
#define __PRETTY_FUNCTION__ "" #define OIL_FUNCTION __PRETTY_FUNCTION__
#elif defined(__func__)
#define OIL_FUNCTION __func__
#else
#define OIL_FUNCTION ""
#endif #endif
#define OIL_DEBUG_PRINT(level, ...) do { \ #define OIL_DEBUG_PRINT(level, ...) do { \
if(_oil_debug_enabled) { \ _oil_debug_print((level), __FILE__, OIL_FUNCTION, __LINE__, __VA_ARGS__);
oil_debug_print((level), __FILE__, __PRETTY_FUNCTION__, __LINE__, \ \
__VA_ARGS__); \
} \
}while(0) }while(0)
extern int _oil_debug_enabled; void oil_debug_set_print_function (OilDebugPrintFunc func);
extern int _oil_debug_level; int oil_debug_get_level (void);
void oil_debug_set_level (int level);
void _oil_debug_init (void); void _oil_debug_init (void);
void oil_spill (void);
void oil_debug_print (int level, const char *file, const char *func, void _oil_debug_print (int level, const char *file, const char *func,
int line, const char *format, ...); int line, const char *format, ...);
#endif #endif
 End of changes. 10 change blocks. 
26 lines changed or deleted 42 lines changed or added


 liboilfuncs.h   liboilfuncs.h 
/* liboil - Library of Optimized Inner Loops /*
* Copyright (C) 2003 David A. Schleef <ds@schleef.org> * LIBOIL - Library of Optimized Inner Loops
* Copyright (c) 2004 David A. Schleef <ds@schleef.org>
* All rights reserved.
* *
* This library is free software; you can redistribute it and/or * Redistribution and use in source and binary forms, with or without
* modify it under the terms of version 2.1 of the GNU Lesser General * modification, are permitted provided that the following conditions
* Public License as published by the Free Software Foundation. * are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* *
* This library is distributed in the hope that it will be useful, * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* but WITHOUT ANY WARRANTY; without even the implied warranty of * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* Library General Public License for more details. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* You should have received a copy of the GNU Lesser General Public * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* License along with this library; if not, write to the * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* Boston, MA 02111-1307 USA. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
/* This file is automatically generated. Do not edit. */ /* This file is automatically generated. Do not edit. */
#ifndef _LIBOIL_FUNCS_H_ #ifndef _LIBOIL_FUNCS_H_
#define _LIBOIL_FUNCS_H_ #define _LIBOIL_FUNCS_H_
#include <liboil/liboiltypes.h>
#ifdef __cplusplus
extern "C" {
#endif
extern OilFunctionClass *oil_function_class_ptr_abs_f32_f32; extern OilFunctionClass *oil_function_class_ptr_abs_f32_f32;
#define oil_abs_f32_f32 ((void (*)(float *dest, int dstr, float *src, int s typedef void (*_oil_type_abs_f32_f32)(float * dest, int dstr, const float *
str, int n)) \ src, int sstr, int n);
oil_function_class_ptr_abs_f32_f32->func) #define oil_abs_f32_f32 ((_oil_type_abs_f32_f32)(*(void **)oil_function_cla
ss_ptr_abs_f32_f32))
extern OilFunctionClass *oil_function_class_ptr_abs_f64_f64; extern OilFunctionClass *oil_function_class_ptr_abs_f64_f64;
#define oil_abs_f64_f64 ((void (*)(double *dest, int dstr, double *src, int typedef void (*_oil_type_abs_f64_f64)(double * dest, int dstr, const double
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_abs_f64_f64->func) #define oil_abs_f64_f64 ((_oil_type_abs_f64_f64)(*(void **)oil_function_cla
ss_ptr_abs_f64_f64))
extern OilFunctionClass *oil_function_class_ptr_abs_u16_s16; extern OilFunctionClass *oil_function_class_ptr_abs_u16_s16;
#define oil_abs_u16_s16 ((void (*)(uint16_t *dest, int dstr, int16_t *src, typedef void (*_oil_type_abs_u16_s16)(uint16_t * dest, int dstr, const int1
int sstr, int n)) \ 6_t * src, int sstr, int n);
oil_function_class_ptr_abs_u16_s16->func) #define oil_abs_u16_s16 ((_oil_type_abs_u16_s16)(*(void **)oil_function_cla
ss_ptr_abs_u16_s16))
extern OilFunctionClass *oil_function_class_ptr_abs_u32_s32; extern OilFunctionClass *oil_function_class_ptr_abs_u32_s32;
#define oil_abs_u32_s32 ((void (*)(uint32_t *dest, int dstr, int32_t *src, typedef void (*_oil_type_abs_u32_s32)(uint32_t * dest, int dstr, const int3
int sstr, int n)) \ 2_t * src, int sstr, int n);
oil_function_class_ptr_abs_u32_s32->func) #define oil_abs_u32_s32 ((_oil_type_abs_u32_s32)(*(void **)oil_function_cla
ss_ptr_abs_u32_s32))
extern OilFunctionClass *oil_function_class_ptr_abs_u8_s8; extern OilFunctionClass *oil_function_class_ptr_abs_u8_s8;
#define oil_abs_u8_s8 ((void (*)(uint8_t *dest, int dstr, int8_t *src, int typedef void (*_oil_type_abs_u8_s8)(uint8_t * dest, int dstr, const int8_t
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_abs_u8_s8->func) #define oil_abs_u8_s8 ((_oil_type_abs_u8_s8)(*(void **)oil_function_class_p
tr_abs_u8_s8))
extern OilFunctionClass *oil_function_class_ptr_add_f32;
typedef void (*_oil_type_add_f32)(float * d, const float * s1, const float
* s2, int n);
#define oil_add_f32 ((_oil_type_add_f32)(*(void **)oil_function_class_ptr_a
dd_f32))
extern OilFunctionClass *oil_function_class_ptr_argb_paint_u8;
typedef void (*_oil_type_argb_paint_u8)(uint8_t * i_4xn, const uint8_t * s1
_4, const uint8_t * s2_n, int n);
#define oil_argb_paint_u8 ((_oil_type_argb_paint_u8)(*(void **)oil_function
_class_ptr_argb_paint_u8))
extern OilFunctionClass *oil_function_class_ptr_average2_u8; extern OilFunctionClass *oil_function_class_ptr_average2_u8;
#define oil_average2_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src1, typedef void (*_oil_type_average2_u8)(uint8_t * dest, int dstr, const uint8
int sstr1, uint8_t *src2, int sstr2, int n)) \ _t * src1, int sstr1, const uint8_t * src2, int sstr2, int n);
oil_function_class_ptr_average2_u8->func) #define oil_average2_u8 ((_oil_type_average2_u8)(*(void **)oil_function_cla
ss_ptr_average2_u8))
extern OilFunctionClass *oil_function_class_ptr_ayuv2argb_u8;
typedef void (*_oil_type_ayuv2argb_u8)(uint8_t * d_4xn, const uint8_t * s_4
xn, int n);
#define oil_ayuv2argb_u8 ((_oil_type_ayuv2argb_u8)(*(void **)oil_function_c
lass_ptr_ayuv2argb_u8))
extern OilFunctionClass *oil_function_class_ptr_ayuv2uyvy;
typedef void (*_oil_type_ayuv2uyvy)(uint32_t * d_n, const uint32_t * s_n, i
nt n);
#define oil_ayuv2uyvy ((_oil_type_ayuv2uyvy)(*(void **)oil_function_class_p
tr_ayuv2uyvy))
extern OilFunctionClass *oil_function_class_ptr_ayuv2yuyv;
typedef void (*_oil_type_ayuv2yuyv)(uint32_t * d_n, const uint32_t * s_n, i
nt n);
#define oil_ayuv2yuyv ((_oil_type_ayuv2yuyv)(*(void **)oil_function_class_p
tr_ayuv2yuyv))
extern OilFunctionClass *oil_function_class_ptr_ayuv2yvyu;
typedef void (*_oil_type_ayuv2yvyu)(uint32_t * d_n, const uint32_t * s_n, i
nt n);
#define oil_ayuv2yvyu ((_oil_type_ayuv2yvyu)(*(void **)oil_function_class_p
tr_ayuv2yvyu))
extern OilFunctionClass *oil_function_class_ptr_clip_f32; extern OilFunctionClass *oil_function_class_ptr_clip_f32;
#define oil_clip_f32 ((void (*)(float *dest, int dstr, float *src, int sstr typedef void (*_oil_type_clip_f32)(float * dest, int dstr, const float * sr
, int n, float param1, float param2)) \ c, int sstr, int n, const float * s2_1, const float * s3_1);
oil_function_class_ptr_clip_f32->func) #define oil_clip_f32 ((_oil_type_clip_f32)(*(void **)oil_function_class_ptr
_clip_f32))
extern OilFunctionClass *oil_function_class_ptr_clip_f64; extern OilFunctionClass *oil_function_class_ptr_clip_f64;
#define oil_clip_f64 ((void (*)(double *dest, int dstr, double *src, int ss typedef void (*_oil_type_clip_f64)(double * dest, int dstr, const double *
tr, int n, double param1, double param2)) \ src, int sstr, int n, const double * s2_1, const double * s3_1);
oil_function_class_ptr_clip_f64->func) #define oil_clip_f64 ((_oil_type_clip_f64)(*(void **)oil_function_class_ptr
_clip_f64))
extern OilFunctionClass *oil_function_class_ptr_clip_s16; extern OilFunctionClass *oil_function_class_ptr_clip_s16;
#define oil_clip_s16 ((void (*)(int16_t *dest, int dstr, int16_t *src, int typedef void (*_oil_type_clip_s16)(int16_t * dest, int dstr, const int16_t
sstr, int n, int16_t param1, int16_t param2)) \ * src, int sstr, int n, const int16_t * s2_1, const int16_t * s3_1);
oil_function_class_ptr_clip_s16->func) #define oil_clip_s16 ((_oil_type_clip_s16)(*(void **)oil_function_class_ptr
_clip_s16))
extern OilFunctionClass *oil_function_class_ptr_clip_s32; extern OilFunctionClass *oil_function_class_ptr_clip_s32;
#define oil_clip_s32 ((void (*)(int32_t *dest, int dstr, int32_t *src, int typedef void (*_oil_type_clip_s32)(int32_t * dest, int dstr, const int32_t
sstr, int n, int32_t param1, int32_t param2)) \ * src, int sstr, int n, const int32_t * s2_1, const int32_t * s3_1);
oil_function_class_ptr_clip_s32->func) #define oil_clip_s32 ((_oil_type_clip_s32)(*(void **)oil_function_class_ptr
_clip_s32))
extern OilFunctionClass *oil_function_class_ptr_clip_s8; extern OilFunctionClass *oil_function_class_ptr_clip_s8;
#define oil_clip_s8 ((void (*)(int8_t *dest, int dstr, int8_t *src, int sst typedef void (*_oil_type_clip_s8)(int8_t * dest, int dstr, const int8_t * s
r, int n, int8_t param1, int8_t param2)) \ rc, int sstr, int n, const int8_t * s2_1, const int8_t * s3_1);
oil_function_class_ptr_clip_s8->func) #define oil_clip_s8 ((_oil_type_clip_s8)(*(void **)oil_function_class_ptr_c
lip_s8))
extern OilFunctionClass *oil_function_class_ptr_clip_u16; extern OilFunctionClass *oil_function_class_ptr_clip_u16;
#define oil_clip_u16 ((void (*)(uint16_t *dest, int dstr, uint16_t *src, in typedef void (*_oil_type_clip_u16)(uint16_t * dest, int dstr, const uint16_
t sstr, int n, uint16_t param1, uint16_t param2)) \ t * src, int sstr, int n, const uint16_t * s2_1, const uint16_t * s3_1);
oil_function_class_ptr_clip_u16->func) #define oil_clip_u16 ((_oil_type_clip_u16)(*(void **)oil_function_class_ptr
_clip_u16))
extern OilFunctionClass *oil_function_class_ptr_clip_u32; extern OilFunctionClass *oil_function_class_ptr_clip_u32;
#define oil_clip_u32 ((void (*)(uint32_t *dest, int dstr, uint32_t *src, in typedef void (*_oil_type_clip_u32)(uint32_t * dest, int dstr, const uint32_
t sstr, int n, uint32_t param1, uint32_t param2)) \ t * src, int sstr, int n, const uint32_t * s2_1, const uint32_t * s3_1);
oil_function_class_ptr_clip_u32->func) #define oil_clip_u32 ((_oil_type_clip_u32)(*(void **)oil_function_class_ptr
_clip_u32))
extern OilFunctionClass *oil_function_class_ptr_clip_u8; extern OilFunctionClass *oil_function_class_ptr_clip_u8;
#define oil_clip_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src, int s typedef void (*_oil_type_clip_u8)(uint8_t * dest, int dstr, const uint8_t *
str, int n, uint8_t param1, uint8_t param2)) \ src, int sstr, int n, const uint8_t * s2_1, const uint8_t * s3_1);
oil_function_class_ptr_clip_u8->func) #define oil_clip_u8 ((_oil_type_clip_u8)(*(void **)oil_function_class_ptr_c
lip_u8))
extern OilFunctionClass *oil_function_class_ptr_clipconv8x8_u8_s16; extern OilFunctionClass *oil_function_class_ptr_clipconv8x8_u8_s16;
#define oil_clipconv8x8_u8_s16 ((void (*)(uint8_t *dest, int dstr, int16_t typedef void (*_oil_type_clipconv8x8_u8_s16)(uint8_t * d_8x8, int dstr, con
*src, int sstr)) \ st int16_t * s_8x8, int sstr);
oil_function_class_ptr_clipconv8x8_u8_s16->func) #define oil_clipconv8x8_u8_s16 ((_oil_type_clipconv8x8_u8_s16)(*(void **)oi
l_function_class_ptr_clipconv8x8_u8_s16))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_f32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_f32;
#define oil_clipconv_s16_f32 ((void (*)(int16_t *dest, int dstr, float *src typedef void (*_oil_type_clipconv_s16_f32)(int16_t * dest, int dstr, const
, int sstr, int n)) \ float * src, int sstr, int n);
oil_function_class_ptr_clipconv_s16_f32->func) #define oil_clipconv_s16_f32 ((_oil_type_clipconv_s16_f32)(*(void **)oil_fu
nction_class_ptr_clipconv_s16_f32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_f64; extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_f64;
#define oil_clipconv_s16_f64 ((void (*)(int16_t *dest, int dstr, double *sr typedef void (*_oil_type_clipconv_s16_f64)(int16_t * dest, int dstr, const
c, int sstr, int n)) \ double * src, int sstr, int n);
oil_function_class_ptr_clipconv_s16_f64->func) #define oil_clipconv_s16_f64 ((_oil_type_clipconv_s16_f64)(*(void **)oil_fu
nction_class_ptr_clipconv_s16_f64))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_s32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_s32;
#define oil_clipconv_s16_s32 ((void (*)(int16_t *dest, int dstr, int32_t *s typedef void (*_oil_type_clipconv_s16_s32)(int16_t * dest, int dstr, const
rc, int sstr, int n)) \ int32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s16_s32->func) #define oil_clipconv_s16_s32 ((_oil_type_clipconv_s16_s32)(*(void **)oil_fu
nction_class_ptr_clipconv_s16_s32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_u16; extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_u16;
#define oil_clipconv_s16_u16 ((void (*)(int16_t *dest, int dstr, uint16_t * typedef void (*_oil_type_clipconv_s16_u16)(int16_t * dest, int dstr, const
src, int sstr, int n)) \ uint16_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s16_u16->func) #define oil_clipconv_s16_u16 ((_oil_type_clipconv_s16_u16)(*(void **)oil_fu
nction_class_ptr_clipconv_s16_u16))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_u32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s16_u32;
#define oil_clipconv_s16_u32 ((void (*)(int16_t *dest, int dstr, uint32_t * typedef void (*_oil_type_clipconv_s16_u32)(int16_t * dest, int dstr, const
src, int sstr, int n)) \ uint32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s16_u32->func) #define oil_clipconv_s16_u32 ((_oil_type_clipconv_s16_u32)(*(void **)oil_fu
nction_class_ptr_clipconv_s16_u32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s32_f32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s32_f32;
#define oil_clipconv_s32_f32 ((void (*)(int32_t *dest, int dstr, float *src typedef void (*_oil_type_clipconv_s32_f32)(int32_t * dest, int dstr, const
, int sstr, int n)) \ float * src, int sstr, int n);
oil_function_class_ptr_clipconv_s32_f32->func) #define oil_clipconv_s32_f32 ((_oil_type_clipconv_s32_f32)(*(void **)oil_fu
nction_class_ptr_clipconv_s32_f32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s32_f64; extern OilFunctionClass *oil_function_class_ptr_clipconv_s32_f64;
#define oil_clipconv_s32_f64 ((void (*)(int32_t *dest, int dstr, double *sr typedef void (*_oil_type_clipconv_s32_f64)(int32_t * dest, int dstr, const
c, int sstr, int n)) \ double * src, int sstr, int n);
oil_function_class_ptr_clipconv_s32_f64->func) #define oil_clipconv_s32_f64 ((_oil_type_clipconv_s32_f64)(*(void **)oil_fu
nction_class_ptr_clipconv_s32_f64))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s32_u32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s32_u32;
#define oil_clipconv_s32_u32 ((void (*)(int32_t *dest, int dstr, uint32_t * typedef void (*_oil_type_clipconv_s32_u32)(int32_t * dest, int dstr, const
src, int sstr, int n)) \ uint32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s32_u32->func) #define oil_clipconv_s32_u32 ((_oil_type_clipconv_s32_u32)(*(void **)oil_fu
nction_class_ptr_clipconv_s32_u32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_f32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_f32;
#define oil_clipconv_s8_f32 ((void (*)(int8_t *dest, int dstr, float *src, typedef void (*_oil_type_clipconv_s8_f32)(int8_t * dest, int dstr, const fl
int sstr, int n)) \ oat * src, int sstr, int n);
oil_function_class_ptr_clipconv_s8_f32->func) #define oil_clipconv_s8_f32 ((_oil_type_clipconv_s8_f32)(*(void **)oil_func
tion_class_ptr_clipconv_s8_f32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_f64; extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_f64;
#define oil_clipconv_s8_f64 ((void (*)(int8_t *dest, int dstr, double *src, typedef void (*_oil_type_clipconv_s8_f64)(int8_t * dest, int dstr, const do
int sstr, int n)) \ uble * src, int sstr, int n);
oil_function_class_ptr_clipconv_s8_f64->func) #define oil_clipconv_s8_f64 ((_oil_type_clipconv_s8_f64)(*(void **)oil_func
tion_class_ptr_clipconv_s8_f64))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_s16; extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_s16;
#define oil_clipconv_s8_s16 ((void (*)(int8_t *dest, int dstr, int16_t *src typedef void (*_oil_type_clipconv_s8_s16)(int8_t * dest, int dstr, const in
, int sstr, int n)) \ t16_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s8_s16->func) #define oil_clipconv_s8_s16 ((_oil_type_clipconv_s8_s16)(*(void **)oil_func
tion_class_ptr_clipconv_s8_s16))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_s32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_s32;
#define oil_clipconv_s8_s32 ((void (*)(int8_t *dest, int dstr, int32_t *src typedef void (*_oil_type_clipconv_s8_s32)(int8_t * dest, int dstr, const in
, int sstr, int n)) \ t32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s8_s32->func) #define oil_clipconv_s8_s32 ((_oil_type_clipconv_s8_s32)(*(void **)oil_func
tion_class_ptr_clipconv_s8_s32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_u16; extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_u16;
#define oil_clipconv_s8_u16 ((void (*)(int8_t *dest, int dstr, uint16_t *sr typedef void (*_oil_type_clipconv_s8_u16)(int8_t * dest, int dstr, const ui
c, int sstr, int n)) \ nt16_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s8_u16->func) #define oil_clipconv_s8_u16 ((_oil_type_clipconv_s8_u16)(*(void **)oil_func
tion_class_ptr_clipconv_s8_u16))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_u32; extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_u32;
#define oil_clipconv_s8_u32 ((void (*)(int8_t *dest, int dstr, uint32_t *sr typedef void (*_oil_type_clipconv_s8_u32)(int8_t * dest, int dstr, const ui
c, int sstr, int n)) \ nt32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s8_u32->func) #define oil_clipconv_s8_u32 ((_oil_type_clipconv_s8_u32)(*(void **)oil_func
tion_class_ptr_clipconv_s8_u32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_u8; extern OilFunctionClass *oil_function_class_ptr_clipconv_s8_u8;
#define oil_clipconv_s8_u8 ((void (*)(int8_t *dest, int dstr, uint8_t *src, typedef void (*_oil_type_clipconv_s8_u8)(int8_t * dest, int dstr, const uin
int sstr, int n)) \ t8_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_s8_u8->func) #define oil_clipconv_s8_u8 ((_oil_type_clipconv_s8_u8)(*(void **)oil_functi
on_class_ptr_clipconv_s8_u8))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_f32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_f32;
#define oil_clipconv_u16_f32 ((void (*)(uint16_t *dest, int dstr, float *sr typedef void (*_oil_type_clipconv_u16_f32)(uint16_t * dest, int dstr, const
c, int sstr, int n)) \ float * src, int sstr, int n);
oil_function_class_ptr_clipconv_u16_f32->func) #define oil_clipconv_u16_f32 ((_oil_type_clipconv_u16_f32)(*(void **)oil_fu
nction_class_ptr_clipconv_u16_f32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_f64; extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_f64;
#define oil_clipconv_u16_f64 ((void (*)(uint16_t *dest, int dstr, double *s typedef void (*_oil_type_clipconv_u16_f64)(uint16_t * dest, int dstr, const
rc, int sstr, int n)) \ double * src, int sstr, int n);
oil_function_class_ptr_clipconv_u16_f64->func) #define oil_clipconv_u16_f64 ((_oil_type_clipconv_u16_f64)(*(void **)oil_fu
nction_class_ptr_clipconv_u16_f64))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_s16; extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_s16;
#define oil_clipconv_u16_s16 ((void (*)(uint16_t *dest, int dstr, int16_t * typedef void (*_oil_type_clipconv_u16_s16)(uint16_t * dest, int dstr, const
src, int sstr, int n)) \ int16_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u16_s16->func) #define oil_clipconv_u16_s16 ((_oil_type_clipconv_u16_s16)(*(void **)oil_fu
nction_class_ptr_clipconv_u16_s16))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_s32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_s32;
#define oil_clipconv_u16_s32 ((void (*)(uint16_t *dest, int dstr, int32_t * typedef void (*_oil_type_clipconv_u16_s32)(uint16_t * dest, int dstr, const
src, int sstr, int n)) \ int32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u16_s32->func) #define oil_clipconv_u16_s32 ((_oil_type_clipconv_u16_s32)(*(void **)oil_fu
nction_class_ptr_clipconv_u16_s32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_u32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u16_u32;
#define oil_clipconv_u16_u32 ((void (*)(uint16_t *dest, int dstr, uint32_t typedef void (*_oil_type_clipconv_u16_u32)(uint16_t * dest, int dstr, const
*src, int sstr, int n)) \ uint32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u16_u32->func) #define oil_clipconv_u16_u32 ((_oil_type_clipconv_u16_u32)(*(void **)oil_fu
nction_class_ptr_clipconv_u16_u32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u32_f32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u32_f32;
#define oil_clipconv_u32_f32 ((void (*)(uint32_t *dest, int dstr, float *sr typedef void (*_oil_type_clipconv_u32_f32)(uint32_t * dest, int dstr, const
c, int sstr, int n)) \ float * src, int sstr, int n);
oil_function_class_ptr_clipconv_u32_f32->func) #define oil_clipconv_u32_f32 ((_oil_type_clipconv_u32_f32)(*(void **)oil_fu
nction_class_ptr_clipconv_u32_f32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u32_f64; extern OilFunctionClass *oil_function_class_ptr_clipconv_u32_f64;
#define oil_clipconv_u32_f64 ((void (*)(uint32_t *dest, int dstr, double *s typedef void (*_oil_type_clipconv_u32_f64)(uint32_t * dest, int dstr, const
rc, int sstr, int n)) \ double * src, int sstr, int n);
oil_function_class_ptr_clipconv_u32_f64->func) #define oil_clipconv_u32_f64 ((_oil_type_clipconv_u32_f64)(*(void **)oil_fu
nction_class_ptr_clipconv_u32_f64))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u32_s32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u32_s32;
#define oil_clipconv_u32_s32 ((void (*)(uint32_t *dest, int dstr, int32_t * typedef void (*_oil_type_clipconv_u32_s32)(uint32_t * dest, int dstr, const
src, int sstr, int n)) \ int32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u32_s32->func) #define oil_clipconv_u32_s32 ((_oil_type_clipconv_u32_s32)(*(void **)oil_fu
nction_class_ptr_clipconv_u32_s32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_f32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_f32;
#define oil_clipconv_u8_f32 ((void (*)(uint8_t *dest, int dstr, float *src, typedef void (*_oil_type_clipconv_u8_f32)(uint8_t * dest, int dstr, const f
int sstr, int n)) \ loat * src, int sstr, int n);
oil_function_class_ptr_clipconv_u8_f32->func) #define oil_clipconv_u8_f32 ((_oil_type_clipconv_u8_f32)(*(void **)oil_func
tion_class_ptr_clipconv_u8_f32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_f64; extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_f64;
#define oil_clipconv_u8_f64 ((void (*)(uint8_t *dest, int dstr, double *src typedef void (*_oil_type_clipconv_u8_f64)(uint8_t * dest, int dstr, const d
, int sstr, int n)) \ ouble * src, int sstr, int n);
oil_function_class_ptr_clipconv_u8_f64->func) #define oil_clipconv_u8_f64 ((_oil_type_clipconv_u8_f64)(*(void **)oil_func
tion_class_ptr_clipconv_u8_f64))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_s16; extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_s16;
#define oil_clipconv_u8_s16 ((void (*)(uint8_t *dest, int dstr, int16_t *sr typedef void (*_oil_type_clipconv_u8_s16)(uint8_t * dest, int dstr, const i
c, int sstr, int n)) \ nt16_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u8_s16->func) #define oil_clipconv_u8_s16 ((_oil_type_clipconv_u8_s16)(*(void **)oil_func
tion_class_ptr_clipconv_u8_s16))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_s32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_s32;
#define oil_clipconv_u8_s32 ((void (*)(uint8_t *dest, int dstr, int32_t *sr typedef void (*_oil_type_clipconv_u8_s32)(uint8_t * dest, int dstr, const i
c, int sstr, int n)) \ nt32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u8_s32->func) #define oil_clipconv_u8_s32 ((_oil_type_clipconv_u8_s32)(*(void **)oil_func
tion_class_ptr_clipconv_u8_s32))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_s8; extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_s8;
#define oil_clipconv_u8_s8 ((void (*)(uint8_t *dest, int dstr, int8_t *src, typedef void (*_oil_type_clipconv_u8_s8)(uint8_t * dest, int dstr, const in
int sstr, int n)) \ t8_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u8_s8->func) #define oil_clipconv_u8_s8 ((_oil_type_clipconv_u8_s8)(*(void **)oil_functi
on_class_ptr_clipconv_u8_s8))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_u16; extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_u16;
#define oil_clipconv_u8_u16 ((void (*)(uint8_t *dest, int dstr, uint16_t *s typedef void (*_oil_type_clipconv_u8_u16)(uint8_t * dest, int dstr, const u
rc, int sstr, int n)) \ int16_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u8_u16->func) #define oil_clipconv_u8_u16 ((_oil_type_clipconv_u8_u16)(*(void **)oil_func
tion_class_ptr_clipconv_u8_u16))
extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_u32; extern OilFunctionClass *oil_function_class_ptr_clipconv_u8_u32;
#define oil_clipconv_u8_u32 ((void (*)(uint8_t *dest, int dstr, uint32_t *s typedef void (*_oil_type_clipconv_u8_u32)(uint8_t * dest, int dstr, const u
rc, int sstr, int n)) \ int32_t * src, int sstr, int n);
oil_function_class_ptr_clipconv_u8_u32->func) #define oil_clipconv_u8_u32 ((_oil_type_clipconv_u8_u32)(*(void **)oil_func
tion_class_ptr_clipconv_u8_u32))
extern OilFunctionClass *oil_function_class_ptr_colsad8x8_u8;
typedef void (*_oil_type_colsad8x8_u8)(uint32_t * d_1, const uint8_t * s1_8
x8, int ss1, const uint8_t * s2_8x8, int ss2);
#define oil_colsad8x8_u8 ((_oil_type_colsad8x8_u8)(*(void **)oil_function_c
lass_ptr_colsad8x8_u8))
extern OilFunctionClass *oil_function_class_ptr_composite_add_argb;
typedef void (*_oil_type_composite_add_argb)(uint32_t * i_n, const uint32_t
* s1_n, int n);
#define oil_composite_add_argb ((_oil_type_composite_add_argb)(*(void **)oi
l_function_class_ptr_composite_add_argb))
extern OilFunctionClass *oil_function_class_ptr_composite_add_argb_const_sr
c;
typedef void (*_oil_type_composite_add_argb_const_src)(uint32_t * i_n, cons
t uint32_t * s1_1, int n);
#define oil_composite_add_argb_const_src ((_oil_type_composite_add_argb_con
st_src)(*(void **)oil_function_class_ptr_composite_add_argb_const_src))
extern OilFunctionClass *oil_function_class_ptr_composite_add_u8;
typedef void (*_oil_type_composite_add_u8)(uint8_t * i_n, const uint8_t * s
1_n, int n);
#define oil_composite_add_u8 ((_oil_type_composite_add_u8)(*(void **)oil_fu
nction_class_ptr_composite_add_u8))
extern OilFunctionClass *oil_function_class_ptr_composite_in_argb;
typedef void (*_oil_type_composite_in_argb)(uint32_t * d_n, const uint32_t
* s1_n, const uint8_t * s2_n, int n);
#define oil_composite_in_argb ((_oil_type_composite_in_argb)(*(void **)oil_
function_class_ptr_composite_in_argb))
extern OilFunctionClass *oil_function_class_ptr_composite_in_argb_const_mas
k;
typedef void (*_oil_type_composite_in_argb_const_mask)(uint32_t * d_n, cons
t uint32_t * s1_n, const uint8_t * s2_1, int n);
#define oil_composite_in_argb_const_mask ((_oil_type_composite_in_argb_cons
t_mask)(*(void **)oil_function_class_ptr_composite_in_argb_const_mask))
extern OilFunctionClass *oil_function_class_ptr_composite_in_argb_const_src
;
typedef void (*_oil_type_composite_in_argb_const_src)(uint32_t * d_n, const
uint32_t * s1_1, const uint8_t * s2_n, int n);
#define oil_composite_in_argb_const_src ((_oil_type_composite_in_argb_const
_src)(*(void **)oil_function_class_ptr_composite_in_argb_const_src))
extern OilFunctionClass *oil_function_class_ptr_composite_in_over_argb;
typedef void (*_oil_type_composite_in_over_argb)(uint32_t * i_n, const uint
32_t * s1_n, const uint8_t * s2_n, int n);
#define oil_composite_in_over_argb ((_oil_type_composite_in_over_argb)(*(vo
id **)oil_function_class_ptr_composite_in_over_argb))
extern OilFunctionClass *oil_function_class_ptr_composite_in_over_argb_cons
t_mask;
typedef void (*_oil_type_composite_in_over_argb_const_mask)(uint32_t * i_n,
const uint32_t * s1_n, const uint8_t * s2_1, int n);
#define oil_composite_in_over_argb_const_mask ((_oil_type_composite_in_over
_argb_const_mask)(*(void **)oil_function_class_ptr_composite_in_over_argb_c
onst_mask))
extern OilFunctionClass *oil_function_class_ptr_composite_in_over_argb_cons
t_src;
typedef void (*_oil_type_composite_in_over_argb_const_src)(uint32_t * i_n,
const uint32_t * s1_1, const uint8_t * s2_n, int n);
#define oil_composite_in_over_argb_const_src ((_oil_type_composite_in_over_
argb_const_src)(*(void **)oil_function_class_ptr_composite_in_over_argb_con
st_src))
extern OilFunctionClass *oil_function_class_ptr_composite_over_argb;
typedef void (*_oil_type_composite_over_argb)(uint32_t * i_n, const uint32_
t * s1_n, int n);
#define oil_composite_over_argb ((_oil_type_composite_over_argb)(*(void **)
oil_function_class_ptr_composite_over_argb))
extern OilFunctionClass *oil_function_class_ptr_composite_over_argb_const_s
rc;
typedef void (*_oil_type_composite_over_argb_const_src)(uint32_t * i_n, con
st uint32_t * s1_1, int n);
#define oil_composite_over_argb_const_src ((_oil_type_composite_over_argb_c
onst_src)(*(void **)oil_function_class_ptr_composite_over_argb_const_src))
extern OilFunctionClass *oil_function_class_ptr_composite_over_u8;
typedef void (*_oil_type_composite_over_u8)(uint8_t * i_n, const uint8_t *
s1_n, int n);
#define oil_composite_over_u8 ((_oil_type_composite_over_u8)(*(void **)oil_
function_class_ptr_composite_over_u8))
extern OilFunctionClass *oil_function_class_ptr_conv8x8_f64_s16; extern OilFunctionClass *oil_function_class_ptr_conv8x8_f64_s16;
#define oil_conv8x8_f64_s16 ((void (*)(double *dest, int dstr, int16_t *src typedef void (*_oil_type_conv8x8_f64_s16)(double * d_8x8, int dstr, const i
, int sstr)) \ nt16_t * s_8x8, int sstr);
oil_function_class_ptr_conv8x8_f64_s16->func) #define oil_conv8x8_f64_s16 ((_oil_type_conv8x8_f64_s16)(*(void **)oil_func
tion_class_ptr_conv8x8_f64_s16))
extern OilFunctionClass *oil_function_class_ptr_conv8x8_s16_f64; extern OilFunctionClass *oil_function_class_ptr_conv8x8_s16_f64;
#define oil_conv8x8_s16_f64 ((void (*)(int16_t *dest, int dstr, double *src typedef void (*_oil_type_conv8x8_s16_f64)(int16_t * d_8x8, int dstr, const
, int sstr)) \ double * s_8x8, int sstr);
oil_function_class_ptr_conv8x8_s16_f64->func) #define oil_conv8x8_s16_f64 ((_oil_type_conv8x8_s16_f64)(*(void **)oil_func
tion_class_ptr_conv8x8_s16_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_f32_f64; extern OilFunctionClass *oil_function_class_ptr_conv_f32_f64;
#define oil_conv_f32_f64 ((void (*)(float *dest, int dstr, double *src, int typedef void (*_oil_type_conv_f32_f64)(float * dest, int dstr, const double
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_f32_f64->func) #define oil_conv_f32_f64 ((_oil_type_conv_f32_f64)(*(void **)oil_function_c
lass_ptr_conv_f32_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_f32_s16; extern OilFunctionClass *oil_function_class_ptr_conv_f32_s16;
#define oil_conv_f32_s16 ((void (*)(float *dest, int dstr, int16_t *src, in typedef void (*_oil_type_conv_f32_s16)(float * dest, int dstr, const int16_
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_f32_s16->func) #define oil_conv_f32_s16 ((_oil_type_conv_f32_s16)(*(void **)oil_function_c
lass_ptr_conv_f32_s16))
extern OilFunctionClass *oil_function_class_ptr_conv_f32_s32; extern OilFunctionClass *oil_function_class_ptr_conv_f32_s32;
#define oil_conv_f32_s32 ((void (*)(float *dest, int dstr, int32_t *src, in typedef void (*_oil_type_conv_f32_s32)(float * dest, int dstr, const int32_
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_f32_s32->func) #define oil_conv_f32_s32 ((_oil_type_conv_f32_s32)(*(void **)oil_function_c
lass_ptr_conv_f32_s32))
extern OilFunctionClass *oil_function_class_ptr_conv_f32_s8; extern OilFunctionClass *oil_function_class_ptr_conv_f32_s8;
#define oil_conv_f32_s8 ((void (*)(float *dest, int dstr, int8_t *src, int typedef void (*_oil_type_conv_f32_s8)(float * dest, int dstr, const int8_t
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_f32_s8->func) #define oil_conv_f32_s8 ((_oil_type_conv_f32_s8)(*(void **)oil_function_cla
ss_ptr_conv_f32_s8))
extern OilFunctionClass *oil_function_class_ptr_conv_f32_u16; extern OilFunctionClass *oil_function_class_ptr_conv_f32_u16;
#define oil_conv_f32_u16 ((void (*)(float *dest, int dstr, uint16_t *src, i typedef void (*_oil_type_conv_f32_u16)(float * dest, int dstr, const uint16
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_f32_u16->func) #define oil_conv_f32_u16 ((_oil_type_conv_f32_u16)(*(void **)oil_function_c
lass_ptr_conv_f32_u16))
extern OilFunctionClass *oil_function_class_ptr_conv_f32_u32; extern OilFunctionClass *oil_function_class_ptr_conv_f32_u32;
#define oil_conv_f32_u32 ((void (*)(float *dest, int dstr, uint32_t *src, i typedef void (*_oil_type_conv_f32_u32)(float * dest, int dstr, const uint32
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_f32_u32->func) #define oil_conv_f32_u32 ((_oil_type_conv_f32_u32)(*(void **)oil_function_c
lass_ptr_conv_f32_u32))
extern OilFunctionClass *oil_function_class_ptr_conv_f32_u8; extern OilFunctionClass *oil_function_class_ptr_conv_f32_u8;
#define oil_conv_f32_u8 ((void (*)(float *dest, int dstr, uint8_t *src, int typedef void (*_oil_type_conv_f32_u8)(float * dest, int dstr, const uint8_t
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_f32_u8->func) #define oil_conv_f32_u8 ((_oil_type_conv_f32_u8)(*(void **)oil_function_cla
ss_ptr_conv_f32_u8))
extern OilFunctionClass *oil_function_class_ptr_conv_f64_f32; extern OilFunctionClass *oil_function_class_ptr_conv_f64_f32;
#define oil_conv_f64_f32 ((void (*)(double *dest, int dstr, float *src, int typedef void (*_oil_type_conv_f64_f32)(double * dest, int dstr, const float
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_f64_f32->func) #define oil_conv_f64_f32 ((_oil_type_conv_f64_f32)(*(void **)oil_function_c
lass_ptr_conv_f64_f32))
extern OilFunctionClass *oil_function_class_ptr_conv_f64_s16; extern OilFunctionClass *oil_function_class_ptr_conv_f64_s16;
#define oil_conv_f64_s16 ((void (*)(double *dest, int dstr, int16_t *src, i typedef void (*_oil_type_conv_f64_s16)(double * dest, int dstr, const int16
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_f64_s16->func) #define oil_conv_f64_s16 ((_oil_type_conv_f64_s16)(*(void **)oil_function_c
lass_ptr_conv_f64_s16))
extern OilFunctionClass *oil_function_class_ptr_conv_f64_s32; extern OilFunctionClass *oil_function_class_ptr_conv_f64_s32;
#define oil_conv_f64_s32 ((void (*)(double *dest, int dstr, int32_t *src, i typedef void (*_oil_type_conv_f64_s32)(double * dest, int dstr, const int32
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_f64_s32->func) #define oil_conv_f64_s32 ((_oil_type_conv_f64_s32)(*(void **)oil_function_c
lass_ptr_conv_f64_s32))
extern OilFunctionClass *oil_function_class_ptr_conv_f64_s8; extern OilFunctionClass *oil_function_class_ptr_conv_f64_s8;
#define oil_conv_f64_s8 ((void (*)(double *dest, int dstr, int8_t *src, int typedef void (*_oil_type_conv_f64_s8)(double * dest, int dstr, const int8_t
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_f64_s8->func) #define oil_conv_f64_s8 ((_oil_type_conv_f64_s8)(*(void **)oil_function_cla
ss_ptr_conv_f64_s8))
extern OilFunctionClass *oil_function_class_ptr_conv_f64_u16; extern OilFunctionClass *oil_function_class_ptr_conv_f64_u16;
#define oil_conv_f64_u16 ((void (*)(double *dest, int dstr, uint16_t *src, typedef void (*_oil_type_conv_f64_u16)(double * dest, int dstr, const uint1
int sstr, int n)) \ 6_t * src, int sstr, int n);
oil_function_class_ptr_conv_f64_u16->func) #define oil_conv_f64_u16 ((_oil_type_conv_f64_u16)(*(void **)oil_function_c
lass_ptr_conv_f64_u16))
extern OilFunctionClass *oil_function_class_ptr_conv_f64_u32; extern OilFunctionClass *oil_function_class_ptr_conv_f64_u32;
#define oil_conv_f64_u32 ((void (*)(double *dest, int dstr, uint32_t *src, typedef void (*_oil_type_conv_f64_u32)(double * dest, int dstr, const uint3
int sstr, int n)) \ 2_t * src, int sstr, int n);
oil_function_class_ptr_conv_f64_u32->func) #define oil_conv_f64_u32 ((_oil_type_conv_f64_u32)(*(void **)oil_function_c
lass_ptr_conv_f64_u32))
extern OilFunctionClass *oil_function_class_ptr_conv_f64_u8; extern OilFunctionClass *oil_function_class_ptr_conv_f64_u8;
#define oil_conv_f64_u8 ((void (*)(double *dest, int dstr, uint8_t *src, in typedef void (*_oil_type_conv_f64_u8)(double * dest, int dstr, const uint8_
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_f64_u8->func) #define oil_conv_f64_u8 ((_oil_type_conv_f64_u8)(*(void **)oil_function_cla
ss_ptr_conv_f64_u8))
extern OilFunctionClass *oil_function_class_ptr_conv_s16_f32; extern OilFunctionClass *oil_function_class_ptr_conv_s16_f32;
#define oil_conv_s16_f32 ((void (*)(int16_t *dest, int dstr, float *src, in typedef void (*_oil_type_conv_s16_f32)(int16_t * dest, int dstr, const floa
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_s16_f32->func) #define oil_conv_s16_f32 ((_oil_type_conv_s16_f32)(*(void **)oil_function_c
lass_ptr_conv_s16_f32))
extern OilFunctionClass *oil_function_class_ptr_conv_s16_f64; extern OilFunctionClass *oil_function_class_ptr_conv_s16_f64;
#define oil_conv_s16_f64 ((void (*)(int16_t *dest, int dstr, double *src, i typedef void (*_oil_type_conv_s16_f64)(int16_t * dest, int dstr, const doub
nt sstr, int n)) \ le * src, int sstr, int n);
oil_function_class_ptr_conv_s16_f64->func) #define oil_conv_s16_f64 ((_oil_type_conv_s16_f64)(*(void **)oil_function_c
lass_ptr_conv_s16_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_s16_s32; extern OilFunctionClass *oil_function_class_ptr_conv_s16_s32;
#define oil_conv_s16_s32 ((void (*)(int16_t *dest, int dstr, int32_t *src, typedef void (*_oil_type_conv_s16_s32)(int16_t * dest, int dstr, const int3
int sstr, int n)) \ 2_t * src, int sstr, int n);
oil_function_class_ptr_conv_s16_s32->func) #define oil_conv_s16_s32 ((_oil_type_conv_s16_s32)(*(void **)oil_function_c
lass_ptr_conv_s16_s32))
extern OilFunctionClass *oil_function_class_ptr_conv_s16_s8; extern OilFunctionClass *oil_function_class_ptr_conv_s16_s8;
#define oil_conv_s16_s8 ((void (*)(int16_t *dest, int dstr, int8_t *src, in typedef void (*_oil_type_conv_s16_s8)(int16_t * dest, int dstr, const int8_
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_s16_s8->func) #define oil_conv_s16_s8 ((_oil_type_conv_s16_s8)(*(void **)oil_function_cla
ss_ptr_conv_s16_s8))
extern OilFunctionClass *oil_function_class_ptr_conv_s16_u16; extern OilFunctionClass *oil_function_class_ptr_conv_s16_u16;
#define oil_conv_s16_u16 ((void (*)(int16_t *dest, int dstr, uint16_t *src, typedef void (*_oil_type_conv_s16_u16)(int16_t * dest, int dstr, const uint
int sstr, int n)) \ 16_t * src, int sstr, int n);
oil_function_class_ptr_conv_s16_u16->func) #define oil_conv_s16_u16 ((_oil_type_conv_s16_u16)(*(void **)oil_function_c
lass_ptr_conv_s16_u16))
extern OilFunctionClass *oil_function_class_ptr_conv_s16_u32; extern OilFunctionClass *oil_function_class_ptr_conv_s16_u32;
#define oil_conv_s16_u32 ((void (*)(int16_t *dest, int dstr, uint32_t *src, typedef void (*_oil_type_conv_s16_u32)(int16_t * dest, int dstr, const uint
int sstr, int n)) \ 32_t * src, int sstr, int n);
oil_function_class_ptr_conv_s16_u32->func) #define oil_conv_s16_u32 ((_oil_type_conv_s16_u32)(*(void **)oil_function_c
lass_ptr_conv_s16_u32))
extern OilFunctionClass *oil_function_class_ptr_conv_s16_u8; extern OilFunctionClass *oil_function_class_ptr_conv_s16_u8;
#define oil_conv_s16_u8 ((void (*)(int16_t *dest, int dstr, uint8_t *src, i typedef void (*_oil_type_conv_s16_u8)(int16_t * dest, int dstr, const uint8
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_s16_u8->func) #define oil_conv_s16_u8 ((_oil_type_conv_s16_u8)(*(void **)oil_function_cla
ss_ptr_conv_s16_u8))
extern OilFunctionClass *oil_function_class_ptr_conv_s32_f32; extern OilFunctionClass *oil_function_class_ptr_conv_s32_f32;
#define oil_conv_s32_f32 ((void (*)(int32_t *dest, int dstr, float *src, in typedef void (*_oil_type_conv_s32_f32)(int32_t * dest, int dstr, const floa
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_s32_f32->func) #define oil_conv_s32_f32 ((_oil_type_conv_s32_f32)(*(void **)oil_function_c
lass_ptr_conv_s32_f32))
extern OilFunctionClass *oil_function_class_ptr_conv_s32_f64; extern OilFunctionClass *oil_function_class_ptr_conv_s32_f64;
#define oil_conv_s32_f64 ((void (*)(int32_t *dest, int dstr, double *src, i typedef void (*_oil_type_conv_s32_f64)(int32_t * dest, int dstr, const doub
nt sstr, int n)) \ le * src, int sstr, int n);
oil_function_class_ptr_conv_s32_f64->func) #define oil_conv_s32_f64 ((_oil_type_conv_s32_f64)(*(void **)oil_function_c
lass_ptr_conv_s32_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_s32_s16; extern OilFunctionClass *oil_function_class_ptr_conv_s32_s16;
#define oil_conv_s32_s16 ((void (*)(int32_t *dest, int dstr, int16_t *src, typedef void (*_oil_type_conv_s32_s16)(int32_t * dest, int dstr, const int1
int sstr, int n)) \ 6_t * src, int sstr, int n);
oil_function_class_ptr_conv_s32_s16->func) #define oil_conv_s32_s16 ((_oil_type_conv_s32_s16)(*(void **)oil_function_c
lass_ptr_conv_s32_s16))
extern OilFunctionClass *oil_function_class_ptr_conv_s32_s8; extern OilFunctionClass *oil_function_class_ptr_conv_s32_s8;
#define oil_conv_s32_s8 ((void (*)(int32_t *dest, int dstr, int8_t *src, in typedef void (*_oil_type_conv_s32_s8)(int32_t * dest, int dstr, const int8_
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_s32_s8->func) #define oil_conv_s32_s8 ((_oil_type_conv_s32_s8)(*(void **)oil_function_cla
ss_ptr_conv_s32_s8))
extern OilFunctionClass *oil_function_class_ptr_conv_s32_u16; extern OilFunctionClass *oil_function_class_ptr_conv_s32_u16;
#define oil_conv_s32_u16 ((void (*)(int32_t *dest, int dstr, uint16_t *src, typedef void (*_oil_type_conv_s32_u16)(int32_t * dest, int dstr, const uint
int sstr, int n)) \ 16_t * src, int sstr, int n);
oil_function_class_ptr_conv_s32_u16->func) #define oil_conv_s32_u16 ((_oil_type_conv_s32_u16)(*(void **)oil_function_c
lass_ptr_conv_s32_u16))
extern OilFunctionClass *oil_function_class_ptr_conv_s32_u32; extern OilFunctionClass *oil_function_class_ptr_conv_s32_u32;
#define oil_conv_s32_u32 ((void (*)(int32_t *dest, int dstr, uint32_t *src, typedef void (*_oil_type_conv_s32_u32)(int32_t * dest, int dstr, const uint
int sstr, int n)) \ 32_t * src, int sstr, int n);
oil_function_class_ptr_conv_s32_u32->func) #define oil_conv_s32_u32 ((_oil_type_conv_s32_u32)(*(void **)oil_function_c
lass_ptr_conv_s32_u32))
extern OilFunctionClass *oil_function_class_ptr_conv_s32_u8; extern OilFunctionClass *oil_function_class_ptr_conv_s32_u8;
#define oil_conv_s32_u8 ((void (*)(int32_t *dest, int dstr, uint8_t *src, i typedef void (*_oil_type_conv_s32_u8)(int32_t * dest, int dstr, const uint8
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_s32_u8->func) #define oil_conv_s32_u8 ((_oil_type_conv_s32_u8)(*(void **)oil_function_cla
ss_ptr_conv_s32_u8))
extern OilFunctionClass *oil_function_class_ptr_conv_s8_f32; extern OilFunctionClass *oil_function_class_ptr_conv_s8_f32;
#define oil_conv_s8_f32 ((void (*)(int8_t *dest, int dstr, float *src, int typedef void (*_oil_type_conv_s8_f32)(int8_t * dest, int dstr, const float
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_s8_f32->func) #define oil_conv_s8_f32 ((_oil_type_conv_s8_f32)(*(void **)oil_function_cla
ss_ptr_conv_s8_f32))
extern OilFunctionClass *oil_function_class_ptr_conv_s8_f64; extern OilFunctionClass *oil_function_class_ptr_conv_s8_f64;
#define oil_conv_s8_f64 ((void (*)(int8_t *dest, int dstr, double *src, int typedef void (*_oil_type_conv_s8_f64)(int8_t * dest, int dstr, const double
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_s8_f64->func) #define oil_conv_s8_f64 ((_oil_type_conv_s8_f64)(*(void **)oil_function_cla
ss_ptr_conv_s8_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_s8_s16; extern OilFunctionClass *oil_function_class_ptr_conv_s8_s16;
#define oil_conv_s8_s16 ((void (*)(int8_t *dest, int dstr, int16_t *src, in typedef void (*_oil_type_conv_s8_s16)(int8_t * dest, int dstr, const int16_
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_s8_s16->func) #define oil_conv_s8_s16 ((_oil_type_conv_s8_s16)(*(void **)oil_function_cla
ss_ptr_conv_s8_s16))
extern OilFunctionClass *oil_function_class_ptr_conv_s8_s32; extern OilFunctionClass *oil_function_class_ptr_conv_s8_s32;
#define oil_conv_s8_s32 ((void (*)(int8_t *dest, int dstr, int32_t *src, in typedef void (*_oil_type_conv_s8_s32)(int8_t * dest, int dstr, const int32_
t sstr, int n)) \ t * src, int sstr, int n);
oil_function_class_ptr_conv_s8_s32->func) #define oil_conv_s8_s32 ((_oil_type_conv_s8_s32)(*(void **)oil_function_cla
ss_ptr_conv_s8_s32))
extern OilFunctionClass *oil_function_class_ptr_conv_s8_u16; extern OilFunctionClass *oil_function_class_ptr_conv_s8_u16;
#define oil_conv_s8_u16 ((void (*)(int8_t *dest, int dstr, uint16_t *src, i typedef void (*_oil_type_conv_s8_u16)(int8_t * dest, int dstr, const uint16
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_s8_u16->func) #define oil_conv_s8_u16 ((_oil_type_conv_s8_u16)(*(void **)oil_function_cla
ss_ptr_conv_s8_u16))
extern OilFunctionClass *oil_function_class_ptr_conv_s8_u32; extern OilFunctionClass *oil_function_class_ptr_conv_s8_u32;
#define oil_conv_s8_u32 ((void (*)(int8_t *dest, int dstr, uint32_t *src, i typedef void (*_oil_type_conv_s8_u32)(int8_t * dest, int dstr, const uint32
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_s8_u32->func) #define oil_conv_s8_u32 ((_oil_type_conv_s8_u32)(*(void **)oil_function_cla
ss_ptr_conv_s8_u32))
extern OilFunctionClass *oil_function_class_ptr_conv_s8_u8; extern OilFunctionClass *oil_function_class_ptr_conv_s8_u8;
#define oil_conv_s8_u8 ((void (*)(int8_t *dest, int dstr, uint8_t *src, int typedef void (*_oil_type_conv_s8_u8)(int8_t * dest, int dstr, const uint8_t
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_s8_u8->func) #define oil_conv_s8_u8 ((_oil_type_conv_s8_u8)(*(void **)oil_function_class
_ptr_conv_s8_u8))
extern OilFunctionClass *oil_function_class_ptr_conv_u16_f32; extern OilFunctionClass *oil_function_class_ptr_conv_u16_f32;
#define oil_conv_u16_f32 ((void (*)(uint16_t *dest, int dstr, float *src, i typedef void (*_oil_type_conv_u16_f32)(uint16_t * dest, int dstr, const flo
nt sstr, int n)) \ at * src, int sstr, int n);
oil_function_class_ptr_conv_u16_f32->func) #define oil_conv_u16_f32 ((_oil_type_conv_u16_f32)(*(void **)oil_function_c
lass_ptr_conv_u16_f32))
extern OilFunctionClass *oil_function_class_ptr_conv_u16_f64; extern OilFunctionClass *oil_function_class_ptr_conv_u16_f64;
#define oil_conv_u16_f64 ((void (*)(uint16_t *dest, int dstr, double *src, typedef void (*_oil_type_conv_u16_f64)(uint16_t * dest, int dstr, const dou
int sstr, int n)) \ ble * src, int sstr, int n);
oil_function_class_ptr_conv_u16_f64->func) #define oil_conv_u16_f64 ((_oil_type_conv_u16_f64)(*(void **)oil_function_c
lass_ptr_conv_u16_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_u16_s16; extern OilFunctionClass *oil_function_class_ptr_conv_u16_s16;
#define oil_conv_u16_s16 ((void (*)(uint16_t *dest, int dstr, int16_t *src, typedef void (*_oil_type_conv_u16_s16)(uint16_t * dest, int dstr, const int
int sstr, int n)) \ 16_t * src, int sstr, int n);
oil_function_class_ptr_conv_u16_s16->func) #define oil_conv_u16_s16 ((_oil_type_conv_u16_s16)(*(void **)oil_function_c
lass_ptr_conv_u16_s16))
extern OilFunctionClass *oil_function_class_ptr_conv_u16_s32; extern OilFunctionClass *oil_function_class_ptr_conv_u16_s32;
#define oil_conv_u16_s32 ((void (*)(uint16_t *dest, int dstr, int32_t *src, typedef void (*_oil_type_conv_u16_s32)(uint16_t * dest, int dstr, const int
int sstr, int n)) \ 32_t * src, int sstr, int n);
oil_function_class_ptr_conv_u16_s32->func) #define oil_conv_u16_s32 ((_oil_type_conv_u16_s32)(*(void **)oil_function_c
lass_ptr_conv_u16_s32))
extern OilFunctionClass *oil_function_class_ptr_conv_u16_s8; extern OilFunctionClass *oil_function_class_ptr_conv_u16_s8;
#define oil_conv_u16_s8 ((void (*)(uint16_t *dest, int dstr, int8_t *src, i typedef void (*_oil_type_conv_u16_s8)(uint16_t * dest, int dstr, const int8
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_u16_s8->func) #define oil_conv_u16_s8 ((_oil_type_conv_u16_s8)(*(void **)oil_function_cla
ss_ptr_conv_u16_s8))
extern OilFunctionClass *oil_function_class_ptr_conv_u16_u32; extern OilFunctionClass *oil_function_class_ptr_conv_u16_u32;
#define oil_conv_u16_u32 ((void (*)(uint16_t *dest, int dstr, uint32_t *src typedef void (*_oil_type_conv_u16_u32)(uint16_t * dest, int dstr, const uin
, int sstr, int n)) \ t32_t * src, int sstr, int n);
oil_function_class_ptr_conv_u16_u32->func) #define oil_conv_u16_u32 ((_oil_type_conv_u16_u32)(*(void **)oil_function_c
lass_ptr_conv_u16_u32))
extern OilFunctionClass *oil_function_class_ptr_conv_u16_u8; extern OilFunctionClass *oil_function_class_ptr_conv_u16_u8;
#define oil_conv_u16_u8 ((void (*)(uint16_t *dest, int dstr, uint8_t *src, typedef void (*_oil_type_conv_u16_u8)(uint16_t * dest, int dstr, const uint
int sstr, int n)) \ 8_t * src, int sstr, int n);
oil_function_class_ptr_conv_u16_u8->func) #define oil_conv_u16_u8 ((_oil_type_conv_u16_u8)(*(void **)oil_function_cla
ss_ptr_conv_u16_u8))
extern OilFunctionClass *oil_function_class_ptr_conv_u32_f32; extern OilFunctionClass *oil_function_class_ptr_conv_u32_f32;
#define oil_conv_u32_f32 ((void (*)(uint32_t *dest, int dstr, float *src, i typedef void (*_oil_type_conv_u32_f32)(uint32_t * dest, int dstr, const flo
nt sstr, int n)) \ at * src, int sstr, int n);
oil_function_class_ptr_conv_u32_f32->func) #define oil_conv_u32_f32 ((_oil_type_conv_u32_f32)(*(void **)oil_function_c
lass_ptr_conv_u32_f32))
extern OilFunctionClass *oil_function_class_ptr_conv_u32_f64; extern OilFunctionClass *oil_function_class_ptr_conv_u32_f64;
#define oil_conv_u32_f64 ((void (*)(uint32_t *dest, int dstr, double *src, typedef void (*_oil_type_conv_u32_f64)(uint32_t * dest, int dstr, const dou
int sstr, int n)) \ ble * src, int sstr, int n);
oil_function_class_ptr_conv_u32_f64->func) #define oil_conv_u32_f64 ((_oil_type_conv_u32_f64)(*(void **)oil_function_c
lass_ptr_conv_u32_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_u32_s16; extern OilFunctionClass *oil_function_class_ptr_conv_u32_s16;
#define oil_conv_u32_s16 ((void (*)(uint32_t *dest, int dstr, int16_t *src, typedef void (*_oil_type_conv_u32_s16)(uint32_t * dest, int dstr, const int
int sstr, int n)) \ 16_t * src, int sstr, int n);
oil_function_class_ptr_conv_u32_s16->func) #define oil_conv_u32_s16 ((_oil_type_conv_u32_s16)(*(void **)oil_function_c
lass_ptr_conv_u32_s16))
extern OilFunctionClass *oil_function_class_ptr_conv_u32_s32; extern OilFunctionClass *oil_function_class_ptr_conv_u32_s32;
#define oil_conv_u32_s32 ((void (*)(uint32_t *dest, int dstr, int32_t *src, typedef void (*_oil_type_conv_u32_s32)(uint32_t * dest, int dstr, const int
int sstr, int n)) \ 32_t * src, int sstr, int n);
oil_function_class_ptr_conv_u32_s32->func) #define oil_conv_u32_s32 ((_oil_type_conv_u32_s32)(*(void **)oil_function_c
lass_ptr_conv_u32_s32))
extern OilFunctionClass *oil_function_class_ptr_conv_u32_s8; extern OilFunctionClass *oil_function_class_ptr_conv_u32_s8;
#define oil_conv_u32_s8 ((void (*)(uint32_t *dest, int dstr, int8_t *src, i typedef void (*_oil_type_conv_u32_s8)(uint32_t * dest, int dstr, const int8
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_u32_s8->func) #define oil_conv_u32_s8 ((_oil_type_conv_u32_s8)(*(void **)oil_function_cla
ss_ptr_conv_u32_s8))
extern OilFunctionClass *oil_function_class_ptr_conv_u32_u16; extern OilFunctionClass *oil_function_class_ptr_conv_u32_u16;
#define oil_conv_u32_u16 ((void (*)(uint32_t *dest, int dstr, uint16_t *src typedef void (*_oil_type_conv_u32_u16)(uint32_t * dest, int dstr, const uin
, int sstr, int n)) \ t16_t * src, int sstr, int n);
oil_function_class_ptr_conv_u32_u16->func) #define oil_conv_u32_u16 ((_oil_type_conv_u32_u16)(*(void **)oil_function_c
lass_ptr_conv_u32_u16))
extern OilFunctionClass *oil_function_class_ptr_conv_u32_u8; extern OilFunctionClass *oil_function_class_ptr_conv_u32_u8;
#define oil_conv_u32_u8 ((void (*)(uint32_t *dest, int dstr, uint8_t *src, typedef void (*_oil_type_conv_u32_u8)(uint32_t * dest, int dstr, const uint
int sstr, int n)) \ 8_t * src, int sstr, int n);
oil_function_class_ptr_conv_u32_u8->func) #define oil_conv_u32_u8 ((_oil_type_conv_u32_u8)(*(void **)oil_function_cla
ss_ptr_conv_u32_u8))
extern OilFunctionClass *oil_function_class_ptr_conv_u8_f32; extern OilFunctionClass *oil_function_class_ptr_conv_u8_f32;
#define oil_conv_u8_f32 ((void (*)(uint8_t *dest, int dstr, float *src, int typedef void (*_oil_type_conv_u8_f32)(uint8_t * dest, int dstr, const float
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_u8_f32->func) #define oil_conv_u8_f32 ((_oil_type_conv_u8_f32)(*(void **)oil_function_cla
ss_ptr_conv_u8_f32))
extern OilFunctionClass *oil_function_class_ptr_conv_u8_f64; extern OilFunctionClass *oil_function_class_ptr_conv_u8_f64;
#define oil_conv_u8_f64 ((void (*)(uint8_t *dest, int dstr, double *src, in typedef void (*_oil_type_conv_u8_f64)(uint8_t * dest, int dstr, const doubl
t sstr, int n)) \ e * src, int sstr, int n);
oil_function_class_ptr_conv_u8_f64->func) #define oil_conv_u8_f64 ((_oil_type_conv_u8_f64)(*(void **)oil_function_cla
ss_ptr_conv_u8_f64))
extern OilFunctionClass *oil_function_class_ptr_conv_u8_s16; extern OilFunctionClass *oil_function_class_ptr_conv_u8_s16;
#define oil_conv_u8_s16 ((void (*)(uint8_t *dest, int dstr, int16_t *src, i typedef void (*_oil_type_conv_u8_s16)(uint8_t * dest, int dstr, const int16
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_u8_s16->func) #define oil_conv_u8_s16 ((_oil_type_conv_u8_s16)(*(void **)oil_function_cla
ss_ptr_conv_u8_s16))
extern OilFunctionClass *oil_function_class_ptr_conv_u8_s32; extern OilFunctionClass *oil_function_class_ptr_conv_u8_s32;
#define oil_conv_u8_s32 ((void (*)(uint8_t *dest, int dstr, int32_t *src, i typedef void (*_oil_type_conv_u8_s32)(uint8_t * dest, int dstr, const int32
nt sstr, int n)) \ _t * src, int sstr, int n);
oil_function_class_ptr_conv_u8_s32->func) #define oil_conv_u8_s32 ((_oil_type_conv_u8_s32)(*(void **)oil_function_cla
ss_ptr_conv_u8_s32))
extern OilFunctionClass *oil_function_class_ptr_conv_u8_s8; extern OilFunctionClass *oil_function_class_ptr_conv_u8_s8;
#define oil_conv_u8_s8 ((void (*)(uint8_t *dest, int dstr, int8_t *src, int typedef void (*_oil_type_conv_u8_s8)(uint8_t * dest, int dstr, const int8_t
sstr, int n)) \ * src, int sstr, int n);
oil_function_class_ptr_conv_u8_s8->func) #define oil_conv_u8_s8 ((_oil_type_conv_u8_s8)(*(void **)oil_function_class
_ptr_conv_u8_s8))
extern OilFunctionClass *oil_function_class_ptr_conv_u8_u16; extern OilFunctionClass *oil_function_class_ptr_conv_u8_u16;
#define oil_conv_u8_u16 ((void (*)(uint8_t *dest, int dstr, uint16_t *src, typedef void (*_oil_type_conv_u8_u16)(uint8_t * dest, int dstr, const uint1
int sstr, int n)) \ 6_t * src, int sstr, int n);
oil_function_class_ptr_conv_u8_u16->func) #define oil_conv_u8_u16 ((_oil_type_conv_u8_u16)(*(void **)oil_function_cla
ss_ptr_conv_u8_u16))
extern OilFunctionClass *oil_function_class_ptr_conv_u8_u32; extern OilFunctionClass *oil_function_class_ptr_conv_u8_u32;
#define oil_conv_u8_u32 ((void (*)(uint8_t *dest, int dstr, uint32_t *src, typedef void (*_oil_type_conv_u8_u32)(uint8_t * dest, int dstr, const uint3
int sstr, int n)) \ 2_t * src, int sstr, int n);
oil_function_class_ptr_conv_u8_u32->func) #define oil_conv_u8_u32 ((_oil_type_conv_u8_u32)(*(void **)oil_function_cla
extern OilFunctionClass *oil_function_class_ptr_dct12_f32; ss_ptr_conv_u8_u32))
#define oil_dct12_f32 ((void (*)(float *dest, int dstr, float *src, int sst extern OilFunctionClass *oil_function_class_ptr_copy8x8_u8;
r)) \ typedef void (*_oil_type_copy8x8_u8)(uint8_t * d_8x8, int ds, const uint8_t
oil_function_class_ptr_dct12_f32->func) * s_8x8, int ss);
#define oil_copy8x8_u8 ((_oil_type_copy8x8_u8)(*(void **)oil_function_class
_ptr_copy8x8_u8))
extern OilFunctionClass *oil_function_class_ptr_copy_u8;
typedef void (*_oil_type_copy_u8)(uint8_t * dest, const uint8_t * src, int
n);
#define oil_copy_u8 ((_oil_type_copy_u8)(*(void **)oil_function_class_ptr_c
opy_u8))
extern OilFunctionClass *oil_function_class_ptr_dct36_f32; extern OilFunctionClass *oil_function_class_ptr_dct36_f32;
#define oil_dct36_f32 ((void (*)(float *dest, int dstr, float *src, int sst typedef void (*_oil_type_dct36_f32)(float * d_36, int dstr, const float * s
r, int n)) \ _36, int sstr);
oil_function_class_ptr_dct36_f32->func) #define oil_dct36_f32 ((_oil_type_dct36_f32)(*(void **)oil_function_class_p
tr_dct36_f32))
extern OilFunctionClass *oil_function_class_ptr_dequantize8x8_s16; extern OilFunctionClass *oil_function_class_ptr_dequantize8x8_s16;
#define oil_dequantize8x8_s16 ((void (*)(int16_t *dest, int dstr, int16_t * typedef void (*_oil_type_dequantize8x8_s16)(int16_t * d_8x8, int dstr, cons
src1, int sstr1, int16_t *src2, int sstr2)) \ t int16_t * s1_8x8, int sstr1, const int16_t * s2_8x8, int sstr2);
oil_function_class_ptr_dequantize8x8_s16->func) #define oil_dequantize8x8_s16 ((_oil_type_dequantize8x8_s16)(*(void **)oil_
function_class_ptr_dequantize8x8_s16))
extern OilFunctionClass *oil_function_class_ptr_diff8x8_average_s16_u8;
typedef void (*_oil_type_diff8x8_average_s16_u8)(int16_t * d_64, const uint
8_t * s1_8x8, int ss1, const uint8_t * s2_8x8, int ss2, const uint8_t * s3_
8x8, int ss3);
#define oil_diff8x8_average_s16_u8 ((_oil_type_diff8x8_average_s16_u8)(*(vo
id **)oil_function_class_ptr_diff8x8_average_s16_u8))
extern OilFunctionClass *oil_function_class_ptr_diff8x8_const128_s16_u8;
typedef void (*_oil_type_diff8x8_const128_s16_u8)(int16_t * d_64, const uin
t8_t * s1_8x8, int ss1);
#define oil_diff8x8_const128_s16_u8 ((_oil_type_diff8x8_const128_s16_u8)(*(
void **)oil_function_class_ptr_diff8x8_const128_s16_u8))
extern OilFunctionClass *oil_function_class_ptr_diff8x8_s16_u8;
typedef void (*_oil_type_diff8x8_s16_u8)(int16_t * d_64, const uint8_t * s1
_8x8, int ss1, const uint8_t * s2_8x8, int ss2);
#define oil_diff8x8_s16_u8 ((_oil_type_diff8x8_s16_u8)(*(void **)oil_functi
on_class_ptr_diff8x8_s16_u8))
extern OilFunctionClass *oil_function_class_ptr_diffsquaresum_f64; extern OilFunctionClass *oil_function_class_ptr_diffsquaresum_f64;
#define oil_diffsquaresum_f64 ((void (*)(double *dest, double *src1, int ss typedef void (*_oil_type_diffsquaresum_f64)(double * d_1, const double * sr
tr1, double *src2, int sstr2, int n)) \ c1, int sstr1, const double * src2, int sstr2, int n);
oil_function_class_ptr_diffsquaresum_f64->func) #define oil_diffsquaresum_f64 ((_oil_type_diffsquaresum_f64)(*(void **)oil_
function_class_ptr_diffsquaresum_f64))
extern OilFunctionClass *oil_function_class_ptr_divide_f32;
typedef void (*_oil_type_divide_f32)(float * d, const float * s1, const flo
at * s2, int n);
#define oil_divide_f32 ((_oil_type_divide_f32)(*(void **)oil_function_class
_ptr_divide_f32))
extern OilFunctionClass *oil_function_class_ptr_err_inter8x8_u8;
typedef void (*_oil_type_err_inter8x8_u8)(uint32_t * d_1, const uint8_t * s
1_8x8, int ss1, const uint8_t * s2_8x8, int ss2);
#define oil_err_inter8x8_u8 ((_oil_type_err_inter8x8_u8)(*(void **)oil_func
tion_class_ptr_err_inter8x8_u8))
extern OilFunctionClass *oil_function_class_ptr_err_inter8x8_u8_avg;
typedef void (*_oil_type_err_inter8x8_u8_avg)(uint32_t * d_1, const uint8_t
* s1_8x8, int ss1, const uint8_t * s2_8x8, const uint8_t * s3_8x8, int ss2
);
#define oil_err_inter8x8_u8_avg ((_oil_type_err_inter8x8_u8_avg)(*(void **)
oil_function_class_ptr_err_inter8x8_u8_avg))
extern OilFunctionClass *oil_function_class_ptr_err_intra8x8_u8;
typedef void (*_oil_type_err_intra8x8_u8)(uint32_t * d_1, const uint8_t * s
1_8x8, int ss1);
#define oil_err_intra8x8_u8 ((_oil_type_err_intra8x8_u8)(*(void **)oil_func
tion_class_ptr_err_intra8x8_u8))
extern OilFunctionClass *oil_function_class_ptr_fdct8_f64; extern OilFunctionClass *oil_function_class_ptr_fdct8_f64;
#define oil_fdct8_f64 ((void (*)(double *dest, double *src, int dstr, int s typedef void (*_oil_type_fdct8_f64)(double * d_8, const double * s_8, int d
str)) \ str, int sstr);
oil_function_class_ptr_fdct8_f64->func) #define oil_fdct8_f64 ((_oil_type_fdct8_f64)(*(void **)oil_function_class_p
tr_fdct8_f64))
extern OilFunctionClass *oil_function_class_ptr_fdct8x8_f64;
typedef void (*_oil_type_fdct8x8_f64)(double * d_8x8, int dstr, const doubl
e * s_8x8, int sstr);
#define oil_fdct8x8_f64 ((_oil_type_fdct8x8_f64)(*(void **)oil_function_cla
ss_ptr_fdct8x8_f64))
extern OilFunctionClass *oil_function_class_ptr_fdct8x8s_s16;
typedef void (*_oil_type_fdct8x8s_s16)(int16_t * d_8x8, int ds, const int16
_t * s_8x8, int ss);
#define oil_fdct8x8s_s16 ((_oil_type_fdct8x8s_s16)(*(void **)oil_function_c
lass_ptr_fdct8x8s_s16))
extern OilFunctionClass *oil_function_class_ptr_fdct8x8theora;
typedef void (*_oil_type_fdct8x8theora)(const int16_t * s_8x8, int16_t * d_
8x8);
#define oil_fdct8x8theora ((_oil_type_fdct8x8theora)(*(void **)oil_function
_class_ptr_fdct8x8theora))
extern OilFunctionClass *oil_function_class_ptr_floor_f32;
typedef void (*_oil_type_floor_f32)(float * d, const float * s, int n);
#define oil_floor_f32 ((_oil_type_floor_f32)(*(void **)oil_function_class_p
tr_floor_f32))
extern OilFunctionClass *oil_function_class_ptr_idct8_f64; extern OilFunctionClass *oil_function_class_ptr_idct8_f64;
#define oil_idct8_f64 ((void (*)(double *dest, int dstr, double *src, int s typedef void (*_oil_type_idct8_f64)(double * d_8, int dstr, const double *
str)) \ s_8, int sstr);
oil_function_class_ptr_idct8_f64->func) #define oil_idct8_f64 ((_oil_type_idct8_f64)(*(void **)oil_function_class_p
tr_idct8_f64))
extern OilFunctionClass *oil_function_class_ptr_idct8theora_s16;
typedef void (*_oil_type_idct8theora_s16)(int16_t * d_8, int dstr, const in
t16_t * s_8, int sstr);
#define oil_idct8theora_s16 ((_oil_type_idct8theora_s16)(*(void **)oil_func
tion_class_ptr_idct8theora_s16))
extern OilFunctionClass *oil_function_class_ptr_idct8x8_f64; extern OilFunctionClass *oil_function_class_ptr_idct8x8_f64;
#define oil_idct8x8_f64 ((void (*)(double *dest, int dstr, double *src, int typedef void (*_oil_type_idct8x8_f64)(double * d_8x8, int dstr, const doubl
sstr)) \ e * s_8x8, int sstr);
oil_function_class_ptr_idct8x8_f64->func) #define oil_idct8x8_f64 ((_oil_type_idct8x8_f64)(*(void **)oil_function_cla
ss_ptr_idct8x8_f64))
extern OilFunctionClass *oil_function_class_ptr_idct8x8_s16; extern OilFunctionClass *oil_function_class_ptr_idct8x8_s16;
#define oil_idct8x8_s16 ((void (*)(int16_t *dest, int dstr, int16_t *src, i typedef void (*_oil_type_idct8x8_s16)(int16_t * d_8x8, int dstr, const int1
nt sstr)) \ 6_t * s_8x8, int sstr);
oil_function_class_ptr_idct8x8_s16->func) #define oil_idct8x8_s16 ((_oil_type_idct8x8_s16)(*(void **)oil_function_cla
ss_ptr_idct8x8_s16))
extern OilFunctionClass *oil_function_class_ptr_idct8x8lim10_f64;
typedef void (*_oil_type_idct8x8lim10_f64)(double * d_8x8, int dstr, const
double * s_8x8, int sstr);
#define oil_idct8x8lim10_f64 ((_oil_type_idct8x8lim10_f64)(*(void **)oil_fu
nction_class_ptr_idct8x8lim10_f64))
extern OilFunctionClass *oil_function_class_ptr_idct8x8lim10_s16;
typedef void (*_oil_type_idct8x8lim10_s16)(int16_t * d_8x8, int dstr, const
int16_t * s_8x8, int sstr);
#define oil_idct8x8lim10_s16 ((_oil_type_idct8x8lim10_s16)(*(void **)oil_fu
nction_class_ptr_idct8x8lim10_s16))
extern OilFunctionClass *oil_function_class_ptr_idct8x8theora_s16;
typedef void (*_oil_type_idct8x8theora_s16)(int16_t * d_8x8, int dstr, cons
t int16_t * s_8x8, int sstr);
#define oil_idct8x8theora_s16 ((_oil_type_idct8x8theora_s16)(*(void **)oil_
function_class_ptr_idct8x8theora_s16))
extern OilFunctionClass *oil_function_class_ptr_imdct12_f64;
typedef void (*_oil_type_imdct12_f64)(double * d_12, const double * s_6);
#define oil_imdct12_f64 ((_oil_type_imdct12_f64)(*(void **)oil_function_cla
ss_ptr_imdct12_f64))
extern OilFunctionClass *oil_function_class_ptr_imdct32_f32; extern OilFunctionClass *oil_function_class_ptr_imdct32_f32;
#define oil_imdct32_f32 ((void (*)(float *dest, float *src)) \ typedef void (*_oil_type_imdct32_f32)(float * d_32, const float * s_32);
oil_function_class_ptr_imdct32_f32->func) #define oil_imdct32_f32 ((_oil_type_imdct32_f32)(*(void **)oil_function_cla
ss_ptr_imdct32_f32))
extern OilFunctionClass *oil_function_class_ptr_imdct36_f64;
typedef void (*_oil_type_imdct36_f64)(double * d_36, const double * s_18);
#define oil_imdct36_f64 ((_oil_type_imdct36_f64)(*(void **)oil_function_cla
ss_ptr_imdct36_f64))
extern OilFunctionClass *oil_function_class_ptr_inverse_f32;
typedef void (*_oil_type_inverse_f32)(float * d, const float * s, int n);
#define oil_inverse_f32 ((_oil_type_inverse_f32)(*(void **)oil_function_cla
ss_ptr_inverse_f32))
extern OilFunctionClass *oil_function_class_ptr_maximum_f32;
typedef void (*_oil_type_maximum_f32)(float * d, const float * s1, const fl
oat * s2, int n);
#define oil_maximum_f32 ((_oil_type_maximum_f32)(*(void **)oil_function_cla
ss_ptr_maximum_f32))
extern OilFunctionClass *oil_function_class_ptr_md5; extern OilFunctionClass *oil_function_class_ptr_md5;
#define oil_md5 ((void (*)(uint32_t *state, uint32_t *src)) \ typedef void (*_oil_type_md5)(uint32_t * i_4, const uint32_t * s_16);
oil_function_class_ptr_md5->func) #define oil_md5 ((_oil_type_md5)(*(void **)oil_function_class_ptr_md5))
extern OilFunctionClass *oil_function_class_ptr_mdct12_f64;
typedef void (*_oil_type_mdct12_f64)(double * d_6, const double * s_12);
#define oil_mdct12_f64 ((_oil_type_mdct12_f64)(*(void **)oil_function_class
_ptr_mdct12_f64))
extern OilFunctionClass *oil_function_class_ptr_mdct36_f64;
typedef void (*_oil_type_mdct36_f64)(double * d_18, const double * s_36);
#define oil_mdct36_f64 ((_oil_type_mdct36_f64)(*(void **)oil_function_class
_ptr_mdct36_f64))
extern OilFunctionClass *oil_function_class_ptr_merge_linear_argb;
typedef void (*_oil_type_merge_linear_argb)(uint32_t * d_n, const uint32_t
* s_n, const uint32_t * s2_n, const uint32_t * s3_1, int n);
#define oil_merge_linear_argb ((_oil_type_merge_linear_argb)(*(void **)oil_
function_class_ptr_merge_linear_argb))
extern OilFunctionClass *oil_function_class_ptr_minimum_f32;
typedef void (*_oil_type_minimum_f32)(float * d, const float * s1, const fl
oat * s2, int n);
#define oil_minimum_f32 ((_oil_type_minimum_f32)(*(void **)oil_function_cla
ss_ptr_minimum_f32))
extern OilFunctionClass *oil_function_class_ptr_mix_u8; extern OilFunctionClass *oil_function_class_ptr_mix_u8;
#define oil_mix_u8 ((void (*)(uint8_t *dest, uint8_t *src1, uint8_t *src2, typedef void (*_oil_type_mix_u8)(uint8_t * dest, const uint8_t * src1, cons
uint8_t *param, int n)) \ t uint8_t * src2, const uint8_t * src3, int n);
oil_function_class_ptr_mix_u8->func) #define oil_mix_u8 ((_oil_type_mix_u8)(*(void **)oil_function_class_ptr_mix
_u8))
extern OilFunctionClass *oil_function_class_ptr_mult8x8_s16; extern OilFunctionClass *oil_function_class_ptr_mult8x8_s16;
#define oil_mult8x8_s16 ((void (*)(int16_t *dest, int16_t *src1, int16_t *s typedef void (*_oil_type_mult8x8_s16)(int16_t * d_8x8, const int16_t * s1_8
rc2, int dstr, int sstr1, int sstr2)) \ x8, const int16_t * s2_8x8, int ds, int ss1, int ss2);
oil_function_class_ptr_mult8x8_s16->func) #define oil_mult8x8_s16 ((_oil_type_mult8x8_s16)(*(void **)oil_function_cla
ss_ptr_mult8x8_s16))
extern OilFunctionClass *oil_function_class_ptr_multiply_f32;
typedef void (*_oil_type_multiply_f32)(float * d, const float * s1, const f
loat * s2, int n);
#define oil_multiply_f32 ((_oil_type_multiply_f32)(*(void **)oil_function_c
lass_ptr_multiply_f32))
extern OilFunctionClass *oil_function_class_ptr_multsum_f32; extern OilFunctionClass *oil_function_class_ptr_multsum_f32;
#define oil_multsum_f32 ((void (*)(float *dest, float *src1, int sstr1, flo typedef void (*_oil_type_multsum_f32)(float * dest, const float * src1, int
at *src2, int sstr2, int n)) \ sstr1, const float * src2, int sstr2, int n);
oil_function_class_ptr_multsum_f32->func) #define oil_multsum_f32 ((_oil_type_multsum_f32)(*(void **)oil_function_cla
ss_ptr_multsum_f32))
extern OilFunctionClass *oil_function_class_ptr_multsum_f64; extern OilFunctionClass *oil_function_class_ptr_multsum_f64;
#define oil_multsum_f64 ((void (*)(double *dest, double *src1, int sstr1, d typedef void (*_oil_type_multsum_f64)(double * dest, const double * src1, i
ouble *src2, int sstr2, int n)) \ nt sstr1, const double * src2, int sstr2, int n);
oil_function_class_ptr_multsum_f64->func) #define oil_multsum_f64 ((_oil_type_multsum_f64)(*(void **)oil_function_cla
ss_ptr_multsum_f64))
extern OilFunctionClass *oil_function_class_ptr_negative_f32;
typedef void (*_oil_type_negative_f32)(float * d, const float * s, int n);
#define oil_negative_f32 ((_oil_type_negative_f32)(*(void **)oil_function_c
lass_ptr_negative_f32))
extern OilFunctionClass *oil_function_class_ptr_null;
typedef void (*_oil_type_null)(void);
#define oil_null ((_oil_type_null)(*(void **)oil_function_class_ptr_null))
extern OilFunctionClass *oil_function_class_ptr_permute_f32; extern OilFunctionClass *oil_function_class_ptr_permute_f32;
#define oil_permute_f32 ((void (*)(float *dest, int dstr, float *src1, int typedef void (*_oil_type_permute_f32)(float * dest, int dstr, const float *
sstr1, int32_t *src2, int sstr2, int n)) \ src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_f32->func) #define oil_permute_f32 ((_oil_type_permute_f32)(*(void **)oil_function_cla
ss_ptr_permute_f32))
extern OilFunctionClass *oil_function_class_ptr_permute_f64; extern OilFunctionClass *oil_function_class_ptr_permute_f64;
#define oil_permute_f64 ((void (*)(double *dest, int dstr, double *src1, in typedef void (*_oil_type_permute_f64)(double * dest, int dstr, const double
t sstr1, int32_t *src2, int sstr2, int n)) \ * src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_f64->func) #define oil_permute_f64 ((_oil_type_permute_f64)(*(void **)oil_function_cla
ss_ptr_permute_f64))
extern OilFunctionClass *oil_function_class_ptr_permute_s16; extern OilFunctionClass *oil_function_class_ptr_permute_s16;
#define oil_permute_s16 ((void (*)(int16_t *dest, int dstr, int16_t *src1, typedef void (*_oil_type_permute_s16)(int16_t * dest, int dstr, const int16
int sstr1, int32_t *src2, int sstr2, int n)) \ _t * src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_s16->func) #define oil_permute_s16 ((_oil_type_permute_s16)(*(void **)oil_function_cla
ss_ptr_permute_s16))
extern OilFunctionClass *oil_function_class_ptr_permute_s32; extern OilFunctionClass *oil_function_class_ptr_permute_s32;
#define oil_permute_s32 ((void (*)(int32_t *dest, int dstr, int32_t *src1, typedef void (*_oil_type_permute_s32)(int32_t * dest, int dstr, const int32
int sstr1, int32_t *src2, int sstr2, int n)) \ _t * src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_s32->func) #define oil_permute_s32 ((_oil_type_permute_s32)(*(void **)oil_function_cla
ss_ptr_permute_s32))
extern OilFunctionClass *oil_function_class_ptr_permute_s8; extern OilFunctionClass *oil_function_class_ptr_permute_s8;
#define oil_permute_s8 ((void (*)(int8_t *dest, int dstr, int8_t *src1, int typedef void (*_oil_type_permute_s8)(int8_t * dest, int dstr, const int8_t
sstr1, int32_t *src2, int sstr2, int n)) \ * src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_s8->func) #define oil_permute_s8 ((_oil_type_permute_s8)(*(void **)oil_function_class
_ptr_permute_s8))
extern OilFunctionClass *oil_function_class_ptr_permute_u16; extern OilFunctionClass *oil_function_class_ptr_permute_u16;
#define oil_permute_u16 ((void (*)(uint16_t *dest, int dstr, uint16_t *src1 typedef void (*_oil_type_permute_u16)(uint16_t * dest, int dstr, const uint
, int sstr1, int32_t *src2, int sstr2, int n)) \ 16_t * src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_u16->func) #define oil_permute_u16 ((_oil_type_permute_u16)(*(void **)oil_function_cla
ss_ptr_permute_u16))
extern OilFunctionClass *oil_function_class_ptr_permute_u32; extern OilFunctionClass *oil_function_class_ptr_permute_u32;
#define oil_permute_u32 ((void (*)(uint32_t *dest, int dstr, uint32_t *src1 typedef void (*_oil_type_permute_u32)(uint32_t * dest, int dstr, const uint
, int sstr1, int32_t *src2, int sstr2, int n)) \ 32_t * src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_u32->func) #define oil_permute_u32 ((_oil_type_permute_u32)(*(void **)oil_function_cla
ss_ptr_permute_u32))
extern OilFunctionClass *oil_function_class_ptr_permute_u8; extern OilFunctionClass *oil_function_class_ptr_permute_u8;
#define oil_permute_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src1, i typedef void (*_oil_type_permute_u8)(uint8_t * dest, int dstr, const uint8_
nt sstr1, int32_t *src2, int sstr2, int n)) \ t * src1, int sstr1, const int32_t * src2, int sstr2, int n);
oil_function_class_ptr_permute_u8->func) #define oil_permute_u8 ((_oil_type_permute_u8)(*(void **)oil_function_class
_ptr_permute_u8))
extern OilFunctionClass *oil_function_class_ptr_recon8x8_inter;
typedef void (*_oil_type_recon8x8_inter)(uint8_t * d_8x8, int ds, const uin
t8_t * s1_8x8, int ss1, const int16_t * s2_8x8);
#define oil_recon8x8_inter ((_oil_type_recon8x8_inter)(*(void **)oil_functi
on_class_ptr_recon8x8_inter))
extern OilFunctionClass *oil_function_class_ptr_recon8x8_inter2;
typedef void (*_oil_type_recon8x8_inter2)(uint8_t * d_8x8, int ds, const ui
nt8_t * s1_8x8, int ss1, const uint8_t * s2_8x8, int ss2, const int16_t * s
3_8x8);
#define oil_recon8x8_inter2 ((_oil_type_recon8x8_inter2)(*(void **)oil_func
tion_class_ptr_recon8x8_inter2))
extern OilFunctionClass *oil_function_class_ptr_recon8x8_intra;
typedef void (*_oil_type_recon8x8_intra)(uint8_t * d_8x8, int ds, const int
16_t * s_8x8);
#define oil_recon8x8_intra ((_oil_type_recon8x8_intra)(*(void **)oil_functi
on_class_ptr_recon8x8_intra))
extern OilFunctionClass *oil_function_class_ptr_resample_linear_argb;
typedef void (*_oil_type_resample_linear_argb)(uint32_t * d_n, const uint32
_t * s_2xn, int n, uint32_t * i_2);
#define oil_resample_linear_argb ((_oil_type_resample_linear_argb)(*(void *
*)oil_function_class_ptr_resample_linear_argb))
extern OilFunctionClass *oil_function_class_ptr_resample_linear_u8;
typedef void (*_oil_type_resample_linear_u8)(uint8_t * d_n, const uint8_t *
s_2xn, int n, uint32_t * i_2);
#define oil_resample_linear_u8 ((_oil_type_resample_linear_u8)(*(void **)oi
l_function_class_ptr_resample_linear_u8))
extern OilFunctionClass *oil_function_class_ptr_rgb2bgr;
typedef void (*_oil_type_rgb2bgr)(uint8_t * d_3xn, const uint8_t * s_3xn, i
nt n);
#define oil_rgb2bgr ((_oil_type_rgb2bgr)(*(void **)oil_function_class_ptr_r
gb2bgr))
extern OilFunctionClass *oil_function_class_ptr_rgb2rgba;
typedef void (*_oil_type_rgb2rgba)(uint8_t * d_4xn, const uint8_t * s_3xn,
int n);
#define oil_rgb2rgba ((_oil_type_rgb2rgba)(*(void **)oil_function_class_ptr
_rgb2rgba))
extern OilFunctionClass *oil_function_class_ptr_rowsad8x8_u8;
typedef void (*_oil_type_rowsad8x8_u8)(uint32_t * d_1, const uint8_t * s1_8
x8, const uint8_t * s2_8x8);
#define oil_rowsad8x8_u8 ((_oil_type_rowsad8x8_u8)(*(void **)oil_function_c
lass_ptr_rowsad8x8_u8))
extern OilFunctionClass *oil_function_class_ptr_sad8x8_f64; extern OilFunctionClass *oil_function_class_ptr_sad8x8_f64;
#define oil_sad8x8_f64 ((void (*)(double *dest, int dstr, double *src1, int typedef void (*_oil_type_sad8x8_f64)(double * d_8x8, int ds, const double *
sstr1, double *src2, int sstr2)) \ s1_8x8, int ss1, const double * s2_8x8, int ss2);
oil_function_class_ptr_sad8x8_f64->func) #define oil_sad8x8_f64 ((_oil_type_sad8x8_f64)(*(void **)oil_function_class
_ptr_sad8x8_f64))
extern OilFunctionClass *oil_function_class_ptr_sad8x8_f64_2;
typedef void (*_oil_type_sad8x8_f64_2)(double * d_1, const double * s1_8x8,
int ss1, const double * s2_8x8, int ss2);
#define oil_sad8x8_f64_2 ((_oil_type_sad8x8_f64_2)(*(void **)oil_function_c
lass_ptr_sad8x8_f64_2))
extern OilFunctionClass *oil_function_class_ptr_sad8x8_s16; extern OilFunctionClass *oil_function_class_ptr_sad8x8_s16;
#define oil_sad8x8_s16 ((void (*)(uint32_t *dest, int dstr, int16_t *src1, typedef void (*_oil_type_sad8x8_s16)(uint32_t * d_8x8, int ds, const int16_
int sstr1, int16_t *src2, int sstr2)) \ t * s1_8x8, int ss1, const int16_t * s2_8x8, int ss2);
oil_function_class_ptr_sad8x8_s16->func) #define oil_sad8x8_s16 ((_oil_type_sad8x8_s16)(*(void **)oil_function_class
_ptr_sad8x8_s16))
extern OilFunctionClass *oil_function_class_ptr_sad8x8_s16_2;
typedef void (*_oil_type_sad8x8_s16_2)(uint32_t * d_1, const int16_t * s1_8
x8, int ss1, const int16_t * s2_8x8, int ss2);
#define oil_sad8x8_s16_2 ((_oil_type_sad8x8_s16_2)(*(void **)oil_function_c
lass_ptr_sad8x8_s16_2))
extern OilFunctionClass *oil_function_class_ptr_sad8x8_u8;
typedef void (*_oil_type_sad8x8_u8)(uint32_t * d_1, const uint8_t * s1_8x8,
int ss1, const uint8_t * s2_8x8, int ss2);
#define oil_sad8x8_u8 ((_oil_type_sad8x8_u8)(*(void **)oil_function_class_p
tr_sad8x8_u8))
extern OilFunctionClass *oil_function_class_ptr_sad8x8_u8_avg;
typedef void (*_oil_type_sad8x8_u8_avg)(uint32_t * d_1, const uint8_t * s1_
8x8, int ss1, const uint8_t * s2_8x8, const uint8_t * s3_8x8, int ss2);
#define oil_sad8x8_u8_avg ((_oil_type_sad8x8_u8_avg)(*(void **)oil_function
_class_ptr_sad8x8_u8_avg))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_f32; extern OilFunctionClass *oil_function_class_ptr_scalaradd_f32;
#define oil_scalaradd_f32 ((void (*)(float *dest, int dstr, float *src, int typedef void (*_oil_type_scalaradd_f32)(float * dest, int dstr, const float
sstr, float param, int n)) \ * src, int sstr, const float * s2_1, int n);
oil_function_class_ptr_scalaradd_f32->func) #define oil_scalaradd_f32 ((_oil_type_scalaradd_f32)(*(void **)oil_function
_class_ptr_scalaradd_f32))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_f32_ns;
typedef void (*_oil_type_scalaradd_f32_ns)(float * d, const float * s1, con
st float * s2_1, int n);
#define oil_scalaradd_f32_ns ((_oil_type_scalaradd_f32_ns)(*(void **)oil_fu
nction_class_ptr_scalaradd_f32_ns))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_f64; extern OilFunctionClass *oil_function_class_ptr_scalaradd_f64;
#define oil_scalaradd_f64 ((void (*)(double *dest, int dstr, double *src, i typedef void (*_oil_type_scalaradd_f64)(double * dest, int dstr, const doub
nt sstr, double param, int n)) \ le * src, int sstr, const double * s2_1, int n);
oil_function_class_ptr_scalaradd_f64->func) #define oil_scalaradd_f64 ((_oil_type_scalaradd_f64)(*(void **)oil_function
_class_ptr_scalaradd_f64))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_s16; extern OilFunctionClass *oil_function_class_ptr_scalaradd_s16;
#define oil_scalaradd_s16 ((void (*)(int16_t *dest, int dstr, int16_t *src, typedef void (*_oil_type_scalaradd_s16)(int16_t * dest, int dstr, const int
int sstr, int16_t param, int n)) \ 16_t * src, int sstr, const int16_t * s2_1, int n);
oil_function_class_ptr_scalaradd_s16->func) #define oil_scalaradd_s16 ((_oil_type_scalaradd_s16)(*(void **)oil_function
_class_ptr_scalaradd_s16))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_s32; extern OilFunctionClass *oil_function_class_ptr_scalaradd_s32;
#define oil_scalaradd_s32 ((void (*)(int32_t *dest, int dstr, int32_t *src, typedef void (*_oil_type_scalaradd_s32)(int32_t * dest, int dstr, const int
int sstr, int32_t param, int n)) \ 32_t * src, int sstr, const int32_t * s2_1, int n);
oil_function_class_ptr_scalaradd_s32->func) #define oil_scalaradd_s32 ((_oil_type_scalaradd_s32)(*(void **)oil_function
_class_ptr_scalaradd_s32))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_s8; extern OilFunctionClass *oil_function_class_ptr_scalaradd_s8;
#define oil_scalaradd_s8 ((void (*)(int8_t *dest, int dstr, int8_t *src, in typedef void (*_oil_type_scalaradd_s8)(int8_t * dest, int dstr, const int8_
t sstr, int8_t param, int n)) \ t * src, int sstr, const int8_t * s2_1, int n);
oil_function_class_ptr_scalaradd_s8->func) #define oil_scalaradd_s8 ((_oil_type_scalaradd_s8)(*(void **)oil_function_c
lass_ptr_scalaradd_s8))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_u16; extern OilFunctionClass *oil_function_class_ptr_scalaradd_u16;
#define oil_scalaradd_u16 ((void (*)(uint16_t *dest, int dstr, uint16_t *sr typedef void (*_oil_type_scalaradd_u16)(uint16_t * dest, int dstr, const ui
c, int sstr, uint16_t param, int n)) \ nt16_t * src, int sstr, const uint16_t * s2_1, int n);
oil_function_class_ptr_scalaradd_u16->func) #define oil_scalaradd_u16 ((_oil_type_scalaradd_u16)(*(void **)oil_function
_class_ptr_scalaradd_u16))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_u32; extern OilFunctionClass *oil_function_class_ptr_scalaradd_u32;
#define oil_scalaradd_u32 ((void (*)(uint32_t *dest, int dstr, uint32_t *sr typedef void (*_oil_type_scalaradd_u32)(uint32_t * dest, int dstr, const ui
c, int sstr, uint32_t param, int n)) \ nt32_t * src, int sstr, const uint32_t * s2_1, int n);
oil_function_class_ptr_scalaradd_u32->func) #define oil_scalaradd_u32 ((_oil_type_scalaradd_u32)(*(void **)oil_function
_class_ptr_scalaradd_u32))
extern OilFunctionClass *oil_function_class_ptr_scalaradd_u8; extern OilFunctionClass *oil_function_class_ptr_scalaradd_u8;
#define oil_scalaradd_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src, typedef void (*_oil_type_scalaradd_u8)(uint8_t * dest, int dstr, const uint
int sstr, uint8_t param, int n)) \ 8_t * src, int sstr, const uint8_t * s2_1, int n);
oil_function_class_ptr_scalaradd_u8->func) #define oil_scalaradd_u8 ((_oil_type_scalaradd_u8)(*(void **)oil_function_c
lass_ptr_scalaradd_u8))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_f32; extern OilFunctionClass *oil_function_class_ptr_scalarmult_f32;
#define oil_scalarmult_f32 ((void (*)(float *dest, int dstr, float *src, in typedef void (*_oil_type_scalarmult_f32)(float * dest, int dstr, const floa
t sstr, float param, int n)) \ t * src, int sstr, const float * s2_1, int n);
oil_function_class_ptr_scalarmult_f32->func) #define oil_scalarmult_f32 ((_oil_type_scalarmult_f32)(*(void **)oil_functi
on_class_ptr_scalarmult_f32))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_f64; extern OilFunctionClass *oil_function_class_ptr_scalarmult_f64;
#define oil_scalarmult_f64 ((void (*)(double *dest, int dstr, double *src, typedef void (*_oil_type_scalarmult_f64)(double * dest, int dstr, const dou
int sstr, double param, int n)) \ ble * src, int sstr, const double * s2_1, int n);
oil_function_class_ptr_scalarmult_f64->func) #define oil_scalarmult_f64 ((_oil_type_scalarmult_f64)(*(void **)oil_functi
on_class_ptr_scalarmult_f64))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_s16; extern OilFunctionClass *oil_function_class_ptr_scalarmult_s16;
#define oil_scalarmult_s16 ((void (*)(int16_t *dest, int dstr, int16_t *src typedef void (*_oil_type_scalarmult_s16)(int16_t * dest, int dstr, const in
, int sstr, int16_t param, int n)) \ t16_t * src, int sstr, const int16_t * s2_1, int n);
oil_function_class_ptr_scalarmult_s16->func) #define oil_scalarmult_s16 ((_oil_type_scalarmult_s16)(*(void **)oil_functi
on_class_ptr_scalarmult_s16))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_s32; extern OilFunctionClass *oil_function_class_ptr_scalarmult_s32;
#define oil_scalarmult_s32 ((void (*)(int32_t *dest, int dstr, int32_t *src typedef void (*_oil_type_scalarmult_s32)(int32_t * dest, int dstr, const in
, int sstr, int32_t param, int n)) \ t32_t * src, int sstr, const int32_t * s2_1, int n);
oil_function_class_ptr_scalarmult_s32->func) #define oil_scalarmult_s32 ((_oil_type_scalarmult_s32)(*(void **)oil_functi
on_class_ptr_scalarmult_s32))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_s8; extern OilFunctionClass *oil_function_class_ptr_scalarmult_s8;
#define oil_scalarmult_s8 ((void (*)(int8_t *dest, int dstr, int8_t *src, i typedef void (*_oil_type_scalarmult_s8)(int8_t * dest, int dstr, const int8
nt sstr, int8_t param, int n)) \ _t * src, int sstr, const int8_t * s2_1, int n);
oil_function_class_ptr_scalarmult_s8->func) #define oil_scalarmult_s8 ((_oil_type_scalarmult_s8)(*(void **)oil_function
_class_ptr_scalarmult_s8))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_u16; extern OilFunctionClass *oil_function_class_ptr_scalarmult_u16;
#define oil_scalarmult_u16 ((void (*)(uint16_t *dest, int dstr, uint16_t *s typedef void (*_oil_type_scalarmult_u16)(uint16_t * dest, int dstr, const u
rc, int sstr, uint16_t param, int n)) \ int16_t * src, int sstr, const uint16_t * s2_1, int n);
oil_function_class_ptr_scalarmult_u16->func) #define oil_scalarmult_u16 ((_oil_type_scalarmult_u16)(*(void **)oil_functi
on_class_ptr_scalarmult_u16))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_u32; extern OilFunctionClass *oil_function_class_ptr_scalarmult_u32;
#define oil_scalarmult_u32 ((void (*)(uint32_t *dest, int dstr, uint32_t *s typedef void (*_oil_type_scalarmult_u32)(uint32_t * dest, int dstr, const u
rc, int sstr, uint32_t param, int n)) \ int32_t * src, int sstr, const uint32_t * s2_1, int n);
oil_function_class_ptr_scalarmult_u32->func) #define oil_scalarmult_u32 ((_oil_type_scalarmult_u32)(*(void **)oil_functi
on_class_ptr_scalarmult_u32))
extern OilFunctionClass *oil_function_class_ptr_scalarmult_u8; extern OilFunctionClass *oil_function_class_ptr_scalarmult_u8;
#define oil_scalarmult_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src, typedef void (*_oil_type_scalarmult_u8)(uint8_t * dest, int dstr, const uin
int sstr, uint8_t param, int n)) \ t8_t * src, int sstr, const uint8_t * s2_1, int n);
oil_function_class_ptr_scalarmult_u8->func) #define oil_scalarmult_u8 ((_oil_type_scalarmult_u8)(*(void **)oil_function
_class_ptr_scalarmult_u8))
extern OilFunctionClass *oil_function_class_ptr_scalarmultiply_f32_ns;
typedef void (*_oil_type_scalarmultiply_f32_ns)(float * d, const float * s1
, const float * s2_1, int n);
#define oil_scalarmultiply_f32_ns ((_oil_type_scalarmultiply_f32_ns)(*(void
**)oil_function_class_ptr_scalarmultiply_f32_ns))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f32_s16;
typedef void (*_oil_type_scaleconv_f32_s16)(float * dest, const int16_t * s
rc, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f32_s16 ((_oil_type_scaleconv_f32_s16)(*(void **)oil_
function_class_ptr_scaleconv_f32_s16))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f32_s32;
typedef void (*_oil_type_scaleconv_f32_s32)(float * dest, const int32_t * s
rc, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f32_s32 ((_oil_type_scaleconv_f32_s32)(*(void **)oil_
function_class_ptr_scaleconv_f32_s32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f32_s8;
typedef void (*_oil_type_scaleconv_f32_s8)(float * dest, const int8_t * src
, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f32_s8 ((_oil_type_scaleconv_f32_s8)(*(void **)oil_fu
nction_class_ptr_scaleconv_f32_s8))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f32_u16;
typedef void (*_oil_type_scaleconv_f32_u16)(float * dest, const uint16_t *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f32_u16 ((_oil_type_scaleconv_f32_u16)(*(void **)oil_
function_class_ptr_scaleconv_f32_u16))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f32_u32;
typedef void (*_oil_type_scaleconv_f32_u32)(float * dest, const uint32_t *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f32_u32 ((_oil_type_scaleconv_f32_u32)(*(void **)oil_
function_class_ptr_scaleconv_f32_u32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f32_u8;
typedef void (*_oil_type_scaleconv_f32_u8)(float * dest, const uint8_t * sr
c, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f32_u8 ((_oil_type_scaleconv_f32_u8)(*(void **)oil_fu
nction_class_ptr_scaleconv_f32_u8))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f64_s16;
typedef void (*_oil_type_scaleconv_f64_s16)(double * dest, const int16_t *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f64_s16 ((_oil_type_scaleconv_f64_s16)(*(void **)oil_
function_class_ptr_scaleconv_f64_s16))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f64_s32;
typedef void (*_oil_type_scaleconv_f64_s32)(double * dest, const int32_t *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f64_s32 ((_oil_type_scaleconv_f64_s32)(*(void **)oil_
function_class_ptr_scaleconv_f64_s32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f64_s8;
typedef void (*_oil_type_scaleconv_f64_s8)(double * dest, const int8_t * sr
c, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f64_s8 ((_oil_type_scaleconv_f64_s8)(*(void **)oil_fu
nction_class_ptr_scaleconv_f64_s8))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f64_u16;
typedef void (*_oil_type_scaleconv_f64_u16)(double * dest, const uint16_t *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f64_u16 ((_oil_type_scaleconv_f64_u16)(*(void **)oil_
function_class_ptr_scaleconv_f64_u16))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f64_u32;
typedef void (*_oil_type_scaleconv_f64_u32)(double * dest, const uint32_t *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f64_u32 ((_oil_type_scaleconv_f64_u32)(*(void **)oil_
function_class_ptr_scaleconv_f64_u32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_f64_u8;
typedef void (*_oil_type_scaleconv_f64_u8)(double * dest, const uint8_t * s
rc, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_f64_u8 ((_oil_type_scaleconv_f64_u8)(*(void **)oil_fu
nction_class_ptr_scaleconv_f64_u8))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_s16_f32;
typedef void (*_oil_type_scaleconv_s16_f32)(int16_t * dest, const float * s
rc, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_s16_f32 ((_oil_type_scaleconv_s16_f32)(*(void **)oil_
function_class_ptr_scaleconv_s16_f32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_s16_f64;
typedef void (*_oil_type_scaleconv_s16_f64)(int16_t * dest, const double *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_s16_f64 ((_oil_type_scaleconv_s16_f64)(*(void **)oil_
function_class_ptr_scaleconv_s16_f64))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_s32_f32;
typedef void (*_oil_type_scaleconv_s32_f32)(int32_t * dest, const float * s
rc, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_s32_f32 ((_oil_type_scaleconv_s32_f32)(*(void **)oil_
function_class_ptr_scaleconv_s32_f32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_s32_f64;
typedef void (*_oil_type_scaleconv_s32_f64)(int32_t * dest, const double *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_s32_f64 ((_oil_type_scaleconv_s32_f64)(*(void **)oil_
function_class_ptr_scaleconv_s32_f64))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_s8_f32;
typedef void (*_oil_type_scaleconv_s8_f32)(int8_t * dest, const float * src
, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_s8_f32 ((_oil_type_scaleconv_s8_f32)(*(void **)oil_fu
nction_class_ptr_scaleconv_s8_f32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_s8_f64;
typedef void (*_oil_type_scaleconv_s8_f64)(int8_t * dest, const double * sr
c, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_s8_f64 ((_oil_type_scaleconv_s8_f64)(*(void **)oil_fu
nction_class_ptr_scaleconv_s8_f64))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_u16_f32;
typedef void (*_oil_type_scaleconv_u16_f32)(uint16_t * dest, const float *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_u16_f32 ((_oil_type_scaleconv_u16_f32)(*(void **)oil_
function_class_ptr_scaleconv_u16_f32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_u16_f64;
typedef void (*_oil_type_scaleconv_u16_f64)(uint16_t * dest, const double *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_u16_f64 ((_oil_type_scaleconv_u16_f64)(*(void **)oil_
function_class_ptr_scaleconv_u16_f64))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_u32_f32;
typedef void (*_oil_type_scaleconv_u32_f32)(uint32_t * dest, const float *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_u32_f32 ((_oil_type_scaleconv_u32_f32)(*(void **)oil_
function_class_ptr_scaleconv_u32_f32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_u32_f64;
typedef void (*_oil_type_scaleconv_u32_f64)(uint32_t * dest, const double *
src, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_u32_f64 ((_oil_type_scaleconv_u32_f64)(*(void **)oil_
function_class_ptr_scaleconv_u32_f64))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_u8_f32;
typedef void (*_oil_type_scaleconv_u8_f32)(uint8_t * dest, const float * sr
c, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_u8_f32 ((_oil_type_scaleconv_u8_f32)(*(void **)oil_fu
nction_class_ptr_scaleconv_u8_f32))
extern OilFunctionClass *oil_function_class_ptr_scaleconv_u8_f64;
typedef void (*_oil_type_scaleconv_u8_f64)(uint8_t * dest, const double * s
rc, int n, const double * s2_1, const double * s3_1);
#define oil_scaleconv_u8_f64 ((_oil_type_scaleconv_u8_f64)(*(void **)oil_fu
nction_class_ptr_scaleconv_u8_f64))
extern OilFunctionClass *oil_function_class_ptr_scanlinescale2_u8; extern OilFunctionClass *oil_function_class_ptr_scanlinescale2_u8;
#define oil_scanlinescale2_u8 ((void (*)(uint8_t *dest, uint8_t *src, int n typedef void (*_oil_type_scanlinescale2_u8)(uint8_t * dest, const uint8_t *
)) \ src, int n);
oil_function_class_ptr_scanlinescale2_u8->func) #define oil_scanlinescale2_u8 ((_oil_type_scanlinescale2_u8)(*(void **)oil_
function_class_ptr_scanlinescale2_u8))
extern OilFunctionClass *oil_function_class_ptr_sign_f32;
typedef void (*_oil_type_sign_f32)(float * d, const float * s, int n);
#define oil_sign_f32 ((_oil_type_sign_f32)(*(void **)oil_function_class_ptr
_sign_f32))
extern OilFunctionClass *oil_function_class_ptr_sincos_f64; extern OilFunctionClass *oil_function_class_ptr_sincos_f64;
#define oil_sincos_f64 ((void (*)(double *dest1, double *dest2, int n, doub typedef void (*_oil_type_sincos_f64)(double * dest1, double * dest2, int n,
le param1, double param2)) \ const double * s1_1, const double * s2_1);
oil_function_class_ptr_sincos_f64->func) #define oil_sincos_f64 ((_oil_type_sincos_f64)(*(void **)oil_function_class
_ptr_sincos_f64))
extern OilFunctionClass *oil_function_class_ptr_splat_u32; extern OilFunctionClass *oil_function_class_ptr_splat_u32;
#define oil_splat_u32 ((void (*)(uint32_t *dest, int dstr, uint32_t *param, typedef void (*_oil_type_splat_u32)(uint32_t * dest, int dstr, const uint32
int n)) \ _t * s1_1, int n);
oil_function_class_ptr_splat_u32->func) #define oil_splat_u32 ((_oil_type_splat_u32)(*(void **)oil_function_class_p
tr_splat_u32))
extern OilFunctionClass *oil_function_class_ptr_splat_u32_ns;
typedef void (*_oil_type_splat_u32_ns)(uint32_t * dest, const uint32_t * s1
_1, int n);
#define oil_splat_u32_ns ((_oil_type_splat_u32_ns)(*(void **)oil_function_c
lass_ptr_splat_u32_ns))
extern OilFunctionClass *oil_function_class_ptr_splat_u8; extern OilFunctionClass *oil_function_class_ptr_splat_u8;
#define oil_splat_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *param, in typedef void (*_oil_type_splat_u8)(uint8_t * dest, int dstr, const uint8_t
t n)) \ * s1_1, int n);
oil_function_class_ptr_splat_u8->func) #define oil_splat_u8 ((_oil_type_splat_u8)(*(void **)oil_function_class_ptr
_splat_u8))
extern OilFunctionClass *oil_function_class_ptr_splat_u8_ns;
typedef void (*_oil_type_splat_u8_ns)(uint8_t * dest, const uint8_t * s1_1,
int n);
#define oil_splat_u8_ns ((_oil_type_splat_u8_ns)(*(void **)oil_function_cla
ss_ptr_splat_u8_ns))
extern OilFunctionClass *oil_function_class_ptr_squaresum_f64; extern OilFunctionClass *oil_function_class_ptr_squaresum_f64;
#define oil_squaresum_f64 ((void (*)(double *dest, double *src, int n)) \ typedef void (*_oil_type_squaresum_f64)(double * dest, const double * src,
oil_function_class_ptr_squaresum_f64->func) int n);
#define oil_squaresum_f64 ((_oil_type_squaresum_f64)(*(void **)oil_function
_class_ptr_squaresum_f64))
extern OilFunctionClass *oil_function_class_ptr_subtract_f32;
typedef void (*_oil_type_subtract_f32)(float * d, const float * s1, const f
loat * s2, int n);
#define oil_subtract_f32 ((_oil_type_subtract_f32)(*(void **)oil_function_c
lass_ptr_subtract_f32))
extern OilFunctionClass *oil_function_class_ptr_sum_f64; extern OilFunctionClass *oil_function_class_ptr_sum_f64;
#define oil_sum_f64 ((void (*)(double *dest, double *src, int sstr, int n)) typedef void (*_oil_type_sum_f64)(double * dest, const double * src, int ss
\ tr, int n);
oil_function_class_ptr_sum_f64->func) #define oil_sum_f64 ((_oil_type_sum_f64)(*(void **)oil_function_class_ptr_s
um_f64))
extern OilFunctionClass *oil_function_class_ptr_tablelookup_u8; extern OilFunctionClass *oil_function_class_ptr_tablelookup_u8;
#define oil_tablelookup_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src typedef void (*_oil_type_tablelookup_u8)(uint8_t * d, int ds, const uint8_t
1, int sstr1, uint8_t *src2, int sstr2, int n)) \ * s1, int ss1, const uint8_t * s2_256, int ss2, int n);
oil_function_class_ptr_tablelookup_u8->func) #define oil_tablelookup_u8 ((_oil_type_tablelookup_u8)(*(void **)oil_functi
on_class_ptr_tablelookup_u8))
extern OilFunctionClass *oil_function_class_ptr_trans8x8_f64; extern OilFunctionClass *oil_function_class_ptr_trans8x8_f64;
#define oil_trans8x8_f64 ((void (*)(double *dest, int dstr, double *src, in typedef void (*_oil_type_trans8x8_f64)(double * d_8x8, int ds, const double
t sstr)) \ * s_8x8, int ss);
oil_function_class_ptr_trans8x8_f64->func) #define oil_trans8x8_f64 ((_oil_type_trans8x8_f64)(*(void **)oil_function_c
lass_ptr_trans8x8_f64))
extern OilFunctionClass *oil_function_class_ptr_trans8x8_u16; extern OilFunctionClass *oil_function_class_ptr_trans8x8_u16;
#define oil_trans8x8_u16 ((void (*)(uint16_t *dest, int dstr, uint16_t *src typedef void (*_oil_type_trans8x8_u16)(uint16_t * d_8x8, int ds, const uint
, int sstr)) \ 16_t * s_8x8, int ss);
oil_function_class_ptr_trans8x8_u16->func) #define oil_trans8x8_u16 ((_oil_type_trans8x8_u16)(*(void **)oil_function_c
lass_ptr_trans8x8_u16))
extern OilFunctionClass *oil_function_class_ptr_trans8x8_u32; extern OilFunctionClass *oil_function_class_ptr_trans8x8_u32;
#define oil_trans8x8_u32 ((void (*)(uint32_t *dest, int dstr, uint32_t *src typedef void (*_oil_type_trans8x8_u32)(uint32_t * d_8x8, int ds, const uint
, int sstr)) \ 32_t * s_8x8, int ss);
oil_function_class_ptr_trans8x8_u32->func) #define oil_trans8x8_u32 ((_oil_type_trans8x8_u32)(*(void **)oil_function_c
lass_ptr_trans8x8_u32))
extern OilFunctionClass *oil_function_class_ptr_trans8x8_u8; extern OilFunctionClass *oil_function_class_ptr_trans8x8_u8;
#define oil_trans8x8_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src, i typedef void (*_oil_type_trans8x8_u8)(uint8_t * d_8x8, int ds, const uint8_
nt sstr)) \ t * s_8x8, int ss);
oil_function_class_ptr_trans8x8_u8->func) #define oil_trans8x8_u8 ((_oil_type_trans8x8_u8)(*(void **)oil_function_cla
ss_ptr_trans8x8_u8))
extern OilFunctionClass *oil_function_class_ptr_unzigzag8x8_s16; extern OilFunctionClass *oil_function_class_ptr_unzigzag8x8_s16;
#define oil_unzigzag8x8_s16 ((void (*)(int16_t *dest, int dstr, int16_t *sr typedef void (*_oil_type_unzigzag8x8_s16)(int16_t * d_8x8, int ds, const in
c, int sstr)) \ t16_t * s_8x8, int ss);
oil_function_class_ptr_unzigzag8x8_s16->func) #define oil_unzigzag8x8_s16 ((_oil_type_unzigzag8x8_s16)(*(void **)oil_func
tion_class_ptr_unzigzag8x8_s16))
extern OilFunctionClass *oil_function_class_ptr_utf8_validate;
typedef void (*_oil_type_utf8_validate)(int32_t * d_1, const uint8_t * s, i
nt n);
#define oil_utf8_validate ((_oil_type_utf8_validate)(*(void **)oil_function
_class_ptr_utf8_validate))
extern OilFunctionClass *oil_function_class_ptr_uyvy2ayuv;
typedef void (*_oil_type_uyvy2ayuv)(uint32_t * d_n, const uint32_t * s_n, i
nt n);
#define oil_uyvy2ayuv ((_oil_type_uyvy2ayuv)(*(void **)oil_function_class_p
tr_uyvy2ayuv))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_f32; extern OilFunctionClass *oil_function_class_ptr_vectoradd_f32;
#define oil_vectoradd_f32 ((void (*)(float *dest, int dstr, float *src1, in typedef void (*_oil_type_vectoradd_f32)(float * dest, int dstr, const float
t sstr1, float *src2, int sstr2, int n, float param1, float param2)) \ * src1, int sstr1, const float * src2, int sstr2, int n, const float * s3_
oil_function_class_ptr_vectoradd_f32->func) 1, const float * s4_1);
#define oil_vectoradd_f32 ((_oil_type_vectoradd_f32)(*(void **)oil_function
_class_ptr_vectoradd_f32))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_f64; extern OilFunctionClass *oil_function_class_ptr_vectoradd_f64;
#define oil_vectoradd_f64 ((void (*)(double *dest, int dstr, double *src1, typedef void (*_oil_type_vectoradd_f64)(double * dest, int dstr, const doub
int sstr1, double *src2, int sstr2, int n, double param1, double param2)) \ le * src1, int sstr1, const double * src2, int sstr2, int n, const double *
oil_function_class_ptr_vectoradd_f64->func) s3_1, const double * s4_1);
#define oil_vectoradd_f64 ((_oil_type_vectoradd_f64)(*(void **)oil_function
_class_ptr_vectoradd_f64))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_s16; extern OilFunctionClass *oil_function_class_ptr_vectoradd_s16;
#define oil_vectoradd_s16 ((void (*)(int16_t *dest, int dstr, int16_t *src1 typedef void (*_oil_type_vectoradd_s16)(int16_t * dest, int dstr, const int
, int sstr1, int16_t *src2, int sstr2, int n, int16_t param1, int16_t param 16_t * src1, int sstr1, const int16_t * src2, int sstr2, int n, const int16
2)) \ _t * s3_1, const int16_t * s4_1);
oil_function_class_ptr_vectoradd_s16->func) #define oil_vectoradd_s16 ((_oil_type_vectoradd_s16)(*(void **)oil_function
_class_ptr_vectoradd_s16))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_s32; extern OilFunctionClass *oil_function_class_ptr_vectoradd_s32;
#define oil_vectoradd_s32 ((void (*)(int32_t *dest, int dstr, int32_t *src1 typedef void (*_oil_type_vectoradd_s32)(int32_t * dest, int dstr, const int
, int sstr1, int32_t *src2, int sstr2, int n, int32_t param1, int32_t param 32_t * src1, int sstr1, const int32_t * src2, int sstr2, int n, const int32
2)) \ _t * s3_1, const int32_t * s4_1);
oil_function_class_ptr_vectoradd_s32->func) #define oil_vectoradd_s32 ((_oil_type_vectoradd_s32)(*(void **)oil_function
_class_ptr_vectoradd_s32))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_s8; extern OilFunctionClass *oil_function_class_ptr_vectoradd_s8;
#define oil_vectoradd_s8 ((void (*)(int8_t *dest, int dstr, int8_t *src1, i typedef void (*_oil_type_vectoradd_s8)(int8_t * dest, int dstr, const int8_
nt sstr1, int8_t *src2, int sstr2, int n, int8_t param1, int8_t param2)) \ t * src1, int sstr1, const int8_t * src2, int sstr2, int n, const int8_t *
oil_function_class_ptr_vectoradd_s8->func) s3_1, const int8_t * s4_1);
#define oil_vectoradd_s8 ((_oil_type_vectoradd_s8)(*(void **)oil_function_c
lass_ptr_vectoradd_s8))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_u16; extern OilFunctionClass *oil_function_class_ptr_vectoradd_u16;
#define oil_vectoradd_u16 ((void (*)(uint16_t *dest, int dstr, uint16_t *sr typedef void (*_oil_type_vectoradd_u16)(uint16_t * dest, int dstr, const ui
c1, int sstr1, uint16_t *src2, int sstr2, int n, uint16_t param1, uint16_t nt16_t * src1, int sstr1, const uint16_t * src2, int sstr2, int n, const ui
param2)) \ nt16_t * s3_1, const uint16_t * s4_1);
oil_function_class_ptr_vectoradd_u16->func) #define oil_vectoradd_u16 ((_oil_type_vectoradd_u16)(*(void **)oil_function
_class_ptr_vectoradd_u16))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_u32; extern OilFunctionClass *oil_function_class_ptr_vectoradd_u32;
#define oil_vectoradd_u32 ((void (*)(uint32_t *dest, int dstr, uint32_t *sr typedef void (*_oil_type_vectoradd_u32)(uint32_t * dest, int dstr, const ui
c1, int sstr1, uint32_t *src2, int sstr2, int n, uint32_t param1, uint32_t nt32_t * src1, int sstr1, const uint32_t * src2, int sstr2, int n, const ui
param2)) \ nt32_t * s3_1, const uint32_t * s4_1);
oil_function_class_ptr_vectoradd_u32->func) #define oil_vectoradd_u32 ((_oil_type_vectoradd_u32)(*(void **)oil_function
_class_ptr_vectoradd_u32))
extern OilFunctionClass *oil_function_class_ptr_vectoradd_u8; extern OilFunctionClass *oil_function_class_ptr_vectoradd_u8;
#define oil_vectoradd_u8 ((void (*)(uint8_t *dest, int dstr, uint8_t *src1, typedef void (*_oil_type_vectoradd_u8)(uint8_t * dest, int dstr, const uint
int sstr1, uint8_t *src2, int sstr2, int n, uint8_t param1, uint8_t param2 8_t * src1, int sstr1, const uint8_t * src2, int sstr2, int n, const uint8_
)) \ t * s3_1, const uint8_t * s4_1);
oil_function_class_ptr_vectoradd_u8->func) #define oil_vectoradd_u8 ((_oil_type_vectoradd_u8)(*(void **)oil_function_c
lass_ptr_vectoradd_u8))
extern OilFunctionClass *oil_function_class_ptr_yuv2rgbx_sub2_u8; extern OilFunctionClass *oil_function_class_ptr_yuv2rgbx_sub2_u8;
#define oil_yuv2rgbx_sub2_u8 ((void (*)(uint8_t *dest, uint8_t *src1, uint8 typedef void (*_oil_type_yuv2rgbx_sub2_u8)(uint8_t * d_4xn, const uint8_t *
_t *src2, uint8_t *src3, int n)) \ src1, const uint8_t * src2, const uint8_t * src3, int n);
oil_function_class_ptr_yuv2rgbx_sub2_u8->func) #define oil_yuv2rgbx_sub2_u8 ((_oil_type_yuv2rgbx_sub2_u8)(*(void **)oil_fu
nction_class_ptr_yuv2rgbx_sub2_u8))
extern OilFunctionClass *oil_function_class_ptr_yuv2rgbx_sub4_u8; extern OilFunctionClass *oil_function_class_ptr_yuv2rgbx_sub4_u8;
#define oil_yuv2rgbx_sub4_u8 ((void (*)(uint8_t *dest, uint8_t *src1, uint8 typedef void (*_oil_type_yuv2rgbx_sub4_u8)(uint8_t * d_4xn, const uint8_t *
_t *src2, uint8_t *src3, int n)) \ src1, const uint8_t * src2, const uint8_t * src3, int n);
oil_function_class_ptr_yuv2rgbx_sub4_u8->func) #define oil_yuv2rgbx_sub4_u8 ((_oil_type_yuv2rgbx_sub4_u8)(*(void **)oil_fu
nction_class_ptr_yuv2rgbx_sub4_u8))
extern OilFunctionClass *oil_function_class_ptr_yuv2rgbx_u8; extern OilFunctionClass *oil_function_class_ptr_yuv2rgbx_u8;
#define oil_yuv2rgbx_u8 ((void (*)(uint8_t *dest, uint8_t *src1, uint8_t *s typedef void (*_oil_type_yuv2rgbx_u8)(uint8_t * d_4xn, const uint8_t * src1
rc2, uint8_t *src3, int n)) \ , const uint8_t * src2, const uint8_t * src3, int n);
oil_function_class_ptr_yuv2rgbx_u8->func) #define oil_yuv2rgbx_u8 ((_oil_type_yuv2rgbx_u8)(*(void **)oil_function_cla
ss_ptr_yuv2rgbx_u8))
extern OilFunctionClass *oil_function_class_ptr_yuyv2ayuv;
typedef void (*_oil_type_yuyv2ayuv)(uint32_t * d_n, const uint32_t * s_n, i
nt n);
#define oil_yuyv2ayuv ((_oil_type_yuyv2ayuv)(*(void **)oil_function_class_p
tr_yuyv2ayuv))
extern OilFunctionClass *oil_function_class_ptr_yvyu2ayuv;
typedef void (*_oil_type_yvyu2ayuv)(uint32_t * d_n, const uint32_t * s_n, i
nt n);
#define oil_yvyu2ayuv ((_oil_type_yvyu2ayuv)(*(void **)oil_function_class_p
tr_yvyu2ayuv))
extern OilFunctionClass *oil_function_class_ptr_zigzag8x8_s16;
typedef void (*_oil_type_zigzag8x8_s16)(int16_t * d_8x8, int ds, const int1
6_t * s_8x8, int ss);
#define oil_zigzag8x8_s16 ((_oil_type_zigzag8x8_s16)(*(void **)oil_function
_class_ptr_zigzag8x8_s16))
#ifdef __cplusplus
}
#endif
#endif #endif
 End of changes. 169 change blocks. 
515 lines changed or deleted 1169 lines changed or added


 liboilfunction.h   liboilfunction.h 
/* liboil - Library of Optimized Inner Loops /*
* Copyright (C) 2003 David A. Schleef <ds@schleef.org> * LIBOIL - Library of Optimized Inner Loops
* Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
* All rights reserved.
* *
* This library is free software; you can redistribute it and/or * Redistribution and use in source and binary forms, with or without
* modify it under the terms of version 2.1 of the GNU Lesser General * modification, are permitted provided that the following conditions
* Public License as published by the Free Software Foundation. * are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* *
* This library is distributed in the hope that it will be useful, * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* but WITHOUT ANY WARRANTY; without even the implied warranty of * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* Library General Public License for more details. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* You should have received a copy of the GNU Lesser General Public * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* License along with this library; if not, write to the * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* Boston, MA 02111-1307 USA. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef _LIBOIL_FUNCTION_H_ #ifndef _LIBOIL_FUNCTION_H_
#define _LIBOIL_FUNCTION_H_ #define _LIBOIL_FUNCTION_H_
#include <liboil/liboiltypes.h> #include <liboil/liboiltypes.h>
typedef struct _OilFunctionClass OilFunctionClass; #ifdef LIBOIL_STRICT_PROTOTYPES
typedef struct _OilFunctionImpl OilFunctionImpl; #include <liboil/liboilfuncs.h>
typedef struct _OilFunctionArg OilFunctionArg; #define LIBOIL_CHECK_PROTOTYPE(a) a
#else
typedef void (*OilTestFunction) (OilFunctionClass *klass, #define LIBOIL_CHECK_PROTOTYPE(a)
OilFunctionImpl *impl); #endif
#ifdef HAVE_GNU_LINKER #ifndef OIL_OPT_MANGLE
#define OIL_ATTRIBUTE_ALIGNED_16 __attribute__ ((aligned (16))) #define OIL_OPT_MANGLE(a) a
#define OIL_IMPL_SECTION __attribute__ ((section ("oil_impl"))) #define OIL_OPT_FLAG_MANGLE(a) a
#define OIL_CLASS_SECTION __attribute__ ((section ("oil_class")))
#else #else
#define OIL_ATTRIBUTE_ALIGNED_16 #define OIL_NO_CLASSES
#define OIL_IMPL_SECTION #define OIL_OPT_FLAG_MANGLE(a) (((a)&(~OIL_IMPL_FLAG_REF)) | OIL_IMPL_FLAG_
#define OIL_CLASS_SECTION OPT)
#endif
#ifndef OIL_OPT_SUFFIX
#define OIL_OPT_SUFFIX
#endif #endif
struct _OilFunctionClass { struct _OilFunctionClass {
void *func; void *func;
const char *name; const char *name;
const char *desc; const char *desc;
OilTestFunction test_func; OilTestFunction test_func;
OilFunctionImpl *first_impl; OilFunctionImpl *first_impl;
OilFunctionImpl *reference_impl; OilFunctionImpl *reference_impl;
OilFunctionImpl *chosen_impl; OilFunctionImpl *chosen_impl;
const char *prototype; const char *prototype;
} OIL_ATTRIBUTE_ALIGNED_16; };
struct _OilFunctionImpl { struct _OilFunctionImpl {
void *next; void *next;
OilFunctionClass *klass; OilFunctionClass *klass;
void *func; void *func;
unsigned int flags; unsigned int flags;
const char *name; const char *name;
unsigned int prof; double profile_ave;
} OIL_ATTRIBUTE_ALIGNED_16; double profile_std;
};
#define OIL_GET(ptr, offset, type) (*(type *)((uint8_t *)ptr + offset) )
#define OIL_OFFSET(ptr, offset) ((void *)((uint8_t *)ptr + offset) ) #define OIL_GET(ptr, offset, type) (*(type *)((uint8_t *)ptr + (offset)) )
#define OIL_INCREMENT(ptr, offset) (ptr = (void *)((uint8_t *)ptr + offset) #define OIL_OFFSET(ptr, offset) ((void *)((uint8_t *)ptr + (offset)) )
) #define OIL_INCREMENT(ptr, offset) (ptr = (void *)((uint8_t *)ptr + (offset
)) )
#define OIL_IMPL_FLAG_REF (1<<0) #define OIL_IMPL_FLAG_REF (1<<0)
#define OIL_IMPL_FLAG_OPT (1<<1)
#define OIL_IMPL_FLAG_ASM (1<<2)
#define OIL_IMPL_FLAG_DISABLED (1<<3)
#define OIL_ARCH_FLAGS 0xffff0000 #define OIL_CPU_FLAG_MASK 0xffff0000
/* i386 */ /* i386 */
#define OIL_IMPL_REQUIRES_CMOV (1<<16) #define OIL_IMPL_FLAG_CMOV (1<<16)
#define OIL_IMPL_REQUIRES_MMX (1<<17) #define OIL_IMPL_FLAG_MMX (1<<17)
#define OIL_IMPL_REQUIRES_SSE (1<<18) #define OIL_IMPL_FLAG_SSE (1<<18)
#define OIL_IMPL_REQUIRES_MMXEXT (1<<19) #define OIL_IMPL_FLAG_MMXEXT (1<<19)
#define OIL_IMPL_REQUIRES_SSE2 (1<<20) #define OIL_IMPL_FLAG_SSE2 (1<<20)
#define OIL_IMPL_REQUIRES_3DNOW (1<<21) #define OIL_IMPL_FLAG_3DNOW (1<<21)
#define OIL_IMPL_REQUIRES_3DNOWEXT (1<<22) #define OIL_IMPL_FLAG_3DNOWEXT (1<<22)
#define OIL_IMPL_FLAG_SSE3 (1<<23)
/* powerpc */ /* powerpc */
#define OIL_IMPL_REQUIRES_ALTIVEC (1<<16) #define OIL_IMPL_FLAG_ALTIVEC (1<<16)
#define OIL_DECLARE_CLASS(klass) \ #define OIL_DECLARE_CLASS(klass) \
extern OilFunctionClass _oil_function_class_ ## klass extern OilFunctionClass _oil_function_class_ ## klass
#ifndef OIL_NO_CLASSES
#define OIL_DEFINE_CLASS_FULL(klass, string, test) \ #define OIL_DEFINE_CLASS_FULL(klass, string, test) \
OilFunctionClass _oil_function_class_ ## klass OIL_CLASS_SECTION = { \ OilFunctionClass _oil_function_class_ ## klass = { \
NULL, \ NULL, \
#klass , \ #klass , \
NULL, \ NULL, \
(OilTestFunction) test, \ test, \
NULL, \ NULL, \
NULL, \ NULL, \
NULL, \ NULL, \
string \ string \
}; \ }; \
OilFunctionClass *oil_function_class_ptr_ ## klass = \ OilFunctionClass *oil_function_class_ptr_ ## klass = \
&_oil_function_class_ ## klass &_oil_function_class_ ## klass
#else
#define OIL_DEFINE_CLASS_FULL(klass, string, test) \
OIL_DECLARE_CLASS(klass)
#endif
#define OIL_DEFINE_CLASS(klass, string) \ #define OIL_DEFINE_CLASS(klass, string) \
OilFunctionClass _oil_function_class_ ## klass OIL_CLASS_SECTION = { \ OIL_DEFINE_CLASS_FULL (klass, string, NULL)
NULL, \
#klass , \
NULL, \
(OilTestFunction) NULL, \
NULL, \
NULL, \
NULL, \
string \
}; \
OilFunctionClass *oil_function_class_ptr_ ## klass = \
&_oil_function_class_ ## klass
#define OIL_ARG(a,b,c,d) { a, b, c, d }
#define OIL_DEFINE_IMPL_FULL(function,klass,flags) \ #define OIL_DEFINE_IMPL_FULL(function,klass,flags) \
OilFunctionImpl _oil_function_impl_ ## function OIL_IMPL_SECTION = { \ OilFunctionImpl OIL_OPT_MANGLE(_oil_function_impl_ ## function) = { \
NULL, \ NULL, \
&_oil_function_class_ ## klass , \ &_oil_function_class_ ## klass , \
(void *)function, \ (void *)function, \
flags, \ OIL_OPT_FLAG_MANGLE(flags), \
#function \ #function OIL_OPT_SUFFIX \
} } \
LIBOIL_CHECK_PROTOTYPE(;_oil_type_ ## klass _ignore_me_ ## function = funct
ion)
#define OIL_DEFINE_IMPL(function,klass) \ #define OIL_DEFINE_IMPL(function,klass) \
OIL_DEFINE_IMPL_FULL(function,klass,0) OIL_DEFINE_IMPL_FULL(function,klass,0)
#define OIL_DEFINE_IMPL_REF(function,klass) \ #define OIL_DEFINE_IMPL_REF(function,klass) \
OIL_DEFINE_IMPL_FULL(function,klass,OIL_IMPL_FLAG_REF) OIL_DEFINE_IMPL_FULL(function,klass,OIL_IMPL_FLAG_REF)
#define OIL_DEFINE_IMPL_ASM(function,klass) \
OIL_DEFINE_IMPL_FULL(function,klass,OIL_IMPL_FLAG_ASM)
#define OIL_DEFINE_IMPL_DEPENDS(function,klass,...) \ #define OIL_DEFINE_IMPL_DEPENDS(function,klass,...) \
OIL_DEFINE_IMPL_FULL(function,klass,OIL_IMPL_FLAG_REF) OIL_DEFINE_IMPL_FULL(function,klass,0)
extern unsigned int oil_arch_flags;
extern int oil_n_function_impls;
extern int oil_n_function_classes;
void oil_init (void);
void oil_optimize_all (void); void oil_optimize_all (void);
void oil_optimize (const char *class_name); void oil_optimize (const char *class_name);
OilFunctionClass * oil_class_get_by_index (int i); OilFunctionClass * oil_class_get_by_index (int i);
OilFunctionClass *oil_class_get (const char *class_name); OilFunctionClass *oil_class_get (const char *class_name);
void oil_class_optimize (OilFunctionClass *klass); void oil_class_optimize (OilFunctionClass *klass);
int oil_class_get_n_classes (void);
OilFunctionImpl * oil_impl_get_by_index (int i); OilFunctionImpl * oil_impl_get_by_index (int i);
int oil_impl_is_runnable (OilFunctionImpl *impl);
void oil_class_choose_by_name (OilFunctionClass * klass, const char *name); void oil_class_choose_by_name (OilFunctionClass * klass, const char *name);
void oil_class_register_impl_full (OilFunctionClass * klass,
void (*func)(void), const char *name, unsigned int flags);
void oil_class_register_impl (OilFunctionClass * klass, OilFunctionImpl *im
pl);
void oil_class_register_impl_by_name (const char *klass_name,
OilFunctionImpl *impl);
void oil_init_no_optimize(void);
#endif #endif
 End of changes. 24 change blocks. 
71 lines changed or deleted 89 lines changed or added


 liboilprototype.h   liboilprototype.h 
/* liboil - Library of Optimized Inner Loops /*
* Copyright (C) 2003,2004 David A. Schleef <ds@schleef.org> * LIBOIL - Library of Optimized Inner Loops
* Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
* All rights reserved.
* *
* This library is free software; you can redistribute it and/or * Redistribution and use in source and binary forms, with or without
* modify it under the terms of version 2.1 of the GNU Lesser General * modification, are permitted provided that the following conditions
* Public License as published by the Free Software Foundation. * are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* *
* This library is distributed in the hope that it will be useful, * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* but WITHOUT ANY WARRANTY; without even the implied warranty of * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* Library General Public License for more details. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* You should have received a copy of the GNU Lesser General Public * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* License along with this library; if not, write to the * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* Boston, MA 02111-1307 USA. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef _LIBOIL_PROTOTYPE_H_ #ifndef _LIBOIL_PROTOTYPE_H_
#define _LIBOIL_PROTOTYPE_H_ #define _LIBOIL_PROTOTYPE_H_
typedef struct _OilParameter OilParameter; #include <liboil/liboilfunction.h>
struct _OilParameter { #include <liboil/liboilparameter.h>
char *type;
int ptr;
char *name;
};
typedef struct _OilPrototype OilPrototype; typedef struct _OilPrototype OilPrototype;
struct _OilPrototype { struct _OilPrototype {
int n_params; int n_params;
OilParameter *params; OilParameter *params;
}; OilFunctionClass *klass;
enum{
OIL_TYPE_UNKNOWN,
OIL_TYPE_s8,
OIL_TYPE_u8,
OIL_TYPE_s16,
OIL_TYPE_u16,
OIL_TYPE_s32,
OIL_TYPE_u32,
OIL_TYPE_f32,
OIL_TYPE_f64,
}; };
OilPrototype *oil_prototype_from_string (const char *s); OilPrototype *oil_prototype_from_string (const char *s);
char *oil_prototype_to_string (OilPrototype *proto); char *oil_prototype_to_string (OilPrototype *proto);
void oil_prototype_free (OilPrototype *proto); void oil_prototype_free (OilPrototype *proto);
void oil_prototype_append_param (OilPrototype *proto, OilParameter *param); void oil_prototype_append_param (OilPrototype *proto, OilParameter *param);
int oil_type_sizeof (OilType type);
const char * oil_type_name (OilType type);
const char * oil_arg_type_name (OilArgType type);
#endif #endif
 End of changes. 6 change blocks. 
32 lines changed or deleted 30 lines changed or added


 liboiltypes.h   liboiltypes.h 
/* liboil - Library of Optimized Inner Loops /*
* Copyright (C) 2003 David A. Schleef <ds@schleef.org> * LIBOIL - Library of Optimized Inner Loops
* Copyright (c) 2003,2004 David A. Schleef <ds@schleef.org>
* All rights reserved.
* *
* This library is free software; you can redistribute it and/or * Redistribution and use in source and binary forms, with or without
* modify it under the terms of version 2.1 of the GNU Lesser General * modification, are permitted provided that the following conditions
* Public License as published by the Free Software Foundation. * are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* *
* This library is distributed in the hope that it will be useful, * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* but WITHOUT ANY WARRANTY; without even the implied warranty of * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* Library General Public License for more details. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
* * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* You should have received a copy of the GNU Lesser General Public * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* License along with this library; if not, write to the * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* Free Software Foundation, Inc., 59 Temple Place, Suite 330, * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* Boston, MA 02111-1307 USA. * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef _LIBOIL_TYPES_H_ #ifndef _LIBOIL_TYPES_H_
#define _LIBOIL_TYPES_H_ #define _LIBOIL_TYPES_H_
#include <stdint.h> #include <stdint.h>
#ifndef NULL #ifndef NULL
#define NULL ((void *)0) #define NULL ((void *)0)
#endif #endif
typedef struct _OilFunctionClass OilFunctionClass;
typedef struct _OilFunctionImpl OilFunctionImpl;
typedef struct _OilParameter OilParameter;
typedef struct _OilTest OilTest;
typedef void (*OilTestFunction) (OilTest *test);
#define type_s8 int8_t #define type_s8 int8_t
#define type_u8 uint8_t #define type_u8 uint8_t
#define type_s16 int16_t #define type_s16 int16_t
#define type_u16 uint16_t #define type_u16 uint16_t
#define type_s32 int32_t #define type_s32 int32_t
#define type_u32 uint32_t #define type_u32 uint32_t
#define type_f32 float #define type_f32 float
#define type_f64 double #define type_f64 double
#define type_min_s8 (-128) #define type_min_s8 (-128)
 End of changes. 4 change blocks. 
14 lines changed or deleted 30 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/