Discussion :

[silenteagle]

Salut à tous,
Voici mon problème, j'ai un fichier binaire, constitué d'une succession d'ensembles, en quantité inconnue, de taille variable mais commencent tous par le même entête. J'aimerais récupérer chacun d'entre eux.

Se que j'ai essayer de faire:
Lire le fichier et stocker son contenus dans un buffer et l'entête dans un autre buffer. Je pensais comparer les deux buffers mais je ne sais pas comment procéder

[6-MarViN]

Pour trouver une chaine dans une chaine utilise la fonction strstr().

[silenteagle]

J'ai penser à cette fonction, mais vus quelle retourne le premier cas compatible. Je ne vois pas comment l'utiliser dans le cas ou la string rechercher figure plusieurs fois dans la string principale.

[6-MarViN]

Tu fais un décalage à chaque check.

En gros:

Imaginons que tu cherche la chaine "bla" dans la chaine "bladibladibla"

Tu fais appel une première fois à cette fonction en fournissant les 2 chaines en paramètres.

La fonction te renverra un pointeur vers le premier élément.

Ensuite tu verifie si ce pointeur est en fin de chaine. (Là, en l'occurence, non).

Si non tu rappelle la fonction, mais au lieu de lui filer la chaine "bladibladibla" complète, tu lui file uniquement "dibladibla" (un truc du genre: strstr(str + 3, str2)).

et ainsi de suite jusqu'à arriver à la fin de la chaine.

[diogene]

Pour compléter le réponse précédente :

strstr() retourne NULL si la sosu-chaine n'est pas trouvée ou si elle est trouvée l'adresse du début de la sous-chaine dans la chaine.
Ceci étant, il faut savoir si on considère le cas où une deuxième sous-chaine peut débuter à l'intérieur de la première sous-chaine.

Par exemple chaine : "xxxabababxxx" , sous-chaine : "aba"
Une premiere sous-chaine est trouvée en "xxxaba..." Peut-on considérer que la deuxième est en "xxxababa", donc inclus le dernier caractère de la première sous-chaine ou qu'il n'y a pas de deuxième sous-chaine à partir de la fin de la première ?

- Dans le premier cas,

  1- initialiser le pointeur p à l'adresse du début de la chaine
  2- rechercher la sous-chaine à partir de p
  - si on en trouve une débutant en p, faire p = p+1 et recommencer en 2.
  - sinon, il n'y en a plus.

- Dans le second cas, au lieu de chercher les sous chaines à partir de p+1 on recherchera à partir p+L où L est la longueur de la sous-chaine

[fregolo52]

Voici mon problème, j'ai un fichier binaire, constitué d'une succession d'ensembles, en quantité inconnue, de taille variable mais commencent tous par le même entête. J'aimerais récupérer chacun d'entre eux.

Ce qui me chagrine dans ton énoncé c'est le mot binaire.

Ton fichier est 100% chaine de caractères ? ou est qu'on peut se retrouver avec des octets non imprimable style 0x01 qui va faire pèter strstr (il me semble).

[bpy1401]

Bonjour

Je suis d'accord avec fregolo52. Le mot binaire me fait dire que traiter ce fichier avec des fonctions utilisables pour des String me parait très dangereux.

Pour pour, il faut le traiter d'une manière binaire.
- On cherche dans le buffer toutes les occurrences d'une suite d'octets et on mémorise leurs positions.
- Puis pour chaque position (sauf la dernière), on extrait le code binaire entre cette position et la position suivante.

Je ne connais pas d'autre moyens plus simples, mais c'est pas parce que je n'en connais , qu'il n'existe pas d'autre.

Dommage que la taille des champs ne soit pas renseigner pour chaque champs, cela aurait été beaucoup plus simple et plus rapide.

[silenteagle]

J'ai essayer d'implémenté l'idée de 6-MarViN, et sa marche, se bout de code affiche la position ou se trouve de la chaine "bla" soit en 0, en 5 et en 10. Toute fois, je fait plusieurs fois le test ch!=NULL, est ce qu'il n'y aurais pas moyen d'améliorer ?

Le bout de 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
char str[] ="bladibladibla";
	  char * ch;
	  ch = strstr (str,"bla");
	  int cmpt=0,ret=-1,temp=0;
	  while(ch != NULL || ch != '\0')
	  {
		  ch = strstr (str + cmpt,"bla");
		  if(ch != NULL)
		  {
			  temp = ch - str;
			  if(temp != ret)
			  {
				  ret=temp;
				  printf("%d\n",ret);
			  }
		  }
		  cmpt++;
	  }

Edit : diogene, le problème que tu expose, n'apparais pas dans les fichiers sur lesquels je travaille.
Edit2 : fregolo52, les fichiers avec lesquels je travaille sont 100% binaire, j'ai joins un de ces fichiers si sa peut aider.

Edit3 :

Dommage que la taille des champs ne soit pas renseigner pour chaque champs, cela aurait été beaucoup plus simple et plus rapide.

Dans l'entête y a un octet qui permet de calculer la taille de l'entête (71 octets dans mon fichier). Il y a aussi deux octets qui permettent de connaitre la taille des élément qui suivent l'entête (777 octets dans mon fichier)

Le problème que j'ai c'est qu'il arrive d'avoir les élément qui suivent l'entête d'une longueur inférieurs à celle indiqué par l'entête.

[fregolo52]

Le problème que j'ai c'est qu'il arrive d'avoir les élément qui suivent l'entête d'une longueur inférieurs à celle indiqué par l'entête.

Tu es devin ? Non !! Donc comment peux-tu gérer ce cas ? Dur dur !! A moins que dans l'en-tête il y aie une suite d'octet identique dans chaque en-tête.
En gros tu ne peux pas faire confiance aux données du fichier !!

[silenteagle]

A moins que dans l'en-tête il y aie une suite d'octet identique dans chaque en-tête.

Les 71 octets qui compose les en-têtes sont identiques.

En gros tu ne peux pas faire confiance aux données du fichier !!

Étant donnée qu'il arrive d'avoir moins de donnée que annoncé par l'en-tête. Oui, quelqu'un aurais une solution ?

[fregolo52]

tu peux nous décrire la structure du fichier ?

Style :

Code :

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

1
2
|--entete-------|--taille--|-data-----------------|--entete-------|--taille--|-data-----------------|
   71 octets       2octets   taille octets

[silenteagle]

Le fichier est construit comme sa :

Code :

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

1
2
|en-tête|donnée|en-tête|donnée|en-tête|donnée|
| 71o   | 777o | 71o   | 777o | 71o   | 777o |

Tout les en-tête sont les mêmes.
L'en-tête commence par 7F7F, les données par 8000 suivit du numéro d'ensemble.

Vous pouvez constater par exemple que l'ensemble A2, qui commence au 97*591ème octet du fichier fait non pas 777 octets mais 713octet.

[lilington]

Moi je comprend toujours quelquechose:
tu as dis que ton fichier est 100% binaire donc c'est pas un fichier texte. et tu t'obstine a utiliser la solution de 6-MarViN. Si ca marche pour le moment dit toi que c'est juste de la chance et ne soit pas suppris si tu as des resultats inattendu.

en suite comme l'a dit fregolo52 pourquoi ne pas juste ajouter la taille des donnees entre l'entete et les donnee? ca te permet d'eviter la partie recherche tu feras:

-lecture de l'entete
-lecture de la taille
-decallage de distance = taille pour arriver a l'entete suivante

[fregolo52]

Le fichier est construit comme sa :

Code :

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

1
2
|en-tête|donnée|en-tête|donnée|en-tête|donnée|
| 71o   | 777o | 71o   | 777o | 71o   | 777o |

Tout les en-tête sont les mêmes.
L'en-tête commence par 7F7F, les données par 8000 suivit du numéro d'ensemble.

Vous pouvez constater par exemple que l'ensemble A2, qui commence au 97*591ème octet du fichier fait non pas 777 octets mais 713octet.

Il te reste à faire un bel algo pour gérer tous les cas.
Vu que 7F7F peut être aussi dans les données, faut penser à gérer ce cas :

Code :

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

1
2
3
4
5
6
si data = 7f7f alors 
   si dada + 71 = 8000 alors
      c''est une en-tete
   sinon
      c''est des data
....

en suite comme l'a dit fregolo52 pourquoi ne pas juste ajouter la taille des donnees entre l'entete et les donnee?

En effet, d'où vient ce fichier ?

Dans les 71o y a-t-il des données pernitentes autre qui 7f7f ?

[silenteagle]

La solution que tu indique lilington est celle que j'utilisais alors, le problème est que la taille des données est parfois inférieur à celle indiqué par l'entête. Quand cela arrive, lors du décalage, j'empiète sur l'en-tête suivant, a partir de là tout se que je vais lire sa vas être l'importe quoi.
En faite je ne peut pas me fié à la valeur contenue dans l'en-tête.

En effet, d'où vient ce fichier ?

C'est un capteur qui crache des données toutes les x secondes, un micro-contrôleur les récupère et les stockes dans un fichier.

Dans les 71o y a-t-il des données pernitentes autre qui 7f7f ?

y a un octet qui permet de calculer la taille de l'en-tête et deux autre pour calculer la taille de l'ensemble en-tête + données.

[fregolo52]

y a un octet qui permet de calculer la taille de l'en-tête et deux autre pour calculer la taille de l'ensemble en-tête + données.

Donc il y a aucun souci !!!!
Tu es capable d'avancer correctement dans ton fichier grâce à ces données !!

[lilington]

le micro contoleur en question est ecrit par toi?
si oui tu n'a qu'a inserer la taille.
Et non si tu donnes une bonne tailles il est impossible que tu tombes dans le vide ex:

E,N,T,E,T,E,0,10,12,3,4,55,3,23,9,0,65,12,E,N,T,E,T,E,0,255,....,EOF

donc ici dan mon exemple tu as une entete de 6 octets, ENTETE suivi de deux octets 0 et 10 qui donne 0*256+10 = 10. tu peux aussi en metre 4 ou plus selon la taille maximal de la partie donner. donc tu sais que tu peux faire un fread(&c,1,1,f) 10 fois ou alors lire d'un coup 10 octets. et tu es positionnes automatiquement sur l'entete suivante.
si tu veux sauter ben tu fait fseek(f,10+taille_entete,SEEK_CUR); et tu tombe directement sur la taille suivante.
je ne vois vraiment pas ce qui pose probleme.

sinon tu mets la taille au debut en y ajoutant la taille de l'entete ce qui donne dans notre exemple precedent:

0,16,E,N,T,E,T,E,12,3,4,55,3,23,9,0,65,12,1,5,E,N,T,E,T,E,....,EOF

donc le 1,5 avant le E de entete signifie 1*256+6=261 octet de donnee+entete.
tu peux lire aussi le fichier specification du format png http://www.w3.org/TR/PNG/ (partie chunk) pour voir comment c'est fait.

[silenteagle]

Le problème c'est que parfois j'ai un en-tête qui m'indique un ensemble en-tête + donnée de 848 octets et que en fait pour une raison inconnue cet ensemble fait 784 octet. Lorsque je fait un décalage de 848 octets pour passer à l'ensemble suivant, je ne suis pas au début de l'en-tête mais 64 octets plus loin ce qui fait échoué tout le reste de la lecture.

C'est pour sa que je cherche à détecter l'en-tête suivant et non pas me déplacer jusqu'à sa position théorique.

[fregolo52]

Ah oui !! j'avais oublié !!!

Ton programme doit compenser un bug du micro controleur.
Euh .. ceux qui ont fait ce bug ne peuvent pas le corriger ?

En gros, tu dois regarder si à entete+data tu as bien 7F7F, si non, alors parser le fichier depuis l'entete actuelle pour trouver la vraie fin !!! Où comment contourner un bug qui ne vient pas de soi !! Bonne chance.

[lilington]

tu n'as toujours pas repondu a ma question: qui ecris le code du controleur? si c'est toi alors ca peut etre regle plus facilement que tu ne le crois.

si c'est toi alors ca veut dire que la taille des donnees est mal calcule, si par exemple tu as utilises strlen c'est normal que tu aies une taille fausse car quand strlen trouve un 0 il stop. donc si data est 1,2,3,0,4,5 alors strlen renvois 3.
bref pour dire qu'il est mathematiquement impossible que si la taille est donnee correctement le decallage soit incorrect.

si c'est pas toi qui a ecris le controlleur alors faut etre sur que la sequense de l'entete ne peux jamais se trouver dans les donnees et dans ce cas tu ecris une fonction recherche qui cherche une sequence par exemple.

Code :

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

1
2
3
4
5
6
7
8
9
 int findentet(const char *datalist, const char *entete,int pos)
{
     int where=-1;
    datalist+=pos; // decallage de pos octets
 
    //ici insert une double boucle de recherche de souschaine dans datalist de
    //entete avec where=position_du_premier_octet_de_entete
    return where; // -1 si rien est trouve ou alors la position 
}

a utiliser comme ceci:

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
pos =0;
do
{
     last =pos+size_of_entete;
     pos = findentete(data,"entete",pos)
     if (pos<0)
     {
         (1)
         break;
     }
// faire quelquechose ex:
     fprintf(stdout,"position de l'entete trouve a l'octet #%d\n",pos);
     char *dataext=extract(data,last,pos);
     //faire quelquechose avec dataext
     free(dataext);
}while(1);

(1) c'est le cas ou on ne trouve plus d'entete la on doit extraire jusqu'a EOF avant de break ou meme mieux tu ne break pas tu calcule pos et tu break apres le free.