Function Classes

Function Classes — Function Classes

Synopsis




void        oil_abs_f32_f32                 (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_abs_f64_f64                 (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_abs_u16_s16                 (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_abs_u32_s32                 (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_abs_u8_s8                   (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_argb_paint_u8               (uint8_t *i_4xn,
                                             const uint8_t *s1_4,
                                             const uint8_t *s2_n,
                                             int n);
void        oil_average2_u8                 (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src1,
                                             int sstr1,
                                             const uint8_t *src2,
                                             int sstr2,
                                             int n);
void        oil_ayuv2argb_u8                (uint8_t *d_4xn,
                                             const uint8_t *s_4xn,
                                             int n);
void        oil_clip_f32                    (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n,
                                             const float *s2_1,
                                             const float *s3_1);
void        oil_clip_f64                    (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n,
                                             const double *s2_1,
                                             const double *s3_1);
void        oil_clip_s16                    (int16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n,
                                             const int16_t *s2_1,
                                             const int16_t *s3_1);
void        oil_clip_s32                    (int32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n,
                                             const int32_t *s2_1,
                                             const int32_t *s3_1);
void        oil_clip_s8                     (int8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n,
                                             const int8_t *s2_1,
                                             const int8_t *s3_1);
void        oil_clip_u16                    (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n,
                                             const uint16_t *s2_1,
                                             const uint16_t *s3_1);
void        oil_clip_u32                    (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n,
                                             const uint32_t *s2_1,
                                             const uint32_t *s3_1);
void        oil_clip_u8                     (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n,
                                             const uint8_t *s2_1,
                                             const uint8_t *s3_1);
void        oil_clipconv8x8_u8_s16          (uint8_t *d_8x8,
                                             int dstr,
                                             const int16_t *s_8x8,
                                             int sstr);
void        oil_clipconv_s16_f32            (int16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s16_f64            (int16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s16_s32            (int16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s16_u16            (int16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s16_u32            (int16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s32_f32            (int32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s32_f64            (int32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s32_u32            (int32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s8_f32             (int8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s8_f64             (int8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s8_s16             (int8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s8_s32             (int8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s8_u16             (int8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s8_u32             (int8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_s8_u8              (int8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u16_f32            (uint16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u16_f64            (uint16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u16_s16            (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u16_s32            (uint16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u16_u32            (uint16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u32_f32            (uint32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u32_f64            (uint32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u32_s32            (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u8_f32             (uint8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u8_f64             (uint8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u8_s16             (uint8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u8_s32             (uint8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u8_s8              (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u8_u16             (uint8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_clipconv_u8_u32             (uint8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv8x8_f64_s16             (double *d_8x8,
                                             int dstr,
                                             const int16_t *s_8x8,
                                             int sstr);
void        oil_conv8x8_s16_f64             (int16_t *d_8x8,
                                             int dstr,
                                             const double *s_8x8,
                                             int sstr);
void        oil_conv_f32_f64                (float *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_conv_f32_s16                (float *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f32_s32                (float *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f32_s8                 (float *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f32_u16                (float *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f32_u32                (float *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f32_u8                 (float *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f64_f32                (double *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_conv_f64_s16                (double *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f64_s32                (double *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f64_s8                 (double *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f64_u16                (double *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f64_u32                (double *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_f64_u8                 (double *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s16_f32                (int16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_conv_s16_f64                (int16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_conv_s16_s32                (int16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s16_s8                 (int16_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s16_u16                (int16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s16_u32                (int16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s16_u8                 (int16_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s32_f32                (int32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_conv_s32_f64                (int32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_conv_s32_s16                (int32_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s32_s8                 (int32_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s32_u16                (int32_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s32_u32                (int32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s32_u8                 (int32_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s8_f32                 (int8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_conv_s8_f64                 (int8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_conv_s8_s16                 (int8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s8_s32                 (int8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s8_u16                 (int8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s8_u32                 (int8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_s8_u8                  (int8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u16_f32                (uint16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_conv_u16_f64                (uint16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_conv_u16_s16                (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u16_s32                (uint16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u16_s8                 (uint16_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u16_u32                (uint16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u16_u8                 (uint16_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u32_f32                (uint32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_conv_u32_f64                (uint32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_conv_u32_s16                (uint32_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u32_s32                (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u32_s8                 (uint32_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u32_u16                (uint32_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u32_u8                 (uint32_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u8_f32                 (uint8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);
void        oil_conv_u8_f64                 (uint8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_conv_u8_s16                 (uint8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u8_s32                 (uint8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u8_s8                  (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u8_u16                 (uint8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);
void        oil_conv_u8_u32                 (uint8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);
void        oil_copy_u8                     (uint8_t *dest,
                                             const uint8_t *src,
                                             int n);
void        oil_dct36_f32                   (float *d_36,
                                             int dstr,
                                             const float *s_36,
                                             int sstr);
void        oil_dequantize8x8_s16           (int16_t *d_8x8,
                                             int dstr,
                                             const int16_t *s1_8x8,
                                             int sstr1,
                                             const int16_t *s2_8x8,
                                             int sstr2);
void        oil_diffsquaresum_f64           (double *d_1,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n);
void        oil_fdct8_f64                   (double *d_8,
                                             const double *s_8,
                                             int dstr,
                                             int sstr);
void        oil_fdct8x8_f64                 (double *d_8x8,
                                             int dstr,
                                             const double *s_8x8,
                                             int sstr);
void        oil_fdct8x8s_s16                (int16_t *d_8x8,
                                             int ds,
                                             const int16_t *s_8x8,
                                             int ss);
void        oil_idct8_f64                   (double *d_8,
                                             int dstr,
                                             const double *s_8,
                                             int sstr);
void        oil_idct8x8_f64                 (double *d_8x8,
                                             int dstr,
                                             const double *s_8x8,
                                             int sstr);
void        oil_idct8x8_s16                 (int16_t *d_8x8,
                                             int dstr,
                                             const int16_t *s_8x8,
                                             int sstr);
void        oil_imdct12_f64                 (double *d_12,
                                             const double *s_6);
void        oil_imdct32_f32                 (float *d_32,
                                             const float *s_32);
void        oil_imdct36_f64                 (double *d_36,
                                             const double *s_18);
void        oil_md5                         (uint32_t *i_4,
                                             const uint32_t *s_16);
void        oil_mdct12_f64                  (double *d_6,
                                             const double *s_12);
void        oil_mdct36_f64                  (double *d_18,
                                             const double *s_36);
void        oil_mix_u8                      (uint8_t *dest,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);
void        oil_mult8x8_s16                 (int16_t *d_8x8,
                                             const int16_t *s1_8x8,
                                             const int16_t *s2_8x8,
                                             int ds,
                                             int ss1,
                                             int ss2);
void        oil_multsum_f32                 (float *dest,
                                             const float *src1,
                                             int sstr1,
                                             const float *src2,
                                             int sstr2,
                                             int n);
void        oil_multsum_f64                 (double *dest,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n);
void        oil_null                        ();
void        oil_permute_f32                 (float *dest,
                                             int dstr,
                                             const float *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_permute_f64                 (double *dest,
                                             int dstr,
                                             const double *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_permute_s16                 (int16_t *dest,
                                             int dstr,
                                             const int16_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_permute_s32                 (int32_t *dest,
                                             int dstr,
                                             const int32_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_permute_s8                  (int8_t *dest,
                                             int dstr,
                                             const int8_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_permute_u16                 (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_permute_u32                 (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_permute_u8                  (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);
void        oil_rgb2bgr                     (uint8_t *d_3xn,
                                             const uint8_t *s_3xn,
                                             int n);
void        oil_rgb2rgba                    (uint8_t *d_4xn,
                                             const uint8_t *s_3xn,
                                             int n);
void        oil_sad8x8_f64                  (double *d_8x8,
                                             int ds,
                                             const double *s1_8x8,
                                             int ss1,
                                             const double *s2_8x8,
                                             int ss2);
void        oil_sad8x8_s16                  (uint32_t *d_8x8,
                                             int ds,
                                             const int16_t *s1_8x8,
                                             int ss1,
                                             const int16_t *s2_8x8,
                                             int ss2);
void        oil_scalaradd_f32               (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             const float *s2_1,
                                             int n);
void        oil_scalaradd_f64               (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             const double *s2_1,
                                             int n);
void        oil_scalaradd_s16               (int16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);
void        oil_scalaradd_s32               (int32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);
void        oil_scalaradd_s8                (int8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);
void        oil_scalaradd_u16               (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);
void        oil_scalaradd_u32               (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);
void        oil_scalaradd_u8                (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);
void        oil_scalarmult_f32              (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             const float *s2_1,
                                             int n);
void        oil_scalarmult_f64              (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             const double *s2_1,
                                             int n);
void        oil_scalarmult_s16              (int16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);
void        oil_scalarmult_s32              (int32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);
void        oil_scalarmult_s8               (int8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);
void        oil_scalarmult_u16              (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);
void        oil_scalarmult_u32              (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);
void        oil_scalarmult_u8               (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);
void        oil_scanlinescale2_u8           (uint8_t *dest,
                                             const uint8_t *src,
                                             int n);
void        oil_sincos_f64                  (double *dest1,
                                             double *dest2,
                                             int n,
                                             const double *s1_1,
                                             const double *s2_1);
void        oil_splat_u32                   (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *s1_1,
                                             int n);
void        oil_splat_u8                    (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *s1_1,
                                             int n);
void        oil_squaresum_f64               (double *dest,
                                             const double *src,
                                             int n);
void        oil_sum_f64                     (double *dest,
                                             const double *src,
                                             int sstr,
                                             int n);
void        oil_tablelookup_u8              (uint8_t *d,
                                             int ds,
                                             const uint8_t *s1,
                                             int ss1,
                                             const uint8_t *s2_256,
                                             int ss2,
                                             int n);
void        oil_trans8x8_f64                (double *d_8x8,
                                             int ds,
                                             const double *s_8x8,
                                             int ss);
void        oil_trans8x8_u16                (uint16_t *d_8x8,
                                             int ds,
                                             const uint16_t *s_8x8,
                                             int ss);
void        oil_trans8x8_u32                (uint32_t *d_8x8,
                                             int ds,
                                             const uint32_t *s_8x8,
                                             int ss);
void        oil_trans8x8_u8                 (uint8_t *d_8x8,
                                             int ds,
                                             const uint8_t *s_8x8,
                                             int ss);
void        oil_unzigzag8x8_s16             (int16_t *d_8x8,
                                             int ds,
                                             const int16_t *s_8x8,
                                             int ss);
void        oil_utf8_validate               (int32_t *d_1,
                                             const uint8_t *s,
                                             int n);
void        oil_vectoradd_f32               (float *dest,
                                             int dstr,
                                             const float *src1,
                                             int sstr1,
                                             const float *src2,
                                             int sstr2,
                                             int n,
                                             const float *s3_1,
                                             const float *s4_1);
void        oil_vectoradd_f64               (double *dest,
                                             int dstr,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n,
                                             const double *s3_1,
                                             const double *s4_1);
void        oil_vectoradd_s16               (int16_t *dest,
                                             int dstr,
                                             const int16_t *src1,
                                             int sstr1,
                                             const int16_t *src2,
                                             int sstr2,
                                             int n,
                                             const int16_t *s3_1,
                                             const int16_t *s4_1);
void        oil_vectoradd_s32               (int32_t *dest,
                                             int dstr,
                                             const int32_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n,
                                             const int32_t *s3_1,
                                             const int32_t *s4_1);
void        oil_vectoradd_s8                (int8_t *dest,
                                             int dstr,
                                             const int8_t *src1,
                                             int sstr1,
                                             const int8_t *src2,
                                             int sstr2,
                                             int n,
                                             const int8_t *s3_1,
                                             const int8_t *s4_1);
void        oil_vectoradd_u16               (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src1,
                                             int sstr1,
                                             const uint16_t *src2,
                                             int sstr2,
                                             int n,
                                             const uint16_t *s3_1,
                                             const uint16_t *s4_1);
void        oil_vectoradd_u32               (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src1,
                                             int sstr1,
                                             const uint32_t *src2,
                                             int sstr2,
                                             int n,
                                             const uint32_t *s3_1,
                                             const uint32_t *s4_1);
void        oil_vectoradd_u8                (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src1,
                                             int sstr1,
                                             const uint8_t *src2,
                                             int sstr2,
                                             int n,
                                             const uint8_t *s3_1,
                                             const uint8_t *s4_1);
void        oil_yuv2rgbx_sub2_u8            (uint8_t *d_4xn,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);
void        oil_yuv2rgbx_sub4_u8            (uint8_t *d_4xn,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);
void        oil_yuv2rgbx_u8                 (uint8_t *d_4xn,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);
void        oil_zigzag8x8_s16               (int16_t *d_8x8,
                                             int ds,
                                             const int16_t *s_8x8,
                                             int ss);

Description

Functions operate on arrays of data. The arrays can be either source arrays (input only), destination arrays (output only), or in-place arrays (both input and output).

The interpretation of a parameter can usually be determined from its name. Parameters for arrays are of the form d1_1xn, where the first character represents the direction (source, destination, or in-place), the second represents the index for that particular direction, and the characters after the underscore indicate the size of the array. In this case, "1xn" represents an array that is 1 by N. Note that the index and the size can both be omitted, giving a default of 1 for the index and 1xn for the size.

Parameters that represent strides are of the form "d1s". The interpretation is similar to above, except that the s indicates a stride parameter.

The exceptions to the above rule are "dest", "src", "dstr", "sstr", etc. These are aliases for "d1", "s1", "d1s", and "s1s", respectively. This form is deprecated and will be removed in the 0.4 series.

Two special parameters are "n" and "m", which determine the size of the arrays in other parameters.

Data arrays are laid out such that rows are separated by the number of bytes given by the corresponding stride. Elements in each row are contiguous. If there is no stride parameter corresponding to an array, the rows of the array are contiguous.

Details

oil_abs_f32_f32 ()

void        oil_abs_f32_f32                 (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n : Calculates the absolute value of each element.

oil_abs_f64_f64 ()

void        oil_abs_f64_f64                 (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n : Calculates the absolute value of each element.

oil_abs_u16_s16 ()

void        oil_abs_u16_s16                 (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n : Calculates the absolute value of each element.

oil_abs_u32_s32 ()

void        oil_abs_u32_s32                 (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n : Calculates the absolute value of each element.

oil_abs_u8_s8 ()

void        oil_abs_u8_s8                   (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n : Calculates the absolute value of each element.

oil_argb_paint_u8 ()

void        oil_argb_paint_u8               (uint8_t *i_4xn,
                                             const uint8_t *s1_4,
                                             const uint8_t *s2_n,
                                             int n);

i_4xn :
s1_4 :
s2_n :
n :

oil_average2_u8 ()

void        oil_average2_u8                 (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src1,
                                             int sstr1,
                                             const uint8_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n : Calculates the average of each element in the source arrays.

oil_ayuv2argb_u8 ()

void        oil_ayuv2argb_u8                (uint8_t *d_4xn,
                                             const uint8_t *s_4xn,
                                             int n);

d_4xn :
s_4xn :
n : Converts an array of AYUV pixels to ARGB.

oil_clip_f32 ()

void        oil_clip_f32                    (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n,
                                             const float *s2_1,
                                             const float *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :minumum
s3_1 :maximum Clips each element in the first source array.

oil_clip_f64 ()

void        oil_clip_f64                    (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n,
                                             const double *s2_1,
                                             const double *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :minumum
s3_1 :maximum Clips each element in the first source array.

oil_clip_s16 ()

void        oil_clip_s16                    (int16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n,
                                             const int16_t *s2_1,
                                             const int16_t *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :minumum
s3_1 :maximum Clips each element in the first source array.

oil_clip_s32 ()

void        oil_clip_s32                    (int32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n,
                                             const int32_t *s2_1,
                                             const int32_t *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :
s3_1 :

oil_clip_s8 ()

void        oil_clip_s8                     (int8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n,
                                             const int8_t *s2_1,
                                             const int8_t *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :
s3_1 :

oil_clip_u16 ()

void        oil_clip_u16                    (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n,
                                             const uint16_t *s2_1,
                                             const uint16_t *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :
s3_1 :

oil_clip_u32 ()

void        oil_clip_u32                    (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n,
                                             const uint32_t *s2_1,
                                             const uint32_t *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :
s3_1 :

oil_clip_u8 ()

void        oil_clip_u8                     (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n,
                                             const uint8_t *s2_1,
                                             const uint8_t *s3_1);

dest :
dstr :
src :
sstr :
n :
s2_1 :
s3_1 :

oil_clipconv8x8_u8_s16 ()

void        oil_clipconv8x8_u8_s16          (uint8_t *d_8x8,
                                             int dstr,
                                             const int16_t *s_8x8,
                                             int sstr);

d_8x8 :
dstr :
s_8x8 :
sstr :

oil_clipconv_s16_f32 ()

void        oil_clipconv_s16_f32            (int16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s16_f64 ()

void        oil_clipconv_s16_f64            (int16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s16_s32 ()

void        oil_clipconv_s16_s32            (int16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s16_u16 ()

void        oil_clipconv_s16_u16            (int16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s16_u32 ()

void        oil_clipconv_s16_u32            (int16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s32_f32 ()

void        oil_clipconv_s32_f32            (int32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s32_f64 ()

void        oil_clipconv_s32_f64            (int32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s32_u32 ()

void        oil_clipconv_s32_u32            (int32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s8_f32 ()

void        oil_clipconv_s8_f32             (int8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s8_f64 ()

void        oil_clipconv_s8_f64             (int8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s8_s16 ()

void        oil_clipconv_s8_s16             (int8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s8_s32 ()

void        oil_clipconv_s8_s32             (int8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s8_u16 ()

void        oil_clipconv_s8_u16             (int8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s8_u32 ()

void        oil_clipconv_s8_u32             (int8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_s8_u8 ()

void        oil_clipconv_s8_u8              (int8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u16_f32 ()

void        oil_clipconv_u16_f32            (uint16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u16_f64 ()

void        oil_clipconv_u16_f64            (uint16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u16_s16 ()

void        oil_clipconv_u16_s16            (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u16_s32 ()

void        oil_clipconv_u16_s32            (uint16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u16_u32 ()

void        oil_clipconv_u16_u32            (uint16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u32_f32 ()

void        oil_clipconv_u32_f32            (uint32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u32_f64 ()

void        oil_clipconv_u32_f64            (uint32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u32_s32 ()

void        oil_clipconv_u32_s32            (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u8_f32 ()

void        oil_clipconv_u8_f32             (uint8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u8_f64 ()

void        oil_clipconv_u8_f64             (uint8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u8_s16 ()

void        oil_clipconv_u8_s16             (uint8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u8_s32 ()

void        oil_clipconv_u8_s32             (uint8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u8_s8 ()

void        oil_clipconv_u8_s8              (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u8_u16 ()

void        oil_clipconv_u8_u16             (uint8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_clipconv_u8_u32 ()

void        oil_clipconv_u8_u32             (uint8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv8x8_f64_s16 ()

void        oil_conv8x8_f64_s16             (double *d_8x8,
                                             int dstr,
                                             const int16_t *s_8x8,
                                             int sstr);

d_8x8 :
dstr :
s_8x8 :
sstr :

oil_conv8x8_s16_f64 ()

void        oil_conv8x8_s16_f64             (int16_t *d_8x8,
                                             int dstr,
                                             const double *s_8x8,
                                             int sstr);

d_8x8 :
dstr :
s_8x8 :
sstr :

oil_conv_f32_f64 ()

void        oil_conv_f32_f64                (float *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f32_s16 ()

void        oil_conv_f32_s16                (float *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f32_s32 ()

void        oil_conv_f32_s32                (float *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f32_s8 ()

void        oil_conv_f32_s8                 (float *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f32_u16 ()

void        oil_conv_f32_u16                (float *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f32_u32 ()

void        oil_conv_f32_u32                (float *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f32_u8 ()

void        oil_conv_f32_u8                 (float *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f64_f32 ()

void        oil_conv_f64_f32                (double *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f64_s16 ()

void        oil_conv_f64_s16                (double *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f64_s32 ()

void        oil_conv_f64_s32                (double *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f64_s8 ()

void        oil_conv_f64_s8                 (double *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f64_u16 ()

void        oil_conv_f64_u16                (double *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f64_u32 ()

void        oil_conv_f64_u32                (double *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_f64_u8 ()

void        oil_conv_f64_u8                 (double *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s16_f32 ()

void        oil_conv_s16_f32                (int16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s16_f64 ()

void        oil_conv_s16_f64                (int16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s16_s32 ()

void        oil_conv_s16_s32                (int16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s16_s8 ()

void        oil_conv_s16_s8                 (int16_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s16_u16 ()

void        oil_conv_s16_u16                (int16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s16_u32 ()

void        oil_conv_s16_u32                (int16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s16_u8 ()

void        oil_conv_s16_u8                 (int16_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s32_f32 ()

void        oil_conv_s32_f32                (int32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s32_f64 ()

void        oil_conv_s32_f64                (int32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s32_s16 ()

void        oil_conv_s32_s16                (int32_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s32_s8 ()

void        oil_conv_s32_s8                 (int32_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s32_u16 ()

void        oil_conv_s32_u16                (int32_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s32_u32 ()

void        oil_conv_s32_u32                (int32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s32_u8 ()

void        oil_conv_s32_u8                 (int32_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s8_f32 ()

void        oil_conv_s8_f32                 (int8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s8_f64 ()

void        oil_conv_s8_f64                 (int8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s8_s16 ()

void        oil_conv_s8_s16                 (int8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s8_s32 ()

void        oil_conv_s8_s32                 (int8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s8_u16 ()

void        oil_conv_s8_u16                 (int8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s8_u32 ()

void        oil_conv_s8_u32                 (int8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_s8_u8 ()

void        oil_conv_s8_u8                  (int8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u16_f32 ()

void        oil_conv_u16_f32                (uint16_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u16_f64 ()

void        oil_conv_u16_f64                (uint16_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u16_s16 ()

void        oil_conv_u16_s16                (uint16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u16_s32 ()

void        oil_conv_u16_s32                (uint16_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u16_s8 ()

void        oil_conv_u16_s8                 (uint16_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u16_u32 ()

void        oil_conv_u16_u32                (uint16_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u16_u8 ()

void        oil_conv_u16_u8                 (uint16_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u32_f32 ()

void        oil_conv_u32_f32                (uint32_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u32_f64 ()

void        oil_conv_u32_f64                (uint32_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u32_s16 ()

void        oil_conv_u32_s16                (uint32_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u32_s32 ()

void        oil_conv_u32_s32                (uint32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u32_s8 ()

void        oil_conv_u32_s8                 (uint32_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u32_u16 ()

void        oil_conv_u32_u16                (uint32_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u32_u8 ()

void        oil_conv_u32_u8                 (uint32_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u8_f32 ()

void        oil_conv_u8_f32                 (uint8_t *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u8_f64 ()

void        oil_conv_u8_f64                 (uint8_t *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u8_s16 ()

void        oil_conv_u8_s16                 (uint8_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u8_s32 ()

void        oil_conv_u8_s32                 (uint8_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u8_s8 ()

void        oil_conv_u8_s8                  (uint8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u8_u16 ()

void        oil_conv_u8_u16                 (uint8_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_conv_u8_u32 ()

void        oil_conv_u8_u32                 (uint8_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             int n);

dest :
dstr :
src :
sstr :
n :

oil_copy_u8 ()

void        oil_copy_u8                     (uint8_t *dest,
                                             const uint8_t *src,
                                             int n);

dest :
src :
n :

oil_dct36_f32 ()

void        oil_dct36_f32                   (float *d_36,
                                             int dstr,
                                             const float *s_36,
                                             int sstr);

d_36 :
dstr :
s_36 :
sstr :

oil_dequantize8x8_s16 ()

void        oil_dequantize8x8_s16           (int16_t *d_8x8,
                                             int dstr,
                                             const int16_t *s1_8x8,
                                             int sstr1,
                                             const int16_t *s2_8x8,
                                             int sstr2);

d_8x8 :
dstr :
s1_8x8 :
sstr1 :
s2_8x8 :
sstr2 :

oil_diffsquaresum_f64 ()

void        oil_diffsquaresum_f64           (double *d_1,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n);

d_1 :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_fdct8_f64 ()

void        oil_fdct8_f64                   (double *d_8,
                                             const double *s_8,
                                             int dstr,
                                             int sstr);

d_8 :
s_8 :
dstr :
sstr :

oil_fdct8x8_f64 ()

void        oil_fdct8x8_f64                 (double *d_8x8,
                                             int dstr,
                                             const double *s_8x8,
                                             int sstr);

d_8x8 :
dstr :
s_8x8 :
sstr :

oil_fdct8x8s_s16 ()

void        oil_fdct8x8s_s16                (int16_t *d_8x8,
                                             int ds,
                                             const int16_t *s_8x8,
                                             int ss);

d_8x8 :
ds :
s_8x8 :
ss :

oil_idct8_f64 ()

void        oil_idct8_f64                   (double *d_8,
                                             int dstr,
                                             const double *s_8,
                                             int sstr);

d_8 :
dstr :
s_8 :
sstr :

oil_idct8x8_f64 ()

void        oil_idct8x8_f64                 (double *d_8x8,
                                             int dstr,
                                             const double *s_8x8,
                                             int sstr);

d_8x8 :
dstr :
s_8x8 :
sstr :

oil_idct8x8_s16 ()

void        oil_idct8x8_s16                 (int16_t *d_8x8,
                                             int dstr,
                                             const int16_t *s_8x8,
                                             int sstr);

d_8x8 :
dstr :
s_8x8 :
sstr :

oil_imdct12_f64 ()

void        oil_imdct12_f64                 (double *d_12,
                                             const double *s_6);

d_12 :
s_6 :

oil_imdct32_f32 ()

void        oil_imdct32_f32                 (float *d_32,
                                             const float *s_32);

d_32 :
s_32 :

oil_imdct36_f64 ()

void        oil_imdct36_f64                 (double *d_36,
                                             const double *s_18);

d_36 :
s_18 :

oil_md5 ()

void        oil_md5                         (uint32_t *i_4,
                                             const uint32_t *s_16);

i_4 :
s_16 :

oil_mdct12_f64 ()

void        oil_mdct12_f64                  (double *d_6,
                                             const double *s_12);

d_6 :
s_12 :

oil_mdct36_f64 ()

void        oil_mdct36_f64                  (double *d_18,
                                             const double *s_36);

d_18 :
s_36 :

oil_mix_u8 ()

void        oil_mix_u8                      (uint8_t *dest,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);

dest :
src1 :
src2 :
src3 :
n :

oil_mult8x8_s16 ()

void        oil_mult8x8_s16                 (int16_t *d_8x8,
                                             const int16_t *s1_8x8,
                                             const int16_t *s2_8x8,
                                             int ds,
                                             int ss1,
                                             int ss2);

d_8x8 :
s1_8x8 :
s2_8x8 :
ds :
ss1 :
ss2 :

oil_multsum_f32 ()

void        oil_multsum_f32                 (float *dest,
                                             const float *src1,
                                             int sstr1,
                                             const float *src2,
                                             int sstr2,
                                             int n);

dest :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_multsum_f64 ()

void        oil_multsum_f64                 (double *dest,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n);

dest :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_null ()

void        oil_null                        ();


oil_permute_f32 ()

void        oil_permute_f32                 (float *dest,
                                             int dstr,
                                             const float *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_permute_f64 ()

void        oil_permute_f64                 (double *dest,
                                             int dstr,
                                             const double *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_permute_s16 ()

void        oil_permute_s16                 (int16_t *dest,
                                             int dstr,
                                             const int16_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_permute_s32 ()

void        oil_permute_s32                 (int32_t *dest,
                                             int dstr,
                                             const int32_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_permute_s8 ()

void        oil_permute_s8                  (int8_t *dest,
                                             int dstr,
                                             const int8_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_permute_u16 ()

void        oil_permute_u16                 (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_permute_u32 ()

void        oil_permute_u32                 (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_permute_u8 ()

void        oil_permute_u8                  (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :

oil_rgb2bgr ()

void        oil_rgb2bgr                     (uint8_t *d_3xn,
                                             const uint8_t *s_3xn,
                                             int n);

d_3xn :
s_3xn :
n :

oil_rgb2rgba ()

void        oil_rgb2rgba                    (uint8_t *d_4xn,
                                             const uint8_t *s_3xn,
                                             int n);

d_4xn :
s_3xn :
n :

oil_sad8x8_f64 ()

void        oil_sad8x8_f64                  (double *d_8x8,
                                             int ds,
                                             const double *s1_8x8,
                                             int ss1,
                                             const double *s2_8x8,
                                             int ss2);

d_8x8 :
ds :
s1_8x8 :
ss1 :
s2_8x8 :
ss2 :

oil_sad8x8_s16 ()

void        oil_sad8x8_s16                  (uint32_t *d_8x8,
                                             int ds,
                                             const int16_t *s1_8x8,
                                             int ss1,
                                             const int16_t *s2_8x8,
                                             int ss2);

d_8x8 :
ds :
s1_8x8 :
ss1 :
s2_8x8 :
ss2 :

oil_scalaradd_f32 ()

void        oil_scalaradd_f32               (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             const float *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalaradd_f64 ()

void        oil_scalaradd_f64               (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             const double *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalaradd_s16 ()

void        oil_scalaradd_s16               (int16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalaradd_s32 ()

void        oil_scalaradd_s32               (int32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalaradd_s8 ()

void        oil_scalaradd_s8                (int8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalaradd_u16 ()

void        oil_scalaradd_u16               (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalaradd_u32 ()

void        oil_scalaradd_u32               (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalaradd_u8 ()

void        oil_scalaradd_u8                (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_f32 ()

void        oil_scalarmult_f32              (float *dest,
                                             int dstr,
                                             const float *src,
                                             int sstr,
                                             const float *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_f64 ()

void        oil_scalarmult_f64              (double *dest,
                                             int dstr,
                                             const double *src,
                                             int sstr,
                                             const double *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_s16 ()

void        oil_scalarmult_s16              (int16_t *dest,
                                             int dstr,
                                             const int16_t *src,
                                             int sstr,
                                             const int16_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_s32 ()

void        oil_scalarmult_s32              (int32_t *dest,
                                             int dstr,
                                             const int32_t *src,
                                             int sstr,
                                             const int32_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_s8 ()

void        oil_scalarmult_s8               (int8_t *dest,
                                             int dstr,
                                             const int8_t *src,
                                             int sstr,
                                             const int8_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_u16 ()

void        oil_scalarmult_u16              (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src,
                                             int sstr,
                                             const uint16_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_u32 ()

void        oil_scalarmult_u32              (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src,
                                             int sstr,
                                             const uint32_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scalarmult_u8 ()

void        oil_scalarmult_u8               (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src,
                                             int sstr,
                                             const uint8_t *s2_1,
                                             int n);

dest :
dstr :
src :
sstr :
s2_1 :
n :

oil_scanlinescale2_u8 ()

void        oil_scanlinescale2_u8           (uint8_t *dest,
                                             const uint8_t *src,
                                             int n);

dest :
src :
n :

oil_sincos_f64 ()

void        oil_sincos_f64                  (double *dest1,
                                             double *dest2,
                                             int n,
                                             const double *s1_1,
                                             const double *s2_1);

dest1 :
dest2 :
n :
s1_1 :
s2_1 :

oil_splat_u32 ()

void        oil_splat_u32                   (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *s1_1,
                                             int n);

dest :
dstr :
s1_1 :
n :

oil_splat_u8 ()

void        oil_splat_u8                    (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *s1_1,
                                             int n);

dest :
dstr :
s1_1 :
n :

oil_squaresum_f64 ()

void        oil_squaresum_f64               (double *dest,
                                             const double *src,
                                             int n);

dest :
src :
n :

oil_sum_f64 ()

void        oil_sum_f64                     (double *dest,
                                             const double *src,
                                             int sstr,
                                             int n);

dest :
src :
sstr :
n :

oil_tablelookup_u8 ()

void        oil_tablelookup_u8              (uint8_t *d,
                                             int ds,
                                             const uint8_t *s1,
                                             int ss1,
                                             const uint8_t *s2_256,
                                             int ss2,
                                             int n);

d :
ds :
s1 :
ss1 :
s2_256 :
ss2 :
n :

oil_trans8x8_f64 ()

void        oil_trans8x8_f64                (double *d_8x8,
                                             int ds,
                                             const double *s_8x8,
                                             int ss);

d_8x8 :
ds :
s_8x8 :
ss :

oil_trans8x8_u16 ()

void        oil_trans8x8_u16                (uint16_t *d_8x8,
                                             int ds,
                                             const uint16_t *s_8x8,
                                             int ss);

d_8x8 :
ds :
s_8x8 :
ss :

oil_trans8x8_u32 ()

void        oil_trans8x8_u32                (uint32_t *d_8x8,
                                             int ds,
                                             const uint32_t *s_8x8,
                                             int ss);

d_8x8 :
ds :
s_8x8 :
ss :

oil_trans8x8_u8 ()

void        oil_trans8x8_u8                 (uint8_t *d_8x8,
                                             int ds,
                                             const uint8_t *s_8x8,
                                             int ss);

d_8x8 :
ds :
s_8x8 :
ss :

oil_unzigzag8x8_s16 ()

void        oil_unzigzag8x8_s16             (int16_t *d_8x8,
                                             int ds,
                                             const int16_t *s_8x8,
                                             int ss);

d_8x8 :
ds :
s_8x8 :
ss :

oil_utf8_validate ()

void        oil_utf8_validate               (int32_t *d_1,
                                             const uint8_t *s,
                                             int n);

d_1 :
s :
n :

oil_vectoradd_f32 ()

void        oil_vectoradd_f32               (float *dest,
                                             int dstr,
                                             const float *src1,
                                             int sstr1,
                                             const float *src2,
                                             int sstr2,
                                             int n,
                                             const float *s3_1,
                                             const float *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_f64 ()

void        oil_vectoradd_f64               (double *dest,
                                             int dstr,
                                             const double *src1,
                                             int sstr1,
                                             const double *src2,
                                             int sstr2,
                                             int n,
                                             const double *s3_1,
                                             const double *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_s16 ()

void        oil_vectoradd_s16               (int16_t *dest,
                                             int dstr,
                                             const int16_t *src1,
                                             int sstr1,
                                             const int16_t *src2,
                                             int sstr2,
                                             int n,
                                             const int16_t *s3_1,
                                             const int16_t *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_s32 ()

void        oil_vectoradd_s32               (int32_t *dest,
                                             int dstr,
                                             const int32_t *src1,
                                             int sstr1,
                                             const int32_t *src2,
                                             int sstr2,
                                             int n,
                                             const int32_t *s3_1,
                                             const int32_t *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_s8 ()

void        oil_vectoradd_s8                (int8_t *dest,
                                             int dstr,
                                             const int8_t *src1,
                                             int sstr1,
                                             const int8_t *src2,
                                             int sstr2,
                                             int n,
                                             const int8_t *s3_1,
                                             const int8_t *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_u16 ()

void        oil_vectoradd_u16               (uint16_t *dest,
                                             int dstr,
                                             const uint16_t *src1,
                                             int sstr1,
                                             const uint16_t *src2,
                                             int sstr2,
                                             int n,
                                             const uint16_t *s3_1,
                                             const uint16_t *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_u32 ()

void        oil_vectoradd_u32               (uint32_t *dest,
                                             int dstr,
                                             const uint32_t *src1,
                                             int sstr1,
                                             const uint32_t *src2,
                                             int sstr2,
                                             int n,
                                             const uint32_t *s3_1,
                                             const uint32_t *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_vectoradd_u8 ()

void        oil_vectoradd_u8                (uint8_t *dest,
                                             int dstr,
                                             const uint8_t *src1,
                                             int sstr1,
                                             const uint8_t *src2,
                                             int sstr2,
                                             int n,
                                             const uint8_t *s3_1,
                                             const uint8_t *s4_1);

dest :
dstr :
src1 :
sstr1 :
src2 :
sstr2 :
n :
s3_1 :
s4_1 :

oil_yuv2rgbx_sub2_u8 ()

void        oil_yuv2rgbx_sub2_u8            (uint8_t *d_4xn,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);

d_4xn :
src1 :
src2 :
src3 :
n :

oil_yuv2rgbx_sub4_u8 ()

void        oil_yuv2rgbx_sub4_u8            (uint8_t *d_4xn,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);

d_4xn :
src1 :
src2 :
src3 :
n :

oil_yuv2rgbx_u8 ()

void        oil_yuv2rgbx_u8                 (uint8_t *d_4xn,
                                             const uint8_t *src1,
                                             const uint8_t *src2,
                                             const uint8_t *src3,
                                             int n);

d_4xn :
src1 :
src2 :
src3 :
n :

oil_zigzag8x8_s16 ()

void        oil_zigzag8x8_s16               (int16_t *d_8x8,
                                             int ds,
                                             const int16_t *s_8x8,
                                             int ss);

d_8x8 :
ds :
s_8x8 :
ss :