Problème de pointeur (encore un)

Version imprimable

1 pièce(s) jointe(s)

Tout d'abord bonjour :)

voilà je suis en plein dans (la tentative de) la programmation d'un compresseur d'image en C

Mais un problème réside : je stock l'image dans un pointeur, à l'aide d'une fonction "void ouvrir_fichier(struct image *image)"
mais impossible d'utiliser le pointeur en dehors de la fonction ouvrir_fichier
bon je vous passe les bout de code :

Code:

1
2
3
4
5
6
7
8
9
10
11
int main(int argc, char** argv)
{
    struct taille taille;
    struct image *image = NULL;
    unsigned char *entete = NULL;
    unsigned char *temp = NULL;
 
    taille=taille_fichier(argv[1]);
    ouvrir_fichier(taille,argv[1],temp,entete,image);
    printf("x : %d\ny : %d\nbleu : %d\nvert : %d\nrouge : %d\n" ,image[60].x,image[60].y,image[60].bleu,image[60].vert,image[60].rouge);
}

Code:

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
void ouvrir_fichier(struct taille taille,char *file,unsigned char *temp,unsigned char *entete,struct image *image)
{
     int i;
    FILE *fichier;
    entete = malloc (54 * sizeof *entete);
    temp = malloc( taille.taille * sizeof *temp );
    image=malloc(taille.taille* sizeof *image);
    if (image == NULL || temp == NULL || entete == NULL)
    {
              fprintf(stderr,"Allocation impossible \n");
              exit(EXIT_FAILURE);
    }
    //Ouverture du Fichier
    fichier=fopen(file,"rb");
    if(!fichier)
    {
                printf("Erreur d'ouverture du fichier");
                exit(-1);
    }
 
    //Copie de l'entete de l'image
    fread(entete,1,54,fichier);
    if (entete == NULL)
    {
               printf("Erreur de copie de l'entete");
               exit(-1);
    }
    //Copie de l'image
    fread(temp,1,taille.taille,fichier);
    if (temp == NULL)
    {
              printf("Erreur de copie de l'image");
              exit(-1);
    }
    fclose(fichier);
    //Traitement de l'image
    for(i=0;i<(taille.largeur)*(taille.hauteur);i=i+3)
    {
                                  image[i].bleu=temp[i];
                                  image[i].vert=temp[i+1];
                                  image[i].rouge=temp[i+2];
                                  image[i].x=i%taille.largeur;
                                  image[i].y=(i-(i%taille.largeur))/taille.largeur;
    }
    // Liberation de la mémoire allouée à *temp
    free(temp);
}

Voilà en esperant que vous pourrez m'aider, je vous remercie d'avance

EDIT : je joint les fichiers sources complets si besoin...

29/05/2006, 11h29
Nasky
Salut et bienvenue sur les forums de Developpez ;)

C'est normal ton erreur. Tu alloues de la mémoire au pointeur dans la fonction. Mais tu ne retournes pas ce pointeur donc tu perds le pointeur en quelque sorte.
La solution : soit retourner le pointeur "image" et donc le récupérer dans la main mais dans ce cas là, pas besoin de le passer en argument. Tu déclares "image" en local à la fonction puis tu le retournes.

Code:

image = ouvrir_fichier(...);

Soit tu passes l'adresse du pointeur.

Code:

ouvrir_image(...,&image) ;

Mais ta fonction devient :
Code:

1 2 *image=malloc(taille.taille* sizeof *image); // rajouter une étoile partout
Et dans ce cas-là, pas besoin de retourner le pointeur.

Nas'
29/05/2006, 11h46
Arry_C
Merci pour cette réponse si rapide :)

J'ai essayé la 2eme solution et :

Code:

ouvrir_fichier(taille,argv[1],temp,entete,&image)

Code:

void ouvrir_fichier(struct taille taille,char *file,unsigned char *temp,unsigned char *entete,&image)

Et il me fait "error before token "&"" dans la définition de la fonction.

Ensuite j'ai essayer la 1er Solution et :

Code:

image = ouvrir_fichier(taille,argv[1],temp,entete)

et là l'erreur est : "incompatible type in assignement"

alors que je retourne bien un "struct image" et que image est définie comme suit :
Code:

1 2 struct image *image = NULL; image=malloc(taille.taille* sizeof *image);

Citation:

Envoyé par Arry_C

bon je vous passe les bout de code :

Ce code est incomplet et ne peut être compilé.

EDIT: Voici ton code remis au carré. Pose des questions si tu ne comprends pas.

Code:

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
 
#include <stdio.h>
#include <stdlib.h>
 
/* 0=normal 1=debug */
#define DBG 1
 
#define HEADER_SIZE 54
 
struct taille
{
   unsigned long filesize;      /* [2]  32-bit */
   unsigned long offset;        /* [10] 32-bit */
   unsigned long headersize;    /* [14] 32-bit */
   unsigned long largeur;       /* [18] 32-bit */
   unsigned long hauteur;       /* [22] 32-bit */
   unsigned short planes;       /* [26] 16-bit */
   unsigned short bit_per_pix;  /* [28] 16-bit */
   unsigned long compression;   /* [30] 32-bit */
   unsigned long sizeimage;     /* [34] 32-bit */
   unsigned long resolution_hor;  /* [38] 32-bit */
   unsigned long resolution_ver;  /* [42] 32-bit */
   unsigned long coul_uti;      /* [46] 32-bit */
   unsigned long coul_imp;      /* [50] 32-bit */
};
 
struct image
{
   unsigned char bleu;
   unsigned char vert;
   unsigned char rouge;
   size_t x;
   size_t y;
};
 
static struct image *lecture_image (struct taille *p_taille
                                             , char const *file)
{
   struct image *image = NULL;
   if (p_taille->sizeimage != 0)
   {
      unsigned char *temp = malloc (p_taille->sizeimage * sizeof * temp);
 
      if (temp != NULL)
      {
         //Ouverture du Fichier
         FILE *fichier = fopen (file, "rb");
         if (fichier != NULL)
         {
            //Ignorer de l'entete de l'image
            {
               unsigned char entete[HEADER_SIZE];
               fread (entete, 1, sizeof entete, fichier);
            }
 
            //Copie de l'image
            fread (temp, 1, p_taille->sizeimage, fichier);
            fclose (fichier), fichier = NULL;
 
            {
               image = malloc (p_taille->sizeimage * sizeof * image);
               if (image != NULL)
               {
                  //Traitement de l'image
                  {
                     size_t i;
                     for (i = 0; i < p_taille->largeur * p_taille->hauteur; i += 3)
                     {
                        image[i].bleu = temp[i];
                        image[i].vert = temp[i + 1];
                        image[i].rouge = temp[i + 2];
                        image[i].x = i % p_taille->largeur;
                        image[i].y = (i - (i % p_taille->largeur)) / p_taille->largeur;
                     }
                  }
               }
               else
               {
                  fprintf (stderr, "Allocation impossible\n");
               }
            }
         }
         else
         {
            fprintf (stderr, "Erreur d'ouverture du fichier\n");
         }
 
         assert (fichier == NULL);
 
         free (temp), temp = NULL;
      }
      else
      {
         fprintf (stderr, "Allocation impossible\n");
      }
      assert (temp == NULL);
   }
   else
   {
      fprintf (stderr, "Taille nulle\n");
   }
   return image;
}
 
static unsigned long bytes2ul (unsigned char const *p)
{
   unsigned long ul = 0;
   /* LSB en tete : */
   ul |= p[0] << (8 * 0);
   ul |= p[1] << (8 * 1);
   ul |= p[2] << (8 * 2);
   ul |= p[3] << (8 * 3);
 
   return ul;
}
 
static unsigned short bytes2us (unsigned char const *p)
{
   unsigned short us = 0;
   /* LSB en tete : */
   us |= p[0] << (8 * 0);
   us |= p[1] << (8 * 1);
 
   return us;
}
 
static int taille_fichier (struct taille *p_taille, char const *fname)
{
   int err = 0;
 
   if (p_taille != NULL && fname != NULL && *fname != 0)
   {
      //Ouverture du Fichier
      FILE *fichier = fopen (fname, "rb");
 
      printf ("chargement de '%s'\n", fname);
 
      if (fichier != NULL)
      {
         unsigned char entete[HEADER_SIZE];
         fread (entete, 1, sizeof entete, fichier);
 
         if (strncmp (entete, "BM", 2) == 0)
         {
#if DBG
#define PRT(field, ofs, cmt)\
   ,printf ("[%2d] %-14s = %lu %s\n", ofs, #field, (unsigned long) p_taille->field, cmt)
#else
#define PRT(field, ofs, cmt)
#endif
 
#define UPD_UL(field, ofs, cmt)\
   p_taille->field = bytes2ul (entete + ofs)\
   PRT (field, ofs, cmt)
 
#define UPD_US(field, ofs, cmt)\
   p_taille->field = bytes2us (entete + ofs)\
   PRT (field, ofs, cmt)
 
            UPD_UL (filesize, 2, "bytes");
            UPD_UL (offset, 10, "bytes");
            UPD_UL (headersize, 14, "bytes");
            UPD_UL (largeur, 18, "pix");
            UPD_UL (hauteur, 22, "pix");
            UPD_US (planes, 26, "");
            UPD_US (bit_per_pix, 28, "");
            UPD_UL (compression, 30
                    , "(0=pas de comp. 1=RLE 8bits 2=RLE 4bits 3=bitfield enc.)");
            UPD_UL (sizeimage, 34, "bytes");
            UPD_UL (resolution_hor, 38, "pix/metre");
            UPD_UL (resolution_ver, 42, "pix/metre");
            UPD_UL (coul_uti, 46, "");
            UPD_UL (coul_imp, 50, "");
#undef UPD_US
#undef UPD_UL
#undef PRT
 
         }
         else
         {
            fprintf (stderr, "not a bit map\n");
            err = 1;
         }
      }
      else
      {
         err = 1;
      }
   }
   else
   {
      err = 1;
   }
   return err;
}
 
int main (int argc, char **argv)
{
   if (argc > 1)
   {
      char const *fname = argv[1];
      struct taille taille =
         {
            0
         };
      int err = taille_fichier (&taille, fname);
      if (!err)
      {
         struct image *image = lecture_image (&taille, argv[1]);
         if (image != NULL)
         {
            printf ("x : %d\n"
                    "y : %d\n"
                    "bleu : %d\n"
                    "vert : %d\n"
                    "rouge : %d\n"
                    , (int) image[60].x
                    , (int) image[60].y
                    , (int) image[60].bleu
                    , (int) image[60].vert
                    , (int) image[60].rouge);
            free (image), image = NULL;
         }
         else
         {
            fprintf (stderr, "erreur image\n");
         }
      }
      else
      {
         fprintf (stderr, "erreur fichier\n");
      }
   }
   else
   {
      fprintf (stderr, "erreur parametres\n");
   }
   return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
chargement de 'Rhododendron.bmp'
[ 2] filesize       = 17362 bytes
[10] offset         = 978 bytes
[14] headersize     = 40 bytes
[18] largeur        = 128 pix
[22] hauteur        = 128 pix
[26] planes         = 1
[28] bit_per_pix    = 8
[30] compression    = 0 (0=pas de comp. 1=RLE 8bits 2=RLE 4bits 3=bitfield enc.)
[34] sizeimage      = 16384 bytes
[38] resolution_hor = 3779 pix/metre
[42] resolution_ver = 3779 pix/metre
[46] coul_uti       = 231
[50] coul_imp       = 231
x : 60
y : 0
bleu : 8
vert : 8
rouge : 66
 
Press ENTER to continue.

29/05/2006, 11h52
Nasky

Pour la 1er solution, faut pas faire ainsi. Faut écrire ça :

Code:

void ouvrir_fichier(struct taille taille,char *file,unsigned char *temp,unsigned char *entete,struct image **image)

C'est juste au moment de l'appel de la fonction que tu mets l'opérateur d'adresse & .
Pour la deuxième solution, t'as bien laissé le même code que t'as déjà fait mais en faisant un

Code:

return image;

à la fin de la fonction? T'as bien pensé à modifier le prototype de la fonction et tout ? Y'a pas de raison que ça ne marche pas...

Nas'
29/05/2006, 12h00
Arry_C
Pour la première solution, oui j'ai bien tout modifier dans les définitions des fonctions.

Par contre pour la seconde méthode je sais pas si ça peut marcher... ou alors je sais pas comment car j'ai des chose comme suis :
Code:

1 2 3 4 5 6 image[i].bleu=temp[i]; image[i].vert=temp[i+1]; image[i].rouge=temp[i+2]; image[i].x=i%taille.largeur; image[i].y=(i-(i%taille.largeur))/taille.largeur;

Bon je vais essayer d'être plus clair.

Code:

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
 
void ouvrir_fichier(struct taille taille,char *file,unsigned char *entete,struct image **image)
{
      int i;
    FILE *fichier;
    unsigned char *temp;
 
    entete = malloc (54 * sizeof *entete);
    temp = malloc( taille.taille * sizeof *temp );
    *image=malloc(taille.taille* sizeof *image);
    if (image == NULL || temp == NULL || entete == NULL)
    {
              fprintf(stderr,"Allocation impossible \n");
              exit(EXIT_FAILURE);
    }
    //Ouverture du Fichier
    fichier=fopen(file,"rb");
    if(!fichier)
    {
                printf("Erreur d'ouverture du fichier");
                exit(-1);
    }
 
    //Copie de l'entete de l'image
    fread(entete,1,54,fichier);
    if (entete == NULL)
    {
               printf("Erreur de copie de l'entete");
               exit(-1);
    }
    //Copie de l'image
    fread(temp,1,taille.taille,fichier);
    if (temp == NULL)
    {
              printf("Erreur de copie de l'image");
              exit(-1);
    }
    fclose(fichier);
    //Traitement de l'image
    for(i=0;i<(taille.largeur)*(taille.hauteur);i=i+3)
    {
                                  *image[i].bleu=temp[i];
                                  *image[i].vert=temp[i+1];
                                  *image[i].rouge=temp[i+2];
                                  *image[i].x=i%taille.largeur;
                                  *image[i].y=(i-(i%taille.largeur))/taille.largeur;
    }
    // Liberation de la mémoire allouée à *temp
    free(temp);
}

l'erreur :
76 C:\Documents and Settings\Arry\Bureau\comp\fichier.c request for member `bleu' in something not a structure or union

pour tout le reste des *image[i]. c'est pareil.

Donc voilà :?

29/05/2006, 18h07
J&B

Le plus simple est encore de mettre le tableau de point image en global comme ça pas de problème de transimission de tableau de structure. Sinon on peut créer une autre structure qui contient le tableau de point et transmettre cette sturcture par reference.
29/05/2006, 20h12
Emmanuel Delahaye

Citation:

Envoyé par J&B

Le plus simple est encore de mettre le tableau de point image en global

Ben tient... Goretisation de Force 7 (minimum). Sans 'static' on passe à 10 !

http://emmanuel-delahaye.developpez.com/goret.htm

Trois Pater et un Avé...
29/05/2006, 22h36
J&B

Pour un debutant comme Arry_c (je le connait personnelement) la goretisation force 10 est parfois plus compréhenssible que la transmission d'un tableau de structure de taille variables en argument ( le tableau pas la structure) 8O . Et une petite variable globale pour débugger avant de passer à autre chose ne fait jamais de mal au début si elle est rattrapée.
29/05/2006, 22h54
Emmanuel Delahaye

Citation:

Envoyé par J&B

Et une petite variable globale pour débugger avant de passer à autre chose ne fait jamais de mal au début si elle est rattrapée.

L'expérience (15 ans de métier) prouve que si on ne fait pas bien tout de suite, on ne le fait jamais...
29/05/2006, 23h06
J&B

L'experience (une semaine avec des néophite complet ) montre que quand un debutant cherche à faire compliqué alors qu'il ne sait pas faire simple ça donne souvent :aie: . Et puis la première fois que j'ai programmer j'ai bien commencer avec 60 variables globales et je detester ça maintenant mais bon :roll: . ( surtout que ça fesait trois jour qu'il était sur ce problème)
30/05/2006, 09h24
Médinoc

Et puis, il y a des cas où c'est indispensable:
Sous Windows, une variable globale (ou un équivalent : Variable locale statique, variable de classe C++ statique) est l'unique moyen de mémoriser des données comme le HMODULE d'une DLL indépendament de son nom de fichier...

Et je ne parle pas du thread-local storage, qui est en lui-même une pratique de variables globales.
30/05/2006, 14h39
Arry_C

Bon ben J&B est passé à ma maison !
Et bon ben on va ce contenter de sa solution douteuse puisque j'en ai pas d'autre sous la main ^^:mouarf:

Merci à tous pour vous être pencher sur le problème 8-)
30/05/2006, 18h27
Arry_C

Citation:

Envoyé par Emmanuel Delahaye

EDIT: Voici ton code remis au carré. Pose des questions si tu ne comprends pas.

Attention : Selon la spec, le bitmap commence à 'offset' bytes... (non corrigé). D'autre part, les RGB seraient tous les 4 bytes et non tous les 3...

Merci pour avoir remis notre programme au carré (je viens de voir ça en fait) mais comme on a fini cette partie et que je comprend pas grand chose (peut-être due au fait que j'ai commencer à faire du C il y a 1mois) je pense que je vais garder mon code mal écrit :)

Concernant le codage des couleurs :
* Les images en couleurs réelles utilisent 24 bits par pixel, ce qui signifie qu'il faut 3 octets pour coder chaque pixel, en prenant soin de respecter l'ordre de l'alternance bleu, vert et rouge.
30/05/2006, 19h38
Arry_C

Nan justement c'est pas ça que ça veut dire, editeur hexa à l'appuie.
C'est juste que les pixels sont codés sur 3 octets, mais par contre une ligne d'image doit être un multiple de 4.
En fait pour simplifier la tache on ne travaille qu'avec des images dont la largeur est multiple de 8, ce qui évince cette possibilité
30/05/2006, 19h47
Emmanuel Delahaye

Citation:

Envoyé par Arry_C

Nan justement c'est pas ça que ça veut dire, editeur hexa à l'appuie.
C'est juste que les pixels sont codés sur 3 octets, mais par contre une ligne d'image doit être un multiple de 4.
En fait pour simplifier la tache on ne travaille qu'avec des images dont la largeur est multiple de 8, ce qui évince cette possibilité

:oops: :oops: :oops: