C++, char vers integer, binaire

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.

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

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

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é.

Citation:

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 ...

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:

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