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.

Conversion C++ vers delphi

API, COM et SDKs Delphi

Vue hybride

Discussions similaires

Partager

Partager