00001
00002 #include <config.h>
00003 #include <stdlib.h>
00004
00005
00006 #include <jutils.h>
00007 #include <blitter.h>
00008
00009 #include <SDL_imageFilter.h>
00010
00011
00012
00013
00014 BLIT blit_xor(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00015 register int c;
00016 register uint32_t *s = (uint32_t*)src;
00017 register uint32_t *d = (uint32_t*)dst;
00018
00019 for(c=bytes>>2;c>0;c--,s++,d++)
00020 *d ^= *s;
00021 }
00022
00023
00024 BLIT rgb_jmemcpy(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00025 jmemcpy(dst,src,bytes);
00026 }
00027
00028 BLIT red_channel(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00029 register int c;
00030 register uint8_t *s = (uint8_t*)src;
00031 register uint8_t *d = (uint8_t*)dst;
00032 for(c=bytes>>2;c>0;c--,s+=4,d+=4)
00033 *(d+rchan) = *(s+rchan);
00034 }
00035
00036 BLIT green_channel(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00037 register int c;
00038 register uint8_t *s = (uint8_t*)src;
00039 register uint8_t *d = (uint8_t*)dst;
00040 for(c=bytes>>2;c>0;c--,s+=4,d+=4)
00041 *(d+gchan) = *(s+gchan);
00042 }
00043
00044 BLIT blue_channel(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00045 register int c;
00046 register uint8_t *s = (uint8_t*)src;
00047 register uint8_t *d = (uint8_t*)dst;
00048 for(c=bytes>>2;c>0;c--,s+=4,d+=4)
00049 *(d+bchan) = *(s+bchan);
00050 }
00051
00052 BLIT red_mask(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00053 register int c;
00054 register uint32_t *s = (uint32_t*)src;
00055 register uint32_t *d = (uint32_t*)dst;
00056
00057 for(c=bytes>>2;c>0;c--,s++,d++)
00058 *d |= *s & red_bitmask;
00059
00060 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00061
00062 SDL_imageFilterBinarizeUsingThreshold
00063 ((unsigned char*)dst,(unsigned char*)dst,bytes, v);
00064 }
00065
00066 BLIT green_mask(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00067 register int c;
00068 register uint32_t *s = (uint32_t*)src;
00069 register uint32_t *d = (uint32_t*)dst;
00070
00071 for(c=bytes>>2;c>0;c--,s++,d++)
00072 *d |= *s & green_bitmask;
00073
00074 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00075
00076 SDL_imageFilterBinarizeUsingThreshold
00077 ((unsigned char*)dst,(unsigned char*)dst,bytes, v);
00078 }
00079
00080 BLIT blue_mask(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00081 register int c;
00082 register uint32_t *s = (uint32_t*)src;
00083 register uint32_t *d = (uint32_t*)dst;
00084
00085 for(c=bytes>>2;c>0;c--,s++,d++)
00086 *d |= *s & blue_bitmask;
00087
00088 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00089
00090 SDL_imageFilterBinarizeUsingThreshold
00091 ((unsigned char*)dst,(unsigned char*)dst,bytes,v);
00092 }
00093
00094
00095 BLIT schiffler_add(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00096 SDL_imageFilterAdd((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00097 }
00098
00099 BLIT schiffler_sub(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00100 SDL_imageFilterSub((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00101 }
00102
00103 BLIT schiffler_mean(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00104 SDL_imageFilterMean((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00105 }
00106
00107 BLIT schiffler_absdiff(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00108 SDL_imageFilterAbsDiff((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00109 }
00110
00111 BLIT schiffler_mult(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00112 SDL_imageFilterMult((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00113 }
00114
00115 BLIT schiffler_multnor(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00116 SDL_imageFilterMultNor((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00117 }
00118
00119 BLIT schiffler_div(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00120 SDL_imageFilterDiv((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00121 }
00122
00123 BLIT schiffler_multdiv2(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00124 SDL_imageFilterMultDivby2((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00125 }
00126
00127 BLIT schiffler_multdiv4(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00128 SDL_imageFilterMultDivby2((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00129 }
00130
00131 BLIT schiffler_and(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00132 SDL_imageFilterBitAnd((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00133 }
00134
00135 BLIT schiffler_or(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00136 SDL_imageFilterBitOr((unsigned char*)src,(unsigned char*)dst,(unsigned char*)dst,bytes);
00137 }
00138
00139
00140
00141
00142
00144
00145 BLIT schiffler_neg(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00146 SDL_imageFilterBitNegation((unsigned char*)src,(unsigned char*)dst,bytes);
00147 }
00148
00149 BLIT schiffler_addbyte(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00150 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00151
00152 SDL_imageFilterAddByte((unsigned char*)src,(unsigned char*)dst,bytes, v);
00153 }
00154
00155 BLIT schiffler_addbytetohalf(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00156 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00157
00158 SDL_imageFilterAddByteToHalf((unsigned char*)src,(unsigned char*)dst,bytes, v);
00159 }
00160
00161 BLIT schiffler_subbyte(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00162 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00163
00164 SDL_imageFilterSubByte((unsigned char*)src,(unsigned char*)dst,bytes, v);
00165 }
00166
00167 BLIT schiffler_shl(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00168 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00169
00170 SDL_imageFilterShiftLeft((unsigned char*)src,(unsigned char*)dst,bytes, v);
00171 }
00172
00173 BLIT schiffler_shlb(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00174 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00175
00176 SDL_imageFilterShiftLeftByte((unsigned char*)src,(unsigned char*)dst,bytes,v);
00177 }
00178
00179 BLIT schiffler_shr(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00180 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00181
00182 SDL_imageFilterShiftRight((unsigned char*)src,(unsigned char*)dst,bytes,v);
00183 }
00184
00185 BLIT schiffler_mulbyte(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00186 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00187
00188 SDL_imageFilterMultByByte((unsigned char*)src,(unsigned char*)dst,bytes,v);
00189 }
00190
00191 BLIT schiffler_binarize(void *src, void *dst, int bytes, Linklist<Parameter> *params) {
00192 unsigned char v = (unsigned int) *(float*)(params->begin()->value);
00193 SDL_imageFilterBinarizeUsingThreshold
00194 ((unsigned char*)src,(unsigned char*)dst,bytes, v);
00195 }
00196
00197
00198
00199
00200 void setup_linear_blits(Blitter *blitter) {
00201 Blit *b;
00202 Parameter *p;
00203
00204 b = new Blit(); b->set_name("RGB");
00205 sprintf(b->desc, "RGB blit (jmemcpy)");
00206 b->type = Blit::LINEAR;
00207 b->fun = rgb_jmemcpy; blitter->blitlist.prepend(b);
00208
00209 blitter->default_blit = b;
00210
00211 b = new Blit(); b->set_name("ADD");
00212 sprintf(b->desc,"bytewise addition");
00213 b->type = Blit::LINEAR;
00214 b->fun = schiffler_add; blitter->blitlist.prepend(b);
00215
00216 b = new Blit(); b->set_name("SUB");
00217 sprintf(b->desc,"bytewise subtraction");
00218 b->type = Blit::LINEAR;
00219 b->fun = schiffler_sub; blitter->blitlist.prepend(b);
00220
00221 b = new Blit(); b->set_name("MEAN");
00222 sprintf(b->desc,"bytewise mean");
00223 b->type = Blit::LINEAR;
00224 b->fun = schiffler_add; blitter->blitlist.prepend(b);
00225
00226 b = new Blit(); b->set_name("ABSDIFF");
00227 sprintf(b->desc,"absolute difference");
00228 b->type = Blit::LINEAR;
00229 b->fun = schiffler_absdiff; blitter->blitlist.prepend(b);
00230
00231 b = new Blit(); b->set_name("MULT");
00232 sprintf(b->desc,"multiplication");
00233 b->type = Blit::LINEAR;
00234 b->fun = schiffler_mult; blitter->blitlist.prepend(b);
00235
00236 b = new Blit(); b->set_name("MULTNOR");
00237 sprintf(b->desc,"normalized multiplication");
00238 b->type = Blit::LINEAR;
00239 b->fun = schiffler_multnor; blitter->blitlist.prepend(b);
00240
00241 b = new Blit(); b->set_name("DIV");
00242 sprintf(b->desc,"division");
00243 b->type = Blit::LINEAR;
00244 b->fun = schiffler_div; blitter->blitlist.prepend(b);
00245
00246 b = new Blit(); b->set_name("MULTDIV2");
00247 sprintf(b->desc,"multiplication and division by 2");
00248 b->type = Blit::LINEAR;
00249 b->fun = schiffler_multdiv2; blitter->blitlist.prepend(b);
00250
00251 b = new Blit(); b->set_name("MULTDIV4");
00252 sprintf(b->desc,"multiplication and division by 4");
00253 b->type = Blit::LINEAR;
00254 b->fun = schiffler_multdiv4; blitter->blitlist.prepend(b);
00255
00256 b = new Blit(); b->set_name("AND");
00257 sprintf(b->desc,"bitwise and");
00258 b->type = Blit::LINEAR;
00259 b->fun = schiffler_and; blitter->blitlist.prepend(b);
00260
00261 b = new Blit(); b->set_name("OR");
00262 sprintf(b->desc,"bitwise or");
00263 b->type = Blit::LINEAR;
00264 b->fun = schiffler_or; blitter->blitlist.prepend(b);
00265
00266 b = new Blit(); b->set_name("XOR");
00267 sprintf(b->desc,"bitwise xor");
00268 b->type = Blit::LINEAR;
00269 b->fun = blit_xor; blitter->blitlist.prepend(b);
00270
00271 b = new Blit(); b->set_name("RED");
00272 sprintf(b->desc,"red channel only blit");
00273 b->type = Blit::LINEAR;
00274 b->fun = red_channel; blitter->blitlist.prepend(b);
00275
00276 b = new Blit(); b->set_name("GREEN");
00277 sprintf(b->desc,"green channel only blit");
00278 b->type = Blit::LINEAR;
00279 b->fun = green_channel; blitter->blitlist.prepend(b);
00280
00281 b = new Blit(); b->set_name("BLUE");
00282 sprintf(b->desc,"blue channel only blit");
00283 b->type = Blit::LINEAR;
00284 b->fun = blue_channel; blitter->blitlist.prepend(b);
00285
00286 b = new Blit(); b->set_name("REDMASK");
00287 sprintf(b->desc,"red channel threshold mask");
00288 b->type = Blit::LINEAR;
00289 b->fun = red_mask; blitter->blitlist.prepend(b);
00290
00291 p = new Parameter(Parameter::NUMBER);
00292 strcpy(p->name, "bit threshold");
00293 strcpy(p->description, "bitmask threshold to apply to the red channel");
00294 p->multiplier = 255.0;
00295 b->parameters.append(p);
00296
00298
00299 b = new Blit(); b->set_name("GREENMASK");
00300 sprintf(b->desc,"green channel threshold mask");
00301 b->type = Blit::LINEAR;
00302 b->fun = green_mask; blitter->blitlist.prepend(b);
00303
00304 p = new Parameter(Parameter::NUMBER);
00305 strcpy(p->name, "bit threshold");
00306 strcpy(p->description, "bitmask threshold to apply to the green channel");
00307 p->multiplier = 255.0;
00308 b->parameters.append(p);
00309
00311
00312 b = new Blit(); b->set_name("BLUEMASK");
00313 sprintf(b->desc,"blue channel threshold mask");
00314 b->type = Blit::LINEAR;
00315 b->fun = blue_mask; blitter->blitlist.prepend(b);
00316
00317 p = new Parameter(Parameter::NUMBER);
00318 strcpy(p->name, "bit threshold");
00319 strcpy(p->description, "bitmask threshold to apply to the blue channel");
00320 p->multiplier = 255.0;
00321 b->parameters.append(p);
00322
00324
00325 b = new Blit(); b->set_name("NEG");
00326 sprintf(b->desc,"bitwise negation");
00327 b->type = Blit::LINEAR;
00328 b->fun = schiffler_neg; blitter->blitlist.prepend(b);
00329
00331
00332 b = new Blit(); b->set_name("ADDB");
00333 sprintf(b->desc,"add byte to bytes");
00334 b->type = Blit::LINEAR;
00335 b->fun = schiffler_addbyte; blitter->blitlist.prepend(b);
00336
00337 p = new Parameter(Parameter::NUMBER);
00338 strcpy(p->name, "byte increment");
00339 strcpy(p->description, "amount to sum to the byte");
00340 p->multiplier = 255.0;
00341 b->parameters.append(p);
00342
00344
00345 b = new Blit(); b->set_name("ADDBH");
00346 sprintf(b->desc,"add byte to half");
00347 b->type = Blit::LINEAR;
00348 b->fun = schiffler_addbytetohalf; blitter->blitlist.prepend(b);
00349
00350 p = new Parameter(Parameter::NUMBER);
00351 strcpy(p->name, "half byte increment");
00352 strcpy(p->description, "amount to sum to the half byte");
00353 p->multiplier = 127.0;
00354 b->parameters.append(p);
00355
00357
00358 b = new Blit(); b->set_name("SUBB");
00359 sprintf(b->desc,"subtract byte to bytes");
00360 b->type = Blit::LINEAR;
00361 b->fun = schiffler_subbyte; blitter->blitlist.prepend(b);
00362
00363 p = new Parameter(Parameter::NUMBER);
00364 strcpy(p->name, "byte decrement");
00365 strcpy(p->description, "amount to substract to the pixel bytes");
00366 p->multiplier = 255.0;
00367 b->parameters.append(p);
00368
00370
00371 b = new Blit(); b->set_name("SHL");
00372 sprintf(b->desc,"shift left bits");
00373 b->type = Blit::LINEAR;
00374 b->fun = schiffler_shl; blitter->blitlist.prepend(b);
00375
00376 p = new Parameter(Parameter::NUMBER);
00377 strcpy(p->name, "byte decrement");
00378 strcpy(p->description, "amount to substract to the pixel bytes");
00379 p->multiplier = 255.0;
00380 b->parameters.append(p);
00381
00383
00384 b = new Blit(); b->set_name("SHLB");
00385 sprintf(b->desc,"shift left byte");
00386 b->type = Blit::LINEAR;
00387 b->fun = schiffler_shlb; blitter->blitlist.prepend(b);
00388
00389 p = new Parameter(Parameter::NUMBER);
00390 strcpy(p->name, "shift bits");
00391 strcpy(p->description, "amount of left bit shifts to apply on each pixel's byte");
00392 p->multiplier = 8.0;
00393 b->parameters.append(p);
00394
00396
00397 b = new Blit(); b->set_name("SHR");
00398 sprintf(b->desc,"shift right bits");
00399 b->type = Blit::LINEAR;
00400 b->fun = schiffler_shr; blitter->blitlist.prepend(b);
00401
00402 p = new Parameter(Parameter::NUMBER);
00403 strcpy(p->name, "shift bits");
00404 strcpy(p->description, "amount of right bit shifts to apply on each pixel's byte");
00405 p->multiplier = 8.0;
00406 b->parameters.append(p);
00407
00409
00410 b = new Blit(); b->set_name("MULB");
00411 sprintf(b->desc,"multiply by byte");
00412 b->type = Blit::LINEAR;
00413 b->fun = schiffler_mulbyte; blitter->blitlist.prepend(b);
00414
00415 p = new Parameter(Parameter::NUMBER);
00416 strcpy(p->name, "byte multiplier");
00417 strcpy(p->description, "amount to multiply on each pixel's byte");
00418 p->multiplier = 255.0;
00419 b->parameters.append(p);
00420
00422
00423 b = new Blit(); b->set_name("BIN");
00424 sprintf(b->desc,"binarize using threshold");
00425 b->type = Blit::LINEAR;
00426 b->fun = schiffler_binarize; blitter->blitlist.prepend(b);
00427
00428 p = new Parameter(Parameter::NUMBER);
00429 strcpy(p->name, "threshold");
00430 strcpy(p->description, "binary threshold value");
00431 p->multiplier = 255.0;
00432 b->parameters.append(p);
00433
00434
00435 }
