Structure du lecteur de fichier audio au format jo

Un fichier au format jo commence toujours par

AbadieJoris

ensuite nous indiquons le nombre de piste audio, chaque piste possédant son propre fichier.

ensuite nous indiquons le code qui va lancer tel ou tel lecteur

code 1 : 2 octets par front, 1 octet pour l'amplitude et 1 octet pour la durée, cette version est destinée à la téléphonie en ligne de part sa légèreté, c'est la première version que j'ai créé il y a plus de trois ans.

Code 2 : 3 octets par front, 2 octets pour l'amplitude et 1 octet pour la durée.

Code 3 : 4 octets par front, 2 octets pour l'amplitude, 1 octet pour la durée et 1 octet pour jo

code 4 : 5 octets par front, 2 octets pour l'amplitude, 2 octet pour la durée et 1 octet pour jo

code 5 : utilisation d'un système mathématique dédié utilisant les possibles.Le fichier indique en premier les 3 valeurs de base, ensuite la règle d''écriture pour chaqu'une des valeurs, les données sont ensuite écrite en bit en mode complément. L'avantage de cette écriture est d'avoir la possibilité d'avoir 4 modes, le quatrième mode étant le mode boucle.

/* Imaginer et creer par Abadie joris*/
/* en utilisant un concept de Andre pierre jocelyn*/
/*Cette oeuvre est protégée et n'est divulguée que pour utilisation sous linux dans les conditions Creative common ci-dessous*/
/* Cette oeuvre est mise à disposition selon les termes de la Licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Partage des Conditions Initiales à l'Identique 2.0 France. */
/*Aucune garantie n'est donner sur les effets de cet executable*/
/**pour*compiler*gcc lecteur.c -lm -o lecteur_audio_jo****/
/**Pour comprendre le code, ci-dessous il faut considérer Fourier, l'algèbre, les sinus et les techniques coutumières comme fausses****/
/**Le concept modélise en accordant à la nature des choses un état d'équilibre composé de matières et de phénomènes****/
/**Le concept écrit ici la pression et ses variations et comme celle-ci revient toujours à son état initial nous allons l'écrire comme naturellement stable ****/
/**Nous allons donc avoir deux bases de temps par front, la force des fronts donnée par leurs formes, les alignement des crètes des ondes****/
/**les alignement passe des crètes basses aux crète haute et peuvent même s'agrandire en éloignant les ondes suivantes de l'état d'équilibre****/
/**l'aspect de complexité des ondes n'est due qu'à l'utilisation d'un mauvaix outil, une mauvaise association d'idées****/
/**Plusieurs sources de variations de pression très simple semblent complexes même s'il en est rien****/
/**comme plusieurs causes peuvent avoir le même effet notre but est de créer ou reproduire en utilisant la cause qui nous semble la plus simple****/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#define temps1 "abadie.jo"
#define temps "joris.wav"
#define baserepos  32768
#define total 256
#define total1 256
#define total2 256



int force;
int force1;
int groupe1;
int groupe2;
int amplitude;
int amplitudemax;
int amplitudemin;
int jo;
int pourtableau1;
int pourtableau2;
int memoire;

int assemble = 0;
int ludion = 0;
int enclanche = 0;
int nbdepoints, bascule;

int ouaitu;
double force2;
double force3;
int amplitude;
int force1;
int groupe1;
int groupe2;
int groupe3;
int groupe4;
int groupe5;
int jo;

/*****************ici je calcul la durer en additionnant toutes les durer du format 2 octets**************************/
int octets2 (int argc, char *argv[])
{
}
/*****************fin du calcul format 2 octets**************************/
/*****************ici je calcul la durer en additionnant toutes les durer du format 3 octets**************************/
int octets3 (int argc, char *argv[])
{
}
/*****************fin du calcul format 3 octets**************************/
/*****************ici je calcul la durer en additionnant toutes les durer du format 4 octets**************************/
int octets4 (int argc, char *argv[])
{
}
/*****************fin du calcul format 4 octets**************************/
/*****************ici je calcul la durer en additionnant toutes les durer du format 5 octets**************************/
int octets5 (int argc, char *argv[])
{
}
/*****************fin du calcul format 5 octets**************************/
/*****************ici je calcul la durer en additionnant toutes les durer du complement**************************/
int complement (int argc, char *argv[])
{
}
/*****************fin du calcul format complement**************************/


/*****************ici je fais le choix du type de fonction a lancer pour lire le fichier audio**************************/
int main (int argc, char *argv[])
{/**1**/

FILE* pourjo = NULL;
FILE* joris = NULL;

int abadie = 0;

int joencour;
int imprime;
imprime = 2;

/*debut effet memoire*/
double tamponcomparateur = 0; /* tamponcomparateur est une mise en memoire de la derniere valeur de l'amplitude */
int nbdepoints1;
nbdepoints1 = 0;
int nbdepoints2;
nbdepoints2 = 0;
int Mise_en_memoire1 [5000];
int Mise_en_memoire2 [5000];
int position;
position = 1;
int positionmonte;
positionmonte = 0;
int positiondescent;
positiondescent = 0;
int purge;
purge = 0;
int assemble;
assemble = 1;

int ji =256;
amplitudemax = 100000;
amplitudemin = 1;
pourtableau1 = 0;
pourtableau2 = 0;



unsigned char tab1[total1] = 
{0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,
0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};


pourjo = fopen(temps1, "rb");
joris = fopen(temps, "wb+");


if (pourjo != NULL)
{/**2**/


if (joris != NULL)
{/**3**/


int trouve = 1;
int trouvet = 1;
abadie = fgetc(pourjo); /* abadie vient chercher tout ce qui bouge*/
while (abadie != EOF)
{/**4**/

/*je verifie que le fichier est au bon format et commence bien par AbadieJoris */ 

switch (trouve) {/**5**/

case 1 :

if ( abadie == 0x41 )
{
trouve = 2;
}
else
{
trouve = 18;
}
break;

case 2 :

if ( abadie == 0x62 )
{
trouve = 3;
}
else
{
trouve = 18;
}
break;

case 3 :

if ( abadie == 0x61 )
{
trouve = 4;
}
else
{
trouve = 18;
}
break;

case 4 :

if ( abadie == 0x64 )
{
trouve = 5;
}
else
{
trouve = 18;
}
break;
case 5 :

if ( abadie == 0x69 )
{
trouve = 6;
}
else
{
trouve = 18;
}
break;

case 6 :

if ( abadie == 0x65 )
{
trouve = 7;
}
else
{
trouve = 18;
}
break;
case 7 :

if ( abadie == 0x4A )
{
trouve = 8;
}
else
{
trouve = 18;
}
break;

case 8 :

if ( abadie == 0x6F )
{
trouve = 9;
}
else
{
trouve = 18;
}
break;
case 9 :

if ( abadie == 0x72 )
{
trouve = 10;
}
else
{
trouve = 18;
}
break;

case 10 :

if ( abadie == 0x69 )
{
trouve = 11;
}
else
{
trouve = 18;
}
break;
case 11 :

if ( abadie == 0x73 )
{
trouve = 12;
}
else
{
trouve = 18;
}
break;

case 12 :
/*Fichier audio en .jo pour la telephonie 2 octets par front 01 */ 
if ( abadie == 0x01 )
{
trouve = 13;
}
/*Fichier audio en .jo 3 octets par front, 2 pour l'amplitude, et 1 pour la durée 02 */ 
if ( abadie == 0x02 )
{
trouve = 14;
}
/*Fichier audio en .jo 4 octets par front, 2 pour l'amplitude, 1 pour la durée, 1 pour la forme 03 */
if ( abadie == 0x03 )
{
trouve = 15;
}
/*Fichier audio en .jo 5 octets par front, 2 pour l'amplitude, 2 pour la durée, 1 pour la forme 04 */
if ( abadie == 0x04 )
{
trouve = 16;
}
/*Fichier audio en .jo format complément, les bases sont donnees par les valeur qui suivent. la forme 05 */
if ( abadie == 0x05 )
{
trouve = 17;
}
/*début des fichiers stereo**/
/*Fichier audio en .jo pour la telephonie 2 octets par front 01 */ 
if ( abadie == 0x21 )
{
trouve = 21;
}
/*Fichier audio en .jo 3 octets par front, 2 pour l'amplitude, et 1 pour la durée 02 */ 
if ( abadie == 0x22 )
{
trouve = 22;
}
/*Fichier audio en .jo 4 octets par front, 2 pour l'amplitude, 1 pour la durée, 1 pour la forme 03 */
if ( abadie == 0x23 )
{
trouve = 23;
}
/*Fichier audio en .jo 5 octets par front, 2 pour l'amplitude, 2 pour la durée, 1 pour la forme 04 */
if ( abadie == 0x24 )
{
trouve = 24;
}
/*Fichier audio en .jo format complément, les bases sont donnees par les valeur qui suivent. la forme 05 */
if ( abadie == 0x25 )
{
trouve = 25;
}
else
{
trouve = 18;
}
break;

case 13 :/*************debut******cas mono 2 octets**************************/

break;/*************fin******cas mono 2 octets**************************/
case 14 :/*************debut******cas mono 3 octets**************************/

break;/*************fin******cas mono 3 octets**************************/
case 15 :/*************debut******cas mono 4 octets**************************/

break;/*************fin******cas mono 4 octets**************************/
case 16 :/*************debut******cas mono 5 octets****************************************************************************************/

/*******************cas mono 5 octets**************************/



for (ouaitu=0; ouaitu<255; ouaitu++)
{
if ( abadie == tab1[ouaitu])
{
force1 = ouaitu;
assemble++;
}
}
/***debut assemble***/

switch (assemble) {/**1mono5**/

case 1 :
groupe1 = force1;
/*assemble = 2;*/
break;

case 2 :
groupe2 = force1;
/*assemble = 3;*/
force2 = (double)(groupe1 + 256 * groupe2);
amplitude = (int)(force2);
break;

case 3 :
groupe3 = force1;
/*assemble = 2;*/
break;

case 4 :
groupe4 = force1;
force3 = (double)(groupe3 + 256 * groupe4);
nbdepoints = (int)(force3);
break;

default:
groupe5 =  force1;
joencour = (force1);
/****fin traitement bin******/
float okioki ;
float okioki1 ;
okioki = (float)(nbdepoints);
okioki1 = (float)(joencour);

jo = (okioki * okioki1 * (0.01));

/***conversion nouvelle donner en ancienne****/

if (jo < 2){ jo = 1; }
int sens;
if (ludion > amplitude) { sens = 2; }
else { sens = 1; }

/***fin conversion***/
double codebash;
char va;

char tab[total] ={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D,0x1E,0x1F,0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D,0x2E,0x2F,0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F,0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0x7B,0x7C,0x7D,0x7E,0x7F,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F,0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF,0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF,0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,
0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF,0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};


char *ptr;
char *petr;






/*******/

if(sens == 2)

/*ajouter dessous*/
{


if ( nbdepoints < 2)
{
codebash = (int)(amplitude);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);


}

else if (( nbdepoints & 1)&&( nbdepoints >= 2))
{


 float ote, ote1;
int boucle;
boucle = nbdepoints * 0.5;
ote = ( ludion - amplitude) * 0.5;




while ( boucle > 0)


{
ote1 = ote * ( 1 - exp (-boucle/jo));

/*
fprintf(joris,"%d ", (int)codebash );
*/


codebash = (int)( amplitude + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);

/****************************/
boucle--;
bascule = codebash;
}


enclanche = 2;/*****************premier enclanche du sens 2************/

if ( enclanche == 2)
{




 float ote, ote1;
ote = (ludion - amplitude ) * 0.5;



int boucle1 = 1;
while (boucle1 < nbdepoints * 0.5 + 2)
{

ote1 = ote * ( 1 - exp (-boucle1/jo));




codebash = (int) ( ludion - ote -ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);






/*fin modif*/

boucle1++;

}



enclanche = 0;







}
}

/**************************/


else
{


 float ote, ote1;
int boucle;
boucle = nbdepoints * 0.5;

ote = (ludion - amplitude) * 0.5;




while ( boucle > 0)





{
ote1 = ote * ( 1 - exp (-boucle/jo));

/*
fprintf(joris,"%d ", (int)codebash );
*/


codebash = (int)( amplitude + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);





/*fin modif*/
boucle--;
bascule = codebash;
}


enclanche = 2; /*** deuxieme enclanche du sens 2**********/

if ( enclanche == 2)
{




 float ote, ote1;

ote = (ludion - amplitude) * 0.5;



int boucle1 = 1;
while (boucle1 < nbdepoints * 0.5 + 1)
{

ote1 = ote * ( 1 - exp (-boucle1/jo));




codebash = (int) ( ludion - ote -ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);






/*fin modif*/

boucle1++;

}



enclanche = 0;




/* fin descente 2*/


}
}

}


/*en attente*/

/**********/

if(sens == 1)
{
if ( nbdepoints < 2)
{
codebash = (int)(amplitude);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);


}

/************************correction impair*************************************************************************/


else if (( nbdepoints & 1)&&( nbdepoints >= 2))
{



 float ote, ote1;

int boucle;
boucle = nbdepoints * 0.5;
if ( boucle == 0)
{
boucle = 1;
}


ote = ( amplitude - ludion ) * 0.5;




while ( boucle > 0)
{

ote1 = ote * ( 1 - exp (-boucle/jo));

codebash = amplitude - ote - ote1;
/*
fprintf(joris,"%d ", (int)codebash );
*/



codebash = (int)(amplitude - ote - ote1);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);






bascule = codebash;


/*fin modif*/
boucle--;

}

enclanche = 1;
/* debut descente inverse du sens 1 */
if (enclanche == 1)

{


 float ote, ote1;
int boucle, boncompte;
boucle = 1;

ote = ( amplitude - ludion ) * 0.5;
boncompte = nbdepoints * 0.5;
if (boncompte == 0)
{
boncompte = 1;
}


while (boucle < (boncompte+2))


{
ote1 = ote * ( 1 - exp (-boucle/jo));




codebash = (int) (ludion + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);






/*fin modif*/
boucle++;
}


enclanche = 0;

}

}


/***********************************fin correction impair**************************************************************/
else
{


 float ote, ote1;

int boucle;
boucle = nbdepoints * 0.5;
if ( boucle == 0)
{
boucle = 1;
}


ote = ( amplitude - ludion ) * 0.5;




while ( boucle > 0)
{

ote1 = ote * ( 1 - exp (-boucle/jo));

codebash = amplitude - ote - ote1;
/*
fprintf(joris,"%d ", (int)codebash );
*/



codebash = (int)(amplitude - ote - ote1);



int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);






bascule = codebash;


/*fin modif*/
boucle--;

}

enclanche = 1;
/* debut descente inverse du sens 1 */
if (enclanche == 1)

{


 float ote, ote1;
int boucle, boncompte;
boucle = 1;

ote = ( amplitude - ludion ) * 0.5;
boncompte = nbdepoints * 0.5;
if (boncompte == 0)
{
boncompte = 1;
}


while (boucle < (boncompte+1))


{
ote1 = ote * ( 1 - exp (-boucle/jo));




codebash = (int) (ludion + ote + ote1);


int ji;
int ij;
int ola;
ola = (int)codebash;

/*ji = ola%256;*/
ij = (int)(ola*0.00390625);
ji = ola - (256*ij);

ptr = &tab[ji];
petr = &tab[ij];


fwrite( ptr, sizeof(char), 1, joris);
fwrite( petr, sizeof(char), 1, joris);






/*fin modif*/
boucle++;
}


enclanche = 0;

}

}


}


/* fin*/






/********/


/*****/



ludion = amplitude;

/*pas*toucher*/
assemble = 0;
} /***fin assemble*1mono**/





/****************fin cas mono 5 octets************/

break;/*************fin******cas mono 5 octets***********************************************************************************************/
case 17 :/*************debut******cas format complement ou escalier libre**************************/

break;/*************fin******cas format complement ou escalier libre**************************/


case 21 :/*************debut******cas stereo 2 octets**************************/

break;/*************fin******cas stereo 2 octets**************************/
case 22 :/*************debut******cas stereo 3 octets**************************/

break;/*************fin******cas stereo 3 octets**************************/
case 23 :/*************debut******cas stereo 4 octets**************************/

break;/*************fin******cas stereo 4 octets**************************/
case 24 :/*************debut******cas stereo 5 octets**************************/

break;/*************fin******cas stereo 5 octets**************************/
case 25 :/*************debut******cas format complement ou escalier libre**************************/

break;/*************fin******cas format complement ou escalier libre**************************/


default:
trouve = 18;

}/**fin du switch trouve**repere 5**/

abadie = fgetc(pourjo); /* abadie va chercher la suivante*/
}
fclose(joris), joris = NULL;;

}
fclose(pourjo), pourjo = NULL;;

}

return 0;
}