opengl
/
OpenGLCore
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

* added Delphi Support

master
Bergmann89 10 years ago
parent
5707b04adc
commit
483a3227cc
1 changed files with 181 additions and 196 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +181
    -196
      glBitmap.pas

+ 181
- 196
glBitmap.pas View File

@@ -241,7 +241,7 @@ unit glBitmap;
{.$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)
@@ -286,16 +286,16 @@ unit glBitmap;
{$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
@@ -362,7 +362,7 @@ unit glBitmap;
// 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}
@@ -377,7 +377,7 @@ interface
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}
@@ -393,20 +393,6 @@ uses

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;
@@ -524,13 +510,13 @@ const
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;
@@ -550,6 +536,13 @@ type
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}
@@ -579,13 +572,6 @@ type
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;
@@ -614,7 +600,7 @@ type

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,
@@ -641,6 +627,13 @@ var
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;
@@ -669,22 +662,7 @@ var

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
@@ -1132,6 +1110,14 @@ uses
Math, syncobjs, typinfo;

type
{$IFNDEF fpc}
QWord = System.UInt64;
PQWord = ^QWord;

PtrInt = Longint;
PtrUInt = DWord;
{$ENDIF}

////////////////////////////////////////////////////////////////////////////////////////////////////
TShiftRec = packed record
case Integer of
@@ -1186,8 +1172,8 @@ type
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;
@@ -1842,8 +1828,6 @@ var

function glbGetProcAddress(aProcName: PChar; aLibHandle: Pointer = nil): Pointer;
begin
result := nil;

if not Assigned(aLibHandle) then
aLibHandle := GL_LibHandle;

@@ -1868,7 +1852,7 @@ begin
end;

result := dlsym(aLibHandle, aProcName);
{$ENDIF}
{$IFEND}
if not Assigned(result) then
raise EglBitmapException.Create('unable to load procedure form library: ' + aProcName);
end;
@@ -1891,7 +1875,7 @@ procedure glbInitOpenGL;
result := dlopen(Name, RTLD_LAZY);
{$ELSE}
result := nil;
{$ENDIF}
{$IFEND}
end;

////////////////////////////////////////////////////////////////////////////////
@@ -1905,7 +1889,7 @@ procedure glbInitOpenGL;
Result := FreeLibrary({%H-}HINST(aLibHandle));
{$ELSEIF DEFINED(GLB_LINUX)}
Result := dlclose(aLibHandle) = 0;
{$ENDIF}
{$IFEND}
end;

begin
@@ -1928,8 +1912,8 @@ 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');
@@ -1963,9 +1947,6 @@ end;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
procedure glbReadOpenGLExtensions;
var
{$IFDEF GLB_DELPHI}
Context: HGLRC;
{$ENDIF}
Buffer: AnsiString;
MajorVersion, MinorVersion: Integer;

@@ -2024,61 +2005,52 @@ begin
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}

@@ -3798,7 +3770,7 @@ begin
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;
@@ -3848,10 +3820,10 @@ begin
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;
@@ -4621,7 +4593,27 @@ 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
@@ -4635,35 +4627,30 @@ begin
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;
@@ -4674,46 +4661,40 @@ function TglBitmap.AssignFromBitmap(const aBitmap: TBitmap): Boolean;
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);
@@ -4731,17 +4712,17 @@ begin
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;
@@ -4751,8 +4732,7 @@ begin
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);
@@ -4761,8 +4741,7 @@ begin
Inc(pSource);
end;
end;
end;

end;
result := true;
end;
end;
@@ -4770,14 +4749,14 @@ begin
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;
@@ -5765,7 +5744,7 @@ begin
end;
end;
end;
{$ENDIF}
{$IFEND}
{$ENDIF}

{$IFDEF GLB_SUPPORT_PNG_WRITE}
@@ -5931,7 +5910,7 @@ begin
FreeAndNil(Png);
end;
end;
{$ENDIF}
{$IFEND}
{$ENDIF}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -6219,9 +6198,9 @@ begin
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
@@ -6229,7 +6208,7 @@ begin
try
jpg := TJPEGImage.Create;
try
jpg.LoadFromStream(Stream);
jpg.LoadFromStream(aStream);
bmp.Assign(jpg);
result := AssignFromBitmap(bmp);
finally
@@ -6240,7 +6219,7 @@ begin
end;
end;
end;
{$ENDIF}
{$IFEND}
{$ENDIF}

{$IFDEF GLB_SUPPORT_JPEG_WRITE}
@@ -6351,25 +6330,25 @@ end;

{$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;
@@ -6377,7 +6356,7 @@ begin
FreeAndNil(Bmp);
end;
end;
{$ENDIF}
{$IFEND}
{$ENDIF}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -6844,13 +6823,15 @@ const
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^;
@@ -6881,9 +6862,10 @@ const
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;

@@ -6961,9 +6943,10 @@ const

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
@@ -7012,6 +6995,7 @@ begin
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;
@@ -7156,7 +7140,7 @@ begin

if Assigned(Converter) then begin
LineSize := FormatDesc.GetSize(Width, 1);
LineBuf := GetMem(LineSize);
GetMem(LineBuf, LineSize);
SourceMD := FormatDesc.CreateMappingData;
DestMD := Converter.CreateMappingData;
try
@@ -7364,7 +7348,8 @@ begin
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


Write Preview
Loading…
Cancel
Save