manipulations bit à bit

Version imprimable

bonjour

je recupère la valeur du pixel d'une image dans un entier. Le pixel est codé en RGB. Cela signifie que mon entier contient 4 informations stockées chacune sur un octet : la valeur pour le rouge, pour le vert, pour le bleu et pour l'alpha.
je souhaite récupérer chacune de ces informations séparément dans un entier.

Pour celà j'ai écrit 3 fonctions opérant chacune un décalage et appliquant un masque pour obtenir les valeurs pour les composantes red, green et blue.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int redFromRGB(int *rgb){ return ((*rgb >> 16) & 0xff); } int greenFromRGB(int *rgb){ return ((*rgb >> 8) & 0xff); } int blueFromRGB(int *rgb){ return((*rgb) & 0xff); }
Problème : je récupère toujours 0 pour les composants red et green.
Où est mon erreur ?

merci pour votre aide :?

Salut,

Citation:

Envoyé par floopi51

Problème : je récupère toujours 0 pour les composants red et green.
Où est mon erreur ?

merci pour votre aide :?

Peut-être un problème d'endianess? essaie avec quelque chose du genre
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #include <stdio.h> int blueFromRGB(int *rgb); int blueFromRGB(int *rgb) { int tempval = *rgb; return (tempval & 0xff); } int main() { int mycolor = 0x123456; printf ("blue : %02x",blueFromRGB(&mycolor )) ; return 0;}
A+

Pfeuh

05/01/2009, 17h24
diogene

Ca marche pour moi. Comment et avec quelle valeur appelles-tu tes fonctions ?

voici l'extrait de code ou j'appelle mes fonctions :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
  int* c_pix;
 ....
      red = redFromRGB(c_pix);
      green = greenFromRGB(c_pix);
      blue = blueFromRGB(c_pix);
 
      fprintf(stderr,"*c_pix=<%d>\n",*c_pix);
      fprintf(stderr,"red=<%d>\n",pix->red);
      fprintf(stderr,"green=<%d>\n",pix->green);
      fprintf(stderr,"blue=<%d>\n",pix->blue);

si j'ai *c_pix = 127.
je recupère :
red = 0
green = 0
blue = 127

Citation:

Envoyé par floopi51

bonjour

je recupère la valeur du pixel d'une image dans un entier. Le pixel est codé en RGB. Cela signifie que mon entier contient 4 informations stockées chacune sur un octet : la valeur pour le rouge, pour le vert, pour le bleu et pour l'alpha.
je souhaite récupérer chacune de ces informations séparément dans un entier.
Problème : je récupère toujours 0 pour les composants red et green.
Où est mon erreur ?

Je ne vois pas trop de problèmes avec ce code, à part que tout devrait se faire en unsigned...

Ceci :

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
 
#include <stdio.h>
 
int redFromRGB (int *rgb)
{
   return ((*rgb >> 16) & 0xff);
}
 
int greenFromRGB (int *rgb)
{
   return ((*rgb >> 8) & 0xff);
}
 
int blueFromRGB (int *rgb)
{
   return ((*rgb) & 0xff);
}
 
int main (void)
{
   unsigned long rgb = 1;
 
   while (rgb != 0)
   {
      printf ("R=%d ", redFromRGB ((int *) &rgb));
      printf ("G=%d ", greenFromRGB ((int *) &rgb));
      printf ("B=%d\n", blueFromRGB ((int *) &rgb));
      rgb <<= 1lu;
   }
 
   return 0;
}

donne

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
 
R=0 G=0 B=1
R=0 G=0 B=2
R=0 G=0 B=4
R=0 G=0 B=8
R=0 G=0 B=16
R=0 G=0 B=32
R=0 G=0 B=64
R=0 G=0 B=128
R=0 G=1 B=0
R=0 G=2 B=0
R=0 G=4 B=0
R=0 G=8 B=0
R=0 G=16 B=0
R=0 G=32 B=0
R=0 G=64 B=0
R=0 G=128 B=0
R=1 G=0 B=0
R=2 G=0 B=0
R=4 G=0 B=0
R=8 G=0 B=0
R=16 G=0 B=0
R=32 G=0 B=0
R=64 G=0 B=0
R=128 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
R=0 G=0 B=0
 
Process returned 0 (0x0)   execution time : 0.035 s
Press any key to continue.

ce qui me parait normal.

Et je suggère de ne faire qu'une fonction qui charge une structure rgb...

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
 
#include <stdio.h>
 
struct rgb
{
   unsigned r;
   unsigned g;
   unsigned b;
};
 
void getFromRGB (struct rgb *p_rgb, unsigned long i_rgb)
{
   p_rgb->r = (i_rgb >> (8*2)) & 0xFF;
   p_rgb->g = (i_rgb >> (8*1)) & 0xFF;
   p_rgb->b = (i_rgb >> (8*0)) & 0xFF;
}
 
int main (void)
{
   unsigned long i_rgb = 1;
 
   while (i_rgb != 0)
   {
      struct rgb rgb;
 
      getFromRGB (&rgb, i_rgb);
 
      printf ("R=%d ", rgb.r);
      printf ("G=%d ", rgb.g);
      printf ("B=%d\n",rgb.b);
      i_rgb <<= 1lu;
   }
 
   return 0;
}

Citation:
Envoyé par floopi51
voici l'extrait de code ou j'appelle mes fonctions :
Code:

1 2 3 4 5 6 7 8 9 10 11 int* c_pix; .... red = redFromRGB(c_pix); green = greenFromRGB(c_pix); blue = blueFromRGB(c_pix); fprintf(stderr,"*c_pix=<%d>\n",*c_pix); fprintf(stderr,"red=<%d>\n",pix->red); fprintf(stderr,"green=<%d>\n",pix->green); fprintf(stderr,"blue=<%d>\n",pix->blue);
si j'ai *c_pix = 127.
je recupère :
red = 0
green = 0
blue = 127
Si tu passes des pointeurs non initialisés, il se passe n'importe quoi. Le comportement est indéfini.

05/01/2009, 17h42
crocodilex

Citation:

Envoyé par floopi51

si j'ai *c_pix = 127.
je recupère :
red = 0
green = 0
blue = 127

Où est le problème ?
05/01/2009, 18h01
floopi51

:oops:
effectivement vu comme ça il n'y a pas de problème.
mais sachant que je recupère les données dans une image qui n'est pas toute bleue, j'ai un problème......:aie:

celà doit venir de ma façon de lire les données....
en tout cas merci pour vos réponses.
je continue de chercher........:bug:
05/01/2009, 18h11
floopi51

en relisant mon code je viens de voir que je ne lisais qu'un octet dans mon fichier au lieu de 4...... donc je ne pouvais pas avoir 4 informations dans mon entier :marteau:

merci.

re-... suite :

j'utilise la fonction fread pour récupérer mes 4 octets dans un fichier.
quand j'édite mon fichier en hexa, les données sont dans l'ordre : 78 9c ed 7d.

Lorsque j'affiche la valeur récupérée, j'obtiens : 7d ed 9c 78.

Pourquoi les valeurs sont-elles inversées ??

voici mon code :

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
 
int * c_pix
 
....
 
      c_pix = (int*)malloc(sizeof(int));
      if(c_pix == NULL) {
	fprintf(stderr,"Out of memory\n");
	return 1;
      }
      fread(c_pix, 4, 1, fileIn);
 
      /* allocation de la structure de données */
      pix = (struct pixel*)malloc(sizeof(struct pixel));
      if(pix == NULL) {
	fprintf(stderr,"Out of memory\n");
	return 1;
      }
      pix->red = redFromRGB(c_pix);
      pix->green = greenFromRGB(c_pix);
      pix->blue = blueFromRGB(c_pix);
 
	printf("*c_pix=<%08x>\n",*c_pix);
	printf("red=<%d>\n",pix->red);
	printf("green=<%d>\n",pix->green);
	printf("blue=<%d>\n",pix->blue);

merci

05/01/2009, 19h29
Emmanuel Delahaye
Citation:

Envoyé par floopi51

re-... suite :

j'utilise la fonction fread pour récupérer mes 4 octets dans un fichier.
quand j'édite mon fichier en hexa, les données sont dans l'ordre : 78 9c ed 7d.

Lorsque j'affiche la valeur récupérée, j'obtiens : 7d ed 9c 78.

Pourquoi les valeurs sont-elles inversées ??

Parce que la représentation des entiers peut varier d'une machine à l'autre. Je ne sais pas quelle est la spec de ton fichier, mais l'usage est MSB en tête (comme pour le réseau). Pour lire ce format de manière portable, je recommande ;
Code:

1 2 3 4 5 6 7 8 { unsigned long x = 0; x |= (fgetc(fp) << (8ul * 3); /* MSB en tete */ x |= (fgetc(fp) << (8ul * 2); x |= (fgetc(fp) << (8ul * 1); x |= (fgetc(fp) << (8ul * 0);
Evidemment, une fonction serait toute indiquée...
06/01/2009, 09h36
pfeuh

Citation:

Envoyé par floopi51

quand j'édite mon fichier en hexa, les données sont dans l'ordre : 78 9c ed 7d.
Lorsque j'affiche la valeur récupérée, j'obtiens : 7d ed 9c 78.

Serais-tu en train de lire un fichier ".bmp"? La spec indique que pour une couleur 24 bits, on donne quatre octets par pixel, dans l'ordre bleu, vert, rouge et un quatrième inutilisé. Attends toi à une autre surprise, le bitmap contient les lignes de la dernière à la première.

une spec des .bmp

A+

Pfeuh
06/01/2009, 10h27
floopi51

Citation:

Envoyé par pfeuh

Serais-tu en train de lire un fichier ".bmp"? La spec indique que pour une couleur 24 bits, on donne quatre octets par pixel, dans l'ordre bleu, vert, rouge et un quatrième inutilisé. Attends toi à une autre surprise, le bitmap contient les lignes de la dernière à la première.

une spec des .bmp

A+

Pfeuh

non je lis un fichier .png. Les caractéristiques sont : image truecolor, bit-depth=8.
06/01/2009, 10h39
pfeuh

Citation:

Envoyé par floopi51

non je lis un fichier .png. Les caractéristiques sont : image truecolor, bit-depth=8.

Ah, ça je ne connais pas trop, mais je crois que c'est comme un .gif, il y a une palette de 256 couleurs (je ne sais pas si c'est en 24 ou 32 bits, voir une spec .png) et chaque pixel est un index 0-255 dans la table des couleurs (la palette). Je crois qu'il y a en plus une compression pour les pixels consécutifs de la même couleur.

A+

Pfeuh
06/01/2009, 10h41
floopi51

Citation:

Envoyé par Emmanuel Delahaye

Parce que la représentation des entiers peut varier d'une machine à l'autre. Je ne sais pas quelle est la spec de ton fichier, mais l'usage est MSB en tête (comme pour le réseau). Pour lire ce format de manière portable, je recommande ;

le fichier que je lis est de type png. J'ai bien lu les spec de l'entête, je la recupère avant pour lire ensuite les pixels. Je recupère chaque pixel dans un entier.
je fais l'edition du fichier en héxa sur la même machine que celle où je fais tourner mon programme C. Je m'attends donc à ce que la lecture du fichier se fasse dans le même sens.

qu'est-ce que MSB ?

Floopi51
06/01/2009, 10h48
Emmanuel Delahaye

Citation:

Envoyé par floopi51

qu'est-ce que MSB ?

Most Significant Bits (bits de poids fort)
06/01/2009, 11h05
floopi51

Citation:

Envoyé par Emmanuel Delahaye

Most Significant Bits (bits de poids fort)

étant donné que ce que je récupère sous forme d'un entier est un pixel codé sur 4 bits, qu'est ce qui détermine où seront les bits de poids forts ?

Floopi51
06/01/2009, 11h16
Emmanuel Delahaye
Citation:

Envoyé par floopi51

étant donné que ce que je récupère sous forme d'un entier est un pixel codé sur 4 bits, qu'est ce qui détermine où seront les bits de poids forts ?

4 bits ? Tu veux sans doute dire 4 octets ? Eh bien, c'est la spec qui dit comment sont codés les données...

La norme réseau dit que le transmission des données se fait MSB en tête. Ca signifie, par exemple, qu'un mot de 32-bit valant 0x12345678 est codé avec une séquence de 4 octets comme suit :
Code:

1 2 3 4 5 [0] 12 [1] 34 [2] 56 [3] 78
C'est en général le mode de codage retenu pour le fichiers. Mais certaines spécifications ne suivent pas cette norme et définsieent LSB en tête. Le même mot est alors codé :
Code:

1 2 3 4 5 [0] 78 [1] 56 [2] 34 [3] 12
06/01/2009, 11h22
floopi51

Citation:

Envoyé par Emmanuel Delahaye

4 bits ? Tu veux sans doute dire 4 octets ? Eh bien, c'est la spec qui dit comment sont codés les données...

dans ce cas comment expliquer que pour un même fichier, lorque je l'édite avec hexedit, j'obtiens 4 octets dans l'ordre "78 9C ED 7D" et lorsque je les recupère avec fread j'obtiens "7D ED 9C 78" ?

floopi51
06/01/2009, 11h31
Invité(e)

Bonjour,

Citation:

Envoyé par floopi51

étant donné que ce que je récupère sous forme d'un entier est un pixel codé sur 4 bits, qu'est ce qui détermine où seront les bits de poids forts ?

N'y a-t-il pas confusion entre bit et octet ?

Les spécifications PNG demandent le MSB en premier. Attention, cela n'a de sens que pour les images où la profondeur pixel est supérieure à 8 bits, les images 3x8bits ou 4x8bits ne sont donc pas concernées.

Citation:

dans ce cas comment expliquer que pour un même fichier, lorque je l'édite avec hexedit, j'obtiens 4 octets dans l'ordre "78 9C ED 7D" et lorsque je les recupère avec fread j'obtiens "7D ED 9C 78" ?

hexedit édite caractère par caractère.
Si tu lis un entier avec fread, il va tenir compte de l'endianness de ton système.

Si tu lis deux entiers 16 bits avec fread, il y a de fortes chances que tu obtiennes 9C 78 : 7D ED.
06/01/2009, 11h43
floopi51
Citation:

Envoyé par mabu

Bonjour,

N'y a-t-il pas confusion entre bit et octet ?

oui j ecris bit pour byte, il vaut mieux parler d'octet donc :oops:

Citation:

Les spécifications PNG demandent le MSB en premier. Attention, cela n'a de sens que pour les images où la profondeur pixel est supérieure à 8 bits, les images 3x8bits ou 4x8bits ne sont donc pas concernées.

j'ai une image true color avec bit depth = 8. SI je comprend bien, j'ai donc effectivement MSB en premier.

Citation:

hexedit édite caractère par caractère.
Si tu lis un entier avec fread, il va tenir compte de l'endianness de ton système.

Si tu lis deux entiers 16 bits avec fread, il y a de fortes chances que tu obtiennes 9C 78 : 7D ED.

voici mon appel à fread :
Code:

1 2 3 4 5 6 7 8 9 10 int * c_pix; .... c_pix = (int*)malloc(sizeof(int)); if(c_pix == NULL) { fprintf(stderr,"Out of memory\n"); return 1; } fread(c_pix, 4, 1, fileIn); ...
06/01/2009, 12h00
Invité(e)
Citation:

Envoyé par floopi51

j'ai une image true color avec bit depth = 8. SI je comprend bien, j'ai donc effectivement MSB en premier.

Pas tout à fait :
- chaque pixel est constitué de 4 composants.
- chaque composant est codé sur 8 bits.
La taille des pixels ne dépasse pas 8 bits par composant, la notion de MSB/LSB sur les pixels ne s'applique pas : dans les données décompressées, on a un octet rouge, un octet vert, un octet bleu, un octet alpha...

En revanche, cette notion de MSB/LSB va s'appliquer au moment de la lecture si on lit des données depuis le fichier par bloc.
Les processeurs x86 fonctionnent en little-endian (LSB en premier).
Exemple : l'entier 0x00000001 sera écrit 01 00 00 00 dans un fichier binaire.
Citation:
Envoyé par floopi51

voici mon appel à fread :

Code:

1 2 3 4 5 6 7 8 9 10 int * c_pix; .... c_pix = (int*)malloc(sizeof(int)); if(c_pix == NULL) { fprintf(stderr,"Out of memory\n"); return 1; } fread(c_pix, 4, 1, fileIn); ...
Il y a plus simple :
Code:

1 2 3 4 5 6 7 8 9 10 11 typedef struct pixel_s { unsigned char red; unsigned char green; unsigned char blue; unsigned char alpha; } pixel; pixel pix; fread(&pix, sizeof pix, 1, fileIn);
Cela dit, les données lues par l'exemple précédent n'ont rien d'exploitable : elles sont encore compressées.
06/01/2009, 12h24
Emmanuel Delahaye
Citation:
Envoyé par mabu

Il y a plus simple :

Code:

1 2 3 4 5 6 7 8 9 10 11 typedef struct pixel_s { unsigned char red; unsigned char green; unsigned char blue; unsigned char alpha; } pixel; pixel pix; fread(&pix, sizeof pix, 1, fileIn);
Horriblement pas portable pour de nombreuses raisons. J'ai déjà donné le code qui fonctionne...

http://www.developpez.net/forums/m3910592-11/
06/01/2009, 12h27
floopi51

Citation:

Envoyé par mabu

Pas tout à fait :
En revanche, cette notion de MSB/LSB va s'appliquer au moment de la lecture si on lit des données depuis le fichier par bloc.
Les processeurs x86 fonctionnent en little-endian (LSB en premier).
Exemple : l'entier 0x00000001 sera écrit 01 00 00 00 dans un fichier binaire.

comment savoir si mon processeur fonctionne en little-endian ou big-endian ?

Citation:

Cela dit, les données lues par l'exemple précédent n'ont rien d'exploitable : elles sont encore compressées.

mon fichier image est un png.
je croyais que dans ce cas mes données n'étaient pas compressées ???

Floopi51
06/01/2009, 12h29
Emmanuel Delahaye

Citation:

Envoyé par floopi51

comment savoir si mon processeur fonctionne en little-endian ou big-endian ?

Ca n'a strictement aucune importance. j'ai déjà donné le code portable qui fonctionne...
06/01/2009, 12h32
floopi51

Citation:

Envoyé par Emmanuel Delahaye

Horriblement pas portable pour de nombreuses raisons. J'ai déjà donné le code qui fonctionne...

http://www.developpez.net/forums/m3910592-11/

j'ai essayé ce code mais mon problème c'est que je ne récupère pas séparément chacun des octets.

Quel masque appliquer pour obtenir chaque octet dans un entier ?

Floopi51
06/01/2009, 12h33
floopi51

Citation:

Envoyé par Emmanuel Delahaye

Ca n'a strictement aucune importance. j'ai déjà donné le code portable qui fonctionne...

sans m'interesser au code, je voulais juste savoir comment savoir si mon processeur est little-endian ou big-endian ? :D
06/01/2009, 12h50
Médinoc
Je sais faire ça en run-time, mais je n'ai trouvé aucun moyen de tester (ni même simplement vérifier) l'endianness en compile-time: :
Code:

1 2 3 4 5 6 7 8 9 unsigned short testEndian = 0x1234; if( *((unsigned char*)&testEndian) == 0x34 ) { /*Little-endian*/ } else { /*Big-endian*/ }
06/01/2009, 12h53
Emmanuel Delahaye
Citation:

Envoyé par floopi51

j'ai essayé ce code mais mon problème c'est que je ne récupère pas séparément chacun des octets.
Code:

1 2 3 4 5 6 { unsigned r = fgetc(fp); /* MSB en tete */ unsigned v = fgetc(fp); unsigned b = fgetc(fp); unsigned alpha = (fgetc(fp);
C'était dur ?

Citation:

Envoyé par floopi51

sans m'interesser au code, je voulais juste savoir comment savoir si mon processeur est little-endian ou big-endian ? :D
Code:

1 2 3 4 5 6 7 8 9 10 11 #include <stdio.h> int main (void) { unsigned char a[sizeof (int)] = { 1 }; unsigned int i = (*(int *) a); printf ("My machine is %s endian\n", i == 1 ? "little" : "big"); return 0; }

Citation:

Envoyé par Emmanuel Delahaye

Code:

1
2
3
4
5
6
 
{
   unsigned r = fgetc(fp); /* MSB en tete */
   unsigned v = fgetc(fp);
   unsigned b = fgetc(fp);
   unsigned alpha = (fgetc(fp);

C'était dur ?

Quelle différence avec le code ci-dessous ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
struct pixel {
  unsigned int red;
  unsigned int green;
  unsigned int blue;
  unsigned int alpha;
};
 
...
 
{
     struct pixel * pix=NULL;
 
      pix = (struct pixel*)malloc(sizeof(struct pixel));
      if(pix == NULL) {
	fprintf(stderr,"Out of memory\n");
	return 1;
      }
      fread(&pix->red, 1, 1, fileIn);
      fread(&pix->green, 1, 1, fileIn);
      fread(&pix->blue, 1, 1, fileIn);
      fread(&pix->alpha, 1, 1, fileIn);

Citation:

Envoyé par floopi51

Quelle différence avec le code ci-dessous ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
struct pixel {
  unsigned int red;
  unsigned int green;
  unsigned int blue;
  unsigned int alpha;
};
 
...
 
{
     struct pixel * pix=NULL;
 
      pix = (struct pixel*)malloc(sizeof(struct pixel));
      if(pix == NULL) {
	fprintf(stderr,"Out of memory\n");
	return 1;
      }
      fread(&pix->red, 1, 1, fileIn);
      fread(&pix->green, 1, 1, fileIn);
      fread(&pix->blue, 1, 1, fileIn);
      fread(&pix->alpha, 1, 1, fileIn);

aucune, à part la simplicité de l'un des deux.... Je te laisse deviner lequel.

Je suis néanmoins d'accord pour la structure, mais pourquoi une allocation dynamique ? Ne pas compliquer le code plus que nécessaire...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
struct pixel {
  unsigned red;
  unsigned green;
  unsigned blue;
  unsigned alpha;
};
 
 
{
     struct pixel pix;
 
      pix.red = fgets(fp);
      pix.green = fgets(fp);
      pix.blue = fgets(fp);
      pix.alpha = fgets(fp);

06/01/2009, 13h21
floopi51

Citation:

Envoyé par Emmanuel Delahaye

Je suis néanmoins d'accord pour la structure, mais pourquoi une allocation dynamique ? Ne pas compliquer le code plus que nécessaire...

il faut lire fgetc au lieu de fgets dans le code non ?

j'utilise une allocation dynamique parce que j'insère ensuite la structure dan sune liste chaînée pour traiter ensuite les données.

merci pour vos réponses.

Floopi51
06/01/2009, 13h26
Emmanuel Delahaye

Citation:

Envoyé par floopi51

j'utilise une allocation dynamique parce que j'insère ensuite la structure dan sune liste chaînée pour traiter ensuite les données.

OK.