Discussion :

[BeanzMaster]

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


* 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


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é]

Salut,

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


* 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...

[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

[BeanzMaster]

Salut,


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

Parles pour toi !

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)

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

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

C'est fait, alors une idée ?

[BeanzMaster]

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

[Jipété]

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 :
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à.

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...

C'est fait, alors une idée ?

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

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 ?

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]

1-) Bla bla bla bla.

T'as répondu trop vite

[BeanzMaster]

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

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é.

[Jipété]

Salut,

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

Très intéressant, mais ça n'a rien à voir avec ton histoire


Sinon, suite à tes postages de codes, je ne comprends pas la différence entre le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Type
    TGLZColorBGR_24 =  record
      blue, green, red : byte;
    end;
    PGLZColorBGR_24 = ^TGLZColorBGR_24;

et le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
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;

Aucune similitude de nommage, ça laisse à penser qu'il peut y avoir d'autres types, planqués dans des coins, genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Type
    TGLZColorBGRA_32 =  record

ou Type TGLZColor24Rec = packed record qui existe, on le voit dans ta liste et ça, d'ailleurs, c'est surprenant, pour moi : ton 32bits peut se transformer en 24 ?

Autre chose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 FCenterX:=(FWidth shr 1)-1;
 FCenterY:=(FHeight shr 1)-1;

Mets des commentaires pour dire ce que ça fait ! Perso je ne m'en souviens jamais.

Ensuite,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
procedure TGLZCustomBitmap.ComputeScanLineLUT;
Var
  y:Integer;
begin
  if (FWidth=0) or (FHeight=0) then  Exit;
  For y:=0 to FMaxHeight do // manque pas un "-1" ici ?

Et dans ton

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Type
    TGLZColorBGR_24 =  record
...
            For X:=0 to MaxWidth do // manque pas un "-1" ici ?
...
// et surtout, pour ton histoire de ligne blanche :
repeat
...
Until (Y>MaxHeight);

ça serait pas plutôt Until (Y=MaxHeight); ou peut-être MaxHeight-1, à voir.


Je lis ça :

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

ça tombe bien, les réponses que j'apporte concernent le pf24, mais vu comment tu exposais le problème dans le post d'origine, on aurait dit que le 32 avait aussi un souci avec sa transparence, ça m'a tellement intrigué que j'ai écrit une question à laquelle tu n'as pas cru bon de répondre, à part ton "bla bla bla bla" qui n'apporte rien...

Et les différences de couleurs, tu t'es penché dessus ?

[anapurna]

salut

ouais c’était un peu confus ^^
bon on est d'accord c'est le 24 qui a des soucis et c'est normal l’incrément n'est pas le même entre ton FSurfaceBuffer (32 bits)
et LineBuffer (24 bits)

pour le 32 bits tu as de la chance que ce soit la même taille car ton parcourt ne fait pas la taille de ton buffer

refaisons l’algorithme en langage naturel

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
 
TansQue
  Je lit ma Ligne source (24)
  Je creer ma ligne de destination(32)
 
  Pour tout x entre 0 et largeur de mon image Faire 
    SrcColor:=SrcPtr^;
    // c'est un peut comme si tu faisait 
    (* SrcColor[X]:=SrcPtr[X];
       SrcColor[X+1]:=SrcPtr[X+1];
       SrcColor[X+N]:=SrcPtr[X+N]; // N Fin de ligne
   *) // en 32 ça fonctionne pas de changement de format
       // en 24 çà ne marche pas 
       // il faut gérer les deux incréments
  Fin Pour
Fin Tanque

autre chose de bizarre que j'ai vu dans tes différentes sources

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
 
function TGLZCustomBufferedStream.Read(var aBuffer; Count: Longint): Longint;
...
begin
   ...
    BufferPtr := @aBuffer;
    while NumOfBytesLeft>0 do
    begin
        // On copie les données
        CachePtr := Buffer; // ?? c'est quoi buffer
        Inc(CachePtr, BufferPosition);
		... 
      end;
   ...
    end;
end;

l'algo de transformation non optimisé serait de cette forme

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
 
  DestDatas,SrcDatas : Array of byte;
...
Begin
  ...
  SrcSizeImage  := height*width*3;// Calcul block data 24
  DestsizeImage := height*width*4;// Calcul block data 32
  SetLength(DestDatas,DestsizeImage);
  padding := width mod 4;
  largeur_24bits := width*3;//Taille Ligne 24 bits
  DestIndex := 0;
  SrcIndex   := 0 ;
  while SrcIndex < SrcSizeImage do
  begin
    DestDatas[DestIndex] := SrcDatas[SrcIndex];
    if( (0 <> padding) and (0 = ((SrcIndex+1) mod largeur_24bits) ) ) Then
    begin
      SrcIndex := SrcIndex + padding; 
      largeur_24bits := width*3+largeur_24bits+padding;
    end;
    Inc(DestIndex);
    if(0 = (DestIndex+1) mod 4) Then // on ajoute le 4ieme
    begin
      DestDatas[DestIndex] := $00;
      inc(DestIndex);
    end;
    SrcIndex:=SrcIndex+1;// on se decale de 1 dans le tableau source
  end;
  ...
end;

[BeanzMaster]

Bonjour Merci de votre aide.

Salut,


Très intéressant, mais ça n'a rien à voir avec ton histoire

Heu si,un peu je parle de Stream

Sinon, suite à tes postages de codes, je ne comprends pas la différence entre le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
Type
    TGLZColorBGR_24 =  record
      blue, green, red : byte;
    end;
    PGLZColorBGR_24 = ^TGLZColorBGR_24;

et le

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
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;

Aucune similitude de nommage, ça laisse à penser qu'il peut y avoir d'autres types, planqués dans des coins, genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Type
    TGLZColorBGRA_32 =  record

ou Type TGLZColor24Rec = packed record qui existe, on le voit dans ta liste et ça, d'ailleurs, c'est surprenant, pour moi : ton 32bits peut se transformer en 24 ?

C'est pas tout à fait ça, le truc c'est que tu peux avec TGLZColor32Rec lui assigner directement TGLZColor24Rec. (MaCouleur32.Color24Rec := MaCouleur24);
Cette structure permet d'accéder au valeurs de différentes manières. D'autres pourront surement mieux t'expliquer tout ça que moi.

Autre chose :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 FCenterX:=(FWidth shr 1)-1;
 FCenterY:=(FHeight shr 1)-1;

Mets des commentaires pour dire ce que ça fait ! Perso je ne m'en souviens jamais.

Ok, ça sera fait merci ,

Ensuite,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
procedure TGLZCustomBitmap.ComputeScanLineLUT;
Var
  y:Integer;
begin
  if (FWidth=0) or (FHeight=0) then  Exit;
  For y:=0 to FMaxHeight do // manque pas un "-1" ici ?

Et dans ton

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
Type
    TGLZColorBGR_24 =  record
...
            For X:=0 to MaxWidth do // manque pas un "-1" ici ?
...
// et surtout, pour ton histoire de ligne blanche :
repeat
...
Until (Y>MaxHeight);

ça serait pas plutôt Until (Y=MaxHeight); ou peut-être MaxHeight-1, à voir.

Non, il ne manque pas -1, regardes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
FMaxWidth:=FWidth-1;
FMaxHeight:=FHeight-1;
FMaxSize:=(FWidth*FHeight)-1;
FCenterX:=(FWidth shr 1)-1;
FCenterY:=(FHeight shr 1)-1;

Ces valeurs sont à utilisées lors des accès aux pixel vu que l'on part de 0. Ces valeurs sont pré-calculées, juste pour les performances

Je lis ça :
ça tombe bien, les réponses que j'apporte concernent le pf24, mais vu comment tu exposais le problème dans le post d'origine, on aurait dit que le 32 avait aussi un souci avec sa transparence, ça m'a tellement intrigué que j'ai écrit une question à laquelle tu n'as pas cru bon de répondre, à part ton "bla bla bla bla" qui n'apporte rien...

Et les différences de couleurs, tu t'es penché dessus ?

Nos posts se sont croisés. tu avais déja posté, alors que j'étais entrain de les modifiés. les réponses sont dedans.

Merci

salut

ouais c’était un peu confus ^^
bon on est d'accord c'est le 24 qui a des soucis et c'est normal l’incrément n'est pas le même entre ton FSurfaceBuffer (32 bits)
et LineBuffer (24 bits)

pour le 32 bits tu as de la chance que ce soit la même taille car ton parcourt ne fait pas la taille de ton buffer

Oui je l'avoue c'est confus,le code est plutôt imposant et il y a ici qu'un infime partie.

On est d'accord c'est le 24Bits. Et l’incrément est bien Différent PGLZColorBGR_24 (ou le 24Rec c'est pareil) pour le 24bits et pour le 32Bits Un LongWord.

Pour ce qui est d'avoir de la chance. Dans les 2 cas que je lise depuis le debut des données de l'image (Fonction Memory.Flush) ou sans et donc lecture de ligne non entière (c'est dur de s'exprimer clairement )
Le résultat est le même

refaisons l’algorithme en langage naturel

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
 
TansQue
  Je lit ma Ligne source (24)
  Je creer ma ligne de destination(32)
 
  Pour tout x entre 0 et largeur de mon image Faire 
    SrcColor:=SrcPtr^;
    // c'est un peut comme si tu faisait 
    (* SrcColor[X]:=SrcPtr[X];
       SrcColor[X+1]:=SrcPtr[X+1];
       SrcColor[X+N]:=SrcPtr[X+N]; // N Fin de ligne
   *) // en 32 ça fonctionne pas de changement de format
       // en 24 çà ne marche pas 
       // il faut gérer les deux incréments
  Fin Pour
Fin Tanque

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
 
TansQue
  Je lit ma Ligne source (24)  ==> Avec la padding si il y existe
  Je creer ma ligne de destination(32) ==> Je recupere l'adresse de la ligne dans mon "SurfaceBuffer" avec GetScanLine (c'est là ou je planque les pixels)
 
  Pour tout x entre 0 et largeur-1 de mon image Faire 
    SrcColor:=SrcPtr^;
    // c'est un peut comme si tu faisait==> Oui c'est pareil
    (* SrcColor[X]:=SrcPtr[X];
       SrcColor[X+1]:=SrcPtr[X+1];
       SrcColor[X+N]:=SrcPtr[X+N]; // N Fin de ligne
   *) // en 32 ça fonctionne pas de changement de format ==> Uniquement si decodage compression BitField dans l'en-tête
       // en 24 çà ne marche pas ==> Oui c'est ça
       // il faut gérer les deux incréments ==>C'est FPC qui se charge de çà PGLZColor(LineBuffer+X)^ et Inc(DstLine)
  Fin Pour
Fin Tanque

autre chose de bizarre que j'ai vu dans tes différentes sources

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
 
function TGLZCustomBufferedStream.Read(var aBuffer; Count: Longint): Longint;
...
begin
   ...
    BufferPtr := @aBuffer;
    while NumOfBytesLeft>0 do
    begin
        // On copie les données
        CachePtr := Buffer; // ?? c'est quoi buffer
        Inc(CachePtr, BufferPosition);
		... 
      end;
   ...
    end;
end;

?? c'est quoi buffer. C'est le tampon ou sont chargé les donnée du Stream cf Class TGLZCustomBufferedStream

l'algo de transformation non optimisé serait de cette forme ....

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
 
  DestDatas,SrcDatas : Array of byte;  //Pbyte dans mon cas
...
Begin
  ...
  SrcSizeImage  := height*width*3;// Calcul block data 24 ==>  + Padding par ligne 
  DestsizeImage := height*width*4;// Calcul block data 32 ==> Oui
  SetLength(DestDatas,DestsizeImage);  // 
  padding := width mod 4;
  largeur_24bits := width*3;//Taille Ligne 24 bits 
  DestIndex := 0;
  SrcIndex   := 0 ;
  while SrcIndex < SrcSizeImage do
  begin
    DestDatas[DestIndex] := SrcDatas[SrcIndex];
    if( (0 <> padding) and (0 = ((SrcIndex+1) mod largeur_24bits) ) ) Then
    begin
      SrcIndex := SrcIndex + padding; 
      largeur_24bits := width*3+largeur_24bits+padding;
    end;
    Inc(DestIndex);
    if(0 = (DestIndex+1) mod 4) Then // on ajoute le 4ieme
    begin
      DestDatas[DestIndex] := $00;
      inc(DestIndex);
    end;
    SrcIndex:=SrcIndex+1;// on se decale de 1 dans le tableau source
  end;
  ...
end;

Je vais regarder, mais vu que je lit les donnée avec le padding et que la lecture du LineBuffer est bornée par le "For X:=0 to MaxHeight" je ne lis jamais le padding.

Piouf sinon j'ai fait quelques tests. Premierement j'ai enregistré les données de l'image dans un fichier et je l'ai comparé avec le fichier BMP d'origine.
IDENTIQUE !!!



J'ai également sortie le costume du debugger. Je vois rien de bizarre




Bon me reste plus que ma procedure d'affichage mais je vois pas ce qui cloche

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
 
procedure DrawGLZBitmapToCanvas(ABmp:TGLZBitmap; Canvas: TCanvas;R:Types.TRect; Const Opaque:Boolean=true;Const ClearBk : Boolean=false);
{$IFDEF WINDOWS}
Var
  BitsInfo: TBitmapInfo;
  //RW,RH : Integer;
  hBmp: HBitmap;
  memDC: HDC;
  hOld: HGDIOBJ;
  BitsPtr: Pointer;
  PixPtr:PGLZColor;
  DataSize: integer;
  bf: TBlendFunction;
Begin
 
 With BitsInfo.bmiHeader Do
 Begin
   biSize := SizeOf(TBitmapInfoHeader);
   biWidth :=ABmp.Width;
   biHeight := -ABmp.Height; { Note: Une hauteur negative signifie que la lecture d'une ligne se fait de bas en haut }
   biPlanes := 1;
   biBitCount := 32; //On Affiche en 32bits (normalent prendre donnée depuis "Device"
   biCompression := BI_RGB;
   biSizeImage :=  (ABmp.Width*ABmp.Height)*4;
   biXPelsPerMeter := 0;
   biYPelsPerMeter := 0;
   biClrUsed := 0;
   biClrImportant := 0;
  End;
 BitsPtr:=nil;
 
   // On doit inverser notre d'affichage de haut en bas à de bas en haut
   DataSize:=ABmp.Width*4; //((BitsInfo.bmiHeader.biWidth * BitsInfo.bmiHeader.biBitCount + 31 ) shr 5 ) shl 2;
   DataSize:=DataSize * -BitsInfo.bmiHeader.biHeight;
 
   memDC := CreateCompatibleDC(Canvas.Handle);
   hBmp := Windows.CreateDIBSection(Canvas.Handle, BitsInfo, DIB_RGB_COLORS,BitsPtr,0,0);
 
   hOld  := SelectObject(memDC, hBMp);
 
   Canvas.Lock;
   if ClearBk then Canvas.Clear;
   Move(aBmp.getScanline(0)^, BitsPtr^, DataSize);
 
  if ABmp.RawImage.Description.HasAlpha or not(opaque) then
  begin
    With bf do
    begin
     BlendOp := AC_SRC_OVER;
     BlendFlags := 0;
     SourceConstantAlpha :=$FF;
     AlphaFormat := AC_SRC_ALPHA;
    end;
 
    Win32Extra.AlphaBlend(Canvas.Handle,
      R.Left, R.Top, (R.Right-R.Left), (R.Bottom-R.Top),
      memDC,
      0, 0, aBmp.Width, aBmp.Height,bf);
 
  end
  else
  begin
 
    Windows.StretchDIBits(Canvas.Handle,
                  R.Left, R.Top, (R.Right-R.Left), (R.Bottom-R.Top),
                  0, 0, aBmp.Width, aBmp.Height, BitsPtr, //PByte(ABmp.GetSurfaceBuffer)
                  BitsInfo, DIB_RGB_COLORS, SRCCOPY);
  end;
  Canvas.Unlock;
  SelectObject(MemDC, hOld);
  DeleteDC(memDC);
  DeleteObject(hBMp);
 
End;
{$ENDIF}

Je vais réessayé à partir d'une simple classe non hérité de TStream comparé avec mon ancien code. Mais la je ne comprend vraiment pas, et n'arrive pas à voir ou est le problème.

[anapurna]

resalut


pour faire plus simple avec ton sources et les pointer voila comment faire pour les pointeur

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
 
procedure BGR24ToRGBA32(PSrce,PDest:pointer;PixelCount:Integer;Alpha:Byte);
begin
  while PixelCount>0 do
  begin
     PChar(PDest)[0]:=PChar(PSrce)[2];
     PChar(PDest)[1]:=PChar(PSrce)[1];
     PChar(PDest)[2]:=PChar(PSrce)[0];
     PChar(PDest)[3]:=chr(Alpha);
     Pdest:= Pointer(Integer(Dest)+4);  // 4 Octets = 32 bits
     PSrce :=Pointer(Integer(PSrce)+3);// 3 Octets = 24 bits
     Dec(PixelCount);
  end;
end;
 
procedure BGR32ToRGBA32(PSrce,PDest:pointer;PixelCount:Integer);
begin
  while PixelCount>0 do
   begin
      PChar(PDest)[0]:=PChar(PSrce)[2];
      PChar(PDest)[1]:=PChar(PSrce)[1];
      PChar(PDest)[2]:=PChar(PSrce)[0];
      PChar(PDest)[3]:=PChar(PSrce)[3];
      PDest :=Pointer(Integer(PDest)+4);  // 4 Octets = 32 bits
      PSrce :=Pointer(Integer(PSrce)+4);   // 4 Octets = 32 bits
      Dec(PixelCount);
   end;
end;

[BeanzMaster]

resalut


pour faire plus simple avec ton sources et les pointer voila comment faire pour les pointeur

Salut, j'ai testé avec ton exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
procedure BGR24ToBGRA32(PSrce,PDest:pointer;PixelCount:Integer;Alpha:Byte);
  begin
    while PixelCount>0 do
    begin
       PChar(PDest)[0]:=PChar(PSrce)[0];
       PChar(PDest)[1]:=PChar(PSrce)[1];
       PChar(PDest)[2]:=PChar(PSrce)[2];
       PChar(PDest)[3]:=chr(Alpha);
       Pdest:= Pointer(PtrUInt(PDest)+4);  // 4 Octets = 32 bits //PtrUInt() ==> Code portable Integer() ==> réservé Windows
       PSrce :=Pointer(PtrUInt(PSrce)+3);// 3 Octets = 24 bits
       Dec(PixelCount);
    end;
  end;

Idem toujours cette grosse ligne blanche.

[anapurna]

salut

en amenageant le code ça donne quoi ?

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
 
ZeroMemory(@BitsInfo, sizeof(BITMAPINFO));
  With BitsInfo.bmiHeader Do
  Begin
    biSize := SizeOf(TBitmapInfoHeader);
    biWidth :=   ABmp.Width;
    biHeight := -ABmp.Height; { Note: Une hauteur negative signifie que la lecture d'une ligne se fait de bas en haut }
    biPlanes := 1;
    biBitCount := 32; //On Affiche en 32bits (normalent prendre donnée depuis "Device"
    biCompression := BI_RGB;
    biSizeImage :=  (ABmp.Width*ABmp.Height)*4;// Pf32
  End;
 
   BitsPtr:=nil;
   DataSize:=BitsInfo.bmiHeader.biSizeImage;
 
   memDC := CreateCompatibleDC(Canvas.Handle);
 
   Move(aBmp.getScanline(0)^, BitsPtr^, DataSize);
 
   if ABmp.RawImage.Description.HasAlpha or not(opaque) then
   begin
      hBmp := Windows.CreateDIBSection(Canvas.Handle, BitsInfo, DIB_RGB_COLORS,BitsPtr,0,0);
      hOld  := SelectObject(memDC, hBMp);
   end;
 
   Canvas.Lock;
   if ClearBk then
     Canvas.Clear;
 
   if ABmp.RawImage.Description.HasAlpha or not(opaque) then
   begin
      With bf do
      begin
        BlendOp := AC_SRC_OVER;
        BlendFlags := 0;
        SourceConstantAlpha :=$FF;
        AlphaFormat := AC_SRC_ALPHA;
      end;
 
    Win32Extra.AlphaBlend(Canvas.Handle, R.Left, R.Top, aBmp.Width, aBmp.Height
    ,memDC,0,0,aBmp.Width, aBmp.Height,bf);
   end
   else
   begin
     Windows.StretchDIBits(Canvas.Handle, R.Left, R.Top,aBmp.Width, aBmp.Height,
      0, 0, aBmp.Width, aBmp.Height, BitsPtr, BitsInfo, DIB_RGB_COLORS, SRCCOPY);
   end;

[Jipété]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
  
    biHeight := -ABmp.Height; { Note: Une hauteur négative signifie que la lecture d'une ligne se fait de bas en haut }

Euh, ça sort d'où, ça ?
Extrait du BitmapInfoHeader, où l'on constate que c'est l'inverse :



Ensuite, tu parles de grosse ligne blanche ; c'est l'énorme rectangle qui fait le quart de l'image ? Ce n'est plus une grosse ligne (moi je m'attendais à un machin de 3 ou 4 pixels), c'est le quart de l'image ! Donc on ne comprend pas.

Enfin, j'ai zoomé très fort sur l'image récupérée, ça donne ça :


et on se rend compte qu'il y a un foutoir de lignes plus ou moins sombres et difficilement explicables.

Enfin, le rectangle de sélection matérialisé par les pointillés fait 63 de haut : s'il faisait 64 ça serait bien une embrouille 32 versus 24, mais peut-être faut-il prendre en compte une ligne grise pour arriver à 64 ?

Pour y voir clair, tu devrais travailler avec du bitmap et des couleurs unies, genre ce style d'images :



Et présente-nous une seule image, celle avec le défaut, mais non réduite car sinon, comment faire la différence entre ta compression et celle du logiciel d'exportation pour publication ? Le coup des lignes sombres, je ne sais pas d'où elles sortent...

[BeanzMaster]

Euh, ça sort d'où, ça ?
Extrait du BitmapInfoHeader, où l'on constate que c'est l'inverse :

Source Microsoft
[EDIT] Ici c'est pour l'affichage, ce ne sont pas les informations qui sont lue dans le fichier mais celle que l'on envoi via StretchDIBits ou "hBmp := Windows.CreateDIBSection" pour l'affichage avec prise en charge, de la transparence.

Ensuite, tu parles de grosse ligne blanche ; c'est l'énorme rectangle qui fait le quart de l'image ? Ce n'est plus une grosse ligne (moi je m'attendais à un machin de 3 ou 4 pixels), c'est le quart de l'image ! Donc on ne comprend pas.

Bon quand même là tu chippotes tu vois bien, sur les captures que ce n'est pas 3 ou 4 pixels

Enfin, j'ai zoomé très fort sur l'image récupérée, ça donne ça :

et on se rend compte qu'il y a un foutoir de lignes plus ou moins sombres et difficilement explicables.

J'ai laissé de coté le mon 1er problème, alors j'ai jeté un oeil (et le bon cet fois, merci pour ta pipette dans "comparimages". Il y avait effectivement un filtre mal placé "PreMultiplyAlpha" dans la source du décodage 32bits.
Il faut que je le place dans la procedure d'affichage. Il ne faut pas appliquer ce filtre si on ne tient pas compte de la transparence.



Bien vue

Enfin, le rectangle de sélection matérialisé par les pointillés fait 63 de haut : s'il faisait 64 ça serait bien une embrouille 32 versus 24, mais peut-être faut-il prendre en compte une ligne grise pour arriver à 64 ?

La hauteur de se gros rectangle blanc diffère suivant la hauteur de l'image et si ces dimensions sont impairs

Pour y voir clair, tu devrais travailler avec du bitmap et des couleurs unies, genre ce style d'images :

Et présente-nous une seule image, celle avec le défaut, mais non réduite car sinon, comment faire la différence entre ta compression et celle du logiciel d'exportation pour publication ? Le coup des lignes sombres, je ne sais pas d'où elles sortent...

J'ai suivi tes conseils j'ai passé ton fichier ci-dessus sous Gimp et ai exporté l'image aux formats 16,24 et 32bits

Le 32bits

Le 24Bits

Le 16Bits


Ce que l'on peux remarquer c'est que le carré blanc est proportionnel à la taille du pixel (16bits = 2 octets / 24bits = 3 octets / 32bits = 4 octets.
Il y aurais du padding en fin de ligne je pourrais dire ok, mais ici il n'y a pas de padding. Quid ????
Le plus bizarre ce sont les fichiers de sorties que je génère pour vérifier dans l'éditeur Hexadécimal et lors de la session de debug. Les valeurs sont identiques.
De plus les formats de couleurs sont convertit en 32bits pour l'affichage donc la aussi pas de padding

Le code du chargement du 16bits 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
 
    pf16Bits: // Pas de compression, formats couleurs suivant "BitField" XRGB_1555, ARGB_4444, RGB/BGR_565
    Begin
      LineBuffer := nil;
      ReallocMem(LineBuffer, FRowSize);
      Y := 0;
      Repeat
        Memory.Read(LineBuffer^, FRowSize);
        If TopDown Then
          YY := Y
        Else
          YY := MaxHeight - Y;
 
        DstLine := GetScanLine(YY);
 
        SrcPtr16 := PWord(LineBuffer);
        For X := 0 To MaxWidth Do
        Begin
          SrcColor16 := SrcPtr16^;
          DstColor := ConvertBitFieldsToGLZColor(RAwImage.Description.BitFields, SrcColor16);
          DstColor.Alpha := 255;
          DstLine^ := DstColor;
          Inc(SrcPtr16);
          Inc(DstLine);
        End;
 
        Inc(Y);
      Until (Y > MaxHeight);
 
      ReAllocMem(LineBuffer, 0);
      FreeMem(LineBuffer);
      LineBuffer := nil;
    End;

Mise à par le nombre d'octets lu dans LineBuffer qui est différent suivant le "PixelFormat" 16,24 ou 32bits. J'arrive pas à pigé pourquoi seulement une partie est affichée ?
J'aurais préféré rien voir du tout

bonne fin de soirée.

[BeanzMaster]

Ne cherchez plus !! j'ai trouvé le coupable en cherchant un fuite mémoire

il se cachait dans ce bout de code, le code commenté

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
 
procedure TGLZBitmap.LoadFromFile(Const FileName:String);
 var
   BaseImageClass: TGLZBitmapClass;
   tempImage: TGLZCustomBitmap;
   SrcPtr, DstPtr:PGLZColor;
   bSize: Longint;
 begin
   if filename = '' then exit;
   BaseImageClass := GetRasterFileFormats.FindFromFileName(filename);
   TempImage:=nil;
   tempImage := BaseImageClass.Create(0,0);
   try
     tempImage.LoadFromFile(fileName);
     SetSize(TempImage.Width, TempImage.Height);
     Clipping:=false;
     ClipRect:=TempImage.ClipRect;
     with RawImage do
     begin
       Description.Width:=TempImage.RawImage.Description.Width;
       Description.Height:=TempImage.RawImage.Description.Height;
       Description.Size:=TempImage.RawImage.Description.Size;
       Description.ColorFormat:=TempImage.RawImage.Description.ColorFormat;
       Description.PixelFormat:=TempImage.RawImage.Description.PixelFormat;
       Description.HasAlpha:=TempImage.RawImage.Description.HasAlpha;
       Description.BitFields := TempImage.RawImage.Description.BitFields;
     end;
     SrcPtr:=PGLZColor(TempImage.getSurfaceBuffer);
     DstPtr:=PGLZColor(GetSurfaceBuffer);
 
    // Move(SrcPtr^,DstPtr^,TempImage.RawImage.Description.Size);
    bSize:=(Width*Height)*4;
    Move(SrcPtr^,DstPtr^,bSize);
 
   finally
     FreeAndNil(tempImage);
   end;
end;

Merci pour votre aide. Ton fichier nickel JP

[Jipété]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
    // Move(SrcPtr^,DstPtr^,TempImage.RawImage.Description.Size);

Je t'avais dit que RawImage c'est le Mal !
Tout juste bon à nous induire en erreur...

Ton fichier nickel JP

Bon quand même là tu chippotes tu vois bien, sur les captures que ce n'est pas 3 ou 4 pixels

Oui, je chipote, mais seule une précision rigoureuse permet de trouver des décalages de 1 pixel, induits par exemple par l'oubli d'un "-1" ou son ajout quand il ne le faudrait pas, à la différence d'un défaut impactant le quart de l'image.
Je me revendique comme grand chipoteur devant l'Éternel, pourquoi crois-tu que je travaillais avec des fichiers de 3x1 ou 3x2, mmmh ?

Ce que l'on peut remarquer c'est que le carré blanc est proportionnel à la taille du pixel (16bits = 2 octets / 24bits = 3 octets / 32bits = 4 octets.

Exemple de chipotage : dans l'image des 16 couleurs unies, il se trouve qu'il y a un carré blanc, mais ce n'est pas lui qui est en défaut, c'est le grand rectangle blanc.
En géométrie on n'a pas le droit de mélanger carrés sympas et gros rectangles foireux, ça augmente la confusion.
(Alors oui, dans l'absolu, un carré est un rectangle un peu particulier, on est d'accord, mais ça c'est pour ceux qui passent au tableau avec une craie à la main (ça existe encore, ça ?) tout en regardant le reste de la classe avec de grands points d'interrogation au fond des yeux, souvenirs souvenirs... )

Et pour conclure, j'aimerais bien que tu nous expliques qu'est-ce que c'est que cette grosse ligne (2 pixels !) noire en bas des 2 Lena, précédée par un rectangle blanc de 1x2, ici on le voit à la jonction des deux images mais c'est pareil à gauche toute :
(zoom 8x de ton image de 00h07)

L'image de Lena au-dessus fait bien 512x512, donc, problème du support du TImage (si c'est ça que tu utilises) ?
En examinant les images de "l'œil" de davdata, on voit bien qu'il s'agit du support dessous, mais ce rectangle blanc de 1x2 au début est gênant.

Bon, enfin, content pour toi que tu aies trouvé la source de ton souci.

[BeanzMaster]

Je t'avais dit que RawImage c'est le Mal !
Tout juste bon à nous induire en erreur...

Oui mais je sais pas trop quoi choisir comme nom pour cette classe qui serait plus parlant que "RawImage". je vais peut-être changer par "ImageInfos" ou un truc dans le genre.

Oui, je chipote, mais seule une précision rigoureuse permet de trouver des décalages de 1 pixel, induits par exemple par l'oubli d'un "-1" ou son ajout quand il ne le faudrait pas, à la différence d'un défaut impactant le quart de l'image.
Je me revendique comme grand chipoteur devant l'Éternel, pourquoi crois-tu que je travaillais avec des fichiers de 3x1 ou 3x2, mmmh ?

Exemple de chipotage : dans l'image des 16 couleurs unies, il se trouve qu'il y a un carré blanc, mais ce n'est pas lui qui est en défaut, c'est le grand rectangle blanc.
En géométrie on n'a pas le droit de mélanger carrés sympas et gros rectangles foireux, ça augmente la confusion.
(Alors oui, dans l'absolu, un carré est un rectangle un peu particulier, on est d'accord, mais ça c'est pour ceux qui passent au tableau avec une craie à la main (ça existe encore, ça ?) tout en regardant le reste de la classe avec de grands points d'interrogation au fond des yeux, souvenirs souvenirs... )

Tu as raison, la précision et la rigueur sont les maîtres mots. Mais c'était tellement gros que... ben voilà

Et pour conclure, j'aimerais bien que tu nous expliques qu'est-ce que c'est que cette grosse ligne (2 pixels !) noire en bas des 2 Lena, précédée par un rectangle blanc de 1x2, ici on le voit à la jonction des deux images mais c'est pareil à gauche toute :

L'image de Lena au-dessus fait bien 512x512, donc, problème du support du TImage (si c'est ça que tu utilises) ?
En examinant les images de "l'œil" de davdata, on voit bien qu'il s'agit du support dessous, mais ce rectangle blanc de 1x2 au début est gênant.

Bon, enfin, content pour toi que tu aies trouvé la source de ton souci.

La ligne blanche et la noire ce sont les bordures et le fond des TPanel dans lesquels j'affiche les images. Faudrait que je passe au "none" ou bien decalé de 2 pixel à droite et vers lebas lors de l'affichage au lieu de 0,0.
Merci dans tous les cas car ce sont bien tes "chipotages" et les explications d'Anapurna qui m'ont poussé dans mes retranchements. Et en plus j'ai solutionné le Stream/Cette Histoire de transparence/une fuite mémoire et le fait que mes images s'affichent EC'était vraiment sous mes yeux, je suis passé dessus je ne sais combien de fois depuis 10 jours sans rien percuté.

[anapurna]

salut

en fait il y a deux éléments a prendre en comptes
il y a les infosreel de l'images
et en arrière plan le tableau de bytes mis en 32 pour le moments afin de pouvoir travailler sur l'image
de la même manière quelque soit le format et c'est la le plus dur
le jonglage entre les données brut et les données retraitées