diff --git a/libxmount/libxmount.c b/libxmount/libxmount.c
index 2f9b741..90b166b 100644
--- a/libxmount/libxmount.c
+++ b/libxmount/libxmount.c
@@ -1,213 +1,220 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #include <config.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <string.h>
 
 #include "libxmount.h"
 #include "../src/macros.h"
 
+#define LOG_WARNING(...) {            \
+  LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
+}
+#define LOG_ERROR(...) {            \
+  LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
+}
+
 /*
  * XmountLib_SplitLibParams
  */
 int XmountLib_SplitLibParams(char *p_params,
                              uint32_t *p_ret_opts_count,
                              pts_LibXmountOptions **ppp_ret_opt)
 {
   pts_LibXmountOptions p_opts=NULL;
   pts_LibXmountOptions *pp_opts=NULL;
   uint32_t params_len;
   uint32_t opts_count=0;
   uint32_t sep_pos=0;
   char *p_buf=p_params;
 
   if(p_params==NULL) return 0;
 
   // Get params length
   params_len=strlen(p_params);
 
   // Return if no params specified
   if(params_len==0) {
     *ppp_ret_opt=NULL;
     p_ret_opts_count=0;
     return 1;
   }
 
   // Split params
   while(*p_buf!='\0') {
     XMOUNT_MALLOC(p_opts,pts_LibXmountOptions,sizeof(ts_LibXmountOptions));
     p_opts->valid=0;
 
 #define FREE_PP_OPTS() {                                 \
   if(pp_opts!=NULL) {                                    \
     for(uint32_t i=0;i<opts_count;i++) free(pp_opts[i]); \
     free(pp_opts);                                       \
   }                                                      \
 }
 
     // Search next assignment operator
     sep_pos=0;
     while(p_buf[sep_pos]!='\0' &&  p_buf[sep_pos]!='=') sep_pos++;
     if(sep_pos==0 || p_buf[sep_pos]=='\0') {
       LOG_ERROR("Library parameter '%s' is missing an assignment operator!\n",
                 p_buf);
       free(p_opts);
       FREE_PP_OPTS();
       return 0;
     }
 
     // Save option key
     XMOUNT_STRNSET(p_opts->p_key,p_buf,sep_pos);
     p_buf+=(sep_pos+1);
 
     // Search next separator
     sep_pos=0;
     while(p_buf[sep_pos]!='\0' &&  p_buf[sep_pos]!=',') sep_pos++;
     if(sep_pos==0) {
       LOG_ERROR("Library parameter '%s' is not of format key=value!\n",
                 p_opts->p_key);
       free(p_opts->p_key);
       free(p_opts);
       FREE_PP_OPTS();
       return 0;
     }
 
     // Save option value
     XMOUNT_STRNSET(p_opts->p_value,p_buf,sep_pos);
     p_buf+=sep_pos;
 
     LIBXMOUNT_LOG_DEBUG("Extracted library option: '%s' = '%s'\n",
                         p_opts->p_key,
                         p_opts->p_value);
 
 #undef FREE_PP_OPTS
 
     // Add current option to return array
     XMOUNT_REALLOC(pp_opts,
                    pts_LibXmountOptions*,
                    sizeof(pts_LibXmountOptions)*(opts_count+1));
     pp_opts[opts_count++]=p_opts;
 
     // If we're not at the end of p_params, skip over separator for next run
     if(*p_buf!='\0') p_buf++;
   }
 
   LIBXMOUNT_LOG_DEBUG("Extracted a total of %" PRIu32 " library options\n",
                       opts_count);
 
   *p_ret_opts_count=opts_count;
   *ppp_ret_opt=pp_opts;
   return 1;
 }
 
 /*
  * LogMessage
  */
 void LogMessage(char *p_msg_type,
                 char *p_calling_fun,
                 int line,
                 char *p_msg,
                 ...)
 {
   va_list var_list;
 
   // Print message "header"
   printf("%s: %s@%u : ",p_msg_type,p_calling_fun,line);
   // Print message with variable parameters
   va_start(var_list,p_msg);
   vprintf(p_msg,var_list);
   va_end(var_list);
 }
 
 /*
  * StrToInt32
  */
 int32_t StrToInt32(const char *p_value, int *p_ok) {
   long int num;
   char *p_tail;
 
   errno=0;
   num=strtol(p_value,&p_tail,0);
   if(errno==ERANGE || *p_tail!='\0' || num<INT32_MIN || num>INT32_MAX) {
     *p_ok=0;
     return 0;
   }
 
   *p_ok=1;
   return (int32_t)num;
 }
 
 /*
  * StrToUint32
  */
 uint32_t StrToUint32(const char *p_value, int *p_ok) {
   unsigned long int num;
   char *p_tail;
 
   errno=0;
   num=strtoul(p_value,&p_tail,0);
   if(errno==ERANGE || *p_tail!='\0' || num>UINT32_MAX) {
     *p_ok=0;
     return 0;
   }
 
   *p_ok=1;
   return (uint32_t)num;
 }
 
 /*
  * StrToInt64
  */
 int64_t StrToInt64(const char *p_value, int *p_ok) {
   long long int num;
   char *p_tail;
 
   errno=0;
   num=strtoll(p_value,&p_tail,0);
   if(errno==ERANGE || *p_tail!='\0' || num<INT64_MIN || num>INT64_MAX) {
     *p_ok=0;
     return 0;
   }
 
   *p_ok=1;
   return (int64_t)num;
 }
 
 /*
  * StrToUint64
  */
 uint64_t StrToUint64(const char *p_value, int *p_ok) {
   unsigned long long int num;
   char *p_tail;
 
   errno=0;
   num=strtoull(p_value,&p_tail,0);
   if(errno==ERANGE || *p_tail!='\0' || num>UINT64_MAX) {
     *p_ok=0;
     return 0;
   }
 
   *p_ok=1;
   return (uint64_t)num;
 }
 
diff --git a/src/xmount.c b/src/xmount.c
index 08aba17..630228f 100755
--- a/src/xmount.c
+++ b/src/xmount.c
@@ -1,1934 +1,1762 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * xmount is a small tool to "fuse mount" various harddisk image formats as dd, *
 * vdi, vhd or vmdk files and enable virtual write access to them.              *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #include <config.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
 #include <inttypes.h> // For PRI*
 #include <errno.h>
 #include <dlfcn.h> // For dlopen, dlclose, dlsym
 #include <dirent.h> // For opendir, readdir, closedir
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/stat.h> // For fstat
 #include <sys/types.h>
 #ifdef HAVE_LINUX_FS_H
   #include <linux/fs.h> // For SEEK_* ??
 #endif
 #if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
   #include <grp.h> // For getgrnam, struct group
   #include <pwd.h> // For getpwuid, struct passwd
 #endif
 #include <pthread.h>
 #include <time.h> // For time
 
 #include "xmount.h"
 #include "xmount_fuse.h"
 #include "md5.h"
 #include "macros.h"
 #include "../libxmount/libxmount.h"
 
 #define XMOUNT_COPYRIGHT_NOTICE \
   "xmount v%s Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>"
 
 #define LOG_WARNING(...) {            \
   LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
 }
 #define LOG_ERROR(...) {            \
   LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
 }
 #define LOG_DEBUG(...) {                              \
   LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
 }
 
 #define HASH_AMOUNT (1024*1024)*10 // Amount of data used to construct a
                                    // "unique" hash for every input image
                                    // (10MByte)
 
 /*******************************************************************************
  * Forward declarations
  ******************************************************************************/
 /*
  * Misc
  */
-static void InitResources();
+static int InitResources();
 static void FreeResources();
 static void PrintUsage(char*);
 static void CheckFuseSettings();
 static int ParseCmdLine(const int, char**);
 static int ExtractOutputFileNames(char*);
 static int CalculateInputImageHash(uint64_t*, uint64_t*);
 /*
  * Info file
  */
 static int InitInfoFile();
 /*
  * Lib related
  */
 static int LoadLibs();
-static int FindInputLib(pts_InputImage);
 static int FindMorphingLib();
 static int FindOutputLib();
-static int SplitLibraryParameters(char*, uint32_t*, pts_LibXmountOptions**);
 /*
  * Functions exported to LibXmount_Morphing
  */
 static int LibXmount_Morphing_ImageCount(uint64_t*);
 static int LibXmount_Morphing_Size(uint64_t, uint64_t*);
 static int LibXmount_Morphing_Read(uint64_t, char*, off_t, size_t, size_t*);
 /*
  * Functions exported to LibXmount_Output
  */
 static int LibXmount_Output_Size(uint64_t*);
 static int LibXmount_Output_Read(char*, off_t, size_t, size_t*);
 static int LibXmount_Output_Write(char*, off_t, size_t, size_t*);
 
 /*******************************************************************************
  * Helper functions
  ******************************************************************************/
 //! Print usage instructions (cmdline options etc..)
 /*!
  * \param p_prog_name Program name (argv[0])
  */
 static void PrintUsage(char *p_prog_name) {
   char *p_buf;
   int first;
   int ret;
 
   printf("\n" XMOUNT_COPYRIGHT_NOTICE "\n",XMOUNT_VERSION);
   printf("\nUsage:\n");
   printf("  %s [fopts] <xopts> <mntp>\n\n",p_prog_name);
   printf("Options:\n");
   printf("  fopts:\n");
   printf("    -d : Enable FUSE's and xmount's debug mode.\n");
   printf("    -h : Display this help message.\n");
   printf("    -s : Run single threaded.\n");
   printf("    -o no_allow_other : Disable automatic addition of FUSE's "
            "allow_other option.\n");
   printf("    -o <fopts> : Specify fuse mount options. Will also disable "
            "automatic addition of FUSE's allow_other option!\n");
   printf("\n");
   printf("  xopts:\n");
   printf("    --cache <cfile> : Enable virtual write support.\n");
   printf("      <cfile> specifies the cache file to use.\n");
   printf("    --in <itype> <ifile> : Input image format and source file(s). "
            "May be specified multiple times.\n");
   printf("      <itype> can be ");
 
+#define PRINTUSAGE__LIST_SUPP_LIB_TYPES(fun,handle,ret_ok) do { \
+  first=1;                                                      \
+  if(fun(handle,&p_buf)==ret_ok) {                              \
+    while(*p_buf!='\0') {                                       \
+      if(first==1) {                                            \
+        printf("\"%s\"",p_buf);                                 \
+        first=0;                                                \
+      } else printf(", \"%s\"",p_buf);                          \
+      p_buf+=(strlen(p_buf)+1);                                 \
+    }                                                           \
+    free(p_buf);                                                \
+  }                                                             \
+  printf(".\n");                                                \
+} while(0)
+
   // List supported input formats
-  first=1;
-  if(XmountInput_GetSupportedFormats(glob_xmount.h_input,
-                                     &p_buf)==e_XmountInput_Error_None)
-  {
-    while(*p_buf!='\0') {
-      if(first==1) {
-        printf("\"%s\"",p_buf);
-        first=0;
-      } else printf(", \"%s\"",p_buf);
-      p_buf+=(strlen(p_buf)+1);
-    }
-    free(p_buf);
-  }
-  printf(".\n");
+  PRINTUSAGE__LIST_SUPP_LIB_TYPES(XmountInput_GetSupportedFormats,
+                                  glob_xmount.h_input,
+                                  e_XmountInput_Error_None);
 
   printf("      <ifile> specifies the source file. If your image is split into "
            "multiple files, you have to specify them all!\n");
   printf("    --inopts <iopts> : Specify input library specific options.\n");
   printf("      <iopts> specifies a comma separated list of key=value options. "
            "See below for details.\n");
   printf("    --info : Print out infos about used compiler and libraries.\n");
   printf("    --morph <mtype> : Morphing function to apply to input image(s). "
            "If not specified, defaults to \"combine\".\n");
   printf("      <mtype> can be ");
 
   // List supported morphing functions
-  first=1;
-  for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
-    p_buf=glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types;
-    while(*p_buf!='\0') {
-      if(first==1) {
-        printf("\"%s\"",p_buf);
-        first=0;
-      } else printf(", \"%s\"",p_buf);
-      p_buf+=(strlen(p_buf)+1);
-    }
-  }
-  printf(".\n");
+  PRINTUSAGE__LIST_SUPP_LIB_TYPES(XmountMorphing_GetSupportedTypes,
+                                  glob_xmount.h_morphing,
+                                  e_XmountMorphError_None);
 
   printf("    --morphopts <mopts> : Specify morphing library specific "
            "options.\n");
   printf("      <mopts> specifies a comma separated list of key=value options. "
            "See below for details.\n");
   printf("    --offset <off> : Move the output image data start <off> bytes "
            "into the input image(s).\n");
   printf("    --out <otype> : Output image format. If not specified, "
            "defaults to ");
 #ifdef __APPLE__
   printf("\"dmg\".\n");
 #else
   printf("\"raw\".\n");
 #endif
   printf("      <otype> can be ");
 
   // List supported output formats
   first=1;
   for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
     p_buf=glob_xmount.output.pp_libs[i]->p_supported_output_formats;
     while(*p_buf!='\0') {
       if(first==1) {
         printf("\"%s\"",p_buf);
         first=0;
       } else printf(", \"%s\"",p_buf);
       p_buf+=(strlen(p_buf)+1);
     }
   }
   printf(".\n");
 
   printf("    --outopts <oopts> : Specify output library specific "
            "options.\n");
   printf("    --owcache <file> : Same as --cache <file> but overwrites "
            "existing cache file.\n");
   printf("    --sizelimit <size> : The data end of input image(s) is set to no "
            "more than <size> bytes after the data start.\n");
   printf("    --version : Same as --info.\n");
   printf("\n");
   printf("  mntp:\n");
   printf("    Mount point where output image should be located.\n");
   printf("\n");
   printf("Infos:\n");
   printf("  * One --in option and a mount point are mandatory!\n");
   printf("  * If you specify --in multiple times, data from all images is "
            "morphed into one output image using the specified morphing "
            "function.\n");
   printf("  * For VMDK emulation, you have to uncomment \"user_allow_other\" "
            "in /etc/fuse.conf or run xmount as root.\n");
   printf("\n");
   printf("Input / Morphing / Output library specific options:\n");
   printf("  Input / Morphing libraries might support an own set of "
            "options to configure / tune their behaviour.\n");
   printf("  Libraries supporting this feature (if any) and their "
            "options are listed below.\n");
   printf("\n");
 
+#define PRINTUSAGE__LIST_LIB_OPT_HELP(fun,handle,ret_ok) do { \
+  if(fun(handle,&p_buf)==ret_ok) {                            \
+    printf("%s",p_buf);                                       \
+    free(p_buf);                                              \
+  }                                                           \
+} while(0)
+
   // List input, morphing and output lib options
-  if(XmountInput_GetOptionsHelpText(glob_xmount.h_input,
-                                    &p_buf)==e_XmountInput_Error_None)
-  {
-    printf("%s",p_buf);
-    free(p_buf);
-  }
-  for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
-    ret=glob_xmount.morphing.pp_libs[i]->
-          lib_functions.OptionsHelp((const char**)&p_buf);
-    if(ret!=0) {
-      LOG_ERROR("Unable to get options help for library '%s': %s!\n",
-                glob_xmount.morphing.pp_libs[i]->p_name,
-                glob_xmount.morphing.pp_libs[i]->
-                  lib_functions.GetErrorMessage(ret));
-    }
-    if(p_buf==NULL) continue;
-    printf("  - %s\n",glob_xmount.morphing.pp_libs[i]->p_name);
-    printf("%s",p_buf);
-    printf("\n");
-  }
+  PRINTUSAGE__LIST_LIB_OPT_HELP(XmountInput_GetOptionsHelpText,
+                                glob_xmount.h_input,
+                                e_XmountInput_Error_None);
+  PRINTUSAGE__LIST_LIB_OPT_HELP(XmountMorphing_GetOptionsHelpText,
+                                glob_xmount.h_morphing,
+                                e_XmountMorphError_None);
+
   for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
     ret=glob_xmount.output.pp_libs[i]->
           lib_functions.OptionsHelp((const char**)&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get options help for library '%s': %s!\n",
                 glob_xmount.output.pp_libs[i]->p_name,
                 glob_xmount.output.pp_libs[i]->
                   lib_functions.GetErrorMessage(ret));
     }
     if(p_buf==NULL) continue;
     printf("  - %s\n",glob_xmount.output.pp_libs[i]->p_name);
     printf("%s",p_buf);
     printf("\n");
   }
+
+#undef PRINTUSAGE__LIST_LIB_OPT_HELP
+#undef PRINTUSAGE__LIST_SUPPORTED_LIB_OPTS
+
 }
 
 //! Check fuse settings
 /*!
  * Check if FUSE allows us to pass the -o allow_other parameter. This only works
  * if we are root or user_allow_other is set in /etc/fuse.conf.
  *
  * In addition, this function also checks if the user is member of the fuse
  * group which is generally needed to use fuse at all.
  */
 static void CheckFuseSettings() {
 #if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
   struct group *p_group;
   struct passwd *p_passwd;
 #endif
   int found;
   FILE *h_fuse_conf;
   char line[256];
 
   glob_xmount.may_set_fuse_allow_other=FALSE;
 
   if(geteuid()==0) {
     // Running as root, there should be no problems
     glob_xmount.may_set_fuse_allow_other=TRUE;
     return;
   }
 
 #if !defined(__APPLE__) && defined(HAVE_GRP_H) && defined(HAVE_PWD_H)
   // Check if a fuse group exists and if so, make sure user is a member of it.
   // Makes only sense on Linux because as far as I know osxfuse has no own group
   p_group=getgrnam("fuse");
   if(p_group!=NULL) {
     // Get effective user name
     p_passwd=getpwuid(geteuid());
     if(p_passwd==NULL) {
       printf("\nWARNING: Unable to determine your effective user name. If "
              "mounting works, you can ignore this message.\n\n");
       return;
     }
     // Check if user is member of fuse group
     found=FALSE;
     while(*(p_group->gr_mem)!=NULL) {
       if(strcmp(*(p_group->gr_mem),p_passwd->pw_name)==0) {
         found=TRUE;
         break;
       }
       p_group->gr_mem++;
     }
     if(found==FALSE) {
       printf("\nWARNING: You are not a member of the \"fuse\" group. This will "
                "prevent you from mounting images using xmount. Please add "
                "yourself to the \"fuse\" group using the command "
                "\"sudo usermod -a -G fuse %s\" and reboot your system or "
                "execute xmount as root.\n\n",
              p_passwd->pw_name);
       return;
     }
   } else {
     printf("\nWARNING: Your system does not seem to have a \"fuse\" group. If "
              "mounting works, you can ignore this message.\n\n");
   }
 #endif
 
   // Read FUSE's config file /etc/fuse.conf and check for set user_allow_other
   h_fuse_conf=(FILE*)FOPEN("/etc/fuse.conf","r");
   if(h_fuse_conf!=NULL) {
     // Search conf file for set user_allow_others
     found=FALSE;
     while(fgets(line,sizeof(line),h_fuse_conf)!=NULL) {
       // TODO: This works as long as there is no other parameter beginning with
       // "user_allow_other" :)
       if(strncmp(line,"user_allow_other",16)==0) {
         found=TRUE;
         break;
       }
     }
     fclose(h_fuse_conf);
     if(found==TRUE) {
       glob_xmount.may_set_fuse_allow_other=TRUE;
     } else {
       printf("\nWARNING: FUSE will not allow other users nor root to access "
                "your virtual harddisk image. To change this behavior, please "
                "add \"user_allow_other\" to /etc/fuse.conf or execute xmount "
                "as root.\n\n");
     }
   } else {
     printf("\nWARNING: Unable to open /etc/fuse.conf. If mounting works, you "
              "can ignore this message. If you encounter issues, please create "
              "the file and add a single line containing the string "
              "\"user_allow_other\" or execute xmount as root.\n\n");
     return;
   }
 }
 
 //! Parse command line options
 /*!
  * \param argc Number of cmdline params
  * \param pp_argv Array containing cmdline params
  * \return TRUE on success, FALSE on error
  */
 static int ParseCmdLine(const int argc, char **pp_argv) {
   int i=1;
   int FuseMinusOControl=TRUE;
   int FuseAllowOther=TRUE;
   int first;
   uint64_t buf;
   char *p_buf;
   char **pp_buf;
   int ret;
   te_XmountInput_Error input_ret=e_XmountInput_Error_None;
+  te_XmountMorphError morph_ret=e_XmountMorphError_None;
 
   // add pp_argv[0] to FUSE's argv
   XMOUNT_MALLOC(glob_xmount.pp_fuse_argv,char**,sizeof(char*));
   XMOUNT_STRSET(glob_xmount.pp_fuse_argv[0],pp_argv[0]);
   glob_xmount.fuse_argc=1;
 
   // Parse options
   while(i<argc && *pp_argv[i]=='-') {
     if(strlen(pp_argv[i])>1 && *(pp_argv[i]+1)!='-') {
       // Options beginning with one - are mostly FUSE specific
       if(strcmp(pp_argv[i],"-d")==0) {
         // Enable FUSE's and xmount's debug mode
         XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                        char**,
                        (glob_xmount.fuse_argc+1)*sizeof(char*));
         XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                       pp_argv[i])
         glob_xmount.fuse_argc++;
         glob_xmount.debug=TRUE;
+        input_ret=XmountInput_EnableDebugging(glob_xmount.h_input);
+        if(input_ret!=e_XmountInput_Error_None) {
+          LOG_ERROR("Unable to enable input debugging: Error code %u!\n",
+                    input_ret);
+          return FALSE;
+        }
       } else if(strcmp(pp_argv[i],"-h")==0) {
         // Print help message
         PrintUsage(pp_argv[0]);
         exit(0);
       } else if(strcmp(pp_argv[i],"-o")==0) {
         // Next parameter specifies fuse mount options
         if((i+1)<argc) {
           i++;
           // As the user specified the -o option, we assume he knows what he is
           // doing. We won't append allow_other automatically. And we allow him
           // to disable allow_other by passing a single "-o no_allow_other"
           // which won't be passed to FUSE as it is xmount specific.
           if(strcmp(pp_argv[i],"no_allow_other")!=0) {
             glob_xmount.fuse_argc+=2;
             XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                            char**,
                            glob_xmount.fuse_argc*sizeof(char*));
             XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-2],
                           pp_argv[i-1]);
             XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                           pp_argv[i]);
             FuseMinusOControl=FALSE;
           } else FuseAllowOther=FALSE;
         } else {
           LOG_ERROR("Couldn't parse fuse mount options!\n")
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"-s")==0) {
         // Enable FUSE's single threaded mode
         XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                        char**,
                        (glob_xmount.fuse_argc+1)*sizeof(char*));
         XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                       pp_argv[i]);
         glob_xmount.fuse_argc++;
       } else if(strcmp(pp_argv[i],"-V")==0) {
         // Display FUSE version info
         XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                        char**,
                        (glob_xmount.fuse_argc+1)*sizeof(char*));
         XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                       pp_argv[i]);
         glob_xmount.fuse_argc++;
       } else {
         LOG_ERROR("Unknown command line option \"%s\"\n",pp_argv[i]);
         return FALSE;
       }
     } else {
       // Options beginning with -- are xmount specific
       if(strcmp(pp_argv[i],"--cache")==0 /*|| strcmp(pp_argv[i],"--rw")==0*/) {
         // Emulate writable access to mounted image
         // Next parameter must be cache file to read/write changes from/to
         if((i+1)<argc) {
           i++;
           XMOUNT_STRSET(glob_xmount.args.p_cache_file,pp_argv[i])
           glob_xmount.output.writable=TRUE;
         } else {
           LOG_ERROR("You must specify a cache file!\n")
           return FALSE;
         }
         LOG_DEBUG("Enabling virtual write support using cache file \"%s\"\n",
                   glob_xmount.args.p_cache_file)
       } else if(strcmp(pp_argv[i],"--in")==0) {
         // Input image format and source files
         if((i+2)<argc) {
           i++;
           // Save format
           p_buf=pp_argv[i];
           // Parse input image filename(s) and save to temporary array
           i++;
           buf=0;
           pp_buf=NULL;
           while(i<(argc-1) && strncmp(pp_argv[i],"--",2)!=0) {
             buf++;
             XMOUNT_REALLOC(pp_buf,char**,buf*sizeof(char*));
             pp_buf[buf-1]=pp_argv[i];
             i++;
           }
           i--;
           if(buf==0) {
             LOG_ERROR("No input files specified for \"--in %s\"!\n",p_buf);
             return FALSE;
           }
           // Add input image
           if((input_ret=XmountInput_AddImage(glob_xmount.h_input,
                                              p_buf,
                                              buf,
                                              (const char**)pp_buf)
              )!=e_XmountInput_Error_None)
           {
             LOG_ERROR("Unable to load input image: Error code %u!\n",input_ret);
             XMOUNT_FREE(pp_buf);
             return FALSE;
           }
           // Save first image path to generate fsname later on
           if(glob_xmount.p_first_input_image_name==NULL) {
             XMOUNT_STRSET(glob_xmount.p_first_input_image_name,
                           pp_buf[0]);
           }
         } else {
           LOG_ERROR("You must specify an input image format and source file!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--inopts")==0) {
         // Set input lib options
         if((i+1)<argc) {
           i++;
           input_ret=XmountInput_SetOptions(glob_xmount.h_input,pp_argv[i]);
           if(input_ret!=e_XmountInput_Error_None) {
             LOG_ERROR("Unable to parse input library options: Error code %u!\n",
                       input_ret);
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify special options!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--morph")==0) {
         // Set morphing lib to use
         if((i+1)<argc) {
           i++;
-          if(glob_xmount.morphing.p_morph_type==NULL) {
-            XMOUNT_STRSET(glob_xmount.morphing.p_morph_type,pp_argv[i]);
-          } else {
-            LOG_ERROR("You can only specify --morph once!")
+          morph_ret=XmountMorphing_SetType(glob_xmount.h_morphing,
+                                           pp_argv[i]);
+          if(morph_ret!=e_XmountMorphError_None) {
+            LOG_ERROR("Unable to set morphing type: Error code %u!\n",
+                      morph_ret);
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify morphing type!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--morphopts")==0) {
         // Set morphing lib options
         if((i+1)<argc) {
           i++;
-          if(glob_xmount.morphing.pp_lib_params==NULL) {
-            if(SplitLibraryParameters(pp_argv[i],
-                                      &(glob_xmount.morphing.lib_params_count),
-                                      &(glob_xmount.morphing.pp_lib_params)
-                                     )==FALSE)
-            {
-              LOG_ERROR("Unable to parse morphing library options '%s'!\n",
-                        pp_argv[i]);
-              return FALSE;
-            }
-          } else {
-            LOG_ERROR("You can only specify --morphopts once!")
+          morph_ret=XmountMorphing_SetOptions(glob_xmount.h_morphing,
+                                              pp_argv[i]);
+          if(morph_ret!=e_XmountMorphError_None) {
+            LOG_ERROR("Unable to parse morphing library options: "
+                        "Error code %u!\n",
+                      morph_ret);
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify special morphing lib params!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--offset")==0) {
         // Set input image offset
         if((i+1)<argc) {
           i++;
           buf=StrToUint64(pp_argv[i],&ret);
           if(ret==0) {
             LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i]);
             return FALSE;
           }
           input_ret=XmountInput_SetInputOffset(glob_xmount.h_input,buf);
           if(input_ret!=e_XmountInput_Error_None) {
             LOG_ERROR("Unable to set input offset: Error code %u!\n",input_ret);
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify an offset!\n")
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--out")==0) {
         // Set output lib to use
         if((i+1)<argc) {
           i++;
           if(glob_xmount.output.p_output_format==NULL) {
             XMOUNT_STRSET(glob_xmount.output.p_output_format,pp_argv[i]);
           } else {
             LOG_ERROR("You can only specify --out once!")
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify an output format!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--outopts")==0) {
         // Set output lib options
         if((i+1)<argc) {
           i++;
           if(glob_xmount.output.pp_lib_params==NULL) {
-            if(SplitLibraryParameters(pp_argv[i],
-                                      &(glob_xmount.output.lib_params_count),
-                                      &(glob_xmount.output.pp_lib_params)
-                                     )==FALSE)
+            if(XmountLib_SplitLibParams(pp_argv[i],
+                                        &(glob_xmount.output.lib_params_count),
+                                        &(glob_xmount.output.pp_lib_params)
+                                       )==FALSE)
             {
               LOG_ERROR("Unable to parse output library options '%s'!\n",
                         pp_argv[i]);
               return FALSE;
             }
           } else {
             LOG_ERROR("You can only specify --outopts once!")
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify special output lib params!\n");
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--owcache")==0) {
         // Enable writable access to mounted image and overwrite existing cache
         // Next parameter must be cache file to read/write changes from/to
         if((i+1)<argc) {
           i++;
           XMOUNT_STRSET(glob_xmount.args.p_cache_file,pp_argv[i])
           glob_xmount.output.writable=TRUE;
           glob_xmount.args.overwrite_cache=TRUE;
         } else {
           LOG_ERROR("You must specify a cache file!\n")
           return FALSE;
         }
         LOG_DEBUG("Enabling virtual write support overwriting cache file %s\n",
                   glob_xmount.args.p_cache_file)
       } else if(strcmp(pp_argv[i],"--sizelimit")==0) {
         // Set input image size limit
         if((i+1)<argc) {
           i++;
           buf=StrToUint64(pp_argv[i],&ret);
           if(ret==0) {
             LOG_ERROR("Unable to convert '%s' to a number!\n",pp_argv[i]);
             return FALSE;
           }
           input_ret=XmountInput_SetInputSizeLimit(glob_xmount.h_input,buf);
           if(input_ret!=e_XmountInput_Error_None) {
             LOG_ERROR("Unable to set input size limit: Error code %u!\n",
                       input_ret);
             return FALSE;
           }
         } else {
           LOG_ERROR("You must specify a size limit!\n")
           return FALSE;
         }
       } else if(strcmp(pp_argv[i],"--version")==0 ||
                 strcmp(pp_argv[i],"--info")==0)
       {
         // Print xmount info
         printf(XMOUNT_COPYRIGHT_NOTICE "\n\n",XMOUNT_VERSION);
 #ifdef __GNUC__
         printf("  compile timestamp: %s %s\n",__DATE__,__TIME__);
         printf("  gcc version: %s\n",__VERSION__);
 #endif
-        printf("  loaded input libraries:\n");
-        input_ret=XmountInput_GetLibsInfoText(glob_xmount.h_input,&p_buf);
-        if(p_buf==NULL || input_ret!=e_XmountInput_Error_None) {
-          LOG_ERROR("Unable to get input library infos: Error code %u!\n",
-                    input_ret);
-          return FALSE;
-        }
-        printf("%s",p_buf);
-        XMOUNT_FREE(p_buf);
-        printf("  loaded morphing libraries:\n");
-        for(uint32_t ii=0;ii<glob_xmount.morphing.libs_count;ii++) {
-          printf("    - %s supporting ",
-                 glob_xmount.morphing.pp_libs[ii]->p_name);
-          p_buf=glob_xmount.morphing.pp_libs[ii]->p_supported_morphing_types;
-          first=TRUE;
-          while(*p_buf!='\0') {
-            if(first) {
-              printf("\"%s\"",p_buf);
-              first=FALSE;
-            } else printf(", \"%s\"",p_buf);
-            p_buf+=(strlen(p_buf)+1);
-          }
-          printf("\n");
-        }
+
+#define PARSECMDLINE__PRINT_LOADED_LIBINFO(text,libret,fun,handle,err_ok) do { \
+  printf(text);                                                                \
+  libret=fun(handle,&p_buf);                                                   \
+  if(p_buf==NULL || libret!=err_ok) {                                          \
+    LOG_ERROR("Unable to get library infos: Error code %u!\n",libret);         \
+    return FALSE;                                                              \
+  }                                                                            \
+  printf("%s",p_buf);                                                          \
+  XMOUNT_FREE(p_buf);                                                          \
+} while(0)
+
+        PARSECMDLINE__PRINT_LOADED_LIBINFO("  loaded input libraries:\n",
+                                           input_ret,
+                                           XmountInput_GetLibsInfoText,
+                                           glob_xmount.h_input,
+                                           e_XmountInput_Error_None);
+        PARSECMDLINE__PRINT_LOADED_LIBINFO("  loaded morphing libraries:\n",
+                                           morph_ret,
+                                           XmountMorphing_GetLibsInfoText,
+                                           glob_xmount.h_morphing,
+                                           e_XmountMorphError_None);
+
         printf("  loaded output libraries:\n");
         for(uint32_t ii=0;ii<glob_xmount.output.libs_count;ii++) {
           printf("    - %s supporting ",
                  glob_xmount.output.pp_libs[ii]->p_name);
           p_buf=glob_xmount.output.pp_libs[ii]->p_supported_output_formats;
           first=TRUE;
           while(*p_buf!='\0') {
             if(first) {
               printf("\"%s\"",p_buf);
               first=FALSE;
             } else printf(", \"%s\"",p_buf);
             p_buf+=(strlen(p_buf)+1);
           }
           printf("\n");
         }
         printf("\n");
         exit(0);
       } else {
         LOG_ERROR("Unknown command line option \"%s\"\n",pp_argv[i]);
         return FALSE;
       }
     }
     i++;
   }
 
   // Extract mountpoint
   if(i==(argc-1)) {
     XMOUNT_STRSET(glob_xmount.p_mountpoint,pp_argv[argc-1])
     XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                    char**,
                    (glob_xmount.fuse_argc+1)*sizeof(char*));
     XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc],
                   glob_xmount.p_mountpoint);
     glob_xmount.fuse_argc++;
   } else {
     LOG_ERROR("No mountpoint specified!\n")
     return FALSE;
   }
 
   if(FuseMinusOControl==TRUE) {
     // We control the -o flag, set subtype, fsname and allow_other options
     glob_xmount.fuse_argc+=2;
     XMOUNT_REALLOC(glob_xmount.pp_fuse_argv,
                    char**,
                    glob_xmount.fuse_argc*sizeof(char*));
     XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-2],"-o");
     XMOUNT_STRSET(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                   "subtype=xmount");
     if(glob_xmount.p_first_input_image_name!=NULL) {
       // Set name of first source file as fsname
       XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                     ",fsname='");
       // If possible, use full path
       p_buf=realpath(glob_xmount.p_first_input_image_name,NULL);
       if(p_buf==NULL) {
         XMOUNT_STRSET(p_buf,glob_xmount.p_first_input_image_name);
       }
       // Make sure fsname does not include some forbidden chars
       for(uint32_t i=0;i<strlen(p_buf);i++) {
         if(p_buf[i]=='\'') p_buf[i]='_';
       }
       // Set fsname
       XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                     p_buf);
       XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                     "'");
       free(p_buf);
     }
     if(FuseAllowOther==TRUE) {
       // Add "allow_other" option if allowed
       if(glob_xmount.may_set_fuse_allow_other) {
         XMOUNT_STRAPP(glob_xmount.pp_fuse_argv[glob_xmount.fuse_argc-1],
                       ",allow_other");
       }
     }
   }
 
+#undef PARSECMDLINE__PRINT_LOADED_LIBINFO
+
   return TRUE;
 }
 
 //! Extract output file name from input image name
 /*!
  * \param p_orig_name Name of input image (may include a path)
  * \return TRUE on success, FALSE on error
  */
 static int ExtractOutputFileNames(char *p_orig_name) {
   char *tmp;
 
   // Truncate any leading path
   tmp=strrchr(p_orig_name,'/');
   if(tmp!=NULL) p_orig_name=tmp+1;
 
   // Extract file extension
   tmp=strrchr(p_orig_name,'.');
 
   // Set leading '/'
   XMOUNT_STRSET(glob_xmount.output.p_virtual_image_path,"/");
   XMOUNT_STRSET(glob_xmount.output.p_info_path,"/");
 
   // Copy filename
   if(tmp==NULL) {
     // Input image filename has no extension
     XMOUNT_STRAPP(glob_xmount.output.p_virtual_image_path,p_orig_name);
     XMOUNT_STRAPP(glob_xmount.output.p_info_path,p_orig_name);
     XMOUNT_STRAPP(glob_xmount.output.p_info_path,".info");
   } else {
     XMOUNT_STRNAPP(glob_xmount.output.p_virtual_image_path,p_orig_name,
                    strlen(p_orig_name)-strlen(tmp));
     XMOUNT_STRNAPP(glob_xmount.output.p_info_path,p_orig_name,
                    strlen(p_orig_name)-strlen(tmp));
     XMOUNT_STRAPP(glob_xmount.output.p_info_path,".info");
   }
 
   // Add virtual file extensions
   // TODO: Get from output lib and add
   //XMOUNT_STRAPP(glob_xmount.output.p_virtual_image_path,".dd");
 
   LOG_DEBUG("Set virtual image name to \"%s\"\n",
             glob_xmount.output.p_virtual_image_path);
   LOG_DEBUG("Set virtual image info name to \"%s\"\n",
             glob_xmount.output.p_info_path);
   return TRUE;
 }
 
 //! Calculates an MD5 hash of the first HASH_AMOUNT bytes of the input image
 /*!
  * \param p_hash_low Pointer to the lower 64 bit of the hash
  * \param p_hash_high Pointer to the higher 64 bit of the hash
  * \return TRUE on success, FALSE on error
  */
 static int CalculateInputImageHash(uint64_t *p_hash_low,
                                    uint64_t *p_hash_high)
 {
   char hash[16];
   md5_state_t md5_state;
   char *p_buf;
   int ret;
   size_t read_data;
 
   XMOUNT_MALLOC(p_buf,char*,HASH_AMOUNT*sizeof(char));
   ret=ReadMorphedImageData(p_buf,0,HASH_AMOUNT,&read_data);
   if(ret!=TRUE || read_data==0) {
     LOG_ERROR("Couldn't read data from morphed image file!\n")
     free(p_buf);
     return FALSE;
   }
 
   // Calculate MD5 hash
   md5_init(&md5_state);
   md5_append(&md5_state,(const md5_byte_t*)p_buf,read_data);
   md5_finish(&md5_state,(md5_byte_t*)hash);
   // Convert MD5 hash into two 64bit integers
   *p_hash_low=*((uint64_t*)hash);
   *p_hash_high=*((uint64_t*)(hash+8));
   free(p_buf);
 
   return TRUE;
 }
 
 //! Create info file
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int InitInfoFile() {
   int ret;
-  te_XmountInput_Error input_ret=e_XmountInput_Error_None;
   char *p_buf;
+  te_XmountInput_Error input_ret=e_XmountInput_Error_None;
+  te_XmountMorphError morph_ret=e_XmountMorphError_None;
 
   // Start with static input header
   XMOUNT_MALLOC(glob_xmount.output.p_info_file,
                 char*,
                 strlen(IMAGE_INFO_INPUT_HEADER)+1);
   strncpy(glob_xmount.output.p_info_file,
           IMAGE_INFO_INPUT_HEADER,
           strlen(IMAGE_INFO_INPUT_HEADER)+1);
 
+#define INITINFOFILE__GET_CONTENT(libret,fun,handle,err_ok,err_msg) do { \
+  libret=fun(handle,&p_buf);                                             \
+  if(p_buf==NULL || libret!=err_ok) {                                    \
+    LOG_ERROR(err_msg "Error code %u!\n",libret);                        \
+    return FALSE;                                                        \
+  }                                                                      \
+  XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);                   \
+  XMOUNT_FREE(p_buf);                                                    \
+} while(0)
+
   // Get and add infos from input lib(s)
-  input_ret=XmountInput_GetInfoFileContent(glob_xmount.h_cache,&p_buf);
-  if(p_buf==NULL || input_ret!=e_XmountInput_Error_None) {
-    LOG_ERROR("Unable to get info file content for input image(s): "
-                "Error code %u!\n",
-              input_ret);
-    return FALSE;
-  }
-  XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);
-  XMOUNT_FREE(p_buf);
+  INITINFOFILE__GET_CONTENT(input_ret,
+                            XmountInput_GetInfoFileContent,
+                            glob_xmount.h_input,
+                            e_XmountInput_Error_None,
+                            "Unable to get info file content from input lib: ");
 
   // Add static morphing header
   XMOUNT_STRAPP(glob_xmount.output.p_info_file,IMAGE_INFO_MORPHING_HEADER);
 
   // Get and add infos from morphing lib
-  ret=glob_xmount.morphing.p_functions->
-        GetInfofileContent(glob_xmount.morphing.p_handle,(const char**)&p_buf);
-  if(ret!=0) {
-    LOG_ERROR("Unable to get info file content from morphing lib: %s!\n",
-              glob_xmount.morphing.p_functions->GetErrorMessage(ret));
-    return FALSE;
-  }
-  if(p_buf!=NULL) {
-    XMOUNT_STRAPP(glob_xmount.output.p_info_file,p_buf);
-    glob_xmount.morphing.p_functions->FreeBuffer(p_buf);
-  } else {
-    XMOUNT_STRAPP(glob_xmount.output.p_info_file,"None\n");
-  }
+  INITINFOFILE__GET_CONTENT(morph_ret,
+                            XmountMorphing_GetInfoFileContent,
+                            glob_xmount.h_morphing,
+                            e_XmountMorphError_None,
+                            "Unable to get info file content from morphing "
+                              "lib: ");
+
+#undef INITINFOFILE__GET_CONTENT
 
   return TRUE;
 }
 
 //! Load input / morphing libs
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int LoadLibs() {
   DIR *p_dir=NULL;
   struct dirent *p_dirent=NULL;
   int base_library_path_len=0;
   char *p_library_path=NULL;
   void *p_libxmount=NULL;
-  t_LibXmount_Morphing_GetApiVersion pfun_morphing_GetApiVersion;
-  t_LibXmount_Morphing_GetSupportedTypes pfun_morphing_GetSupportedTypes;
-  t_LibXmount_Morphing_GetFunctions pfun_morphing_GetFunctions;
   t_LibXmount_Output_GetApiVersion pfun_output_GetApiVersion;
   t_LibXmount_Output_GetSupportedFormats pfun_output_GetSupportedFormats;
   t_LibXmount_Output_GetFunctions pfun_output_GetFunctions;
   const char *p_supported_formats=NULL;
   const char *p_buf;
   uint32_t supported_formats_len=0;
   uint32_t input_lib_count=0;
-  pts_MorphingLib p_morphing_lib=NULL;
+  uint32_t morphing_lib_count=0;
   pts_OutputLib p_output_lib=NULL;
   te_XmountInput_Error input_ret=e_XmountInput_Error_None;
+  te_XmountMorphError morph_ret=e_XmountMorphError_None;
 
   LOG_DEBUG("Searching for xmount libraries in '%s'.\n",
             XMOUNT_LIBRARY_PATH);
 
   // Open lib dir
   p_dir=opendir(XMOUNT_LIBRARY_PATH);
   if(p_dir==NULL) {
     LOG_ERROR("Unable to access xmount library directory '%s'!\n",
               XMOUNT_LIBRARY_PATH);
     return FALSE;
   }
 
   // Construct base library path
   base_library_path_len=strlen(XMOUNT_LIBRARY_PATH);
   XMOUNT_STRSET(p_library_path,XMOUNT_LIBRARY_PATH);
   if(XMOUNT_LIBRARY_PATH[base_library_path_len]!='/') {
     base_library_path_len++;
     XMOUNT_STRAPP(p_library_path,"/");
   }
 
 #define LIBXMOUNT_LOAD(path) {                            \
   p_libxmount=dlopen(path,RTLD_NOW);                      \
   if(p_libxmount==NULL) {                                 \
     LOG_ERROR("Unable to load input library '%s': %s!\n", \
               path,                                       \
               dlerror());                                 \
     continue;                                             \
   }                                                       \
 }
 #define LIBXMOUNT_LOAD_SYMBOL(name,pfun) {                       \
   if((pfun=dlsym(p_libxmount,name))==NULL) {                     \
     LOG_ERROR("Unable to load symbol '%s' from library '%s'!\n", \
               name,                                              \
               p_library_path);                                   \
     dlclose(p_libxmount);                                        \
     p_libxmount=NULL;                                            \
     continue;                                                    \
   }                                                              \
 }
 
   // Loop over lib dir
   while((p_dirent=readdir(p_dir))!=NULL) {
     LOG_DEBUG("Trying to load '%s'\n",p_dirent->d_name);
 
     // Construct full path to found object
     p_library_path=realloc(p_library_path,
                            base_library_path_len+strlen(p_dirent->d_name)+1);
     if(p_library_path==NULL) {
       LOG_ERROR("Couldn't allocate memory!\n");
       exit(1);
     }
     strcpy(p_library_path+base_library_path_len,p_dirent->d_name);
 
     if(strncmp(p_dirent->d_name,
                XMOUNT_INPUT_LIBRARY_NAMING_SCHEME,
                strlen(XMOUNT_INPUT_LIBRARY_NAMING_SCHEME))==0)
     {
       // Found possible input lib. Try to load it
       input_ret=XmountInput_AddLibrary(glob_xmount.h_input,p_dirent->d_name);
       if(input_ret!=e_XmountInput_Error_None) {
         LOG_ERROR("Unable to add input library '%s': Error code %u!\n",
                   p_dirent->d_name,
                   input_ret);
         continue;
       }
-    } if(strncmp(p_dirent->d_name,"libxmount_morphing_",19)==0) {
+    } if(strncmp(p_dirent->d_name,
+                 XMOUNT_MORPHING_LIBRARY_NAMING_SCHEME,
+                 strlen(XMOUNT_MORPHING_LIBRARY_NAMING_SCHEME))==0)
+    {
       // Found possible morphing lib. Try to load it
-      LIBXMOUNT_LOAD(p_library_path);
-
-      // Load library symbols
-      LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetApiVersion",
-                            pfun_morphing_GetApiVersion);
-
-      // Check library's API version
-      if(pfun_morphing_GetApiVersion()!=LIBXMOUNT_MORPHING_API_VERSION) {
-        LOG_DEBUG("Failed! Wrong API version.\n");
-        LOG_ERROR("Unable to load morphing library '%s'. Wrong API version\n",
-                  p_library_path);
-        dlclose(p_libxmount);
-        continue;
-      }
-
-      LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetSupportedTypes",
-                            pfun_morphing_GetSupportedTypes);
-      LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetFunctions",
-                            pfun_morphing_GetFunctions);
-
-      // Construct new entry for our library list
-      XMOUNT_MALLOC(p_morphing_lib,pts_MorphingLib,sizeof(ts_MorphingLib));
-      // Initialize lib_functions structure to NULL
-      memset(&(p_morphing_lib->lib_functions),
-             0,
-             sizeof(ts_LibXmountMorphingFunctions));
-
-      // Set name and handle
-      XMOUNT_STRSET(p_morphing_lib->p_name,p_dirent->d_name);
-      p_morphing_lib->p_lib=p_libxmount;
-
-      // Get and set supported types
-      p_supported_formats=pfun_morphing_GetSupportedTypes();
-      supported_formats_len=0;
-      p_buf=p_supported_formats;
-      while(*p_buf!='\0') {
-        supported_formats_len+=(strlen(p_buf)+1);
-        p_buf+=(strlen(p_buf)+1);
-      }
-      supported_formats_len++;
-      XMOUNT_MALLOC(p_morphing_lib->p_supported_morphing_types,
-                    char*,
-                    supported_formats_len);
-      memcpy(p_morphing_lib->p_supported_morphing_types,
-             p_supported_formats,
-             supported_formats_len);
-
-      // Get, set and check lib_functions
-      pfun_morphing_GetFunctions(&(p_morphing_lib->lib_functions));
-      if(p_morphing_lib->lib_functions.CreateHandle==NULL ||
-         p_morphing_lib->lib_functions.DestroyHandle==NULL ||
-         p_morphing_lib->lib_functions.Morph==NULL ||
-         p_morphing_lib->lib_functions.Size==NULL ||
-         p_morphing_lib->lib_functions.Read==NULL ||
-         p_morphing_lib->lib_functions.OptionsHelp==NULL ||
-         p_morphing_lib->lib_functions.OptionsParse==NULL ||
-         p_morphing_lib->lib_functions.GetInfofileContent==NULL ||
-         p_morphing_lib->lib_functions.GetErrorMessage==NULL ||
-         p_morphing_lib->lib_functions.FreeBuffer==NULL)
-      {
-        LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
-                  p_dirent->d_name);
-        free(p_morphing_lib->p_supported_morphing_types);
-        free(p_morphing_lib->p_name);
-        free(p_morphing_lib);
-        dlclose(p_libxmount);
+      morph_ret=XmountMorphing_AddLibrary(glob_xmount.h_morphing,
+                                          p_dirent->d_name);
+      if(morph_ret!=e_XmountMorphError_None) {
+        LOG_ERROR("Unable to add morphing library '%s': Error code %u!\n",
+                  p_dirent->d_name,
+                  morph_ret);
         continue;
       }
-
-      // Add entry to the input library list
-      XMOUNT_REALLOC(glob_xmount.morphing.pp_libs,
-                     pts_MorphingLib*,
-                     sizeof(pts_MorphingLib)*
-                       (glob_xmount.morphing.libs_count+1));
-      glob_xmount.morphing.pp_libs[glob_xmount.morphing.libs_count++]=
-        p_morphing_lib;
-
-      LOG_DEBUG("Morphing library '%s' loaded successfully\n",p_dirent->d_name);
     } if(strncmp(p_dirent->d_name,"libxmount_output_",17)==0) {
       // Found possible output lib. Try to load it
       LIBXMOUNT_LOAD(p_library_path);
 
       // Load library symbols
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetApiVersion",
                             pfun_output_GetApiVersion);
 
       // Check library's API version
       if(pfun_output_GetApiVersion()!=LIBXMOUNT_OUTPUT_API_VERSION) {
         LOG_DEBUG("Failed! Wrong API version.\n");
         LOG_ERROR("Unable to load output library '%s'. Wrong API version\n",
                   p_library_path);
         dlclose(p_libxmount);
         continue;
       }
 
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetSupportedFormats",
                             pfun_output_GetSupportedFormats);
       LIBXMOUNT_LOAD_SYMBOL("LibXmount_Output_GetFunctions",
                             pfun_output_GetFunctions);
 
       // Construct new entry for our library list
       XMOUNT_MALLOC(p_output_lib,pts_OutputLib,sizeof(ts_OutputLib));
       // Initialize lib_functions structure to NULL
       memset(&(p_output_lib->lib_functions),
              0,
              sizeof(ts_LibXmountOutput_Functions));
 
       // Set name and handle
       XMOUNT_STRSET(p_output_lib->p_name,p_dirent->d_name);
       p_output_lib->p_lib=p_libxmount;
 
       // Get and set supported types
       p_supported_formats=pfun_output_GetSupportedFormats();
       supported_formats_len=0;
       p_buf=p_supported_formats;
       while(*p_buf!='\0') {
         supported_formats_len+=(strlen(p_buf)+1);
         p_buf+=(strlen(p_buf)+1);
       }
       supported_formats_len++;
       XMOUNT_MALLOC(p_output_lib->p_supported_output_formats,
                     char*,
                     supported_formats_len);
       memcpy(p_output_lib->p_supported_output_formats,
              p_supported_formats,
              supported_formats_len);
 
       // Get, set and check lib_functions
       pfun_output_GetFunctions(&(p_output_lib->lib_functions));
       if(p_output_lib->lib_functions.CreateHandle==NULL ||
          p_output_lib->lib_functions.DestroyHandle==NULL ||
          p_output_lib->lib_functions.Transform==NULL ||
          p_output_lib->lib_functions.Size==NULL ||
          p_output_lib->lib_functions.Read==NULL ||
          p_output_lib->lib_functions.Write==NULL ||
          p_output_lib->lib_functions.OptionsHelp==NULL ||
          p_output_lib->lib_functions.OptionsParse==NULL ||
          p_output_lib->lib_functions.GetInfofileContent==NULL ||
          p_output_lib->lib_functions.GetErrorMessage==NULL ||
          p_output_lib->lib_functions.FreeBuffer==NULL)
       {
         LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
                   p_dirent->d_name);
         free(p_output_lib->p_supported_output_formats);
         free(p_output_lib->p_name);
         free(p_output_lib);
         dlclose(p_libxmount);
         continue;
       }
 
       // Add entry to the input library list
       XMOUNT_REALLOC(glob_xmount.output.pp_libs,
                      pts_OutputLib*,
                      sizeof(pts_OutputLib)*
                        (glob_xmount.output.libs_count+1));
       glob_xmount.output.pp_libs[glob_xmount.output.libs_count++]=
         p_output_lib;
 
       LOG_DEBUG("Output library '%s' loaded successfully\n",p_dirent->d_name);
     } else {
       LOG_DEBUG("Ignoring '%s'.\n",p_dirent->d_name);
       continue;
     }
   }
 
 #undef LIBXMOUNT_LOAD_SYMBOL
 #undef LIBXMOUNT_LOAD
 
   // Get loaded library counts
   input_ret=XmountInput_GetLibraryCount(glob_xmount.h_input,&input_lib_count);
   if(input_ret!=e_XmountInput_Error_None) {
     LOG_ERROR("Unable to get input library count: Error code %u!\n",input_ret);
     return FALSE;
   }
+  morph_ret=XmountMorphing_GetLibraryCount(glob_xmount.h_morphing,
+                                           &morphing_lib_count);
+  if(morph_ret!=e_XmountMorphError_None) {
+    LOG_ERROR("Unable to get morphing library count: Error code %u!\n",
+              input_ret);
+    return FALSE;
+  }
 
   LOG_DEBUG("A total of %u input libs, %u morphing libs and %u output libs "
               "were loaded.\n",
             input_lib_count,
-            glob_xmount.morphing.libs_count,
+            morphing_lib_count,
             glob_xmount.output.libs_count);
 
   free(p_library_path);
   closedir(p_dir);
   return ((input_lib_count>0 &&
-           glob_xmount.morphing.libs_count>0 &&
+           morphing_lib_count>0 &&
            glob_xmount.output.libs_count>0) ? TRUE : FALSE);
 }
 
 //! Search an appropriate morphing lib for the specified morph type
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int FindMorphingLib() {
   char *p_buf;
 
   LOG_DEBUG("Trying to find suitable library for morph type '%s'.\n",
             glob_xmount.morphing.p_morph_type);
 
   // Loop over all loaded libs
   for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
     LOG_DEBUG("Checking morphing library %s\n",
               glob_xmount.morphing.pp_libs[i]->p_name);
     p_buf=glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types;
     while(*p_buf!='\0') {
       if(strcmp(p_buf,glob_xmount.morphing.p_morph_type)==0) {
         // Library supports morph type, set lib functions
         LOG_DEBUG("Morphing library '%s' pretends to handle that morph type.\n",
                   glob_xmount.morphing.pp_libs[i]->p_name);
         glob_xmount.morphing.p_functions=
           &(glob_xmount.morphing.pp_libs[i]->lib_functions);
         return TRUE;
       }
       p_buf+=(strlen(p_buf)+1);
     }
   }
 
   LOG_DEBUG("Couldn't find any suitable library.\n");
 
   // No library supporting morph type found
   return FALSE;
 }
 
 //! Search an appropriate output lib for the specified output format
 /*!
  * \return TRUE on success, FALSE on error
  */
 static int FindOutputLib() {
   char *p_buf;
 
   LOG_DEBUG("Trying to find suitable library for output format '%s'.\n",
             glob_xmount.output.p_output_format);
 
   // Loop over all loaded output libs
   for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
     LOG_DEBUG("Checking output library %s\n",
               glob_xmount.output.pp_libs[i]->p_name);
     p_buf=glob_xmount.output.pp_libs[i]->p_supported_output_formats;
     while(*p_buf!='\0') {
       if(strcmp(p_buf,glob_xmount.output.p_output_format)==0) {
         // Library supports output type, set lib functions
         LOG_DEBUG("Output library '%s' pretends to handle that output format.\n",
                   glob_xmount.output.pp_libs[i]->p_name);
         glob_xmount.output.p_functions=
           &(glob_xmount.output.pp_libs[i]->lib_functions);
         return TRUE;
       }
       p_buf+=(strlen(p_buf)+1);
     }
   }
 
   LOG_DEBUG("Couldn't find any suitable library.\n");
 
   // No library supporting output format found
   return FALSE;
 }
 
-static void InitResources() {
+static int InitResources() {
+  te_XmountInput_Error input_ret=e_XmountInput_Error_None;
+
   // Args
   glob_xmount.args.overwrite_cache=FALSE;
   glob_xmount.args.p_cache_file=NULL;
 
   // Input
-  glob_xmount.h_input=NULL;
+  input_ret=XmountInput_CreateHandle(&(glob_xmount.h_input));
+  if(input_ret!=e_XmountInput_Error_None) {
+    LOG_ERROR("Unable to create input handle: Error code %u!\n",input_ret);
+    return FALSE;
+  }
 
   // Morphing
   glob_xmount.morphing.libs_count=0;
   glob_xmount.morphing.pp_libs=NULL;
   glob_xmount.morphing.p_morph_type=NULL;
   glob_xmount.morphing.lib_params_count=0;
   glob_xmount.morphing.pp_lib_params=NULL;
   glob_xmount.morphing.p_handle=NULL;
   glob_xmount.morphing.p_functions=NULL;
   glob_xmount.morphing.input_image_functions.ImageCount=
     &LibXmount_Morphing_ImageCount;
   glob_xmount.morphing.input_image_functions.Size=&LibXmount_Morphing_Size;
   glob_xmount.morphing.input_image_functions.Read=&LibXmount_Morphing_Read;
 
   // Cache
   glob_xmount.h_cache=NULL;
 
   // Output
   glob_xmount.output.libs_count=0;
   glob_xmount.output.pp_libs=NULL;
   glob_xmount.output.p_output_format=NULL;
   glob_xmount.output.lib_params_count=0;
   glob_xmount.output.pp_lib_params=NULL;
   glob_xmount.output.p_handle=NULL;
   glob_xmount.output.p_functions=NULL;
   glob_xmount.output.input_functions.Size=&LibXmount_Output_Size;
   glob_xmount.output.input_functions.Read=&LibXmount_Output_Read;
   glob_xmount.output.input_functions.Write=&LibXmount_Output_Write;
   glob_xmount.output.image_size=0;
   glob_xmount.output.writable=FALSE;
   glob_xmount.output.p_virtual_image_path=NULL;
   glob_xmount.output.p_info_path=NULL;
   glob_xmount.output.p_info_file=NULL;
 
   // Misc data
   glob_xmount.debug=FALSE;
   glob_xmount.may_set_fuse_allow_other=FALSE;
   glob_xmount.fuse_argc=0;
   glob_xmount.pp_fuse_argv=NULL;
   glob_xmount.p_mountpoint=NULL;
   glob_xmount.p_first_input_image_name=NULL;
-  // TODO: Move where needed
-  //glob_xmount.image_hash_lo=0;
-  //glob_xmount.image_hash_hi=0;
+  glob_xmount.image_hash_lo=0;
+  glob_xmount.image_hash_hi=0;
+
+  return TRUE;
 }
 
 /*
  * FreeResources
  */
 static void FreeResources() {
   int ret;
   te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
   te_XmountInput_Error input_ret=e_XmountInput_Error_None;
 
   LOG_DEBUG("Freeing all resources\n");
 
   // Misc
   if(glob_xmount.p_first_input_image_name!=NULL) {
     XMOUNT_FREE(glob_xmount.p_first_input_image_name);
   }
   if(glob_xmount.pp_fuse_argv!=NULL) {
     for(int i=0;i<glob_xmount.fuse_argc;i++) free(glob_xmount.pp_fuse_argv[i]);
     free(glob_xmount.pp_fuse_argv);
   }
   if(glob_xmount.p_mountpoint!=NULL) free(glob_xmount.p_mountpoint);
 
   // Output
   if(glob_xmount.output.p_functions!=NULL) {
     if(glob_xmount.output.p_handle!=NULL) {
       // Destroy output handle
       ret=glob_xmount.output.p_functions->
             DestroyHandle(&(glob_xmount.output.p_handle));
       if(ret!=0) {
         LOG_ERROR("Unable to destroy output handle: %s!\n",
                   glob_xmount.output.p_functions->GetErrorMessage(ret));
       }
     }
   }
   if(glob_xmount.output.pp_lib_params!=NULL) {
     for(uint32_t i=0;i<glob_xmount.output.lib_params_count;i++)
       free(glob_xmount.output.pp_lib_params[i]);
     free(glob_xmount.output.pp_lib_params);
   }
   if(glob_xmount.output.p_output_format!=NULL)
     free(glob_xmount.output.p_output_format);
   if(glob_xmount.output.pp_libs!=NULL) {
     // Unload output libs
     for(uint32_t i=0;i<glob_xmount.output.libs_count;i++) {
       if(glob_xmount.output.pp_libs[i]==NULL) continue;
       if(glob_xmount.output.pp_libs[i]->p_supported_output_formats!=NULL)
         free(glob_xmount.output.pp_libs[i]->p_supported_output_formats);
       if(glob_xmount.output.pp_libs[i]->p_lib!=NULL)
         dlclose(glob_xmount.output.pp_libs[i]->p_lib);
       if(glob_xmount.output.pp_libs[i]->p_name!=NULL)
         free(glob_xmount.output.pp_libs[i]->p_name);
       free(glob_xmount.output.pp_libs[i]);
     }
     free(glob_xmount.output.pp_libs);
   }
   if(glob_xmount.output.p_info_path!=NULL)
     free(glob_xmount.output.p_info_path);
   if(glob_xmount.output.p_info_file!=NULL)
     free(glob_xmount.output.p_info_file);
   if(glob_xmount.output.p_virtual_image_path!=NULL)
     free(glob_xmount.output.p_virtual_image_path);
 
   // Cache
   if(glob_xmount.h_cache!=NULL) {
     cache_ret=XmountCache_Close(&(glob_xmount.h_cache));
     if(cache_ret!=e_XmountCache_Error_None) {
       LOG_ERROR("Unable to close cache file: Error code %u: Ignoring!\n",
                 cache_ret);
     }
   }
 
   // Morphing
   if(glob_xmount.morphing.p_functions!=NULL) {
     if(glob_xmount.morphing.p_handle!=NULL) {
       // Destroy morphing handle
       ret=glob_xmount.morphing.p_functions->
             DestroyHandle(&(glob_xmount.morphing.p_handle));
       if(ret!=0) {
         LOG_ERROR("Unable to destroy morphing handle: %s!\n",
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
       }
     }
   }
   if(glob_xmount.morphing.pp_lib_params!=NULL) {
     for(uint32_t i=0;i<glob_xmount.morphing.lib_params_count;i++)
       free(glob_xmount.morphing.pp_lib_params[i]);
     free(glob_xmount.morphing.pp_lib_params);
   }
   if(glob_xmount.morphing.p_morph_type!=NULL)
     free(glob_xmount.morphing.p_morph_type);
   if(glob_xmount.morphing.pp_libs!=NULL) {
     // Unload morphing libs
     for(uint32_t i=0;i<glob_xmount.morphing.libs_count;i++) {
       if(glob_xmount.morphing.pp_libs[i]==NULL) continue;
       if(glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types!=NULL)
         free(glob_xmount.morphing.pp_libs[i]->p_supported_morphing_types);
       if(glob_xmount.morphing.pp_libs[i]->p_lib!=NULL)
         dlclose(glob_xmount.morphing.pp_libs[i]->p_lib);
       if(glob_xmount.morphing.pp_libs[i]->p_name!=NULL)
         free(glob_xmount.morphing.pp_libs[i]->p_name);
       free(glob_xmount.morphing.pp_libs[i]);
     }
     free(glob_xmount.morphing.pp_libs);
   }
 
   // Input
   // Just in case close was not already called, call it now
   input_ret=XmountInput_Close(glob_xmount.h_input);
   if(input_ret!=e_XmountInput_Error_None) {
     LOG_ERROR("Unable to close input image(s): Error code %u: Ignoring!\n",
               input_ret);
   }
   input_ret=XmountInput_DestroyHandle(&(glob_xmount.h_input));
   if(input_ret!=e_XmountInput_Error_None) {
     LOG_ERROR("Unable to destroy input handle: Error code %u: Ignoring!\n",
               input_ret);
   }
 
   // Args
   if(glob_xmount.args.p_cache_file!=NULL) {
     XMOUNT_FREE(glob_xmount.args.p_cache_file);
   }
 
   // Before we return, initialize everything in case ReleaseResources would be
   // called again.
   InitResources();
 }
 
 /*******************************************************************************
  * LibXmount_Morphing function implementation
  ******************************************************************************/
 //! Function to get the amount of input images
 /*!
  * \param p_count Count of input images
  * \return 0 on success
  */
 static int LibXmount_Morphing_ImageCount(uint64_t *p_count) {
   te_XmountInput_Error input_ret=e_XmountInput_Error_None;
 
   input_ret=XmountInput_GetImageCount(glob_xmount.h_input,p_count);
   if(input_ret!=e_XmountInput_Error_None) {
     LOG_ERROR("Unable to get input image count: Error code %u!\n",input_ret);
     return -EIO;
   }
 
   return 0;
 }
 
 //! Function to get the size of the morphed data
 /*!
  * \param image Image number
  * \param p_size Pointer to store input image's size to
  * \return 0 on success
  */
 static int LibXmount_Morphing_Size(uint64_t image, uint64_t *p_size) {
   te_XmountInput_Error input_ret=e_XmountInput_Error_None;
 
   input_ret=XmountInput_GetSize(glob_xmount.h_input,image,p_size);
   if(input_ret!=e_XmountInput_Error_None) {
     LOG_ERROR("Unable to get size of input image %" PRIu64 ": Error code %u!\n",
               image,
               input_ret);
     return -EIO;
   }
 
   return 0;
 }
 
 //! Function to read data from input image
 /*!
  * \param image Image number
  * \param p_buf Buffer to store read data to
  * \param offset Position at which to start reading
  * \param count Amount of bytes to read
  * \param p_read Number of read bytes on success
  * \return 0 on success or negated error code on error
  */
 static int LibXmount_Morphing_Read(uint64_t image,
                                    char *p_buf,
                                    off_t offset,
                                    size_t count,
                                    size_t *p_read)
 {
   te_XmountInput_Error input_ret=e_XmountInput_Error_None;
 
   input_ret=XmountInput_ReadData(glob_xmount.h_input,
                                  image,
                                  p_buf,
                                  offset,
                                  count,
                                  p_read);
   if(input_ret!=e_XmountInput_Error_None) {
     LOG_ERROR("Unable to read data of input image %" PRIu64
                 ": Error code %u!\n",
               image,
               input_ret);
     return -EIO;
   }
 
   return 0;
 }
 
 /*******************************************************************************
  * LibXmount_Output function implementation
  ******************************************************************************/
 //! Function to get the size of the morphed image
 /*!
  * \param p_size Pointer to store morphed image's size to
  * \return 0 on success
  */
 static int LibXmount_Output_Size(uint64_t *p_size) {
   int ret=0;
 
   ret=GetMorphedImageSize(p_size);
 
   return ret==TRUE ? 0 : ret;
 }
 
 //! Function to read data from the morphed image
 /*!
  * \param p_buf Buffer to store read data to
  * \param offset Position at which to start reading
  * \param count Amount of bytes to read
  * \param p_read Number of read bytes on success
  * \return 0 on success or negated error code on error
  */
 static int LibXmount_Output_Read(char *p_buf,
                                  off_t offset,
                                  size_t count,
                                  size_t *p_read)
 {
   return ReadMorphedImageData(p_buf,offset,count,p_read);
 }
 
 //! Function to write data to the morphed image
 /*!
  * \param p_buf Buffer with data to write
  * \param offset Position at which to start writing
  * \param count Amount of bytes to write
  * \param p_written Number of written bytes on success
  * \return 0 on success or negated error code on error
  */
 static int LibXmount_Output_Write(char *p_buf,
                                   off_t offset,
                                   size_t count,
                                   size_t *p_written)
 {
   return WriteMorphedImageData(p_buf,offset,count,p_written);
 }
 
 /*******************************************************************************
  * Main
  ******************************************************************************/
 int main(int argc, char *argv[]) {
+  uint64_t input_image_count=0;
   struct stat file_stat;
   int ret;
   int fuse_ret;
   char *p_err_msg;
+  te_XmountInput_Error input_ret=e_XmountInput_Error_None;
   te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   // Set implemented FUSE functions
   struct fuse_operations xmount_operations = {
     //.access=FuseAccess,
     .getattr=Xmount_FuseGetAttr,
     .mkdir=Xmount_FuseMkDir,
     .mknod=Xmount_FuseMkNod,
     .open=Xmount_FuseOpen,
     .readdir=Xmount_FuseReadDir,
     .read=Xmount_FuseRead,
     .rename=Xmount_FuseRename,
     .rmdir=Xmount_FuseRmDir,
     //.statfs=FuseStatFs,
     .unlink=Xmount_FuseUnlink,
     .write=Xmount_FuseWrite
   };
 
   // Disable std output / input buffering
   setbuf(stdout,NULL);
   setbuf(stderr,NULL);
 
   // Init glob_xmount
-  InitResources();
+  if(InitResources()==FALSE) {
+    LOG_ERROR("Unable to initialize internal resources!\n");
+    return 1;
+  }
 
   // Load input, morphing and output libs
   if(!LoadLibs()) {
     LOG_ERROR("Unable to load any libraries!\n")
     return 1;
   }
 
   // Check FUSE settings
   CheckFuseSettings();
 
   // Parse command line options
   if(ParseCmdLine(argc,argv)!=TRUE) {
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
 
   // Check command line options
-  if(glob_xmount.input.images_count==0) {
+  input_ret=XmountInput_GetImageCount(glob_xmount.h_input,&input_image_count);
+  if(input_ret!=e_XmountInput_Error_None) {
+    LOG_ERROR("Unable to get input image count: Error code %u!\n",input_ret);
+    return 1;
+  }
+  if(input_image_count==0) {
     LOG_ERROR("No --in command line option specified!\n")
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
   if(glob_xmount.fuse_argc<2) {
     LOG_ERROR("Couldn't parse command line options!\n")
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
   if(glob_xmount.morphing.p_morph_type==NULL) {
     XMOUNT_STRSET(glob_xmount.morphing.p_morph_type,"combine");
   }
   // TODO: Add default output image format here
 
   // Check if mountpoint is a valid dir
   if(stat(glob_xmount.p_mountpoint,&file_stat)!=0) {
     LOG_ERROR("Unable to stat mount point '%s'!\n",glob_xmount.p_mountpoint);
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
   if(!S_ISDIR(file_stat.st_mode)) {
     LOG_ERROR("Mount point '%s' is not a directory!\n",
               glob_xmount.p_mountpoint);
     PrintUsage(argv[0]);
     FreeResources();
     return 1;
   }
 
   if(glob_xmount.debug==TRUE) {
     LOG_DEBUG("Options passed to FUSE: ")
     for(int i=0;i<glob_xmount.fuse_argc;i++) {
       printf("%s ",glob_xmount.pp_fuse_argv[i]);
     }
     printf("\n");
   }
 
   // Init mutexes
   pthread_mutex_init(&(glob_xmount.mutex_image_rw),NULL);
   pthread_mutex_init(&(glob_xmount.mutex_info_read),NULL);
 
   // Load input images
-  for(uint64_t i=0;i<glob_xmount.input.images_count;i++) {
-    if(glob_xmount.debug==TRUE) {
-      if(glob_xmount.input.pp_images[i]->files_count==1) {
-        LOG_DEBUG("Loading image file \"%s\"...\n",
-                  glob_xmount.input.pp_images[i]->pp_files[0])
-      } else {
-        LOG_DEBUG("Loading image files \"%s .. %s\"...\n",
-                  glob_xmount.input.pp_images[i]->pp_files[0],
-                  glob_xmount.input.pp_images[i]->
-                    pp_files[glob_xmount.input.pp_images[i]->files_count-1])
-      }
-    }
-
-    // Find input lib
-    if(!FindInputLib(glob_xmount.input.pp_images[i])) {
-      LOG_ERROR("Unknown input image type '%s' for input image '%s'!\n",
-                glob_xmount.input.pp_images[i]->p_type,
-                glob_xmount.input.pp_images[i]->pp_files[0])
-      PrintUsage(argv[0]);
-      FreeResources();
-      return 1;
-    }
-
-    // Init input image handle
-    ret=glob_xmount.input.pp_images[i]->p_functions->
-          CreateHandle(&(glob_xmount.input.pp_images[i]->p_handle),
-                       glob_xmount.input.pp_images[i]->p_type,
-                       glob_xmount.debug);
-    if(ret!=0) {
-      LOG_ERROR("Unable to init input handle for input image '%s': %s!\n",
-                glob_xmount.input.pp_images[i]->pp_files[0],
-                glob_xmount.input.pp_images[i]->p_functions->
-                  GetErrorMessage(ret));
-      FreeResources();
-      return 1;
-    }
-
-    // Parse input lib specific options
-    if(glob_xmount.input.pp_lib_params!=NULL) {
-      ret=glob_xmount.input.pp_images[i]->p_functions->
-            OptionsParse(glob_xmount.input.pp_images[i]->p_handle,
-                         glob_xmount.input.lib_params_count,
-                         glob_xmount.input.pp_lib_params,
-                         (const char**)&p_err_msg);
-      if(ret!=0) {
-        if(p_err_msg!=NULL) {
-          LOG_ERROR("Unable to parse input library specific options for image "
-                      "'%s': %s: %s!\n",
-                    glob_xmount.input.pp_images[i]->pp_files[0],
-                    glob_xmount.input.pp_images[i]->p_functions->
-                      GetErrorMessage(ret),
-                    p_err_msg);
-          glob_xmount.input.pp_images[i]->p_functions->FreeBuffer(p_err_msg);
-          FreeResources();
-          return 1;
-        } else {
-          LOG_ERROR("Unable to parse input library specific options for image "
-                      "'%s': %s!\n",
-                    glob_xmount.input.pp_images[i]->pp_files[0],
-                    glob_xmount.input.pp_images[i]->p_functions->
-                      GetErrorMessage(ret));
-          FreeResources();
-          return 1;
-        }
-      }
-    }
-
-    // Open input image
-    ret=
-      glob_xmount.input.pp_images[i]->
-        p_functions->
-          Open(glob_xmount.input.pp_images[i]->p_handle,
-               (const char**)(glob_xmount.input.pp_images[i]->pp_files),
-               glob_xmount.input.pp_images[i]->files_count);
-    if(ret!=0) {
-      LOG_ERROR("Unable to open input image file '%s': %s!\n",
-                glob_xmount.input.pp_images[i]->pp_files[0],
-                glob_xmount.input.pp_images[i]->p_functions->
-                  GetErrorMessage(ret));
-      FreeResources();
-      return 1;
-    }
-
-    // Determine input image size
-    ret=glob_xmount.input.pp_images[i]->
-      p_functions->
-        Size(glob_xmount.input.pp_images[i]->p_handle,
-             &(glob_xmount.input.pp_images[i]->size));
-    if(ret!=0) {
-      LOG_ERROR("Unable to determine size of input image '%s': %s!\n",
-                glob_xmount.input.pp_images[i]->pp_files[0],
-                glob_xmount.input.pp_images[i]->
-                  p_functions->GetErrorMessage(ret));
-      FreeResources();
-      return 1;
-    }
-
-    // If an offset was specified, check it against offset and change size
-    if(glob_xmount.input.image_offset!=0) {
-      if(glob_xmount.input.image_offset>glob_xmount.input.pp_images[i]->size) {
-        LOG_ERROR("The specified offset is larger than the size of the input "
-                    "image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
-                  glob_xmount.input.pp_images[i]->pp_files[0],
-                  glob_xmount.input.image_offset,
-                  glob_xmount.input.pp_images[i]->size);
-        FreeResources();
-        return 1;
-      }
-      glob_xmount.input.pp_images[i]->size-=glob_xmount.input.image_offset;
-    }
-
-    // If a size limit was specified, check it and change size
-    if(glob_xmount.input.image_size_limit!=0) {
-      if(glob_xmount.input.pp_images[i]->size<
-           glob_xmount.input.image_size_limit)
-      {
-        LOG_ERROR("The specified size limit is larger than the size of the "
-                    "input image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
-                  glob_xmount.input.pp_images[i]->pp_files[0],
-                  glob_xmount.input.image_size_limit,
-                  glob_xmount.input.pp_images[i]->size);
-        FreeResources();
-        return 1;
-      }
-      glob_xmount.input.pp_images[i]->size=glob_xmount.input.image_size_limit;
-    }
-
-    LOG_DEBUG("Input image loaded successfully\n")
+  input_ret=XmountInput_Open(glob_xmount.h_input);
+  if(input_ret!=e_XmountInput_Error_None) {
+    LOG_ERROR("Failed opening input image(s): Error code %u!\n",input_ret);
+    FreeResources();
+    return 1;
   }
 
   // Find morphing lib
   if(FindMorphingLib()!=TRUE) {
     LOG_ERROR("Unable to find a library supporting the morphing type '%s'!\n",
               glob_xmount.morphing.p_morph_type);
     FreeResources();
     return 1;
   }
 
   // Init morphing
   ret=glob_xmount.morphing.p_functions->
         CreateHandle(&glob_xmount.morphing.p_handle,
                      glob_xmount.morphing.p_morph_type,
                      glob_xmount.debug);
   if(ret!=0) {
     LOG_ERROR("Unable to create morphing handle: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Parse morphing lib specific options
   if(glob_xmount.morphing.pp_lib_params!=NULL) {
     p_err_msg=NULL;
     ret=glob_xmount.morphing.p_functions->
           OptionsParse(glob_xmount.morphing.p_handle,
                        glob_xmount.morphing.lib_params_count,
                        glob_xmount.morphing.pp_lib_params,
                        (const char**)&p_err_msg);
     if(ret!=0) {
       if(p_err_msg!=NULL) {
         LOG_ERROR("Unable to parse morphing library specific options: %s: %s!\n",
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret),
                   p_err_msg);
         glob_xmount.morphing.p_functions->FreeBuffer(p_err_msg);
         FreeResources();
         return 1;
       } else {
         LOG_ERROR("Unable to parse morphing library specific options: %s!\n",
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
         FreeResources();
         return 1;
       }
     }
   }
 
   // Morph image
   ret=glob_xmount.morphing.p_functions->
         Morph(glob_xmount.morphing.p_handle,
               &(glob_xmount.morphing.input_image_functions));
   if(ret!=0) {
     LOG_ERROR("Unable to start morphing: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Init random generator
   srand(time(NULL));
 
   // Calculate partial MD5 hash of input image file
-  if(CalculateInputImageHash(&(glob_xmount.input.image_hash_lo),
-                             &(glob_xmount.input.image_hash_hi))==FALSE)
+  if(CalculateInputImageHash(&(glob_xmount.image_hash_lo),
+                             &(glob_xmount.image_hash_hi))==FALSE)
   {
     LOG_ERROR("Couldn't calculate partial hash of morphed image!\n")
     return 1;
   }
 
   if(glob_xmount.debug==TRUE) {
     LOG_DEBUG("Partial MD5 hash of morphed image: ")
     for(int i=0;i<8;i++)
-      printf("%02hhx",*(((char*)(&(glob_xmount.input.image_hash_lo)))+i));
+      printf("%02hhx",*(((char*)(&(glob_xmount.image_hash_lo)))+i));
     for(int i=0;i<8;i++)
-      printf("%02hhx",*(((char*)(&(glob_xmount.input.image_hash_hi)))+i));
+      printf("%02hhx",*(((char*)(&(glob_xmount.image_hash_hi)))+i));
     printf("\n");
   }
 
-  if(!ExtractOutputFileNames(glob_xmount.input.pp_images[0]->pp_files[0])) {
+  if(!ExtractOutputFileNames(glob_xmount.p_first_input_image_name)) {
     LOG_ERROR("Couldn't extract virtual file names!\n");
     FreeResources();
     return 1;
   }
   LOG_DEBUG("Virtual file names extracted successfully\n")
 
   // Find output lib
   if(FindOutputLib()!=TRUE) {
     LOG_ERROR("Unable to find a library supporting the output format '%s'!\n",
               glob_xmount.output.p_output_format);
     FreeResources();
     return 1;
   }
 
   // Init output
   ret=glob_xmount.output.p_functions->
         CreateHandle(&glob_xmount.output.p_handle,
                      glob_xmount.output.p_output_format,
                      glob_xmount.debug);
   if(ret!=0) {
     LOG_ERROR("Unable to create output handle: %s!\n",
               glob_xmount.output.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Parse output lib specific options
   if(glob_xmount.output.pp_lib_params!=NULL) {
     p_err_msg=NULL;
     ret=glob_xmount.output.p_functions->
           OptionsParse(glob_xmount.output.p_handle,
                        glob_xmount.output.lib_params_count,
                        glob_xmount.output.pp_lib_params,
                        (const char**)&p_err_msg);
     if(ret!=0) {
       if(p_err_msg!=NULL) {
         LOG_ERROR("Unable to parse output library specific options: %s: %s!\n",
                   glob_xmount.output.p_functions->GetErrorMessage(ret),
                   p_err_msg);
         glob_xmount.output.p_functions->FreeBuffer(p_err_msg);
         FreeResources();
         return 1;
       } else {
         LOG_ERROR("Unable to parse output library specific options: %s!\n",
                   glob_xmount.output.p_functions->GetErrorMessage(ret));
         FreeResources();
         return 1;
       }
     }
   }
 
   // Morph image
   ret=glob_xmount.morphing.p_functions->
         Morph(glob_xmount.morphing.p_handle,
               &(glob_xmount.morphing.input_image_functions));
   if(ret!=0) {
     LOG_ERROR("Unable to start morphing: %s!\n",
               glob_xmount.morphing.p_functions->GetErrorMessage(ret));
     FreeResources();
     return 1;
   }
 
   // Gather infos for info file
   if(!InitInfoFile()) {
     LOG_ERROR("Couldn't gather infos for virtual image info file!\n")
     FreeResources();
     return 1;
   }
   LOG_DEBUG("Virtual image info file build successfully\n")
 
   if(glob_xmount.output.writable) {
     // Init cache file and cache file block index
     // TODO: Add cache file creration / opening
 /*
     if(glob_xmount.args.overwrite_cache==TRUE) {
       cache_ret=XmountCache_Create(&(glob_xmount.h_cache),
                                    glob_xmount.args.p_cache_file,
 
 
     } else {
       cache_ret=XmountCache_Open
     }
 
 
     te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
     if(!InitCacheFile()) {
       LOG_ERROR("Couldn't initialize cache file!\n")
       FreeResources();
       return 1;
     }
 */
     LOG_DEBUG("Cache file initialized successfully\n")
   }
 
   // Call fuse_main to do the fuse magic
   fuse_ret=fuse_main(glob_xmount.fuse_argc,
                      glob_xmount.pp_fuse_argv,
                      &xmount_operations,
                      NULL);
 
   // Destroy mutexes
   pthread_mutex_destroy(&(glob_xmount.mutex_image_rw));
   pthread_mutex_destroy(&(glob_xmount.mutex_info_read));
 
   // Free allocated memory
   FreeResources();
   return fuse_ret;
 }
diff --git a/src/xmount.h b/src/xmount.h
index 829f789..59fb28a 100755
--- a/src/xmount.h
+++ b/src/xmount.h
@@ -1,95 +1,99 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * xmount is a small tool to "fuse mount" various image formats and enable      *
 * virtual write access.                                                        *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #ifndef XMOUNT_H
 #define XMOUNT_H
 
 #include "xmount_input.h"
 #include "xmount_morphing.h"
 #include "xmount_cache.h"
 #include "xmount_output.h"
 
 #undef FALSE
 #undef TRUE
 #define FALSE 0
 #define TRUE 1
 
 /*
  * Constants
  */
 #define IMAGE_INFO_INPUT_HEADER \
   "------> The following values are supplied by the used input library(ies) " \
     "<------\n"
 #define IMAGE_INFO_MORPHING_HEADER \
   "\n------> The following values are supplied by the used morphing library " \
     "<------\n\n"
 
 /*******************************************************************************
  * Xmount specific structures
  ******************************************************************************/
 //! Structure containing xmount arguments
 typedef struct s_XmountArgs {
   //! Cache file
   char *p_cache_file;
   //! If set to 1, overwrite any existing cache file
   uint8_t overwrite_cache;
 } ts_XmountArgs;
 
 //! Structure containing global xmount runtime infos
 typedef struct s_XmountData {
   //! Parsed xmount arguments
   ts_XmountArgs args;
   //! Input image related data
   pts_XmountInputHandle h_input;
   //! Morphing related data
-  ts_MorphingData morphing;
+  pts_XmountMorphHandle h_morphing;
   //! Cache file handle
   pts_XmountCacheHandle h_cache;
   //! Output image related data
   ts_OutputData output;
   //! Enable debug output
   uint8_t debug;
   //! Set if we are allowed to set fuse's allow_other option
   uint8_t may_set_fuse_allow_other;
   //! Argv for FUSE
   int fuse_argc;
   //! Argv for FUSE
   char **pp_fuse_argv;
   //! Mount point
   char *p_mountpoint;
   //! First input image's path/name
   char *p_first_input_image_name;
+  //! MD5 hash of partial input image (lower 64 bit) (after morph)
+  uint64_t image_hash_lo;
+  //! MD5 hash of partial input image (higher 64 bit) (after morph)
+  uint64_t image_hash_hi;
   //! Mutex to control concurrent read & write access on output image
   pthread_mutex_t mutex_image_rw;
   //! Mutex to control concurrent read access on info file
   pthread_mutex_t mutex_info_read;
 } ts_XmountData;
 
 /*******************************************************************************
  * Global vars
  ******************************************************************************/
 //! Struct that contains various runtime configuration options
 ts_XmountData glob_xmount;
 
 /*******************************************************************************
  * Xmount functions
  ******************************************************************************/
 
 #endif // XMOUNT_H
diff --git a/src/xmount_fuse.c b/src/xmount_fuse.c
index 9d22d22..d57b5ac 100644
--- a/src/xmount_fuse.c
+++ b/src/xmount_fuse.c
@@ -1,366 +1,370 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
 #include <errno.h>
+#include <sys/types.h>
 
 #include "xmount_fuse.h"
 #include "xmount.h"
 
 #define LOG_WARNING(...) {            \
   LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
 }
 #define LOG_ERROR(...) {            \
   LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
 }
 #define LOG_DEBUG(...) {                              \
   LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
 }
 
 /*******************************************************************************
  * FUSE function implementation
  ******************************************************************************/
 //! FUSE access implementation
 /*!
  * \param p_path Path of file to get attributes from
  * \param perm Requested permissisons
  * \return 0 on success, negated error code on error
  */
 /*
 int Xmount_FuseAccess(const char *path, int perm) {
   // TODO: Implement propper file permission handling
   // http://www.cs.cf.ac.uk/Dave/C/node20.html
   // Values for the second argument to access.
   // These may be OR'd together.
   //#define	R_OK	4		// Test for read permission.
   //#define	W_OK	2		// Test for write permission.
   //#define	X_OK	1		// Test for execute permission.
   //#define	F_OK	0		// Test for existence.
   return 0;
 }
 */
 
 //! FUSE getattr implementation
 /*!
  * \param p_path Path of file to get attributes from
  * \param p_stat Pointer to stat structure to save attributes to
  * \return 0 on success, negated error code on error
  */
 int Xmount_FuseGetAttr(const char *p_path, struct stat *p_stat) {
   memset(p_stat,0,sizeof(struct stat));
   if(strcmp(p_path,"/")==0) {
     // Attributes of mountpoint
     p_stat->st_mode=S_IFDIR | 0777;
     p_stat->st_nlink=2;
   } else if(strcmp(p_path,glob_xmount.output.p_virtual_image_path)==0) {
     // Attributes of virtual image
     if(!glob_xmount.output.writable) p_stat->st_mode=S_IFREG | 0444;
     else p_stat->st_mode=S_IFREG | 0666;
     p_stat->st_nlink=1;
     // Get output image file size
     if(!GetOutputImageSize((uint64_t*)&(p_stat->st_size))) {
       LOG_ERROR("Couldn't get image size!\n");
       return -ENOENT;
     }
     // Make sure virtual image seems to be fully allocated (not sparse file).
     p_stat->st_blocks=p_stat->st_size/512;
     if(p_stat->st_size%512!=0) p_stat->st_blocks++;
   } else if(strcmp(p_path,glob_xmount.output.p_info_path)==0) {
     // Attributes of virtual image info file
     p_stat->st_mode=S_IFREG | 0444;
     p_stat->st_nlink=1;
     // Get virtual image info file size
     if(glob_xmount.output.p_info_file!=NULL) {
       p_stat->st_size=strlen(glob_xmount.output.p_info_file);
     } else p_stat->st_size=0;
   } else return -ENOENT;
   // Set uid and gid of all files to uid and gid of current process
   p_stat->st_uid=getuid();
   p_stat->st_gid=getgid();
   return 0;
 }
 
 //! FUSE mkdir implementation
 /*!
  * \param p_path Directory path
  * \param mode Directory permissions
  * \return 0 on success, negated error code on error
  */
 int Xmount_FuseMkDir(const char *p_path, mode_t mode) {
   // TODO: Implement
   LOG_ERROR("Attempt to create directory \"%s\" "
             "on read-only filesystem!\n",p_path)
   return -1;
 }
 
 //! FUSE create implementation.
 /*!
  * \param p_path File to create
  * \param mode File mode
  * \param dev ??? but not used
  * \return 0 on success, negated error code on error
  */
 int Xmount_FuseMkNod(const char *p_path, mode_t mode, dev_t dev) {
   // TODO: Implement
   LOG_ERROR("Attempt to create illegal file \"%s\"\n",p_path)
   return -1;
 }
 
 //! FUSE readdir implementation
 /*!
  * \param p_path Path from where files should be listed
  * \param p_buf Buffer to write file entrys to
  * \param filler Function to write dir entrys to buffer
  * \param offset ??? but not used
  * \param p_fi File info struct
  * \return 0 on success, negated error code on error
  */
 int Xmount_FuseReadDir(const char *p_path,
                        void *p_buf,
                        fuse_fill_dir_t filler,
                        off_t offset,
                        struct fuse_file_info *p_fi)
 {
   // Ignore some params
   (void)offset;
   (void)p_fi;
 
   if(strcmp(p_path,"/")==0) {
     // Add std . and .. entrys
     filler(p_buf,".",NULL,0);
     filler(p_buf,"..",NULL,0);
     // Add our virtual files (p+1 to ignore starting "/")
     filler(p_buf,glob_xmount.output.p_virtual_image_path+1,NULL,0);
     filler(p_buf,glob_xmount.output.p_info_path+1,NULL,0);
   } else return -ENOENT;
 
   return 0;
 }
 
 //! FUSE open implementation
 /*!
  * \param p_path Path to file to open
  * \param p_fi File info struct
  * \return 0 on success, negated error code on error
  */
 int Xmount_FuseOpen(const char *p_path, struct fuse_file_info *p_fi) {
 
 #define CHECK_OPEN_PERMS() {                                              \
   if(!glob_xmount.output.writable && (p_fi->flags & 3)!=O_RDONLY) {       \
     LOG_DEBUG("Attempt to open the read-only file \"%s\" for writing.\n", \
               p_path)                                                     \
     return -EACCES;                                                       \
   }                                                                       \
   return 0;                                                               \
 }
 
   if(strcmp(p_path,glob_xmount.output.p_virtual_image_path)==0 ||
      strcmp(p_path,glob_xmount.output.p_info_path)==0)
   {
     CHECK_OPEN_PERMS();
   }
 
 #undef CHECK_OPEN_PERMS
 
   LOG_DEBUG("Attempt to open inexistant file \"%s\".\n",p_path);
   return -ENOENT;
 }
 
 //! FUSE read implementation
 /*!
  * \param p_path Path (relative to mount folder) of file to read data from
  * \param p_buf Pre-allocated buffer where read data should be written to
  * \param size Number of bytes to read
  * \param offset Offset to start reading at
  * \param p_fi: File info struct
  * \return Read bytes on success, negated error code on error
  */
 int Xmount_FuseRead(const char *p_path,
                     char *p_buf,
                     size_t size,
                     off_t offset,
                     struct fuse_file_info *p_fi)
 {
   (void)p_fi;
 
   int ret;
   uint64_t len;
 
 #define READ_MEM_FILE(filebuf,filesize,filetypestr,mutex) {                    \
   len=filesize;                                                                \
   if(offset<len) {                                                             \
     if(offset+size>len) {                                                      \
       LOG_DEBUG("Attempt to read past EOF of virtual " filetypestr " file\n"); \
       LOG_DEBUG("Adjusting read size from %u to %u\n",size,len-offset);        \
       size=len-offset;                                                         \
     }                                                                          \
     pthread_mutex_lock(&mutex);                                                \
     memcpy(p_buf,filebuf+offset,size);                                         \
     pthread_mutex_unlock(&mutex);                                              \
     LOG_DEBUG("Read %" PRIu64 " bytes at offset %" PRIu64                      \
               " from virtual " filetypestr " file\n",size,offset);             \
     ret=size;                                                                  \
   } else {                                                                     \
     LOG_DEBUG("Attempt to read behind EOF of virtual " filetypestr " file\n"); \
     ret=0;                                                                     \
   }                                                                            \
 }
 
   if(strcmp(p_path,glob_xmount.output.p_virtual_image_path)==0) {
     // Read data from virtual output file
     // Wait for other threads to end reading/writing data
     pthread_mutex_lock(&(glob_xmount.mutex_image_rw));
     // Get requested data
     if((ret=ReadOutputImageData(p_buf,offset,size))<0) {
       LOG_ERROR("Couldn't read data from virtual image file!\n")
     }
     // Allow other threads to read/write data again
     pthread_mutex_unlock(&(glob_xmount.mutex_image_rw));
   } else if(strcmp(p_path,glob_xmount.output.p_info_path)==0) {
     // Read data from virtual info file
     READ_MEM_FILE(glob_xmount.output.p_info_file,
                   strlen(glob_xmount.output.p_info_file),
                   "info",
                   glob_xmount.mutex_info_read);
   } else {
     // Attempt to read non existant file
     LOG_DEBUG("Attempt to read from non existant file \"%s\"\n",p_path)
     ret=-ENOENT;
   }
 
 #undef READ_MEM_FILE
 
   // TODO: Return size of read data!!!!!
   return ret;
 }
 
 //! FUSE rename implementation
 /*!
  * \param p_path File to rename
  * \param p_npath New filename
  * \return 0 on error, negated error code on error
  */
 int Xmount_FuseRename(const char *p_path, const char *p_npath) {
   // TODO: Implement
   return -ENOENT;
 }
 
 //! FUSE rmdir implementation
 /*!
  * \param p_path Directory to delete
  * \return 0 on success, negated error code on error
  */
 int Xmount_FuseRmDir(const char *p_path) {
   // TODO: Implement
   return -1;
 }
 
 //! FUSE unlink implementation
 /*!
  * \param p_path File to delete
  * \return 0 on success, negated error code on error
  */
 int Xmount_FuseUnlink(const char *p_path) {
   // TODO: Implement
   return -1;
 }
 
 //! FUSE statfs implementation
 /*!
  * \param p_path Get stats for fs that the specified file resides in
  * \param stats Stats
  * \return 0 on success, negated error code on error
  */
 /*
 int Xmount_FuseStatFs(const char *p_path, struct statvfs *stats) {
   struct statvfs CacheFileFsStats;
   int ret;
 
   if(glob_xmount.writable==TRUE) {
     // If write support is enabled, return stats of fs upon which cache file
     // resides in
     if((ret=statvfs(glob_xmount.p_cache_file,&CacheFileFsStats))==0) {
       memcpy(stats,&CacheFileFsStats,sizeof(struct statvfs));
       return 0;
     } else {
       LOG_ERROR("Couldn't get stats for fs upon which resides \"%s\"\n",
                 glob_xmount.p_cache_file)
       return ret;
     }
   } else {
     // TODO: Return read only
     return 0;
   }
 }
 */
 
 // FUSE write implementation
 /*!
  * \param p_buf Buffer containing data to write
  * \param size Number of bytes to write
  * \param offset Offset to start writing at
  * \param p_fi: File info struct
  *
  * Returns:
  *   Written bytes on success, negated error code on error
  */
 int Xmount_FuseWrite(const char *p_path,
                      const char *p_buf,
                      size_t size,
                      off_t offset,
                      struct fuse_file_info *p_fi)
 {
   (void)p_fi;
 
   uint64_t len;
 
   if(strcmp(p_path,glob_xmount.output.p_virtual_image_path)==0) {
     // Wait for other threads to end reading/writing data
     pthread_mutex_lock(&(glob_xmount.mutex_image_rw));
 
     // Get output image file size
     if(!GetOutputImageSize(&len)) {
       LOG_ERROR("Couldn't get virtual image size!\n")
       pthread_mutex_unlock(&(glob_xmount.mutex_image_rw));
       return 0;
     }
     if(offset<len) {
       if(offset+size>len) size=len-offset;
       if(WriteOutputImageData(p_buf,offset,size)!=size) {
         LOG_ERROR("Couldn't write data to virtual image file!\n")
         pthread_mutex_unlock(&(glob_xmount.mutex_image_rw));
         return 0;
       }
     } else {
       LOG_DEBUG("Attempt to write past EOF of virtual image file\n")
       pthread_mutex_unlock(&(glob_xmount.mutex_image_rw));
       return 0;
     }
 
     // Allow other threads to read/write data again
     pthread_mutex_unlock(&(glob_xmount.mutex_image_rw));
   } else if(strcmp(p_path,glob_xmount.output.p_info_path)==0) {
     // Attempt to write data to read only image info file
     LOG_DEBUG("Attempt to write data to virtual info file\n");
     return -ENOENT;
   } else {
     // Attempt to write to non existant file
     LOG_DEBUG("Attempt to write to the non existant file \"%s\"\n",p_path)
     return -ENOENT;
   }
 
   return size;
 }
diff --git a/src/xmount_input.c b/src/xmount_input.c
index 414abd6..abd6503 100644
--- a/src/xmount_input.c
+++ b/src/xmount_input.c
@@ -1,826 +1,921 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #include <stdlib.h> // For calloc
 #include <string.h> // For memcpy
-//#include <errno.h>
 #include <dlfcn.h> // For dlopen, dlclose, dlsym
 
 #include "xmount_input.h"
 #include "xmount.h"
 #include "macros.h"
 #include "../libxmount_input/libxmount_input.h"
 
 /*******************************************************************************
  * Private definitions / macros
  ******************************************************************************/
 
 #define LOG_WARNING(...) {            \
   LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
 }
 #define LOG_ERROR(...) {            \
   LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
 }
 #define LOG_DEBUG(...) {                              \
   LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
 }
 
 /*******************************************************************************
  * Private types / structures / enums
  ******************************************************************************/
 
 //! Structure containing infos about input libs
 typedef struct s_XmountInputLib {
   //! Filename of lib (without path)
   char *p_name;
   //! Handle to the loaded lib
   void *p_lib;
   //! Array of supported input types
   char *p_supported_input_types;
   //! Struct containing lib functions
   ts_LibXmountInputFunctions lib_functions;
 } ts_XmountInputLib, *pts_XmountInputLib;
 
 //! Structure containing infos about input images
 typedef struct s_XmountInputImage {
   //! Image type
   char *p_type;
   //! Image source file count
   uint64_t files_count;
   //! Image source files
   char **pp_files;
   //! Input lib functions for this image
   pts_LibXmountInputFunctions p_functions;
   //! Image handle
   void *p_handle;
   //! Image size
   uint64_t size;
 } ts_XmountInputImage, *pts_XmountInputImage;
 
 typedef struct s_XmountInputHandle {
   //! Loaded input lib count
   uint32_t libs_count;
   //! Array containing infos about loaded input libs
   pts_XmountInputLib *pp_libs;
   //! Amount of input lib params (--inopts)
   uint32_t lib_params_count;
   //! Input lib params (--inopts)
   pts_LibXmountOptions *pp_lib_params;
   //! Input image count
   uint64_t images_count;
   //! Input images
   pts_XmountInputImage *pp_images;
   //! Input image offset (--offset)
   uint64_t image_offset;
   //! Input image size limit (--sizelimit)
   uint64_t image_size_limit;
-
-  // TODO: Move
-  //! MD5 hash of partial input image (lower 64 bit) (after morph)
-  //uint64_t image_hash_lo;
-  //! MD5 hash of partial input image (higher 64 bit) (after morph)
-  //uint64_t image_hash_hi;
+  //! Enable debugging
+  uint8_t debug;
 } ts_XmountInputHandle;
 
 /*******************************************************************************
  * Private functions declarations
  ******************************************************************************/
 /*!
  * \brief Find an input lib for a given input image
  *
  * Searches trough the list of loaded input libraries to find one that supports
  * the given input image's format. On success, that library is associated with
  * the given image.
  *
  * \param p_h Input handle
  * \param p_input_image Input image to search input lib for
  * \return e_XmountInput_Error_None on success
  */
-te_XmountInput_Error FindInputLib(pts_XmountInputHandle p_h,
-                                  pts_XmountInputImage p_input_image);
+te_XmountInput_Error XmountInput_FindLib(pts_XmountInputHandle p_h,
+                                         pts_XmountInputImage p_input_image);
 
 /*******************************************************************************
  * Public functions implementations
  ******************************************************************************/
 /*
  * XmountInput_CreateHandle
  */
 te_XmountInput_Error XmountInput_CreateHandle(pts_XmountInputHandle *pp_h) {
   pts_XmountInputHandle p_h=NULL;
 
   // Params check
   if(pp_h==NULL) return e_XmountInput_Error_InvalidHandlePointer;
 
   // Alloc new handle
   p_h=(pts_XmountInputHandle)calloc(1,sizeof(ts_XmountInputHandle));
   if(p_h==NULL) {
     return e_XmountInput_Error_Alloc;
   }
 
   // Init values
   p_h->pp_libs=NULL;
   p_h->pp_lib_params=NULL;
   p_h->pp_images=NULL;
 
   *pp_h=p_h;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_DestroyHandle
  */
 te_XmountInput_Error XmountInput_DestroyHandle(pts_XmountInputHandle *pp_h) {
   pts_XmountInputHandle p_h=NULL;
 
   // Params check
   if(pp_h==NULL) return e_XmountInput_Error_InvalidHandlePointer;
   if(*pp_h==NULL) return e_XmountInput_Error_InvalidHandle;
   p_h=*pp_h;
 
   // Free resources
   if(p_h->images_count!=0 && p_h->pp_images!=NULL) {
     // TODO: Close images
   }
   if(p_h->libs_count>0 && p_h->pp_libs!=NULL) {
     // Unload all input libs
     for(uint32_t i=0;i<p_h->libs_count;i++) {
       if(p_h->pp_libs[i]->p_supported_input_types!=NULL) {
         XMOUNT_FREE(p_h->pp_libs[i]->p_supported_input_types);
       }
       if(p_h->pp_libs[i]->p_lib!=NULL) {
         dlclose(p_h->pp_libs[i]->p_lib);
         p_h->pp_libs[i]->p_lib=NULL;
       }
       if(p_h->pp_libs[i]->p_name!=NULL) {
         XMOUNT_FREE(p_h->pp_libs[i]->p_name);
       }
       XMOUNT_FREE(p_h->pp_libs[i]);
     }
     XMOUNT_FREE(p_h->pp_libs);
     p_h->libs_count=0;
   }
   if(p_h->lib_params_count!=0 && p_h->pp_lib_params!=NULL) {
     // Free library parameter array
     for(uint32_t i=0;i<p_h->lib_params_count;i++) {
       XMOUNT_FREE(p_h->pp_lib_params[i]);
     }
     XMOUNT_FREE(p_h->pp_lib_params);
     p_h->lib_params_count=0;
   }
 
   return e_XmountInput_Error_None;
 }
 
+/*
+ * XmountInput_EnableDebugging
+ */
+te_XmountInput_Error XmountInput_EnableDebugging(pts_XmountInputHandle p_h) {
+  // Params check
+  if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
+
+  p_h->debug=1;
+  return e_XmountInput_Error_None;
+}
+
 /*
  * XmountInput_AddLibrary
  */
 te_XmountInput_Error XmountInput_AddLibrary(pts_XmountInputHandle p_h,
                                             const char *p_lib_name)
 {
   uint32_t supported_formats_len=0;
   t_LibXmount_Input_GetApiVersion pfun_input_GetApiVersion;
   t_LibXmount_Input_GetSupportedFormats pfun_input_GetSupportedFormats;
   t_LibXmount_Input_GetFunctions pfun_input_GetFunctions;
   void *p_libxmount=NULL;
   pts_XmountInputLib p_input_lib=NULL;
   char *p_buf=NULL;
   char *p_library_path=NULL;
   char *p_supported_formats=NULL;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(p_lib_name==NULL) return e_XmountInput_Error_InvalidString;
 
   // Construct full library path
   XMOUNT_STRSET(p_library_path,XMOUNT_LIBRARY_PATH);
   if(p_library_path[strlen(p_library_path)]!='/') {
     XMOUNT_STRAPP(p_library_path,"/");
   }
   XMOUNT_STRAPP(p_library_path,p_lib_name);
 
 #define XMOUNTINPUT_LOADLIBS__LOAD_SYMBOL(name,pfun) {           \
   if((pfun=dlsym(p_libxmount,name))==NULL) {                     \
     LOG_ERROR("Unable to load symbol '%s' from library '%s'!\n", \
               name,                                              \
               p_library_path);                                   \
     dlclose(p_libxmount);                                        \
-    p_libxmount=NULL;                                            \
-    continue;                                                    \
+    return e_XmountInput_Error_FailedLoadingSymbol;              \
   }                                                              \
 }
 
   // Try to load given library
   p_libxmount=dlopen(p_library_path,RTLD_NOW);
   if(p_libxmount==NULL) {
     LOG_ERROR("Unable to load input library '%s': %s!\n",
               p_library_path,
               dlerror());
     return e_XmountInput_Error_FailedLoadingLibrary;
   }
 
   // Load library symbols
-  LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetApiVersion",
-                        pfun_input_GetApiVersion);
+  XMOUNTINPUT_LOADLIBS__LOAD_SYMBOL("LibXmount_Input_GetApiVersion",
+                                    pfun_input_GetApiVersion);
 
   // Check library's API version
   if(pfun_input_GetApiVersion()!=LIBXMOUNT_INPUT_API_VERSION) {
     LOG_DEBUG("Failed! Wrong API version.\n");
     LOG_ERROR("Unable to load input library '%s'. Wrong API version\n",
               p_library_path);
     dlclose(p_libxmount);
     return e_XmountInput_Error_WrongLibraryApiVersion;
   }
 
-  LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetSupportedFormats",
-                        pfun_input_GetSupportedFormats);
-  LIBXMOUNT_LOAD_SYMBOL("LibXmount_Input_GetFunctions",
-                        pfun_input_GetFunctions);
+  XMOUNTINPUT_LOADLIBS__LOAD_SYMBOL("LibXmount_Input_GetSupportedFormats",
+                                    pfun_input_GetSupportedFormats);
+  XMOUNTINPUT_LOADLIBS__LOAD_SYMBOL("LibXmount_Input_GetFunctions",
+                                    pfun_input_GetFunctions);
 
   // Construct new entry for our library list
   XMOUNT_MALLOC(p_input_lib,pts_XmountInputLib,sizeof(ts_XmountInputLib));
   // Initialize lib_functions structure to NULL
   memset(&(p_input_lib->lib_functions),
          0,
          sizeof(ts_LibXmountInputFunctions));
 
   // Set name and handle
   XMOUNT_STRSET(p_input_lib->p_name,p_lib_name);
   p_input_lib->p_lib=p_libxmount;
 
   // Get and set supported formats
   p_supported_formats=pfun_input_GetSupportedFormats();
   p_buf=p_supported_formats;
   while(*p_buf!='\0') {
     supported_formats_len+=(strlen(p_buf)+1);
     p_buf+=(strlen(p_buf)+1);
   }
   supported_formats_len++;
   XMOUNT_MALLOC(p_input_lib->p_supported_input_types,
                 char*,
                 supported_formats_len);
   memcpy(p_input_lib->p_supported_input_types,
          p_supported_formats,
          supported_formats_len);
 
   // Get, set and check lib_functions
   pfun_input_GetFunctions(&(p_input_lib->lib_functions));
   if(p_input_lib->lib_functions.CreateHandle==NULL ||
      p_input_lib->lib_functions.DestroyHandle==NULL ||
      p_input_lib->lib_functions.Open==NULL ||
      p_input_lib->lib_functions.Close==NULL ||
      p_input_lib->lib_functions.Size==NULL ||
      p_input_lib->lib_functions.Read==NULL ||
      p_input_lib->lib_functions.OptionsHelp==NULL ||
      p_input_lib->lib_functions.OptionsParse==NULL ||
      p_input_lib->lib_functions.GetInfofileContent==NULL ||
      p_input_lib->lib_functions.GetErrorMessage==NULL ||
      p_input_lib->lib_functions.FreeBuffer==NULL)
   {
     LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
               p_lib_name);
-    free(p_input_lib->p_supported_input_types);
-    free(p_input_lib->p_name);
-    free(p_input_lib);
+    XMOUNT_FREE(p_input_lib->p_supported_input_types);
+    XMOUNT_FREE(p_input_lib->p_name);
+    XMOUNT_FREE(p_input_lib);
     dlclose(p_libxmount);
     return e_XmountInput_Error_MissingLibraryFunction;
   }
 
   // Add entry to the input library list
   XMOUNT_REALLOC(p_h->pp_libs,
                  pts_XmountInputLib*,
                  sizeof(pts_XmountInputLib)*(p_h->libs_count+1));
   p_h->pp_libs[p_h->libs_count++]=p_input_lib;
 
   LOG_DEBUG("Input library '%s' loaded successfully\n",p_lib_name);
 
 #undef XMOUNTINPUT_LOADLIBS__LOAD_SYMBOL
 
   return e_XmountInput_Error_None;
 }
 
 te_XmountInput_Error XmountInput_GetLibraryCount(pts_XmountInputHandle p_h,
                                                  uint32_t *p_count)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(p_count==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   *p_count=p_h->libs_count;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_GetSupportedFormats
  */
 te_XmountInput_Error XmountInput_GetSupportedFormats(pts_XmountInputHandle p_h,
                                                      char **pp_formats)
 {
   char *p_buf=NULL;
   char *p_formats=NULL;
   uint32_t cur_len=0;
   uint32_t vector_len=0;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(pp_formats==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   // Loop over all loaded libs, extract supported formats and add to our vector
   // TODO: IMPROVEMENT: Final vector could be sorted
   for(uint32_t i=0;i<p_h->libs_count;i++) {
     p_buf=p_h->pp_libs[i]->p_supported_input_types;
     while(p_buf!=NULL && *p_buf!='\0') p_buf+=(strlen(p_buf)+1);
     cur_len=(uint32_t)(p_buf-p_h->pp_libs[i]->p_supported_input_types);
     if(cur_len==0) continue;
     p_formats=(char*)realloc(p_formats,vector_len+cur_len);
     if(p_formats==NULL) return e_XmountInput_Error_Alloc;
     memcpy(p_formats+vector_len,
            p_h->pp_libs[i]->p_supported_input_types,
            cur_len);
     vector_len+=cur_len;
   }
 
   // Null-terminate vector
   p_formats=(char*)realloc(p_formats,vector_len+1);
   if(p_formats==NULL) return e_XmountInput_Error_Alloc;
   p_formats[vector_len]='\0';
 
   *pp_formats=p_formats;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_SetOptions
  */
 te_XmountInput_Error XmountInput_SetOptions(pts_XmountInputHandle p_h,
                                             char *p_options)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(p_options==NULL) return e_XmountInput_Error_InvalidString;
 
   // Make sure library parameters haven't been set previously
   if(p_h->pp_lib_params!=NULL) {
     LOG_ERROR("Input library options already set!\n");
     return e_XmountInput_Error_LibOptionsAlreadySet;
   }
 
   // Save options
   if(XmountLib_SplitLibParams(p_options,
                               &(p_h->lib_params_count),
                               &(p_h->pp_lib_params))!=0)
   {
     LOG_ERROR("Unable to parse input library options '%s'!\n",p_options);
     return e_XmountInput_Error_FailedParsingOptions;
   }
 
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_GetOptionsHelpText
  */
 te_XmountInput_Error XmountInput_GetOptionsHelpText(pts_XmountInputHandle p_h,
                                                     char **pp_help_text)
 {
   const char *p_buf=NULL;
   char *p_help=NULL;
   int ret=0;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(pp_help_text==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   // Loop over all loaded libs, extract help and add to our text buffer
   // TODO: IMPROVEMENT: Final text should be sorted by lib's name
   for(uint32_t i=0;i<p_h->libs_count;i++) {
     ret=p_h->pp_libs[i]->lib_functions.OptionsHelp(&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get options help for library '%s': %s!\n",
                 p_h->pp_libs[i]->p_name,
                 p_h->pp_libs[i]->lib_functions.GetErrorMessage(ret));
       continue;
     }
     if(p_buf==NULL) continue;
     XMOUNT_STRAPP(p_help,"  - ");
     XMOUNT_STRAPP(p_help,p_h->pp_libs[i]->p_name);
     XMOUNT_STRAPP(p_help,"\n");
     XMOUNT_STRAPP(p_help,p_buf);
     XMOUNT_STRAPP(p_help,"\n");
     ret=p_h->pp_libs[i]->lib_functions.FreeBuffer(p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to free options help text from library '%s': %s!\n",
                 p_h->pp_libs[i]->p_name,
                 p_h->pp_libs[i]->lib_functions.GetErrorMessage(ret));
     }
   }
 
   *pp_help_text=p_help;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_GetLibsInfoText
  */
 te_XmountInput_Error XmountInput_GetLibsInfoText(pts_XmountInputHandle p_h,
                                                  char **pp_info_text)
 {
   char *p_buf=NULL;
   char *p_info_text=NULL;
   uint8_t first=0;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(pp_info_text==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   // Loop over all loaded libs, extract name and supported formats and add to
   // our text buffer
   // TODO: IMPROVEMENT: Final text should be sorted by lib's name
   for(uint32_t i=0;i<p_h->libs_count;i++) {
     XMOUNT_STRAPP(p_info_text,"    - ");
     XMOUNT_STRAPP(p_info_text,p_h->pp_libs[i]->p_name);
     XMOUNT_STRAPP(p_info_text," supporting ");
     XMOUNT_STRAPP(p_info_text,"    - ");
     XMOUNT_STRAPP(p_info_text,"    - ");
     p_buf=p_h->pp_libs[i]->p_supported_input_types;
     first=1;
     while(*p_buf!='\0') {
       if(first==1) {
         XMOUNT_STRAPP(p_info_text,"\"");
         XMOUNT_STRAPP(p_info_text,p_buf);
         XMOUNT_STRAPP(p_info_text,"\"");
         first=0;
       } else {
         XMOUNT_STRAPP(p_info_text,", \"");
         XMOUNT_STRAPP(p_info_text,p_buf);
         XMOUNT_STRAPP(p_info_text,"\"");
       }
       p_buf+=(strlen(p_buf)+1);
     }
     XMOUNT_STRAPP(p_info_text,"\n");
   }
 
   *pp_info_text=p_info_text;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_AddImage
  */
 te_XmountInput_Error XmountInput_AddImage(pts_XmountInputHandle p_h,
                                           const char *p_format,
                                           uint64_t files_count,
                                           const char **pp_files)
 {
   pts_XmountInputImage p_image=NULL;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(p_format==NULL) return e_XmountInput_Error_InvalidString;
   if(pp_files==NULL) return e_XmountInput_Error_InvalidArray;
 
   // Alloc and fill new image structure
   XMOUNT_CALLOC(p_image,pts_XmountInputImage,sizeof(ts_XmountInputImage));
   XMOUNT_STRSET(p_image->p_type,p_format);
   p_image->files_count=files_count;
   XMOUNT_CALLOC(p_image->pp_files,char**,p_image->files_count*sizeof(char*));
   for(uint64_t i=0;i<p_image->files_count;i++) {
     XMOUNT_STRSET(p_image->pp_files[i],pp_files[i]);
   }
   p_image->p_functions=NULL;
   p_image->p_handle=NULL;
 
   // TODO: Find lib and open input file
 
   // Add image to our image array
   XMOUNT_REALLOC(p_h->pp_images,pts_XmountInputImage*,p_h->images_count+1);
   p_h->pp_images[p_h->images_count++]=p_image;
 
   return e_XmountInput_Error_None;
 }
 
 /*!
  * \brief Get input image count
  *
  * Get input image count.
  *
  * \param p_h Input handle
  * \param p_count Input image count is returned in this variable
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetImageCount(pts_XmountInputHandle p_h,
                                                uint64_t *p_count)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(p_count==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   *p_count=p_h->images_count;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_SetInputOffset
  */
 te_XmountInput_Error XmountInput_SetInputOffset(pts_XmountInputHandle p_h,
                                                 uint64_t offset)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
 
   LOG_DEBUG("Setting input image offset to \"%" PRIu64 "\"\n",offset);
 
   p_h->image_offset=offset;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_SetInputSizeLimit
  */
 te_XmountInput_Error XmountInput_SetInputSizeLimit(pts_XmountInputHandle p_h,
                                                    uint64_t size_limit)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
 
   LOG_DEBUG("Setting input image size limit to \"%" PRIu64 "\"\n",size_limit);
 
   p_h->image_size_limit=size_limit;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_Open
  */
 te_XmountInput_Error XmountInput_Open(pts_XmountInputHandle p_h) {
+  int ret=0;
+  const char *p_err_msg;
+  te_XmountInput_Error input_ret=e_XmountInput_Error_None;
+
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
 
-  // TODO: Implement
+  for(uint64_t i=0;i<p_h->images_count;i++) {
+    if(p_h->debug==TRUE) {
+      if(p_h->pp_images[i]->files_count==1) {
+        LOG_DEBUG("Loading image file \"%s\"...\n",
+                  p_h->pp_images[i]->pp_files[0]);
+      } else {
+        LOG_DEBUG("Loading image files \"%s .. %s\"...\n",
+                  p_h->pp_images[i]->pp_files[0],
+                  p_h->pp_images[i]->
+                    pp_files[p_h->pp_images[i]->files_count-1]);
+      }
+    }
+
+    // Find input lib
+    input_ret=XmountInput_FindLib(p_h,p_h->pp_images[i]);
+    if(input_ret!=e_XmountInput_Error_None) {
+      LOG_ERROR("Unable to find input library for input image format '%s' "
+                  "of input image '%s': Error code %u!\n",
+                p_h->pp_images[i]->p_type,
+                p_h->pp_images[i]->pp_files[0],
+                input_ret);
+      return input_ret;
+    }
+
+    // Init input image handle
+    ret=p_h->pp_images[i]->p_functions->
+          CreateHandle(&(p_h->pp_images[i]->p_handle),
+                       p_h->pp_images[i]->p_type,
+                       p_h->debug);
+    if(ret!=0) {
+      LOG_ERROR("Unable to init input handle for input image '%s': %s!\n",
+                p_h->pp_images[i]->pp_files[0],
+                p_h->pp_images[i]->p_functions->
+                  GetErrorMessage(ret));
+      return e_XmountInput_Error_FailedCreatingImageHandle;
+    }
+
+    // Parse input lib specific options
+    if(p_h->pp_lib_params!=NULL) {
+      ret=p_h->pp_images[i]->p_functions->
+            OptionsParse(p_h->pp_images[i]->p_handle,
+                         p_h->lib_params_count,
+                         p_h->pp_lib_params,
+                         &p_err_msg);
+      if(ret!=0) {
+        if(p_err_msg!=NULL) {
+          LOG_ERROR("Unable to parse input library specific options for image "
+                      "'%s': %s: %s!\n",
+                    p_h->pp_images[i]->pp_files[0],
+                    p_h->pp_images[i]->p_functions->
+                      GetErrorMessage(ret),
+                    p_err_msg);
+          p_h->pp_images[i]->p_functions->FreeBuffer(p_err_msg);
+        } else {
+          LOG_ERROR("Unable to parse input library specific options for image "
+                      "'%s': %s!\n",
+                    p_h->pp_images[i]->pp_files[0],
+                    p_h->pp_images[i]->p_functions->
+                      GetErrorMessage(ret));
+        }
+        return e_XmountInput_Error_FailedParsingLibParams;
+      }
+    }
+
+    // Open input image
+    ret=p_h->pp_images[i]->p_functions->Open(p_h->pp_images[i]->p_handle,
+                                             (const char**)(p_h->pp_images[i]->
+                                               pp_files),
+                                             p_h->pp_images[i]->files_count);
+    if(ret!=0) {
+      LOG_ERROR("Unable to open input image file '%s': %s!\n",
+                p_h->pp_images[i]->pp_files[0],
+                p_h->pp_images[i]->p_functions->
+                  GetErrorMessage(ret));
+      return e_XmountInput_Error_FailedOpeningImage;
+    }
+
+    // Determine input image size
+    ret=p_h->pp_images[i]->p_functions->Size(p_h->pp_images[i]->p_handle,
+                                             &(p_h->pp_images[i]->size));
+    if(ret!=0) {
+      LOG_ERROR("Unable to determine size of input image '%s': %s!\n",
+                p_h->pp_images[i]->pp_files[0],
+                p_h->pp_images[i]->
+                  p_functions->GetErrorMessage(ret));
+      return e_XmountInput_Error_FailedGettingImageSize;
+    }
+
+    // If an offset was specified, check it against offset and change size
+    if(p_h->image_offset!=0) {
+      if(p_h->image_offset>p_h->pp_images[i]->size) {
+        LOG_ERROR("The specified offset is larger than the size of the input "
+                    "image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
+                  p_h->pp_images[i]->pp_files[0],
+                  p_h->image_offset,
+                  p_h->pp_images[i]->size);
+        return e_XmountInput_Error_OffsetExceedsImageSize;
+      }
+      p_h->pp_images[i]->size-=p_h->image_offset;
+    }
+
+    // If a size limit was specified, check it and change size
+    if(p_h->image_size_limit!=0) {
+      if(p_h->pp_images[i]->size<p_h->image_size_limit) {
+        LOG_ERROR("The specified size limit is larger than the size of the "
+                    "input image '%s'! (%" PRIu64 " > %" PRIu64 ")\n",
+                  p_h->pp_images[i]->pp_files[0],
+                  p_h->image_size_limit,
+                  p_h->pp_images[i]->size);
+        return e_XmountInput_Error_SizelimitExceedsImageSize;
+      }
+      p_h->pp_images[i]->size=p_h->image_size_limit;
+    }
+
+    LOG_DEBUG("Input image loaded successfully\n")
+  }
 
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_Close
  */
 te_XmountInput_Error XmountInput_Close(pts_XmountInputHandle p_h) {
   int ret=0;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
 
   if(p_h->pp_images!=NULL) {
     // Close all input images
     for(uint64_t i=0;i<p_h->images_count;i++) {
       if(p_h->pp_images[i]==NULL) continue;
       if(p_h->pp_images[i]->p_functions!=NULL) {
         if(p_h->pp_images[i]->p_handle!=NULL) {
           ret=p_h->pp_images[i]->p_functions->
             Close(p_h->pp_images[i]->p_handle);
           if(ret!=0) {
             LOG_ERROR("Unable to close input image '%s': %s\n",
                       p_h->pp_images[i]->pp_files[0]!=NULL ?
                         p_h->pp_images[i]->pp_files[0] : "n/a",
                       p_h->pp_images[i]->p_functions->GetErrorMessage(ret));
           }
           ret=p_h->pp_images[i]->p_functions->
                 DestroyHandle(&(p_h->pp_images[i]->p_handle));
           if(ret!=0) {
             LOG_ERROR("Unable to destroy handle of input image '%s': %s\n",
                       p_h->pp_images[i]->pp_files[0]!=NULL ?
                         p_h->pp_images[i]->pp_files[0] : "n/a",
                       p_h->pp_images[i]->p_functions->GetErrorMessage(ret));
           }
           p_h->pp_images[i]->p_handle=NULL;
         }
       }
       if(p_h->pp_images[i]->pp_files!=NULL) {
         for(uint64_t ii=0;ii<p_h->pp_images[i]->files_count;ii++) {
           if(p_h->pp_images[i]->pp_files[ii]!=NULL)
             XMOUNT_FREE(p_h->pp_images[i]->pp_files[ii]);
         }
         XMOUNT_FREE(p_h->pp_images[i]->pp_files);
       }
       if(p_h->pp_images[i]->p_type!=NULL) {
         XMOUNT_FREE(p_h->pp_images[i]->p_type);
       }
       XMOUNT_FREE(p_h->pp_images[i]);
     }
     XMOUNT_FREE(p_h->pp_images);
   }
 
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_GetSize
  */
 te_XmountInput_Error XmountInput_GetSize(pts_XmountInputHandle p_h,
                                          uint64_t image_nr,
                                          uint64_t *p_size)
 {
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(image_nr>=p_h->images_count) return e_XmountInput_Error_NoSuchImage;
   if(p_size==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   *p_size=p_h->pp_images[image_nr]->size;
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_ReadData
  */
 te_XmountInput_Error XmountInput_ReadData(pts_XmountInputHandle p_h,
                                           uint64_t image_nr,
                                           char *p_buf,
                                           uint64_t offset,
                                           uint64_t count,
                                           uint64_t *p_read)
 {
+  uint64_t to_read=0;
   int ret=0;
+  int read_errno=0;
+  pts_XmountInputImage p_image=NULL;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(image_nr>=p_h->images_count) return e_XmountInput_Error_NoSuchImage;
   if(p_buf==NULL) return e_XmountInput_Error_InvalidBuffer;
+  p_image=p_h->pp_images[image_nr];
 
-  // TODO: Implement
-/*
-  ret=ReadInputImageData(glob_xmount.input.pp_images[image],
-                            p_buf,
-                            offset,
-                            count,
-                            p_read);
-*/
+  LOG_DEBUG("Reading %zu bytes at offset %zu from input image '%s'\n",
+            count,
+            offset,
+            p_image->pp_files[0]);
+
+  // Make sure we aren't reading past EOF of image file
+  if(offset>=p_image->size) {
+    // Offset is beyond image size
+    LOG_DEBUG("Offset %zu is at / beyond size of input image '%s'\n",
+              offset,
+              p_image->pp_files[0]);
+    *p_read=0;
+    return 0;
+  }
+  if(offset+count>p_image->size) {
+    // Attempt to read data past EOF of image file
+    to_read=p_image->size-offset;
+    LOG_DEBUG("Attempt to read data past EOF of input image '%s'. "
+                "Correcting size from %zu to %zu\n",
+              p_image->pp_files[0],
+              count,
+              to_read);
+  } else to_read=count;
+
+  // Read data from image file (adding input image offset if one was specified)
+  ret=p_image->p_functions->Read(p_image->p_handle,
+                                 p_buf,
+                                 offset+p_h->image_offset,
+                                 to_read,
+                                 p_read,
+                                 &read_errno);
+  if(ret!=0) {
+    LOG_ERROR("Couldn't read %zu bytes at offset %zu from input image "
+                "'%s': %s: Error code %u!\n",
+              to_read,
+              offset,
+              p_image->pp_files[0],
+              p_image->p_functions->GetErrorMessage(ret),
+              read_errno);
+    return e_XmountInput_Error_FailedReadingData;
+  }
 
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_WriteData
  */
 te_XmountInput_Error XmountInput_WriteData(pts_XmountInputHandle p_h,
                                            uint64_t image_nr,
                                            const char *p_buf,
                                            uint64_t offset,
                                            uint64_t count)
 {
   // TODO: Implement
   return e_XmountInput_Error_None;
 }
 
 /*
  * XmountInput_GetInfoFileContent
  */
 te_XmountInput_Error XmountInput_GetInfoFileContent(pts_XmountInputHandle p_h,
                                                     char **pp_content)
 {
   int ret=0;
   char *p_buf=NULL;
   char *p_content=NULL;
 
   // Params check
   if(p_h==NULL) return e_XmountInput_Error_InvalidHandle;
   if(pp_content==NULL) return e_XmountInput_Error_InvalidBuffer;
 
   for(uint64_t i=0;i<p_h->images_count;i++) {
     ret=p_h->pp_images[i]->p_functions->
       GetInfofileContent(p_h->pp_images[i]->p_handle,(const char**)&p_buf);
     if(ret!=0) {
       LOG_ERROR("Unable to get info file content for image '%s': %s!\n",
                 p_h->pp_images[i]->pp_files[0],
                 p_h->pp_images[i]->p_functions->GetErrorMessage(ret));
       return e_XmountInput_Error_FailedGettingInfoFileContent;
     }
     // Add infos to main buffer and free p_buf
     XMOUNT_STRAPP(p_content,"\n--> ");
     XMOUNT_STRAPP(p_content,p_h->pp_images[i]->pp_files[0]);
     XMOUNT_STRAPP(p_content," <--\n");
     if(p_buf!=NULL) {
       XMOUNT_STRAPP(p_content,p_buf);
       p_h->pp_images[i]->p_functions->FreeBuffer(p_buf);
     } else {
       XMOUNT_STRAPP(p_content,"None\n");
     }
   }
 
   *pp_content=p_content;
   return e_XmountInput_Error_None;
 }
 
 /*******************************************************************************
  * Private functions implementations
  ******************************************************************************/
 /*
  * FindInputLib
  */
-te_XmountInput_Error FindInputLib(pts_XmountInputHandle p_h,
-                                  pts_XmountInputImage p_input_image)
+te_XmountInput_Error XmountInput_FindLib(pts_XmountInputHandle p_h,
+                                         pts_XmountInputImage p_input_image)
 {
   char *p_buf;
 
   LOG_DEBUG("Trying to find suitable library for input type '%s'.\n",
             p_input_image->p_type);
 
   // Loop over all loaded libs
   for(uint32_t i=0;i<p_h->libs_count;i++) {
     LOG_DEBUG("Checking input library %s\n",p_h->pp_libs[i]->p_name);
     p_buf=p_h->pp_libs[i]->p_supported_input_types;
     while(*p_buf!='\0') {
       if(strcmp(p_buf,p_input_image->p_type)==0) {
         // Library supports input type, set lib functions
         LOG_DEBUG("Input library '%s' pretends to handle that input type.\n",
                   p_h->pp_libs[i]->p_name);
         p_input_image->p_functions=&(p_h->pp_libs[i]->lib_functions);
         return e_XmountInput_Error_None;
       }
       p_buf+=(strlen(p_buf)+1);
     }
   }
 
   LOG_DEBUG("Couldn't find any suitable library.\n");
 
   // No library supporting input type found
   return e_XmountInput_Error_UnsupportedFormat;
 }
-
-//! Read data from input image
-/*!
- * \param p_image Image from which to read data
- * \param p_buf Pointer to buffer to write read data to (must be preallocated!)
- * \param offset Offset at which data should be read
- * \param size Size of data which should be read (size of buffer)
- * \param p_read Number of read bytes on success
- * \return 0 on success, negated error code on error
- */
-/*
-int ReadInputImageData(pts_InputImage p_image,
-                       char *p_buf,
-                       off_t offset,
-                       size_t size,
-                       size_t *p_read)
-{
-  int ret;
-  size_t to_read=0;
-  int read_errno=0;
-
-  LOG_DEBUG("Reading %zu bytes at offset %zu from input image '%s'\n",
-            size,
-            offset,
-            p_image->pp_files[0]);
-
-  // Make sure we aren't reading past EOF of image file
-  if(offset>=p_image->size) {
-    // Offset is beyond image size
-    LOG_DEBUG("Offset %zu is at / beyond size of input image '%s'\n",
-              offset,
-              p_image->pp_files[0]);
-    *p_read=0;
-    return 0;
-  }
-  if(offset+size>p_image->size) {
-    // Attempt to read data past EOF of image file
-    to_read=p_image->size-offset;
-    LOG_DEBUG("Attempt to read data past EOF of input image '%s'. "
-                "Correcting size from %zu to %zu\n",
-              p_image->pp_files[0],
-              size,
-              to_read);
-  } else to_read=size;
-
-  // Read data from image file (adding input image offset if one was specified)
-  ret=p_image->p_functions->Read(p_image->p_handle,
-                                 p_buf,
-                                 offset+glob_xmount.input.image_offset,
-                                 to_read,
-                                 p_read,
-                                 &read_errno);
-  if(ret!=0) {
-    LOG_ERROR("Couldn't read %zu bytes at offset %zu from input image "
-                "'%s': %s!\n",
-              to_read,
-              offset,
-              p_image->pp_files[0],
-              p_image->p_functions->GetErrorMessage(ret));
-    if(read_errno==0) return -EIO;
-    else return (read_errno*(-1));
-  }
-
-  return 0;
-}
-*/
diff --git a/src/xmount_input.h b/src/xmount_input.h
index 287895f..6fed491 100644
--- a/src/xmount_input.h
+++ b/src/xmount_input.h
@@ -1,342 +1,329 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #ifndef XMOUNT_INPUT_H
 #define XMOUNT_INPUT_H
 
 #include <stdint.h>
 
 /*******************************************************************************
  * Public definitions / macros
  ******************************************************************************/
 //! Naming scheme of input libraries
 #define XMOUNT_INPUT_LIBRARY_NAMING_SCHEME "libxmount_input_"
 
 /*******************************************************************************
  * Public types / structures / enums
  ******************************************************************************/
 typedef struct s_XmountInputHandle *pts_XmountInputHandle;
 
 typedef enum e_XmountInput_Error {
   //! No error
   e_XmountInput_Error_None=0,
   //! Error to allocate memory
   e_XmountInput_Error_Alloc,
   //! Invalid input handle
   e_XmountInput_Error_InvalidHandle,
   //! Invalid pointer to an input handle
   e_XmountInput_Error_InvalidHandlePointer,
   //! A given buffer is invalid
   e_XmountInput_Error_InvalidBuffer,
   //! A given string is invalid
   e_XmountInput_Error_InvalidString,
   //! A given array is invalid
   e_XmountInput_Error_InvalidArray,
   //! Library options have already been set
   e_XmountInput_Error_LibOptionsAlreadySet,
   //! Library options couldn't be parsed
   e_XmountInput_Error_FailedParsingOptions,
   //! Unable to get info file content from library
   e_XmountInput_Error_FailedGettingInfoFileContent,
   //! Unable to load library file
   e_XmountInput_Error_FailedLoadingLibrary,
+  //! Unable to load a library symbol
+  e_XmountInput_Error_FailedLoadingSymbol,
   //! Library has wrong API version
   e_XmountInput_Error_WrongLibraryApiVersion,
   //! Library is missing a function
   e_XmountInput_Error_MissingLibraryFunction,
   //! Unsupported input image format
   e_XmountInput_Error_UnsupportedFormat,
   //! Specified image number is incorrect
   e_XmountInput_Error_NoSuchImage,
-/*
-
-  //! A given file path / name is invalid
-  e_XmountCache_Error_InvalidFile,
-  //! A given file does not exist
-  e_XmountCache_Error_InexistingFile,
-  //! A given file exists
-  e_XmountCache_Error_ExistingFile,
-  //! Unable to create needed xmount structures inside cache file
-  e_XmountCache_Error_FailedCacheInit,
-  //! Unable to open xmount cache file
-  e_XmountCache_Error_FailedOpeningCache,
-  //! Failed to get block cache index size
-  e_XmountCache_Error_FailedGettingIndexSize,
-  //! Invalid block cache index size
-  e_XmountCache_Error_InvalidIndexSize,
-  //! Unable to read block cache index
-  e_XmountCache_Error_FailedReadingIndex,
-  //! Failed closing cache block index
-  e_XmountCache_Error_FailedClosingIndex,
-  //! Failed closing cache block index
-  e_XmountCache_Error_FailedClosingBlockCache,
-  //! Failed closing cache block index
-  e_XmountCache_Error_FailedClosingCache,
-  //! Failed to update block cache index
-  e_XmountCache_Error_FailedUpdatingIndex,
-  //! Invalid block cache index specified
-  e_XmountCache_Error_InvalidIndex,
-  //! Block has not yet been cached
-  e_XmountCache_Error_UncachedBlock,
-  //! Invalid buffer specified
-  e_XmountCache_Error_InvalidBuffer,
-  //! Request would read beyond a single cache block
-  e_XmountCache_Error_ReadBeyondBlockBounds,
-  //! Failed reading cached data
-  e_XmountCache_Error_FailedReadingBlockCache,
-  //! Failed writing cached data
-  e_XmountCache_Error_FailedWritingBlockCache,
-*/
+  //! Unable to create input image handle
+  e_XmountInput_Error_FailedCreatingImageHandle,
+  //! Unable to parse input library options
+  e_XmountInput_Error_FailedParsingLibParams,
+  //! Unable to open input image
+  e_XmountInput_Error_FailedOpeningImage,
+  //! Unable to get image size
+  e_XmountInput_Error_FailedGettingImageSize,
+  //! A specified offset is larger than a specified image
+  e_XmountInput_Error_OffsetExceedsImageSize,
+  //! A specified size limit is larger than a specified image
+  e_XmountInput_Error_SizelimitExceedsImageSize,
+  //! Unable to read data from input image
+  e_XmountInput_Error_FailedReadingData
 } te_XmountInput_Error;
 
 /*******************************************************************************
  * Public functions declarations
  ******************************************************************************/
 /*!
  * \brief Create new input handle
  *
  * Creates a new input handle.
  *
  * \param pp_h Pointer to input handle
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_CreateHandle(pts_XmountInputHandle *pp_h);
 
 /*!
  * \brief Destroy input handle
  *
  * Invalidates the given handle and frees all used resources.
  *
  * \param pp_h Pointer to input handle
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_DestroyHandle(pts_XmountInputHandle *pp_h);
 
+/*!
+ * \brief Enable internal debugging
+ *
+ * Enables the generation of intrernal debugging messages.
+ *
+ * \param p_h Input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountInput_Error XmountInput_EnableDebugging(pts_XmountInputHandle p_h);
+
 /*!
  * \brief Load an input library
  *
  * Loads a given input library.
  *
  * \param p_h Input handle
  * \param p_lib Library name (without path)
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_AddLibrary(pts_XmountInputHandle p_h,
                                             const char *p_lib_name);
 
 /*!
  * \brief Get loaded input library count
  *
  * Returns the number of successfully loaded input libraries.
  *
  * \param p_h Input handle
  * \param p_count Library count is returned in this variable
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetLibraryCount(pts_XmountInputHandle p_h,
                                                  uint32_t *p_count);
 
 /*!
  * \brief Return all supported formats
  *
  * Returns a null-terminated vector of all supported input formats.
  *
  * The returned vector must be freed by the caller.
  *
  * \param p_h Input handle
  * \param pp_formats Supported formats vector is returned in this var
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetSupportedFormats(pts_XmountInputHandle p_h,
                                                      char **pp_formats);
 
 /*!
  * \brief Set library options
  *
  * Parses the given library option string (as given after --inopts).
  *
  * \param p_h Input handle
  * \param p_options Library option string
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_SetOptions(pts_XmountInputHandle p_h,
                                             char *p_options);
 
 /*!
  * \brief Return all library specific option help texts
  *
  * Returns a string containing help messages for all loaded input lib options.
  * The string is pre-formated to be used in xmount's help output.
  *
  * The caller must free the returned string.
  *
  * \param p_h Input handle
  * \param pp_help_text Help text is returned in this parameter
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetOptionsHelpText(pts_XmountInputHandle p_h,
                                                     char **pp_help_text);
 
 /*!
  * \brief Returns a string containing infos about loaded libs
  *
  * Returns a string containing infos about loaded input libraries. The string is
  * pre-formated to be used in xmount's info output.
  *
  * The caller must free the returned string.
  *
  * \param p_h Input handle
  * \param pp_info_text Info text is returned in this parameter
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetLibsInfoText(pts_XmountInputHandle p_h,
                                                  char **pp_info_text);
 
 /*!
  * \brief Add an input image
  *
  * Adds the given input image to the list of available input images.
  *
  * \param p_h Input handle
  * \param p_format Input image format string as given by the user
  * \param files_count Amount of files specified by the user
  * \param pp_files Array containing all specified files
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_AddImage(pts_XmountInputHandle p_h,
                                           const char *p_format,
                                           uint64_t files_count,
                                           const char **pp_files);
 
 /*!
  * \brief Get input image count
  *
  * Get input image count.
  *
  * \param p_h Input handle
  * \param p_count Input image count is returned in this variable
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetImageCount(pts_XmountInputHandle p_h,
                                                uint64_t *p_count);
 
 /*!
  * \brief Set an input image offset
  *
  * Sets the amount of bytes that should be ignored at the beginning of every
  * input image.
  *
  * \param p_h Input handle
  * \param offset Amount of bytes to ignore
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_SetInputOffset(pts_XmountInputHandle p_h,
                                                 uint64_t offset);
 
 /*!
  * \brief Set an input image size limit
  *
  * Sets the amount of bytes that should be ignored at the end of every
  * input image.
  *
  * \param p_h Input handle
  * \param size_limit Amount of bytes to ignore
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_SetInputSizeLimit(pts_XmountInputHandle p_h,
                                                    uint64_t size_limit);
 
 /*!
  * \brief Opens all added input images
  *
  * Opens all added input images.
  *
  * \param p_h Input handle
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_Open(pts_XmountInputHandle p_h);
 
 /*!
  * \brief Closes all previously opened input images
  *
  * Closes all previously opened input images.
  *
  * \param p_h Input handle
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_Close(pts_XmountInputHandle p_h);
 
 /*!
  * \brief Get the size of an input image
  *
  * Returns the size (in bytes) of the specified input image.
  *
  * \param p_h Input handle
  * \param image_nr Image number for which to return the size
  * \param p_size On success, size is returned in this variable
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetSize(pts_XmountInputHandle p_h,
                                          uint64_t image_nr,
                                          uint64_t *p_size);
 
 /*!
  * \brief Read data from an input image
  *
  * Reads count bytes from input image image_nr starting at given offset and
  * copies the data into p_buf.
  *
  * The given buffer must be pre-allocated to hold as many bytes as should be
  * read!
  *
  * \param p_h Input handle
  * \param image_nr Image number for which to return the size
  * \param p_buf Buffer into which to copy read data
  * \param offset Offset at which to start reading
  * \param count Amount of bytes to read
  * \param p_read On success, amount of bytes read is returned in this variable
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_ReadData(pts_XmountInputHandle p_h,
                                           uint64_t image_nr,
                                           char *p_buf,
                                           uint64_t offset,
                                           uint64_t count,
                                           uint64_t *p_read);
 
 te_XmountInput_Error XmountInput_WriteData(pts_XmountInputHandle p_h,
                                            uint64_t image_nr,
                                            const char *p_buf,
                                            uint64_t offset,
                                            uint64_t count);
 
 /*!
  * \brief Get info text to be added to xmount's info file
  *
  * Generates a string containing informations about currently opened input
  * images.
  *
  * The caller must free the returned string.
  *
  * \param p_h Input handle
  * \param pp_content Buffer in which text is returned
  * \return e_XmountInput_Error_None on success
  */
 te_XmountInput_Error XmountInput_GetInfoFileContent(pts_XmountInputHandle p_h,
                                                     char **pp_content);
 
 #endif // XMOUNT_INPUT_H
diff --git a/src/xmount_morphing.c b/src/xmount_morphing.c
index ea3fb42..ed691b2 100644
--- a/src/xmount_morphing.c
+++ b/src/xmount_morphing.c
@@ -1,316 +1,820 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
-#include <errno.h>
+#include <stdlib.h> // For calloc
 #include <string.h> // For memcpy
+#include <dlfcn.h> // For dlopen, dlclose, dlsym
 
+#include "../libxmount_morphing/libxmount_morphing.h"
 #include "xmount_morphing.h"
 #include "xmount.h"
 #include "macros.h"
 
+/*******************************************************************************
+ * Private definitions / macros
+ ******************************************************************************/
+
 #define LOG_WARNING(...) {            \
   LIBXMOUNT_LOG_WARNING(__VA_ARGS__); \
 }
 #define LOG_ERROR(...) {            \
   LIBXMOUNT_LOG_ERROR(__VA_ARGS__); \
 }
 #define LOG_DEBUG(...) {                              \
   LIBXMOUNT_LOG_DEBUG(glob_xmount.debug,__VA_ARGS__); \
 }
 
-//! Get size of morphed image
+/*******************************************************************************
+ * Private types / structures / enums
+ ******************************************************************************/
+
+//! Structure containing infos about morphing libs
+typedef struct s_XmountMorphingLib {
+  //! Filename of lib (without path)
+  char *p_name;
+  //! Handle to the loaded lib
+  void *p_lib;
+  //! Array of supported morphing types
+  char *p_supported_morphing_types;
+  //! Struct containing lib functions
+  ts_LibXmountMorphingFunctions lib_functions;
+} ts_XmountMorphingLib, *pts_XmountMorphingLib;
+
+//! Structures and vars needed for morph support
+typedef struct s_XmountMorphHandle {
+  //! Loaded morphing lib count
+  uint32_t libs_count;
+  //! Array containing infos about loaded morphing libs
+  pts_XmountMorphingLib *pp_libs;
+  //! Specified morphing type (--morph)
+  char *p_morph_type;
+  //! Amount of specified morphing lib params (--morphopts)
+  uint32_t lib_params_count;
+  //! Specified morphing lib params (--morphopts)
+  pts_LibXmountOptions *pp_lib_params;
+  //! Handle to initialized morphing lib
+  void *p_handle;
+  //! Morphing functions of initialized lib
+  pts_LibXmountMorphingFunctions p_functions;
+  //! Input image functions passed to morphing lib
+  ts_LibXmountMorphingInputFunctions input_image_functions;
+} ts_XmountMorphHandle;
+
+/*******************************************************************************
+ * Private functions declarations
+ ******************************************************************************/
 /*!
- * \param p_size Buf to save size to
- * \return TRUE on success, FALSE on error
+ * \brief Find an input lib for a given input image
+ *
+ * Searches trough the list of loaded input libraries to find one that supports
+ * the given input image's format. On success, that library is associated with
+ * the given image.
+ *
+ * \param p_h Input handle
+ * \param p_input_image Input image to search input lib for
+ * \return e_XmountInput_Error_None on success
  */
-int GetMorphedImageSize(uint64_t *p_size) {
-  int ret;
+/*
+te_XmountInput_Error XmountInput_FindLib(pts_XmountInputHandle p_h,
+                                         pts_XmountInputImage p_input_image);
+*/
+
+/*******************************************************************************
+ * Public functions implementations
+ ******************************************************************************/
+/*
+ * XmountMorphing_CreateHandle
+ */
+te_XmountMorphError XmountMorphing_CreateHandle(pts_XmountMorphHandle *pp_h) {
+  // Params check
+  if(pp_h==NULL) return e_XmountMorphError_InvalidHandlePointer;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_DestroyHandle
+ */
+te_XmountMorphError XmountMorphing_DestroyHandle(pts_XmountMorphHandle *pp_h) {
+  // Params check
+  if(pp_h==NULL) return e_XmountMorphError_InvalidHandlePointer;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_EnableDebugging
+ */
+te_XmountMorphError XmountMorphing_EnableDebugging(pts_XmountMorphHandle p_h) {
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_AddLibrary
+ */
+te_XmountMorphError XmountMorphing_AddLibrary(pts_XmountMorphHandle p_h,
+                                              const char *p_lib_name)
+{
+  uint32_t supported_types_len=0;
+  t_LibXmount_Morphing_GetApiVersion pfun_morphing_GetApiVersion;
+  t_LibXmount_Morphing_GetSupportedTypes pfun_morphing_GetSupportedTypes;
+  t_LibXmount_Morphing_GetFunctions pfun_morphing_GetFunctions;
+  void *p_libxmount=NULL;
+  pts_XmountMorphingLib p_morphing_lib=NULL;
+  char *p_buf=NULL;
+  char *p_library_path=NULL;
+  char *p_supported_types=NULL;
+
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(p_lib_name==NULL) return e_XmountMorphError_InvalidString;
+
+  // Construct full library path
+  XMOUNT_STRSET(p_library_path,XMOUNT_LIBRARY_PATH);
+  if(p_library_path[strlen(p_library_path)]!='/') {
+    XMOUNT_STRAPP(p_library_path,"/");
+  }
+  XMOUNT_STRAPP(p_library_path,p_lib_name);
+
+#define XMOUNTMORPHING_LOADLIBS__LOAD_SYMBOL(name,pfun) {        \
+  if((pfun=dlsym(p_libxmount,name))==NULL) {                     \
+    LOG_ERROR("Unable to load symbol '%s' from library '%s'!\n", \
+              name,                                              \
+              p_library_path);                                   \
+    dlclose(p_libxmount);                                        \
+    return e_XmountMorphError_FailedLoadingSymbol;               \
+  }                                                              \
+}
+
+  // Try to load given library
+  p_libxmount=dlopen(p_library_path,RTLD_NOW);
+  if(p_libxmount==NULL) {
+    LOG_ERROR("Unable to load morphing library '%s': %s!\n",
+              p_library_path,
+              dlerror());
+    return e_XmountMorphError_FailedLoadingLibrary;
+  }
+
+  // Load library symbols
+  XMOUNTMORPHING_LOADLIBS__LOAD_SYMBOL("LibXmount_Morphing_GetApiVersion",
+                                       pfun_morphing_GetApiVersion);
+
+  // Check library's API version
+  if(pfun_morphing_GetApiVersion()!=LIBXMOUNT_MORPHING_API_VERSION) {
+    LOG_DEBUG("Failed! Wrong API version.\n");
+    LOG_ERROR("Unable to load morphing library '%s'. Wrong API version\n",
+              p_library_path);
+    dlclose(p_libxmount);
+    return e_XmountMorphError_WrongLibraryApiVersion;
+  }
+
+  LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetSupportedTypes",
+                        pfun_morphing_GetSupportedTypes);
+  LIBXMOUNT_LOAD_SYMBOL("LibXmount_Morphing_GetFunctions",
+                        pfun_morphing_GetFunctions);
+
+  // Construct new entry for our library list
+  XMOUNT_MALLOC(p_morphing_lib,
+                pts_XmountMorphingLib,
+                sizeof(ts_XmountMorphingLib));
+  // Initialize lib_functions structure to NULL
+  memset(&(p_morphing_lib->lib_functions),
+         0,
+         sizeof(ts_LibXmountMorphingFunctions));
+
+  // Set name and handle
+  XMOUNT_STRSET(p_morphing_lib->p_name,p_lib_name);
+  p_morphing_lib->p_lib=p_libxmount;
+
+  // Get and set supported types
+  p_supported_types=pfun_morphing_GetSupportedTypes();
+  supported_types_len=0;
+  p_buf=p_supported_types;
+  while(*p_buf!='\0') {
+    supported_types_len+=(strlen(p_buf)+1);
+    p_buf+=(strlen(p_buf)+1);
+  }
+  supported_types_len++;
+  XMOUNT_MALLOC(p_morphing_lib->p_supported_morphing_types,
+                char*,
+                supported_types_len);
+  memcpy(p_morphing_lib->p_supported_morphing_types,
+         p_supported_types,
+         supported_types_len);
+
+  // Get, set and check lib_functions
+  pfun_morphing_GetFunctions(&(p_morphing_lib->lib_functions));
+  if(p_morphing_lib->lib_functions.CreateHandle==NULL ||
+     p_morphing_lib->lib_functions.DestroyHandle==NULL ||
+     p_morphing_lib->lib_functions.Morph==NULL ||
+     p_morphing_lib->lib_functions.Size==NULL ||
+     p_morphing_lib->lib_functions.Read==NULL ||
+     p_morphing_lib->lib_functions.OptionsHelp==NULL ||
+     p_morphing_lib->lib_functions.OptionsParse==NULL ||
+     p_morphing_lib->lib_functions.GetInfofileContent==NULL ||
+     p_morphing_lib->lib_functions.GetErrorMessage==NULL ||
+     p_morphing_lib->lib_functions.FreeBuffer==NULL)
+  {
+    LOG_DEBUG("Missing implemention of one or more functions in lib %s!\n",
+              p_lib_name);
+    XMOUNT_FREE(p_morphing_lib->p_supported_morphing_types);
+    XMOUNT_FREE(p_morphing_lib->p_name);
+    XMOUNT_FREE(p_morphing_lib);
+    dlclose(p_libxmount);
+    return e_XmountMorphError_MissingLibraryFunction;
+  }
+
+  // Add entry to the input library list
+  XMOUNT_REALLOC(p_h->pp_libs,
+                 pts_XmountMorphingLib*,
+                 sizeof(pts_XmountMorphingLib)*(p_h->libs_count+1));
+  p_h->pp_libs[p_h->libs_count++]=p_morphing_lib;
+
+  LOG_DEBUG("Morphing library '%s' loaded successfully\n",p_lib_name);
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_GetLibraryCount
+ */
+te_XmountMorphError XmountMorphing_GetLibraryCount(pts_XmountMorphHandle p_h,
+                                                   uint32_t *p_count)
+{
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_GetSupportedTypes
+ */
+te_XmountMorphError XmountMorphing_GetSupportedTypes(pts_XmountMorphHandle p_h,
+                                                     char **pp_types)
+{
+  char *p_buf=NULL;
+  char *p_types=NULL;
+  uint32_t cur_len=0;
+  uint32_t vector_len=0;
+
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(pp_types==NULL) return e_XmountMorphError_InvalidBuffer;
+
+  // Loop over all loaded libs, extract supported types and add to our vector
+  // TODO: IMPROVEMENT: Final vector could be sorted
+  for(uint32_t i=0;i<p_h->libs_count;i++) {
+    p_buf=p_h->pp_libs[i]->p_supported_morphing_types;
+    while(p_buf!=NULL && *p_buf!='\0') p_buf+=(strlen(p_buf)+1);
+    cur_len=(uint32_t)(p_buf-p_h->pp_libs[i]->p_supported_morphing_types);
+    if(cur_len==0) continue;
+    p_types=(char*)realloc(p_types,vector_len+cur_len);
+    if(p_types==NULL) return e_XmountInput_Error_Alloc;
+    memcpy(p_types+vector_len,
+           p_h->pp_libs[i]->p_supported_morphing_types,
+           cur_len);
+    vector_len+=cur_len;
+  }
+
+  // Null-terminate vector
+  p_types=(char*)realloc(p_types,vector_len+1);
+  if(p_types==NULL) return e_XmountInput_Error_Alloc;
+  p_types[vector_len]='\0';
+
+  *pp_types=p_types;
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_SetOptions
+ */
+te_XmountMorphError XmountMorphing_SetOptions(pts_XmountMorphHandle p_h,
+                                              char *p_options)
+{
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(p_options==NULL) return e_XmountMorphError_InvalidString;
+
+  // Make sure library parameters haven't been set previously
+  if(p_h->pp_lib_params!=NULL) {
+    LOG_ERROR("Morphing library options already set!\n");
+    return e_XmountMorphError_LibOptionsAlreadySet;
+  }
 
-  ret=glob_xmount.morphing.p_functions->Size(glob_xmount.morphing.p_handle,
-                                             p_size);
+  // Save options
+  if(XmountLib_SplitLibParams(p_options,
+                              &(p_h->lib_params_count),
+                              &(p_h->pp_lib_params))!=0)
+  {
+    LOG_ERROR("Unable to parse morphing library options '%s'!\n",p_options);
+    return e_XmountMorphError_FailedParsingOptions;
+  }
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_GetOptionsHelpText
+ */
+te_XmountMorphError XmountMorphing_GetOptionsHelpText(pts_XmountMorphHandle p_h,
+                                                      char **pp_help_text)
+{
+  const char *p_buf=NULL;
+  char *p_help=NULL;
+  int ret=0;
+
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(pp_help_text==NULL) return e_XmountMorphError_InvalidBuffer;
+
+  // Loop over all loaded libs, extract help and add to our text buffer
+  // TODO: IMPROVEMENT: Final text should be sorted by lib's name
+  for(uint32_t i=0;i<p_h->libs_count;i++) {
+    ret=p_h->pp_libs[i]->lib_functions.OptionsHelp(&p_buf);
+    if(ret!=0) {
+      LOG_ERROR("Unable to get options help for library '%s': %s!\n",
+                p_h->pp_libs[i]->p_name,
+                p_h->pp_libs[i]->lib_functions.GetErrorMessage(ret));
+      continue;
+    }
+    if(p_buf==NULL) continue;
+    XMOUNT_STRAPP(p_help,"  - ");
+    XMOUNT_STRAPP(p_help,p_h->pp_libs[i]->p_name);
+    XMOUNT_STRAPP(p_help,"\n");
+    XMOUNT_STRAPP(p_help,p_buf);
+    XMOUNT_STRAPP(p_help,"\n");
+    p_h->pp_libs[i]->lib_functions.FreeBuffer(p_buf);
+  }
+
+  *pp_help_text=p_help;
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphingt_GetLibsInfoText
+ */
+te_XmountMorphError XmountMorphing_GetLibsInfoText(pts_XmountMorphHandle p_h,
+                                                   char **pp_info_text)
+{
+  char *p_buf=NULL;
+  char *p_info_text=NULL;
+  uint8_t first=0;
+
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(pp_info_text==NULL) return e_XmountMorphError_InvalidBuffer;
+
+  // Loop over all loaded libs, extract name and supported types and add to
+  // our text buffer
+  // TODO: IMPROVEMENT: Final text should be sorted by lib's name
+  for(uint32_t i=0;i<p_h->libs_count;i++) {
+    XMOUNT_STRAPP(p_info_text,"    - ");
+    XMOUNT_STRAPP(p_info_text,p_h->pp_libs[i]->p_name);
+    XMOUNT_STRAPP(p_info_text," supporting ");
+    XMOUNT_STRAPP(p_info_text,"    - ");
+    XMOUNT_STRAPP(p_info_text,"    - ");
+    p_buf=p_h->pp_libs[i]->p_supported_morphing_types;
+    first=1;
+    while(*p_buf!='\0') {
+      if(first==1) {
+        XMOUNT_STRAPP(p_info_text,"\"");
+        XMOUNT_STRAPP(p_info_text,p_buf);
+        XMOUNT_STRAPP(p_info_text,"\"");
+        first=0;
+      } else {
+        XMOUNT_STRAPP(p_info_text,", \"");
+        XMOUNT_STRAPP(p_info_text,p_buf);
+        XMOUNT_STRAPP(p_info_text,"\"");
+      }
+      p_buf+=(strlen(p_buf)+1);
+    }
+    XMOUNT_STRAPP(p_info_text,"\n");
+  }
+
+  *pp_info_text=p_info_text;
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_SetType
+ */
+te_XmountMorphError XmountMorphing_SetType(pts_XmountMorphHandle p_h,
+                                           char *p_type)
+{
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(p_type==NULL) return e_XmountMorphError_InvalidString;
+
+  XMOUNT_STRSET(p_h->p_morph_type,p_type);
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_StartMorph
+ */
+te_XmountMorphError XmountMorphing_StartMorph(pts_XmountMorphHandle p_h) {
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountInput_StopMorph
+ */
+te_XmountMorphError XmountInput_StopMorph(pts_XmountMorphHandle p_h) {
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_GetSize
+ */
+te_XmountMorphError XmountMorphing_GetSize(pts_XmountMorphHandle p_h,
+                                           uint64_t *p_size)
+{
+  int ret=0;
+
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(p_size==NULL) return e_XmountMorphError_InvalidBuffer;
+
+  // Get morphed image size
+  ret=p_h->p_functions->Size(p_h->p_handle,p_size);
   if(ret!=0) {
     LOG_ERROR("Unable to get morphed image size: %s!\n",
-              glob_xmount.morphing.p_functions->GetErrorMessage(ret));
-    return FALSE;
+              p_h->p_functions->GetErrorMessage(ret));
+    return e_XmountMorphError_FailedGettingImageSize;
   }
 
-  return TRUE;
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_ReadData
+ */
+te_XmountMorphError XmountMorphing_ReadData(pts_XmountMorphHandle p_h,
+                                            char *p_buf,
+                                            uint64_t offset,
+                                            uint64_t count,
+                                            uint64_t *p_read)
+{
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
+}
+
+/*
+ * XmountMorphing_WriteData
+ */
+te_XmountMorphError XmountMorphing_WriteData(pts_XmountMorphHandle p_h,
+                                             const char *p_buf,
+                                             uint64_t offset,
+                                             uint64_t count)
+{
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+
+  // TODO: Impement
+
+  return e_XmountMorphError_None;
 }
 
+/*
+ * XmountMorphing_GetInfoFileContent
+ */
+te_XmountMorphError XmountMorphing_GetInfoFileContent(pts_XmountMorphHandle p_h,
+                                                      char **pp_content)
+{
+  int ret=0;
+  char *p_buf=NULL;
+  char *p_content=NULL;
+
+  // Params check
+  if(p_h==NULL) return e_XmountMorphError_InvalidHandle;
+  if(pp_content==NULL) return e_XmountMorphError_InvalidBuffer;
+
+  ret=p_h->p_functions->GetInfofileContent(p_h->p_handle,(const char**)&p_buf);
+  if(ret!=0) {
+    LOG_ERROR("Unable to get info file content from morphing lib: %s!\n",
+              p_h->p_functions->GetErrorMessage(ret));
+    return e_XmountMorphError_FailedGettingInfoFileContent;
+  }
+  // Add infos to main buffer and free p_buf
+  if(p_buf!=NULL) {
+    XMOUNT_STRAPP(p_content,p_buf);
+    p_h->p_functions->FreeBuffer(p_buf);
+  } else {
+    XMOUNT_STRAPP(p_content,"None\n");
+  }
+
+  *pp_content=p_content;
+  return e_XmountMorphError_None;
+}
+
+/*******************************************************************************
+ * Private functions implementations
+ ******************************************************************************/
+
 //! Read data from morphed image
 /*!
  * \param p_buf Pointer to buffer to write read data to (must be preallocated!)
  * \param offset Offset at which data should be read
  * \param size Size of data which should be read (size of buffer)
  * \param p_read Number of read bytes on success
  * \return TRUE on success, negated error code on error
  */
+/*
 int ReadMorphedImageData(char *p_buf,
                                 off_t offset,
                                 size_t size,
                                 size_t *p_read)
 {
   uint64_t block_off=0;
   uint64_t cur_block=0;
   uint64_t cur_to_read=0;
   uint64_t image_size=0;
   size_t read=0;
   size_t to_read=0;
   int ret;
   uint8_t is_block_cached=FALSE;
   te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   // Make sure we aren't reading past EOF of image file
   if(GetMorphedImageSize(&image_size)!=TRUE) {
     LOG_ERROR("Couldn't get size of morphed image!\n");
     return -EIO;
   }
   if(offset>=image_size) {
     // Offset is beyond image size
     LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
     *p_read=0;
     return FALSE;
   }
   if(offset+size>image_size) {
     // Attempt to read data past EOF of morphed image file
     to_read=image_size-offset;
     LOG_DEBUG("Attempt to read data past EOF of morphed image. Corrected size "
                 "from %zu to %" PRIu64 ".\n",
               size,
               to_read);
   } else to_read=size;
 
   // Calculate block to start reading data from
   cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
   block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
 
   // Read image data
   while(to_read!=0) {
     // Calculate how many bytes we have to read from this block
     if(block_off+to_read>XMOUNT_CACHE_BLOCK_SIZE) {
       cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-block_off;
     } else cur_to_read=to_read;
 
     // Determine if we have to read cached data
     is_block_cached=FALSE;
     if(glob_xmount.output.writable==TRUE) {
       cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
       if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
       else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
         LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
                     "Error code %u!\n",
                   cur_block,
                   cache_ret);
         return -EIO;
       }
     }
 
     // Check if block is cached
     if(is_block_cached==TRUE) {
       // Write support enabled and need to read altered data from cachefile
       LOG_DEBUG("Reading %zu bytes from block cache file\n",cur_to_read);
 
       cache_ret=XmountCache_BlockCacheRead(glob_xmount.h_cache,
                                            p_buf,
                                            cur_block,
                                            block_off,
                                            cur_to_read);
       if(cache_ret!=e_XmountCache_Error_None) {
         LOG_ERROR("Unable to read %" PRIu64
                     " bytes of cached data from cache block %" PRIu64
                     " at cache block offset %" PRIu64 ": Error code %u!\n",
                   cur_to_read,
                   cur_block,
                   block_off,
                   cache_ret);
         return -EIO;
       }
     } else {
       // No write support or data not cached
       ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
                                                  p_buf,
                                                  (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
                                                    block_off,
                                                  cur_to_read,
                                                  &read);
       if(ret!=0 || read!=cur_to_read) {
         LOG_ERROR("Couldn't read %zu bytes at offset %zu from morphed image: "
                     "%s!\n",
                   cur_to_read,
                   offset,
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
         return -EIO;
       }
       LOG_DEBUG("Read %" PRIu64 " bytes at offset %" PRIu64
                   " from morphed image file\n",
                 cur_to_read,
                 (cur_block*XMOUNT_CACHE_BLOCK_SIZE)+block_off);
     }
 
     cur_block++;
     block_off=0;
     p_buf+=cur_to_read;
     to_read-=cur_to_read;
   }
 
   *p_read=to_read;
   return TRUE;
 }
+*/
 
 //! Write data to morphed image
 /*!
  * \param p_buf Buffer with data to write
  * \param offset Offset to start writing at
  * \param count Amount of bytes to write
  * \param p_written Amount of successfully written bytes
  * \return TRUE on success, negated error code on error
  */
+/*
 int WriteMorphedImageData(const char *p_buf,
                                  off_t offset,
                                  size_t count,
                                  size_t *p_written)
 {
   uint64_t block_off=0;
   uint64_t cur_block=0;
   uint64_t cur_to_read=0;
   uint64_t cur_to_write=0;
   uint64_t image_size=0;
   uint64_t read=0;
   size_t written=0;
   size_t to_write=0;
   int ret;
   char *p_buf2=NULL;
   uint8_t is_block_cached=FALSE;
   te_XmountCache_Error cache_ret=e_XmountCache_Error_None;
 
   // Make sure we aren't writing past EOF of image file
   if(GetMorphedImageSize(&image_size)!=TRUE) {
     LOG_ERROR("Couldn't get size of morphed image!\n");
     return -EIO;
   }
   if(offset>=image_size) {
     // Offset is beyond image size
     LOG_DEBUG("Offset %zu is at / beyond size of morphed image.\n",offset);
     *p_written=0;
     return 0;
   }
   if(offset+count>image_size) {
     // Attempt to write data past EOF of morphed image file
     to_write=image_size-offset;
     LOG_DEBUG("Attempt to write data past EOF of morphed image. Corrected size "
                 "from %zu to %" PRIu64 ".\n",
               count,
               to_write);
   } else to_write=count;
 
   // Calculate block to start writing data to
   cur_block=offset/XMOUNT_CACHE_BLOCK_SIZE;
   block_off=offset%XMOUNT_CACHE_BLOCK_SIZE;
 
   while(to_write!=0) {
     // Calculate how many bytes we have to write to this block
     if(block_off+to_write>XMOUNT_CACHE_BLOCK_SIZE) {
       cur_to_write=XMOUNT_CACHE_BLOCK_SIZE-block_off;
     } else cur_to_write=to_write;
 
     // Determine if block is already in cache
     is_block_cached=FALSE;
     cache_ret=XmountCache_IsBlockCached(glob_xmount.h_cache,cur_block);
     if(cache_ret==e_XmountCache_Error_None) is_block_cached=TRUE;
     else if(cache_ret!=e_XmountCache_Error_UncachedBlock) {
       LOG_ERROR("Unable to determine if block %" PRIu64 " is cached: "
                   "Error code %u!\n",
                 cur_block,
                 cache_ret);
       return -EIO;
     }
 
     // Check if block is cached
     if(is_block_cached==TRUE) {
       // Block is cached
       cache_ret=XmountCache_BlockCacheWrite(glob_xmount.h_cache,
                                             p_buf,
                                             cur_block,
                                             block_off,
                                             cur_to_write);
       if(cache_ret!=e_XmountCache_Error_None) {
         LOG_ERROR("Unable to write %" PRIu64
                     " bytes of data to cache block %" PRIu64
                     " at cache block offset %" PRIu64 ": Error code %u!\n",
                   cur_to_write,
                   cur_block,
                   block_off,
                   cache_ret);
         return -EIO;
       }
 
       LOG_DEBUG("Wrote %" PRIu64 " bytes to block cache\n",cur_to_write);
     } else {
       // Uncached block. Need to cache entire new block
       // Prepare new write buffer
       XMOUNT_MALLOC(p_buf2,char*,XMOUNT_CACHE_BLOCK_SIZE);
       memset(p_buf2,0x00,XMOUNT_CACHE_BLOCK_SIZE);
 
       // Read full block from morphed image
       cur_to_read=XMOUNT_CACHE_BLOCK_SIZE;
       if((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+XMOUNT_CACHE_BLOCK_SIZE>image_size) {
         cur_to_read=XMOUNT_CACHE_BLOCK_SIZE-(((cur_block*XMOUNT_CACHE_BLOCK_SIZE)+
                                          XMOUNT_CACHE_BLOCK_SIZE)-image_size);
       }
       ret=glob_xmount.morphing.p_functions->Read(glob_xmount.morphing.p_handle,
                                                  p_buf2,
                                                  cur_block*XMOUNT_CACHE_BLOCK_SIZE,
                                                  cur_to_read,
                                                  &read);
       if(ret!=0 || read!=cur_to_read) {
         LOG_ERROR("Couldn't read %" PRIu64 " bytes at offset %zu "
                     "from morphed image: %s!\n",
                   cur_to_read,
                   offset,
                   glob_xmount.morphing.p_functions->GetErrorMessage(ret));
         XMOUNT_FREE(p_buf2);
         return -EIO;
       }
 
       // Set changed data
       memcpy(p_buf2+block_off,p_buf,cur_to_write);
 
       cache_ret=XmountCache_BlockCacheAppend(glob_xmount.h_cache,
                                              p_buf,
                                              cur_block);
       if(cache_ret!=e_XmountCache_Error_None) {
         LOG_ERROR("Unable to append new block cache block %" PRIu64
                     ": Error code %u!\n",
                   cur_block,
                   cache_ret);
         XMOUNT_FREE(p_buf2);
         return -EIO;
       }
       XMOUNT_FREE(p_buf2);
 
       LOG_DEBUG("Appended new block cache block %" PRIu64 "\n",cur_block);
     }
 
     block_off=0;
     cur_block++;
     p_buf+=cur_to_write;
     to_write-=cur_to_write;
   }
 
   *p_written=to_write;
   return TRUE;
 }
+*/
diff --git a/src/xmount_morphing.h b/src/xmount_morphing.h
index d0c0e10..c01e8d4 100644
--- a/src/xmount_morphing.h
+++ b/src/xmount_morphing.h
@@ -1,59 +1,286 @@
 /*******************************************************************************
 * xmount Copyright (c) 2008-2016 by Gillen Daniel <gillen.dan@pinguin.lu>      *
 *                                                                              *
 * This program is free software: you can redistribute it and/or modify it      *
 * under the terms of the GNU General Public License as published by the Free   *
 * Software Foundation, either version 3 of the License, or (at your option)    *
 * any later version.                                                           *
 *                                                                              *
 * This program is distributed in the hope that it will be useful, but WITHOUT  *
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or        *
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for     *
 * more details.                                                                *
 *                                                                              *
 * You should have received a copy of the GNU General Public License along with *
 * this program. If not, see <http://www.gnu.org/licenses/>.                    *
 *******************************************************************************/
 
 #ifndef XMOUNT_MORPHING_H
 #define XMOUNT_MORPHING_H
 
-#include "../libxmount_morphing/libxmount_morphing.h"
-
-//! Structure containing infos about morphing libs
-typedef struct s_MorphingLib {
-  //! Filename of lib (without path)
-  char *p_name;
-  //! Handle to the loaded lib
-  void *p_lib;
-  //! Array of supported morphing types
-  char *p_supported_morphing_types;
-  //! Struct containing lib functions
-  ts_LibXmountMorphingFunctions lib_functions;
-} ts_MorphingLib, *pts_MorphingLib;
-
-//! Structures and vars needed for morph support
-typedef struct s_MorphingData {
-  //! Loaded morphing lib count
-  uint32_t libs_count;
-  //! Array containing infos about loaded morphing libs
-  pts_MorphingLib *pp_libs;
-  //! Specified morphing type (--morph)
-  char *p_morph_type;
-  //! Amount of specified morphing lib params (--morphopts)
-  uint32_t lib_params_count;
-  //! Specified morphing lib params (--morphopts)
-  pts_LibXmountOptions *pp_lib_params;
-  //! Handle to initialized morphing lib
-  void *p_handle;
-  //! Morphing functions of initialized lib
-  pts_LibXmountMorphingFunctions p_functions;
-  //! Input image functions passed to morphing lib
-  ts_LibXmountMorphingInputFunctions input_image_functions;
-} ts_MorphingData;
-
-int GetMorphedImageSize(uint64_t*);
-int ReadMorphedImageData(char*, off_t, size_t, size_t*);
-int WriteMorphedImageData(const char*, off_t, size_t, size_t*);
+/*******************************************************************************
+ * Public definitions / macros
+ ******************************************************************************/
+//! Naming scheme of input libraries
+#define XMOUNT_MORPHING_LIBRARY_NAMING_SCHEME "libxmount_morph_"
+
+/*******************************************************************************
+ * Public types / structures / enums
+ ******************************************************************************/
+typedef struct s_XmountMorphHandle *pts_XmountMorphHandle;
+
+typedef enum e_XmountMorphError {
+  //! No error
+  e_XmountMorphError_None=0,
+  //! Error to allocate memory
+  e_XmountMorphError_Alloc,
+  //! Invalid input handle
+  e_XmountMorphError_InvalidHandle,
+  //! Invalid pointer to an input handle
+  e_XmountMorphError_InvalidHandlePointer,
+  //! A given buffer is invalid
+  e_XmountMorphError_InvalidBuffer,
+  //! A given string is invalid
+  e_XmountMorphError_InvalidString,
+  //! A given array is invalid
+  //e_XmountMorphError_InvalidArray,
+  //! Library options have already been set
+  e_XmountMorphError_LibOptionsAlreadySet,
+  //! Library options couldn't be parsed
+  e_XmountMorphError_FailedParsingOptions,
+  //! Unable to get info file content from library
+  e_XmountMorphError_FailedGettingInfoFileContent,
+  //! Unable to load library file
+  e_XmountMorphError_FailedLoadingLibrary,
+  //! Unable to load a library symbol
+  e_XmountMorphError_FailedLoadingSymbol,
+  //! Library has wrong API version
+  e_XmountMorphError_WrongLibraryApiVersion,
+  //! Library is missing a function
+  e_XmountMorphError_MissingLibraryFunction,
+/*
+  //! Unsupported input image format
+  e_XmountInput_Error_UnsupportedFormat,
+  //! Specified image number is incorrect
+  e_XmountInput_Error_NoSuchImage,
+  //! Unable to create input image handle
+  e_XmountInput_Error_FailedCreatingImageHandle,
+  //! Unable to parse input library options
+  e_XmountInput_Error_FailedParsingLibParams,
+  //! Unable to open input image
+  e_XmountInput_Error_FailedOpeningImage,
+*/
+  //! Unable to get image size
+  e_XmountMorphError_FailedGettingImageSize,
+/*
+  //! A specified offset is larger than a specified image
+  e_XmountInput_Error_OffsetExceedsImageSize,
+  //! A specified size limit is larger than a specified image
+  e_XmountInput_Error_SizelimitExceedsImageSize,
+  //! Unable to read data from input image
+  e_XmountInput_Error_FailedReadingData
+*/
+} te_XmountMorphError;
+
+/*******************************************************************************
+ * Public functions declarations
+ ******************************************************************************/
+/*!
+ * \brief Create new input handle
+ *
+ * Creates a new input handle.
+ *
+ * \param pp_h Pointer to input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_CreateHandle(pts_XmountMorphHandle *pp_h);
+
+/*!
+ * \brief Destroy input handle
+ *
+ * Invalidates the given handle and frees all used resources.
+ *
+ * \param pp_h Pointer to input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_DestroyHandle(pts_XmountMorphHandle *pp_h);
+
+/*!
+ * \brief Enable internal debugging
+ *
+ * Enables the generation of intrernal debugging messages.
+ *
+ * \param p_h Input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_EnableDebugging(pts_XmountMorphHandle p_h);
+
+/*!
+ * \brief Load an input library
+ *
+ * Loads a given input library.
+ *
+ * \param p_h Input handle
+ * \param p_lib Library name (without path)
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_AddLibrary(pts_XmountMorphHandle p_h,
+                                              const char *p_lib_name);
+
+/*!
+ * \brief Get loaded input library count
+ *
+ * Returns the number of successfully loaded input libraries.
+ *
+ * \param p_h Input handle
+ * \param p_count Library count is returned in this variable
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_GetLibraryCount(pts_XmountMorphHandle p_h,
+                                                   uint32_t *p_count);
+
+/*!
+ * \brief Return all supported morphing types
+ *
+ * Returns a null-terminated vector of all supported morphing types.
+ *
+ * The returned vector must be freed by the caller.
+ *
+ * \param p_h Morphing handle
+ * \param pp_types Supported types vector is returned in this var
+ * \return e_XmountMorphError_None on success
+ */
+te_XmountMorphError XmountMorphing_GetSupportedTypes(pts_XmountMorphHandle p_h,
+                                                     char **pp_types);
+
+/*!
+ * \brief Set library options
+ *
+ * Parses the given library option string (as given after --inopts).
+ *
+ * \param p_h Input handle
+ * \param p_options Library option string
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_SetOptions(pts_XmountMorphHandle p_h,
+                                              char *p_options);
+
+/*!
+ * \brief Return all library specific option help texts
+ *
+ * Returns a string containing help messages for all loaded input lib options.
+ * The string is pre-formated to be used in xmount's help output.
+ *
+ * The caller must free the returned string.
+ *
+ * \param p_h Input handle
+ * \param pp_help_text Help text is returned in this parameter
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_GetOptionsHelpText(pts_XmountMorphHandle p_h,
+                                                      char **pp_help_text);
+
+/*!
+ * \brief Returns a string containing infos about loaded libs
+ *
+ * Returns a string containing infos about loaded input libraries. The string is
+ * pre-formated to be used in xmount's info output.
+ *
+ * The caller must free the returned string.
+ *
+ * \param p_h Input handle
+ * \param pp_info_text Info text is returned in this parameter
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_GetLibsInfoText(pts_XmountMorphHandle p_h,
+                                                    char **pp_info_text);
+
+/*!
+ * \brief Set morphing type
+ *
+ * Set the morphing type that should be applied to the input image.
+ *
+ * \param p_h Input handle
+ * \param p_type Morphing type string as specified with xmount's --morph option.
+ * \return e_XmountMorphError_None on success
+ */
+te_XmountMorphError XmountMorphing_SaetType(pts_XmountMorphHandle p_h,
+                                            char *p_type);
+
+/*!
+ * \brief Opens all added input images
+ *
+ * Opens all added input images.
+ *
+ * \param p_h Input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_StartMorphing(pts_XmountMorphHandle p_h);
+
+/*!
+ * \brief Closes all previously opened input images
+ *
+ * Closes all previously opened input images.
+ *
+ * \param p_h Input handle
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountInput_StopMorphing(pts_XmountMorphHandle p_h);
+
+/*!
+ * \brief Get the size of an input image
+ *
+ * Returns the size (in bytes) of the specified input image.
+ *
+ * \param p_h Input handle
+ * \param image_nr Image number for which to return the size
+ * \param p_size On success, size is returned in this variable
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_GetSize(pts_XmountMorphHandle p_h,
+                                           uint64_t *p_size);
+
+/*!
+ * \brief Read data from an input image
+ *
+ * Reads count bytes from input image image_nr starting at given offset and
+ * copies the data into p_buf.
+ *
+ * The given buffer must be pre-allocated to hold as many bytes as should be
+ * read!
+ *
+ * \param p_h Input handle
+ * \param image_nr Image number for which to return the size
+ * \param p_buf Buffer into which to copy read data
+ * \param offset Offset at which to start reading
+ * \param count Amount of bytes to read
+ * \param p_read On success, amount of bytes read is returned in this variable
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_ReadData(pts_XmountMorphHandle p_h,
+                                            char *p_buf,
+                                            uint64_t offset,
+                                            uint64_t count,
+                                            uint64_t *p_read);
+
+te_XmountMorphError XmountMorphing_WriteData(pts_XmountMorphHandle p_h,
+                                             const char *p_buf,
+                                             uint64_t offset,
+                                             uint64_t count);
+
+/*!
+ * \brief Get info text to be added to xmount's info file
+ *
+ * Generates a string containing informations about currently opened input
+ * images.
+ *
+ * The caller must free the returned string.
+ *
+ * \param p_h Input handle
+ * \param pp_content Buffer in which text is returned
+ * \return e_XmountInput_Error_None on success
+ */
+te_XmountMorphError XmountMorphing_GetInfoFileContent(pts_XmountMorphHandle p_h,
+                                                      char **pp_content);
 
 #endif // XMOUNT_MORPHING_H