{.$DEFINE GLB_DELPHI}
// activate to enable the support for TLazIntfImage from Lazarus
-{$DEFINE GLB_LAZARUS}
+{.$DEFINE GLB_LAZARUS}
// activate to enable the support of SDL_image to load files. (READ ONLY)
{$ENDIF}
// Operation System
-{$IF DEFINED(WIN32) or DEFINED(WIN64)}
+{$IF DEFINED(WIN32) or DEFINED(WIN64) or DEFINED(WINDOWS)}
{$DEFINE GLB_WIN}
{$ELSEIF DEFINED(LINUX)}
{$DEFINE GLB_LINUX}
-{$ENDIF}
+{$IFEND}
// native OpenGL Support
{$IF DEFINED(GLB_NATIVE_OGL_STATIC) OR DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
{$DEFINE GLB_NATIVE_OGL}
-{$ENDIF}
+{$IFEND}
// checking define combinations
//SDL Image
// native OpenGL
{$IF DEFINED(GLB_NATIVE_OGL_STATIC) AND DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
{$MESSAGE warn 'GLB_NATIVE_OGL_STATIC will be ignored because you enabled GLB_NATIVE_OGL_DYNAMIC'}
-{$ENDIF}
+{$IFEND}
// general options
{$EXTENDEDSYNTAX ON}
uses
{$IFNDEF GLB_NATIVE_OGL} dglOpenGL, {$ENDIF}
{$IF DEFINED(GLB_WIN) AND
- DEFINED(GLB_NATIVE_OGL)} windows, {$ENDIF}
+ DEFINED(GLB_NATIVE_OGL)} windows, {$IFEND}
{$IFDEF GLB_SDL} SDL, {$ENDIF}
{$IFDEF GLB_LAZARUS} IntfGraphics, GraphType, {$ENDIF}
Classes, SysUtils;
-{$IFNDEF GLB_DELPHI}
-type
- HGLRC = Cardinal;
- DWORD = Cardinal;
- PDWORD = ^DWORD;
-
- TRGBQuad = packed record
- rgbBlue: Byte;
- rgbGreen: Byte;
- rgbRed: Byte;
- rgbReserved: Byte;
- end;
-{$ENDIF}
-
{$IFDEF GLB_NATIVE_OGL}
const
GL_TRUE = 1;
GL_TEXTURE_MAX_ANISOTROPY_EXT = $84FE;
GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT = $84FF;
-{$ifdef LINUX}
- libglu = 'libGLU.so.1';
- libopengl = 'libGL.so.1';
-{$else}
+{$IF DEFINED(GLB_WIN)}
libglu = 'glu32.dll';
libopengl = 'opengl32.dll';
-{$endif}
+{$ELSEIF DEFINED(GLB_LINUX)}
+ libglu = 'libGLU.so.1';
+ libopengl = 'libGL.so.1';
+{$IFEND}
type
GLboolean = BYTEBOOL;
TglCompressedTexImage2D = procedure(target: GLenum; level: GLint; internalformat: GLenum; width: GLsizei; height: GLsizei; border: GLint; imageSize: GLsizei; const data: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglGetCompressedTexImage = procedure(target: GLenum; level: GLint; img: PGLvoid); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
+{$IF DEFINED(GLB_WIN)}
+ TwglGetProcAddress = function (ProcName: PAnsiChar): Pointer; stdcall;
+{$ELSEIF DEFINED(GLB_LINUX)}
+ TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl;
+ TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
+{$IFEND}
+
{$IF DEFINED(GLB_NATIVE_OGL_DYNAMIC)}
TglEnable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TglDisable = procedure(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TgluBuild1DMipmaps = function(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
TgluBuild2DMipmaps = function(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF}
- {$IFDEF GLB_LINUX}
- TglXGetProcAddress = function(ProcName: PAnsiChar): Pointer; cdecl;
- TglXGetProcAddressARB = function(const name: PAnsiChar): pointer; cdecl;
- {$ELSE}
- TwglGetProcAddress = function(ProcName: PAnsiChar): Pointer; stdcall;
- {$ENDIF}
-
{$ELSEIF DEFINED(GLB_NATIVE_OGL_STATIC)}
procedure glEnable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
procedure glDisable(cap: GLenum); {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libopengl;
function gluBuild1DMipmaps(target: GLEnum; components, width: GLint; format, atype: GLEnum; const data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
function gluBuild2DMipmaps(target: GLEnum; components, width, height: GLint; format, atype: GLEnum; const Data: Pointer): GLint; {$IFDEF GLB_WIN}stdcall; {$ELSE}cdecl; {$ENDIF} external libglu;
-{$ENDIF}
+{$IFEND}
var
GL_VERSION_1_2,
glCompressedTexImage2D: TglCompressedTexImage2D;
glGetCompressedTexImage: TglGetCompressedTexImage;
+{$IF DEFINED(GLB_WIN)}
+ wglGetProcAddress: TwglGetProcAddress;
+{$ELSEIF DEFINED(GLB_LINUX)}
+ glXGetProcAddress: TglXGetProcAddress;
+ glXGetProcAddressARB: TglXGetProcAddress;
+{$IFEND}
+
{$IFDEF GLB_NATIVE_OGL_DYNAMIC}
glEnable: TglEnable;
glDisable: TglDisable;
gluBuild1DMipmaps: TgluBuild1DMipmaps;
gluBuild2DMipmaps: TgluBuild2DMipmaps;
-
- {$IF DEFINED(GLB_WIN)}
- wglGetProcAddress: TwglGetProcAddress;
- {$ELSEIF DEFINED(GLB_LINUX)}
- glXGetProcAddress: TglXGetProcAddress;
- glXGetProcAddressARB: TglXGetProcAddressARB;
- {$ENDIF}
-{$ENDIF}
-
-(*
-{$IFDEF GLB_DELPHI}
-var
- gLastContext: HGLRC;
{$ENDIF}
-*)
-
{$ENDIF}
type
Math, syncobjs, typinfo;
type
+{$IFNDEF fpc}
+ QWord = System.UInt64;
+ PQWord = ^QWord;
+
+ PtrInt = Longint;
+ PtrUInt = DWord;
+{$ENDIF}
+
////////////////////////////////////////////////////////////////////////////////////////////////////
TShiftRec = packed record
case Integer of
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;
- function GetSize(const aSize: TglBitmapPixelPosition): Integer; virtual; overload;
- function GetSize(const aWidth, aHeight: Integer): Integer; virtual; overload;
+ function GetSize(const aSize: TglBitmapPixelPosition): Integer; overload; virtual;
+ function GetSize(const aWidth, aHeight: Integer): Integer; overload; virtual;
function CreateMappingData: Pointer; virtual;
procedure FreeMappingData(var aMappingData: Pointer); virtual;
function glbGetProcAddress(aProcName: PChar; aLibHandle: Pointer = nil): Pointer;
begin
- result := nil;
-
if not Assigned(aLibHandle) then
aLibHandle := GL_LibHandle;
end;
result := dlsym(aLibHandle, aProcName);
-{$ENDIF}
+{$IFEND}
if not Assigned(result) then
raise EglBitmapException.Create('unable to load procedure form library: ' + aProcName);
end;
result := dlopen(Name, RTLD_LAZY);
{$ELSE}
result := nil;
- {$ENDIF}
+ {$IFEND}
end;
////////////////////////////////////////////////////////////////////////////////
Result := FreeLibrary({%H-}HINST(aLibHandle));
{$ELSEIF DEFINED(GLB_LINUX)}
Result := dlclose(aLibHandle) = 0;
- {$ENDIF}
+ {$IFEND}
end;
begin
wglGetProcAddress := glbGetProcAddress('wglGetProcAddress');
{$ELSEIF DEFINED(GLB_LINUX)}
glXGetProcAddress := glbGetProcAddress('glXGetProcAddress');
- glXGetProcAddressARB := dglGetProcAddress('glXGetProcAddressARB');
- {$ENDIF}
+ glXGetProcAddressARB := glbGetProcAddress('glXGetProcAddressARB');
+ {$IFEND}
glEnable := glbGetProcAddress('glEnable');
glDisable := glbGetProcAddress('glDisable');
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure glbReadOpenGLExtensions;
var
- {$IFDEF GLB_DELPHI}
- Context: HGLRC;
- {$ENDIF}
Buffer: AnsiString;
MajorVersion, MinorVersion: Integer;
end;
{$ENDIF}
-{$IFDEF GLB_DELPHI}
- Context := wglGetCurrentContext;
- if (Context <> gLastContext) then begin
- gLastContext := Context;
-{$ENDIF}
-
- // Version
- Buffer := glGetString(GL_VERSION);
- TrimVersionString(Buffer, MajorVersion, MinorVersion);
+ // Version
+ Buffer := glGetString(GL_VERSION);
+ TrimVersionString(Buffer, MajorVersion, MinorVersion);
- GL_VERSION_1_2 := false;
- GL_VERSION_1_3 := false;
- GL_VERSION_1_4 := false;
- GL_VERSION_2_0 := false;
- if MajorVersion = 1 then begin
- if MinorVersion >= 2 then
- GL_VERSION_1_2 := true;
-
- if MinorVersion >= 3 then
- GL_VERSION_1_3 := true;
-
- if MinorVersion >= 4 then
- GL_VERSION_1_4 := true;
- end else if MajorVersion >= 2 then begin
+ GL_VERSION_1_2 := false;
+ GL_VERSION_1_3 := false;
+ GL_VERSION_1_4 := false;
+ GL_VERSION_2_0 := false;
+ if MajorVersion = 1 then begin
+ if MinorVersion >= 2 then
GL_VERSION_1_2 := true;
+
+ if MinorVersion >= 3 then
GL_VERSION_1_3 := true;
- GL_VERSION_1_4 := true;
- GL_VERSION_2_0 := true;
- end;
- // Extensions
- Buffer := glGetString(GL_EXTENSIONS);
- GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp');
- GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two');
- GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle');
- GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat');
- GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp');
- GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');
- GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle');
- GL_NV_texture_rectangle := CheckExtension('GL_NV_texture_rectangle');
- GL_IBM_texture_mirrored_repeat := CheckExtension('GL_IBM_texture_mirrored_repeat');
- GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap');
-
- if GL_VERSION_1_3 then begin
- glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1D');
- glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2D');
- glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage');
- end else begin
- glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1DARB');
- glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB');
- glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB');
- end;
-{$IFDEF GLB_DELPHI}
+ if MinorVersion >= 4 then
+ GL_VERSION_1_4 := true;
+ end else if MajorVersion >= 2 then begin
+ GL_VERSION_1_2 := true;
+ GL_VERSION_1_3 := true;
+ GL_VERSION_1_4 := true;
+ GL_VERSION_2_0 := true;
+ end;
+
+ // Extensions
+ Buffer := glGetString(GL_EXTENSIONS);
+ GL_ARB_texture_border_clamp := CheckExtension('GL_ARB_texture_border_clamp');
+ GL_ARB_texture_non_power_of_two := CheckExtension('GL_ARB_texture_non_power_of_two');
+ GL_ARB_texture_rectangle := CheckExtension('GL_ARB_texture_rectangle');
+ GL_ARB_texture_mirrored_repeat := CheckExtension('GL_ARB_texture_mirrored_repeat');
+ GL_EXT_texture_edge_clamp := CheckExtension('GL_EXT_texture_edge_clamp');
+ GL_EXT_texture_filter_anisotropic := CheckExtension('GL_EXT_texture_filter_anisotropic');
+ GL_EXT_texture_rectangle := CheckExtension('GL_EXT_texture_rectangle');
+ GL_NV_texture_rectangle := CheckExtension('GL_NV_texture_rectangle');
+ GL_IBM_texture_mirrored_repeat := CheckExtension('GL_IBM_texture_mirrored_repeat');
+ GL_SGIS_generate_mipmap := CheckExtension('GL_SGIS_generate_mipmap');
+
+ if GL_VERSION_1_3 then begin
+ glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1D');
+ glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2D');
+ glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImage');
+ end else begin
+ glCompressedTexImage1D := glbGetProcAddress('glCompressedTexImage1DARB');
+ glCompressedTexImage2D := glbGetProcAddress('glCompressedTexImage2DARB');
+ glGetCompressedTexImage := glbGetProcAddress('glGetCompressedTexImageARB');
end;
-{$ENDIF}
end;
{$ENDIF}
aData^ := 0;
d := LuminanceWeight(aPixel) and Range.r;
aData^ := aData^ or (d shl (4 - {%H-}PtrUInt(aMapData)));
- inc(aMapData, 4);
+ inc(PByte(aMapData), 4);
if ({%H-}PtrUInt(aMapData) >= 8) then begin
inc(aData);
aMapData := nil;
aPixel.Data.b := b;
aPixel.Data.a := a;
end;
- inc(aMapData, bits);
+ inc(PByte(aMapData), bits);
if ({%H-}PtrUInt(aMapData) >= 8) then begin
inc(aData, 1);
- dec(aMapData, 8);
+ dec(PByte(aMapData), 8);
end;
inc(aData, s);
end;
{$ENDIF}
{$IFDEF GLB_DELPHI}
-//TODO rework & test
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+function CreateGrayPalette: HPALETTE;
+var
+ Idx: Integer;
+ Pal: PLogPalette;
+begin
+ GetMem(Pal, SizeOf(TLogPalette) + (SizeOf(TPaletteEntry) * 256));
+
+ Pal.palVersion := $300;
+ Pal.palNumEntries := 256;
+
+ for Idx := 0 to Pal.palNumEntries - 1 do begin
+ Pal.palPalEntry[Idx].peRed := Idx;
+ Pal.palPalEntry[Idx].peGreen := Idx;
+ Pal.palPalEntry[Idx].peBlue := Idx;
+ Pal.palPalEntry[Idx].peFlags := 0;
+ end;
+ Result := CreatePalette(Pal^);
+ FreeMem(Pal);
+end;
+
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
function TglBitmap.AssignToBitmap(const aBitmap: TBitmap): Boolean;
var
aBitmap.Height := Height;
case Format of
- tfAlpha8, ifLuminance, ifDepth8:
- begin
- Bitmap.PixelFormat := pf8bit;
- Bitmap.Palette := CreateGrayPalette;
- end;
- ifRGB5A1:
- Bitmap.PixelFormat := pf15bit;
- ifR5G6B5:
- Bitmap.PixelFormat := pf16bit;
- ifRGB8, ifBGR8:
- Bitmap.PixelFormat := pf24bit;
- ifRGBA8, ifBGRA8:
- Bitmap.PixelFormat := pf32bit;
- else
- raise EglBitmapException.Create('AssignToBitmap - Invalid Pixelformat.');
+ tfAlpha8, tfLuminance8: begin
+ aBitmap.PixelFormat := pf8bit;
+ aBitmap.Palette := CreateGrayPalette;
+ end;
+ tfRGB5A1:
+ aBitmap.PixelFormat := pf15bit;
+ tfR5G6B5:
+ aBitmap.PixelFormat := pf16bit;
+ tfRGB8, tfBGR8:
+ aBitmap.PixelFormat := pf24bit;
+ tfRGBA8, tfBGRA8:
+ aBitmap.PixelFormat := pf32bit;
+ else
+ raise EglBitmapException.Create('AssignToBitmap - Invalid Pixelformat.');
end;
pSource := Data;
for Row := 0 to FileHeight -1 do begin
- pData := Bitmap.Scanline[Row];
-
+ pData := aBitmap.Scanline[Row];
Move(pSource^, pData^, fRowSize);
Inc(pSource, fRowSize);
-
- // swap RGB(A) to BGR(A)
- if InternalFormat in [ifRGB8, ifRGBA8] then
- SwapRGB(pData, FileWidth, InternalFormat = ifRGBA8);
+ if (Format in [tfRGB8, tfRGBA8]) then // swap RGB(A) to BGR(A)
+ SwapRGB(pData, FileWidth, Format = tfRGBA8);
end;
-
result := true;
end;
end;
var
pSource, pData, pTempData: PByte;
Row, RowSize, TempWidth, TempHeight: Integer;
- IntFormat: TglBitmapInternalFormat;
+ IntFormat: TglBitmapFormat;
begin
result := false;
- if (Assigned(Bitmap)) then begin
- case Bitmap.PixelFormat of
+ if (Assigned(aBitmap)) then begin
+ case aBitmap.PixelFormat of
pf8bit:
- IntFormat := ifLuminance;
+ IntFormat := tfLuminance8;
pf15bit:
- IntFormat := ifRGB5A1;
+ IntFormat := tfRGB5A1;
pf16bit:
- IntFormat := ifR5G6B5;
+ IntFormat := tfR5G6B5;
pf24bit:
- IntFormat := ifBGR8;
+ IntFormat := tfBGR8;
pf32bit:
- IntFormat := ifBGRA8;
- else
- raise EglBitmapException.Create('AssignFromBitmap - Invalid Pixelformat.');
+ IntFormat := tfBGRA8;
+ else
+ raise EglBitmapException.Create('AssignFromBitmap - Invalid Pixelformat.');
end;
- TempWidth := Bitmap.Width;
- TempHeight := Bitmap.Height;
-
- RowSize := Trunc(TempWidth * FormatGetSize(IntFormat));
-
+ TempWidth := aBitmap.Width;
+ TempHeight := aBitmap.Height;
+ RowSize := TFormatDescriptor.Get(IntFormat).GetSize(TempWidth, 1);
GetMem(pData, TempHeight * RowSize);
try
pTempData := pData;
-
for Row := 0 to TempHeight -1 do begin
- pSource := Bitmap.Scanline[Row];
-
+ pSource := aBitmap.Scanline[Row];
if (Assigned(pSource)) then begin
Move(pSource^, pTempData^, RowSize);
Inc(pTempData, RowSize);
end;
end;
-
SetDataPointer(pData, IntFormat, TempWidth, TempHeight);
-
result := true;
except
FreeMem(pData);
result := false;
if Assigned(Data) then begin
- if InternalFormat in [ifAlpha, ifLuminanceAlpha, ifRGBA8, ifBGRA8] then begin
- if Assigned(Bitmap) then begin
- Bitmap.PixelFormat := pf8bit;
- Bitmap.Palette := CreateGrayPalette;
- Bitmap.Width := Width;
- Bitmap.Height := Height;
-
- case InternalFormat of
- ifLuminanceAlpha:
+ if (Format in [tfAlpha8, tfLuminance8Alpha8, tfRGBA8, tfBGRA8]) then begin
+ if Assigned(aBitmap) then begin
+ aBitmap.PixelFormat := pf8bit;
+ aBitmap.Palette := CreateGrayPalette;
+ aBitmap.Width := Width;
+ aBitmap.Height := Height;
+
+ case Format of
+ tfLuminance8Alpha8:
AlphaInterleave := 1;
- ifRGBA8, ifBGRA8:
+ tfRGBA8, tfBGRA8:
AlphaInterleave := 3;
else
AlphaInterleave := 0;
pSource := Data;
for Row := 0 to Height -1 do begin
- pDest := Bitmap.Scanline[Row];
-
+ pDest := aBitmap.Scanline[Row];
if Assigned(pDest) then begin
for Col := 0 to Width -1 do begin
Inc(pSource, AlphaInterleave);
Inc(pSource);
end;
end;
- end;
-
+ end;
result := true;
end;
end;
end;
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: PtrInt): Boolean;
+function TglBitmap.AddAlphaFromBitmap(const aBitmap: TBitmap; const aFunc: TglBitmapFunction; const aArgs: Pointer): Boolean;
var
tex: TglBitmap2D;
begin
tex := TglBitmap2D.Create;
try
- tex.AssignFromBitmap(Bitmap);
- result := AddAlphaFromglBitmap(tex, Func, CustomData);
+ tex.AssignFromBitmap(ABitmap);
+ result := AddAlphaFromglBitmap(tex, aFunc, aArgs);
finally
tex.Free;
end;
end;
end;
end;
-{$ENDIF}
+{$IFEND}
{$ENDIF}
{$IFDEF GLB_SUPPORT_PNG_WRITE}
FreeAndNil(Png);
end;
end;
-{$ENDIF}
+{$IFEND}
{$ENDIF}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
result := false;
// reading first two bytes to test file and set cursor back to begin
- StreamPos := Stream.Position;
- Stream.Read(Temp[0], 2);
- Stream.Position := StreamPos;
+ StreamPos := aStream.Position;
+ aStream.Read(Temp[0], 2);
+ aStream.Position := StreamPos;
// if Bitmap then read file.
if ((Temp[0] = $FF) and (Temp[1] = $D8)) then begin
try
jpg := TJPEGImage.Create;
try
- jpg.LoadFromStream(Stream);
+ jpg.LoadFromStream(aStream);
bmp.Assign(jpg);
result := AssignFromBitmap(bmp);
finally
end;
end;
end;
-{$ENDIF}
+{$IFEND}
{$ENDIF}
{$IFDEF GLB_SUPPORT_JPEG_WRITE}
{$ELSEIF DEFINED(GLB_DELPHI_JPEG)}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-procedure TglBitmap.SaveJPEG(Stream: TStream);
+procedure TglBitmap.SaveJPEG(const aStream: TStream);
var
Bmp: TBitmap;
Jpg: TJPEGImage;
begin
- if not (ftJPEG in FormatGetSupportedFiles (InternalFormat)) then
- raise EglBitmapUnsupportedInternalFormat.Create('SaveJpg - ' + UNSUPPORTED_INTERNAL_FORMAT);
+ if not (ftJPEG in FormatGetSupportedFiles(Format)) then
+ raise EglBitmapUnsupportedFormat.Create(Format);
Bmp := TBitmap.Create;
try
Jpg := TJPEGImage.Create;
try
AssignToBitmap(Bmp);
- if FInternalFormat in [ifAlpha, ifLuminance, ifDepth8] then begin
- Jpg.Grayscale := true;
+ if (Format in [tfAlpha8, tfLuminance8]) then begin
+ Jpg.Grayscale := true;
Jpg.PixelFormat := jf8Bit;
end;
Jpg.Assign(Bmp);
- Jpg.SaveToStream(Stream);
+ Jpg.SaveToStream(aStream);
finally
FreeAndNil(Jpg);
end;
FreeAndNil(Bmp);
end;
end;
-{$ENDIF}
+{$IFEND}
{$ENDIF}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
begin
buf := nil;
if (Counter.X.dir < 0) then
- buf := GetMem(LineSize);
+ GetMem(buf, LineSize);
try
while (Counter.Y.low <> Counter.Y.high + counter.Y.dir) do begin
- tmp1 := ImageData + (Counter.Y.low * LineSize); //pointer to LineStart
+ tmp1 := ImageData;
+ inc(tmp1, (Counter.Y.low * LineSize)); //pointer to LineStart
if (Counter.X.dir < 0) then begin //flip X
aStream.Read(buf^, LineSize);
- tmp2 := buf + LineSize - PixelSize; //pointer to last pixel in line
+ tmp2 := buf;
+ inc(tmp2, LineSize - PixelSize); //pointer to last pixel in line
for i := 0 to Header.Width-1 do begin //for all pixels in line
for j := 0 to PixelSize-1 do begin //for all bytes in pixel
tmp1^ := tmp2^;
if (LinePixelsRead >= Header.Width) then begin
LinePixelsRead := 0;
inc(Counter.Y.low, Counter.Y.dir); //next line index
- TmpData := ImageData + Counter.Y.low * LineSize; //set line
+ TmpData := ImageData;
+ inc(TmpData, Counter.Y.low * LineSize); //set line
if (Counter.X.dir < 0) then //if x flipped then
- TmpData := TmpData + LineSize - PixelSize; //set last pixel
+ inc(TmpData, LineSize - PixelSize); //set last pixel
end;
end;
GetMem(Cache, CACHE_SIZE);
try
- TmpData := ImageData + Counter.Y.low * LineSize; //set line
+ TmpData := ImageData;
+ inc(TmpData, Counter.Y.low * LineSize); //set line
if (Counter.X.dir < 0) then //if x flipped then
- TmpData := TmpData + LineSize - PixelSize; //set last pixel
+ inc(TmpData, LineSize - PixelSize); //set last pixel
repeat
//read CommandByte
if Header.ImageID <> 0 then // skip image ID
aStream.Position := aStream.Position + Header.ImageID;
+ tgaFormat := tfEmpty;
case Header.Bpp of
8: if IsGrayFormat then case (Header.ImageDesc and $F) of
0: tgaFormat := tfLuminance8;
if Assigned(Converter) then begin
LineSize := FormatDesc.GetSize(Width, 1);
- LineBuf := GetMem(LineSize);
+ GetMem(LineBuf, LineSize);
SourceMD := FormatDesc.CreateMappingData;
DestMD := Converter.CreateMappingData;
try
DestMD := FormatDesc.CreateMappingData;
try
for y := 0 to Header.dwHeight-1 do begin
- TmpData := NewImage + y * LineSize;
+ TmpData := NewImage;
+ inc(TmpData, y * LineSize);
SrcData := RowData;
aStream.Read(SrcData^, RowSize);
for x := 0 to Header.dwWidth-1 do begin
projects / LazOpenGLCore.git / blobdiff