Discussion :

[hbx360]

Bonjour, je souhaiterais copié les éléments d'une SDL_Surface dans une autre, dans le cadre d'un réalloc.

Voici comment j'ai fait le problème c'est que je trouve ça super lourd :

Ma struct Sprites :

Code :

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

1
2
3
4
5
6
typedef struct
{
  SDL_Rect Ref;
  SDL_Surface *Gfx;
  SDL_Surface *Mask;
}Sprites;

La déclaration de mon tableau de Sprites dans le Sprites.h :

Code :

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

1
2
 
Sprites* sprites;

Ma fonction Sprites_Create :

Code :

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

1
2
3
4
5
6
7
 
inline Sprites* Sprites_Create()
{
  Sprites* S=(Sprites*)malloc(sizeof*S*NB_SPR_MAX);
 
  return S;
}

Ma fonction Réalloc :

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
 
inline Sprites* Sprites_Realloc()
{
  u32 i;
  Sprites* S=(Sprites*)malloc(sizeof*S*(NbSprMax*=2)); /*NbSprMax est déclarer dans mon fichier Sprites.c*/
 
 
  for(i=0;i<NbSpr;i++)
    {
      S[i].Ref.x=sprites[i].Ref.x;
      S[i].Ref.y=sprites[i].Ref.y;
      S[i].Ref.w=sprites[i].Ref.w;
      S[i].Ref.h=sprites[i].Ref.h;
 
      S[i].Gfx->flags=sprites[i].Gfx->flags;
      S[i].Gfx->format=sprites[i].Gfx->format;
      S[i].Gfx->w=sprites[i].Gfx->w;
      S[i].Gfx->h=sprites[i].Gfx->h;
      S[i].Gfx->pitch=sprites[i].Gfx->pitch;
      S[i].Gfx->pixels=sprites[i].Gfx->pixels;
      S[i].Gfx->clip_rect=sprites[i].Gfx->clip_rect;
      S[i].Gfx->refcount=sprites[i].Gfx->refcount;
 
      S[i].Mask->flags=sprites[i].Mask->flags;
      S[i].Mask->format=sprites[i].Mask->format;
      S[i].Mask->w=sprites[i].Mask->w;
      S[i].Mask->h=sprites[i].Mask->h;
      S[i].Mask->pitch=sprites[i].Mask->pitch;
      S[i].Mask->pixels=sprites[i].Mask->pixels;
      S[i].Mask->clip_rect=sprites[i].Mask->clip_rect;
      S[i].Mask->refcount=sprites[i].Mask->refcount;
    }
  return S;
}

y a t-il une solution alternative et plus rapide que de faire ça ?

Merci par avance pour vos réponse.

[Mat.M]

salut eh bien au lieu d'allouer avec malloc ( perso je suis pas fana de malloc je préfère le new du C++ car on sait jamais la taille qu'il faut allouer ) il suffit de créer une SDL_Surface de taille équivalente et attributs équivalents.
Ensuite s'assurer s'il faut verrouiller ou non la SDL_Surface au besoin avec SDL_MUSTLOCK et SDL_LockSurface.
Puis il suffit de copier les pixels comme tu fais

[hbx360]

Merci pour ton aide, je cherche aussi à récupérer les autres élément (donc les indications de ma surface) de ma SDL_Surface et non a recopié mon image dans une autre puisque je transvase notamment

Code :

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

S[i].Gfx->pixels=sprites[i].Gfx->pixels;

.

[hbx360]

Je vais essayer de passer par un double pointeur on verra logiquement ça devrait marcher

[LittleWhite]

Bonjour,

Pour la copie d'une surface, pourquoi ne pas utiliser la fonction de BlitSurface() ? (Je demande juste, car cela me semble plus simple et plus sur, mais je sais aussi que vous pouvez avoir un objectif autre).

[hbx360]

Merci pour ton aide @LittleWhite

Question : est-ce que le SDL_BlitSurface me permettrait de récupérer tous les éléments de SDL_Surface non pas simplement copié une surface dans une autre mais aussi de pouvoir accéder aux autres champs de la SDL_Surface comme pitch, w, h etc.

En faite ce que je voulais c'était créer un tableau de struct Sprites de 4 struct (par exemple) et mon but est de faire une réallocation et de passer à un tableau de struct Sprites de 8 struct pour cela je dois copié tous les éléments de mon 1er tableau de 4 struct vers le 2eme de 8 struct comme ça j'aurai un nouveau tableau ou les 4 struct du précédant tableau serait mi dans les case 0,1,2,3 et les 4 dernière serait vide pour être utiliser.

Je sais pas si je me suis fait bien comprendre c'est pas toujours évident de bien expliqué.

Maintenant voilà comment j'ai fait pour faire mon réalloc si ça peut aider quelqu'un on ne sait jamais (attention je me considère comme un débutant et non comme un professionnel donc mon code est un code de débutant et n'a pas la prétention d'être un code pro) :

Rappel : Ma struct Sprites :

Code :

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

1
2
3
4
5
6
7
 
typedef struct Sprites
{
  SDL_Rect Ref;
  SDL_Surface *Gfx;
  SDL_Surface *Mask;
}Sprites;

J'ai créé dans mon .h un double pointeur de Sprites soit :

Code :

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

Sprites** sprites;

et un define pour la taille max de mon tableau

Code :

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

#define NB_SPR_MAX 4    /*la valeur 4 c'est pour l'exemple* /

Dans mon .c j'ai déclarer une variable :

Code :

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

u32 NbSprMax=NB_SPR_MAX;

si il y a réalloc la nouvelle référence qui sera pris en compte sera NbSprMax pour l'agrandissement du tableau. Qui doublera.


Donc ensuite j'ai créer mon tableau de pointeurs de Sprites avec cette fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
inline Sprites** Sprites_Create()
{
  u32 i;
  Sprites** S=(Sprites**)malloc(sizeof*S*NB_SPR_MAX);
  for(i=0;i<NB_SPR_MAX;i++)
    {
      S[i]=(Sprites*)malloc(sizeof*S[i]);
    }
 
  return S;
}

Ensuite je récupère mes sprites que je met dans mon tabeau de pointeur de struct Sprites puis je demande si mon tableau est rempli en faisant un if.

Si il n'y a plus de place je rentres dans le if :

Code :

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

1
2
3
4
5
 
    if(NbSpr>=NbSprMax) /*NbSpr est le nombre de sprites capturé dans ma planche*/
      {
	sprites=Sprites_Realloc();
      }

et j'appelle ma fonction réalloc dont voici le code :

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
 
inline Sprites** Sprites_Realloc()
{
  u32 i;
  Sprites** S=(Sprites**)malloc(sizeof*S*(NbSprMax*=2));
 
 
  for(i=0;i<NbSprMax;i++)
    {
      if(i<NbSpr) 
	S[i]=NULL; /*je met a NULL ici dans mon exemple NbSpr vaudra 4 donc les 4
 premier pointeur seront a NULL et attendrons les 4 pointeurs de l'ancien tableau*/
      S[i]=(Sprites*)malloc(sizeof*S[i]); /*j'alloue les 5,6,7 et 8eme case */
    }
 
  for(i=0;i<NbSpr;i++) /*je copie les 4 pointeur de struct Sprites de mon
 premier tableau dans le nouveau*/ 
      S[i]=sprites[i];
 
  /*fonction release a faire pour effacer le 1er tableau de pointeur de struct*/
  return S;
}

[LittleWhite]

Bah, je pense que oui. Pour la création de la surface : SDL_CreateRGBSurface() et pour copier les données, SDL_BlitSurface().
Encore plus rapide, peut être : SDL_CreateRGBSurfaceFrom().

Aussi :

Code :

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

Sprites** S=(Sprites**)malloc(sizeof*S*NB_SPR_MAX);

Votre utilisation de malloc me parait étrange. Normalement, c'est sizeof(type).

En C, j'essaie au maximum d'éviter les doubles pointeurs (**).
Sinon, pour le malloc/realloc de Sprites, ça me semble bon.

[hbx360]

Ok merci pour tes conseils et ton aide.

Votre utilisation de malloc me parait étrange. Normalement, c'est sizeof(type).

En fait, j'ai vu (toujours sur internet) que l'on pouvait faire des malloc de cette façon (je ne me souviens plus où j'ai vu ça) donc c'est pour simplifier, ce qui m'évite de faire : Sprites** S=(Sprites**) malloc (NB_SPR_MAX * sizeof(Sprites));. Bon, en fait, effectivement la différence est minime.

En C, j'essaie au maximum d'éviter les doubles pointeurs (**).

Quelle en est la raison ? Manque de clarté dans le code, baisse de performance ?

Sinon, pour le malloc/realloc de Sprites, ça me semble bon.

Merci d'avoir pris le temps de regarder le code.

Je vais regarder de nouveau si je peu me servir des fonctions SDL, SDL_CreateRGBSurface() et SDL_CreateRGBSurfaceFrom() je connais pas cette fonction mais je vais me renseigner.

[Kannagi]

Quel en ai la raison ? Manque de clarté dans le code, baisse de performance ?

ça évite de faire des erreurs , de plus c'est pas le truc le plus facile a manipuler ,je ne parle pas forcément de parcourir les tableaux mais si t'as envie de jouer avec les différent pointeur ça demande une certain rigueur et gymnastique que en général on se passerai bien

[LittleWhite]

En faite j'ai vu (toujours sur internet) que l'on pouvait faire des malloc de cette façon (je ne me souviens plus ou j'ai vu ça) donc c'est pour simplifier ce qui m'évite de faire : Sprites** S=(Sprites**) malloc (NB_SPR_MAX * sizeof(Sprites)); Bon en faite effectivement la différence est minime.

Je vous conseille très fortement de faire un coup de valgrind/Dr Memory sur votre programme par la suite (le plus tôt sera le mieux de toute façon).

Sinon, la réponse de Kannagi est exactement identique à ce que j'aurai dit

[hbx360]

Merci pour vos réponses

[hbx360]

J'ai un problème avec ma fonction Sprites_Release_Realloc qui donc supprime l'ancien tableau.

Voici le code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
inline void Sprites_Release_Realloc(Sprites** S,u32 NbSpr)
{
  u32 i;
  for(i=0;i<NbSpr;i++) 
    {
      free(S[i])); /*L'erreur se trouve ici*/
    }
 
  free(S);
  S=NULL;
}

J'ai un core dumped mais si je désactive le code free(S[i]); mon code marche normalement.

Je n'arrive pas à comprendre ce qui se passe ; j'ai l'impression que soit S[i] (donc mon ancien tableau de pointeur) est déjà désalloué ou bien que free n'arrive pas à le désalouer.

Si vous voyer ou est le problème merci par avance.

[Kannagi]

Les doubles pointeurs c'est cool

Impossible de te dire ou ça coince , initialise tout tes pointeur a NULL.
ensuite tu fais ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
inline void Sprites_Release_Realloc(Sprites** S,u32 NbSpr)
{
  u32 i;
  for(i=0;i<NbSpr;i++) 
    {
      if(S[i] != NULL) free(S[i])); /*L'erreur se trouve ici*/
    }
 
   if(S != NULL) free(S);
  S=NULL;
}

Et si ça planete encore ben y'a une adresse pas correct dans ton code

Bref tu pourrait aussi debuggais toi même faire des printf voir sur quel boucle ça plante ,quel adresse ect ect

[hbx360]

Merci pour ton aide Kannagi je vais continuer a regarder sinon j'essayerais de faire comme ma dit LittleWhite avec le SDL_CreateRGBSurfaceFrom.

Bref tu pourrait aussi debuggais toi même faire des printf voir sur quel boucle ça plante ,quel adresse ect ect

En faite dans ma fonction j'ai mis ou ça bugger.

Salut.

[hbx360]

Alors en faisant ton code Kannagi j'ai donc un core dumped donc j'en conclu que sa vient du free(S[i]) qu'il y a un problème.

Est-ce que je peut faire ça pour désallouer la mémoire j'ai essayé sa marche mais je sais pas si c'est bien de faire de cette façon:

Code :

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

1
2
3
 
      for(i=0;i<NbSpr;i++)
         S[i]=NULL;

Est-ce que faire :

Code :

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

S[i]=NULL;

c'est la même chose que de faire

Code :

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

free(S[i]);

?

[Mat.M]

Merci pour ton aide Kannagi je vais continuer a regarder sinon j'essayerais de faire comme ma dit LittleWhite avec le SDL_CreateRGBSurfaceFrom.

la SDL c'est précisément conçu pour éviter de gérer les allocations mémoires et s'embêter avec malloc realloc.
Donc oui il faut utiliser les fonctions de la SDL plutôt que de tripatouiller avec malloc

[Kannagi]

Alors en faisant ton code Kannagi j'ai donc un core dumped donc j'en conclu que sa vient du free(S[i]) qu'il y a un problème.

Est-ce que je peut faire ça pour désallouer la mémoire j'ai essayé sa marche mais je sais pas si c'est bien de faire de cette façon:

Code :

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

1
2
3
 
      for(i=0;i<NbSpr;i++)
         S[i]=NULL;

Est-ce que faire :

Code :

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

S[i]=NULL;

c'est la même chose que de faire

Code :

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

free(S[i]);

?

Pas du tout si tu fais cela , on appelle ça une fuite de mémoire
ça veut dire que tu as une adresse que tu ne pourra plus y accéder et qui est en plus ne peut plus être allouer (vu qu'on peut plus la liberer) ,Ton OS considère que tu possède toujours ce bloc de mémoire et donc ton programme va augmenter continuellement en mo puis go , jusqu'a le programme fermera ou ne sera plus utilisable (si ça monte 2GO mémoire t'imagine bien que ça va faire ramer l'ordi).

[hbx360]

Merci pour vos réponses

[hbx360]

EN faite c'est cette ligne qui ne va pas :

Code :

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

S[i]=Spr[i];

dans ma fonction réa

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
 
inline Sprites** Sprites_Realloc(Sprites** Spr,u32 NbSpr)
{
  u32 i;
  Sprites** S=(Sprites**)malloc((NbSprMax*=2)*sizeof(S));
 
 
  for(i=0;i<NbSprMax;i++)
    {
      if(i<NbSpr)
	S[i]=Spr[i]; /*--------> c'est quand je fait ça que ça ne va pas*/
 
      else
	S[i]=(Sprites*)malloc(sizeof*S[i]);
    }
 
  Sprites_Release_Realloc(Spr,NbSpr);
 
  return S;
}

j'ai l'impression que le faite de copié les pointeurs Spr[i] dans S[i] empêche la désallocation.

S[i]=Spr[i] veut bien dire : je prends le pointeur qui pointe sur la struct Sprites et je le copie dans le nouveau tableau de pointeur que j'ai crée.

Et si au lieu de vouloir désalouer Spr[i] je désalouais juste Spr ce qui libérerait mon ancien tableau de pointeur ?
Comme Spr[i] et S[i] pointe sur la même adresse le faite de désalouer Spr[i] voudrait en faite dire je désaloue ma struct Sprites même si S[i] pointe sur elle sa ne pourrait pas fonctionner ?

Donc je vais partir sur ce principe là c'est dire faire juste pour Spr un free et je ne désaloue pas Spr[i] au risque d'avoir plusieurs tableau qui traine dans ma mémoire.