Mac OS X version compiles and links. I hope I didn't break too many files on windows/linux.

Added switches.inc to all files.
Changed many IFDEFs.
For Windows-only code please use MSWINDOWS instead of WIN32 now. WIN32 is also used by the Mac port.

git-svn-id: svn://svn.code.sf.net/p/ultrastardx/svn/trunk@546 b956fd51-792f-4845-bead-9b4dfca2ff2c

6 files changed, 3478 insertions, 3 deletions

diff --git a/Game/Code/lib/FreeImage/FreeBitmap.pas b/Game/Code/lib/FreeImage/FreeBitmap.pas
new file mode 100755
index 00000000..47be822e
--- /dev/null
+++ b/Game/Code/lib/FreeImage/FreeBitmap.pas
@@ -0,0 +1,1740 @@
+unit FreeBitmap;

+

+{$I switches.inc}

+

+

+// ==========================================================

+//

+// Delphi wrapper for FreeImage 3

+//

+// Design and implementation by

+// - Anatoliy Pulyaevskiy (xvel84@rambler.ru)

+//

+// Contributors:

+// - Enzo Costantini (enzocostantini@libero.it)

+//

+// This file is part of FreeImage 3

+//

+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY

+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES

+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE

+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED

+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT

+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY

+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL

+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER

+// THIS DISCLAIMER.

+//

+// Use at your own risk!

+//

+// ==========================================================

+//

+// From begining all code of this file is based on C++ wrapper to

+// FreeImage - FreeImagePlus.

+//

+// ==========================================================

+

+interface

+

+uses

+  SysUtils, Classes, Windows, FreeImage;

+

+type

+  { TFreeObject }

+

+  TFreeObject = class(TObject)

+  public

+    function IsValid: Boolean; virtual;

+  end;

+

+  { TFreeTag }

+

+  TFreeTag = class(TFreeObject)

+  private

+    // fields

+    FTag: PFITAG;

+

+    // getters & setters

+    function GetCount: Cardinal;

+    function GetDescription: string;

+    function GetID: Word;

+    function GetKey: string;

+    function GetLength: Cardinal;

+    function GetTagType: FREE_IMAGE_MDTYPE;

+    function GetValue: Pointer;

+    procedure SetCount(const Value: Cardinal);

+    procedure SetDescription(const Value: string);

+    procedure SetID(const Value: Word);

+    procedure SetKey(const Value: string);

+    procedure SetLength(const Value: Cardinal);

+    procedure SetTagType(const Value: FREE_IMAGE_MDTYPE);

+    procedure SetValue(const Value: Pointer);

+  public

+    // construction & destruction

+    constructor Create(ATag: PFITAG = nil); virtual;

+    destructor Destroy; override;

+

+    // methods

+    function Clone: TFreeTag;

+    function IsValid: Boolean; override;

+    function ToString(Model: FREE_IMAGE_MDMODEL; Make: PChar = nil): string;

+

+    // properties

+    property Key: string read GetKey write SetKey;

+    property Description: string read GetDescription write SetDescription;

+    property ID: Word read GetID write SetID;

+    property TagType: FREE_IMAGE_MDTYPE read GetTagType write SetTagType;

+    property Count: Cardinal read GetCount write SetCount;

+    property Length: Cardinal read GetLength write SetLength;

+    property Value: Pointer read GetValue write SetValue;

+    property Tag: PFITAG read FTag;

+  end;

+

+  { forward declarations }

+

+  TFreeBitmap = class;

+  TFreeMemoryIO = class;

+

+  { TFreeBitmap }

+

+  TFreeBitmapChangingEvent = procedure(Sender: TFreeBitmap; var OldDib, NewDib: PFIBITMAP; var Handled: Boolean) of object;

+

+  TFreeBitmap = class(TFreeObject)

+  private

+    // fields

+    FDib: PFIBITMAP;

+    FOnChange: TNotifyEvent;

+    FOnChanging: TFreeBitmapChangingEvent;

+

+    procedure SetDib(Value: PFIBITMAP);

+  protected

+    function DoChanging(var OldDib, NewDib: PFIBITMAP): Boolean; dynamic;

+    function Replace(NewDib: PFIBITMAP): Boolean; dynamic;

+  public

+    constructor Create(ImageType: FREE_IMAGE_TYPE = FIT_BITMAP; Width: Integer = 0; Height: Integer = 0; Bpp: Integer = 0);

+    destructor Destroy; override;

+    function SetSize(ImageType: FREE_IMAGE_TYPE; Width, Height, Bpp: Integer; RedMask: Cardinal = 0; GreenMask: Cardinal = 0; BlueMask: Cardinal = 0): Boolean;

+    procedure Change; dynamic;

+    procedure Assign(Source: TFreeBitmap);

+    function CopySubImage(Left, Top, Right, Bottom: Integer; Dest: TFreeBitmap): Boolean;

+    function PasteSubImage(Src: TFreeBitmap; Left, Top: Integer; Alpha: Integer = 256): Boolean;

+    procedure Clear; virtual;

+    function Load(const FileName: string; Flag: Integer = 0): Boolean;

+    function LoadU(const FileName: WideString; Flag: Integer = 0): Boolean;

+    function LoadFromHandle(IO: PFreeImageIO; Handle: fi_handle; Flag: Integer = 0): Boolean;

+    function LoadFromMemory(MemIO: TFreeMemoryIO; Flag: Integer = 0): Boolean;

+    function LoadFromStream(Stream: TStream; Flag: Integer = 0): Boolean;

+    // save functions

+    function CanSave(fif: FREE_IMAGE_FORMAT): Boolean;

+    function Save(const FileName: string; Flag: Integer = 0): Boolean;

+    function SaveU(const FileName: WideString; Flag: Integer = 0): Boolean;

+    function SaveToHandle(fif: FREE_IMAGE_FORMAT; IO: PFreeImageIO; Handle: fi_handle; Flag: Integer = 0): Boolean;

+    function SaveToMemory(fif: FREE_IMAGE_FORMAT; MemIO: TFreeMemoryIO; Flag: Integer = 0): Boolean;

+    function SaveToStream(fif: FREE_IMAGE_FORMAT; Stream: TStream; Flag: Integer = 0): Boolean;

+    // image information

+    function GetImageType: FREE_IMAGE_TYPE;

+    function GetWidth: Integer;

+    function GetHeight: Integer;

+    function GetScanWidth: Integer;

+    function IsValid: Boolean; override;

+    function GetInfo: PBitmapInfo;

+    function GetInfoHeader: PBitmapInfoHeader;

+    function GetImageSize: Cardinal;

+    function GetBitsPerPixel: Integer;

+    function GetLine: Integer;

+    function GetHorizontalResolution: Double;

+    function GetVerticalResolution: Double;

+    procedure SetHorizontalResolution(Value: Double);

+    procedure SetVerticalResolution(Value: Double);

+    // palette operations

+    function GetPalette: PRGBQUAD;

+    function GetPaletteSize: Integer;

+    function GetColorsUsed: Integer;

+    function GetColorType: FREE_IMAGE_COLOR_TYPE;

+    function IsGrayScale: Boolean;

+    // pixels access

+    function AccessPixels: PByte;

+    function GetScanLine(ScanLine: Integer): PByte;

+    function GetPixelIndex(X, Y: Cardinal; var Value: PByte): Boolean;

+    function GetPixelColor(X, Y: Cardinal; Value: PRGBQUAD): Boolean;

+    function SetPixelIndex(X, Y: Cardinal; Value: PByte): Boolean;

+    function SetPixelColor(X, Y: Cardinal; Value: PRGBQUAD): Boolean;

+    // convertion

+    function ConvertToStandardType(ScaleLinear: Boolean): Boolean;

+    function ConvertToType(ImageType: FREE_IMAGE_TYPE; ScaleLinear: Boolean): Boolean;

+    function Threshold(T: Byte): Boolean;

+    function ConvertTo4Bits: Boolean;

+    function ConvertTo8Bits: Boolean;

+    function ConvertTo16Bits555: Boolean;

+    function ConvertTo16Bits565: Boolean;

+    function ConvertTo24Bits: Boolean;

+    function ConvertTo32Bits: Boolean;

+    function ConvertToGrayscale: Boolean;

+    function ColorQuantize(Algorithm: FREE_IMAGE_QUANTIZE): Boolean;

+    function Dither(Algorithm: FREE_IMAGE_DITHER): Boolean;

+    function ConvertToRGBF: Boolean;

+    function ToneMapping(TMO: FREE_IMAGE_TMO; FirstParam, SecondParam: Double): Boolean;

+    // transparency

+    function IsTransparent: Boolean;

+    function GetTransparencyCount: Cardinal;

+    function GetTransparencyTable: PByte;

+    procedure SetTransparencyTable(Table: PByte; Count: Integer);

+    function HasFileBkColor: Boolean;

+    function GetFileBkColor(var BkColor: PRGBQuad): Boolean;

+    function SetFileBkColor(BkColor: PRGBQuad): Boolean;

+    // channel processing routines

+    function GetChannel(Bitmap: TFreeBitmap; Channel: FREE_IMAGE_COLOR_CHANNEL): Boolean;

+    function SetChannel(Bitmap: TFreeBitmap; Channel: FREE_IMAGE_COLOR_CHANNEL): Boolean;

+    function SplitChannels(RedChannel, GreenChannel, BlueChannel: TFreeBitmap): Boolean;

+    function CombineChannels(Red, Green, Blue: TFreeBitmap): Boolean;

+    // rotation and flipping

+    function RotateEx(Angle, XShift, YShift, XOrigin, YOrigin: Double; UseMask: Boolean): Boolean;

+    function Rotate(Angle: Double): Boolean;

+    function FlipHorizontal: Boolean;

+    function FlipVertical: Boolean;

+    // color manipulation routines

+    function Invert: Boolean;

+    function AdjustCurve(Lut: PByte; Channel: FREE_IMAGE_COLOR_CHANNEL): Boolean;

+    function AdjustGamma(Gamma: Double): Boolean;

+    function AdjustBrightness(Percentage: Double): Boolean;

+    function AdjustContrast(Percentage: Double): Boolean;

+    function GetHistogram(Histo: PDWORD; Channel: FREE_IMAGE_COLOR_CHANNEL = FICC_BLACK): Boolean;

+    // upsampling / downsampling

+    procedure MakeThumbnail(const Width, Height: Integer; DestBitmap: TFreeBitmap);

+    function Rescale(NewWidth, NewHeight: Integer; Filter: FREE_IMAGE_FILTER; Dest: TFreeBitmap = nil): Boolean;

+    // metadata routines

+    function FindFirstMetadata(Model: FREE_IMAGE_MDMODEL; var Tag: TFreeTag): PFIMETADATA;

+    function FindNextMetadata(MDHandle: PFIMETADATA; var Tag: TFreeTag): Boolean;

+    procedure FindCloseMetadata(MDHandle: PFIMETADATA);

+    function SetMetadata(Model: FREE_IMAGE_MDMODEL; const Key: string; Tag: TFreeTag): Boolean;

+    function GetMetadata(Model: FREE_IMAGE_MDMODEL; const Key: string; var Tag: TFreeTag): Boolean;

+    function GetMetadataCount(Model: FREE_IMAGE_MDMODEL): Cardinal;

+

+    // properties

+    property Dib: PFIBITMAP read FDib write SetDib;

+    property OnChange: TNotifyEvent read FOnChange write FOnChange;

+    property OnChanging: TFreeBitmapChangingEvent read FOnChanging write FOnChanging;

+  end;

+  

+  { TFreeWinBitmap }

+

+

+  { TFreeMemoryIO }

+

+  TFreeMemoryIO = class(TFreeObject)

+  private

+    FHMem: PFIMEMORY;

+  public

+    // construction and destruction

+    constructor Create(Data: PByte = nil; SizeInBytes: DWORD = 0);

+    destructor Destroy; override;

+

+    function GetFileType: FREE_IMAGE_FORMAT;

+    function Read(fif: FREE_IMAGE_FORMAT; Flag: Integer = 0): PFIBITMAP;

+    function Write(fif: FREE_IMAGE_FORMAT; dib: PFIBITMAP; Flag: Integer = 0): Boolean;

+    function Tell: Longint;

+    function Seek(Offset: Longint; Origin: Word): Boolean;

+    function Acquire(var Data: PByte; var SizeInBytes: DWORD): Boolean;

+    // overriden methods

+    function IsValid: Boolean; override;

+  end;

+

+  { TFreeMultiBitmap }

+

+  TFreeMultiBitmap = class(TFreeObject)

+  private

+    FMPage: PFIMULTIBITMAP;

+    FMemoryCache: Boolean;

+  public

+    // constructor and destructor

+    constructor Create(KeepCacheInMemory: Boolean = False);

+    destructor Destroy; override;

+

+    // methods

+    function Open(const FileName: string; CreateNew, ReadOnly: Boolean; Flags: Integer = 0): Boolean;

+    function Close(Flags: Integer = 0): Boolean;

+    function GetPageCount: Integer;

+    procedure AppendPage(Bitmap: TFreeBitmap);

+    procedure InsertPage(Page: Integer; Bitmap: TFreeBitmap);

+    procedure DeletePage(Page: Integer);

+    function MovePage(Target, Source: Integer): Boolean;

+    procedure LockPage(Page: Integer; DestBitmap: TFreeBitmap);

+    procedure UnlockPage(Bitmap: TFreeBitmap; Changed: Boolean);

+    function GetLockedPageNumbers(var Pages: Integer; var Count: Integer): Boolean;    

+    // overriden methods

+    function IsValid: Boolean; override;

+

+    // properties

+    // change of this property influences only on the next opening of a file

+    property MemoryCache: Boolean read FMemoryCache write FMemoryCache;

+  end;

+

+implementation

+

+const

+  ThumbSize = 150;

+

+// marker used for clipboard copy / paste

+

+procedure SetFreeImageMarker(bmih: PBitmapInfoHeader; dib: PFIBITMAP);

+begin

+  // Windows constants goes from 0L to 5L

+	// Add $FF to avoid conflicts

+	bmih.biCompression := $FF + FreeImage_GetImageType(dib);

+end;

+

+function GetFreeImageMarker(bmih: PBitmapInfoHeader): FREE_IMAGE_TYPE;

+begin

+  Result := FREE_IMAGE_TYPE(bmih.biCompression - $FF);

+end;

+

+{ TFreePersistent }

+

+function TFreeObject.IsValid: Boolean;

+begin

+  Result := False

+end;

+

+{ TFreeBitmap }

+

+function TFreeBitmap.AccessPixels: PByte;

+begin

+  Result := FreeImage_GetBits(FDib)

+end;

+

+function TFreeBitmap.AdjustBrightness(Percentage: Double): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_AdjustBrightness(FDib, Percentage);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.AdjustContrast(Percentage: Double): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_AdjustContrast(FDib, Percentage);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.AdjustCurve(Lut: PByte;

+  Channel: FREE_IMAGE_COLOR_CHANNEL): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_AdjustCurve(FDib, Lut, Channel);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.AdjustGamma(Gamma: Double): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_AdjustGamma(FDib, Gamma);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+procedure TFreeBitmap.Assign(Source: TFreeBitmap);

+var

+  SourceBmp: TFreeBitmap;

+  Clone: PFIBITMAP;

+begin

+  if Source = nil then

+  begin

+    Clear;

+    Exit;

+  end;

+  

+  if Source is TFreeBitmap then

+  begin

+    SourceBmp := TFreeBitmap(Source);

+    if SourceBmp <> Self then

+    begin

+      if SourceBmp.IsValid then

+      begin

+        Clone := FreeImage_Clone(SourceBmp.FDib);

+        Replace(Clone);

+      end

+      else

+        Clear;

+    end;

+  end;

+end;

+

+function TFreeBitmap.CanSave(fif: FREE_IMAGE_FORMAT): Boolean;

+var

+  ImageType: FREE_IMAGE_TYPE;

+  Bpp: Word;

+begin

+  Result := False;

+  if not IsValid then Exit;

+

+  if fif <> FIF_UNKNOWN then

+  begin

+    // check that the dib can be saved in this format

+    ImageType := FreeImage_GetImageType(FDib);

+    if ImageType = FIT_BITMAP then

+    begin

+      // standard bitmap type

+      Bpp := FreeImage_GetBPP(FDib);

+      Result := FreeImage_FIFSupportsWriting(fif)

+                and FreeImage_FIFSupportsExportBPP(fif, Bpp);

+    end

+    else // special bitmap type

+      Result := FreeImage_FIFSupportsExportType(fif, ImageType);

+  end;

+end;

+

+procedure TFreeBitmap.Change;

+begin

+  if Assigned(FOnChange) then FOnChange(Self)

+end;

+

+procedure TFreeBitmap.Clear;

+begin

+  if FDib <> nil then

+  begin

+    FreeImage_Unload(FDib);

+    FDib := nil;

+    Change;

+  end;

+end;

+

+function TFreeBitmap.ColorQuantize(

+  Algorithm: FREE_IMAGE_QUANTIZE): Boolean;

+var

+  dib8: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib8 := FreeImage_ColorQuantize(FDib, Algorithm);

+    Result := Replace(dib8);

+  end

+  else

+    Result := False;

+end;

+

+function TFreeBitmap.CombineChannels(Red, Green,

+  Blue: TFreeBitmap): Boolean;

+var

+  Width, Height: Integer;

+begin

+  if FDib = nil then

+  begin

+    Width := Red.GetWidth;

+    Height := Red.GetHeight;

+    FDib := FreeImage_Allocate(Width, Height, 24, FI_RGBA_RED_MASK,

+            FI_RGBA_GREEN_MASK, FI_RGBA_BLUE_MASK);

+  end;

+

+  if FDib <> nil then

+  begin

+    Result := FreeImage_SetChannel(FDib, Red.FDib, FICC_RED) and

+              FreeImage_SetChannel(FDib, Green.FDib, FICC_GREEN) and

+              FreeImage_SetChannel(FDib, Blue.FDib, FICC_BLUE);

+

+    Change

+  end

+  else

+    Result := False;

+end;

+

+function TFreeBitmap.ConvertTo16Bits555: Boolean;

+var

+  dib16_555: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib16_555 := FreeImage_ConvertTo16Bits555(FDib);

+    Result := Replace(dib16_555);

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.ConvertTo16Bits565: Boolean;

+var

+  dib16_565: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib16_565 := FreeImage_ConvertTo16Bits565(FDib);

+    Result := Replace(dib16_565);

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.ConvertTo24Bits: Boolean;

+var

+  dibRGB: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dibRGB := FreeImage_ConvertTo24Bits(FDib);

+    Result := Replace(dibRGB);

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.ConvertTo32Bits: Boolean;

+var

+  dib32: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib32 := FreeImage_ConvertTo32Bits(FDib);

+    Result := Replace(dib32);

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.ConvertTo4Bits: Boolean;

+var

+  dib4: PFIBITMAP;

+begin

+  Result := False;

+  if IsValid then

+  begin

+    dib4 := FreeImage_ConvertTo4Bits(FDib);

+    Result := Replace(dib4);

+  end;

+end;

+

+function TFreeBitmap.ConvertTo8Bits: Boolean;

+var

+  dib8: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib8 := FreeImage_ConvertTo8Bits(FDib);

+    Result := Replace(dib8);

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.ConvertToGrayscale: Boolean;

+var

+  dib8: PFIBITMAP;

+begin

+  Result := False;

+

+  if IsValid then

+  begin

+    dib8 := FreeImage_ConvertToGreyscale(FDib);

+    Result := Replace(dib8);

+  end

+end;

+

+function TFreeBitmap.ConvertToRGBF: Boolean;

+var

+  ImageType: FREE_IMAGE_TYPE;

+  NewDib: PFIBITMAP;

+begin

+  Result := False;

+  if not IsValid then Exit;

+

+  ImageType := GetImageType;

+

+  if (ImageType = FIT_BITMAP) then

+  begin

+    if GetBitsPerPixel < 24 then

+      if not ConvertTo24Bits then

+        Exit

+  end;

+  NewDib := FreeImage_ConvertToRGBF(FDib);

+  Result := Replace(NewDib);

+end;

+

+function TFreeBitmap.ConvertToStandardType(ScaleLinear: Boolean): Boolean;

+var

+  dibStandard: PFIBITMAP;

+begin

+  if IsValid then

+  begin

+    dibStandard := FreeImage_ConvertToStandardType(FDib, ScaleLinear);

+    Result := Replace(dibStandard);

+  end

+  else

+    Result := False;

+end;

+

+function TFreeBitmap.ConvertToType(ImageType: FREE_IMAGE_TYPE;

+  ScaleLinear: Boolean): Boolean;

+var

+  dib: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib := FreeImage_ConvertToType(FDib, ImageType, ScaleLinear);

+    Result := Replace(dib)

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.CopySubImage(Left, Top, Right, Bottom: Integer;

+  Dest: TFreeBitmap): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Dest.FDib := FreeImage_Copy(FDib, Left, Top, Right, Bottom);

+    Result := Dest.IsValid;

+  end else

+    Result := False;

+end;

+

+constructor TFreeBitmap.Create(ImageType: FREE_IMAGE_TYPE; Width, Height,

+  Bpp: Integer);

+begin

+  inherited Create;

+

+  FDib := nil;

+  if (Width > 0) and (Height > 0) and (Bpp > 0) then

+    SetSize(ImageType, Width, Height, Bpp);

+end;

+

+destructor TFreeBitmap.Destroy;

+begin

+  if FDib <> nil then

+    FreeImage_Unload(FDib);

+  inherited;

+end;

+

+function TFreeBitmap.Dither(Algorithm: FREE_IMAGE_DITHER): Boolean;

+var

+  dib: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib := FreeImage_Dither(FDib, Algorithm);

+    Result := Replace(dib);

+  end

+  else

+    Result := False;

+end;

+

+function TFreeBitmap.DoChanging(var OldDib, NewDib: PFIBITMAP): Boolean;

+begin

+  Result := False;

+  if (OldDib <> NewDib) and Assigned(FOnChanging) then

+    FOnChanging(Self, OldDib, NewDib, Result);

+end;

+

+procedure TFreeBitmap.FindCloseMetadata(MDHandle: PFIMETADATA);

+begin

+  FreeImage_FindCloseMetadata(MDHandle);

+end;

+

+function TFreeBitmap.FindFirstMetadata(Model: FREE_IMAGE_MDMODEL;

+  var Tag: TFreeTag): PFIMETADATA;

+begin

+  Result := FreeImage_FindFirstMetadata(Model, FDib, Tag.FTag);

+end;

+

+function TFreeBitmap.FindNextMetadata(MDHandle: PFIMETADATA;

+  var Tag: TFreeTag): Boolean;

+begin

+  Result := FreeImage_FindNextMetadata(MDHandle, Tag.FTag);

+end;

+

+function TFreeBitmap.FlipHorizontal: Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_FlipHorizontal(FDib);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.FlipVertical: Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_FlipVertical(FDib);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.GetBitsPerPixel: Integer;

+begin

+  Result := FreeImage_GetBPP(FDib)

+end;

+

+function TFreeBitmap.GetChannel(Bitmap: TFreeBitmap;

+  Channel: FREE_IMAGE_COLOR_CHANNEL): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Bitmap.Dib := FreeImage_GetChannel(FDib, Channel);

+    Result := Bitmap.IsValid;

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.GetColorsUsed: Integer;

+begin

+  Result := FreeImage_GetColorsUsed(FDib)

+end;

+

+function TFreeBitmap.GetColorType: FREE_IMAGE_COLOR_TYPE;

+begin

+  Result := FreeImage_GetColorType(FDib);

+end;

+

+function TFreeBitmap.GetFileBkColor(var BkColor: PRGBQuad): Boolean;

+begin

+  Result := FreeImage_GetBackgroundColor(FDib, BkColor)

+end;

+

+function TFreeBitmap.GetHeight: Integer;

+begin

+  Result := FreeImage_GetHeight(FDib)

+end;

+

+function TFreeBitmap.GetHistogram(Histo: PDWORD;

+  Channel: FREE_IMAGE_COLOR_CHANNEL): Boolean;

+begin

+  if FDib <> nil then

+    Result := FreeImage_GetHistogram(FDib, Histo, Channel)

+  else

+    Result := False

+end;

+

+function TFreeBitmap.GetHorizontalResolution: Double;

+begin

+  Result := FreeImage_GetDotsPerMeterX(FDib) / 100

+end;

+

+function TFreeBitmap.GetImageSize: Cardinal;

+begin

+  Result := FreeImage_GetDIBSize(FDib);

+end;

+

+function TFreeBitmap.GetImageType: FREE_IMAGE_TYPE;

+begin

+  Result := FreeImage_GetImageType(FDib);

+end;

+

+function TFreeBitmap.GetInfo: PBitmapInfo;

+begin

+  Result := FreeImage_GetInfo(FDib^)

+end;

+

+function TFreeBitmap.GetInfoHeader: PBITMAPINFOHEADER;

+begin

+  Result := FreeImage_GetInfoHeader(FDib)

+end;

+

+function TFreeBitmap.GetLine: Integer;

+begin

+  Result := FreeImage_GetLine(FDib)

+end;

+

+function TFreeBitmap.GetMetadata(Model: FREE_IMAGE_MDMODEL;

+  const Key: string; var Tag: TFreeTag): Boolean;

+begin

+  Result := FreeImage_GetMetaData(Model, FDib, PChar(Key), Tag.FTag);

+end;

+

+function TFreeBitmap.GetMetadataCount(Model: FREE_IMAGE_MDMODEL): Cardinal;

+begin

+  Result := FreeImage_GetMetadataCount(Model, FDib);

+end;

+

+function TFreeBitmap.GetPalette: PRGBQUAD;

+begin

+  Result := FreeImage_GetPalette(FDib)

+end;

+

+function TFreeBitmap.GetPaletteSize: Integer;

+begin

+  Result := FreeImage_GetColorsUsed(FDib) * SizeOf(RGBQUAD)

+end;

+

+function TFreeBitmap.GetPixelColor(X, Y: Cardinal; Value: PRGBQUAD): Boolean;

+begin

+  Result := FreeImage_GetPixelColor(FDib, X, Y, Value)

+end;

+

+function TFreeBitmap.GetPixelIndex(X, Y: Cardinal;

+  var Value: PByte): Boolean;

+begin

+  Result := FreeImage_GetPixelIndex(FDib, X, Y, Value)

+end;

+

+function TFreeBitmap.GetScanLine(ScanLine: Integer): PByte;

+var

+  H: Integer;

+begin

+  H := FreeImage_GetHeight(FDib);

+  if ScanLine < H then

+    Result := FreeImage_GetScanLine(FDib, ScanLine)

+  else

+    Result := nil;

+end;

+

+function TFreeBitmap.GetScanWidth: Integer;

+begin

+  Result := FreeImage_GetPitch(FDib)

+end;

+

+function TFreeBitmap.GetTransparencyCount: Cardinal;

+begin

+  Result := FreeImage_GetTransparencyCount(FDib)

+end;

+

+function TFreeBitmap.GetTransparencyTable: PByte;

+begin

+  Result := FreeImage_GetTransparencyTable(FDib)

+end;

+

+function TFreeBitmap.GetVerticalResolution: Double;

+begin

+  Result := FreeImage_GetDotsPerMeterY(Fdib) / 100

+end;

+

+function TFreeBitmap.GetWidth: Integer;

+begin

+  Result := FreeImage_GetWidth(FDib)

+end;

+

+function TFreeBitmap.HasFileBkColor: Boolean;

+begin

+  Result := FreeImage_HasBackgroundColor(FDib)

+end;

+

+function TFreeBitmap.Invert: Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_Invert(FDib);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.IsGrayScale: Boolean;

+begin

+  Result := (FreeImage_GetBPP(FDib) = 8)

+            and (FreeImage_GetColorType(FDib) = FIC_PALETTE); 

+end;

+

+function TFreeBitmap.IsTransparent: Boolean;

+begin

+  Result := FreeImage_IsTransparent(FDib);

+end;

+

+function TFreeBitmap.IsValid: Boolean;

+begin

+  Result := FDib <> nil

+end;

+

+function TFreeBitmap.Load(const FileName: string; Flag: Integer): Boolean;

+var

+  fif: FREE_IMAGE_FORMAT;

+begin

+

+  // check the file signature and get its format

+  fif := FreeImage_GetFileType(PChar(Filename), 0);

+  if fif = FIF_UNKNOWN then

+    // no signature?

+    // try to guess the file format from the file extention

+    fif := FreeImage_GetFIFFromFilename(PChar(FileName));

+

+    // check that the plugin has reading capabilities ...

+    if (fif <> FIF_UNKNOWN) and FreeImage_FIFSupportsReading(FIF) then

+    begin

+      // free the previous dib

+      if FDib <> nil then

+        FreeImage_Unload(dib);

+

+      // load the file

+      FDib := FreeImage_Load(fif, PChar(FileName), Flag);

+

+      Change;

+      Result := IsValid;

+    end else

+      Result := False;

+end;

+

+function TFreeBitmap.LoadFromHandle(IO: PFreeImageIO; Handle: fi_handle;

+  Flag: Integer): Boolean;

+var

+  fif: FREE_IMAGE_FORMAT;

+begin

+  // check the file signature and get its format

+  fif := FreeImage_GetFileTypeFromHandle(IO, Handle, 16);

+  if (fif <> FIF_UNKNOWN) and FreeImage_FIFSupportsReading(fif) then

+  begin

+    // free the previous dib

+    if FDib <> nil then

+      FreeImage_Unload(FDib);

+

+    // load the file

+    FDib := FreeImage_LoadFromHandle(fif, IO, Handle, Flag);

+

+    Change;

+    Result := IsValid;

+  end else

+    Result := False;

+end;

+

+function TFreeBitmap.LoadFromMemory(MemIO: TFreeMemoryIO;

+  Flag: Integer): Boolean;

+var

+  fif: FREE_IMAGE_FORMAT;

+begin

+

+  // check the file signature and get its format

+  fif := MemIO.GetFileType;

+  if (fif <> FIF_UNKNOWN) and FreeImage_FIFSupportsReading(fif) then

+  begin

+    // free the previous dib

+    if FDib <> nil then

+      FreeImage_Unload(FDib);

+

+    // load the file

+    FDib := MemIO.Read(fif, Flag);

+

+    Result := IsValid;

+    Change;

+  end else

+    Result := False;

+end;

+

+function TFreeBitmap.LoadFromStream(Stream: TStream;

+  Flag: Integer): Boolean;

+var

+  MemIO: TFreeMemoryIO;

+  Data: PByte;

+  MemStream: TMemoryStream;

+  Size: Cardinal;

+begin

+  Size := Stream.Size;

+

+  MemStream := TMemoryStream.Create;

+  try

+    MemStream.CopyFrom(Stream, Size);

+    Data := MemStream.Memory;

+

+    MemIO := TFreeMemoryIO.Create(Data, Size);

+    try

+      Result := LoadFromMemory(MemIO);

+    finally

+      MemIO.Free;

+    end;

+  finally

+    MemStream.Free;

+  end;

+end;

+

+function TFreeBitmap.LoadU(const FileName: WideString;

+  Flag: Integer): Boolean;

+var

+  fif: FREE_IMAGE_FORMAT;

+begin

+

+  // check the file signature and get its format

+  fif := FreeImage_GetFileTypeU(PWideChar(Filename), 0);

+  if fif = FIF_UNKNOWN then

+    // no signature?

+    // try to guess the file format from the file extention

+    fif := FreeImage_GetFIFFromFilenameU(PWideChar(FileName));

+

+    // check that the plugin has reading capabilities ...

+    if (fif <> FIF_UNKNOWN) and FreeImage_FIFSupportsReading(FIF) then

+    begin

+      // free the previous dib

+      if FDib <> nil then

+        FreeImage_Unload(dib);

+

+      // load the file

+      FDib := FreeImage_LoadU(fif, PWideChar(FileName), Flag);

+

+      Change;

+      Result := IsValid;

+    end else

+      Result := False;

+end;

+

+procedure TFreeBitmap.MakeThumbnail(const Width, Height: Integer;

+  DestBitmap: TFreeBitmap);

+type

+  PRGB24 = ^TRGB24;

+  TRGB24 = packed record

+    B: Byte;

+    G: Byte;

+    R: Byte;

+  end;

+var

+  x, y, ix, iy: integer;

+  x1, x2, x3: integer;

+

+  xscale, yscale: single;

+  iRed, iGrn, iBlu, iRatio: Longword;

+  p, c1, c2, c3, c4, c5: TRGB24;

+  pt, pt1: PRGB24;

+  iSrc, iDst, s1: integer;

+  i, j, r, g, b, tmpY: integer;

+

+  RowDest, RowSource, RowSourceStart: integer;

+  w, h: Integer;

+  dxmin, dymin: integer;

+  ny1, ny2, ny3: integer;

+  dx, dy: integer;

+  lutX, lutY: array of integer;

+

+  SrcBmp, DestBmp: PFIBITMAP;

+begin

+  if not IsValid then Exit;

+

+  if (GetWidth <= ThumbSize) and (GetHeight <= ThumbSize) then

+  begin

+    DestBitmap.Assign(Self);

+    Exit;

+  end;

+

+  w := Width;

+  h := Height;

+

+  // prepare bitmaps

+  if GetBitsPerPixel <> 24 then

+    SrcBmp := FreeImage_ConvertTo24Bits(FDib)

+  else

+    SrcBmp := FDib;

+  DestBmp := FreeImage_Allocate(w, h, 24);

+  Assert(DestBmp <> nil, 'TFreeBitmap.MakeThumbnail error');

+

+{  iDst := (w * 24 + 31) and not 31;

+  iDst := iDst div 8; //BytesPerScanline

+  iSrc := (GetWidth * 24 + 31) and not 31;

+  iSrc := iSrc div 8;

+}

+  // BytesPerScanline

+  iDst := FreeImage_GetPitch(DestBmp);

+  iSrc := FreeImage_GetPitch(SrcBmp);

+

+  xscale := 1 / (w / FreeImage_GetWidth(SrcBmp));

+  yscale := 1 / (h / FreeImage_GetHeight(SrcBmp));

+

+  // X lookup table

+  SetLength(lutX, w);

+  x1 := 0;

+  x2 := trunc(xscale);

+  for x := 0 to w - 1 do

+  begin

+    lutX[x] := x2 - x1;

+    x1 := x2;

+    x2 := trunc((x + 2) * xscale);

+  end;

+

+  // Y lookup table

+  SetLength(lutY, h);

+  x1 := 0;

+  x2 := trunc(yscale);

+  for x := 0 to h - 1 do

+  begin

+    lutY[x] := x2 - x1;

+    x1 := x2;

+    x2 := trunc((x + 2) * yscale);

+  end;

+

+  Dec(w);

+  Dec(h);

+  RowDest := integer(FreeImage_GetScanLine(DestBmp, 0));

+  RowSourceStart := integer(FreeImage_GetScanLine(SrcBmp, 0));

+  RowSource := RowSourceStart;

+

+  for y := 0 to h do

+  // resampling

+  begin

+    dy := lutY[y];

+    x1 := 0;

+    x3 := 0;

+    for x := 0 to w do  // loop through row

+    begin

+      dx:= lutX[x];

+      iRed:= 0;

+      iGrn:= 0;

+      iBlu:= 0;

+      RowSource := RowSourceStart;

+      for iy := 1 to dy do

+      begin

+        pt := PRGB24(RowSource + x1);

+        for ix := 1 to dx do

+        begin

+          iRed := iRed + pt.R;

+          iGrn := iGrn + pt.G;

+          iBlu := iBlu + pt.B;

+          inc(pt);

+        end;

+        RowSource := RowSource + iSrc;

+      end;

+      iRatio := 65535 div (dx * dy);

+      pt1 := PRGB24(RowDest + x3);

+      pt1.R := (iRed * iRatio) shr 16;

+      pt1.G := (iGrn * iRatio) shr 16;

+      pt1.B := (iBlu * iRatio) shr 16;

+      x1 := x1 + 3 * dx;

+      inc(x3,3);

+    end;

+    RowDest := RowDest + iDst;

+    RowSourceStart := RowSource;

+  end; // resampling

+

+  if FreeImage_GetHeight(DestBmp) >= 3 then

+  // Sharpening...

+  begin

+    s1 := integer(FreeImage_GetScanLine(DestBmp, 0));

+    iDst := integer(FreeImage_GetScanLine(DestBmp, 1)) - s1;

+    ny1 := Integer(s1);

+    ny2 := ny1 + iDst;

+    ny3 := ny2 + iDst;

+    for y := 1 to FreeImage_GetHeight(DestBmp) - 2 do

+    begin

+      for x := 0 to FreeImage_GetWidth(DestBmp) - 3 do

+      begin

+        x1 := x * 3;

+        x2 := x1 + 3;

+        x3 := x1 + 6;

+

+        c1 := pRGB24(ny1 + x1)^;

+        c2 := pRGB24(ny1 + x3)^;

+        c3 := pRGB24(ny2 + x2)^;

+        c4 := pRGB24(ny3 + x1)^;

+        c5 := pRGB24(ny3 + x3)^;

+

+        r := (c1.R + c2.R + (c3.R * -12) + c4.R + c5.R) div -8;

+        g := (c1.G + c2.G + (c3.G * -12) + c4.G + c5.G) div -8;

+        b := (c1.B + c2.B + (c3.B * -12) + c4.B + c5.B) div -8;

+

+        if r < 0 then r := 0 else if r > 255 then r := 255;

+        if g < 0 then g := 0 else if g > 255 then g := 255;

+        if b < 0 then b := 0 else if b > 255 then b := 255;

+

+        pt1 := pRGB24(ny2 + x2);

+        pt1.R := r;

+        pt1.G := g;

+        pt1.B := b;

+      end;

+      inc(ny1, iDst);

+      inc(ny2, iDst);

+      inc(ny3, iDst);

+    end;

+  end; // sharpening

+

+  if SrcBmp <> FDib then

+    FreeImage_Unload(SrcBmp);

+  DestBitmap.Replace(DestBmp);

+end;

+

+function TFreeBitmap.PasteSubImage(Src: TFreeBitmap; Left, Top,

+  Alpha: Integer): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_Paste(FDib, Src.Dib, Left, Top, Alpha);

+    Change;

+  end else

+    Result := False;

+end;

+

+function TFreeBitmap.Replace(NewDib: PFIBITMAP): Boolean;

+begin

+  Result := False;

+  if NewDib = nil then Exit;

+

+  if not DoChanging(FDib, NewDib) and IsValid then

+    FreeImage_Unload(FDib);

+

+  FDib := NewDib;

+  Result := True;

+  Change;

+end;

+

+function TFreeBitmap.Rescale(NewWidth, NewHeight: Integer;

+  Filter: FREE_IMAGE_FILTER; Dest: TFreeBitmap): Boolean;

+var

+  Bpp: Integer;

+  DstDib: PFIBITMAP;

+begin

+  Result := False;

+

+  if FDib <> nil then

+  begin

+    Bpp := FreeImage_GetBPP(FDib);

+

+    if Bpp < 8 then

+      if not ConvertToGrayscale then Exit

+    else

+    if Bpp = 16 then

+    // convert to 24-bit

+      if not ConvertTo24Bits then Exit;

+

+    // perform upsampling / downsampling

+    DstDib := FreeImage_Rescale(FDib, NewWidth, NewHeight, Filter);

+    if Dest = nil then

+      Result := Replace(DstDib)

+    else

+      Result := Dest.Replace(DstDib)

+  end

+end;

+

+function TFreeBitmap.Rotate(Angle: Double): Boolean;

+var

+  Bpp: Integer;

+  Rotated: PFIBITMAP;

+begin

+  Result := False;

+  if IsValid then

+  begin

+    Bpp := FreeImage_GetBPP(FDib);

+    if Bpp in [1, 8, 24, 32] then

+    begin

+      Rotated := FreeImage_RotateClassic(FDib, Angle);

+      Result := Replace(Rotated);

+    end

+  end;

+end;

+

+function TFreeBitmap.RotateEx(Angle, XShift, YShift, XOrigin,

+  YOrigin: Double; UseMask: Boolean): Boolean;

+var

+  Rotated: PFIBITMAP;

+begin

+  Result := False;

+  if FDib <> nil then

+  begin

+    if FreeImage_GetBPP(FDib) >= 8 then

+    begin

+      Rotated := FreeImage_RotateEx(FDib, Angle, XShift, YShift, XOrigin, YOrigin, UseMask);

+      Result := Replace(Rotated);

+    end

+  end;

+end;

+

+function TFreeBitmap.Save(const FileName: string; Flag: Integer): Boolean;

+var

+  fif: FREE_IMAGE_FORMAT;

+begin

+  Result := False;

+

+  // try to guess the file format from the file extension

+  fif := FreeImage_GetFIFFromFilename(PChar(Filename));

+  if CanSave(fif) then

+    Result := FreeImage_Save(fif, FDib, PChar(FileName), Flag);

+end;

+

+function TFreeBitmap.SaveToHandle(fif: FREE_IMAGE_FORMAT; IO: PFreeImageIO;

+  Handle: fi_handle; Flag: Integer): Boolean;

+begin

+  Result := False;

+  if CanSave(fif) then

+    Result := FreeImage_SaveToHandle(fif, FDib, IO, Handle, Flag)

+end;

+

+function TFreeBitmap.SaveToMemory(fif: FREE_IMAGE_FORMAT;

+  MemIO: TFreeMemoryIO; Flag: Integer): Boolean;

+begin

+  Result := False;

+

+  if CanSave(fif) then

+    Result := MemIO.Write(fif, FDib, Flag)

+end;

+

+function TFreeBitmap.SaveToStream(fif: FREE_IMAGE_FORMAT; Stream: TStream;

+  Flag: Integer): Boolean;

+var

+  MemIO: TFreeMemoryIO;

+  Data: PByte;

+  Size: Cardinal;

+begin

+  MemIO := TFreeMemoryIO.Create;

+  try

+    Result := SaveToMemory(fif, MemIO, Flag);

+    if Result then

+    begin

+      MemIO.Acquire(Data, Size);

+      Stream.WriteBuffer(Data^, Size);

+    end;

+  finally

+    MemIO.Free;

+  end;

+end;

+

+function TFreeBitmap.SaveU(const FileName: WideString;

+  Flag: Integer): Boolean;

+var

+  fif: FREE_IMAGE_FORMAT;

+begin

+  Result := False;

+

+  // try to guess the file format from the file extension

+  fif := FreeImage_GetFIFFromFilenameU(PWideChar(Filename));

+  if CanSave(fif) then

+    Result := FreeImage_SaveU(fif, FDib, PWideChar(FileName), Flag);

+end;

+

+function TFreeBitmap.SetChannel(Bitmap: TFreeBitmap;

+  Channel: FREE_IMAGE_COLOR_CHANNEL): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    Result := FreeImage_SetChannel(FDib, Bitmap.FDib, Channel);

+    Change;

+  end

+  else

+    Result := False

+end;

+

+procedure TFreeBitmap.SetDib(Value: PFIBITMAP);

+begin

+  Replace(Value);

+end;

+

+function TFreeBitmap.SetFileBkColor(BkColor: PRGBQuad): Boolean;

+begin

+  Result := FreeImage_SetBackgroundColor(FDib, BkColor);

+  Change;

+end;

+

+procedure TFreeBitmap.SetHorizontalResolution(Value: Double);

+begin

+  if IsValid then

+  begin

+    FreeImage_SetDotsPerMeterX(FDib, Trunc(Value * 100 + 0.5));

+    Change;

+  end;

+end;

+

+function TFreeBitmap.SetMetadata(Model: FREE_IMAGE_MDMODEL;

+  const Key: string; Tag: TFreeTag): Boolean;

+begin

+  Result := FreeImage_SetMetadata(Model, FDib, PChar(Key), Tag.Tag);

+end;

+

+function TFreeBitmap.SetPixelColor(X, Y: Cardinal;

+  Value: PRGBQUAD): Boolean;

+begin

+  Result := FreeImage_SetPixelColor(FDib, X, Y, Value);

+  Change;

+end;

+

+function TFreeBitmap.SetPixelIndex(X, Y: Cardinal; Value: PByte): Boolean;

+begin

+  Result := FreeImage_SetPixelIndex(FDib, X, Y, Value);

+  Change;

+end;

+

+function TFreeBitmap.SetSize(ImageType: FREE_IMAGE_TYPE; Width, Height,

+  Bpp: Integer; RedMask, GreenMask, BlueMask: Cardinal): Boolean;

+var

+  Pal: PRGBQuad;

+  I: Cardinal;

+begin

+  Result := False;

+

+  if FDib <> nil then

+    FreeImage_Unload(FDib);

+

+  FDib := FreeImage_Allocate(Width, Height, Bpp, RedMask, GreenMask, BlueMask);

+  if FDib = nil then Exit;

+

+  if ImageType = FIT_BITMAP then

+  case Bpp of

+    1, 4, 8:

+    begin

+      Pal := FreeImage_GetPalette(FDib);

+      for I := 0 to FreeImage_GetColorsUsed(FDib) - 1 do

+      begin

+        Pal.rgbBlue := I;

+        Pal.rgbGreen := I;

+        Pal.rgbRed := I;

+        Inc(Pal, SizeOf(RGBQUAD));

+      end;

+    end;

+  end;

+

+  Result := True;

+  Change;

+end;

+

+procedure TFreeBitmap.SetTransparencyTable(Table: PByte; Count: Integer);

+begin

+  FreeImage_SetTransparencyTable(FDib, Table, Count);

+  Change;

+end;

+

+procedure TFreeBitmap.SetVerticalResolution(Value: Double);

+begin

+  if IsValid then

+  begin

+    FreeImage_SetDotsPerMeterY(FDib, Trunc(Value * 100 + 0.5));

+    Change;

+  end;

+end;

+

+function TFreeBitmap.SplitChannels(RedChannel, GreenChannel,

+  BlueChannel: TFreeBitmap): Boolean;

+begin

+  if FDib <> nil then

+  begin

+    RedChannel.FDib := FreeImage_GetChannel(FDib, FICC_RED);

+    GreenChannel.FDib := FreeImage_GetChannel(FDib, FICC_GREEN);

+    BlueChannel.FDib := FreeImage_GetChannel(FDib, FICC_BLUE);

+    Result := RedChannel.IsValid and GreenChannel.IsValid and BlueChannel.IsValid;

+  end

+  else

+    Result := False  

+end;

+

+function TFreeBitmap.Threshold(T: Byte): Boolean;

+var

+  dib1: PFIBITMAP;

+begin

+  if FDib <> nil then

+  begin

+    dib1 := FreeImage_Threshold(FDib, T);

+    Result := Replace(dib1);

+  end

+  else

+    Result := False

+end;

+

+function TFreeBitmap.ToneMapping(TMO: FREE_IMAGE_TMO; FirstParam,

+  SecondParam: Double): Boolean;

+var

+  NewDib: PFIBITMAP;

+begin

+  Result := False;

+  if not IsValid then Exit;

+

+  NewDib := FreeImage_ToneMapping(Fdib, TMO, FirstParam, SecondParam);

+  Result := Replace(NewDib);

+end;

+

+

+{ TFreeMultiBitmap }

+

+procedure TFreeMultiBitmap.AppendPage(Bitmap: TFreeBitmap);

+begin

+  if IsValid then

+    FreeImage_AppendPage(FMPage, Bitmap.FDib);

+end;

+

+function TFreeMultiBitmap.Close(Flags: Integer): Boolean;

+begin

+  Result := FreeImage_CloseMultiBitmap(FMPage, Flags);

+  FMPage := nil;

+end;

+

+constructor TFreeMultiBitmap.Create(KeepCacheInMemory: Boolean);

+begin

+  inherited Create;

+  FMemoryCache := KeepCacheInMemory;

+end;

+

+procedure TFreeMultiBitmap.DeletePage(Page: Integer);

+begin

+  if IsValid then

+    FreeImage_DeletePage(FMPage, Page);

+end;

+

+destructor TFreeMultiBitmap.Destroy;

+begin

+  if FMPage <> nil then Close;

+  inherited;

+end;

+

+function TFreeMultiBitmap.GetLockedPageNumbers(var Pages,

+  Count: Integer): Boolean;

+begin

+  Result := False;

+  if not IsValid then Exit;

+  Result := FreeImage_GetLockedPageNumbers(FMPage, Pages, Count)

+end;

+

+function TFreeMultiBitmap.GetPageCount: Integer;

+begin

+  Result := 0;

+  if IsValid then

+    Result := FreeImage_GetPageCount(FMPage)

+end;

+

+procedure TFreeMultiBitmap.InsertPage(Page: Integer; Bitmap: TFreeBitmap);

+begin

+  if IsValid then

+    FreeImage_InsertPage(FMPage, Page, Bitmap.FDib);

+end;

+

+function TFreeMultiBitmap.IsValid: Boolean;

+begin

+  Result := FMPage <> nil

+end;

+

+procedure TFreeMultiBitmap.LockPage(Page: Integer; DestBitmap: TFreeBitmap);

+begin

+  if not IsValid then Exit;

+

+  if Assigned(DestBitmap) then

+  begin

+    DestBitmap.Replace(FreeImage_LockPage(FMPage, Page));

+  end;

+end;

+

+function TFreeMultiBitmap.MovePage(Target, Source: Integer): Boolean;

+begin

+  Result := False;

+  if not IsValid then Exit;

+  Result := FreeImage_MovePage(FMPage, Target, Source);

+end;

+

+function TFreeMultiBitmap.Open(const FileName: string; CreateNew,

+  ReadOnly: Boolean; Flags: Integer): Boolean;

+var

+  fif: FREE_IMAGE_FORMAT;

+begin

+  Result := False;

+

+  // try to guess the file format from the filename

+  fif := FreeImage_GetFIFFromFilename(PChar(FileName));

+

+  // check for supported file types

+  if (fif <> FIF_UNKNOWN) and (not fif in [FIF_TIFF, FIF_ICO, FIF_GIF]) then

+    Exit;

+

+  // open the stream

+  FMPage := FreeImage_OpenMultiBitmap(fif, PChar(FileName), CreateNew, ReadOnly, FMemoryCache, Flags);

+

+  Result := FMPage <> nil;  

+end;

+

+procedure TFreeMultiBitmap.UnlockPage(Bitmap: TFreeBitmap;

+  Changed: Boolean);

+begin

+  if IsValid then

+  begin

+    FreeImage_UnlockPage(FMPage, Bitmap.FDib, Changed);

+    // clear the image so that it becomes invalid.

+    // don't use Bitmap.Clear method because it calls FreeImage_Unload

+    // just clear the pointer

+    Bitmap.FDib := nil;

+    Bitmap.Change;

+  end;

+end;

+

+{ TFreeMemoryIO }

+

+function TFreeMemoryIO.Acquire(var Data: PByte;

+  var SizeInBytes: DWORD): Boolean;

+begin

+  Result := FreeImage_AcquireMemory(FHMem, Data, SizeInBytes);

+end;

+

+constructor TFreeMemoryIO.Create(Data: PByte; SizeInBytes: DWORD);

+begin

+  inherited Create;

+  FHMem := FreeImage_OpenMemory(Data, SizeInBytes);

+end;

+

+destructor TFreeMemoryIO.Destroy;

+begin

+  FreeImage_CloseMemory(FHMem);

+  inherited;

+end;

+

+function TFreeMemoryIO.GetFileType: FREE_IMAGE_FORMAT;

+begin

+  Result := FreeImage_GetFileTypeFromMemory(FHMem);

+end;

+

+function TFreeMemoryIO.IsValid: Boolean;

+begin

+  Result := FHMem <> nil

+end;

+

+function TFreeMemoryIO.Read(fif: FREE_IMAGE_FORMAT;

+  Flag: Integer): PFIBITMAP;

+begin

+  Result := FreeImage_LoadFromMemory(fif, FHMem, Flag)

+end;

+

+function TFreeMemoryIO.Seek(Offset: Longint; Origin: Word): Boolean;

+begin

+  Result := FreeImage_SeekMemory(FHMem, Offset, Origin)

+end;

+

+function TFreeMemoryIO.Tell: Longint;

+begin

+  Result := FreeImage_TellMemory(FHMem)

+end;

+

+function TFreeMemoryIO.Write(fif: FREE_IMAGE_FORMAT; dib: PFIBITMAP;

+  Flag: Integer): Boolean;

+begin

+  Result := FreeImage_SaveToMemory(fif, dib, FHMem, Flag)

+end;

+

+{ TFreeTag }

+

+function TFreeTag.Clone: TFreeTag;

+var

+  CloneTag: PFITAG;

+begin

+  Result := nil;

+  if not IsValid then Exit;

+

+  CloneTag := FreeImage_CloneTag(FTag);

+  Result := TFreeTag.Create(CloneTag);

+end;

+

+constructor TFreeTag.Create(ATag: PFITAG);

+begin

+  inherited Create;

+

+  if ATag <> nil then

+    FTag := ATag

+  else

+    FTag := FreeImage_CreateTag;

+end;

+

+destructor TFreeTag.Destroy;

+begin

+  if IsValid then

+    FreeImage_DeleteTag(FTag);

+    

+  inherited;

+end;

+

+function TFreeTag.GetCount: Cardinal;

+begin

+  Result := 0;

+  if not IsValid then Exit;

+

+  Result := FreeImage_GetTagCount(FTag);

+end;

+

+function TFreeTag.GetDescription: string;

+begin

+  Result := '';

+  if not IsValid then Exit;

+

+  Result := FreeImage_GetTagDescription(FTag);

+end;

+

+function TFreeTag.GetID: Word;

+begin

+  Result := 0;

+  if not IsValid then Exit;

+

+  Result := FreeImage_GetTagID(FTag);

+end;

+

+function TFreeTag.GetKey: string;

+begin

+  Result := '';

+  if not IsValid then Exit;

+

+  Result := FreeImage_GetTagKey(FTag);

+end;

+

+function TFreeTag.GetLength: Cardinal;

+begin

+  Result := 0;

+  if not IsValid then Exit;

+

+  Result := FreeImage_GetTagLength(FTag);

+end;

+

+function TFreeTag.GetTagType: FREE_IMAGE_MDTYPE;

+begin

+  Result := FIDT_NOTYPE;

+  if not IsValid then Exit;

+

+  Result := FreeImage_GetTagType(FTag);

+end;

+

+function TFreeTag.GetValue: Pointer;

+begin

+  Result := nil;

+  if not IsValid then Exit;

+

+  Result := FreeImage_GetTagValue(FTag);

+end;

+

+function TFreeTag.IsValid: Boolean;

+begin

+  Result := FTag <> nil;

+end;

+

+procedure TFreeTag.SetCount(const Value: Cardinal);

+begin

+  if IsValid then

+    FreeImage_SetTagCount(FTag, Value);

+end;

+

+procedure TFreeTag.SetDescription(const Value: string);

+begin

+  if IsValid then

+    FreeImage_SetTagDescription(FTag, PChar(Value));

+end;

+

+procedure TFreeTag.SetID(const Value: Word);

+begin

+  if IsValid then

+    FreeImage_SetTagID(FTag, Value);

+end;

+

+procedure TFreeTag.SetKey(const Value: string);

+begin

+  if IsValid then

+    FreeImage_SetTagKey(FTag, PChar(Value));

+end;

+

+procedure TFreeTag.SetLength(const Value: Cardinal);

+begin

+  if IsValid then

+    FreeImage_SetTagLength(FTag, Value);

+end;

+

+procedure TFreeTag.SetTagType(const Value: FREE_IMAGE_MDTYPE);

+begin

+  if IsValid then

+    FreeImage_SetTagType(FTag, Value);

+end;

+

+procedure TFreeTag.SetValue(const Value: Pointer);

+begin

+  if IsValid then

+    FreeImage_SetTagValue(FTag, Value);

+end;

+

+function TFreeTag.ToString(Model: FREE_IMAGE_MDMODEL; Make: PChar): string;

+begin

+  Result := FreeImage_TagToString(Model, FTag, Make);

+end;

+

+end.

diff --git a/Game/Code/lib/FreeImage/FreeImage.pas b/Game/Code/lib/FreeImage/FreeImage.pas
new file mode 100755
index 00000000..a1c0e7de
--- /dev/null
+++ b/Game/Code/lib/FreeImage/FreeImage.pas
@@ -0,0 +1,743 @@
+unit FreeImage;
+
+{$I switches.inc}
+
+
+
+
+// ==========================================================
+// Delphi wrapper for FreeImage 3
+//
+// Design and implementation by
+// - Simon Beavis
+// - Peter Byström
+// - Anatoliy Pulyaevskiy (xvel84@rambler.ru)
+//
+// This file is part of FreeImage 3
+//
+// COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
+// OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
+// THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
+// OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
+// CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
+// THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
+// SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
+// PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
+// THIS DISCLAIMER.
+//
+// Use at your own risk!
+// ==========================================================
+
+interface
+
+uses Windows;
+
+{$MINENUMSIZE 4} // Make sure enums are stored as an integer to be compatible with C/C++
+
+const
+  FIDLL = 'libfreeimage.dylib';
+
+// --------------------------------------------------------------------------
+// Bitmap types -------------------------------------------------------------
+// --------------------------------------------------------------------------
+
+type
+  FIBITMAP = record
+    data : Pointer;
+  end;
+  PFIBITMAP = ^FIBITMAP;
+
+  FIMULTIBITMAP = record
+    data : Pointer;
+  end;
+  PFIMULTIBITMAP = ^FIMULTIBITMAP;
+
+// --------------------------------------------------------------------------
+// Indexes for byte arrays, masks and shifts for treating pixels as words ---
+// These coincide with the order of RGBQUAD and RGBTRIPLE -------------------
+// Little Endian (x86 / MS Windows, Linux) : BGR(A) order -------------------
+// --------------------------------------------------------------------------
+
+const
+  FI_RGBA_RED         = 2;
+  FI_RGBA_GREEN       = 1;
+  FI_RGBA_BLUE        = 0;
+  FI_RGBA_ALPHA       = 3;
+  FI_RGBA_RED_MASK    = $00FF0000;
+  FI_RGBA_GREEN_MASK  = $0000FF00;
+  FI_RGBA_BLUE_MASK   = $000000FF;
+  FI_RGBA_ALPHA_MASK  = $FF000000;
+  FI_RGBA_RED_SHIFT   = 16;
+  FI_RGBA_GREEN_SHIFT = 8;
+  FI_RGBA_BLUE_SHIFT  = 0;
+  FI_RGBA_ALPHA_SHIFT = 24;
+
+// --------------------------------------------------------------------------
+// The 16bit macros only include masks and shifts, --------------------------
+// since each color element is not byte aligned -----------------------------
+// --------------------------------------------------------------------------
+
+const
+  FI16_555_RED_MASK		 = $7C00;
+  FI16_555_GREEN_MASK	 = $03E0;
+  FI16_555_BLUE_MASK	 = $001F;
+  FI16_555_RED_SHIFT	 = 10;
+  FI16_555_GREEN_SHIFT = 5;
+  FI16_555_BLUE_SHIFT	 = 0;
+  FI16_565_RED_MASK		 = $F800;
+  FI16_565_GREEN_MASK	 = $07E0;
+  FI16_565_BLUE_MASK	 = $001F;
+  FI16_565_RED_SHIFT	 = 11;
+  FI16_565_GREEN_SHIFT = 5;
+  FI16_565_BLUE_SHIFT	 = 0;
+
+// --------------------------------------------------------------------------
+// ICC profile support ------------------------------------------------------
+// --------------------------------------------------------------------------
+
+const
+  FIICC_DEFAULT = $0;
+  FIICC_COLOR_IS_CMYK	= $1;
+
+type
+  FIICCPROFILE = record
+    flags : WORD;   // info flag
+    size : DWORD;   // profile's size measured in bytes
+    data : Pointer; // points to a block of contiguous memory containing the profile
+  end;
+  PFIICCPROFILE = ^FIICCPROFILE;
+
+// --------------------------------------------------------------------------
+// Important enums ----------------------------------------------------------
+// --------------------------------------------------------------------------
+
+type
+  FREE_IMAGE_FORMAT         = type Integer;
+  FREE_IMAGE_TYPE           = type Integer;
+  FREE_IMAGE_COLOR_TYPE     = type Integer;
+  FREE_IMAGE_QUANTIZE       = type Integer;
+  FREE_IMAGE_DITHER         = type Integer;
+  FREE_IMAGE_FILTER         = type Integer;
+  FREE_IMAGE_COLOR_CHANNEL  = type Integer;
+  FREE_IMAGE_MDTYPE         = type Integer;
+  FREE_IMAGE_MDMODEL        = type Integer;
+  FREE_IMAGE_JPEG_OPERATION = type Integer;
+  FREE_IMAGE_TMO            = type Integer;
+
+const
+  // I/O image format identifiers.
+  FIF_UNKNOWN = FREE_IMAGE_FORMAT(-1);
+  FIF_BMP     = FREE_IMAGE_FORMAT(0);
+  FIF_ICO     = FREE_IMAGE_FORMAT(1);
+  FIF_JPEG    = FREE_IMAGE_FORMAT(2);
+  FIF_JNG     = FREE_IMAGE_FORMAT(3);
+  FIF_KOALA   = FREE_IMAGE_FORMAT(4);
+  FIF_LBM     = FREE_IMAGE_FORMAT(5);
+  FIF_IFF     = FIF_LBM;
+  FIF_MNG     = FREE_IMAGE_FORMAT(6);
+  FIF_PBM     = FREE_IMAGE_FORMAT(7);
+  FIF_PBMRAW  = FREE_IMAGE_FORMAT(8);
+  FIF_PCD     = FREE_IMAGE_FORMAT(9);
+  FIF_PCX     = FREE_IMAGE_FORMAT(10);
+  FIF_PGM     = FREE_IMAGE_FORMAT(11);
+  FIF_PGMRAW  = FREE_IMAGE_FORMAT(12);
+  FIF_PNG     = FREE_IMAGE_FORMAT(13);
+  FIF_PPM     = FREE_IMAGE_FORMAT(14);
+  FIF_PPMRAW  = FREE_IMAGE_FORMAT(15);
+  FIF_RAS     = FREE_IMAGE_FORMAT(16);
+  FIF_TARGA   = FREE_IMAGE_FORMAT(17);
+  FIF_TIFF    = FREE_IMAGE_FORMAT(18);
+  FIF_WBMP    = FREE_IMAGE_FORMAT(19);
+  FIF_PSD     = FREE_IMAGE_FORMAT(20);
+  FIF_CUT     = FREE_IMAGE_FORMAT(21);
+  FIF_XBM     = FREE_IMAGE_FORMAT(22);
+  FIF_XPM     = FREE_IMAGE_FORMAT(23);
+  FIF_DDS     = FREE_IMAGE_FORMAT(24);
+  FIF_GIF     = FREE_IMAGE_FORMAT(25);
+  FIF_HDR     = FREE_IMAGE_FORMAT(26);
+  FIF_FAXG3   = FREE_IMAGE_FORMAT(27);
+  FIF_SGI     = FREE_IMAGE_FORMAT(28);  
+
+  // Image type used in FreeImage.
+  FIT_UNKNOWN = FREE_IMAGE_TYPE(0);  // unknown type
+  FIT_BITMAP  = FREE_IMAGE_TYPE(1);	 // standard image: 1-, 4-, 8-, 16-, 24-, 32-bit
+  FIT_UINT16  = FREE_IMAGE_TYPE(2);	 // array of unsigned short: unsigned 16-bit
+  FIT_INT16   = FREE_IMAGE_TYPE(3);  // array of short: signed 16-bit
+  FIT_UINT32  = FREE_IMAGE_TYPE(4);	 // array of unsigned long: unsigned 32-bit
+  FIT_INT32   = FREE_IMAGE_TYPE(5);	 // array of long: signed 32-bit
+  FIT_FLOAT   = FREE_IMAGE_TYPE(6);	 // array of float: 32-bit IEEE floating point
+  FIT_DOUBLE  = FREE_IMAGE_TYPE(7);	 // array of double: 64-bit IEEE floating point
+  FIT_COMPLEX = FREE_IMAGE_TYPE(8);	 // array of FICOMPLEX: 2 x 64-bit IEEE floating point
+  FIT_RGB16	  = FREE_IMAGE_TYPE(9);	 // 48-bit RGB image: 3 x 16-bit
+	FIT_RGBA16	= FREE_IMAGE_TYPE(10); // 64-bit RGBA image: 4 x 16-bit
+	FIT_RGBF	  = FREE_IMAGE_TYPE(11); // 96-bit RGB float image: 3 x 32-bit IEEE floating point
+	FIT_RGBAF	  = FREE_IMAGE_TYPE(12); // 128-bit RGBA float image: 4 x 32-bit IEEE floating point
+
+  // Image color type used in FreeImage.
+  FIC_MINISWHITE = FREE_IMAGE_COLOR_TYPE(0); // min value is white
+  FIC_MINISBLACK = FREE_IMAGE_COLOR_TYPE(1); // min value is black
+  FIC_RGB        = FREE_IMAGE_COLOR_TYPE(2); // RGB color model
+  FIC_PALETTE    = FREE_IMAGE_COLOR_TYPE(3); // color map indexed
+  FIC_RGBALPHA   = FREE_IMAGE_COLOR_TYPE(4); // RGB color model with alpha channel
+  FIC_CMYK       = FREE_IMAGE_COLOR_TYPE(5); // CMYK color model
+
+  // Color quantization algorithms. Constants used in FreeImage_ColorQuantize.
+  FIQ_WUQUANT = FREE_IMAGE_QUANTIZE(0);	// Xiaolin Wu color quantization algorithm
+  FIQ_NNQUANT = FREE_IMAGE_QUANTIZE(1);	// NeuQuant neural-net quantization algorithm by Anthony Dekker
+
+  // Dithering algorithms. Constants used FreeImage_Dither.
+  FID_FS            = FREE_IMAGE_DITHER(0);	// Floyd & Steinberg error diffusion
+  FID_BAYER4x4      = FREE_IMAGE_DITHER(1);	// Bayer ordered dispersed dot dithering (order 2 dithering matrix)
+  FID_BAYER8x8      = FREE_IMAGE_DITHER(2);	// Bayer ordered dispersed dot dithering (order 3 dithering matrix)
+  FID_CLUSTER6x6    = FREE_IMAGE_DITHER(3);	// Ordered clustered dot dithering (order 3 - 6x6 matrix)
+  FID_CLUSTER8x8    = FREE_IMAGE_DITHER(4);	// Ordered clustered dot dithering (order 4 - 8x8 matrix)
+  FID_CLUSTER16x16  = FREE_IMAGE_DITHER(5); // Ordered clustered dot dithering (order 8 - 16x16 matrix)
+
+  // Lossless JPEG transformations Constants used in FreeImage_JPEGTransform
+	FIJPEG_OP_NONE			  = FREE_IMAGE_JPEG_OPERATION(0);	// no transformation
+	FIJPEG_OP_FLIP_H		  = FREE_IMAGE_JPEG_OPERATION(1);	// horizontal flip
+	FIJPEG_OP_FLIP_V		  = FREE_IMAGE_JPEG_OPERATION(2);	// vertical flip
+	FIJPEG_OP_TRANSPOSE		= FREE_IMAGE_JPEG_OPERATION(3);	// transpose across UL-to-LR axis
+	FIJPEG_OP_TRANSVERSE	= FREE_IMAGE_JPEG_OPERATION(4);	// transpose across UR-to-LL axis
+	FIJPEG_OP_ROTATE_90		= FREE_IMAGE_JPEG_OPERATION(5);	// 90-degree clockwise rotation
+	FIJPEG_OP_ROTATE_180	= FREE_IMAGE_JPEG_OPERATION(6);	// 180-degree rotation
+	FIJPEG_OP_ROTATE_270	= FREE_IMAGE_JPEG_OPERATION(7); // 270-degree clockwise (or 90 ccw)
+
+  // Tone mapping operators. Constants used in FreeImage_ToneMapping.
+  FITMO_DRAGO03	   = FREE_IMAGE_TMO(0);	// Adaptive logarithmic mapping (F. Drago, 2003)
+	FITMO_REINHARD05 = FREE_IMAGE_TMO(1);	// Dynamic range reduction inspired by photoreceptor physiology (E. Reinhard, 2005)
+
+  // Upsampling / downsampling filters. Constants used in FreeImage_Rescale.
+  FILTER_BOX	      = FREE_IMAGE_FILTER(0);	// Box, pulse, Fourier window, 1st order (constant) b-spline
+  FILTER_BICUBIC    = FREE_IMAGE_FILTER(1);	// Mitchell & Netravali's two-param cubic filter
+  FILTER_BILINEAR   = FREE_IMAGE_FILTER(2);	// Bilinear filter
+  FILTER_BSPLINE    = FREE_IMAGE_FILTER(3);	// 4th order (cubic) b-spline
+  FILTER_CATMULLROM = FREE_IMAGE_FILTER(4);	// Catmull-Rom spline, Overhauser spline
+  FILTER_LANCZOS3   = FREE_IMAGE_FILTER(5);	// Lanczos3 filter
+
+  // Color channels. Constants used in color manipulation routines.
+  FICC_RGB   = FREE_IMAGE_COLOR_CHANNEL(0); // Use red, green and blue channels
+  FICC_RED   = FREE_IMAGE_COLOR_CHANNEL(1); // Use red channel
+  FICC_GREEN = FREE_IMAGE_COLOR_CHANNEL(2); // Use green channel
+  FICC_BLUE  = FREE_IMAGE_COLOR_CHANNEL(3); // Use blue channel
+  FICC_ALPHA = FREE_IMAGE_COLOR_CHANNEL(4); // Use alpha channel
+  FICC_BLACK = FREE_IMAGE_COLOR_CHANNEL(5); // Use black channel
+  FICC_REAL  = FREE_IMAGE_COLOR_CHANNEL(6); // Complex images: use real part
+  FICC_IMAG  = FREE_IMAGE_COLOR_CHANNEL(7); // Complex images: use imaginary part
+  FICC_MAG   = FREE_IMAGE_COLOR_CHANNEL(8); // Complex images: use magnitude
+  FICC_PHASE = FREE_IMAGE_COLOR_CHANNEL(9);	// Complex images: use phase
+
+  // Tag data type information (based on TIFF specifications)
+  FIDT_NOTYPE	   = FREE_IMAGE_MDTYPE(0);	// placeholder
+  FIDT_BYTE	     = FREE_IMAGE_MDTYPE(1);	// 8-bit unsigned integer
+  FIDT_ASCII	   = FREE_IMAGE_MDTYPE(2);	// 8-bit bytes w/ last byte null
+  FIDT_SHORT	   = FREE_IMAGE_MDTYPE(3);	// 16-bit unsigned integer
+  FIDT_LONG	     = FREE_IMAGE_MDTYPE(4);	// 32-bit unsigned integer
+  FIDT_RATIONAL  = FREE_IMAGE_MDTYPE(5);	// 64-bit unsigned fraction
+  FIDT_SBYTE	   = FREE_IMAGE_MDTYPE(6);	// 8-bit signed integer
+  FIDT_UNDEFINED = FREE_IMAGE_MDTYPE(7);	// 8-bit untyped data
+  FIDT_SSHORT	   = FREE_IMAGE_MDTYPE(8);	// 16-bit signed integer
+  FIDT_SLONG	   = FREE_IMAGE_MDTYPE(9);	// 32-bit signed integer
+  FIDT_SRATIONAL = FREE_IMAGE_MDTYPE(10); // 64-bit signed fraction
+  FIDT_FLOAT	   = FREE_IMAGE_MDTYPE(11); // 32-bit IEEE floating point
+  FIDT_DOUBLE	   = FREE_IMAGE_MDTYPE(12); // 64-bit IEEE floating point
+  FIDT_IFD	     = FREE_IMAGE_MDTYPE(13);	// 32-bit unsigned integer (offset)
+  FIDT_PALETTE	 = FREE_IMAGE_MDTYPE(14);	// 32-bit RGBQUAD
+
+  // Metadata models supported by FreeImage
+  FIMD_NODATA	        = FREE_IMAGE_MDMODEL(-1);
+  FIMD_COMMENTS	      = FREE_IMAGE_MDMODEL(0);  // single comment or keywords
+  FIMD_EXIF_MAIN      = FREE_IMAGE_MDMODEL(1);  // Exif-TIFF metadata
+  FIMD_EXIF_EXIF      = FREE_IMAGE_MDMODEL(2);  // Exif-specific metadata
+  FIMD_EXIF_GPS	      = FREE_IMAGE_MDMODEL(3);  // Exif GPS metadata
+  FIMD_EXIF_MAKERNOTE = FREE_IMAGE_MDMODEL(4);  // Exif maker note metadata
+  FIMD_EXIF_INTEROP   = FREE_IMAGE_MDMODEL(5);  // Exif interoperability metadata
+  FIMD_IPTC	          = FREE_IMAGE_MDMODEL(6);  // IPTC/NAA metadata
+  FIMD_XMP	          = FREE_IMAGE_MDMODEL(7);  // Abobe XMP metadata
+  FIMD_GEOTIFF	      = FREE_IMAGE_MDMODEL(8);  // GeoTIFF metadata (to be implemented)
+  FIMD_ANIMATION		  = FREE_IMAGE_MDMODEL(9);  // Animation metadata
+  FIMD_CUSTOM	        = FREE_IMAGE_MDMODEL(10); // Used to attach other metadata types to a dib
+
+//{$endif}
+
+type
+  // Handle to a metadata model
+  FIMETADATA = record
+    data: Pointer;
+  end;
+  PFIMETADATA = ^FIMETADATA;
+
+  // Handle to a metadata tag
+  FITAG = record
+    data: Pointer;
+  end;
+  PFITAG = ^FITAG;
+
+// --------------------------------------------------------------------------
+// File IO routines ---------------------------------------------------------
+// --------------------------------------------------------------------------
+
+type
+  FI_Handle = Pointer;
+  PCardinal = ^Cardinal;
+  PInt = ^Integer;
+
+  FI_ReadProc = function(buffer : pointer; size : Cardinal; count : Cardinal; handle : fi_handle) : PCardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_WriteProc = function(buffer : pointer; size, count : Cardinal; handle : FI_Handle) : PCardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_SeekProc = function(handle : fi_handle; offset : longint; origin : integer) : pint; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_TellProc = function(handle : fi_handle) : PCardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+
+  FreeImageIO = packed record
+    read_proc : FI_ReadProc;     // pointer to the function used to read data
+    write_proc: FI_WriteProc;    // pointer to the function used to write data
+    seek_proc : FI_SeekProc;     // pointer to the function used to seek
+    tell_proc : FI_TellProc;     // pointer to the function used to aquire the current position
+  end;
+  PFreeImageIO = ^FreeImageIO;
+
+  // Handle to a memory I/O stream
+  FIMEMORY = record
+    data: Pointer;
+  end;
+  PFIMEMORY = ^FIMEMORY;
+
+const
+  // constants used in FreeImage_Seek for Origin parameter
+  SEEK_SET = 0;
+  SEEK_CUR = 1;
+  SEEK_END = 2;
+
+// --------------------------------------------------------------------------
+// Plugin routines ----------------------------------------------------------
+// --------------------------------------------------------------------------
+
+type
+  PPluginStruct = ^PluginStruct;
+
+  FI_InitProc = procedure(Plugin: PPluginStruct; Format_ID: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_FormatProc = function: PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_DescriptionProc = function: PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_ExtensionListProc = function: PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_RegExprProc = function: PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_OpenProc = function(IO: PFreeImageIO; Handle: FI_Handle; Read: Boolean): Pointer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_CloseProc = procedure(IO: PFreeImageIO; Handle: FI_Handle; Data: Pointer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_PageCountProc = function(IO: PFreeImageIO; Handle: FI_Handle; Data: Pointer): Integer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_PageCapabilityProc = function(IO: PFreeImageIO; Handle: FI_Handle; Data: Pointer): integer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_LoadProc = function(IO: PFreeImageIO; Handle: FI_Handle; Page, Flags: Integer; data: pointer): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_SaveProc = function(IO: PFreeImageIO; Dib: PFIBITMAP; Handle: FI_Handle; Page, Flags: Integer; Data: Pointer): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_ValidateProc = function(IO: PFreeImageIO; Handle: FI_Handle): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_MimeProc = function: PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_SupportsExportBPPProc = function(Bpp: integer): boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_SupportsExportTypeProc = function(AType: FREE_IMAGE_TYPE): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  FI_SupportsICCProfilesProc = function: Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+
+  PluginStruct = record
+    format_proc: FI_FormatProc;
+    description_proc: FI_DescriptionProc;
+    extension_proc: FI_ExtensionListProc;
+    regexpr_proc: FI_RegExprProc;
+    open_proc: FI_OpenProc;
+    close_proc: FI_CloseProc;
+    pagecount_proc: FI_PageCountProc;
+    pagecapability_proc: FI_PageCapabilityProc;
+    load_proc: FI_LoadProc;
+    save_proc: FI_SaveProc;
+    validate_proc: FI_ValidateProc;
+    mime_proc: FI_MimeProc;
+    supports_export_bpp_proc: FI_SupportsExportBPPProc;
+    supports_export_type_proc: FI_SupportsExportTypeProc;
+    supports_icc_profiles_proc: FI_SupportsICCProfilesProc;
+  end;
+
+// --------------------------------------------------------------------------
+// Load/Save flag constants -------------------------------------------------
+// --------------------------------------------------------------------------
+
+const
+  BMP_DEFAULT         = 0;
+  BMP_SAVE_RLE        = 1;
+  CUT_DEFAULT         = 0;
+  DDS_DEFAULT         = 0;
+  FAXG3_DEFAULT       = 0;
+  GIF_DEFAULT         = 0;
+  ICO_DEFAULT         = 0;
+  ICO_MAKEALPHA       = 0;     // convert to 32bpp and create an alpha channel from the AND-mask when loading
+  IFF_DEFAULT         = 0;
+  JPEG_DEFAULT        = 0;
+  JPEG_FAST           = 1;
+  JPEG_ACCURATE       = 2;
+  JPEG_QUALITYSUPERB  = $0080;
+  JPEG_QUALITYGOOD    = $0100;
+  JPEG_QUALITYNORMAL  = $0200;
+  JPEG_QUALITYAVERAGE = $0400;
+  JPEG_QUALITYBAD     = $0800;
+  JPEG_CMYK           = $1000; // load separated CMYK "as is" (use | to combine with other flags)
+  KOALA_DEFAULT       = 0;
+  LBM_DEFAULT         = 0;
+  MNG_DEFAULT         = 0;
+  PCD_DEFAULT         = 0;
+  PCD_BASE            = 1;     // load the bitmap sized 768 x 512
+  PCD_BASEDIV4        = 2;     // load the bitmap sized 384 x 256
+  PCD_BASEDIV16       = 3;     // load the bitmap sized 192 x 128
+  PCX_DEFAULT         = 0;
+  PNG_DEFAULT         = 0;
+  PNG_IGNOREGAMMA     = 1;     // avoid gamma correction
+  PNM_DEFAULT         = 0;
+  PNM_SAVE_RAW        = 0;     // If set the writer saves in RAW format (i.e. P4, P5 or P6)
+  PNM_SAVE_ASCII      = 1;     // If set the writer saves in ASCII format (i.e. P1, P2 or P3)
+  PSD_DEFAULT         = 0;
+  RAS_DEFAULT         = 0;
+  SGI_DEFAULT         = 0;
+  TARGA_DEFAULT       = 0;
+  TARGA_LOAD_RGB888   = 1;     // If set the loader converts RGB555 and ARGB8888 -> RGB888.
+  TIFF_DEFAULT        = 0;
+  TIFF_CMYK	          = $0001;  // reads/stores tags for separated CMYK (use | to combine with compression flags)
+  TIFF_PACKBITS       = $0100;  // save using PACKBITS compression
+  TIFF_DEFLATE        = $0200;  // save using DEFLATE compression
+  TIFF_ADOBE_DEFLATE  = $0400;  // save using ADOBE DEFLATE compression
+  TIFF_NONE           = $0800;  // save without any compression
+  TIFF_CCITTFAX3		  = $1000;  // save using CCITT Group 3 fax encoding
+  TIFF_CCITTFAX4		  = $2000;  // save using CCITT Group 4 fax encoding
+  TIFF_LZW			      = $4000; 	// save using LZW compression
+  TIFF_JPEG			      = $8000;	// save using JPEG compression
+  WBMP_DEFAULT        = 0;
+  XBM_DEFAULT         = 0;
+  XPM_DEFAULT         = 0;
+
+// --------------------------------------------------------------------------
+// Init/Error routines ------------------------------------------------------
+// --------------------------------------------------------------------------
+
+procedure FreeImage_Initialise(load_local_plugins_only : boolean = False); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_DeInitialise; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Version routines ---------------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_GetVersion : PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetCopyrightMessage : PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Message output functions -------------------------------------------------
+// --------------------------------------------------------------------------
+
+procedure FreeImage_OutPutMessageProc(fif: Integer; fmt: PChar); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+type FreeImage_OutputMessageFunction = function(fif: FREE_IMAGE_FORMAT; msg: PChar): pointer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+procedure FreeImage_SetOutputMessage(omf: FreeImage_OutputMessageFunction); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Allocate/Unload routines -------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_Allocate(width, height, bpp: integer; red_mask: Cardinal = 0; green_mask: Cardinal = 0; blue_mask: Cardinal = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_AllocateT(Atype: FREE_IMAGE_TYPE; Width, Height: Integer; bpp: Integer = 8; red_mask: Cardinal = 0; green_mask: Cardinal = 0; blue_mask: Cardinal = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_Clone(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_Unload(dib: PFIBITMAP); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Load / Save routines -----------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_Load(fif: FREE_IMAGE_FORMAT; const filename: PChar; flags: integer = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_LoadU(fif: FREE_IMAGE_FORMAT; const filename: PWideChar; flags: Integer = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_LoadFromHandle(fif: FREE_IMAGE_FORMAT; io: PFreeImageIO; handle: fi_handle; flags: integer = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_Save(fif: FREE_IMAGE_FORMAT; dib: PFIBITMAP; filename: PChar; flags: integer = 0): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SaveU(fif: FREE_IMAGE_FORMAT; dib: PFIBITMAP; const filename: PWideChar; flags: Integer = 0): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SaveToHandle(fif: FREE_IMAGE_FORMAT; dib: PFIBITMAP; io : PFreeImageIO; handle : fi_handle; flags : integer = 0) : Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Memory I/O stream routines -----------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_OpenMemory(data: PByte = nil; size_in_bytes: DWORD = 0): PFIMEMORY; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_CloseMemory(stream: PFIMEMORY); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_LoadFromMemory(fif: FREE_IMAGE_FORMAT; stream: PFIMEMORY; flags: Integer = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SaveToMemory(fif: FREE_IMAGE_FORMAT; dib: PFIBITMAP; stream: PFIMEMORY; flags: Integer = 0): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_TellMemory(stream: PFIMEMORY): Longint; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SeekMemory(stream: PFIMEMORY; offset: Longint; origin: Integer): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_AcquireMemory(stream: PFIMEMORY; var data: PByte; var size_in_bytes: DWORD): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Plugin Interface ---------------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_RegisterLocalPlugin(proc_address: FI_InitProc; format, description, extension, regexpr: PChar): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_RegisterExternalPlugin(path, format, description, extension, regexpr: PChar): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFCount: Integer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_SetPluginEnabled(fif: FREE_IMAGE_FORMAT; enable: Boolean); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_IsPluginEnabled(fif: FREE_IMAGE_FORMAT): Integer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFFromFormat(const format: PChar): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFFromMime(const format: PChar): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFormatFromFIF(fif: FREE_IMAGE_FORMAT): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFExtensionList(fif: FREE_IMAGE_FORMAT): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFDescription(fif: FREE_IMAGE_FORMAT): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFRegExpr(fif: FREE_IMAGE_FORMAT): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFFromFilename(const fname: PChar): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFIFFromFilenameU(const fname:PWideChar): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FIFSupportsReading(fif: FREE_IMAGE_FORMAT): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FIFSupportsWriting(fif: FREE_IMAGE_FORMAT): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FIFSupportsExportBPP(fif: FREE_IMAGE_FORMAT; bpp: Integer): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FIFSupportsICCProfiles(fif: FREE_IMAGE_FORMAT): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FIFSupportsExportType(fif: FREE_IMAGE_FORMAT; image_type: FREE_IMAGE_TYPE): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Multipaging interface ----------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_OpenMultiBitmap(fif: FREE_IMAGE_FORMAT; filename: PChar; create_new, read_only, keep_cache_in_memory: Boolean; flags: integer = 0): PFIMULTIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_CloseMultiBitmap(bitmap: PFIMULTIBITMAP; flags: Integer = 0): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetPageCount(bitmap: PFIMULTIBITMAP): Integer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_AppendPage(bitmap: PFIMULTIBITMAP; data: PFIBITMAP); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_InsertPage(bitmap: PFIMULTIBITMAP; page: Integer; data: PFIBITMAP); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_DeletePage(bitmap: PFIMULTIBITMAP; page: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_LockPage(bitmap: PFIMULTIBITMAP; page: Integer): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_UnlockPage(bitmap: PFIMULTIBITMAP; page: PFIBITMAP; changed: boolean); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_MovePage(bitmap: PFIMULTIBITMAP; target, source: Integer): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetLockedPageNumbers(bitmap: PFIMULTIBITMAP; var pages: Integer; var count : integer): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Filetype request routines ------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_GetFileType(const filename: PChar; size: Integer): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFileTypeU(const filename: PWideChar; size: Integer): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFileTypeFromHandle(io: PFreeImageIO; handle: FI_Handle; size: Integer = 0): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetFileTypeFromMemory(stream: PFIMEMORY; size: Integer = 0): FREE_IMAGE_FORMAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL; 
+
+// --------------------------------------------------------------------------
+// ImageType request routine ------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_GetImageType(dib: PFIBITMAP): FREE_IMAGE_TYPE; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// FreeImage helper routines ------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_IsLittleEndian: Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_LookupX11Color(const szColor: PChar; var nRed, nGreen, nBlue: PByte): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_LookupSVGColor(const szColor: PChar; var nRed, nGreen, nBlue: PByte): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Pixels access routines ---------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_GetBits(dib: PFIBITMAP): PByte; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetScanLine(dib: PFIBITMAP; scanline: Integer): PByte; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_GetPixelIndex(dib: PFIBITMAP; X, Y: Longint; Value: PByte): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetPixelColor(dib: PFIBITMAP; X, Y: Longint; Value: PRGBQuad): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetPixelIndex(dib: PFIBITMAP; X, Y: Longint; Value: PByte): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetPixelColor(dib: PFIBITMAP; X, Y: Longint; Value: PRGBQuad): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// DIB info routines --------------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_GetColorsUsed(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetBPP(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetWidth(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetHeight(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetLine(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetPitch(dib : PFIBITMAP) : Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetDIBSize(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetPalette(dib: PFIBITMAP): PRGBQUAD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_GetDotsPerMeterX(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetDotsPerMeterY(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_SetDotsPerMeterX(dib: PFIBITMAP; res: Cardinal); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_SetDotsPerMeterY(dib: PFIBITMAP; res: Cardinal); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_GetInfoHeader(dib: PFIBITMAP): PBITMAPINFOHEADER; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetInfo(var dib: FIBITMAP): PBITMAPINFO; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetColorType(dib: PFIBITMAP): FREE_IMAGE_COLOR_TYPE; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_GetRedMask(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetGreenMask(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetBlueMask(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_GetTransparencyCount(dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetTransparencyTable(dib: PFIBITMAP): PByte; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_SetTransparent(dib: PFIBITMAP; enabled: boolean); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_SetTransparencyTable(dib: PFIBITMAP; table: PByte; count: integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_IsTransparent(dib: PFIBITMAP): boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_HasBackgroundColor(dib: PFIBITMAP): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetBackgroundColor(dib: PFIBITMAP; var bkcolor: PRGBQUAD): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetBackgroundColor(dib: PFIBITMAP; bkcolor: PRGBQUAD): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// ICC profile routines -----------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_GetICCProfile(var dib: FIBITMAP): PFIICCPROFILE; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_CreateICCProfile(var dib: FIBITMAP; data: Pointer; size: Longint): PFIICCPROFILE; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_DestroyICCProfile(var dib : FIBITMAP); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Line conversion routines -------------------------------------------------
+// --------------------------------------------------------------------------
+
+procedure FreeImage_ConvertLine1To4(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine8To4(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQuad);  {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To4_555(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To4_565(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine24To4(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine32To4(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+procedure FreeImage_ConvertLine1To8(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine4To8(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To8_555(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To8_565(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine24To8(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine32To8(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+procedure FreeImage_ConvertLine1To16_555(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine4To16_555(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine8To16_555(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16_565_To16_555(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine24To16_555(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine32To16_555(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+procedure FreeImage_ConvertLine1To16_565(target, source : PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine4To16_565(target, source : PBYTE; width_in_pixels : Integer; palette : PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine8To16_565(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16_555_To16_565(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine24To16_565(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine32To16_565(target, source : PBYTE; width_in_pixels : Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+procedure FreeImage_ConvertLine1To24(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine4To24(target, source : PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine8To24(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To24_555(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To24_565(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine32To24(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+procedure FreeImage_ConvertLine1To32(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine4To32(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine8To32(target, source: PBYTE; width_in_pixels: Integer; palette: PRGBQUAD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To32_555(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine16To32_565(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertLine24To32(target, source: PBYTE; width_in_pixels: Integer); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Smart conversion routines ------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_ConvertTo4Bits(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ConvertTo8Bits(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ConvertToGreyscale(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ConvertTo16Bits555(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ConvertTo16Bits565(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ConvertTo24Bits(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ConvertTo32Bits(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ColorQuantize(dib: PFIBITMAP; quantize: FREE_IMAGE_QUANTIZE): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ColorQuantizeEx(dib: PFIBITMAP; quantize: FREE_IMAGE_QUANTIZE = FIQ_WUQUANT; PaletteSize: Integer = 256; ReserveSize: Integer = 0; ReservePalette: PRGBQuad = nil): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_Threshold(dib: PFIBITMAP; T: Byte): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_Dither(dib: PFIBITMAP; algorithm: FREE_IMAGE_DITHER): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_ConvertFromRawBits(bits: PBYTE; width, height, pitch: Integer; bpp, red_mask, green_mask, blue_mask: LongWord; topdown: Boolean): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_ConvertToRawBits(bits: PBYTE; dib: PFIBITMAP; pitch: Integer; bpp, red_mask, green_mask, blue_mask: LongWord; topdown: Boolean); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_ConvertToRGBF(dib: PFIBITMAP): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_ConvertToStandardType(src: PFIBITMAP; scale_linear: Boolean = True): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ConvertToType(src: PFIBITMAP; dst_type: FREE_IMAGE_TYPE; scale_linear: Boolean = True): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// tone mapping operators
+function FreeImage_ToneMapping(dib: PFIBITMAP; tmo: FREE_IMAGE_TMO; first_param: Double = 0; second_param: Double = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_TmoDrago03(src: PFIBITMAP; gamma: Double = 2.2; exposure: Double = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_TmoReinhard05(src: PFIBITMAP; intensity: Double = 0; contrast: Double = 0): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// ZLib interface -----------------------------------------------------------
+// --------------------------------------------------------------------------
+
+function FreeImage_ZLibCompress(target: PBYTE; target_size: DWORD; source: PBYTE; source_size: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ZLibUncompress(target: PBYTE; target_size: DWORD; source: PBYTE; source_size: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_ZLibGZip(target: PBYTE; target_size: DWORD; source: PBYTE; source_size: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ZLibGUnzip(target: PBYTE; target_size: DWORD; source: PBYTE; source_size: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_ZLibCRC32(crc: DWORD; source: PByte; source_size: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Metadata routines --------------------------------------------------------
+// --------------------------------------------------------------------------
+
+// tag creation / destruction
+function FreeImage_CreateTag: PFITAG; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_DeleteTag(tag: PFITAG); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_CloneTag(tag: PFITAG): PFITAG; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// tag getters and setters
+function FreeImage_GetTagKey(tag: PFITAG): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetTagDescription(tag: PFITAG): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetTagID(tag: PFITAG): Word; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetTagType(tag: PFITAG): FREE_IMAGE_MDTYPE; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetTagCount(tag: PFITAG): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetTagLength(tag: PFITAG): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetTagValue(tag: PFITAG): Pointer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+function FreeImage_SetTagKey(tag: PFITAG; const key: PChar): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetTagDescription(tag: PFITAG; const description: PChar): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetTagID(tag: PFITAG; id: Word): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetTagType(tag: PFITAG; atype: FREE_IMAGE_MDTYPE): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetTagCount(tag: PFITAG; count: DWORD): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetTagLength(tag: PFITAG; length: DWORD): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetTagValue(tag: PFITAG; const value: Pointer): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// iterator
+function FreeImage_FindFirstMetadata(model: FREE_IMAGE_MDMODEL; dib: PFIBITMAP; var tag: PFITAG): PFIMETADATA; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FindNextMetadata(mdhandle: PFIMETADATA; var tag: PFITAG): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+procedure FreeImage_FindCloseMetadata(mdhandle: PFIMETADATA); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// metadata setter and getter
+function FreeImage_SetMetadata(model: FREE_IMAGE_MDMODEL; dib: PFIBITMAP; const key: PChar; tag: PFITAG): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetMetadata(model: FREE_IMAGE_MDMODEL; dib: PFIBITMAP; const key: PChar; var tag: PFITAG): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// helpers
+function FreeImage_GetMetadataCount(model: FREE_IMAGE_MDMODEL; dib: PFIBITMAP): Cardinal; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// tag to C string conversion
+function FreeImage_TagToString(model: FREE_IMAGE_MDMODEL; tag: PFITAG; Make: PChar = nil): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// --------------------------------------------------------------------------
+// Image manipulation toolkit -----------------------------------------------
+// --------------------------------------------------------------------------
+
+// rotation and flipping
+function FreeImage_RotateClassic(dib: PFIBITMAP; angle: Double): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_RotateEx(dib: PFIBITMAP; angle, x_shift, y_shift, x_origin, y_origin: Double; use_mask: Boolean): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FlipHorizontal(dib: PFIBITMAP): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_FlipVertical(dib: PFIBITMAP): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_JPEGTransform(const src_file: PChar; const dst_file: PChar; operation: FREE_IMAGE_JPEG_OPERATION; perfect: Boolean = False): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// upsampling / downsampling
+function FreeImage_Rescale(dib: PFIBITMAP; dst_width, dst_height: Integer; filter: FREE_IMAGE_FILTER): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_MakeThumbnail(dib: PFIBITMAP; max_pixel_size: Integer; convert:boolean = TRUE): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL; 
+
+// color manipulation routines (point operations)
+function FreeImage_AdjustCurve(dib: PFIBITMAP; LUT: PBYTE; channel: FREE_IMAGE_COLOR_CHANNEL): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_AdjustGamma(dib: PFIBITMAP; gamma: Double): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_AdjustBrightness(dib: PFIBITMAP; percentage: Double): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_AdjustContrast(dib: PFIBITMAP; percentage: Double): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_Invert(dib: PFIBITMAP): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetHistogram(dib: PFIBITMAP; histo: PDWORD; channel: FREE_IMAGE_COLOR_CHANNEL = FICC_BLACK): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// channel processing routines
+function FreeImage_GetChannel(dib: PFIBITMAP; channel: FREE_IMAGE_COLOR_CHANNEL): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetChannel(dib, dib8: PFIBITMAP; channel: FREE_IMAGE_COLOR_CHANNEL): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_GetComplexChannel(src: PFIBITMAP; channel: FREE_IMAGE_COLOR_CHANNEL): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_SetComplexChannel(src: PFIBITMAP; channel: FREE_IMAGE_COLOR_CHANNEL): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+
+// copy / paste / composite routines
+
+function FreeImage_Copy(dib: PFIBITMAP; left, top, right, bottom: Integer): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_Paste(dst, src: PFIBITMAP; left, top, alpha: Integer): Boolean; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+function FreeImage_Composite(fg: PFIBITMAP; useFileBkg: Boolean = False; appBkColor: PRGBQUAD = nil; bg: PFIBITMAP = nil): PFIBITMAP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external FIDLL;
+  
+{$MINENUMSIZE 1}
+implementation
+
+end.
diff --git a/Game/Code/lib/FreeImage/libfreeimage.dylib b/Game/Code/lib/FreeImage/libfreeimage.dylib
new file mode 100755
index 00000000..5f9aecce
--- /dev/null
+++ b/Game/Code/lib/FreeImage/libfreeimage.dylib
diff --git a/Game/Code/lib/SQLite/SQLite3.pas b/Game/Code/lib/SQLite/SQLite3.pas
index b7f9d375..4991fc66 100644
--- a/Game/Code/lib/SQLite/SQLite3.pas
+++ b/Game/Code/lib/SQLite/SQLite3.pas
@@ -10,9 +10,19 @@ unit SQLite3;
 

 interface

 

+{$I switches.inc}

+

 const

 

+{$IFDEF MSWINDOWS}

   SQLiteDLL = 'sqlite3.dll';

+{$ENDIF}

+{$IFDEF LINUX}

+  SQLiteDLL = 'sqlite3.so';

+{$ENDIF}

+{$IFDEF DARWIN}

+  SQLiteDLL = 'libsqlite3.dylib';

+{$ENDIF}

 

 // Return values for sqlite3_exec() and sqlite3_step()

 

diff --git a/Game/Code/lib/SQLite/SQLiteTable3.pas b/Game/Code/lib/SQLite/SQLiteTable3.pas
index 05fbd573..18135765 100644
--- a/Game/Code/lib/SQLite/SQLiteTable3.pas
+++ b/Game/Code/lib/SQLite/SQLiteTable3.pas
@@ -17,9 +17,7 @@ unit SQLiteTable3;
 
 interface
 
-{$IFDEF FPC}
- {$MODE Delphi}
-{$ENDIF}
+{$I switches.inc}
 
 uses
   {$ifdef win32}
diff --git a/Game/Code/lib/bass/MacOSX/Bass.pas b/Game/Code/lib/bass/MacOSX/Bass.pas
new file mode 100755
index 00000000..d065f027
--- /dev/null
+++ b/Game/Code/lib/bass/MacOSX/Bass.pas
@@ -0,0 +1,984 @@
+{
+  BASS 2.3 Audio Library, (c) 1999-2007 Ian Luck.
+  Please report bugs/suggestions/etc... to bass@un4seen.com
+
+  See the BASS.CHM file for more complete documentation
+
+
+  How to install
+  ----------------
+  Copy BASS.PAS to the \LIB subdirectory of your Delphi path or your project dir
+}
+unit Bass;
+
+{$I switches.inc}
+
+interface
+
+uses
+  Windows;
+
+const
+  BASSVERSION = $203;             // API version
+
+  // Use these to test for error from functions that return a DWORD or QWORD
+  DW_ERROR = Cardinal(-1); // -1 (DWORD)
+  QW_ERROR = Int64(-1);    // -1 (QWORD)
+
+  // Error codes returned by BASS_GetErrorCode()
+  BASS_OK                 = 0;    // all is OK
+  BASS_ERROR_MEM          = 1;    // memory error
+  BASS_ERROR_FILEOPEN     = 2;    // can't open the file
+  BASS_ERROR_DRIVER       = 3;    // can't find a free sound driver
+  BASS_ERROR_BUFLOST      = 4;    // the sample buffer was lost - please report this!
+  BASS_ERROR_HANDLE       = 5;    // invalid handle
+  BASS_ERROR_FORMAT       = 6;    // unsupported sample format
+  BASS_ERROR_POSITION     = 7;    // invalid playback position
+  BASS_ERROR_INIT         = 8;    // BASS_Init has not been successfully called
+  BASS_ERROR_START        = 9;    // BASS_Start has not been successfully called
+  BASS_ERROR_ALREADY      = 14;   // already initialized/paused/whatever
+  BASS_ERROR_NOPAUSE      = 16;   // not paused
+  BASS_ERROR_NOCHAN       = 18;   // can't get a free channel
+  BASS_ERROR_ILLTYPE      = 19;   // an illegal type was specified
+  BASS_ERROR_ILLPARAM     = 20;   // an illegal parameter was specified
+  BASS_ERROR_NO3D         = 21;   // no 3D support
+  BASS_ERROR_NOEAX        = 22;   // no EAX support
+  BASS_ERROR_DEVICE       = 23;   // illegal device number
+  BASS_ERROR_NOPLAY       = 24;   // not playing
+  BASS_ERROR_FREQ         = 25;   // illegal sample rate
+  BASS_ERROR_NOTFILE      = 27;   // the stream is not a file stream
+  BASS_ERROR_NOHW         = 29;   // no hardware voices available
+  BASS_ERROR_EMPTY        = 31;   // the MOD music has no sequence data
+  BASS_ERROR_NONET        = 32;   // no internet connection could be opened
+  BASS_ERROR_CREATE       = 33;   // couldn't create the file
+  BASS_ERROR_NOFX         = 34;   // effects are not enabled
+  BASS_ERROR_PLAYING      = 35;   // the channel is playing
+  BASS_ERROR_NOTAVAIL     = 37;   // requested data is not available
+  BASS_ERROR_DECODE       = 38;   // the channel is a "decoding channel"
+  BASS_ERROR_DX           = 39;   // a sufficient DirectX version is not installed
+  BASS_ERROR_TIMEOUT      = 40;   // connection timedout
+  BASS_ERROR_FILEFORM     = 41;   // unsupported file format
+  BASS_ERROR_SPEAKER      = 42;   // unavailable speaker
+  BASS_ERROR_VERSION      = 43;   // invalid BASS version (used by add-ons)
+  BASS_ERROR_CODEC        = 44;   // codec is not available/supported
+  BASS_ERROR_UNKNOWN      = -1;   // some other mystery error
+
+  // Initialization flags
+  BASS_DEVICE_8BITS       = 1;    // use 8 bit resolution, else 16 bit
+  BASS_DEVICE_MONO        = 2;    // use mono, else stereo
+  BASS_DEVICE_3D          = 4;    // enable 3D functionality
+  {
+    If the BASS_DEVICE_3D flag is not specified when
+    initilizing BASS, then the 3D flags (BASS_SAMPLE_3D
+    and BASS_MUSIC_3D) are ignored when loading/creating
+    a sample/stream/music.
+  }
+  BASS_DEVICE_LATENCY     = 256;  // calculate device latency (BASS_INFO struct)
+  BASS_DEVICE_SPEAKERS    = 2048; // force enabling of speaker assignment
+  BASS_DEVICE_NOSPEAKER   = 4096; // ignore speaker arrangement
+
+  // DirectSound interfaces (for use with BASS_GetDSoundObject)
+  BASS_OBJECT_DS          = 1;   // IDirectSound
+  BASS_OBJECT_DS3DL       = 2;   // IDirectSound3DListener
+
+  // BASS_INFO flags (from DSOUND.H)
+  DSCAPS_CONTINUOUSRATE   = $00000010;
+  { supports all sample rates between min/maxrate }
+  DSCAPS_EMULDRIVER       = $00000020;
+  { device does NOT have hardware DirectSound support }
+  DSCAPS_CERTIFIED        = $00000040;
+  { device driver has been certified by Microsoft }
+  {
+    The following flags tell what type of samples are
+    supported by HARDWARE mixing, all these formats are
+    supported by SOFTWARE mixing
+  }
+  DSCAPS_SECONDARYMONO    = $00000100;     // mono
+  DSCAPS_SECONDARYSTEREO  = $00000200;     // stereo
+  DSCAPS_SECONDARY8BIT    = $00000400;     // 8 bit
+  DSCAPS_SECONDARY16BIT   = $00000800;     // 16 bit
+
+  // BASS_RECORDINFO flags (from DSOUND.H)
+  DSCCAPS_EMULDRIVER = DSCAPS_EMULDRIVER;
+  { device does NOT have hardware DirectSound recording support }
+  DSCCAPS_CERTIFIED = DSCAPS_CERTIFIED;
+  { device driver has been certified by Microsoft }
+
+  // defines for formats field of BASS_RECORDINFO (from MMSYSTEM.H)
+  WAVE_FORMAT_1M08       = $00000001;      // 11.025 kHz, Mono,   8-bit
+  WAVE_FORMAT_1S08       = $00000002;      // 11.025 kHz, Stereo, 8-bit
+  WAVE_FORMAT_1M16       = $00000004;      // 11.025 kHz, Mono,   16-bit
+  WAVE_FORMAT_1S16       = $00000008;      // 11.025 kHz, Stereo, 16-bit
+  WAVE_FORMAT_2M08       = $00000010;      // 22.05  kHz, Mono,   8-bit
+  WAVE_FORMAT_2S08       = $00000020;      // 22.05  kHz, Stereo, 8-bit
+  WAVE_FORMAT_2M16       = $00000040;      // 22.05  kHz, Mono,   16-bit
+  WAVE_FORMAT_2S16       = $00000080;      // 22.05  kHz, Stereo, 16-bit
+  WAVE_FORMAT_4M08       = $00000100;      // 44.1   kHz, Mono,   8-bit
+  WAVE_FORMAT_4S08       = $00000200;      // 44.1   kHz, Stereo, 8-bit
+  WAVE_FORMAT_4M16       = $00000400;      // 44.1   kHz, Mono,   16-bit
+  WAVE_FORMAT_4S16       = $00000800;      // 44.1   kHz, Stereo, 16-bit
+
+  // Sample info flags
+  BASS_SAMPLE_8BITS       = 1;   // 8 bit
+  BASS_SAMPLE_FLOAT       = 256; // 32-bit floating-point
+  BASS_SAMPLE_MONO        = 2;   // mono, else stereo
+  BASS_SAMPLE_LOOP        = 4;   // looped
+  BASS_SAMPLE_3D          = 8;   // 3D functionality enabled
+  BASS_SAMPLE_SOFTWARE    = 16;  // it's NOT using hardware mixing
+  BASS_SAMPLE_MUTEMAX     = 32;  // muted at max distance (3D only)
+  BASS_SAMPLE_VAM         = 64;  // uses the DX7 voice allocation & management
+  BASS_SAMPLE_FX          = 128; // old implementation of DX8 effects are enabled
+  BASS_SAMPLE_OVER_VOL    = $10000; // override lowest volume
+  BASS_SAMPLE_OVER_POS    = $20000; // override longest playing
+  BASS_SAMPLE_OVER_DIST   = $30000; // override furthest from listener (3D only)
+
+  BASS_STREAM_PRESCAN     = $20000; // enable pin-point seeking (MP3/MP2/MP1)
+  BASS_MP3_SETPOS         = BASS_STREAM_PRESCAN;
+  BASS_STREAM_AUTOFREE	  = $40000; // automatically free the stream when it stop/ends
+  BASS_STREAM_RESTRATE	  = $80000; // restrict the download rate of internet file streams
+  BASS_STREAM_BLOCK       = $100000;// download/play internet file stream in small blocks
+  BASS_STREAM_DECODE      = $200000;// don't play the stream, only decode (BASS_ChannelGetData)
+  BASS_STREAM_STATUS      = $800000;// give server status info (HTTP/ICY tags) in DOWNLOADPROC
+
+  BASS_MUSIC_FLOAT        = BASS_SAMPLE_FLOAT; // 32-bit floating-point
+  BASS_MUSIC_MONO         = BASS_SAMPLE_MONO; // force mono mixing (less CPU usage)
+  BASS_MUSIC_LOOP         = BASS_SAMPLE_LOOP; // loop music
+  BASS_MUSIC_3D           = BASS_SAMPLE_3D; // enable 3D functionality
+  BASS_MUSIC_FX           = BASS_SAMPLE_FX; // enable old implementation of DX8 effects
+  BASS_MUSIC_AUTOFREE     = BASS_STREAM_AUTOFREE; // automatically free the music when it stop/ends
+  BASS_MUSIC_DECODE       = BASS_STREAM_DECODE; // don't play the music, only decode (BASS_ChannelGetData)
+  BASS_MUSIC_PRESCAN      = BASS_STREAM_PRESCAN; // calculate playback length
+  BASS_MUSIC_CALCLEN      = BASS_MUSIC_PRESCAN;
+  BASS_MUSIC_RAMP         = $200;  // normal ramping
+  BASS_MUSIC_RAMPS        = $400;  // sensitive ramping
+  BASS_MUSIC_SURROUND     = $800;  // surround sound
+  BASS_MUSIC_SURROUND2    = $1000; // surround sound (mode 2)
+  BASS_MUSIC_FT2MOD       = $2000; // play .MOD as FastTracker 2 does
+  BASS_MUSIC_PT1MOD       = $4000; // play .MOD as ProTracker 1 does
+  BASS_MUSIC_NONINTER     = $10000; // non-interpolated mixing
+  BASS_MUSIC_POSRESET     = $8000; // stop all notes when moving position
+  BASS_MUSIC_POSRESETEX   = $400000; // stop all notes and reset bmp/etc when moving position
+  BASS_MUSIC_STOPBACK     = $80000; // stop the music on a backwards jump effect
+  BASS_MUSIC_NOSAMPLE     = $100000; // don't load the samples
+
+  // Speaker assignment flags
+  BASS_SPEAKER_FRONT      = $1000000;  // front speakers
+  BASS_SPEAKER_REAR       = $2000000;  // rear/side speakers
+  BASS_SPEAKER_CENLFE     = $3000000;  // center & LFE speakers (5.1)
+  BASS_SPEAKER_REAR2      = $4000000;  // rear center speakers (7.1)
+  BASS_SPEAKER_LEFT       = $10000000; // modifier: left
+  BASS_SPEAKER_RIGHT      = $20000000; // modifier: right
+  BASS_SPEAKER_FRONTLEFT  = BASS_SPEAKER_FRONT or BASS_SPEAKER_LEFT;
+  BASS_SPEAKER_FRONTRIGHT = BASS_SPEAKER_FRONT or BASS_SPEAKER_RIGHT;
+  BASS_SPEAKER_REARLEFT   = BASS_SPEAKER_REAR or BASS_SPEAKER_LEFT;
+  BASS_SPEAKER_REARRIGHT  = BASS_SPEAKER_REAR or BASS_SPEAKER_RIGHT;
+  BASS_SPEAKER_CENTER     = BASS_SPEAKER_CENLFE or BASS_SPEAKER_LEFT;
+  BASS_SPEAKER_LFE        = BASS_SPEAKER_CENLFE or BASS_SPEAKER_RIGHT;
+  BASS_SPEAKER_REAR2LEFT  = BASS_SPEAKER_REAR2 or BASS_SPEAKER_LEFT;
+  BASS_SPEAKER_REAR2RIGHT = BASS_SPEAKER_REAR2 or BASS_SPEAKER_RIGHT;
+
+  BASS_UNICODE            = $80000000;
+
+  BASS_RECORD_PAUSE       = $8000; // start recording paused
+
+  // DX7 voice allocation flags
+  BASS_VAM_HARDWARE       = 1;
+  {
+    Play the sample in hardware. If no hardware voices are available then
+    the "play" call will fail
+  }
+  BASS_VAM_SOFTWARE       = 2;
+  {
+    Play the sample in software (ie. non-accelerated). No other VAM flags
+    may be used together with this flag.
+  }
+
+  // DX7 voice management flags
+  {
+    These flags enable hardware resource stealing... if the hardware has no
+    available voices, a currently playing buffer will be stopped to make room
+    for the new buffer. NOTE: only samples loaded/created with the
+    BASS_SAMPLE_VAM flag are considered for termination by the DX7 voice
+    management.
+  }
+  BASS_VAM_TERM_TIME      = 4;
+  {
+    If there are no free hardware voices, the buffer to be terminated will be
+    the one with the least time left to play.
+  }
+  BASS_VAM_TERM_DIST      = 8;
+  {
+    If there are no free hardware voices, the buffer to be terminated will be
+    one that was loaded/created with the BASS_SAMPLE_MUTEMAX flag and is
+    beyond
+    it's max distance. If there are no buffers that match this criteria, then
+    the "play" call will fail.
+  }
+  BASS_VAM_TERM_PRIO      = 16;
+  {
+    If there are no free hardware voices, the buffer to be terminated will be
+    the one with the lowest priority.
+  }
+
+  // BASS_CHANNELINFO types
+  BASS_CTYPE_SAMPLE       = 1;
+  BASS_CTYPE_RECORD       = 2;
+  BASS_CTYPE_STREAM       = $10000;
+  BASS_CTYPE_STREAM_OGG   = $10002;
+  BASS_CTYPE_STREAM_MP1   = $10003;
+  BASS_CTYPE_STREAM_MP2   = $10004;
+  BASS_CTYPE_STREAM_MP3   = $10005;
+  BASS_CTYPE_STREAM_AIFF  = $10006;
+  BASS_CTYPE_STREAM_WAV   = $40000; // WAVE flag, LOWORD=codec
+  BASS_CTYPE_STREAM_WAV_PCM = $50001;
+  BASS_CTYPE_STREAM_WAV_FLOAT = $50003;
+  BASS_CTYPE_MUSIC_MOD    = $20000;
+  BASS_CTYPE_MUSIC_MTM    = $20001;
+  BASS_CTYPE_MUSIC_S3M    = $20002;
+  BASS_CTYPE_MUSIC_XM     = $20003;
+  BASS_CTYPE_MUSIC_IT     = $20004;
+  BASS_CTYPE_MUSIC_MO3    = $00100; // MO3 flag
+
+  // 3D channel modes
+  BASS_3DMODE_NORMAL      = 0;
+  { normal 3D processing }
+  BASS_3DMODE_RELATIVE    = 1;
+  {
+    The channel's 3D position (position/velocity/
+    orientation) are relative to the listener. When the
+    listener's position/velocity/orientation is changed
+    with BASS_Set3DPosition, the channel's position
+    relative to the listener does not change.
+  }
+  BASS_3DMODE_OFF         = 2;
+  {
+    Turn off 3D processing on the channel, the sound will
+    be played in the center.
+  }
+
+  // EAX environments, use with BASS_SetEAXParameters
+  EAX_ENVIRONMENT_GENERIC           = 0;
+  EAX_ENVIRONMENT_PADDEDCELL        = 1;
+  EAX_ENVIRONMENT_ROOM              = 2;
+  EAX_ENVIRONMENT_BATHROOM          = 3;
+  EAX_ENVIRONMENT_LIVINGROOM        = 4;
+  EAX_ENVIRONMENT_STONEROOM         = 5;
+  EAX_ENVIRONMENT_AUDITORIUM        = 6;
+  EAX_ENVIRONMENT_CONCERTHALL       = 7;
+  EAX_ENVIRONMENT_CAVE              = 8;
+  EAX_ENVIRONMENT_ARENA             = 9;
+  EAX_ENVIRONMENT_HANGAR            = 10;
+  EAX_ENVIRONMENT_CARPETEDHALLWAY   = 11;
+  EAX_ENVIRONMENT_HALLWAY           = 12;
+  EAX_ENVIRONMENT_STONECORRIDOR     = 13;
+  EAX_ENVIRONMENT_ALLEY             = 14;
+  EAX_ENVIRONMENT_FOREST            = 15;
+  EAX_ENVIRONMENT_CITY              = 16;
+  EAX_ENVIRONMENT_MOUNTAINS         = 17;
+  EAX_ENVIRONMENT_QUARRY            = 18;
+  EAX_ENVIRONMENT_PLAIN             = 19;
+  EAX_ENVIRONMENT_PARKINGLOT        = 20;
+  EAX_ENVIRONMENT_SEWERPIPE         = 21;
+  EAX_ENVIRONMENT_UNDERWATER        = 22;
+  EAX_ENVIRONMENT_DRUGGED           = 23;
+  EAX_ENVIRONMENT_DIZZY             = 24;
+  EAX_ENVIRONMENT_PSYCHOTIC         = 25;
+  // total number of environments
+  EAX_ENVIRONMENT_COUNT             = 26;
+
+  // software 3D mixing algorithm modes (used with BASS_Set3DAlgorithm)
+  BASS_3DALG_DEFAULT                = 0;
+  {
+    default algorithm (currently translates to BASS_3DALG_OFF)
+  }
+  BASS_3DALG_OFF                    = 1;
+  {
+    Uses normal left and right panning. The vertical axis is ignored except
+    for scaling of volume due to distance. Doppler shift and volume scaling
+    are still applied, but the 3D filtering is not performed. This is the
+    most CPU efficient software implementation, but provides no virtual 3D
+    audio effect. Head Related Transfer Function processing will not be done.
+    Since only normal stereo panning is used, a channel using this algorithm
+    may be accelerated by a 2D hardware voice if no free 3D hardware voices
+    are available.
+  }
+  BASS_3DALG_FULL                   = 2;
+  {
+    This algorithm gives the highest quality 3D audio effect, but uses more
+    CPU. Requires Windows 98 2nd Edition or Windows 2000 that uses WDM
+    drivers, if this mode is not available then BASS_3DALG_OFF will be used
+    instead.
+  }
+  BASS_3DALG_LIGHT                  = 3;
+  {
+    This algorithm gives a good 3D audio effect, and uses less CPU than the
+    FULL mode. Requires Windows 98 2nd Edition or Windows 2000 that uses WDM
+    drivers, if this mode is not available then BASS_3DALG_OFF will be used
+    instead.
+  }
+
+  {
+    Sync types (with BASS_ChannelSetSync() "param" and
+    SYNCPROC "data" definitions) & flags.
+  }
+  BASS_SYNC_POS                     = 0;
+  {
+    Sync when a channel reaches a position.
+    param: position in bytes
+    data : not used
+  }
+  BASS_SYNC_END                     = 2;
+  {
+    Sync when a channel reaches the end.
+    param: not used
+    data : not used
+  }
+  BASS_SYNC_META                    = 4;
+  {
+    Sync when metadata is received in a stream.
+    param: not used
+    data : pointer to the metadata
+  }
+  BASS_SYNC_SLIDE                   = 5;
+  {
+    Sync when an attribute slide is completed.
+    param: not used
+    data : the type of slide completed (one of the BASS_SLIDE_xxx values)
+  }
+  BASS_SYNC_STALL                   = 6;
+  {
+    Sync when playback has stalled.
+    param: not used
+    data : 0=stalled, 1=resumed
+  }
+  BASS_SYNC_DOWNLOAD                = 7;
+  {
+    Sync when downloading of an internet (or "buffered" user file) stream has ended.
+    param: not used
+    data : not used
+  }
+  BASS_SYNC_FREE                    = 8;
+  {
+    Sync when a channel is freed.
+    param: not used
+    data : not used
+  }
+  BASS_SYNC_SETPOS                  = 11;
+  {
+    Sync when a channel's position is set.
+    param: not used
+    data : 0 = playback buffer not flushed, 1 = playback buffer flushed
+  }
+  BASS_SYNC_MUSICPOS                = 10;
+  {
+    Sync when a MOD music reaches an order:row position.
+    param: LOWORD=order (0=first, -1=all) HIWORD=row (0=first, -1=all)
+    data : LOWORD=order HIWORD=row
+  }
+  BASS_SYNC_MUSICINST               = 1;
+  {
+    Sync when an instrument (sample for the non-instrument based formats)
+    is played in a MOD music (not including retrigs).
+    param: LOWORD=instrument (1=first) HIWORD=note (0=c0...119=b9, -1=all)
+    data : LOWORD=note HIWORD=volume (0-64)
+  }
+  BASS_SYNC_MUSICFX                 = 3;
+  {
+    Sync when the "sync" effect (XM/MTM/MOD: E8x/Wxx, IT/S3M: S2x) is used.
+    param: 0:data=pos, 1:data="x" value
+    data : param=0: LOWORD=order HIWORD=row, param=1: "x" value
+  }
+  BASS_SYNC_MESSAGE                 = $20000000;
+  { FLAG: post a Windows message (instead of callback)
+    When using a window message "callback", the message to post is given in the "proc"
+    parameter of BASS_ChannelSetSync, and is posted to the window specified in the BASS_Init
+    call. The message parameters are: WPARAM = data, LPARAM = user.
+  }
+  BASS_SYNC_MIXTIME                 = $40000000;
+  { FLAG: sync at mixtime, else at playtime }
+  BASS_SYNC_ONETIME                 = $80000000;
+  { FLAG: sync only once, else continuously }
+
+  // BASS_ChannelIsActive return values
+  BASS_ACTIVE_STOPPED = 0;
+  BASS_ACTIVE_PLAYING = 1;
+  BASS_ACTIVE_STALLED = 2;
+  BASS_ACTIVE_PAUSED  = 3;
+
+  // BASS_ChannelIsSliding return flags
+  BASS_SLIDE_FREQ     = 1;
+  BASS_SLIDE_VOL      = 2;
+  BASS_SLIDE_PAN      = 4;
+
+  // BASS_ChannelGetData flags
+  BASS_DATA_AVAILABLE = 0;        // query how much data is buffered
+  BASS_DATA_FLOAT     = $40000000; // flag: return floating-point sample data
+  BASS_DATA_FFT512    = $80000000; // 512 sample FFT
+  BASS_DATA_FFT1024   = $80000001; // 1024 FFT
+  BASS_DATA_FFT2048   = $80000002; // 2048 FFT
+  BASS_DATA_FFT4096   = $80000003; // 4096 FFT
+  BASS_DATA_FFT8192   = $80000004; // 8192 FFT
+  BASS_DATA_FFT_INDIVIDUAL = $10; // FFT flag: FFT for each channel, else all combined
+  BASS_DATA_FFT_NOWINDOW = $20;   // FFT flag: no Hanning window
+
+  // BASS_ChannelGetTags types : what's returned
+  BASS_TAG_ID3        = 0; // ID3v1 tags : 128 byte block
+  BASS_TAG_ID3V2      = 1; // ID3v2 tags : variable length block
+  BASS_TAG_OGG        = 2; // OGG comments : array of null-terminated strings
+  BASS_TAG_HTTP       = 3; // HTTP headers : array of null-terminated strings
+  BASS_TAG_ICY        = 4; // ICY headers : array of null-terminated strings
+  BASS_TAG_META       = 5; // ICY metadata : null-terminated string
+  BASS_TAG_VENDOR     = 9; // OGG encoder : null-terminated string
+  BASS_TAG_LYRICS3    = 10; // Lyric3v2 tag : ASCII string
+  BASS_TAG_RIFF_INFO  = $100; // RIFF/WAVE tags : array of null-terminated ANSI strings
+  BASS_TAG_MUSIC_NAME = $10000;	// MOD music name : ANSI string
+  BASS_TAG_MUSIC_MESSAGE = $10001; // MOD message : ANSI string
+  BASS_TAG_MUSIC_INST = $10100;	// + instrument #, MOD instrument name : ANSI string
+  BASS_TAG_MUSIC_SAMPLE = $10300; // + sample #, MOD sample name : ANSI string
+
+  BASS_FX_CHORUS	  = 0;      // GUID_DSFX_STANDARD_CHORUS
+  BASS_FX_COMPRESSOR  = 1;      // GUID_DSFX_STANDARD_COMPRESSOR
+  BASS_FX_DISTORTION  = 2;      // GUID_DSFX_STANDARD_DISTORTION
+  BASS_FX_ECHO        = 3;      // GUID_DSFX_STANDARD_ECHO
+  BASS_FX_FLANGER     = 4;      // GUID_DSFX_STANDARD_FLANGER
+  BASS_FX_GARGLE      = 5;      // GUID_DSFX_STANDARD_GARGLE
+  BASS_FX_I3DL2REVERB = 6;      // GUID_DSFX_STANDARD_I3DL2REVERB
+  BASS_FX_PARAMEQ     = 7;      // GUID_DSFX_STANDARD_PARAMEQ
+  BASS_FX_REVERB      = 8;      // GUID_DSFX_WAVES_REVERB
+
+  BASS_FX_PHASE_NEG_180 = 0;
+  BASS_FX_PHASE_NEG_90  = 1;
+  BASS_FX_PHASE_ZERO    = 2;
+  BASS_FX_PHASE_90      = 3;
+  BASS_FX_PHASE_180     = 4;
+
+  // BASS_RecordSetInput flags
+  BASS_INPUT_OFF    = $10000;
+  BASS_INPUT_ON     = $20000;
+  BASS_INPUT_LEVEL  = $40000;
+
+  BASS_INPUT_TYPE_MASK    = $ff000000;
+  BASS_INPUT_TYPE_UNDEF   = $00000000;
+  BASS_INPUT_TYPE_DIGITAL = $01000000;
+  BASS_INPUT_TYPE_LINE    = $02000000;
+  BASS_INPUT_TYPE_MIC     = $03000000;
+  BASS_INPUT_TYPE_SYNTH   = $04000000;
+  BASS_INPUT_TYPE_CD      = $05000000;
+  BASS_INPUT_TYPE_PHONE   = $06000000;
+  BASS_INPUT_TYPE_SPEAKER = $07000000;
+  BASS_INPUT_TYPE_WAVE    = $08000000;
+  BASS_INPUT_TYPE_AUX     = $09000000;
+  BASS_INPUT_TYPE_ANALOG  = $0a000000;
+
+  // BASS_SetNetConfig flags
+  BASS_NET_TIMEOUT  = 0;
+  BASS_NET_BUFFER   = 1;
+
+  // BASS_StreamGetFilePosition modes
+  BASS_FILEPOS_CURRENT    = 0;
+  BASS_FILEPOS_DECODE     = BASS_FILEPOS_CURRENT;
+  BASS_FILEPOS_DOWNLOAD   = 1;
+  BASS_FILEPOS_END        = 2;
+  BASS_FILEPOS_START      = 3;
+  BASS_FILEPOS_CONNECTED  = 4;
+
+  // STREAMFILEPROC actions
+  BASS_FILE_CLOSE   = 0;
+  BASS_FILE_READ    = 1;
+  BASS_FILE_LEN     = 3;
+  BASS_FILE_SEEK    = 4;
+
+  BASS_STREAMPROC_END = $80000000; // end of user stream flag
+
+  // BASS_MusicSet/GetAttribute options
+  BASS_MUSIC_ATTRIB_AMPLIFY    = 0;
+  BASS_MUSIC_ATTRIB_PANSEP     = 1;
+  BASS_MUSIC_ATTRIB_PSCALER    = 2;
+  BASS_MUSIC_ATTRIB_BPM        = 3;
+  BASS_MUSIC_ATTRIB_SPEED      = 4;
+  BASS_MUSIC_ATTRIB_VOL_GLOBAL = 5;
+  BASS_MUSIC_ATTRIB_VOL_CHAN   = $100; // + channel #
+  BASS_MUSIC_ATTRIB_VOL_INST   = $200; // + instrument #
+
+  // BASS_Set/GetConfig options
+  BASS_CONFIG_BUFFER        = 0;
+  BASS_CONFIG_UPDATEPERIOD  = 1;
+  BASS_CONFIG_MAXVOL        = 3;
+  BASS_CONFIG_GVOL_SAMPLE   = 4;
+  BASS_CONFIG_GVOL_STREAM   = 5;
+  BASS_CONFIG_GVOL_MUSIC    = 6;
+  BASS_CONFIG_CURVE_VOL     = 7;
+  BASS_CONFIG_CURVE_PAN     = 8;
+  BASS_CONFIG_FLOATDSP      = 9;
+  BASS_CONFIG_3DALGORITHM   = 10;
+  BASS_CONFIG_NET_TIMEOUT   = 11;
+  BASS_CONFIG_NET_BUFFER    = 12;
+  BASS_CONFIG_PAUSE_NOPLAY  = 13;
+  BASS_CONFIG_NET_PREBUF    = 15;
+  BASS_CONFIG_NET_AGENT     = 16;
+  BASS_CONFIG_NET_PROXY     = 17;
+  BASS_CONFIG_NET_PASSIVE   = 18;
+  BASS_CONFIG_REC_BUFFER    = 19;
+  BASS_CONFIG_NET_PLAYLIST  = 21;
+  BASS_CONFIG_MUSIC_VIRTUAL = 22;
+
+type
+  DWORD = cardinal;
+  BOOL = LongBool;
+  FLOAT = Single;
+  QWORD = int64;        // 64-bit (replace "int64" with "comp" if using Delphi 3)
+
+  HMUSIC = DWORD;       // MOD music handle
+  HSAMPLE = DWORD;      // sample handle
+  HCHANNEL = DWORD;     // playing sample's channel handle
+  HSTREAM = DWORD;      // sample stream handle
+  HRECORD = DWORD;      // recording handle
+  HSYNC = DWORD;        // synchronizer handle
+  HDSP = DWORD;         // DSP handle
+  HFX = DWORD;          // DX8 effect handle
+  HPLUGIN = DWORD;      // Plugin handle
+
+  BASS_INFO = record
+    flags: DWORD;       // device capabilities (DSCAPS_xxx flags)
+    hwsize: DWORD;      // size of total device hardware memory
+    hwfree: DWORD;      // size of free device hardware memory
+    freesam: DWORD;     // number of free sample slots in the hardware
+    free3d: DWORD;      // number of free 3D sample slots in the hardware
+    minrate: DWORD;     // min sample rate supported by the hardware
+    maxrate: DWORD;     // max sample rate supported by the hardware
+    eax: BOOL;          // device supports EAX? (always FALSE if BASS_DEVICE_3D was not used)
+    minbuf: DWORD;      // recommended minimum buffer length in ms (requires BASS_DEVICE_LATENCY)
+    dsver: DWORD;       // DirectSound version
+    latency: DWORD;     // delay (in ms) before start of playback (requires BASS_DEVICE_LATENCY)
+    initflags: DWORD;   // "flags" parameter of BASS_Init call
+    speakers: DWORD;    // number of speakers available
+    driver: PChar;      // driver
+    freq: DWORD;        // current output rate (OSX only)
+  end;
+
+  BASS_RECORDINFO = record
+    flags: DWORD;       // device capabilities (DSCCAPS_xxx flags)
+    formats: DWORD;     // supported standard formats (WAVE_FORMAT_xxx flags)
+    inputs: DWORD;      // number of inputs
+    singlein: BOOL;     // only 1 input can be set at a time
+    driver: PChar;      // driver
+    freq: DWORD;        // current input rate (OSX only)
+  end;
+
+  BASS_CHANNELINFO = record
+	freq: DWORD;        // default playback rate
+	chans: DWORD;       // channels
+	flags: DWORD;       // BASS_SAMPLE/STREAM/MUSIC/SPEAKER flags
+	ctype: DWORD;       // type of channel
+	origres: DWORD;     // original resolution
+	plugin: HPLUGIN;    // plugin
+  end;
+
+  BASS_PLUGINFORM = record
+	ctype: DWORD;       // channel type
+	name: PChar;        // format description
+	exts: PChar;	    // file extension filter ( *.ext1;*.ext2;etc...)
+  end;
+  PBASS_PLUGINFORMS = ^TBASS_PLUGINFORMS;
+  TBASS_PLUGINFORMS = array[0..maxInt div sizeOf(BASS_PLUGINFORM) - 1] of BASS_PLUGINFORM;
+
+  BASS_PLUGININFO = record
+	version: DWORD;             // version (same form as BASS_GetVersion)
+	formatc: DWORD;             // number of formats
+	formats: PBASS_PLUGINFORMS; // the array of formats
+  end;
+  PBASS_PLUGININFO = ^BASS_PLUGININFO;
+
+  // Sample info structure
+  BASS_SAMPLE = record
+    freq: DWORD;        // default playback rate
+    volume: DWORD;      // default volume (0-100)
+    pan: Integer;       // default pan (-100=left, 0=middle, 100=right)
+    flags: DWORD;       // BASS_SAMPLE_xxx flags
+    length: DWORD;      // length (in samples, not bytes)
+    max: DWORD;         // maximum simultaneous playbacks
+    origres: DWORD;     // original resolution
+    chans: DWORD;       // number of channels
+    mingap: DWORD;      // minimum gap (ms) between creating channels
+    {
+      The following are the samples default 3D attributes
+      (if the sample is 3D, BASS_SAMPLE_3D is in flags)
+      see BASS_ChannelSet3DAttributes
+    }
+    mode3d: DWORD;      // BASS_3DMODE_xxx mode
+    mindist: FLOAT;     // minimum distance
+    maxdist: FLOAT;     // maximum distance
+    iangle: DWORD;      // angle of inside projection cone
+    oangle: DWORD;      // angle of outside projection cone
+    outvol: DWORD;      // delta-volume outside the projection cone
+    {
+      The following are the defaults used if the sample uses the DirectX 7
+      voice allocation/management features.
+    }
+    vam: DWORD;         // voice allocation/management flags (BASS_VAM_xxx)
+    priority: DWORD;    // priority (0=lowest, $ffffffff=highest)
+  end;
+
+  // 3D vector (for 3D positions/velocities/orientations)
+  BASS_3DVECTOR = record
+    x: FLOAT;           // +=right, -=left
+    y: FLOAT;           // +=up, -=down
+    z: FLOAT;           // +=front, -=behind
+  end;
+
+  BASS_FXCHORUS = record
+    fWetDryMix: FLOAT;
+    fDepth: FLOAT;
+    fFeedback: FLOAT;
+    fFrequency: FLOAT;
+    lWaveform: DWORD;   // 0=triangle, 1=sine
+    fDelay: FLOAT;
+    lPhase: DWORD;      // BASS_FX_PHASE_xxx
+  end;
+
+  BASS_FXCOMPRESSOR = record
+    fGain: FLOAT;
+    fAttack: FLOAT;
+    fRelease: FLOAT;
+    fThreshold: FLOAT;
+    fRatio: FLOAT;
+    fPredelay: FLOAT;
+  end;
+
+  BASS_FXDISTORTION = record
+    fGain: FLOAT;
+    fEdge: FLOAT;
+    fPostEQCenterFrequency: FLOAT;
+    fPostEQBandwidth: FLOAT;
+    fPreLowpassCutoff: FLOAT;
+  end;
+
+  BASS_FXECHO = record
+    fWetDryMix: FLOAT;
+    fFeedback: FLOAT;
+    fLeftDelay: FLOAT;
+    fRightDelay: FLOAT;
+    lPanDelay: BOOL;
+  end;
+
+  BASS_FXFLANGER = record
+    fWetDryMix: FLOAT;
+    fDepth: FLOAT;
+    fFeedback: FLOAT;
+    fFrequency: FLOAT;
+    lWaveform: DWORD;   // 0=triangle, 1=sine
+    fDelay: FLOAT;
+    lPhase: DWORD;      // BASS_FX_PHASE_xxx
+  end;
+
+  BASS_FXGARGLE = record
+    dwRateHz: DWORD;               // Rate of modulation in hz
+    dwWaveShape: DWORD;            // 0=triangle, 1=square
+  end;
+
+  BASS_FXI3DL2REVERB = record
+    lRoom: Longint;                // [-10000, 0]      default: -1000 mB
+    lRoomHF: Longint;              // [-10000, 0]      default: 0 mB
+    flRoomRolloffFactor: FLOAT;    // [0.0, 10.0]      default: 0.0
+    flDecayTime: FLOAT;            // [0.1, 20.0]      default: 1.49s
+    flDecayHFRatio: FLOAT;         // [0.1, 2.0]       default: 0.83
+    lReflections: Longint;         // [-10000, 1000]   default: -2602 mB
+    flReflectionsDelay: FLOAT;     // [0.0, 0.3]       default: 0.007 s
+    lReverb: Longint;              // [-10000, 2000]   default: 200 mB
+    flReverbDelay: FLOAT;          // [0.0, 0.1]       default: 0.011 s
+    flDiffusion: FLOAT;            // [0.0, 100.0]     default: 100.0 %
+    flDensity: FLOAT;              // [0.0, 100.0]     default: 100.0 %
+    flHFReference: FLOAT;          // [20.0, 20000.0]  default: 5000.0 Hz
+  end;
+
+  BASS_FXPARAMEQ = record
+    fCenter: FLOAT;
+    fBandwidth: FLOAT;
+    fGain: FLOAT;
+  end;
+
+  BASS_FXREVERB = record
+    fInGain: FLOAT;                // [-96.0,0.0]            default: 0.0 dB
+    fReverbMix: FLOAT;             // [-96.0,0.0]            default: 0.0 db
+    fReverbTime: FLOAT;            // [0.001,3000.0]         default: 1000.0 ms
+    fHighFreqRTRatio: FLOAT;       // [0.001,0.999]          default: 0.001
+  end;
+
+  // callback function types
+  STREAMPROC = function(handle: HSTREAM; buffer: Pointer; length: DWORD; user: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  {
+    User stream callback function. NOTE: A stream function should obviously be as
+    quick as possible, other streams (and MOD musics) can't be mixed until
+    it's finished.
+    handle : The stream that needs writing
+    buffer : Buffer to write the samples in
+    length : Number of bytes to write
+    user   : The 'user' parameter value given when calling BASS_StreamCreate
+    RETURN : Number of bytes written. Set the BASS_STREAMPROC_END flag to end
+             the stream.
+  }
+
+  STREAMFILEPROC = function(action, param1, param2, user: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  {  
+    User file stream callback function.
+    action : The action to perform, one of BASS_FILE_xxx values.
+    param1 : Depends on "action"
+    param2 : Depends on "action"
+    user   : The 'user' parameter value given when calling BASS_StreamCreate
+    RETURN : Depends on "action"
+  }
+
+  DOWNLOADPROC = procedure(buffer: Pointer; length: DWORD; user: DWORD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  {
+    Internet stream download callback function.
+    buffer : Buffer containing the downloaded data... NULL=end of download
+    length : Number of bytes in the buffer
+    user   : The 'user' parameter value given when calling BASS_StreamCreateURL
+  }
+
+  SYNCPROC = procedure(handle: HSYNC; channel, data: DWORD; user: DWORD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  {
+    Sync callback function. NOTE: a sync callback function should be very
+    quick as other syncs cannot be processed until it has finished. If the
+    sync is a "mixtime" sync, then other streams and MOD musics can not be
+    mixed until it's finished either.
+    handle : The sync that has occured
+    channel: Channel that the sync occured in
+    data   : Additional data associated with the sync's occurance
+    user   : The 'user' parameter given when calling BASS_ChannelSetSync
+  }
+
+  DSPPROC = procedure(handle: HDSP; channel: DWORD; buffer: Pointer; length: DWORD; user: DWORD); {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  {
+    DSP callback function. NOTE: A DSP function should obviously be as quick
+    as possible... other DSP functions, streams and MOD musics can not be
+    processed until it's finished.
+    handle : The DSP handle
+    channel: Channel that the DSP is being applied to
+    buffer : Buffer to apply the DSP to
+    length : Number of bytes in the buffer
+    user   : The 'user' parameter given when calling BASS_ChannelSetDSP
+  }
+
+  RECORDPROC = function(handle: HRECORD; const buffer: Pointer; length: DWORD; user: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}
+  {
+    Recording callback function.
+    handle : The recording handle
+    buffer : Buffer containing the recorded sample data
+    length : Number of bytes
+    user   : The 'user' parameter value given when calling BASS_RecordStart
+    RETURN : TRUE = continue recording, FALSE = stop
+  }
+
+
+// Functions
+const
+
+{$IFDEF MSWINDOWS}
+  bassdll = 'bass.dll';
+{$ENDIF}
+{$IFDEF DARWIN}
+  bassdll = 'libbass.dylib';
+{$ENDIF}
+
+function BASS_SetConfig(option, value: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetConfig(option: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetVersion: DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetDeviceDescription(device: DWORD): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ErrorGetCode: Integer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Init(device: Integer; freq, flags: DWORD; win: HWND; clsid: PGUID): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SetDevice(device: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetDevice: DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Free: BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetDSoundObject(obj: DWORD): Pointer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetInfo(var info: BASS_INFO): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Update: BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetCPU: FLOAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Start: BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Stop: BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Pause: BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SetVolume(volume: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetVolume: Integer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+
+function BASS_PluginLoad(filename: PChar; flags: DWORD): HPLUGIN; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_PluginFree(handle: HPLUGIN): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_PluginGetInfo(handle: HPLUGIN): PBASS_PLUGININFO; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+
+function BASS_Set3DFactors(distf, rollf, doppf: FLOAT): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Get3DFactors(var distf, rollf, doppf: FLOAT): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Set3DPosition(var pos, vel, front, top: BASS_3DVECTOR): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_Get3DPosition(var pos, vel, front, top: BASS_3DVECTOR): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+procedure BASS_Apply3D; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+{$IFDEF MSWINDOWS}
+function BASS_SetEAXParameters(env: Integer; vol, decay, damp: FLOAT): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_GetEAXParameters(var env: DWORD; var vol, decay, damp: FLOAT): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+{$ENDIF}
+
+function BASS_MusicLoad(mem: BOOL; f: Pointer; offset, length, flags, freq: DWORD): HMUSIC; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_MusicFree(handle: HMUSIC): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_MusicSetAttribute(handle: HMUSIC; attrib,value: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_MusicGetAttribute(handle: HMUSIC; attrib: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_MusicGetOrders(handle: HMUSIC): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_MusicGetOrderPosition(handle: HMUSIC): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+
+function BASS_SampleLoad(mem: BOOL; f: Pointer; offset, length, max, flags: DWORD): HSAMPLE; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleCreate(length, freq, chans, max, flags: DWORD): Pointer; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleCreateDone: HSAMPLE; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleFree(handle: HSAMPLE): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleGetInfo(handle: HSAMPLE; var info: BASS_SAMPLE): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleSetInfo(handle: HSAMPLE; var info: BASS_SAMPLE): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleGetChannel(handle: HSAMPLE; onlynew: BOOL): HCHANNEL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleGetChannels(handle: HSAMPLE; channels: Pointer): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_SampleStop(handle: HSAMPLE): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+
+function BASS_StreamCreate(freq, chans, flags: DWORD; proc: Pointer; user: DWORD): HSTREAM; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_StreamCreateFile(mem: BOOL; f: Pointer; offset, length, flags: DWORD): HSTREAM; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_StreamCreateURL(url: PChar; offset: DWORD; flags: DWORD; proc: DOWNLOADPROC; user: DWORD):HSTREAM; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_StreamCreateFileUser(buffered: BOOL; flags: DWORD; proc: STREAMFILEPROC; user: DWORD): HSTREAM; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_StreamFree(handle: HSTREAM): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_StreamGetFilePosition(handle:HSTREAM; mode:DWORD) : DWORD;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_StreamGetLength(handle: DWORD): QWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external  bassdll name 'BASS_ChannelGetLength';
+
+function BASS_RecordGetDeviceDescription(devnum: DWORD):PChar;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_RecordInit(device: Integer):BOOL;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_RecordSetDevice(device: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_RecordGetDevice: DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_RecordFree:BOOL;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_RecordGetInfo(var info:BASS_RECORDINFO):BOOL;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_RecordGetInputName(input:Integer):PChar;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_RecordSetInput(input:Integer; setting:DWORD):BOOL;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_RecordGetInput(input:Integer):DWORD;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_RecordStart(freq,chans,flags:DWORD; proc:RECORDPROC; user:DWORD):HRECORD;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+
+function BASS_ChannelBytes2Seconds(handle: DWORD; pos: QWORD): FLOAT; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_ChannelSeconds2Bytes(handle: DWORD; pos: FLOAT): QWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_ChannelGetDevice(handle: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSetDevice(handle, device: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelIsActive(handle: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_ChannelGetInfo(handle: DWORD; var info:BASS_CHANNELINFO):BOOL;{$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_ChannelGetTags(handle: HSTREAM; tags : DWORD): PChar; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSetFlags(handle, flags: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelPreBuf(handle, length: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelPlay(handle: DWORD; restart: BOOL): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelStop(handle: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelPause(handle: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSetAttributes(handle: DWORD; freq, volume, pan: Integer): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGetAttributes(handle: DWORD; var freq, volume: DWORD; var pan: Integer): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSlideAttributes(handle: DWORD; freq, volume, pan: Integer; time: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelIsSliding(handle: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF}external bassdll;
+function BASS_ChannelSet3DAttributes(handle: DWORD; mode: Integer; min, max: FLOAT; iangle, oangle, outvol: Integer): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGet3DAttributes(handle: DWORD; var mode: DWORD; var min, max: FLOAT; var iangle, oangle, outvol: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSet3DPosition(handle: DWORD; var pos, orient, vel: BASS_3DVECTOR): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGet3DPosition(handle: DWORD; var pos, orient, vel: BASS_3DVECTOR): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGetLength(handle: DWORD): QWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSetPosition(handle: DWORD; pos: QWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGetPosition(handle: DWORD): QWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGetLevel(handle: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGetData(handle: DWORD; buffer: Pointer; length: DWORD): DWORD; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSetSync(handle: DWORD; stype: DWORD; param: QWORD; proc: SYNCPROC; user: DWORD): HSYNC; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelRemoveSync(handle: DWORD; sync: HSYNC): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSetDSP(handle: DWORD; proc: DSPPROC; user: DWORD; priority: Integer): HDSP; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelRemoveDSP(handle: DWORD; dsp: HDSP): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+{$IFDEF MSWINDOWS}
+function BASS_ChannelSetEAXMix(handle: DWORD; mix: FLOAT): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelGetEAXMix(handle: DWORD; var mix: FLOAT): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+{$ENDIF}
+function BASS_ChannelSetLink(handle, chan: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelRemoveLink(handle, chan: DWORD): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelSetFX(handle, etype: DWORD; priority: Integer): HFX; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_ChannelRemoveFX(handle: DWORD; fx: HFX): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+
+function BASS_FXSetParameters(handle: HFX; par: Pointer): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_FXGetParameters(handle: HFX; par: Pointer): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+function BASS_FXReset(handle: HFX): BOOL; {$IFDEF DLL_STDCALL} stdcall; {$ENDIF} {$IFDEF DLL_CDECL} cdecl; {$ENDIF} external bassdll;
+
+
+function BASS_SPEAKER_N(n: DWORD): DWORD;
+function MAKEMUSICPOS(order,row: DWORD): DWORD;
+{$IFDEF MSWINDOWS}
+function BASS_SetEAXPreset(env: Integer): BOOL;
+{
+  This function is defined in the implementation part of this unit.
+  It is not part of BASS.DLL but an extra function which makes it easier
+  to set the predefined EAX environments.
+  env    : a EAX_ENVIRONMENT_xxx constant
+}
+{$ENDIF}
+
+implementation
+
+function BASS_SPEAKER_N(n: DWORD): DWORD;
+begin
+  Result := n shl 24;
+end;
+
+function MAKEMUSICPOS(order,row: DWORD): DWORD;
+begin
+  Result := $80000000 or DWORD(MAKELONG(order,row));
+end;
+
+{$IFDEF MSWINDOWS}
+function BASS_SetEAXPreset(env: Integer): BOOL;
+begin
+  case (env) of
+    EAX_ENVIRONMENT_GENERIC:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_GENERIC, 0.5, 1.493, 0.5);
+    EAX_ENVIRONMENT_PADDEDCELL:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PADDEDCELL, 0.25, 0.1, 0);
+    EAX_ENVIRONMENT_ROOM:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_ROOM, 0.417, 0.4, 0.666);
+    EAX_ENVIRONMENT_BATHROOM:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_BATHROOM, 0.653, 1.499, 0.166);
+    EAX_ENVIRONMENT_LIVINGROOM:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_LIVINGROOM, 0.208, 0.478, 0);
+    EAX_ENVIRONMENT_STONEROOM:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_STONEROOM, 0.5, 2.309, 0.888);
+    EAX_ENVIRONMENT_AUDITORIUM:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_AUDITORIUM, 0.403, 4.279, 0.5);
+    EAX_ENVIRONMENT_CONCERTHALL:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CONCERTHALL, 0.5, 3.961, 0.5);
+    EAX_ENVIRONMENT_CAVE:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CAVE, 0.5, 2.886, 1.304);
+    EAX_ENVIRONMENT_ARENA:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_ARENA, 0.361, 7.284, 0.332);
+    EAX_ENVIRONMENT_HANGAR:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_HANGAR, 0.5, 10.0, 0.3);
+    EAX_ENVIRONMENT_CARPETEDHALLWAY:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CARPETEDHALLWAY, 0.153, 0.259, 2.0);
+    EAX_ENVIRONMENT_HALLWAY:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_HALLWAY, 0.361, 1.493, 0);
+    EAX_ENVIRONMENT_STONECORRIDOR:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_STONECORRIDOR, 0.444, 2.697, 0.638);
+    EAX_ENVIRONMENT_ALLEY:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_ALLEY, 0.25, 1.752, 0.776);
+    EAX_ENVIRONMENT_FOREST:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_FOREST, 0.111, 3.145, 0.472);
+    EAX_ENVIRONMENT_CITY:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_CITY, 0.111, 2.767, 0.224);
+    EAX_ENVIRONMENT_MOUNTAINS:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_MOUNTAINS, 0.194, 7.841, 0.472);
+    EAX_ENVIRONMENT_QUARRY:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_QUARRY, 1, 1.499, 0.5);
+    EAX_ENVIRONMENT_PLAIN:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PLAIN, 0.097, 2.767, 0.224);
+    EAX_ENVIRONMENT_PARKINGLOT:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PARKINGLOT, 0.208, 1.652, 1.5);
+    EAX_ENVIRONMENT_SEWERPIPE:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_SEWERPIPE, 0.652, 2.886, 0.25);
+    EAX_ENVIRONMENT_UNDERWATER:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_UNDERWATER, 1, 1.499, 0);
+    EAX_ENVIRONMENT_DRUGGED:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_DRUGGED, 0.875, 8.392, 1.388);
+    EAX_ENVIRONMENT_DIZZY:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_DIZZY, 0.139, 17.234, 0.666);
+    EAX_ENVIRONMENT_PSYCHOTIC:
+      Result := BASS_SetEAXParameters(EAX_ENVIRONMENT_PSYCHOTIC, 0.486, 7.563, 0.806);
+    else
+      Result := FALSE;
+  end;
+end;
+{$ENDIF}
+
+end.
+// END OF FILE /////////////////////////////////////////////////////////////////
+