bonjour,

j'essaye de modifier des images png en travaillant directement par lecture binaire du fichier image.
comme je modifie mon image, je dois recalculer des CRC avec les valeurs des pixels de mon image.
J'ai donc utilisé le calcul CRC donné dans les spec png.
Lorsque j'ouvre mon image modifiée avec the Gimp, il me dit qu'il y a une erreur de lecture.

je n'arrive pas à trouver mon erreur..... est-ce-que quelqu'un aurait une idée ???


voici mon 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
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
 
struct pixel {
  unsigned int red;
  unsigned int green;
  unsigned int blue;
  unsigned int alpha;
  unsigned char crc[4];
  unsigned int len;
  int flag;
};
 
/* pour les listes chainées */
struct l_pix {
  struct pixel * pix;
  struct l_pix * prev;
  struct l_pix * next;
};
 
struct accesPix {
  struct l_pix * first;
  struct l_pix * last;  
};
.....
 
/* Make the table for a fast CRC. */
void 
make_crc_table(void) {
  unsigned long c;
  int n, k;
 
  for (n = 0; n < 256; n++) {
    c = (unsigned long) n;
    for (k = 0; k < 8; k++) {
      if (c & 1) {
	c = 0xedb88320L ^ (c >> 1);
      } else {
	c = c >> 1;
      }
    }
    crc_table[n] = c;
  }
  crc_table_computed = 1;
}
 
/* Update a running CRC with the bytes buf[0..len-1]--the CRC
   should be initialized to all 1's, and the transmitted value
   is the 1's complement of the final running CRC (see the
   mkCrc() routine below)). */
 
unsigned long 
update_crc(unsigned long crc, unsigned char *buf,int len) {
  unsigned long c = crc;
  int n;
 
  if (!crc_table_computed) {
    make_crc_table();
  }
  for (n = 0; n < len; n++) {
    c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
  }
  return c;
}
 
/* Return the CRC of the bytes buf[0..len-1]. */
unsigned long 
mkCrc(unsigned char *buf, int len) {
  return update_crc(0xffffffffL, buf, len) ^ 0xffffffffL;
}
 
/************************************************************************
 * calcCRC : calcul des crc a partir des chunks IDAT modifiés 
 *
 ***********************************************************************/
int
calcCRC(struct accesPix *lpix) {
  struct l_pix * tmp;
  unsigned char buf[256];
  unsigned long crc;
  int i, len=0;
 
  tmp = lpix->first;
  /* 1er pixel d'un chunk est avec len!=0, dernier pixel est avec
   * flag=1
   */
  while(tmp != NULL) {
    if(tmp->pix->len != 0) {
      len = tmp->pix->len;
      fprintf(stderr,"pix->len=<%d>\n",tmp->pix->len);
      bzero(buf,256);
    }
    for(i=0; i<(len/4); i++) {
      memcpy(&buf[i],(&(tmp->pix->red)), 1); 
      memcpy(&buf[i],(&(tmp->pix->green)), 1); 
      memcpy(&buf[i],(&(tmp->pix->blue)), 1); 
      memcpy(&buf[i],(&(tmp->pix->alpha)), 1); 
 
      if(tmp->pix->flag == 1) {
	crc = mkCrc(buf, len);
	fprintf(stderr,"calcCRC : crc =<%ld> <%8x>\n",crc, crc);
	memcpy(&(tmp->pix->crc),&crc,4);
      }
 
      tmp = tmp->next;
    }
  }
 
  return 0;
}
merci