Discussion :

[kira974]

Bonjour, je posséde un fichier son codé sous 8 bits.
J'aimerai savoir comment, sous matlab, est il possible de coder cet échantillons sous un nombre N de bits choisi par moi même en effectuant un ajustement d'échelle.

Quelles seraient les fonctions à utiliser??

[tubaas]

salut
que souhaites-tu faire exactement (quelles valeurs de N, quel format de fichiers...) ?

[kira974]

Bonjour,

J'ai actuellement un un fichier de son .wav avec des échantillons codés sur 8 bits.
J'aimerais etre capable de coder ces échantillons sur un nombre de bits donc inférieur à 8 et utiliser les bits restant pour y insérer une information comme un message texte encodé.

Merci à vous.

[tubaas]

salut
alors c'est à toi de créer l'algorithme sachant que l'encodage wav n'est pas extrêmement compliqué
j'avais écrit une petite fonction pour ceci, à toi de vérifier que je me suis pas trompé

Code :

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

1
2
3
4
5
6
7
8
9
10
%quantify signal at the deisred quantification
%use only with new quantication value inferior
%to the old quantication value
%sig_in signal d'entrée compris entre -1 et 1 (1 pour 0dBFS)
function sig_out=quantificationf(sig_in,nbit_out)
if sig_in >= 0
    sig_out=round(sig_in*(2^(nbit_out-1)-1))/(2^(nbit_out-1)-1);
else
    sig_out=round(sig_in*(2^(nbit_out-1)))/(2^(n_bitout-1));
end

ainsi tu peux quantifier ton signal avec le nombre de bits souhaité

edit : j'ai ramené la sortie entre -1 et 1. tu peux supprimer la division si tu veux la valeur à coder sur 6bits. je me suis basé sur du -1, 1 car par défaut c'est ce que te donne la fonction wavread

[kira974]

Merci tubaas!

Je pense encodé un message de type texte à l'aide de le méthode d'Huffman que j'ai pu voir dans l'aide de MATLAB, je vais voir se que sa donne...

finalement j'ai un peu de mal à utiliser et comprendre la fonction d'Huffman pour encoder un message texte..

Voila l'exemple donné dans l'aide de matlab

Code :

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

1
2
3
4
5
sig = repmat([3 3 1 3 3 3 3 3 2 3],1,50); % Data to encode
symbols = [1 2 3]; % Distinct data symbols appearing in sig
p = [0.1 0.1 0.8]; % Probability of each data symbol
dict = huffmandict(symbols,p); % Create the dictionary.
hcode = huffmanenco(sig,dict); % Encode the data.

En reprenant votre fonction je teste donc le code suivant :

Code :

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

1
2
3
4
5
6
7
sig = quantificationf(sig_in,6); % On code l'échantillon sur 6 bits
 
% on code le mot : MAISON
symbols = [1 2 3 4 5 6]; % Distinct data symbols appearing in sig
p = [1/6 1/6 1/6 1/6 1/6 1/6]; % Probability of each data symbol
dict = huffmandict(symbols,p); % Create the dictionary.
hcode = huffmanenco(sig,dict); % Encode the data.

Et je tombe sur cette erreur :

Code :

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

1
2
??? Error using ==> huffmanenco at 87
The Huffman dictionary provided does not have the codes for all the input signals.

Mon but est d'utiliser les bits restants sur mon fichier wav pour y encoder un texte, que dois je utiliser pour travailler sur les bits restant de mon signal?

Personne ne pourrait m'aider SVP

[tubaas]

salut
je ne comprends pas bien pourquoi tu veux utiliser un codage de huffmann quisert à de la compression.
d'paès ce que j'en lis (rapidement) sur Wikipedia, le code devrait plutôt ressembler à ceci (étant donné que tu as 2^6 valeurs possibles)

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
sig = quantificationf(sig_in,6)*(2^6);
% Ici l'échantillon n'est pas vraiment codé sur 6bits mais il prend des valeurs qui peuvent l'être

% on code notre signal
symbols = (-32:31); % Distinct data symbols appearing in sig
p = zeros(1,length(symbols); % Probability of each data symbol
for i=1:length(symbols)
p(i)=length(find(sig==symbols(i)));
end
dict = huffmandict(symbols,p); % Create the dictionary.
hcode = huffmanenco(sig,dict); % Encode the data.

function sig_out=quantificationf(sig_in,nbit_out)
if sig_in >= 0
    sig_out=round(sig_in*(2^(nbit_out-1)-1)); 0à31
else
    sig_out=round(sig_in*(2^(nbit_out-1))); -32à-1
end

code non testé j'ai pas la toolbox !!

cependant je ne crois pas que c'est ce que tu veux faire. coder un nombre sur 6bits n'est pas difficile (à partir des valeurs -32à31 tu peux faire un dec2bin par exemple) là où ça se complique c'est en ajoutant les codes détecteurs et correcteurs d'erreurs.

edit : dec2bin ne prend pas en charge le complément à 2 mais si c'est toi qui écrit un codeur t un décodeur et que tu ne t'intéresses pas à ce que ce soit relisible par ailleurs tu peux très bien par exemple translater ton signal vers les positifs pour le coder comme des entiers naturels et faire la translation inverse lors du décodage.

ex:

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
% signal
sig_in=((-1).^(1+round(rand(1,10))).*rand(1,10))
% codage
nbit_out=6;
if sig_in >= 0
    sig_out=round(sig_in*(2^(nbit_out-1)-1)); %0à31
else
    sig_out=round(sig_in*(2^(nbit_out-1))); %-32à-1
end
sig_out = sig_out +32;
sig_out = dec2bin(sig_out)
%décodage
sig_dec = bin2dec(sig_out);
sig_dec = sig_dec-32;
if sig_dec >= 0
    sig_dec=sig_dec/(2^(nbit_out-1)-1); %0à31
else
    sig_dec=sig_dec/(2^(nbit_out-1)); %-32à-1
end
sig_dec

Attention le précédent code ne marche pas car 1 est codé 1000000 (valeur 64). J'ai donc modifié la quantification (à remplacer partout) en utilisant l'indexation logique (que je ne maîtrisais pas à l'époque !). Tu vois dans l'exemple suibant que tout est bien codé sur 6bits :

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
%signal
sig_in=[((-1).^(1+round(rand(1,10))).*rand(1,10)) -1 0 1]
% codage
nbit_out=6;
sig_out(sig_in>=0)=round(sig_in(sig_in>=0)*(2^(nbit_out-1)-1)); %0à31
sig_out(sig_in<0)=round(sig_in(sig_in<0)*(2^(nbit_out-1))); %-32à-1
sig_out = sig_out +32
sig_out = dec2bin(sig_out)
%décodage
sig_dec = bin2dec(sig_out);
sig_dec = sig_dec-32;
sig_dec(sig_dec>=0)=sig_dec(sig_dec>=0)/(2^(nbit_out-1)-1);
sig_dec(sig_dec<0)=sig_dec(sig_dec<0)/(2^(nbit_out-1));
sig_dec
 
sig_in =
 
  Columns 1 through 11
 
   -0.6448    0.3763    0.1909    0.4283   -0.4820   -0.1206   -0.5895    0.2262   -0.3846    0.5830   -1.0000
 
  Columns 12 through 13
 
         0    1.0000
 
 
sig_out =
 
    11    44    38    45    17    28    13    39    20    50     0    32    63
 
 
sig_out =
 
001011
101100
100110
101101
010001
011100
001101
100111
010100
110010
000000
100000
111111
 
 
sig_dec =
 
   -0.6563
    0.3871
    0.1935
    0.4194
   -0.4688
   -0.1250
   -0.5938
    0.2258
   -0.3750
    0.5806
   -1.0000
         0
    1.0000