calcul des valeurs des fronts 1

pour corriger la différence de dimension vu de loin nous pouvons écrire que c'est le rapport plus 0.5, mais comme l'ordinateur rencontre digère mal les opérations mathématiques, nous entrons la valeur directement dans le code pour ce cas sans lui demander de le calculer.

/*************************************debut du synthetiseur vocal****************************************/

/* 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*mais je peux dire qu'il fonctionne bien sur mes PC****/
/* pour compiler : gcc dessi.c -lm -o dessi -Wall*/



#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <math.h>
#include <ctype.h>
#define total 256
#define total1 256
#define total2 256
#define efface "joris1.wav"


int fonctionlecteur ();
int FonctionEntete ();
int fonctionconvertisseur ();


/**********************************************************************************************************************************************/
long int longueurentete, nbdepoints, amplitudeentete, durerentete;
int sequence, sequence1, sequence2, actif, position, ausuivant, assemblage1, saitfait;
unsigned int calcultemps;

int fonctionlecteur()
{
	ausuivant = system("play joris26.wav");
	return ausuivant;
}
/* attenton : ignoring return value of system declared with attribut warm_unused_result*/

int FonctionEntete(int argc, char *argv[])
{

int abadie = 0;
int assemble =0;
durerentete = 0;
longueurentete = 0;
int ouaitu;
int force1 = 1;

/*j ouvre mon fichier de donner*/
FILE* fichierjoa1 = NULL;

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};


fichierjoa1 = NULL;
  fichierjoa1 = fopen(argv[1], "rb");
  if(fichierjoa1 == NULL){
    printf("Ce fichier ne va pas %s\n",argv[1]);
    exit(1);
  }


if (fichierjoa1 != NULL)
{

/************************************************************************************************************************************/
abadie = fgetc(fichierjoa1); /* abadie vient chercher tout ce qui bouge*/
while (abadie != EOF)
{  /*acco1*/

assemble++;
/***debut assemble***/

switch (assemble) {/*acco3*/

case 1 :
/***laisse*passer*amplitude***/
break;


case 2 :

for (ouaitu=0; ouaitu<255; ouaitu++)
{
if ( abadie == tab1[ouaitu])
{
force1 = ouaitu;

}
}
nbdepoints = nbdepoints + (int)(force1);
break;

case 3 :
/***laisse*passer*force***/


assemble = 0;
break;
} /***fin assemble***//*acco3*/
/*}acco2*/
abadie = fgetc(fichierjoa1); /* abadie va chercher la suivante*/
}/*acco1*/
fclose(fichierjoa1), fichierjoa1 = NULL;;
/****fin traitement bin******/


durerentete = nbdepoints ;

 calcultemps = ((unsigned int)durerentete )* 0.0441;
/*******************************************************************************************************************************************/

/*ici*je*commence*le*traitement*comme*jécris*chaque*base*de*temps*sur*deux*octets*je*multiplis*par*2*/

}

FILE* debutwav = NULL;
debutwav = fopen(efface, "wb+");
if (debutwav != NULL)
   {

  unsigned char riff[4] = { 0x52, 0x49, 0x46, 0x46 };
  fwrite (riff, 1, sizeof (riff), debutwav);
int valeurss = (durerentete * 2)+48;
int valeurs = (durerentete * 2);
  fwrite (&valeurss, sizeof (valeurss), 1, debutwav);
  unsigned char wave[4] = { 0x57, 0x41, 0x56, 0x45 };
  fwrite (wave, 1, sizeof (wave), debutwav);
  unsigned char fmt[4] = { 0x66, 0x6D, 0x74, 0x20 };
  fwrite (fmt, 1, sizeof (fmt), debutwav);
  unsigned char poids[4] = { 0x10, 0x00, 0x00, 0x00 };
  fwrite (poids, 1, sizeof (poids), debutwav);
  unsigned char pourpcm[2] = { 0x01, 0x00 };
  fwrite (pourpcm, 1, sizeof (pourpcm), debutwav);
  unsigned char piste[2] = { 0x01, 0x00 };
  fwrite (piste, 1, sizeof (piste), debutwav);
  unsigned char tempsunitaire[4] = { 0x44, 0xAC, 0x00, 0x00 };
  fwrite (tempsunitaire, 1, sizeof (tempsunitaire), debutwav);
  unsigned char octetpars[4] = { 0x88, 0x58, 0x01, 0x00 };
  fwrite (octetpars, 1, sizeof (octetpars), debutwav);
  unsigned char tailleechant[2] = { 0x02, 0x00 };
  fwrite (tailleechant, 1, sizeof (tailleechant), debutwav);
  unsigned char bitparechan[2] = { 0x10, 0x00 };
  fwrite (bitparechan, 1, sizeof (bitparechan), debutwav);
  unsigned char mono[4] = { 0x64, 0x61, 0x74, 0x61 };
  fwrite (mono, 1, sizeof (mono), debutwav);
  fwrite (&valeurs, sizeof (valeurs), 1, debutwav);

fclose(debutwav), debutwav = NULL;;

   }
return 0;
}

/************fin*du createur**entete********************************************************************************/
/*********************************************************************************************************************************************/
int fonctionconvertisseur(int argc, char *argv[])

{

FonctionEntete(argc, argv);

/*j ouvre mon fichier de donner*/
FILE* jojo = NULL;

int abadie = 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};


  jojo = fopen(argv[1], "rb");
  if(jojo == NULL){
    printf("Ce fichier ne va pas %s\n", argv[1]);
    exit(1);
  }

if (jojo != NULL)
{

int assemble = 0;
int ludion = 32768;
int enclanche = 0;
int nbdepoints;

int ouaitu;
int amplitude = 32768;
int force1 = 0;
int joencour;
float jo;

abadie = fgetc(jojo); /* abadie vient chercher tout ce qui bouge*/
while (abadie != EOF)
{



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

switch (assemble) {

case 1 :
amplitude = (force1 * 256);

/****************************traitement*amplitude****/

break;

case 2 :
nbdepoints = force1;

/****************************traitement*amplitude****/

break;

default:
joencour = force1;


/****fin traitement bin***

float okioki ;
float okioki1 ;
float okioki2 ;
float okioki3 ;
float okioki4 = 0.5 ;
okioki = (float)(nbdepoints);
okioki1 = (float)(joencour);
okioki2 = (float)(okioki1/okioki);
okioki3 = (float)(okioki2 + okioki4);
jo = (float)(joencour);***/

float okioki3 = 1;
float okioki2 = 0.1;

float okioki ;
float okioki1 ;
okioki = (float)(nbdepoints);
okioki1 = (float)(joencour);

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


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

/***fin conversion***/
double codebash;

FILE* temps = NULL;

char tab[total] = {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,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};



char *ptr;
char *petr;

temps = fopen(efface, "ab"); /* pour ajouter a. possible w ou r+ w+ tester */

if (temps != NULL)

{





/*******/

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, temps);
fwrite( petr, sizeof(char), 1, temps);


}



else
{


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

int reste;
reste = nbdepoints - boucle;

ote = (ludion - amplitude) * 0.5;




while ( boucle > 0)





{



if(okioki2 > 0.3)
{
ote1 = ote *(1.5) *( 1 - exp (-boucle/jo));
}
else
{
ote1 = ote * ( 1 - exp (-boucle/jo));
}


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


codebash = (int)( ote + ote1 + 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, temps);
fwrite( petr, sizeof(char), 1, temps);





/*fin modif*/
boucle--;

}


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

if ( enclanche == 2)
{




 float ote, ote1;

ote = (ludion - amplitude) * 0.5;



int boucle1 = 1;
while (boucle1 < reste + 1)
{






if(okioki2 >0.3)
{
ote1 = ote * (1.5) * ( 1 - exp (-boucle1/jo));
}
else
{
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, temps);
fwrite( petr, sizeof(char), 1, temps);






/*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, temps);
fwrite( petr, sizeof(char), 1, temps);


}


else
{


 float ote, ote1;



int boucle;
boucle = nbdepoints * 0.5;
int ajuste;
ajuste = nbdepoints - boucle;

if ( boucle == 0)
{
boucle = 1;
}


ote = ( amplitude - ludion ) * 0.5;




while ( boucle > 0)
{





if(okioki2 >0.5)
{
ote1 = ote * ( 1 - exp (-boucle/jo))*(okioki2+0.5);
}
else
{
ote1 = ote * ( 1 - exp (-boucle/jo));
}


/*
fprintf(temps,"%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, temps);
fwrite( petr, sizeof(char), 1, temps);


/*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 = ajuste;
if (boncompte == 0)
{
boncompte = 1;
}


while (boucle < (boncompte+1))


{



if(okioki2 >0.5)
{
ote1 = ote * ( 1 - exp (-boucle/jo))*(okioki2+0.5);
}
else
{
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, temps);
fwrite( petr, sizeof(char), 1, temps);






/*fin modif*/
boucle++;
}


enclanche = 0;

}

}


}


/* fin*/






/********/


/*****/



fclose(temps), temps = NULL;;
}
ludion = amplitude;

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

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


}








return 0;
}

/************************fin fonction***/
/*****fonction main**/

int main(int argc, char *argv[]) {

	FonctionEntete(argc, argv);
	fonctionconvertisseur(argc,argv);/*je lance la lecture*audio du fichier .jo en argument*/
        return 0 ;

    }




Contact et support: Joris Abadie