Bonjour à tous,

Je suis devant un problème que je n'arrive pas à résoudre depuis plus d'une semaine.

Dans mon projet, (d'avoir un TBitmap indépendant de FPC et Lazarus à sa base), j'ai décidé de changer la classe qui servait au chargement des données par une classe descendante de TStream pour plus de confort et d'esthétique dans le code.
Jusque là pas trop de soucis je charge sans problème les fichiers BMP 32bits

Nom : 2017-06-21_153857.jpg Affichages : 333 Taille : 68,1 Ko
* A Gauche TBitmap, a droite ma solution "TGLZBitmap"

Mais lorsque je veux charger des fichiers BMP 24bits
A Gauche le fichier 24Bit, A droite le fichier 32Bits afficher par dessus avec la transparence
Nom : 2017-06-21_154336.jpg Affichages : 227 Taille : 66,2 Ko Nom : 2017-06-21_154514.jpg Affichages : 242 Taille : 70,1 Ko

Elles sont passées ou mes données ????

Voilà le code (version courte) de la Classe dérivée de TStream
Désolé pour les logs posés comme un bourrin
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
 
uses
  Classes, SysUtils;
 
Const
  DefaultBufferedStreamBlockSize = 1024*64; // par défaut tampon de 64Mo, 64ko pour tester
 
type
   { : TGLZCustomBufferedStream aide à la lecture et ou ecriture de données dans un flux (TStream).
      L'acces se fait par le biais d'un tampon de taille définie.
 
      L'acces aux données est un acces directe en mémoire et se fait de façon séquentielle.
    
      Cette classe ameliore surtout les performances d'accès aux données de fichiers physique.
      Ne pas employer directement TGLZCustomBufferedStream. Utilsez la classe TGLZBufferedStream
      et les autres classes descendantes.
  }
  TGLZCustomBufferedStream = class(TStream)
  private
    procedure LoadBuffer; virtual;//(var Buf; BufSize: integer) : integer; virtual;
  protected
    Stream : TStream; // Les données que l'on veux exploiter
    StreamSize : Int64; // La taille des données du stream
    StreamPosition: Int64; // Position dans le stream
    AutoFreeStream : Boolean; //Indicateur si l'on doit libérer le stream ou pas
    StreamViewStart, StreamViewEnd, StreamViewLength : Int64; // position et longueur du tampon dans le stream
    //StreamViewStartPtr, FStreamViewEndPtr : PByte; // pointe directement sur le debut ou la fin peut-être utile dans certain cas (lecture depuis la fin par ex)
    StreamBytesLeft : Int64; // Nombre d'octet qui reste à lire
    StreamBytesRead : Int64; // Nombre d'octet deja lu (égual à FStreamPosition+1)
 
 
    Buffer: Pointer; //PByte; // Tampon mémoire pour l'acces au donnée par bloque
    BufferDefaultSize: Int64; // Taille du tampon par defaut
    BufferSize: Int64; // Taille réelle du tampon
    BufferPosition : Int64;  // Position dans le tampon
    BufferBytesRead,  BufferBytesWrite : Int64;  // Nombre d'octet deja lu ou écrit dans le tampon
    BufferBytesLeft : Int64; // Nombre d'octet qui reste à lire dans le tampon
 
    FUseAlignedCache: Boolean; // On aligne la taille du tampon sur 32bit (accélère les échanges mémoire dans certain cas)
    StrideSize : Byte; //Taille en octet à ajouté à la fin du tampon pour l'alignement des données
 
    procedure SetSize(const NewSize: Int64); override;
 
  public
    constructor Create(Const aBlockSize: Integer = DefaultBufferedStreamBlockSize);
    constructor Create(AStream : TStream; const aBlockSize : integer = DefaultBufferedStreamBlockSize); overload;
 
    destructor Destroy; override;
 
    procedure AssignBuffer(aBuffer:Pointer; aSize:Longint);
    procedure AssignStream(aStream:TStream);
 
    procedure Flush;
    function Read(var aBuffer; Count: Longint): Longint; override;
    function Write(const aBuffer; Count: Longint): Longint; override;
    function Seek(const Offset: Int64; Origin: TSeekOrigin): Int64; override;
 
 
    { Routines de lecture et de déplacement dans le tampon }
    function ReadByte:Byte; inline;
    procedure SkipNextByte(Const aCount:Integer=1); inline;
    procedure GotoPreviousByte; inline;
    procedure GotoNextStringLine; inline;
 
    function ReadWord:Word;
    function ReadInteger:Integer;
    //ect....
 
   { Clear : Efface les données en les mettant à ZERO }
    procedure Clear;
 
    { GetBuffer : Renvoie le tampon brute de pomme }
    function GetBuffer:Pointer;
 
    { GetBufferAsString : Renvoie le tampon sous la forme d'une chaine de caractère
     /!\ Max 64Mo ou la taille que vous aurez définit à la creation de TGLZBufferdStream }
    function GetBufferAsString:String; Inline;
 
    // Renvoie la taille total des données du Stream
    property Size: Int64 read StreamSize;
  end;
  TGLZCustomBufferedStreamClass = class of TGLZCustomBufferedStream;
 
  { : voir TGLZCustomBufferedStream pour informations }
  TGLZBufferedStream = class(TGLZCustomBufferedStream);  
 
implementation
 
uses GLZLogger;
 
{%region%=====[ TGLZCustomBufferedStream ]=====================================}
 
constructor TGLZCustomBufferedStream.Create(Const aBlockSize: Integer = DefaultBufferedStreamBlockSize);
begin
  inherited Create;
  GlobalLogger.LogNotice('TGLZCustomBufferedStream.Create' );
  GlobalLogger.LogNotice('Taille du tampon par defaut :  BufferDefaultSize = '+IntToStr(aBlockSize));
  Buffer:=nil;
  BufferDefaultSize := aBlockSize;
  BufferSize:=BufferDefaultSize;
  BufferBytesRead := 0;
  BufferBytesLeft := 0;
  BufferPosition  := 0;
 
  Stream := nil;
  StreamSize := BufferSize;
  StreamPosition := 0;
  StreamViewStart := 0;
  StreamViewEnd := 0;
  StreamViewLength := 0;
  AutoFreeStream := False;
  StreamBytesLeft := 0;
  StreamBytesRead := 0;
 
end;
 
constructor TGLZCustomBufferedStream.Create(AStream : TStream; const aBlockSize : integer = DefaultBufferedStreamBlockSize);
begin
  GlobalLogger.LogNotice('TGLZCustomBufferedStream.Create depuis TStream' );
  Create(aBlockSize);
  Stream := AStream;
  StreamSize := AStream.Size;
  GlobalLogger.LogNotice('Taille du Stream :  StreamSize = '+IntToStr(StreamSize));
  StreamPosition := 0;
  StreamViewStart := 0;
  StreamViewEnd := 0;
  StreamViewLength := 0;
  AutoFreeStream := False;
  StreamBytesLeft := StreamSize;
  StreamBytesRead := 0;
end;
 
destructor TGLZCustomBufferedStream.Destroy;
begin
  GlobalLogger.LogNotice('TGLZCustomBufferedStream.Destroy' );
  if AutoFreeStream then FreeAndNil(Stream);
  //FreeAndNil(Buffer);
  ReAllocMem(Buffer, 0);
  FreeMem(Buffer);
  Buffer:=nil;
  inherited Destroy;
end;
 
procedure TGLZCustomBufferedStream.Flush;
begin
  GlobalLogger.LogNotice('Vide et reinitialise le tampon à la position : '+inttostr(BufferPosition));
  // Clear; ---> Aucun chargement dans le buffer apres, ecran noir !!!! Est ce que FillByte deplace la position du pointer ???
  StreamViewStart := BufferPosition;
  StreamBytesLeft:=StreamSize-BufferPosition;
  BufferSize:=BufferDefaultSize;
  BufferBytesRead := 0;
  BufferBytesLeft := 0;
  BufferPosition  := 0;
end;
 
 
procedure TGLZCustomBufferedStream.LoadBuffer;
var
  SeekResult: Integer;
  RSize:Longint;
begin
  GlobalLogger.LogNotice('TGLZCustomBufferedStream.LoadBuffer' );
  GlobalLogger.LogStatus('Reste dans le stream : StreamBytesLeft = '+inttostr(StreamBytesLeft));
  // C'est la 1er fois ? on initialise le tampon
  if not(Assigned(Buffer)) then SetSize(BufferDefaultSize);
 
  // Fin des données, plus rien à lire, on remet tout a zero et on s'en va
  if (StreamViewStart>=StreamSize) or (StreamBytesLeft<=0) then
  begin
    GlobalLogger.LogNotice('TGLZCustomBufferedStream.LoadBuffer : Fin des données atteinte' );
    BufferPosition:=0;
    BufferBytesRead := 0;
    BufferBytesLeft := 0;
    StreamViewLength:=0;
    StreamBytesLeft:=0;
    //EndOfStream : boolean = true;
    exit;
  end;
  GlobalLogger.LogNotice('Deplacement dans le stream  :  StreamViewStart = '+IntToStr(StreamViewStart));
  // On se place sous la bonne fenètre
  SeekResult := Stream.Seek(StreamViewStart, soBeginning);
  if SeekResult = -1 then
    raise EStreamError.Create('TGLZCustomBufferedStream.LoadBuffer: Erreur lors du positionnement dans le flux');
  if (StreamBytesLeft<BufferDefaultSize) then Rsize:= StreamBytesLeft else RSize:=BufferDefaultSize;
  // On lit les données, et on transfert dans le tampon
  BufferSize := Stream.Read(Buffer^,RSize);
  if BufferSize <= 0 then
    raise EStreamError.Create('TGLZCustomBufferedStream.LoadBuffer: Erreur lors de la Lecture du flux');
  GlobalLogger.LogNotice('Données copiées depuis stream vers le tampon :  BufferSize = '+IntToStr(BufferSize));
  // On met à jour les marqueurs de la "fenêtre" de lecture du Stream pour le chargement
 
  StreamPosition:=StreamViewStart;
  StreamViewLength:=BufferSize;
  StreamViewEnd := StreamViewStart + StreamViewLength-1;
  if StreamViewEnd > StreamSize then  raise EStreamError.Create('TGLZCustomBufferedStream.LoadBuffer: Index StreamViewEnd hors limite');
  Dec(StreamBytesLeft,BufferSize);
  Inc(StreamBytesRead,BufferSize);
  GlobalLogger.LogStatus('Reste dans le stream : StreamBytesLeft = '+inttostr(StreamBytesLeft));
  // On reinitialise les marqueurs du Buffer
  BufferPosition:=0;
  BufferBytesRead := 0;
  BufferBytesLeft := BufferSize;
  GlobalLogger.LogStatus('StreamViewLength = '+inttostr(StreamViewLength));
  GlobalLogger.LogStatus('StreamViewEnd = '+inttostr(StreamViewEnd));
 
end;
 
procedure TGLZCustomBufferedStream.SetSize(const NewSize: Int64);
begin
  GlobalLogger.LogNotice('Initialisation du tampon :  BufferSize = '+IntToStr(NewSize));
  ReAllocMem(Buffer, NewSize);
  BufferSize:=NewSize;
  BufferPosition:=0;
  BufferBytesRead:=0;
  BufferBytesWrite :=0;
  BufferBytesLeft:=NewSize;
end;
 
function TGLZCustomBufferedStream.Read(var aBuffer; Count: Longint): Longint;
var diff:Longint;
begin
  Result:=0;
  GlobalLogger.Log('----------------------------------------------------------------------');
  GlobalLogger.LogNotice('TGLZCustomBufferedStream.Read' );
  GlobalLogger.LogStatus('Reste dans le tampon : BufferBytesLeft = '+inttostr(BufferBytesLeft));
 
  // Il n'y a plus de données à lire dans le Tampon et le Stream
  //if (StreamBytesLeft<=0) and (BufferBytesLeft<=0) then exit;
  // Il n'y a plus de données à lire dans le Tampon
  if (BufferBytesLeft<=0)  then
  begin
    GlobalLogger.LogNotice('Fin du Tampon atteinte ou 1ere fois');
    GlobalLogger.LogStatus('Position dans le stream : StreamViewStart = '+inttostr(StreamViewStart));
    GlobalLogger.LogStatus('Position dans le Tampon : BufferPosition = '+inttostr(BufferPosition));
    StreamViewStart:=StreamViewStart+BufferPosition;
    GlobalLogger.LogStatus('Nouvelle Position dans le stream : StreamViewStart = '+inttostr(StreamViewStart));
    GlobalLogger.LogStatus('Loading Stream Buffer : '+inttostr(BufferSize));
    LoadBuffer; // On charge un nouveau tampon depuis le stream
  end
  else    // Il n'y a pas assez de donnée restante à lire dans le tampon
  If (BufferBytesLeft<Count) then
  begin
     GlobalLogger.LogNotice('Pas assez de données dans le tampon, reste BufferBytesLeft = '+inttostr(BufferBytesLeft));
     GlobalLogger.LogNotice('  Nombre d''octets à lire : Count = '+inttostr(Count));
     GlobalLogger.LogStatus('  Position dans le Tampon : BufferPosition = '+inttostr(BufferPosition));
     diff := Count-BufferBytesLeft;
     GlobalLogger.LogStatus('  Différence = '+inttostr(Diff));
     GlobalLogger.LogStatus('  Position dans le stream : StreamViewStart = '+inttostr(StreamViewStart));
     Inc(StreamBytesLeft,Diff);
     StreamViewStart:=StreamViewStart+BufferPosition;
     GlobalLogger.LogStatus('Nouvelle Position dans le stream : StreamViewStart = '+inttostr(StreamViewStart));
 
     //StreamBytesLeft:=StreamSize-StreamViewStart+1;
     //StreamBytesRead:=StreamViewStart-1;
     LoadBuffer;
   end;
  // else   // Il reste suffisamment de données à lire,
   If (BufferBytesLeft>=0) and (BufferPosition<BufferSize) and (BufferPosition>=0) then
   begin
    GlobalLogger.LogStatus('Lecture du tampon à la position = '+inttostr(BufferPosition)+' Count = '+inttostr(Count));
    Result:=Count;
    // On copie les données
    Move((Buffer+BufferPosition)^,aBuffer, result);
    // On met à jour les marqueur de notre tampon
    Inc(BufferPosition,Result);
    Inc(BufferBytesRead,Result);
    Dec(BufferBytesLeft,Result);
    GlobalLogger.LogStatus('Reste dans le tampon apres lecture : BufferBytesLeft = '+inttostr(BufferBytesLeft));
   end;
end;
Ensuite le code qui charge les données et les décode (24 et 32bits)

*L'objet "Memory" est le TGLZBufferedStream
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
 
procedure TGLZBitmapBMPImage.LoadFromMemory();
var
   YY,Y : Integer;
   X:Integer;
   DstColor: TGLZColor;
   SrcPtr : PLongWord;
   SrcPtr16 : PWord;
   SrcPtr24 : PGLZColorBGR_24;
   DstLine : PGLZColor;
   SrcColor :LongWord;
   SrcColor16 :Word;
   SrcColor24:TGLZColorBGR_24;
   LineBuffer : PByte;
 
  //https://en.wikipedia.org/wiki/File:BitfieldsSLN.png
 
begin
  FIgnoreAlpha:=true;
  // On initialise les dimensions de notre bitmap
  SetSize(bmpWidth, bmpHeight);
  Case RawImage.Description.PixelFormat of
 
    pf24Bits: // Pas de compression sauf si en-tête OS2x V2 alors compresion RLE. Formats couleurs suivant "BitField" sinon BGR
    begin
      If (FHeaderType = bmpht_OS22x) and (Compression = BMP_COMPRESSION_JPEG) then
      begin
      end
      else
      begin
        GlobalLogger.LogNotice('--> Decode Image Data = '+inttostr(MaxWidth)+'x'+IntToStr(MaxHeight));
        LineBuffer:=nil;
        ReallocMem(LineBuffer,FRowSize);
        Try
          Memory.Flush;
          Y:=0;
          repeat
            Memory.Read(LineBuffer^,FRowSize);
            if TopDown then YY:=Y else  YY:=MaxHeight-Y;
            //LineDecodeBGR24(LineBuffer,YY,((Compression = BMP_COMPRESSION_BITF) and (FHeaderType > bmpht_WindowsV1)));
            DstLine:=GetScanLine(YY);
            SrcPtr24 := PGLZColorBGR_24(LineBuffer);
            For X:=0 to MaxWidth do
             begin
              SrcColor24:=PGLZColorBGR_24(SrcPtr24+X)^;
              DstColor.Red := SrcColor24.Red;
              DstColor.Green := SrcColor24.Green;
              DstColor.Blue := SrcColor24.Blue;
              DstColor.Alpha:=255;
              DstLine^:=DstColor;
              //Inc(SrcPtr24);
              Inc(DstLine);
            end;
 
            Inc(Y);
          Until (Y>MaxHeight);
        Finally
          ReAllocMem(LineBuffer, 0);
          FreeMem(LineBuffer);
          LineBuffer:=nil;
        end;
      end;
    end;
    pf32Bits:  // Pas de compression, formats couleurs suivant "BitField" sinon format couleur par defaut BGRA
    begin
      LineBuffer:=nil;
      ReallocMem(LineBuffer,FRowSize);
      Try
        Memory.Flush;
        Y:=0;
        //DstColor.Alpha:= 255;
        repeat
          Memory.Read(LineBuffer^,FRowSize);
          if TopDown then YY:=Y else  YY:=MaxHeight-Y;
          DstLine:=GetScanLine(YY);
          SrcPtr := PLongWord(LineBuffer);
          For X:=0 to MaxWidth do
          begin
            SrcColor:=SrcPtr^;
            DstColor := ConvertBitFieldsToGLZColor(RawImage.Description.BitFields, SrcColor);
            FIgnoreAlpha := FIgnoreAlpha and (DstColor.alpha = 0);
            DstLine^:= DstColor;
            Inc(SrcPtr);
            Inc(DstLine);
          end;
          Inc(Y);
        Until (Y>MaxHeight);
      Finally
        //FreeAndNil(LineBuffer) provoque un SIGSEGV que je ne comprend pas
        ReAllocMem(LineBuffer, 0);
        FreeMem(LineBuffer);
        LineBuffer:=nil;
      end;
 
      // Dans le cas ou tous les pixels sont transparent
     If FIgnoreAlpha then
      begin
        GLobalLogger.Log('NO ALPHA SUPPORT =  OPAQUE');
        RawImage.Description.HasAlpha:=False;
        With RawImage.Description.BitFields do
        begin
         AlphaSize:=0;
        end;
      end else PreMultiplyAlpha;
    end;
  end;
end;
Ensuite j'ai vérifiés avec les logs générés mais je ne vois rien. sauf sur la fin. Mais je n'arrive pas à trouver mon erreur.

Les deux fichiers BMP sont de dimension 512x512. les données sont donc alignées par rapport au Tampon, donc pas de coupure dans les lignes lorsqu'elle sont lues grâce au Memory.Flush.
Sans Memory.Flush le résultat est le même crash avec le 24bit.

extrait du log du fichier 32Bit

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
[STATUS]   [ 21/06/2017 16:20:34 ] Start Logging project2_32-i386.exe
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Create depuis TStream
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Create
[NOTICE]   [ 16:20:58 ] Taille du tampon par defaut :  BufferDefaultSize = 65536
[NOTICE]   [ 16:20:58 ] Taille du Stream :  StreamSize = 1048646
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 0
[NOTICE]   [ 16:20:58 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 0
[STATUS]  Position dans le Tampon : BufferPosition = 0
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 0
[STATUS]  Loading Stream Buffer : 65536
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 1048646
[NOTICE]   [ 16:20:58 ] Initialisation du tampon :  BufferSize = 65536
[NOTICE]   [ 16:20:58 ] Deplacement dans le stream  :  StreamViewStart = 0
[NOTICE]   [ 16:20:58 ] Données copiées depuis stream vers le tampon :  BufferSize = 65536
[STATUS]  Reste dans le stream : StreamBytesLeft = 983110
[STATUS]  StreamViewLength = 65536
[STATUS]  StreamViewEnd = 65535
[STATUS]  Lecture du tampon à la position = 0 Count = 14
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 65522
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 65518
[STATUS]  Lecture du tampon à la position = 18 Count = 52
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 65466
[STATUS]  gapSize1 = 0
[STATUS]  Read BitCount = 32
[STATUS]  Compression = BitField
[STATUS]  BitCount = 32
[STATUS]  Red Shift = 24
[STATUS]  Green Shift = 16
[STATUS]  Blue Shift = 8
[STATUS]  Alpha Shift = 0
[STATUS]  Red Size = 8
[STATUS]  Green Size = 8
[STATUS]  Blue Size = 8
[STATUS]  Alpha Size = 8
[STATUS]  BitFields Size = 16
[NOTICE]   [ 16:20:58 ] Vide et reinitialise le tampon à la position : 70
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 0
[NOTICE]   [ 16:20:58 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 70
[STATUS]  Position dans le Tampon : BufferPosition = 0
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 70
[STATUS]  Loading Stream Buffer : 65536
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 1048576
[NOTICE]   [ 16:20:58 ] Deplacement dans le stream  :  StreamViewStart = 70
[NOTICE]   [ 16:20:58 ] Données copiées depuis stream vers le tampon :  BufferSize = 65536
[STATUS]  Reste dans le stream : StreamBytesLeft = 983040
[STATUS]  StreamViewLength = 65536
[STATUS]  StreamViewEnd = 65605
[STATUS]  Lecture du tampon à la position = 0 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 63488
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 63488
[STATUS]  Lecture du tampon à la position = 2048 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 61440
----------------------------------------------------------------------
...
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 2048
[STATUS]  Lecture du tampon à la position = 63488 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 0
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 0
[NOTICE]   [ 16:20:58 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 917574
[STATUS]  Position dans le Tampon : BufferPosition = 65536
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 983110
[STATUS]  Loading Stream Buffer : 65536
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 65536
[NOTICE]   [ 16:20:58 ] Deplacement dans le stream  :  StreamViewStart = 983110
[NOTICE]   [ 16:20:58 ] Données copiées depuis stream vers le tampon :  BufferSize = 65536
[STATUS]  Reste dans le stream : StreamBytesLeft = 0
[STATUS]  StreamViewLength = 65536
[STATUS]  StreamViewEnd = 1048645
[STATUS]  Lecture du tampon à la position = 0 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 63488
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 63488
[STATUS]  Lecture du tampon à la position = 2048 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 61440
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 61440
[STATUS]  Lecture du tampon à la position = 4096 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 59392
----------------------------------------------------------------------
...
 
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 4096
[STATUS]  Lecture du tampon à la position = 61440 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 2048
----------------------------------------------------------------------
[NOTICE]   [ 16:20:58 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 2048
[STATUS]  Lecture du tampon à la position = 63488 Count = 2048
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 0
Le log du fichier 24bit

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
[STATUS]   [ 21/06/2017 16:22:48 ] Start Logging project2_32-i386.exe
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Create depuis TStream
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Create
[NOTICE]   [ 16:23:23 ] Taille du tampon par defaut :  BufferDefaultSize = 65536
[NOTICE]   [ 16:23:23 ] Taille du Stream :  StreamSize = 786486
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 0
[NOTICE]   [ 16:23:23 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 0
[STATUS]  Position dans le Tampon : BufferPosition = 0
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 0
[STATUS]  Loading Stream Buffer : 65536
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 786486
[NOTICE]   [ 16:23:23 ] Initialisation du tampon :  BufferSize = 65536
[NOTICE]   [ 16:23:23 ] Deplacement dans le stream  :  StreamViewStart = 0
[NOTICE]   [ 16:23:23 ] Données copiées depuis stream vers le tampon :  BufferSize = 65536
[STATUS]  Reste dans le stream : StreamBytesLeft = 720950
[STATUS]  StreamViewLength = 65536
[STATUS]  StreamViewEnd = 65535
[STATUS]  Lecture du tampon à la position = 0 Count = 14
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 65522
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 65518
[STATUS]  Lecture du tampon à la position = 18 Count = 36
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 65482
[STATUS]  gapSize1 = 0
[STATUS]  Read BitCount = 24
[STATUS]  Red Shift = 16
[STATUS]  Green Shift = 8
[STATUS]  Blue Shift = 0
[STATUS]  Alpha Shift = 0
[STATUS]  Red Size = 8
[STATUS]  Green Size = 8
[STATUS]  Blue Size = 8
[STATUS]  Alpha Size = 0
[STATUS]  BitFields Size = 12
[NOTICE]   [ 16:23:23 ] --> Decode Image Data = 511x511
[NOTICE]   [ 16:23:23 ] Vide et reinitialise le tampon à la position : 54
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 0
[NOTICE]   [ 16:23:23 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 54
[STATUS]  Position dans le Tampon : BufferPosition = 0
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 54
[STATUS]  Loading Stream Buffer : 65536
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 786432
[NOTICE]   [ 16:23:23 ] Deplacement dans le stream  :  StreamViewStart = 54
[NOTICE]   [ 16:23:23 ] Données copiées depuis stream vers le tampon :  BufferSize = 65536
[STATUS]  Reste dans le stream : StreamBytesLeft = 720896
[STATUS]  StreamViewLength = 65536
[STATUS]  StreamViewEnd = 65589
[STATUS]  Lecture du tampon à la position = 0 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 64000
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 64000
[STATUS]  Lecture du tampon à la position = 1536 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 62464
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 62464
[STATUS]  Lecture du tampon à la position = 3072 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 60928
----------------------------------------------------------------------
...
 
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 4096
[STATUS]  Lecture du tampon à la position = 61440 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 2560
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 2560
[STATUS]  Lecture du tampon à la position = 62976 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 1024
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 1024
[NOTICE]   [ 16:23:23 ] Pas assez de données dans le tampon, reste BufferBytesLeft = 1024
[NOTICE]   [ 16:23:23 ]   Nombre d'octets à lire : Count = 1536
[STATUS]    Position dans le Tampon : BufferPosition = 64512
[STATUS]    Différence = 512
[STATUS]    Position dans le stream : StreamViewStart = 709686
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 774198
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 6144
[NOTICE]   [ 16:23:23 ] Deplacement dans le stream  :  StreamViewStart = 774198
[NOTICE]   [ 16:23:23 ] Données copiées depuis stream vers le tampon :  BufferSize = 6144
[STATUS]  Reste dans le stream : StreamBytesLeft = 0
[STATUS]  StreamViewLength = 6144
[STATUS]  StreamViewEnd = 780341
[STATUS]  Lecture du tampon à la position = 0 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 4608
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 4608
[STATUS]  Lecture du tampon à la position = 1536 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 3072
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 3072
[STATUS]  Lecture du tampon à la position = 3072 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 1536
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 1536
[STATUS]  Lecture du tampon à la position = 4608 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = 0
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = 0
[NOTICE]   [ 16:23:23 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 774198
[STATUS]  Position dans le Tampon : BufferPosition = 6144
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 780342
[STATUS]  Loading Stream Buffer : 6144
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 0
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer : Fin des données atteinte
[STATUS]  Lecture du tampon à la position = 0 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = -1536
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = -1536
[NOTICE]   [ 16:23:23 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 780342
[STATUS]  Position dans le Tampon : BufferPosition = 1536
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 781878
[STATUS]  Loading Stream Buffer : 6144
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 0
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer : Fin des données atteinte
[STATUS]  Lecture du tampon à la position = 0 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = -1536
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = -1536
[NOTICE]   [ 16:23:23 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 781878
[STATUS]  Position dans le Tampon : BufferPosition = 1536
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 783414
[STATUS]  Loading Stream Buffer : 6144
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 0
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer : Fin des données atteinte
[STATUS]  Lecture du tampon à la position = 0 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = -1536
----------------------------------------------------------------------
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.Read
[STATUS]  Reste dans le tampon : BufferBytesLeft = -1536
[NOTICE]   [ 16:23:23 ] Fin du Tampon atteinte ou 1ere fois
[STATUS]  Position dans le stream : StreamViewStart = 783414
[STATUS]  Position dans le Tampon : BufferPosition = 1536
[STATUS]  Nouvelle Position dans le stream : StreamViewStart = 784950
[STATUS]  Loading Stream Buffer : 6144
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer
[STATUS]  Reste dans le stream : StreamBytesLeft = 0
[NOTICE]   [ 16:23:23 ] TGLZCustomBufferedStream.LoadBuffer : Fin des données atteinte
[STATUS]  Lecture du tampon à la position = 0 Count = 1536
[STATUS]  Reste dans le tampon apres lecture : BufferBytesLeft = -1536
Vous auriez une idée, ou sont passé ces données ?
Des erreurs dans mon codes ? (j'ai les yeux qui me piquent, je vois plus rien à force)
Des questions, par rapport à tout ça ?

Merci d'avance