Conversion C++ vers delphi

**rdr2510** · 15/04/2013, 09h16

Bonjour,

J'ai un fichier dll créer avec Visual C++ 10 qui une fichier d'entête avec des fonctions exporter suivant:
- hHandle Initialize();
- int DeInitialize(hHandle H);
- Void OnProcessedFrame(hHandle H, Frames F);

Je traduit ce code en delphi 7, mais j'ai une blocage.

Les fonction initialize et deinitialize n'a pas de probleme sauf le fonction callBack OnProcessedFrame donne des erreurs en renvoie le parametre Frame F.

Ma question est: Comment on traduit correctement le parametre Frame en delphi 7.
J'ai mis en bas le code de Frame qui est dans l'entete C++.

En remarquant que Frame contient des array liste mais il renvoie sous forme de pointeur. Comment renvoie tableau array c++ en delphi 7?

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
/** Alert lengths */
#define ALERT_NAME_LENGTH  256
#define ALERT_TYPE_LENGTH  256
#define ALERT_DESC_LENGTH  1024
#define ATTR_KEY_LENGTH    64
#define ATTR_VALUE_LENGTH  1024
#define CLASS_NAME_LENGTH  64
 
/** @param Flag that this is the last frame */
#define FLAG_LAST_FRAME    "FLAG_LAST_FRAME"
 
/** @struct Timestamp struct */ 
typedef struct Timestamp
{
  /** @param - Number of seconds since the epoch */
  time_t mTime;
  /** @param - Millisecond portion of the timestamp */
  unsigned short mMilliseconds;
} Timestamp;
 
/** @struct Alert struct */ 
typedef struct Alert
{
  /** @param - The starting timestamp of the alert */
  Timestamp mStart;
  /** @param - The elapsed time of the alert in milliseconds */
  unsigned int mLength;
  /** @param The alert name */
  char mName[ALERT_NAME_LENGTH];
  /** @param - The alert type */
  char mType[ALERT_TYPE_LENGTH];
  /** @param - The alert's description with the alert */
  char mDescription[ALERT_DESC_LENGTH];
  /** @param - The priority of the alert */
  unsigned short mPriority;
  /** @param - The Unique Alert ID  */
  unsigned int mUID;
  /** @param - The confidence between 1 - 100 */
  unsigned short mConf;
  /** @param - Array of Objects UIDs associated with this event */
  unsigned int* mpObjectUIDs;
  /** @param - Number of Objects associated with this event */
  unsigned int mNumObjectUIDs;
} Alert;
 
/** @struct Attribute struct */
struct Attribute
{
  /** @param The attribute key */
  char mKey[ATTR_KEY_LENGTH];
  /** @param The attribute value */
  char mValue[ATTR_VALUE_LENGTH];
};
 
/** @struct Classifcation Confidence struct */
struct ClassConf
{
  /** @param The class name */
  char mClassName[ATTR_KEY_LENGTH];
  /** @param The confidence between 0.0-1.0 */
  float mConfidence;
};
 
/** @struct Object bounding box struct */
typedef struct Object
{
  /** @param - The Object bounding box pixel x (upper-left corner) */
  unsigned int mX;
  /** @param - The Object bounding box pixel y (upper-left corner) */
  unsigned int mY;
  /** @param - The Object bounding box pixel width */
  unsigned int mWidth;
  /** @param - The Object bounding box pixel height */
  unsigned int mHeight;
  /** @param - The Unique Object ID */
  unsigned int mUID;
  /** @param - The detected object class type */
  char *mpType;
  /** @param - The detected object class type's confidence */
  float mClassConf;
  /** @param The object's attributes */
  Attribute* mpAttributes;
  /** @param The number of attributes */
  unsigned int mNumAttributes;
  /** @param The class confidences */
  ClassConf* mpClassConfs;
  /** @param The number of class confidences */
  unsigned int mNumClassConfs;
} Object;
 
 
/** @enum Image Types */
typedef enum { ivNoImage = 0,         /** No image */
               ivNative               /** The native image */
             } ImageType ;
 
/** @param Frame Drawing Attributes that will be drawn */
#define DRAW_NONE           0x00000000
#define DRAW_BOUNDING_BOXES 0x00000001
 
/** @struct Frames struct */
typedef struct Frames
{
  /** @param - Pointer to the image data */
  const unsigned char* mpData;
  /** @param - Width of the frame image */
  unsigned int mWidth;
  /** @param - Height of the frame image */
  unsigned int mHeight;
  /** @param The number of bytes per pixel */
  unsigned int mBytesPerPixel;
  /** @param The image data length, mWidth x mHeight x mBytesPerPixel */
  unsigned int mDataLength;
  /** @param The  Image Type */
  ImageType mImageType;
  /** @param - Timestamp of the frame */
  Timestamp mSysTime;
  /** @param - Array of current alerts */
  Alert* mpAlerts;
  /** @param - Number of alerts in the array */
  unsigned int mNumAlerts;
  /** @param - Array of current objects */
  Object* mpObjects;
  /** @param - Number of objects in the array */
  unsigned int mNumObjects;
  /** @param The frame's attributes */
  Attribute* mpAttributes;
  /** @param The number of attributes */
  unsigned int mNumAttributes;
} Frames;

**ShaiLeTroll** · 15/04/2013, 10h10

C'est surtout que Frames est une structure que tu passes en valeur,
il faudrait en C++ la passer en Frames * F équivalent Delphi var F: Frames ou F: PFrames avec PFrames = ^Frames;

Pour les tableaux Delphi, au lieu d'utiliser un Array of, utilise un pointeur et un champ taille comme tu l'as fait en C++, c'est une pratique très simple, peux-tu nous fournir une tentative de traduction Delphi de tous ces types, une traduction même partielle que l'on t'aide que sur la partie qui te pose problème

Pour char[ATTR_VALUE_LENGTH] cela doit être compatible avec array[ATTR_VALUE_LENGTH] of AnsiChar ;
Les tableaux fixes c'est plus simples à gérer !

Pense aux alignements mémoire des record (voir packed)

Un paramètre DWORD FSize \ FSize: DWORD contenant le sizeof\SizeOf pour contrôler que la structure est de la bonne taille (packed change cela) mais cela permet aussi de gérer les versions (moche mais fréquent dans les API Windows), si tu rajoutes des membres, la taille change et le receveur peut transtyper le pointeur avec la bonne version de structure

**Paul TOTH** · 15/04/2013, 10h23

Delphi 7 je sais pas gérer les indexes sur les pointeurs "p[x]", il faut donc passer par une structure bidon (ou se passer des indexes)

Code :

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

1
2
3
4
5
6
7
8
9
10
 
type
  TCardinals = array[word] of Cardinal; // dimension bidon
  PCardinals = ^TCardinals; // pointeur sur un tableau de Cardinal
 
  Frame = record 
...
    mpObjectUIDs: PCardinals;
...
  end;

le tableau peut aussi être "array[0..0]" en virant le Range Check Error qu'il est préférable de supprimer de toute façon à moins de savoir précisément le nombre maxi d'élément du tableau

**ShaiLeTroll** · 15/04/2013, 13h52

Envoyé par Paul TOTH

ou se passer des indexes

C'est pour moi un bon exercice de savoir boucler sur un pointeur sur un tableau sans devoir bidouiller un type array of !

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
procedure ProcessedFrameEventHandler(H: THandle; F: PFrames);
var
  pAlert: PAlert;
  pUID: System.PCardinal;
begin  
  pAlert := F.mpAlerts;
  for iAlert := 0 to F.mNumAlerts - 1 do
  begin
     pUID := pAlert.mpObjectUIDs;
     for iObj := 0 to pAlert.NumObjectUIDs - 1 do
     begin
       OutputDebugString(PChar(IntToStr(pUID^)));
       Inc(pUID);
     end;
 
    Inc(pAlert);
  end;
end;

**Paul TOTH** · 15/04/2013, 14h36

Envoyé par ShaiLeTroll

C'est pour moi un bon exercice de savoir boucler sur un pointeur sur un tableau sans devoir bidouiller un type array of !

oui mais j'ai toujours trouvé cette limitation pénible, notamment quand on traduit du code C, et injuste car le PChar autorise l'indexation.

quand il est question de parcourir un tableau ta solution est à la fois efficace et performante, mais s'il est question d'adresser les différents éléments du tableau ça devient compliqué.

NB: sous XE2 (et probablement avant) {$POINTER_MATH ON} permet d'indexer les pointeurs.

**rdr2510** · 16/04/2013, 09h22

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
 
  ALERT_NAME_LENGTH = 256;
  ALERT_TYPE_LENGTH = 256;
  ALERT_DESC_LENGTH = 1024;
  ATTR_KEY_LENGTH = 64;
  ATTR_VALUE_LENGTH = 1024;
  CLASS_NAME_LENGTH = 64;
  IV_FLAG_LAST_FRAME = 'FLAG_LAST_FRAME';
  DRAW_NONE = $00000000;
  DRAW_BOUNDING_BOXES = $00000001;
 
TYPE
  pCardinal = ^Cardinal;
 
  Timestamp = Record
      mTime: Integer;
      mMilliseconds: Integer;
  End;
 
  pAttribute = ^Attribute;
  Attribute = Record
      mKey: Array[0..ATTR_KEY_LENGTH] of Char;
      mValue: Array[0..ATTR_VALUE_LENGTH] of Char;
  End;
 
  pClassConf = ^ClassConf;
  ClassConf = Record
      mClassName: Array[0..ATTR_KEY_LENGTH] of Char;
      mConfidence: Real;
  End;
 
  pAlert = ^Alert;
  Alert = Record
      mStart: Timestamp;
      mLength: Cardinal;
      mName: Array[0..ALERT_NAME_LENGTH] of Char;
      mType: Array[0..ALERT_TYPE_LENGTH] of char;
      mDescription: Array[0..ALERT_DESC_LENGTH] of Char;
      mPriority: Byte;
      mUID: Cardinal;
      mConf: Byte;
      mpObjectUIDs: pCardinal;
      mNumObjectUIDs: Cardinal;
  End;
 
  pObject = ^Object;
  Object = Record
      mX, mY, mWidth, mHeight, mUID: Cardinal;
      mpType: pChar;
      mClassConf: Real;
      mpAttributes: pAttribute;
      mNumAttributes: Cardinal;
      mpClassConfs: pClassConf;
      mNumClassConfs: Cardinal;
  End;
 
  ImageType = (ivNoImage = 0, ivNative);
 
  pFrames = ^Frames;
  Frames = Record
      mpData: pByte;
      mWidth, mHeight, mBytesPerPixel, mDataLength: Integer;
      mImageType: ImageType;
      mSysTime: Timestamp;
      mpAlerts: pAlert;
      mNumAlerts: Cardinal;
      mpObjects: pObject;
      mNumObjects: Cardinal;
      mpAttributes: pAttribute;
      mNumAttributes: Cardinal;
  End;

C'est comme ça ma façon de convertir le code C++ en delphi.

en fait le fonction C++ est une CallBack qui renvoie une valeur dans le frame

Dans C++

Code c++ :

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

1
2
3
4
5
6
7
8
9
10
 
/** @param The intuvision callback function type */
#ifdef _WIN32
  typedef void (__stdcall* MYCALLBACK)( const Frames* pFrame, void* pKey );
#elif defined(linux)
  typedef void (* MYCALLBACK)( const Frames* pFrame, void* pKey );
#endif
 
EXPORT int SetCallback(MYHANDLE hHandle, void* pKey, MYCALLBACK pFunc,
                                  ImageType nImageType, unsigned int nAttributes );

Dans delphi

Code :

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

1
2
3
 
MYCALLBACK = Procedure(const pFrame: pFrames; pKey: Pointer); stdCall;
Function SetCallback(hHandle: MYHANDLE; pKey: Pointer; pFunc: MYCALLBACK; nImageType: ImageType; nAttributes: Cardinal): Integer; cdecl External IV_FILE;

Quand je lance avec ça le programme crash, Tout les autres fonctions qui sont dans le dll marche parfaitement quand je traduit dans delphi sauf cette callback. je sais pas si j'ai bien traduit ou non le structure Frames.

Merci pour votre aide.

**ShaiLeTroll** · 16/04/2013, 09h45

Code :

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

const pFrame: pFrames;

Attention ça doit faire pointeur de pointeur ça !
En Delphi le const pointeur ça n'existe pas, en C++, j'ai toujours du mal à comprendre le const qui peut apparaitre un peu partout et plusieurs fois !

Essaye la version const non pointeur

Code :

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

MYCALLBACK = Procedure(const pFrame: Frames; pKey: Pointer); stdCall;

Normalement const passe plutôt un pointeur qu'une copie, finalement bien plus proche de var et nettement plus performant

Ou tout simplement

Code :

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

MYCALLBACK = Procedure(pFrame: pFrames; pKey: Pointer); stdCall;

attention Array[0..ATTR_KEY_LENGTH] c'est un peu long !

char mName[ALERT_NAME_LENGTH] -> mName: array[0 .. ALERT_NAME_LENGTH - 1] of AnsiChar

Ensuite, pense à comparer les SizeOf de tes struct et record, veille à ce qu'il soit identique en C++ et Delphi

**rdr2510** · 16/04/2013, 10h57

Envoyé par ShaiLeTroll

Code :

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

const pFrame: pFrames;

Attention ça doit faire pointeur de pointeur ça !
En Delphi le const pointeur ça n'existe pas, en C++, j'ai toujours du mal à comprendre le const qui peut apparaitre un peu partout et plusieurs fois !

Essaye la version const non pointeur

Code :

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

MYCALLBACK = Procedure(const pFrame: Frames; pKey: Pointer); stdCall;

Normalement const passe plutôt un pointeur qu'une copie, finalement bien plus proche de var et nettement plus performant

Ou tout simplement

Code :

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

MYCALLBACK = Procedure(pFrame: pFrames; pKey: Pointer); stdCall;

attention Array[0..ATTR_KEY_LENGTH] c'est un peu long !

char mName[ALERT_NAME_LENGTH] -> mName: array[0 .. ALERT_NAME_LENGTH - 1] of AnsiChar

Ensuite, pense à comparer les SizeOf de tes struct et record, veille à ce qu'il soit identique en C++ et Delphi

J'ai changé avec le code suivant:

Code :

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

1
2
3
 
MYCALLBACK = Procedure(const pFrame: Frames; pKey: Pointer); stdCall;
mName: array[0 .. ALERT_NAME_LENGTH - 1] of AnsiChar;

ça marché, il ne plante plus, merci les gars oouf.

Par contre je dois remplir ce structure timestamp en bas

Code c++ :

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

1
2
3
4
5
6
7
8
9
10
/** Timestamp struct */ 
typedef struct Timestamp
{
  /** @param - Number of seconds since the epoch */
  time_t mTime;
  /** @param - Millisecond portion of the timestamp */
  unsigned short mMilliseconds;
} Timestamp;
 
Timestamp it;

pourriez vous nous donnez comment on fait en delphi sachant que en C++ il le rempli de façon suivant:

Code c++ :

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

1
2
3
4
5
timeb tmStruct;
ftime(&tmStruct);
Timestamp it;
it.mTime = tmStruct.time;
it.mMilliseconds = tmStruct.millitm;

Je connais pas l'equivalent de fonction ftime en delphi.

**ShaiLeTroll** · 16/04/2013, 14h09

ftime en C++Builder et le plus proche en Delphi semble DateTimeToUnix

Code :

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

1
2
3
ref := Now();
it.mTime := DateTimeToUnix(ref);
it.mMilliseconds := MilliSecondOf(ref);

**rdr2510** · 16/04/2013, 14h46

Envoyé par ShaiLeTroll

ftime en C++Builder et le plus proche en Delphi semble DateTimeToUnix

Code :

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

1
2
3
ref := Now();
it.mTime := DateTimeToUnix(ref);
it.mMilliseconds := MilliSecondOf(ref);

ça ne marche pas! le fonction crash le programme.

Mais quand j'ai mis une valeur bidon par example:

Code :

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

1
2
it.mTime:= 5;
It.mMilliseconds:= 0;

Le programme ne crash pas, ça marche mais le comportement de son fonctionnement n'est pas à mon attente.

**ShaiLeTroll** · 16/04/2013, 16h31

Envoyé par rdr2510

ça ne marche pas! le fonction crash le programme.

crash ? il s'arrête net ? il bloque ?
Soit plus précis !

Utilise un Try Except pour connaitre l'exception et savoir si c'est Now ou DateTimeToUnix qui pose problème, procède à débogage approfondie !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
try
  OutputDebugString('now');
  ref := Now();
  OutputDebugString('DateTimeToUnix');
  it.mTime := DateTimeToUnix(ref);
  OutputDebugString('MilliSecondOf');
  it.mMilliseconds := MilliSecondOf(ref);
except
 on E: Exception do
   OutputDebugString(PChar(E.Message)); // CTRL + ALT + V = Journal Evènement
end;

**rdr2510** · 18/04/2013, 11h30

Envoyé par ShaiLeTroll

crash ? il s'arrête net ? il bloque ?
Soit plus précis !

Utilise un Try Except pour connaitre l'exception et savoir si c'est Now ou DateTimeToUnix qui pose problème, procède à débogage approfondie !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
try
  OutputDebugString('now');
  ref := Now();
  OutputDebugString('DateTimeToUnix');
  it.mTime := DateTimeToUnix(ref);
  OutputDebugString('MilliSecondOf');
  it.mMilliseconds := MilliSecondOf(ref);
except
 on E: Exception do
   OutputDebugString(PChar(E.Message)); // CTRL + ALT + V = Journal Evènement
end;

j'suis désolé j'ai fait des erreurs, la ça marche.

Je reviens sur

Code :

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

MYCALLBACK = Procedure(const pFrame: Frames; pKey: Pointer); stdCall;

le parametre Frame ne reçoit pas tout son contenu.
j'explique dans le code en bas

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
   Frames = Record
      mpData: pByte; // Contenu bien reçu avec valeur exacte
      mWidth, mHeight, mBytesPerPixel, mDataLength: Integer; // contenu bien réçu avec valeur exacte
      mImageType: ImageType; // Contenu bien reçu avec valeur exacte
      mSysTime: Timestamp; // Contenu bien reçu avec valeur exacte
      mpAlerts: pAlert; // contenu erreur, on peut pas acceder renvoie exception
      mNumAlerts: Cardinal; // Contenu = 0
      mpObjects: pObject;  // contenu erreur, on peut pas acceder renvoie exception
      mNumObjects: Cardinal; // Contenu = 0
      mpAttributes: pAttribute; // contenu erreur, on peut pas acceder renvoie exception
      mNumAttributes: Cardinal; // contenu = 0
  End;

J'ai déjà essayé avec ce code suivant mais toujours erreur.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Frames = Record
      mpData: pByte; // Contenu bien reçu avec valeur exacte
      mWidth, mHeight, mBytesPerPixel, mDataLength: Integer; // contenu bien réçu avec valeur exacte
      mImageType: ImageType; // Contenu bien reçu avec valeur exacte
      mSysTime: Timestamp; // Contenu bien reçu avec valeur exacte
      mpAlerts: array of Alert; // contenu erreur, on peut pas acceder renvoie exception
      mNumAlerts: Cardinal; // Contenu = 0
      mpObjects: array of Object;  // contenu erreur, on peut pas acceder renvoie exception
      mNumObjects: Cardinal; // Contenu = 0
      mpAttributes: array of Attribute; // contenu erreur, on peut pas acceder renvoie exception
      mNumAttributes: Cardinal; // contenu = 0
  End;

Dans le Header C++ du dll, le parametre mpAlert est un array et nombre d'indice est le mNumAlert, pareil aussi le mpObject.

Peut être mal converti le type array c++?

**Paul TOTH** · 18/04/2013, 14h26

"Object* mpObjects;" n'est pas un tableau et nous t'avons déjà donné les explications ci-dessus.

Conversion C++ vers delphi

API, COM et SDKs Delphi

Discussions similaires

Partager

Partager