Bonjour à tous,

Bon je vais essayer d'être le plus clair possible.

Sur le net, j'ai récupéré un morceau de code permettant (normalement, je n'ai pas encore pu le tester) de décoder une image filtré par un filtre Bayer.
Ce code est en C++ or malheureusement pour moi je dois travailler avec Delphi 5. La première idée qui m'est venue est alors (pas forcément la meilleur, j'aurais pu traduire en delphi ... mais ça c'est une autre histoire) de faire une DLL. En gros j'en suis arrivé à ce code :

DllBayer.cpp
Code c++ : 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
 
// include de dll
#include "Stdafx.h"
#include "Main.h"
 
 
#define EXPORTCALL  __declspec(dllexport)  __cdecl // pour faire plus court
 
///////////////////////////////////////////////////////////////////////////////
// déclarations des fonctions de la dll :
 
extern"C" int EXPORTCALL BayerDecode(void *input, int w, int h, void *output, int tile); 
 
 
 
 
 
// point d'entrée de la dll
BOOL APIENTRY DllMainBayer( HANDLE hModule, 
                       DWORD  ul_reason_for_call, 
                       LPVOID lpReserved
                                            )    
{
    return TRUE;
}
 
 
 
extern"C" int EXPORTCALL BayerDecode(void *input, int w, int h, void *output,
             int tile)
{
    BayerTile bonTile;
    switch (tile) {
    default:
    case 0: bonTile = BAYER_TILE_RGGB;
        break;
    case 1: bonTile = BAYER_TILE_GRBG;
        break;
    case 2: bonTile = BAYER_TILE_BGGR;
        break;
    case 3: bonTile = BAYER_TILE_GBRG;
        break;
    case 4: bonTile = BAYER_TILE_RGGB_INTERLACED;
        break;
    case 5: bonTile = BAYER_TILE_GRBG_INTERLACED;
        break;
    case 6: bonTile = BAYER_TILE_BGGR_INTERLACED;
        break;
    case 7:    bonTile = BAYER_TILE_GBRG_INTERLACED;
        break;
    }
    return gp_bayer_decode ((unsigned char *)input,w,h,(unsigned char *)output,bonTile);
}
Main.cpp
Code c++ : 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
 
#include "stdafx.h"
#include "main.h"
 
 
 
static int tile_colors[8][4] = {
    {0, 1, 1, 2},
    {1, 0, 2, 1},
    {2, 1, 1, 0},
    {1, 2, 0, 1},
    {0, 1, 1, 2},
    {1, 0, 2, 1},
    {2, 1, 1, 0},
    {1, 2, 0, 1}};
 
#define RED 0
#define GREEN 1
#define BLUE 2
 
int
gp_bayer_expand (unsigned char *input, int w, int h, unsigned char *output,
         BayerTile tile)
{
    int x, y, i;
    int colour, bayer;
    char *ptr = (char*)input;
    switch (tile) {
 
        case BAYER_TILE_RGGB:
        case BAYER_TILE_GRBG:
        case BAYER_TILE_BGGR:
        case BAYER_TILE_GBRG: 
 
            for (y = 0; y < h; ++y)
            {
                for (x = 0; x < w; ++x, ++ptr) {
                    bayer = (x&1?0:1) + (y&1?0:2);
                    colour = tile_colors[tile][bayer];
                    i = (y * w + x) * 3;
 
                    output[i+RED]    = 0;
                    output[i+GREEN]  = 0;
                    output[i+BLUE]   = 0;
                    output[i+colour] = *ptr;
                }
            }
            break;
 
        case BAYER_TILE_RGGB_INTERLACED:
        case BAYER_TILE_GRBG_INTERLACED:
        case BAYER_TILE_BGGR_INTERLACED:
        case BAYER_TILE_GBRG_INTERLACED:
 
 
            for (y = 0; y < h; ++y, ptr+=w)
                for (x = 0; x < w; ++x) {
                    bayer = (x&1?0:1) + (y&1?0:2);
 
                    colour = tile_colors[tile][bayer];
 
                    i = (y * w + x) * 3;
 
                    output[i+RED]    = 0;
                    output[i+GREEN]  = 0;
                    output[i+BLUE]   = 0;
                    output[i+colour] = (x&1)? ptr[x>>1]:ptr[(w>>1)+(x>>1)];
                }
            break;
    }
 
    return 1;
}
 
#define AD(x, y, w) ((y)*(w)*3+3*(x))
 
int
gp_bayer_interpolate (unsigned char *image, int w, int h, BayerTile tile)
{
    Log("Je suis ici dans interpolate");
    int x, y, bayer;
    int p0, p1, p2, p3;
    int div, value;
 
    switch (tile) {
    default:
    case BAYER_TILE_RGGB:
    case BAYER_TILE_RGGB_INTERLACED:
        p0 = 0; p1 = 1; p2 = 2; p3 = 3;
        break;
    case BAYER_TILE_GRBG:
    case BAYER_TILE_GRBG_INTERLACED:
        p0 = 1; p1 = 0; p2 = 3; p3 = 2;
        break;
    case BAYER_TILE_BGGR:
    case BAYER_TILE_BGGR_INTERLACED:
        p0 = 3; p1 = 2; p2 = 1; p3 = 0;
        break;
    case BAYER_TILE_GBRG:
    case BAYER_TILE_GBRG_INTERLACED:    
        p0 = 2; p1 = 3; p2 = 0; p3 = 1;
        break;
    }
 
    for (y = 0; y < h; y++)
        for (x = 0; x < w; x++) {
            bayer = (x&1?0:1) + (y&1?0:2);
            if ( bayer == p0 ) {
 
                /* red. green lrtb, blue diagonals */
                div = value = 0;
                if (y) {
                    value += image[AD(x,y-1,w)+GREEN];
                    div++;
                }
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+GREEN];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+GREEN];
                    div++;
                }
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+GREEN];
                    div++;
                }
                image[AD(x,y,w)+GREEN] = value / div;
 
                div = value = 0;
                if ((y < (h - 1)) && (x < (w - 1))) {
                    value += image[AD(x+1,y+1,w)+BLUE];
                    div++;
                }
                if ((y) && (x)) {
                    value += image[AD(x-1,y-1,w)+BLUE];
                    div++;
                }
                if ((y < (h - 1)) && (x)) {
                    value += image[AD(x-1,y+1,w)+BLUE];
                    div++;
                }
                if ((y) && (x < (w - 1))) {
                    value += image[AD(x+1,y-1,w)+BLUE];
                    div++;
                }
                image[AD(x,y,w)+BLUE] = value / div;
 
            } else if (bayer == p1) {
 
                /* green. red lr, blue tb */
                div = value = 0;
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+RED];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+RED];
                    div++;
                }
                image[AD(x,y,w)+RED] = value / div;
 
                div = value = 0;
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+BLUE];
                    div++;
                }
                if (y) {
                    value += image[AD(x,y-1,w)+BLUE];
                    div++;
                }
                image[AD(x,y,w)+BLUE] = value / div;
 
            } else if ( bayer == p2 ) {
 
                /* green. blue lr, red tb */
                div = value = 0;
 
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+BLUE];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+BLUE];
                    div++;
                }
                image[AD(x,y,w)+BLUE] = value / div;
 
                div = value = 0;
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+RED];
                    div++;
                }
                if (y) {
                    value += image[AD(x,y-1,w)+RED];
                    div++;
                }
                image[AD(x,y,w)+RED] = value / div;
 
            } else {
 
                /* blue. green lrtb, red diagonals */
                div = value = 0;
 
                if (y) {
                    value += image[AD(x,y-1,w)+GREEN];
                    div++;
                }
                if (y < (h - 1)) {
                    value += image[AD(x,y+1,w)+GREEN];
                    div++;
                }
                if (x) {
                    value += image[AD(x-1,y,w)+GREEN];
                    div++;
                }
                if (x < (w - 1)) {
                    value += image[AD(x+1,y,w)+GREEN];
                    div++;
                }
                image[AD(x,y,w)+GREEN] = value / div;
 
                div = value = 0;
                if ((y < (h - 1)) && (x < (w - 1))) {
                    value += image[AD(x+1,y+1,w)+RED];
                    div++;
                }
                if ((y) && (x)) {
                    value += image[AD(x-1,y-1,w)+RED];
                    div++;
                }
                if ((y < (h - 1)) && (x)) {
                    value += image[AD(x-1,y+1,w)+RED];
                    div++;
                }
                if ((y) && (x < (w - 1))) {
                    value += image[AD(x+1,y-1,w)+RED];
                    div++;
                }
                image[AD(x,y,w)+RED] = value / div;
            }
        }
 
    return 1;
}
 
int
gp_bayer_decode (unsigned char *input, int w, int h, unsigned char *output,
         BayerTile tile)
{
    gp_bayer_expand (input, w, h, output, tile);
    gp_bayer_interpolate (output, w, h, tile);
    return 1;
}
Je tire de ce code un fichier DllBayer.dll

Sous Delphi pour tester tout ça je fais un petit programme tout simple dont mon but serait de récupérer une image, d'appliquer le décodage et de l'afficher... Quelque chose comme un peu ça :

Code Delphi :
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
unit UFMain;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  jpeg, ExtCtrls, ComCtrls, StdCtrls;

////////////////////////////////////////////////////////////////////////////////

const NOM_DLL     = 'DllBayer.dll';

      BAYER_TILE_RGGB = 0;
      BAYER_TILE_GRBG = 1;
      BAYER_TILE_BGGR = 2;
      BAYER_TILE_GBRG = 3;
      BAYER_TILE_RGGB_INTERLACED = 4;
      BAYER_TILE_GRBG_INTERLACED = 5;
      BAYER_TILE_BGGR_INTERLACED = 6;
      BAYER_TILE_GBRG_INTERLACED = 7;

////////////////////////////////////////////////////////////////////////////////

type
  TBayerDecode = function (input : pointer ; width : integer; height : integer;
                           output : pointer ; tile : integer) : integer; cdecl;
type
  TDes = function ():Longword;cdecl;


type
  TFormPrinc = class(TForm)
    ImageNain: TImage;
    ProgressBar1: TProgressBar;
    ImgResult: TImage;
    ImgDebut: TImage;
    procedure FormCreate(Sender: TObject);
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
  private

  public

  end;


var
  FormPrinc: TFormPrinc;
  BayerDecode : TBayerDecode;
  Destruction : TDes;
  MonHandle : THandle;

  ImgBitInfo: TBitmapInfo;       // structure pour getdibits et setdibits
  PImgArrayPix,PImgArrayPix2: PByte;       // buffer de l'image

  BytesPerPixel,
  BmpSrcWidth, BmpSrcHeight: Integer;

  
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


implementation

{$R *.dfm}

procedure TformPrinc.FormCreate(Sender: TObject);
Var
  MS         : TMemoryStream;
  Bmp        : TBitmap;
  nbLignes   : integer;
  i: integer;
begin
  MonHandle := LoadLibrary(NOM_DLL);
  if (Handle <> 0) then
  begin
    @BayerDecode := GetProcAddress(MonHandle,'BayerDecode');
    if @BayerDecode = nil then
      showmessage('allaaaaaaaaaaaaaaaaarme !!!!!'); //!\
  end // fin de   Handle <> 0
  else begin
    Showmessage('DllBayer.dll manquant');
    Application.Terminate;
    //Halt
    //stop
    //alaaaaarme !
  end;

  MS := TMemoryStream.Create;
  With MS do
  Try
   LoadFromFile('.\Im100001.bmp');
   BMP := TBitmap.Create;
   Try
     BMP.LoadFromStream(MS);
     ImgDebut.Picture.Assign(BMP);
     MS.Position := SizeOf(TBITMAPFILEHEADER);
     ReadBuffer(ImgBitInfo, SizeOf(TBITMAPINFO));
     GetMem(PImgArrayPix,ImgBitInfo.bmiHeader.biSizeImage);
     GetMem(PImgArrayPix2,ImgBitInfo.bmiHeader.biSizeImage);
     nbLignes := GetDIBits(BMP.Canvas.Handle, BMP.Handle, 0, 1040, PImgArrayPix,
               ImgBitInfo, DIB_RGB_COLORS);
     if nbLignes = null then
        showmessage('bug get DIB')
     else
        showmessage(IntToStr(nbLignes)+' lignes');
     BayerDecode(PImgArrayPix,1392,1040,PImgArrayPix2,BAYER_TILE_RGGB); ///////////////////////////////////
     ImgResult.Picture.Bitmap.Width := 1392;
     ImgResult.Picture.Bitmap.Height := 1040;
     SetDIBits(ImgResult.Canvas.Handle, ImgResult.Picture.Bitmap.Handle, 0, BmpSrcHeight,
       PImgArrayPix2, ImgBitInfo, DIB_RGB_COLORS);
     ImgResult.Refresh;
   Finally
     BMP.Free;
   End;
  Finally
   Free;
  End;
end;

////////////////////////////////////////////////////////////////////////////////

procedure TformPrinc.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  // Libérer le buffer :
  FreeMem(PImgArrayPix,1392*1040);
  FreeMem(PImgArrayPix2,1392*1040);
  FreeLibrary(MonHandle);
end;

////////////////////////////////////////////////////////////////////////////////

end.

L'erreur est la suivante sous Delphi : EAccessViolation dans DllBayer.Dll

Après divers essais dans la DLL (un débuggage un peu sale ... mais bon passons ...) l'erreur survient pour :
x=48 (voir 47) et y=0








Merci de m'avoir lu (courageux) et d'autant plus à quiconque pourra m'aider




[EDIT] :
J'ai oublié de préciser :
admettons je n'appelle pas la méthode BayerDecode :
1) mon image ne s'affiche pas (mais ça je crois que c'est dû à une erreur de ma part au niveau de SetDIBits)
2) mais surtout FreeMem ne fonctionne pas avec ce code ......


Merci encore