/** * Assumed that the right image is bound to IL */ int perform_operation(const char * operation, int verbose) { /* Where to store the first parsing results? */ char function[long_strlen], params[long_strlen], solid_params[long_strlen]; /* Get the function name string and parameters string */ parse_function(operation, function, params); /* Get rid of any whitespaces from the parameters string */ remove_whitespaces(params, solid_params); if (verbose) printf("Calling %s(%s)\n", function, solid_params); /* What function was wanted? -1 means that we don't know */ int function_index = -1; int i; for (i = 0; i < ILU_FUN_COUNT; i++) if (strncmp(function, ilu_functions[i].Name, short_strlen) == 0) {/* Yeah, this function was wanted. Let's have its index from the ilu_functions array */ function_index = i; break; /* nothing to do here any more */ } if (function_index == -1) {/* Seems we haven't found anything... */ fprintf(stderr, "Error: You have specified an invalid function name '%s' (have you called %s).\nRun '%s --help' command to get some help\n", function, operation, program_name); return 1; } /* We are going to try something and we want to know how it ended */ ILboolean return_value; switch (ilu_functions[function_index].Parameter_type) {/* First semi-automatic processing according to type of parameters */ case PARAM_VOID: { ILboolean (* function)() = ilu_functions[function_index].Callback; return_value = function(); break; }/* endcase PARAM_VOID */ case PARAM_ILUINT: { /* first assign and determine the type of the Callback */ ILboolean (* function)(ILuint) = ilu_functions[function_index].Callback; /* then declare the parameter variables */ ILuint param_value; /* fill them */ int success = sscanf(solid_params, "%u", & param_value); if (success != 1) {/* see how it ended */ fprintf(stderr, "Error interpreting '%s' as unsigned integer (when calling %s)\n", solid_params, operation); break; } /* execute the command and store the result */ return_value = function(param_value); break; }/* endcase PARAM_ILUINT */ case PARAM_ILFLOAT: { ILboolean (* function)(ILfloat) = ilu_functions[function_index].Callback; double param_value; int success = sscanf(solid_params, "%lf", & param_value); if (success != 1) { fprintf(stderr, "Error interpreting '%s' as float (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)param_value); break; }/* endcase PARAM_ILFLOAT */ case PARAM_OTHERS: switch (function_index) {/* next, the manual processing according to names */ case ILU_SHARPEN: { ILboolean (* function)(ILfloat, ILuint) = ilu_functions[function_index].Callback; double factor; ILuint iter; int success = sscanf(solid_params, "%lf,%u", & factor, & iter); if (success != 2) { fprintf(stderr, "Error interpreting '%s' as floating-point number and unsigned integer separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)factor, iter); break; }/* endcase ILU_SHARPEN */ case ILU_CROP: { ILboolean (* function)(ILuint, ILuint, ILuint, ILuint, ILuint, ILuint ) = ilu_functions[function_index].Callback; ILuint xoff, yoff, zoff, width, height, depth; int success = sscanf(solid_params, "%u,%u,%u,%u,%u,%u", & xoff, & yoff, & zoff, & width, & height, & depth); if (success != 6) { fprintf(stderr, "Error interpreting '%s' as 6 unsigned integers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function(xoff, yoff, zoff, width, height, depth); break; }/* endcase ILU_CROP */ case ILU_ENLARGECANVAS: case ILU_SCALE: { ILboolean (* function)(ILuint, ILuint, ILuint) = ilu_functions[function_index].Callback; ILuint width, height, depth; int success = sscanf(solid_params, "%u,%u,%u", & width, & height, & depth); if (success != 3) { fprintf(stderr, "Error interpreting '%s' as 3 unsigned integers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function(width, height, depth); break; }/* endcase ILU_ENLARGECANVAS + ILU_SCALE */ case ILU_ENLARGEIMAGE: case ILU_SCALECOLOURS: { ILboolean (* function)(ILfloat, ILfloat, ILfloat) = ilu_functions[function_index].Callback; double first, second, third; int success = sscanf(solid_params, "%lf,%lf,%lf", & first, & second, & third); if (success != 3) { fprintf(stderr, "Error interpreting '%s' as 3 floating-point numbers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)first, (ILfloat)second, (ILfloat)third); break; }/* endcase ILU_ENLARGEIMAGE + ILU_SCALECOLOURS */ case ILU_ROTATE3D: case ILU_SATURATE4F: { ILboolean (* function)(ILfloat, ILfloat, ILfloat, ILfloat) = ilu_functions[function_index].Callback; double first, second, third, fourth; int success = sscanf(solid_params, "%lf,%lf,%lf,%lf", & first, & second, & third, & fourth); if (success != 4) { fprintf(stderr, "Error interpreting '%s' as 4 floating-point numbers separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILfloat)first, (ILfloat)second, (ILfloat)third, (ILfloat)fourth); break; }/* endcase ILU_ROTATE3D + ILU_SATURATE4F */ case ILU_REPLACECOLOUR: { ILboolean (* function)(ILubyte, ILubyte, ILubyte, ILfloat ) = ilu_functions[function_index].Callback; ILuint red, green, blue; double tolerance; int success = sscanf(solid_params, "%u,%u,%u,%lf", & red, & green, & blue, & tolerance); if (success != 4) { fprintf(stderr, "Error interpreting '%s' as 3 8-bit unsigned integers and one floating-point number separated by comma (when calling %s)\n", solid_params, operation); break; } return_value = function((ILubyte)red, (ILubyte)green, (ILubyte)blue, (ILfloat)tolerance); break; }/* endcase ILU_ROTATE3D + ILU_SATURATE4F * */ /* iluConvolution(ILint *matrix, ILint scale, ILint bias); Any idea about this? */ }/* endswitch(function_index) */ break; }/* endswitch (ilu_functions[function_index].Parameter_type) */ /* It didn't end good for some reason... */ if (return_value == IL_FALSE) { int error= ilGetError(); fprintf(stderr, "Something got wrong when calling %s(%s): %s\n", function, solid_params, iluErrorString(error) ); return error; } return 0; }
image_t *readimage(char *filename) { int w,h,bands,bpc; image_t *ni=NULL; void *handle=NULL; ILuint imageid; /* library functions that we will look up dynamically */ ILint (*dlilGetInteger)(ILenum); void (*dlilInit)(void); void (*dlilShutDown)(void); void (*dlilBindImage)(ILuint imageid); ILboolean (*dlilGenImages)(ILsizei,ILuint *imageid); ILboolean (*dlilLoadImage)(char *filename); void (*dlilDeleteImages)(ILsizei,const ILuint *); void (*dlilCopyPixels)( ILuint Xoff, ILuint Yoff, ILuint Zoff, ILuint Width, ILuint Height, ILuint Depth, ILenum Format, ILenum Type, void *Data); dlerror(); /* clear any old errors in dynamic library loading */ /* get the library handle */ handle=dlopen("libIL.so.1",RTLD_LAZY); if (handle==NULL) { fprintf(stderr,"Error opening library `libIL.so.1'\n"); fprintf(stderr,"%s\n",dlerror()); } /* get all the function handles */ /******* ilGetInteger ***********/ dlerror(); dlilGetInteger=dlsym(handle,"ilGetInteger"); if (dlilGetInteger==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } /******* ilInit ***********/ dlerror(); dlilInit=dlsym(handle,"ilInit"); if (dlilInit==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } /******* ilShutDown ***********/ dlerror(); dlilShutDown=dlsym(handle,"ilShutDown"); if (dlilShutDown==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } /******* ilGenImages ***********/ dlerror(); dlilGenImages=dlsym(handle,"ilGenImages"); if (dlilGenImages==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } /******* ilBindImage ***********/ dlerror(); dlilBindImage=dlsym(handle,"ilBindImage"); if (dlilBindImage==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } /******* ilLoadImage ***********/ dlerror(); dlilLoadImage=dlsym(handle,"ilLoadImage"); if (dlilLoadImage==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } /******* ilDeleteImages ***********/ dlerror(); dlilDeleteImages=dlsym(handle,"ilDeleteImages"); if (dlilDeleteImages==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } /******* ilCopyPixels ***********/ dlerror(); dlilCopyPixels=dlsym(handle,"ilCopyPixels"); if (dlilCopyPixels==NULL) { fprintf(stderr,"Error getting symbols.\n"); fprintf(stderr,"%s\n",dlerror()); dlclose(handle); return NULL; } if (dlilGetInteger(IL_VERSION_NUM)<IL_VERSION) { fprintf(stderr,"DevIL library versions differ!\n"); dlclose(handle); return NULL; } /* initialize the devIL library */ dlilInit(); /* generate an image name */ dlilGenImages(1,&imageid); /* bind to this image as current image to do stuff */ dlilBindImage(imageid); /* load an image */ if (!dlilLoadImage(filename)) { fprintf(stderr,"Error loading image `%s'\n",filename); dlilDeleteImages(1,&imageid); dlilShutDown(); dlclose(handle); return NULL; } /* print out info about image */ w=dlilGetInteger(IL_IMAGE_WIDTH); h=dlilGetInteger(IL_IMAGE_HEIGHT); bands=dlilGetInteger(IL_IMAGE_BPP); bpc=dlilGetInteger(IL_IMAGE_BPC); bands/=bpc; fprintf(stderr,"Image is %u by %u with %d channels at %u bpc.\n", w,h,bands,bpc); /* set up the image */ ni=(image_t*)malloc(sizeof(image_t)); ni->w=w; ni->h=h; ni->d=1; ni->bands=bands; ni->data=(float*)malloc(w*h*bands*sizeof(float)); unsigned char *tmpdata=(unsigned char *)malloc(w*h*bands*bpc*sizeof(unsigned char)); unsigned int format=IL_RGB; unsigned int type=IL_UNSIGNED_BYTE; switch(bands) { case 3: format=IL_RGB; break; case 4: format=IL_RGBA; break; default: format=IL_LUMINANCE; break; } switch(bpc) { case 1: type=IL_UNSIGNED_BYTE; break; case 2: type=IL_UNSIGNED_SHORT; break; } dlilCopyPixels(0,0,0,w,h,1,format,type,tmpdata); /* convert tmp data to floats */ unsigned int val=0; unsigned int maxval=(1<<bpc*8)-1; int i; for (i=0;i<w*h*bands;i++) { if (bpc==1) val=(unsigned int)tmpdata[i]; else if (bpc==2) val=(unsigned int)((short*)tmpdata)[i]; else if (bpc==4) val=((unsigned int*)tmpdata)[i]; ni->data[i]=(float)val/(float)maxval; } /* delete the image */ dlilDeleteImages(1,&imageid); /* shutdown DevIL and free all memory */ dlilShutDown(); dlclose(handle); free(tmpdata); return ni; }