Some aspects of madCodeHook can be modified. For this there's a global function available named "SetMadCHookOption". It allows you to change all available madCodeHook options.

function SetMadCHookOption (option: dword; param: PWideChar) : bool; stdcall;

  // before installing an API hook madCodeHook does some security checks
  // one check is verifying whether the to be hooked code was already modified
  // in this case madCodeHook does not tempt to modify the code another time
  // otherwise there would be a danger to run into stability issues
  // with protected/compressed modules there may be false alarms, though
  // so you can turn this check off
  // param: unsused

  // when calling SendIpcMessage you can specify a timeout value
  // this value only applies to how long madCodeHook waits for the reply
  // there's an additional internal timeout value which specifies how long
  // madCodeHook waits for the IPC message to be accepted by the queue owner
  // the default value is 7000ms
  // param: internal timeout value in ms
  // example: SetMadCHookOption(SET_INTERNAL_IPC_TIMEOUT, PWideChar(5000));

  // system wide dll injection normally injects the hook dll into both:
  // (1) currently running processes
  // (2) newly created processes
  // this flag disables injection into already running processes
  // param: unused

  // normally madCodeHook renews hooks only when they were removed
  // hooks that were overwritten with some other code aren't renewed by default
  // this behaviour allows other hooking libraries to co-exist with madCodeHook
  // use this flag to force madCodeHook to always renew hooks
  // this may result in other hooking libraries stopping to work correctly
  // param: unused

  // system wide dll injection normally injects the hook dll into both:
  // (1) currently running processes
  // (2) newly created processes
  // this option enabled/disables injection into already running processes
  // param: bool
  // default: true

  // system wide dll uninjection normally does two things:
  // (1) uninjecting from all running processes
  // (2) stop automatic injection into newly created processes
  // this option controls if uninjection from running processes is performed
  // param: bool
  // default: true

  // by default madCodeHook allocates at <= $71af0000
  // you can tell madCodeHook to allocate at the address you prefer
  // param: LPVOID (must be < $80000000)
  // default: $71af0000
  X86_ALLOCATION_ADDRESS = $0000000c;

  // By default madCodeHook performs several hook address verifications.
  // You can disable that to save performance, but that means it's your
  // responsibility then to provide proper addresses.
  // Hook address verification includes things such as bypassing existing
  // import/export table manipulations etc.
  // param: bool
  // default: true
  VERIFY_HOOK_ADDRESS = $0000000d;

  // By default madCodeHook disassembles the whole to-be-hooked API/code,
  // to make sure it can be hooked without stability issues. You can disable
  // this check, but if that produces stability issues, that's on your head.
  // param: bool
  // default: true
  DISASM_HOOK_TARGET = $0000000e;

  // madCodeHook has two different IPC solutions built in
  // in Vista+ and in all 64 bit OSs the "old" IPC solution doesn't work
  // so in these OSs the new IPC solution is always used
  // in older OSs the old solution works, but the new one is used by default
  // the new solution is based on undocumented internal Windows LPC APIs
  // the old solution is based on pipes and memory mapped files
  // you can optionally force the old IPC solution for the older OSs
  // param: unused
  USE_OLD_IPC_LOGIC = $0000000f;

  // the IPC port is usually accessible by Everyone
  // if you prefer, you can assign limited access rights to the port
  // only SYSTEM and the creator then have access rights
  // this is not recommended because it may block communication
  // so don't use it, unless you know exactly what you're doing
  // param: bool
  // default: false
  LIMITED_IPC_PORT = $00000010;