* added SDL support

diff --git a/glBitmap.pas b/glBitmap.pas
index d39e7c5..19dba74 100644 (file)
--- a/glBitmap.pas
+++ b/glBitmap.pas
@@ -227,10 +227,10 @@ unit glBitmap;
 
 // activate to enable build-in OpenGL support with dynamically linked methods
 // use dglOpenGL.pas if not enabled
-{$DEFINE GLB_NATIVE_OGL_DYNAMIC}
+{.$DEFINE GLB_NATIVE_OGL_DYNAMIC}
 
 // activate to enable the support for SDL_surfaces
-{.$DEFINE GLB_SDL}
+{$DEFINE GLB_SDL}
 
 // activate  to enable the support for TBitmap from Delphi (not lazarus)
 {.$DEFINE GLB_DELPHI}
@@ -239,7 +239,7 @@ unit glBitmap;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // activate to enable the support of SDL_image to load files. (READ ONLY)
 // If you enable SDL_image all other libraries will be ignored!
-{.$DEFINE GLB_SDL_IMAGE}
+{$DEFINE GLB_SDL_IMAGE}
 
 // activate to enable png support with the unit pngimage. You can download it from http://pngdelphi.sourceforge.net/
 // if you enable pngimage the libPNG will be ignored
@@ -681,7 +681,7 @@ type
   EglBitmapException               = class(Exception);
   EglBitmapSizeToLargeException    = class(EglBitmapException);
   EglBitmapNonPowerOfTwoException  = class(EglBitmapException);
-  EglBitmapUnsupportedFormatFormat = class(EglBitmapException);
+  EglBitmapUnsupportedFormat       = class(EglBitmapException);
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
   TglBitmapFormat = (
@@ -977,14 +977,12 @@ type
     constructor Create(const aInstance: Cardinal; const aResourceID: Integer; const aResType: PChar); overload;
     {$ENDIF}
   private
-    {$IFDEF GLB_SUPPORT_PNG_READ}
-    function LoadPNG(const aStream: TStream): Boolean; virtual;
-    procedure SavePNG(const aStream: TStream); virtual;
-    {$ENDIF}
-    {$IFDEF GLB_SUPPORT_JPEG_READ}
-    function LoadJPEG(const aStream: TStream): Boolean; virtual;
-    procedure SaveJPEG(const aStream: TStream); virtual;
-    {$ENDIF}
+    {$IFDEF GLB_SUPPORT_PNG_READ}  function  LoadPNG(const aStream: TStream): Boolean; virtual; {$ENDIF}
+    {$ifdef GLB_SUPPORT_PNG_WRITE} procedure SavePNG(const aStream: TStream); virtual; {$ENDIF}
+
+    {$IFDEF GLB_SUPPORT_JPEG_READ}  function  LoadJPEG(const aStream: TStream): Boolean; virtual; {$ENDIF}
+    {$IFDEF GLB_SUPPORT_JPEG_WRITE} procedure SaveJPEG(const aStream: TStream); virtual; {$ENDIF}
+
     function LoadBMP(const aStream: TStream): Boolean; virtual;
     procedure SaveBMP(const aStream: TStream); virtual;
 
@@ -1140,10 +1138,10 @@ type
 
   TFormatDescriptor = class(TObject)
   private
-    function GetRedMask: UInt64;
-    function GetGreenMask: UInt64;
-    function GetBlueMask: UInt64;
-    function GetAlphaMask: UInt64;
+    function GetRedMask: QWord;
+    function GetGreenMask: QWord;
+    function GetBlueMask: QWord;
+    function GetAlphaMask: QWord;
   protected
     fFormat: TglBitmapFormat;
     fWithAlpha: TglBitmapFormat;
@@ -1177,10 +1175,10 @@ type
     property Range: TglBitmapColorRec read fRange;
     property Shift: TShiftRec         read fShift;
 
-    property RedMask:   UInt64 read GetRedMask;
-    property GreenMask: UInt64 read GetGreenMask;
-    property BlueMask:  UInt64 read GetBlueMask;
-    property AlphaMask: UInt64 read GetAlphaMask;
+    property RedMask:   QWord read GetRedMask;
+    property GreenMask: QWord read GetGreenMask;
+    property BlueMask:  QWord read GetBlueMask;
+    property AlphaMask: QWord read GetAlphaMask;
 
     procedure Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer); virtual; abstract;
     procedure Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer); virtual; abstract;
@@ -1193,7 +1191,7 @@ type
 
     function IsEmpty:  Boolean; virtual;
     function HasAlpha: Boolean; virtual;
-    function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: UInt64): Boolean; virtual;
+    function MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean; virtual;
 
     procedure PreparePixel(out aPixel: TglBitmapPixelData); virtual;
 
@@ -1532,17 +1530,17 @@ type
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   TbmpBitfieldFormat = class(TFormatDescriptor)
   private
-    procedure SetRedMask  (const aValue: UInt64);
-    procedure SetGreenMask(const aValue: UInt64);
-    procedure SetBlueMask (const aValue: UInt64);
-    procedure SetAlphaMask(const aValue: UInt64);
+    procedure SetRedMask  (const aValue: QWord);
+    procedure SetGreenMask(const aValue: QWord);
+    procedure SetBlueMask (const aValue: QWord);
+    procedure SetAlphaMask(const aValue: QWord);
 
-    procedure Update(aMask: UInt64; out aRange: Cardinal; out aShift: Byte);
+    procedure Update(aMask: QWord; out aRange: Cardinal; out aShift: Byte);
   public
-    property RedMask:   UInt64 read GetRedMask   write SetRedMask;
-    property GreenMask: UInt64 read GetGreenMask write SetGreenMask;
-    property BlueMask:  UInt64 read GetBlueMask  write SetBlueMask;
-    property AlphaMask: UInt64 read GetAlphaMask write SetAlphaMask;
+    property RedMask:   QWord read GetRedMask   write SetRedMask;
+    property GreenMask: QWord read GetGreenMask write SetGreenMask;
+    property BlueMask:  QWord read GetBlueMask  write SetBlueMask;
+    property AlphaMask: QWord read GetAlphaMask write SetAlphaMask;
 
     property PixelSize: Single read fPixelSize write fPixelSize;
 
@@ -1803,7 +1801,7 @@ begin
 end;
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function GetTopMostBit(aBitSet: UInt64): Integer;
+function GetTopMostBit(aBitSet: QWord): Integer;
 begin
   result := 0;
   while aBitSet > 0 do begin
@@ -1813,7 +1811,7 @@ begin
 end;
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function CountSetBits(aBitSet: UInt64): Integer;
+function CountSetBits(aBitSet: QWord): Integer;
 begin
   result := 0;
   while aBitSet > 0 do begin
@@ -2126,8 +2124,10 @@ end;
 {$ENDIF}
 *)
 
-(* TODO GLB_SDL_IMAGE
 {$IFDEF GLB_SDL_IMAGE}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// SDL Image Helper /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function glBitmapRWseek(context: PSDL_RWops; offset: Integer; whence: Integer): Integer; cdecl;
 begin
   result := TStream(context^.unknown.data1).Seek(offset, whence);
@@ -2162,7 +2162,6 @@ begin
   result^.unknown.data1 := Stream;
 end;
 {$ENDIF}
-*)
 
 (* TODO LoadFuncs
 function LoadTexture(Filename: String; var Texture: Cardinal{$IFDEF GLB_DELPHI}; LoadFromRes : Boolean; Instance: Cardinal{$ENDIF}): Boolean;
@@ -2366,25 +2365,25 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TglBitmapFormatDescriptor///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetRedMask: UInt64;
+function TFormatDescriptor.GetRedMask: QWord;
 begin
   result := fRange.r shl fShift.r;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetGreenMask: UInt64;
+function TFormatDescriptor.GetGreenMask: QWord;
 begin
   result := fRange.g shl fShift.g;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetBlueMask: UInt64;
+function TFormatDescriptor.GetBlueMask: QWord;
 begin
   result := fRange.b shl fShift.b;
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.GetAlphaMask: UInt64;
+function TFormatDescriptor.GetAlphaMask: QWord;
 begin
   result := fRange.a shl fShift.a;
 end;
@@ -2447,7 +2446,7 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: UInt64): Boolean;
+function TFormatDescriptor.MaskMatch(const aRedMask, aGreenMask, aBlueMask, aAlphaMask: QWord): Boolean;
 begin
   result := false;
 
@@ -3781,31 +3780,31 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //TBitfieldFormat/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetRedMask(const aValue: UInt64);
+procedure TbmpBitfieldFormat.SetRedMask(const aValue: QWord);
 begin
   Update(aValue, fRange.r, fShift.r);
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetGreenMask(const aValue: UInt64);
+procedure TbmpBitfieldFormat.SetGreenMask(const aValue: QWord);
 begin
   Update(aValue, fRange.g, fShift.g);
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetBlueMask(const aValue: UInt64);
+procedure TbmpBitfieldFormat.SetBlueMask(const aValue: QWord);
 begin
   Update(aValue, fRange.b, fShift.b);
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: UInt64);
+procedure TbmpBitfieldFormat.SetAlphaMask(const aValue: QWord);
 begin
   Update(aValue, fRange.a, fShift.a);
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TbmpBitfieldFormat.Update(aMask: UInt64; out aRange: Cardinal; out
+procedure TbmpBitfieldFormat.Update(aMask: QWord; out aRange: Cardinal; out
   aShift: Byte);
 begin
   aShift := 0;
@@ -3829,10 +3828,8 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TbmpBitfieldFormat.Map(const aPixel: TglBitmapPixelData; var aData: PByte; var aMapData: Pointer);
 var
-  data: UInt64;
+  data: QWord;
   s: Integer;
-type
-  PUInt64 = ^UInt64;
 begin
   data :=
     ((aPixel.Data.r and fRange.r) shl fShift.r) or
@@ -3844,7 +3841,7 @@ begin
     1:           aData^  := data;
     2:     PWord(aData)^ := data;
     4: PCardinal(aData)^ := data;
-    8:   PUInt64(aData)^ := data;
+    8:    PQWord(aData)^ := data;
   else
     raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
   end;
@@ -3854,17 +3851,15 @@ end;
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TbmpBitfieldFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
 var
-  data: UInt64;
+  data: QWord;
   s, i: Integer;
-type
-  PUInt64 = ^UInt64;
 begin
   s := Round(fPixelSize);
   case s of
     1: data :=           aData^;
     2: data :=     PWord(aData)^;
     4: data := PCardinal(aData)^;
-    8: data :=   PUInt64(aData)^;
+    8: data :=    PQWord(aData)^;
   else
     raise EglBitmapException.CreateFmt('invalid pixel size: %.1f', [fPixelSize]);
   end;
@@ -3956,10 +3951,8 @@ end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 procedure TbmpColorTableFormat.Unmap(var aData: PByte; out aPixel: TglBitmapPixelData; var aMapData: Pointer);
-type
-  PUInt64 = ^UInt64;
 var
-  idx: UInt64;
+  idx: QWord;
   s: Integer;
   bits: Byte;
   f: Single;
@@ -3972,7 +3965,7 @@ begin
     1: idx :=           aData^;
     2: idx :=     PWord(aData)^;
     4: idx := PCardinal(aData)^;
-    8: idx :=   PUInt64(aData)^;
+    8: idx :=    PQWord(aData)^;
   else
     raise EglBitmapException.CreateFmt('invalid pixel size: %.3f', [fPixelSize]);
   end;
@@ -4227,7 +4220,7 @@ begin
   if fFormat = aValue then
     exit;
   if TFormatDescriptor.Get(Format).PixelSize <> TFormatDescriptor.Get(aValue).PixelSize then
-    raise EglBitmapUnsupportedFormatFormat.Create('SetInternalFormat - ' + UNSUPPORTED_FORMAT);
+    raise EglBitmapUnsupportedFormat.Create('SetFormat');
   SetDataPointer(Data, aValue, Width, Height);
 end;
 
@@ -4603,42 +4596,37 @@ var
   Row, RowSize: Integer;
   SourceData, TmpData: PByte;
   TempDepth: Integer;
-  Pix: TglBitmapPixelData;
-  FormatDesc: TglBitmapFormatDescriptor;
+  FormatDesc: TFormatDescriptor;
 
   function GetRowPointer(Row: Integer): pByte;
   begin
-    result := Surface.pixels;
+    result := aSurface.pixels;
     Inc(result, Row * RowSize);
   end;
 
 begin
   result := false;
 
-  (* TODO
-  if not FormatIsUncompressed(InternalFormat) then
-    raise EglBitmapUnsupportedInternalFormat.Create('AssignToSurface - ' + UNSUPPORTED_INTERNAL_FORMAT);
-  *)
+  FormatDesc := TFormatDescriptor.Get(Format);
+  if FormatDesc.IsCompressed then
+    raise EglBitmapUnsupportedFormat.Create('AssignToSurface');
 
-  FormatDesc := FORMAT_DESCRIPTORS[Format];
   if Assigned(Data) then begin
-    case Trunc(FormatDesc.GetSize) of
+    case Trunc(FormatDesc.PixelSize) of
       1: TempDepth :=  8;
       2: TempDepth := 16;
       3: TempDepth := 24;
       4: TempDepth := 32;
     else
-      raise EglBitmapException.Create('AssignToSurface - ' + UNSUPPORTED_INTERNAL_FORMAT);
+      raise EglBitmapUnsupportedFormat.Create('AssignToSurface');
     end;
-    FormatDesc.PreparePixel(Pix);
-    with Pix.PixelDesc do
-      Surface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
-        RedRange shl RedShift, GreenRange shl GreenShift, BlueRange shl BlueShift, AlphaRange shl AlphaShift);
 
+    aSurface := SDL_CreateRGBSurface(SDL_SWSURFACE, Width, Height, TempDepth,
+      FormatDesc.RedMask, FormatDesc.GreenMask, FormatDesc.BlueMask, FormatDesc.AlphaMask);
     SourceData := Data;
-    RowSize    := Ceil(FileWidth * FormatDesc.GetSize);
+    RowSize    := FormatDesc.GetSize(FileWidth, 1);
 
-    for Row := 0 to FileHeight -1 do begin
+    for Row := 0 to FileHeight-1 do begin
       TmpData := GetRowPointer(Row);
       if Assigned(TmpData) then begin
         Move(SourceData^, TmpData^, RowSize);
@@ -4654,34 +4642,31 @@ function TglBitmap.AssignFromSurface(const aSurface: PSDL_Surface): Boolean;
 var
   pSource, pData, pTempData: PByte;
   Row, RowSize, TempWidth, TempHeight: Integer;
-  IntFormat, f: TglBitmapInternalFormat;
-  FormatDesc: TglBitmapFormatDescriptor;
+  IntFormat: TglBitmapFormat;
+  FormatDesc: TFormatDescriptor;
 
   function GetRowPointer(Row: Integer): pByte;
   begin
-    result := Surface^.pixels;
+    result := aSurface^.pixels;
     Inc(result, Row * RowSize);
   end;
 
 begin
   result := false;
-  if (Assigned(Surface)) then begin
-    with Surface^.format^ do begin
-      IntFormat := tfEmpty;
-      for f := Low(f) to High(f) do begin
-        if FORMAT_DESCRIPTORS[f].MaskMatch(RMask, GMask, BMask, AMask) then begin
-          IntFormat := f;
+  if (Assigned(aSurface)) then begin
+    with aSurface^.format^ do begin
+      for IntFormat := High(TglBitmapFormat) to Low(TglBitmapFormat) do begin
+        FormatDesc := TFormatDescriptor.Get(IntFormat);
+        if (FormatDesc.MaskMatch(RMask, GMask, BMask, AMask)) then
           break;
-        end;
       end;
       if (IntFormat = tfEmpty) then
         raise EglBitmapException.Create('AssignFromSurface - Invalid Pixelformat.');
     end;
 
-    FormatDesc := FORMAT_DESCRIPTORS[IntFormat];
-    TempWidth  := Surface^.w;
-    TempHeight := Surface^.h;
-    RowSize := Trunc(TempWidth * FormatDesc.GetSize);
+    TempWidth  := aSurface^.w;
+    TempHeight := aSurface^.h;
+    RowSize := FormatDesc.GetSize(TempWidth, 1);
     GetMem(pData, TempHeight * RowSize);
     try
       pTempData := pData;
@@ -4721,9 +4706,9 @@ begin
 
       AlphaInterleave := 0;
       case Format of
-        ifLuminance8Alpha8:
+        tfLuminance8Alpha8:
           AlphaInterleave := 1;
-        ifBGRA8, ifRGBA8:
+        tfBGRA8, tfRGBA8:
           AlphaInterleave := 3;
       end;
 
@@ -4745,14 +4730,14 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean;
+function TglBitmap.AddAlphaFromSurface(const aSurface: PSDL_Surface; const aFunc: TglBitmapFunction = nil; const aArgs: Pointer = nil): Boolean;
 var
   bmp: TglBitmap2D;
 begin
   bmp := TglBitmap2D.Create;
   try
-    bmp.AssignFromSurface(Surface);
-    result := AddAlphaFromGlBitmap(bmp, Func, CustomData);
+    bmp.AssignFromSurface(aSurface);
+    result := AddAlphaFromGlBitmap(bmp, aFunc, aArgs);
   finally
     bmp.Free;
   end;
@@ -5147,7 +5132,7 @@ begin
   FormatDesc := TFormatDescriptor.Get(Format);
   if Assigned(Data) then begin
     if FormatDesc.IsCompressed or not FormatDesc.HasAlpha then
-      raise EglBitmapUnsupportedFormatFormat.Create('RemoveAlpha - ' + UNSUPPORTED_FORMAT);
+      raise EglBitmapUnsupportedFormat.Create('RemoveAlpha');
     result := ConvertTo(FormatDesc.WithoutAlpha);
   end;
 end;
@@ -5522,7 +5507,7 @@ begin
       Surface := IMG_LoadPNG_RW(RWops);
       try
         AssignFromSurface(Surface);
-        Rresult := true;
+        result := true;
       finally
         SDL_FreeSurface(Surface);
       end;
@@ -5923,40 +5908,6 @@ type
   end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{
-procedure glBitmap_libJPEG_error_exit(cinfo: j_common_ptr); cdecl;
-var
-  Msg: String;
-begin
-  SetLength(Msg, 256);
-  cinfo^.err^.format_message(cinfo, pChar(Msg));
-  Writeln('ERROR [' + IntToStr(cinfo^.err^.msg_code) + '] ' + Msg);
-  cinfo^.global_state := 0;
-  jpeg_abort(cinfo);
-end;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{
-procedure glBitmap_libJPEG_output_message(cinfo: j_common_ptr); cdecl;
-var
-  Msg: String;
-begin
-  SetLength(Msg, 256);
-  cinfo^.err^.format_message(cinfo, pChar(Msg));
-  Writeln('OUTPUT [' + IntToStr(cinfo^.err^.msg_code) + '] ' + Msg);
-  cinfo^.global_state := 0;
-end;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{
-procedure glBitmap_libJPEG_init_source(cinfo: j_decompress_ptr); cdecl;
-begin
-end;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function glBitmap_libJPEG_fill_input_buffer(cinfo: j_decompress_ptr): boolean; cdecl;
 var
   src: glBitmap_libJPEG_source_mgr_ptr;
@@ -5998,20 +5949,6 @@ begin
 end;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{
-procedure glBitmap_libJPEG_term_source(cinfo: j_decompress_ptr); cdecl;
-begin
-end;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-{
-procedure glBitmap_libJPEG_init_destination(cinfo: j_compress_ptr); cdecl;
-begin
-end;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function glBitmap_libJPEG_empty_output_buffer(cinfo: j_compress_ptr): boolean; cdecl;
 var
   dest: glBitmap_libJPEG_dest_mgr_ptr;
@@ -6062,7 +5999,7 @@ var
 begin
   result := false;
 
-  RWops := glBitmapCreateRWops(Stream);
+  RWops := glBitmapCreateRWops(aStream);
   try
     if IMG_isJPG(RWops) > 0 then begin
       Surface := IMG_LoadJPG_RW(RWops);
@@ -6622,7 +6559,7 @@ var
 
 begin
   if not (ftBMP in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
+    raise EglBitmapUnsupportedFormat.Create('SaveBMP');
 
   Converter  := nil;
   FormatDesc := TFormatDescriptor.Get(Format);
@@ -6687,7 +6624,7 @@ begin
         Info.biCompression := BMP_COMP_BITFIELDS;
       end;
     else
-      raise EglBitmapUnsupportedFormatFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
+      raise EglBitmapUnsupportedFormat.Create('SaveBMP - ' + UNSUPPORTED_FORMAT);
     end;
     Info.biXPelsPerMeter := 2835;
     Info.biYPelsPerMeter := 2835;
@@ -6804,7 +6741,7 @@ const
 function TglBitmap.LoadTGA(const aStream: TStream): Boolean;
 var
   Header: TTGAHeader;
-  ImageData: PByte;
+  ImageData: System.PByte;
   StartPosition: Int64;
   PixelSize, LineSize: Integer;
   tgaFormat: TglBitmapFormat;
@@ -6822,7 +6759,7 @@ const
   procedure ReadUncompressed;
   var
     i, j: Integer;
-    buf, tmp1, tmp2: PByte;
+    buf, tmp1, tmp2: System.PByte;
   begin
     buf := nil;
     if (Counter.X.dir < 0) then
@@ -6856,7 +6793,7 @@ const
 
     /////////////////////////////////////////////////////////////////
     var
-      TmpData: PByte;
+      TmpData: System.PByte;
       LinePixelsRead: Integer;
     procedure CheckLine;
     begin
@@ -7083,7 +7020,7 @@ var
   Converter: TFormatDescriptor;
 begin
   if not (ftTGA in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormatFormat.Create('SaveTGA - ' + UNSUPPORTED_FORMAT);
+    raise EglBitmapUnsupportedFormat.Create('SaveTGA');
 
   //prepare header
   FillChar(Header{%H-}, SizeOf(Header), 0);
@@ -7296,7 +7233,7 @@ var
 var
   StreamPos: Int64;
   x, y, LineSize, RowSize, Magic: Cardinal;
-  NewImage, TmpData, RowData, SrcData: PByte;
+  NewImage, TmpData, RowData, SrcData: System.PByte;
   SourceMD, DestMD: Pointer;
   Pixel: TglBitmapPixelData;
   ddsFormat: TglBitmapFormat;
@@ -7399,7 +7336,7 @@ var
   FormatDesc: TFormatDescriptor;
 begin
   if not (ftDDS in FormatGetSupportedFiles(Format)) then
-    raise EglBitmapUnsupportedFormatFormat.Create('SaveDDS - ' + UNSUPPORTED_FORMAT);
+    raise EglBitmapUnsupportedFormat.Create('SaveDDS');
 
   FormatDesc := TFormatDescriptor.Get(Format);
 
@@ -7542,7 +7479,7 @@ var
 begin
   FormatDesc := TFormatDescriptor.Get(Format);
   if FormatDesc.IsCompressed then
-    raise EglBitmapUnsupportedFormatFormat.Create('TglBitmap2D.GrabScreen - ' + UNSUPPORTED_FORMAT);
+    raise EglBitmapUnsupportedFormat.Create('TglBitmap2D.GrabScreen');
 
   w    := aRight  - aLeft;
   h    := aBottom - aTop;