Données qui se perdent lors d'un chargement, avec accès par tampon dans un Stream

**BeanzMaster** · 21/06/2017, 16h28

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 : 340
Taille : 68,1 Ko

Nom : 2017-06-21_153857.jpg
Affichages : 340
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 : 231
Taille : 66,2 Ko

Nom : 2017-06-21_154336.jpg
Affichages : 231
Taille : 66,2 Ko

Nom : 2017-06-21_154514.jpg
Affichages : 246
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

**Jipété** · 21/06/2017, 17h48

Salut,

Envoyé par BeanzMaster

Jusque là pas trop de soucis je charge sans problème les fichiers BMP 32bits

Nom : 2017-06-21_153857.jpg
Affichages : 340
Taille : 68,1 Ko

* A Gauche TBitmap, à droite ma solution "TGLZBitmap"

Beaucoup trooooooooop de code et de logs pour pouvoir se faire une idée.

Par contre, la chose qui m'a sautée aux yeux c'est dans la première image, cette pauvre Lena toute sombre, confirmée par le Colorpicker qui montre bien que les 3 canaux perdent de la valeur : c'est quoi ce bazar ?

Ensuite, il me semblait avoir dit que SetSize ne faisait pas que ce que son nom indique, mais aussi tout un tas de choses : va voir dans le code...
À chaque fois que je trouve un SetSize dans mes vieux codes, je remplace systématiquement par bmp.Width := bmpWidth; bmp.Height := bmpHeight;.

Commence par revoir ces points, et on en reparle...

**BeanzMaster** · 21/06/2017, 22h26

Envoyé par Jipété

Salut,

Beaucoup trooooooooop de code et de logs pour pouvoir se faire une idée.

Parles pour toi !

Envoyé par Jipété

Par contre, la chose qui m'a sautée aux yeux c'est dans la première image, cette pauvre Lena toute sombre, confirmée par le Colorpicker qui montre bien que les 3 canaux perdent de la valeur : c'est quoi ce bazar ?

De quoi tu parles ? de 1 c'est une copie d'ecran, de 2 la taille est reduite à 50% de 3 c'est compressé en JPEG.
Si c'est par rapport au fichier 32Bits coté droit, normal , le fond du canvas est gris tres foncé et l'image est affiché avec transparence (le BMP provient de la manip avec Gimp que tu avais décrite dans ton post)

Envoyé par Jipété

Ensuite, il me semblait avoir dit que SetSize ne faisait pas que ce que son nom indique, mais aussi tout un tas de choses : va voir dans le code...
À chaque fois que je trouve un SetSize dans mes vieux codes, je remplace systématiquement par bmp.Width := bmpWidth; bmp.Height := bmpHeight;.

Rien à voir avec TBITMAP ici le SetSize c'est MA FONCTION de MA SOLUTION

Envoyé par Jipété

Commence par revoir ces points, et on en reparle...

C'est fait, alors une idée ?

**Jipété** · 21/06/2017, 22h44

Envoyé par BeanzMaster

De quoi tu parles ? de 1 c'est une copie d'écran, de 2 la taille est réduite à 50% de 3 c'est compressé en JPEG

1-) Je parle de ça :
Nom : yeux_de_Lena.jpg
Affichages : 205
Taille : 9,7 Ko

copie d'écran de ta copie d'écran.
Colorpicker sur le blanc de l'œil droit de Lena, donc celui qui à gauche pour nous, moyenne sur 9 pixels, image de gauche : 201 160 162 et image de droite : 172 139 139, si tu ne vois pas de différences, si tu ne vois pas que l'image de droite est plus sombre (environ 30 points d'écart pour le rouge, environ 20 pour les deux autres, c'est énorme !), tu devrais consulter.

2-) Qu'est-ce que ça peux bien foutre que ça soit réduit de 50 % ? Les différences sont quand même là.

3-) Qu'est-ce que ça peut bien foutre que ça soit compressé en JPEG, ou en PNG, ou pas compressé en BMP si le même traitement est appliqué aux deux images ? Les différences sont quand même là.

Envoyé par BeanzMaster

Rien à voir avec TBITMAP ici le SetSize c'est MA FONCTION de MA SOLUTION

Change-lui le nom car tu induis les lecteurs en erreur...

Envoyé par BeanzMaster

C'est fait, alors une idée ?

~~Aucune pour le moment.~~ Post arrivé pendant que je rédigeais le mien.

Envoyé par BeanzMaster

Le truc de super bizarre c'est que c'est le début des données de l'image (environ 3 Bloques de 64ko qui s'affichent en blanc.

Moi je vois du blanc pour l'image de gauche (24 bits) en bas. Donc l'image commence en bas, donc balayage Bottom2Top, or dans la zone "Extra" du log, on peut lire "Ordre des lignes : de haut en bas" !

Ou c'est moi qui ne comprends pas, ou il y a un truc, là...

Par ailleurs, dans le premier post tu as écrit :

A droite le fichier 32Bits afficher par dessus avec la transparence

affiché par-dessus quoi ? Tu affiches deux images l'une sur l'autre ?

Envoyé par BeanzMaster

Le fichier fait 512x512 on lit les pixels en x et y de 0 à 512-1.

Si ça se trouve ton piège est ici !
(d'ailleurs c'est pour ça que bien souvent j'utilise h et w, c'est plus parlant pour moi).

On balaie horizontalement des pixels (24 ou 32 bits pour faire simple, et pas oublier le padding si 24), mais on parcourt verticalement des lignes, sans notion de pixels !

**BeanzMaster** · 21/06/2017, 22h50

Envoyé par Jipété

1-) Bla bla bla bla.

T'as répondu trop vite

**BeanzMaster** · 21/06/2017, 23h46

Je viens de faire une petite recherche je suis tombé la dessus https://stackoverflow.com/questions/...er-disk-access

Envoyé par BeanzMaster

Le seul problème ici que je connaisse, serait si je désire charger un bloque de mémoire en une fois et que sa taille soit supérieure à celle du tampon (Buffer/BufferSize) de ma classe. Sinon plus d'idées.

J'ai donc modifié la fonction TGLZCustomBufferedStream.Read comme ceci

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
function TGLZCustomBufferedStream.Read(var aBuffer; Count: Longint): Longint;
var
  NumOfBytesToCopy, NumOfBytesLeft, NumOfBytesRead: Longint;
  CachePtr, BufferPtr: PByte;
begin
 
    Result := 0;
    NumOfBytesLeft := Count;
    BufferPtr := @aBuffer;
    while NumOfBytesLeft>0 do
    begin
      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;
 
        GlobalLogger.LogStatus('Lecture du tampon à la position = '+inttostr(BufferPosition)+' Count = '+inttostr(Count));
 
        // On copie les données
        NumOfBytesToCopy := Min(BufferSize-BufferPosition, NumOfBytesLeft);
        CachePtr := Buffer;
        Inc(CachePtr, BufferPosition);
 
        Move(CachePtr^, BufferPtr^, NumOfBytesToCopy);
 
        inc(Result, NumOfBytesToCopy);
        inc(BufferPosition, NumOfBytesToCopy);
        inc(BufferPtr, NumOfBytesToCopy);
 
        // On met à jour les marqueur de notre tampon
 
        Inc(BufferBytesRead,NumOfBytesToCopy);
        Dec(BufferBytesLeft,NumOfBytesToCopy);
        Dec(NumOfBytesLeft,NumOfBytesToCopy);
        GlobalLogger.LogStatus('Reste dans le tampon apres lecture : BufferBytesLeft = '+inttostr(BufferBytesLeft));
      end;
 
    end;
end;

Resultat idem, pas de probleme avec le 32bits, avec le 24bits grosse ligne blanche

Leur problème viendrait de ou là dans :

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
 
 
Type
    TGLZColorBGR_24 =  record
      blue, green, red : byte;
    end;
    PGLZColorBGR_24 = ^TGLZColorBGR_24; 
 
    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;

[EDIT] : Le code des fonctions SetSize, ComputScanlineLUT, GetScanLine au cas ou :

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
 
 
Type TGLZColor32Rec = packed record
      case Longint of
        0 : (AsInteger : TGLZColor32);
        1 : (Blue,  Green, Red, Alpha : byte);
        2 : (Channels: array[0..3] of Byte);
        3 : (Color24Rec: TGLZColor24Rec);
 
    end;
    PGLZColor32Rec = ^TGLZColor32Rec;
    TGLZColor = TGLZColor32Rec;  
    PGLZColor = ^TGLZColor;  
 
FSurfaceBuffer : PByte;
 
procedure TGLZCustomBitmap.SetSize(NewWidth, NewHeight : Integer);
begin
 
 FWidth:=NewWidth;
 FHeight:=NewHeight;
 FSize:=(NewWidth*NewHeight)*4;//*sizeof(TGLZColor); //FRawImage.Description.PixelSize;
 
 FMaxWidth:=FWidth-1;
 FMaxHeight:=FHeight-1;
 FMaxSize:=(FWidth*FHeight)-1;
 FCenterX:=(FWidth shr 1)-1;
 FCenterY:=(FHeight shr 1)-1;
 if FSurfaceBuffer<>nil then
 begin
  ReAllocMem(FSurfaceBuffer, 0);
  FreeMem(FSurfaceBuffer);
  FSurfaceBuffer:=nil;
 end;
 ReallocMem(FSurfaceBuffer,FSize);
 
 setLength(FScanLineLUT,FHeight);
 ComputeScanLineLUT;
 
//    updateProperties;
//    DoOnChange(self);
end;
 
procedure TGLZCustomBitmap.ComputeScanLineLUT;
Var
  y:Integer;
begin
  if (FWidth=0) or (FHeight=0) then  Exit;
  For y:=0 to FMaxHeight do
  begin
    FScanLineLUT[y]:=y*FWidth*4;//*Sizeof(TGLZColor);
  end;
end; 
 
function TGLZCustomBitmap.getScanLine(Row:Integer):PGLZColor;
Var
  yy:integer;
begin
  yy:=FScanLineLUT[Row];
  result:=PGLZColor(FSurfaceBuffer+YY);
end;

------------------------------------

Je sèche, c'est certainement sous mon nez, mais arf

!

et en plus, je n'ai plus de cheveux à m'arracher !

. Je comprend vraiment pas.
Ce qui me nargue le plus, c'est qu'avec mon ancienne classe toute pourrie il n'y avait pas de problème : "TGLZCustomBufferedStream = Class"
Passer par des TStream spécifiques est la meilleur solution pour me rendre là ou je désire allez avec mon projet. Et cela, sera beaucoup plus rapide pour les prochaines étapes que je me suis fixé.

**anapurna** · 21/06/2017, 17h55

salut

petite question bete ^^
ton maxwidth et maxheigth corresponde à la taille de ton image ?
si c'est le cas ton incrément n'est pas correcte
tu dois te déplacer de la valeur d'un pixel donc 32 bits

**BeanzMaster** · 21/06/2017, 22h40

Envoyé par anapurna

salut

petite question bete ^^
ton maxwidth et maxheigth corresponde à la taille de ton image ?
si c'est le cas ton incrément n'est pas correcte
tu dois te déplacer de la valeur d'un pixel donc 32 bits

Le maxWidth et le maxHeight correspondent à la largeur et hauteur du fichier -1
Le fichier fait 512x512 on lit les pixels en x et y de 0 à 512-1. Donc ici 511x511
En plus je prend en compte la padding de fin de ligne si il existe lors du chargement de la "ligne" --> Memory.Read,LineBuffer0^,FRowSize);
Le problème ne vient pas de là. De plus si c'etait çà, il y aurais également des erreurs avec le BMP 32bits je pense.

Le seul problème ici que je connaisse, serait si je désire charger un bloque de mémoire en une fois et que sa taille soit supérieure à celle du tampon (Buffer/BufferSize) de ma classe. Sinon plus d'idées.

Le truc de super bizarre c'est que c'est le début des données de l'image (environ 3 Bloques de 64ko qui s'affiche en blanc.Si je n'aurais rien qui s'affiche cela serait plus simple, mais là je patauge. Un mauvais adressage ? Est ce le fait que je passe par un "record" pour les données 24bits ? Pourquoi le reste de l'image est il affiché correctement ?

Merci

Données qui se perdent lors d'un chargement, avec accès par tampon dans un Stream [Lazarus]

Lazarus Pascal

Vue hybride

Discussions similaires

Partager

Partager