/usr/include/imdi_gen.h is in libimdi-dev 1.5.1-5ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 | #ifndef IMDI_GEN_H
#define IMDI_GEN_H
/* Integer Multi-Dimensional Interpolation */
/*
* Copyright 2000 - 2007 Graeme W. Gill
* All rights reserved.
*
* This material is licenced under the GNU AFFERO GENERAL PUBLIC LICENSE Version 3 :-
* see the License.txt file for licencing details.
*/
/*
* Pixel code generation definitions.
*
* This defines a particular combination of pixel layout,
* number of channels, and other runtime requestable features.
* This is used by the code generation to setup anticipated
* support for these requests, used by the runtime to request
* the features, and by the runtime to identify the correct
* generated module to use.
*
*/
/* -------------------------------------------------- */
/* High level kernel generation description */
/* This is a high level macro desciption of the pixel layout. */
/* It can be expanded by adding a new enumeration, and then */
/* implementing the code in imdi_gen to translate the enumeration */
/* into the exact pixlayout structure details. */
typedef enum {
invalid_rep = 0x00,
pixint8 = 0x01, /* 8 Bits per value, pixel interleaved, no padding */
planeint8 = 0x02, /* 8 bits per value, plane interleaved */
pixint16 = 0x03, /* 16 Bits per value, pixel interleaved, no padding */
planeint16 = 0x04 /* 16 bits per value, plane interleaved */
} imdi_pixrep;
/* The internal processing precision */
typedef enum {
prec_min = 0, /* Minimum of input and output precision */
prec_max = 1, /* Maximum of input and output precision */
prec_in = 2, /* Same as input */
prec_out = 3, /* Same as output */
prec_p8 = 4, /* 8 Bits precision */
prec_p16 = 5 /* 16 Bits precision */
} imdi_iprec;
/* Output per channel processing options. For the compiled */
/* kernels, this is indexed by physical output channel, */
/* (not to be confused with the runtime oopt which is indexed */
/* by callback channel). */
/* - shift left by channel no * 2 to access option. */
/* Note that oopts_skip valid only for plane interleaved, */
/* and doesn't change the number output channels looked up, */
/* it changes the number of output channels written, hence */
/* must be matched by the arguments to interp() (number of */
/* output pointers, stride etc.) */
typedef enum {
oopts_none = 0x0, /* No extra options */
oopts_check = 0x1, /* Test channel value against trigger */
oopts_skip = 0x2, /* Don't write channel value */
oopts_chskp = 0x3 /* oopts_check + oopts_skip */
} imdi_ooptions;
/* Macro to create an instance of imdi_ooptions for a particular channel */
#define OOPT(flag,chan) ((flag) << (chan * 2))
/* Macro to extract the flags particular channel */
#define OOPTX(val,chan) (0x3 & ((val) >> (chan * 2)))
/* Value of no oopt flags set */
#define OOPTS_NONE 0x00000000
/* Mask to detect any oopts_check flags that are set */
#define OOPTS_CHECK 0x55555555
/* Mask to ignore any oopts_check flags that are set */
#define OOPTS_NOT_CHECK 0xAAAAAAAA
/* Mask to detect any oopts_skip flags that are set */
#define OOPTS_SKIP 0xAAAAAAAA
/* Mask to ignore any oopts_skip flags that are set */
#define OOPTS_NOT_SKIP 0x55555555
/* Processing options */
/* Note that there will be a choice between simplex lookup or sort algoritm for */
/* only a subset of kernels (8 bits processing precision, <= 4 input channels) */
typedef enum {
opts_none = 0x00, /* Forward direction, no stride */
opts_fwd = 0x01, /* Forwards direction (default is gen fwd/run don't care) */
opts_bwd = 0x02, /* Backwards direction (default is gen fwd/run don't care) */
opts_istride = 0x04, /* Stride on input */
opts_ostride = 0x08, /* Stride on output */
opts_splx_sort = 0x10, /* Prefer simplex over sort algorithm (generate both) */
opts_sort_splx = 0x20, /* Force sort algorithm, rather than simplex table (generate both) */
opts_splx = 0x40, /* Generate simplex only (when possible), default is sort only. */
opts_end = 0x80 /* End marker */
} imdi_options;
/* This sructure allows a series of related kernels to be generated */
#define MX_GDCS 20
/* * means multiplies combination */
/* + means lockstep with previous line */
typedef struct {
int idcombs[MX_GDCS]; /* * Input dimension combinations (0 at end) */
int itres[MX_GDCS]; /* + Interpolation table resolutions for */
int stres[MX_GDCS]; /* + Simplex table resolutions */
int odcombs[MX_GDCS]; /* * Output dimensions combinations (0 at end) */
imdi_ooptions ooptcombs[MX_GDCS]; /* + output per channel options */
imdi_pixrep incombs[MX_GDCS]; /* * Input pixel representation */
imdi_iprec iprecs[MX_GDCS]; /* + Internal precision */
imdi_pixrep outcombs[MX_GDCS]; /* + Output pixel representation */
imdi_options optcombs[MX_GDCS]; /* * Direction and stride options */
} gendesc;
/* -------------------------------------------------- */
/* Detailed level of generation specification */
/* Pixel layout: */
/* Each channel value is assumed to be read with a */
/* native machine single read of size bpch, */
/* and bov and bpv being bit indexes into that value. */
/* */
/* If pint == 0, then each read will be of size bpch[], and will */
/* have its own pointer, will be incremented by chi[]. */
/* If pint != 0, then the reads will be size bpch[0], from successive */
/* locations, chi[] apart. */
/* */
/* If packed == 0, then separate reads are needed for each input */
/* channel. */
/* If packed != 0, then the channel values will be extracted */
/* from a single read of size bpch[0] */
/* */
/* Note that at all times the bit offset and size values */
/* will be obeyed for each input value. */
/* NOTE :- if you change this, you need to change the code in cgen.c */
/* labeled !genspec and tabspec delta code! */
typedef struct {
int bpch[IXDIDO]; /* Bits per channel read (must be divisible by 8) */
int chi[IXDIDO]; /* channel increment in multiples of bpch[] (0 == dimensionality) */
int bov[IXDIDO]; /* Bit offset to value within channel */
int bpv[IXDIDO]; /* Bits per value within channel */
int pint; /* Flag - nonz if pixel interleaved (ie. reads from successice locations) */
int packed; /* Flag - nonz if all channels are packed into a single read */
} pixlayout;
/* Structure that specifies the configuration of a generated interpolation kernel. */
/* NOTE :- if you change this, you need to change the code in cgen.c */
/* labeled !genspec and tabspec delta code! */
typedef struct {
/* Input to code generator */
int prec; /* Internal precision:- either 8 or 16 bits */
int id; /* Number of input dimensions used for interpolation */
int od; /* Number of output dimensions created by interpolation */
imdi_pixrep irep; /* High level input pixel representation */
imdi_pixrep orep; /* High level output pixel representation */
int in_signed; /* Bit flag per channel, NZ if treat as signed (runtime setup) */
int out_signed; /* Bit flag per channel, NZ if treat as signed (runtime setup) */
pixlayout in; /* Input pixel layout */
pixlayout out; /* Output pixel layout */
imdi_ooptions oopt; /* output per channel options */
imdi_options opt; /* Direction and stride options */
int itres; /* Interpolation table resolution */
int stres; /* Simplex table resolution */
/* Returned value */
char kkeys[100]; /* Kernel keys */
char kdesc[100]; /* At genspec time */
char kname[100]; /* At generation time */
} genspec;
/* - - - - - - - - - - - - - - - - - - - - - - - */
/* Translate between high level and low level generation specification */
int set_genspec(genspec *gs, gendesc *gd, int comb, mach_arch *a);
/* - - - - - - - - - - - - - - - - - - - - - - - */
/* Convert the input and output pixel representation and the internal */
/* precision choice into a precision in bits */
/* (Used at code gen and code execution, hence defined as a macro) */
#define COMPUTE_IPREC(PRECOUT, INREP, IPREC, OUTREP) \
{ \
int _iprec, _oprec; \
\
switch (INREP) { \
default: \
case pixint8: \
case planeint8: \
_iprec = 8; \
break; \
case pixint16: \
case planeint16: \
_iprec = 16; \
break; \
} \
switch (OUTREP) { \
default: \
case pixint8: \
case planeint8: \
_oprec = 8; \
break; \
case pixint16: \
case planeint16: \
_oprec = 16; \
break; \
} \
switch (IPREC) { \
default: \
case prec_min: \
PRECOUT = _iprec < _oprec ? _iprec : _oprec; \
break; \
case prec_max: \
PRECOUT = _iprec > _oprec ? _iprec : _oprec; \
break; \
case prec_in: \
PRECOUT = _iprec; \
break; \
case prec_out: \
PRECOUT = _oprec; \
break; \
case prec_p8: \
PRECOUT = 8; \
break; \
case prec_p16: \
PRECOUT = 16; \
break; \
} \
} \
/* - - - - - - - - - - - - - - - - - - - - - - - */
struct _tabspec;
/* Supported code generators: */
/* The 'C' code generator */
/* Generate a source file to implement the specified */
/* interpolation kernel. Fill in return values and return 0 if OK. */
/* Return 1 if this kernel should be skipped (ie. force sort and sort not forced) */
/* and some other anon-zero on error. */
int gen_c_kernel(genspec *g, struct _tabspec *t, mach_arch *a,
FILE *fp, int index, genspec *og, struct _tabspec *ot);
/* asm, MMX, etc. generators declarations go here ! */
#endif /* IMDI_GEN_H */
|