Discussion :

[colin.sauvanet]

Bonjour,

Pour un projet, j'ai dans une grande chaine de caract�re des donn�es brutes d'un son Wave.
L'avantage de le mettre dans une chaine de caract�re est que 1 ou 2 caract�re (ou plus) donnent une note (8bits per sample ou 16bits per sample - un caract�re fait 8 bits). Pour traiter ce son (en l'occurence, faire un effet d'echo), je dois prendre les valeurs, les atenuer, les sommer et les remettre en format caract�re.

Je cherche donc comment utiliser les fonctions existantes ou quelle fonction ecrire pour passer de 1 ou 2 caract�res � une valeur enti�re : en fait relire les bits mais au format entier et non caract�re... Un cast suffit-il ?

Je dois faire cela sachant que les donn�es � r�cup�rer sont sign�es (-127 a 127 en 8 bits).

Je vous remercie... dites moi si il manque des d�tails pour r�pondre.

[loufoque]

C'est quoi l'ordre de tes octets ? Little Endian ou Big Endian ?

[colin.sauvanet]

L'ordre est en Big endian, il faut que je lise � l'envers...

[Melem]

Les amplitudes aux diff�rents instants sont cod�s sur un octet seulement donc il n'est pas question d'endianess ici. D'ailleurs dans les fichiers Wave, sauf pour les cha�nes de caract�res, c'est toujours le little-endian qui est utilis�.

Je cherche donc comment utiliser les fonctions existantes ou quelle fonction ecrire pour passer de 1 ou 2 caract�res � une valeur enti�re : en fait relire les bits mais au format entier et non caract�re... Un cast suffit-il ?

Il ne faut pas consid�rer ces valeurs comme des "caract�res" ('A', 'B', etc.). Ce sont bel et bien des entiers mais cod�s avec un octet (char) seulement. Il n'y a ni routine de conversion ni cast � faire. Pourquoi caster un entier vers entier ? Seulement, c'est unsigned char en fait qu'il faut utiliser car les valeurs vont de 0 � 255 (l'amplitude 0 est repr�sent� par 127, ou 8 d�j� faudra v�rifier parce que je ne me rappelle plus ...). Si tu utilises signed char, c'est s�r que tu auras des surprises ...

[colin.sauvanet]

C'est bon, j'ai trouv� ce qu'il me faut : voici la fonction qui ajoute de l'echo sur un son Wave stock� dans une cha�ne de caract�res :

projectFormat est un WAVEFORMATEX :

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
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
void Echo(float ap_float_user, int dp_bytes_user)
{
        // parameter attenuation : "ap"
        // parameter delay : "dp"
        if(projectFormat.wBitsPerSample!=8 && projectFormat.wBitsPerSample!=16)
        {
                ShowMessage("Sorry, format not supported for echo effect");
                return;
        }
 
        float ap;
        int dp;
 
        ap = ap_float_user;               // atenuation parameter
        dp = dp_bytes_user * projectFormat.nChannels;       
                        // delay in bytes, multiple of 2
                        // this value has to be multiple of nbChannels, here 2 or 1
 
 
        char* echoWaveData = new char[DataSize+dp];
        char* effectWaveData = new char[DataSize+dp];
 
        // copy WaveData into echoWaveData with decalage
        for(unsigned int i=0; i<DataSize+dp; i++)
        {
                if(i<(unsigned int)dp && projectFormat.wBitsPerSample == 8)
                        echoWaveData[i]= (Sample8)128;         // silent 128
                else
                        if(i<(unsigned int)dp && projectFormat.wBitsPerSample == 16) 
                                echoWaveData[i]=(Sample16)0;
                        else
                                echoWaveData[i]= WaveData[i-dp];
        }
        // end of copy with decalage // OK 16bits, OK 8bits
 
        // attenuation of echoWaveData
        // 8 bits per sample       
        if ( projectFormat.wBitsPerSample == 8 )
        {
                // local temporary variable to avoid cast everywhere
                Sample8 *pSamples = (Sample8 *) echoWaveData;    // change data interpretation
 
                // Traitment
                // take care of 8 bits format
                for(unsigned int i=0; i<DataSize+dp; i++)
                        pSamples[i] = (Sample8)((((int)pSamples[i]-127) * ap) + 127);
        }
        // 16 bits per sample
        else
                if ( projectFormat.wBitsPerSample == 16 )
                {
                        Sample16 *pSamples = (Sample16 *) echoWaveData;
                        unsigned int numSamples = (DataSize+dp) / 2;    // 2 bytes per sample
 
                        for(unsigned int i=0; i<numSamples; i++)
                                pSamples[i] = (Sample16)((float)pSamples[i] * ap);
                }
        // end attenuation // OK 16bits, OK 8bits
 
 
        // addition of two signals
        if ( projectFormat.wBitsPerSample == 8 )
        {
                // local variable to change interpretation
                Sample8 *pSamplesOri = (Sample8 *) WaveData;
                Sample8 *pSamplesEco = (Sample8 *) echoWaveData;
                Sample8 *pSamplesEffect = (Sample8 *) effectWaveData;
 
                // Traitement
                // have to treat case of sum > 127
                // we will add wave divide by 2
                // and multiply it by 2 at the end
                for(unsigned int i=0; i<DataSize+dp; i++)
                {
                        // do not copy data from WaveDatz[DataSize_or_more]
                        // no existing data here
                        if(i>=DataSize)
                        {
                                pSamplesEffect[i] = (Sample8)((int)64 + (int)pSamplesEco[i]/2); // because we divide all by 2
                        }
                        else
                        {
                                pSamplesEffect[i] = (Sample8)((int)pSamplesOri[i]/2 + (int)pSamplesEco[i]/2);
                        }
 
                }
                // Now, amplification of signal by 1.5
                // take care of 8 bits format
                for(unsigned int i=0; i<DataSize+dp; i++)
                        pSamplesEffect[i] = (Sample8)((((int)pSamplesEffect[i]-127) * 1.4) + 127);
 
        }
        // 16 bits per sample
        else
                if ( projectFormat.wBitsPerSample == 16 )
                {
                        Sample16 *pSamplesOri = (Sample16 *) WaveData;
                        Sample16 *pSamplesEco = (Sample16 *) echoWaveData;
                        Sample16 *pSamplesEffect = (Sample16 *) effectWaveData;
                        unsigned int numSamples = (DataSize+dp) / 2;    // 2 octets par échantillons
 
                        for(unsigned int i=0; i<numSamples; i++)
                        {
                                // do not copy data from WaveDatz[DataSize_or_more]
                                // no existing data here
                                if(i>=DataSize/2)
                                        pSamplesEffect[i] = (Sample16)((int)0 + (int)pSamplesEco[i]/2);
                                else
                                        pSamplesEffect[i] = (Sample16)((int)pSamplesOri[i]/2 + (int)pSamplesEco[i]/2);
 
                        }
 
                        for(unsigned int i=0; i<numSamples; i++)
                                pSamplesEffect[i] = (Sample16)((float)pSamplesEffect[i] * 1.4);
 
                }
        // end addition of two signals
        // 16 bits : OK
        // 8 bits : not at all, data more than +/-127
 
        // copying result into WaveData
        if(WaveData)
                delete[] WaveData;
        WaveData = new char[DataSize+dp];
 
 
        for(unsigned int i=0; i<DataSize+dp; i++)
                WaveData[i] = effectWaveData[i];
        // end copying
 
        // destroying buffer
        delete[] echoWaveData;
        delete[] effectWaveData;
 
        // reconfigure DataSize
        DataSize = DataSize + dp;
 
}