manipulations bit à bit

Version imprimable

Voir 40 message(s) de cette discussion en une page

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, 16h24
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, 16h42
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, 17h01
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, 17h11
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, 18h29
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, 08h36
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, 09h27
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, 09h39
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, 09h41
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, 09h48
Emmanuel Delahaye

Citation:

Envoyé par floopi51

qu'est-ce que MSB ?

Most Significant Bits (bits de poids fort)
06/01/2009, 10h05
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, 10h16
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, 10h22
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, 10h31
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.

Voir 40 message(s) de cette discussion en une page