Discussion :

[kidpaddle2]

Bonjour,

Ayant pris peur devant le code immonde que j'avais pondu pour un projet datant de presque un an (résultant d'ajouts successifs), j'ai décidé de le refaire proprement (et d'en profiter pour faire des optimisations [de mémoire en partie, avec l'allocation dynamique] et quelques ajouts).

Cependant, alors même que je finis le composant audio, lors d'un test (puisque j'y introduis de nouveaux concepts, comme l'OO) en console je me rends compte que l'exécution engendre la fermeture du programme, retournant un nombre du type -1073741819, alors qu'en mode debugging, tout marche parfaitement !

Comment cela se fait-il ?

Je ne vois pas du tout d'où cela peut provenir, donc je vous fournis le code en entier...

Main.c :

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
#include "Music.h"
 
#include <stdio.h>
 
/* getch() */
#include <conio.h>
 
static void openPlaylist(Playlist *, const char *);
 
int main(void)
{
    Music music = CreateMusic(InitFmod());
    Playlist playlist = CreatePlaylist();
 
    openPlaylist(&playlist, "playlist.m3u");
 
    music.load(&music, playlist.list[2]);
 
    music.play(&music);
 
    /* getchar(), et même (getchar)() ne bloquent pas le thread... */
    getch();
 
    CloseFmod(music.sys);
    music.free(&music);
    playlist.free(&playlist);
 
    return 0;
}
 
static void openPlaylist(Playlist *playlist, const char *playlistFilePath)
{
    FILE *playlistFile = fopen(playlistFilePath, "r");
 
    if(playlistFile != NULL)
    {
        char path[MAX_PATH] = "";
        while(fgets(path, MAX_PATH, playlistFile) != NULL)
        {
            path[strlen(path)-1] = '\0'; /*Removes '\n'*/
            playlist->add(playlist, path);
        }
 
        fclose(playlistFile);
    }
}

Music.h :

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
#ifndef MUSIC_H_INCLUDED
#define MUSIC_H_INCLUDED
 
#ifndef __bool_true_and_false_are_defined
    #define bool int
    #define true 1
    #define false 0
#endif
 
/* DLL */
#include <windows.h>
#include <fmod/fmod.h>
 
FMOD_SYSTEM *InitFmod(void);
void CloseFmod(FMOD_SYSTEM *);
 
typedef enum Status
{
    PLAYING,
    STOPPED,
    PAUSED
}Status;
 
typedef struct Music
{
    FMOD_SOUND *stream;
    FMOD_CHANNEL *channel;
    FMOD_SYSTEM *sys;
 
    unsigned int (*getElapsedTime)(struct Music*);
    unsigned int (*getTotalTime)(struct Music*);
    void (*seek)(struct Music*, unsigned int);
    void (*load)(struct Music*, const char *);
    Status (*getStatus)(struct Music*);
    void (*play)(struct Music*);
    void (*stop)(struct Music *);
    void (*pause)(struct Music *, bool);
    void (*free)(struct Music*);
    unsigned int (*getVol)(struct Music*);
    void (*setVol)(struct Music*, unsigned int);
}Music;
 
Music CreateMusic(FMOD_SYSTEM*);
Music *NewMusic(FMOD_SYSTEM*);
 
typedef enum Mode
{
    SHUFFLE = 1 << 0,
    LOOP = 1 << 1
}Mode;
 
typedef struct Playlist
{
    void (*add)(struct Playlist*, const char*);
    void (*suppr)(struct Playlist*, unsigned int);
    void (*free)(struct Playlist*);
 
    char **list;
    unsigned int count;
 
    Mode mode;
}Playlist;
 
Playlist CreatePlaylist(void);
Playlist *NewPlaylist(void);
 
unsigned int GetMusicElapsedTime(Music*);
void SeekMusic(Music*, unsigned int);
unsigned int GetMusicTotalTime(Music*);
void LoadMusic(Music*, const char *);
Status GetMusicStatus(Music*);
void PlayMusic(Music*);
void StopMusic(Music *);
void PauseMusic(Music *, bool);
void FreeMusic(Music*);
void DeleteMusic(Music*);
void SetMusicVolume(Music*, float);
float GetMusicVolume(Music*);
 
void AddToPlaylist(Playlist*, const char*);
void SupprFromPlaylist(Playlist*, unsigned int);
void FreePlaylist(Playlist*);
void DeletePlaylist(Playlist*);
 
#endif

Music.c :

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
#include "Music.h"
 
#include <string.h>
#include <stdlib.h>
 
FMOD_SYSTEM *InitFmod(void)
{
    FMOD_SYSTEM *sys;
 
    FMOD_System_Create(&sys);
    FMOD_System_Init(sys, 1, FMOD_INIT_NORMAL, NULL);
 
    return sys;
}
 
void CloseFmod(FMOD_SYSTEM *sys)
{
    FMOD_System_Close(sys);
    FMOD_System_Release(sys);
}
 
static void InitMusic(Music *music, FMOD_SYSTEM *sys)
{
    music->stream = NULL;
    music->channel = NULL;
    music->sys = sys;
 
    music->getElapsedTime = GetMusicElapsedTime;
    music->getTotalTime = GetMusicTotalTime;
    music->seek = SeekMusic;
    music->load = LoadMusic;
    music->getStatus = GetMusicStatus;
    music->play = PlayMusic;
    music->stop = StopMusic;
    music->pause = PauseMusic;
}
 
Music CreateMusic(FMOD_SYSTEM *sys)
{
    Music instance;
    InitMusic(&instance, sys);
    instance.free = FreeMusic;
 
    return instance;
}
 
Music *NewMusic(FMOD_SYSTEM *sys)
{
    Music *instance = NULL;
    instance = malloc(sizeof (Music));
 
    InitMusic(instance, sys);
    instance->free = DeleteMusic;
 
    return instance;
}
 
void FreeMusic(Music *music)
{
    FMOD_Sound_Release(music->stream);
}
 
void DeleteMusic(Music *music)
{
    FreeMusic(music);
    free(music);
}
 
static void InitPlaylist(Playlist *playlist)
{
    playlist->list = NULL;
    playlist->count = 0;
    playlist->mode = 0;
 
    playlist->add = AddToPlaylist;
    playlist->suppr = SupprFromPlaylist;
}
 
Playlist CreatePlaylist(void)
{
    Playlist instance;
    InitPlaylist(&instance);
    instance.free = FreePlaylist;
 
    return instance;
}
 
Playlist *NewPlaylist(void)
{
    Playlist *instance = NULL;
    instance = malloc(sizeof (Playlist));
 
    InitPlaylist(instance);
    instance->free = DeletePlaylist;
 
    return instance;
}
 
void FreePlaylist(Playlist *This)
{
    size_t i;
    for(i = 0 ; i < This->count ; i++)
        free(This->list[i]);
 
    free(This->list);
}
 
void DeletePlaylist(Playlist *This)
{
    FreePlaylist(This);
    free(This);
}
 
void AddToPlaylist(Playlist *This, const char *path)
{
    This->count++;
 
    This->list = realloc(This->list, This->count * sizeof(char*));
    This->list[This->count-1] = malloc(strlen(path) * sizeof (char));
 
    strcpy(This->list[This->count-1], path);
}
 
void SupprFromPlaylist(Playlist *This, size_t index)
{
    free(This->list[index]);
 
    {
        size_t i;
        for(i = index ; i < This->count-1 ; i++)
            This->list[i] = This->list[i+1];
    }
 
    This->count--;
 
    This->list = realloc(This->list, This->count * sizeof(char*));
}
 
size_t GetMusicElapsedTime(Music *music)
{
    size_t ret = 0;
 
    FMOD_Channel_GetPosition(
                                music->channel,
                                &ret,
                                FMOD_TIMEUNIT_MS
                            );
    return ret /= 1000;
}
 
size_t GetMusicTotalTime(Music *music)
{
    size_t ret = 0;
 
    FMOD_Sound_GetLength(music->stream, &ret, FMOD_TIMEUNIT_MS);
 
    return ret /= 1000;
}
 
void SeekMusic(Music *music, size_t pos)
{
    FMOD_Channel_SetPosition(music->channel, pos*1000, FMOD_TIMEUNIT_MS);
}
 
void LoadMusic(Music *music, const char *path)
{
    FMOD_System_CreateStream(
                                music->sys,
                                path,
                                FMOD_DEFAULT,
                                0,
                                &music->stream
                            );
}
 
Status GetMusicStatus(Music *music)
{
    FMOD_BOOL res = false;
    Status ret;
 
    if(music->channel == NULL)
        ret = STOPPED;
    else
    {
        FMOD_Channel_IsPlaying(music->channel, &res);
        if(res == false)
            ret = STOPPED;
        else
        {
            ret = PLAYING;
 
            FMOD_Channel_GetPaused(music->channel, &res);
            if(res == true)
                ret = PAUSED;
        }
    }
    return ret;
}
 
void PlayMusic(Music *music)
{
    FMOD_System_PlaySound(
                            music->sys,
                            FMOD_CHANNEL_FREE,
                            music->stream,
                            0,
                            &music->channel
                         );
}
 
void StopMusic(Music *music)
{
    FMOD_Channel_Stop(music->channel);
}
 
void PauseMusic(Music *music, bool flag)
{
    FMOD_Channel_SetPaused(music->channel, flag);
}
 
void SetMusicVolume(Music *music, float vol)
{
    FMOD_Channel_SetVolume(music->channel, vol);
}
 
float GetMusicVolume(Music *music)
{
    float vol = 0.0;
    FMOD_Channel_GetVolume(music->channel, &vol);
 
    return vol;
}

Merci d'avance.

P.S: Je compile en ANSI. N'hésitez pas à me faire des remarques, même si elles n'ont pas de rapport particulier avec le sujet : j'y suis toujours ouvert

[Médinoc]

Commence par donner le code de retour exact, puis convertis-le en hexa (la calculatrice Windows peut faire ça).
Et ensuite, cherche ce nombre en hexa sur MSDN et dans les headers, ça te donnera déjà un aperçu de l'erreur...

[|PaRa-BoL]

Il se peut qu'un code marche en mode debugging mais pas en normal.

http://fr.wikipedia.org/wiki/Heisenbug

[kidpaddle2]

Très intéressante la comparaison avec le principe d'incertitude... par ailleurs, d'après ce que je vois, le mode debugger allouerait plus de mémoire qu'il n'en est nécessaire (je suis sous Code::Blocks) ?

Sinon, j'ai été voir dans les sources des différentes biblio, le code correspondant, puisque la sortie me semble fixe à :

Process returned -1073741819 (0xC0000005) execution time : 0.187 s
Press any key to continue.

Et je trouve, dans ntstatus.h, le define correspondant :

Code :

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

#define STATUS_ACCESS_VIOLATION ((NTSTATUS)0xC0000005L)

Rremarquez-vous dans mon code une erreur, en ce qui concerne la gestion de la mémoire (d'après le lien de |PaRa-Bol, confirmé par cette macro, ça pourrait en être la cause) ?

Je tiens à préciser que durant mes nombreux essais, getch() et même scanf() pouvaient engendrer le return...

[|PaRa-BoL]

Meme si code::Block n'allou pas plus de mémoire en mode debug (Je n'en sait rien), de toute façon la structure du programme n'est plus la même. Donc vérifi si tu n'a pas un petit overflow quelque part ou une variable non initialisée. Met ton compilateur en mode paranöid et vérifi tout

[Médinoc]

Pour commencer, à ta place j'éviterais de retourner une structure par valeur, surtout en C...

[kidpaddle2]

|PaRa-Bol -> Justement, je ne trouve pas... ça fait un petit moment que j'y suis déjà.

Médinoc -> Oui, je suis au courant. Cependant, ça vient du tuto (sur ce site même) concernant la programmation orientée objet en C, et même si j'utilise ma fonction NewMusic() et NewPlaylist() (retournant des pointeurs), j'ai le même problème.

D'ailleurs, les membres sont copiés un à un, et l'objet d'origine est détruit ensuite... quel problème pourrait-on rencontrer ? Pour un opérateur d'assignation, d'accord, puisque l'on n'est pas sûr de la perrenité de l'objet d'origine, mais là...

[Médinoc]

Je pense que tu as quelque part une variable mal initialisée, ou un truc du genre.
Tu es sous MinGW pour l'instant, non ?
Il faudrait l'essayer sous le debugger de Visual, mais je n'ai pas SDL Music et j'ai la flemme de chercher à faire marcher cette lib...

[kidpaddle2]

Pour moi, Visual c'est la jungle. Bardé de courage, j'ai essayé de le faire marcher à trois reprises, et rien n'y a fait. Lui et moi, c'est incompatible pour le moment ^^

Sinon, je n'utilise pas SDL_Music mais Fmod, même si ça revient au même pour toi... je doute par contre que le problème vienne de son fonctionnement, ou à la limite un dû aux variables que j'utilise dans la structure Music.

Au fait, j'ai réglé mon compilo (oui, MinGW) à la manière 'parano' (selon le site de Emmanuel Delahaye), et seul le header stdio.h est commenté, à part concernant mes fonctions CreateXXXX, qui engendrent (normal) un warning du type "returns aggregate".

[Emmanuel Delahaye]

Bonjour,

Ayant pris peur devant le code immonde que j'avais pondu pour un projet datant de presque un an (résultant d'ajouts successifs), j'ai décidé de le refaire proprement (et d'en profiter pour faire des optimisations [de mémoire en partie, avec l'allocation dynamique] et quelques ajouts).

Cependant, alors même que je finis le composant audio, lors d'un test (puisque j'y introduis de nouveaux concepts, comme l'OO) en console je me rends compte que l'exécution engendre la fermeture du programme, retournant un nombre du type -1073741819, alors qu'en mode debugging, tout marche parfaitement !

Comportement indéfini ? Il manque pas mal de contrôles. Je propose ceci. Pose des questions si tu ne comprends pas :

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
 
/* main.c */
 
#include "playlist.h"
#include "music.h"
 
#include <stdio.h>
#include <conio.h>/* getch() */
 
int main (void)
{
   Music *music = music_create ();
 
   if (music != NULL)
   {
      Playlist *playlist = playlist_create ();
 
      if (playlist != NULL)
      {
         int err = playlist_open (playlist, "playlist.m3u");
         if (!err)
         {
            if (playlist_count(playlist) > 1)
            {
               music_load (music, playlist->list[2]);
               music_play (music);
               getch ();
            }
            playlist_delete (playlist);
         }
      }
      music_delete (music);
   }
   return 0;
}

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
 
#ifndef H_ED_MUSIC_20070623224109
#define H_ED_MUSIC_20070623224109
 
#ifdef __cplusplus
extern "C"
{
#endif
 
/* music.h */
 
#include <stddef.h>
 
   typedef enum
   { false, true }
   bool;
 
   typedef enum Status
   { PLAYING, STOPPED, PAUSED }
   Status;
 
/* type abstrait */
   typedef struct music Music;
 
   Music *music_create (void);
   void music_delete (Music * music);
 
   size_t music_getElapsedTime (Music * music);
   size_t music_getTotalTime (Music * music);
   void music_seek (Music * music, size_t pos);
   void music_load (Music * music, const char *path);
   Status music_getStatus (Music * music);
   void music_play (Music * music);
   void music_stop (Music * music);
   void music_pause (Music * music, bool flag);
   void music_set_volume (Music * music, float vol);
   float music_get_volume (Music * music);
 
#ifdef __cplusplus
}
#endif
 
#endif                          /* guard */
 
/* Guards added by GUARD (c) ED 2000-2005 Jan 17 2005 Ver. 1.7 */

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
 
/* music.c */
 
#include "music.h"
 
#include <string.h>
#include <stdlib.h>
 
#include <fmod/fmod.h>
 
struct music
{
   FMOD_SOUND *stream;
   FMOD_CHANNEL *channel;
   FMOD_SYSTEM *sys;
};
 
static FMOD_SYSTEM *InitFmod (void)
{
   FMOD_SYSTEM *sys;
   FMOD_System_Create (&sys);
   FMOD_System_Init (sys, 1, FMOD_INIT_NORMAL, NULL);
   return sys;
}
 
static void CloseFmod (FMOD_SYSTEM * sys)
{
   FMOD_System_Close (sys);
   FMOD_System_Release (sys);
}
 
/* points d'entree */
Music *music_create (void)
{
   Music *instance = malloc (sizeof (Music));
   if (instance != NULL)
   {
      instance->stream = NULL;
      instance->channel = NULL;
      instance->sys = InitFmod ();
   }
   return instance;
}
 
void music_delete (Music * music)
{
   FMOD_Sound_Release (music->stream);
   CloseFmod (music->sys);
   free (music);
}
 
size_t music_getElapsedTime (Music * music)
{
   size_t ret = 0;
   FMOD_Channel_GetPosition (music->channel, &ret, FMOD_TIMEUNIT_MS);
   return ret /= 1000;
}
 
size_t music_getTotalTime (Music * music)
{
   size_t ret = 0;
   FMOD_Sound_GetLength (music->stream, &ret, FMOD_TIMEUNIT_MS);
   return ret / 1000;
}
 
void music_seek (Music * music, size_t pos)
{
   FMOD_Channel_SetPosition (music->channel, pos * 1000, FMOD_TIMEUNIT_MS);
}
 
void music_load (Music * music, const char *path)
{
   FMOD_System_CreateStream (music->sys, path, FMOD_DEFAULT, 0,
                             &music->stream);
}
 
Status music_getStatus (Music * music)
{
   FMOD_BOOL res = false;
   Status ret;
   if (music->channel == NULL)
      ret = STOPPED;
   else
   {
      FMOD_Channel_IsPlaying (music->channel, &res);
      if (res == false)
         ret = STOPPED;
      else
      {
         ret = PLAYING;
         FMOD_Channel_GetPaused (music->channel, &res);
         if (res == true)
            ret = PAUSED;
      }
   }
   return ret;
}
 
void music_play (Music * music)
{
   FMOD_System_PlaySound (music->sys, FMOD_CHANNEL_FREE, music->stream, 0,
                          &music->channel);
}
 
void music_stop (Music * music)
{
   FMOD_Channel_Stop (music->channel);
}
 
void music_pause (Music * music, bool flag)
{
   FMOD_Channel_SetPaused (music->channel, flag);
}
void music_set_volume (Music * music, float vol)
{
   FMOD_Channel_SetVolume (music->channel, vol);
}
 
float music_get_volume (Music * music)
{
   float vol = 0.0;
   FMOD_Channel_GetVolume (music->channel, &vol);
   return vol;
}

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
 
#ifndef H_ED_PLAYLIST_20070623165015
#define H_ED_PLAYLIST_20070623165015
 
/* playlist.h */
 
#ifdef __cplusplus
extern "C"
{
#endif
 
   typedef enum Mode
   { SHUFFLE = 1 << 0, LOOP = 1 << 1 }
   Mode;
 
   typedef struct
   {
      char **list;
      unsigned int count;
      Mode mode;
   }
   Playlist;
 
   Playlist *playlist_create (void);
   void playlist_delete (Playlist * This);
 
   int playlist_open (Playlist * This, const char *playlistFilePath);
   void playlist_add (Playlist * This, const char *);
   void playlist_suppr (Playlist * This, unsigned int);
   int playlist_count (Playlist * This);
 
#ifdef __cplusplus
}
#endif
 
#endif                          /* guard */
 
/* Guards added by GUARD (c) ED 2000-2005 Jan 17 2005 Ver. 1.7 */

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
 
/* playlist.c */
 
#include "playlist.h"
 
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
 
Playlist *playlist_create (void)
{
   Playlist *This = malloc (sizeof (Playlist));
   if (This != NULL)
   {
      This->list = NULL;
      This->count = 0;
      This->mode = 0;
   }
   return This;
}
 
void playlist_delete (Playlist * This)
{
   size_t i;
   for (i = 0; i < This->count; i++)
      free (This->list[i]);
   free (This->list);
   free (This);
}
 
int playlist_open (Playlist * This, const char *playlistFilePath)
{
   int err = 0;
   FILE *playlistFile = fopen (playlistFilePath, "r");
   if (playlistFile != NULL)
   {
      char path[MAX_PATH] = "";
      while (fgets (path, MAX_PATH, playlistFile) != NULL)
      {
         path[strlen (path) - 1] = '\0'; /*Removes '\n' */
         playlist_add (This, path);
      }
      fclose (playlistFile);
   }
   else
   {
      perror (playlistFilePath);
      err = 1;
   }
 
   return err;
}
 
void playlist_add (Playlist * This, const char *path)
{
   This->count++;
   This->list = realloc (This->list, This->count * sizeof (char *));
   This->list[This->count - 1] = malloc (strlen (path) * sizeof (char));
   strcpy (This->list[This->count - 1], path);
}
 
void playlist_suppr (Playlist * This, size_t index)
{
   free (This->list[index]);
   {
      size_t i;
      for (i = index; i < This->count - 1; i++)
         This->list[i] = This->list[i + 1];
   }
   This->count--;
   This->list = realloc (This->list, This->count * sizeof (char *));
}
 
int playlist_count (Playlist * This)
{
   return This->count;
}

[kidpaddle2]

En ce qui concerne les contrôles, je voulais les implémenter après avoir résolu le problème, mais j'aurais dû effectivement le faire au fur et à mesure.

Bref, je ne vois pas ce qui a changé dans ton code (à part la suppression de l'OO), sauf en ce qui concerne les tests ? Ainsi, à l'exécution, j'ai exactement le même problème...

Ca fait un bout de temps que je cherche, et je n'ai toujours pas la moindre idée d'où cela peut provenir...

[Emmanuel Delahaye]

En ce qui concerne les contrôles, je voulais les implémenter après avoir résolu le problème, mais j'aurais dû effectivement le faire au fur et à mesure.

Bref, je ne vois pas ce qui a changé dans ton code (à part la suppression de l'OO), sauf en ce qui concerne les tests ? Ainsi, à l'exécution, j'ai exactement le même problème...

Ca fait un bout de temps que je cherche, et je n'ai toujours pas la moindre idée d'où cela peut provenir...

Pour pouvoir tester dans les mêmes conditions, il faudrait que j'ai les mêmes fichiers de donnée que toi. Tu peux les déposer sur un site perso ?

Je n'ai pas "supprimmé l'OO". Au contraire, je l'ai même renforcée en la rendant opaque, donc plus sécuritaire. Par contre, l'usage des pointeurs de fonctions ne se justifie pas, à moins que tu cherches à faire de l'héritage multiple...

Si tu tiens aux pointeurs de fonction, ça doit rester une manip 'interne', et vu de l'extérieur, il faut continuer à fournir une interface classique (appel de fonction).

L'utilisateur n'a pas à connaitre les détails de la structure interne.

[koala01]

Salut,

Juste une petite remarque concernant ce seul petit bout de code:

Code :

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

1
2
3
4
5
6
 
#ifndef __bool_true_and_false_are_defined
    #define bool int
    #define true 1
    #define false 0
#endif

Ne manquerait-il pas un define __bool_true_and_false_are_defined dans le lot

Code :

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

1
2
3
4
5
6
#ifndef __bool_true_and_false_are_defined
    #define __bool_true_and_false_are_defined
    #define bool int
    #define true 1
    #define false 0
#endif

Sinon, il me semble que __bool_true_and_false_are_defined ne sera jamais définis

[Emmanuel Delahaye]

Sinon, il me semble que __bool_true_and_false_are_defined ne sera jamais définis

C'est peut être une définition personnelle... Mais je me demande si ce n'est pas dans le <bool.h> de C99...

[koala01]

Ca l'est peut etre, mais, ici, c'est dans son propre code source...

Et un ifndef n'est utile, que s'il contient la définition de l'élément testé, sinon, il ne sert à rien, me semble-t-il du moins

[Emmanuel Delahaye]

Ca l'est peut etre, mais, ici, c'est dans son propre code source...

Bah non, c'est probablement une définition sur la ligne de commande avec -D... ou alors dans un include (bool.h ?)

Et un ifndef n'est utile, que s'il contient la définition de l'élément testé, sinon, il ne sert à rien, me semble-t-il du moins

Bah non, le rôle de #ifdef ou #ifndef est précisément de savoir si la macro a été définie ou non...

[kidpaddle2]

Suis-je tête-en-l'air ^^ Effectivement, il manque un #define...

-ed-, pour les "fichiers de données", je suppose que tu parles des bibliothèques utilisées... j'ai déposé le code source ainsi que les headers, la bibliothèque et la DLL de fmod dans une archive située sur mon espace FTP.

En ce qui concerne playlist.m3u, il s'agit d'un fichier m3u simplifié (pas de commentaires ['#']), à savoir contenant les chemins des musiques disposés à la suite (conséquemment séparés par '\n').

En espérant que tu trouves ce qui cloche (je n'en doute pourtant pas), merci d'avance.

Edit: Ca aurait pu être contenu dans un paramètre -D, effectivement, mais je voulais tout simplement définir un type bool, sans pour autant en redéfinir un dans le cas d'une compilation C99.

[Emmanuel Delahaye]

-ed-, pour les "fichiers de données", je suppose que tu parles des bibliothèques utilisées...

Non. Je parle de "playlist.m3u" et des .mp3 qui vont avec...

En ce qui concerne playlist.m3u, il s'agit d'un fichier m3u simplifié (pas de commentaires ['#']), à savoir contenant les chemins des musiques disposés à la suite (conséquemment séparés par '\n').

... voilà. Mais ce n'est que ça, OK, je vais me débrouiller avec.

En fait, c'est plus compliqué que je ne le pensais. Avec FMOD, il y a 2 branches : 3.x historique, C) et EX (Classes C++).

Curieusement, la branche EX supporte aussi une interface C, mais elle n'est pas documentée. (enfin, j'ai pas trouvé). Faut-il prendre la doc 3.x ?

[kidpaddle2]

Non, en fait, la version _Ex comporte un header d'interface C (obligatoire pour les compilos autre que Visual, à cause des DLL) dont les fonctions observent la nomenclature suivante :

Au lieu de méthode Classe::Méthode(params), FMOD_Classe_Méthode(Classe*, params)

Tu pourras donc utiliser la doc de Fmodex et traduire en C... mais normalement, concernant les fonctions utilisées, il n'y a pas de problèmes. J'avais fait une autre bibliothèque audio (celle-ci pour mon prochain projet Windows API, en C++) comportant les mêmes fonctions, et celle-ci marchait à merveille.

[kidpaddle2]

Hem... up ?