init CR

Partie1/quesion2.m

+% Charger les fichiers audio
+[y1, Fs1] = audioread('single_tone_piano1.wav');
+[y2, Fs2] = audioread('single_tone_piano2.wav');
+
+% Calculer la FFT
+N1 = length(y1);
+N2 = length(y2);
+f1 = (-N1/2:N1/2-1)*(Fs1/N1);
+f2 = (-N2/2:N2/2-1)*(Fs2/N2);
+
+Y1 = fftshift(abs(fft(y1)));
+Y2 = fftshift(abs(fft(y2)));
+
+% Affichage
+figure;
+subplot(2,1,1);
+plot(f1, 20*log10(Y1));
+title('Spectre du Piano 1');
+xlabel('Fréquence (Hz)');
+ylabel('Amplitude (dB)');
+xlim([0 2000]); % zoom sur la zone utile
+
+subplot(2,1,2);
+plot(f2, 20*log10(Y2));
+title('Spectre du Piano 2');
+xlabel('Fréquence (Hz)');
+ylabel('Amplitude (dB)');
+xlim([0 2000]); % zoom aussi
+
+% Sauvegarder la figure
+saveas(gcf, 'spectre_pianos.png');
\ No newline at end of file

Partie1/question1.m

+% --- Paramètres ---
+clear; close all; clc
+
+% Charger les sons d'instruments
+[instru1, Fs1] = audioread('single_tone_guitar_nylon_string_a2.wav');   % Exemple instrument à cordes
+[instru2, Fs2] = audioread('single_tone_violin-a3.wav');    % Exemple instrument à cordes
+[instru3, Fs3] = audioread('single_tone_cello-a3.wav');     % Exemple instrument à vent
+
+% Assurer que ce sont des signaux mono
+if size(instru1,2) > 1, instru1 = mean(instru1,2); end
+if size(instru2,2) > 1, instru2 = mean(instru2,2); end
+if size(instru3,2) > 1, instru3 = mean(instru3,2); end
+
+% Découper pour avoir la même durée
+N = 2^14; % Nombre d'échantillons (choisi ici pour avoir une puissance de 2)
+instru1 = instru1(1:N);
+instru2 = instru2(1:N);
+instru3 = instru3(1:N);
+
+% --- Calcul FFT ---
+f1 = (-N/2:N/2-1)*(Fs1/N); % Axe fréquentiel
+f2 = (-N/2:N/2-1)*(Fs2/N);
+f3 = (-N/2:N/2-1)*(Fs3/N);
+
+FFT1 = fftshift(fft(instru1));
+FFT2 = fftshift(fft(instru2));
+FFT3 = fftshift(fft(instru3));
+
+% --- Calcul de l'amplitude en dB ---
+Amp1 = 20*log10(abs(FFT1));
+Amp2 = 20*log10(abs(FFT2));
+Amp3 = 20*log10(abs(FFT3));
+
+% --- Affichage ---
+figure;
+subplot(3,1,1)
+plot(f1, Amp1);
+xlim([0 5000]); % Limiter entre 0 et 5000 Hz (à adapter si besoin)
+xlabel('Fréquence (Hz)');
+ylabel('Amplitude (dB)');
+title('Spectre de la Guitare');
+grid on
+
+subplot(3,1,2)
+plot(f2, Amp2);
+xlim([0 5000]);
+xlabel('Fréquence (Hz)');
+ylabel('Amplitude (dB)');
+title('Spectre du Violon');
+grid on
+
+subplot(3,1,3)
+plot(f3, Amp3);
+xlim([0 5000]);
+xlabel('Fréquence (Hz)');
+ylabel('Amplitude (dB)');
+title('Spectre de la contrebasse');
+grid on
+
+% --- Détermination de la fréquence fondamentale ---
+% Chercher le maximum dans la partie positive
+[~, idx1] = max(Amp1(N/2:end));
+[~, idx2] = max(Amp2(N/2:end));
+[~, idx3] = max(Amp3(N/2:end));
+
+f_fondamentale1 = f1(N/2 + idx1 - 1);
+f_fondamentale2 = f2(N/2 + idx2 - 1);
+f_fondamentale3 = f3(N/2 + idx3 - 1);
+
+fprintf('Fréquence fondamentale guitare : %.2f Hz\n', f_fondamentale1);
+fprintf('Fréquence fondamentale violon  : %.2f Hz\n', f_fondamentale2);
+fprintf('Fréquence fondamentale flûte   : %.2f Hz\n', f_fondamentale3);
\ No newline at end of file

Partie1/question3.m

+% Charger le son
+[y, Fs] = audioread('single_tone_piano1.wav');
+
+% FFT
+N = 2^nextpow2(length(y));
+Y = fft(y, N);
+P = abs(Y(1:N/2+1));
+f = Fs*(0:(N/2))/N;
+
+% Trouver la fondamentale (plus fort pic sous 500 Hz)
+[~, loc_f1] = max(P(f < 500)); % Suppose que f1 est sous 500Hz
+f1 = f(loc_f1);
+
+% Initialiser
+freq_harm = zeros(1,8);
+amp_harm = zeros(1,8);
+
+% Chercher 8 harmoniques autour de nf1
+for n = 1:8
+    [~, idx] = min(abs(f - n*f1)); % Trouver l'index proche de n*f1
+    freq_harm(n) = f(idx);
+    amp_harm(n) = P(idx);
+end
+
+% Durée du son
+duration = 2; % secondes
+t = 0:1/Fs:duration;
+
+% Signal synthétisé
+synth = zeros(size(t));
+for k = 1:8
+    synth = synth + amp_harm(k) * cos(2*pi*freq_harm(k)*t);
+end
+
+% Normaliser
+synth = synth / max(abs(synth));
+
+% Jouer le son
+sound(synth, Fs);
+
+% Sauvegarder si besoin
+audiowrite('piano_synthetise.wav', synth, Fs);
\ No newline at end of file

Partie1/question4.m

+% Définir les durées relatives
+attackTime = 0.1;   % secondes
+decayTime = 0.2;    % secondes
+sustainLevel = 0.6; % entre 0 et 1
+releaseTime = 0.5;  % secondes
+
+% Créer l'enveloppe
+attackSamples = round(attackTime*Fs);
+decaySamples = round(decayTime*Fs);
+sustainSamples = round((duration - attackTime - decayTime - releaseTime)*Fs);
+releaseSamples = round(releaseTime*Fs);
+
+envelope = [linspace(0,1,attackSamples), ...
+            linspace(1,sustainLevel,decaySamples), ...
+            sustainLevel*ones(1,sustainSamples), ...
+            linspace(sustainLevel,0,releaseSamples)];
+
+% Ajuster au vecteur temps t
+envelope = [envelope, zeros(1, length(t) - length(envelope))];
+
+% Appliquer l'enveloppe au signal synthétisé
+synth_adsr = synth .* envelope;
+
+% Jouer le son
+sound(synth_adsr, Fs);
+
+% Sauvegarder
+audiowrite('piano_synthetise_adsr.wav', synth_adsr, Fs);
\ No newline at end of file

Partie2/question22.m

+N = 1024;
+fe = 1000;
+t = (0: N - 1) / fe;
+x = sign(sin(2 * pi * 5 * t));   % signal carré 5 Hz
+
+% Filtrage passe-bas
+b = [0.5, 0.5];
+a = 1;
+y = filter(b, a, x);
+
+% FFT
+Xf = fftshift(fft(x)) / N;
+Yf = fftshift(fft(y)) / N;
+f = (-N / 2 : N / 2 - 1) * (fe / N);
+
+% Affichage avec subplot
+figure;
+
+subplot(2,1,1);
+plot(f, 20 * log10(abs(Xf) + 1e-12), 'b');
+xlabel('Fréquence (Hz)');
+ylabel('Amplitude (dB)');
+title('Spectre du signal d’entrée (x[k])');
+grid on;
+
+subplot(2,1,2);
+plot(f, 20 * log10(abs(Yf) + 1e-12), 'r');
+xlabel('Fréquence (Hz)');
+ylabel('Amplitude (dB)');
+title('Spectre du signal de sortie (y[k]) après filtrage');
+grid on;

Partie2/test_effet_reverb.m

+% test_effet_reverb.m
+% Script de test de la fonction effet_reverb avec mesure de temps
+
+% --- Étape 1 : Chargement du signal audio source ---
+[x, fe] = audioread('nylon-guitar.wav');  % x : signal source, fe : fréquence d'échantillonnage
+
+% --- Étape 2 : Simulation de la pièce ---
+addpath('C:\Users\infos\OneDrive\Bureau\IMT\Electrical Engineering IMT\SAR\synth_add\student_pack\src');
+z = simule_piece(x, fe);  % réponse simulée de la pièce
+
+% --- Étape 3 : Estimation de la réponse impulsionnelle ---
+[Rzx, ~] = xcorr(z, x, 'none');
+h = Rzx / max(abs(Rzx));  % normalisation facultative
+
+% Application de la réverbération avec mesure de temps ---
+tic;                             % démarrage du chronomètre
+y = effet_reverb(x, h);          % application de la réverbération
+temps_execution = toc;           % arrêt du chronomètre
+
+% Affichage du temps d'exécution ---
+fprintf('Temps d''exécution de effet_reverb : %.6f secondes\n', temps_execution);
+
+% --- Étape 6 : Écoute et export du signal ---
+sound(y, fe);                                 % écoute dans MATLAB
+audiowrite('nylon-guitar-reverbe.wav', y, fe); % export dans un fichier .wav

Partie3/Q319.m

+% Paramètres du filtre
+K = 10;                % Taille du filtre de moyenne glissante
+Fe = 44100;            % Fréquence d'échantillonnage
+Nfft = 4096;           % Taille de la FFT pour la résolution
+
+% Réponse impulsionnelle : moyenne glissante
+h = ones(1, K) / K;
+
+% Réponse en fréquence
+H = fft(h, Nfft);
+H = fftshift(H);                 % Centrer autour de 0
+nu = linspace(-0.5, 0.5, Nfft);  % Axe des fréquences réduites
+
+% Affichage
+figure;
+
+% Module linéaire
+plot(nu, abs(H), 'b', 'LineWidth', 1.5);
+xlabel('Fréquence réduite \nu');
+ylabel('|H_r(\nu)|');
+title('Module linéaire du filtre h_r(k)');
+grid on;
\ No newline at end of file

Partie3/analyse_delay.m

+% analyse_delay.m
+% Script pour obtenir et tracer la réponse impulsionnelle h(k) d’un filtre à retard
+
+% Paramètres du filtre
+tau = 5;       % Retard en échantillons
+g = 0.7;       % Coefficient d'atténuation
+N = 10 * tau;  % Durée d'observation suffisante pour voir les réflexions
+
+% Signal d'entrée : une impulsion de Dirac
+x = zeros(1, N);
+x(1) = 1;  % Dirac à k = 0
+
+% Définition des coefficients du filtre
+a = [1, zeros(1, tau - 1), g];
+b = 1;
+
+% Calcul de la réponse impulsionnelle
+h = filter(b, a, x);
+
+% Affichage de la réponse
+k = 0:N-1;
+stem(k, h, 'filled');
+xlabel('k');
+ylabel('h(k)');
+title('Réponse impulsionnelle du filtre à retard');
+grid on;
\ No newline at end of file

Partie3/analyse_freq_delay_filtre.m

+% analyse_freq_delay_filtre.m
+% Analyse de la réponse fréquentielle du système à delay filtré
+
+% Paramètres
+Fe = 44100;        % fréquence d'échantillonnage
+g = 0.9;           % atténuation
+K = 10;            % longueur moyenne
+tau_s = 0.25;      % retard en secondes
+tau = round(tau_s * Fe);
+N = 4096;          % taille FFT
+
+% Impulsion en entrée
+x = zeros(1, N);
+x(1) = 1;  % Dirac
+
+% Réponse du système
+h = effet_delay_filtre(x, tau_s, g, K, Fe);
+
+% Réponse fréquentielle
+H = fft(h, N);
+nu = linspace(0, 1, N);  % fréquence réduite
+
+% Affichage
+plot(nu, abs(H), 'LineWidth', 1.5);
+xlabel('Fréquence réduite \nu');
+ylabel('|h(nu)|');
+title('Réponse fréquentielle du système à delay filtré');
+grid on;

Partie3/effet_delay.m

+function y = effet_delay(x, delay_s, g, Fe)
+%EFFET_DELAY applique un effet de retard (delay) sur un signal audio.
+%
+%   y = effet_delay(x, delay_s, g, Fe)
+%
+%   Entrées :
+%     - x        : signal d'entrée (vecteur)
+%     - delay_s  : temps de retard en secondes
+%     - g        : coefficient d'atténuation
+%     - Fe       : fréquence d'échantillonnage (Hz)
+%
+%   Sortie :
+%     - y        : signal de sortie filtré avec effet de delay
+
+    % Convertir le temps de delay en nombre d'échantillons
+    tau = round(delay_s * Fe);
+
+    % Définir les coefficients du filtre (forme canonique)
+    a = [1, zeros(1, tau - 1), g];
+    b = 1;
+
+    % Appliquer le filtre
+    y = filter(b, a, x);
+end

Partie3/effet_delay_filtre.m

+function y = effet_delay_filtre(x, delay_s, g, K, Fe)
+%EFFET_DELAY_FILTRE applique un effet de delay avec moyenne glissante dans la boucle de retour.
+%
+%   y = effet_delay_filtre(x, delay_s, g, K, Fe)
+%
+%   Entrées :
+%     - x        : signal d'entrée
+%     - delay_s  : durée du retard (en secondes)
+%     - g        : coefficient d'amortissement
+%     - K        : longueur du filtre de moyenne
+%     - Fe       : fréquence d'échantillonnage (Hz)
+%
+%   Sortie :
+%     - y        : signal de sortie avec effet de delay filtré
+
+    % Calcul du retard en échantillons
+    tau = round(delay_s * Fe);
+
+    % Initialisation du vecteur de sortie
+    N = length(x);
+    y = zeros(size(x));
+
+    % Boucle de calcul récursif
+    for k = 1:N
+        % Calcul de la somme de moyenne glissante
+        somme = 0;
+        for n = 0:K-1
+            index = k - tau - n;
+            if index > 0
+                somme = somme + y(index);
+            end
+        end
+        y(k) = x(k) - (g / K) * somme;
+    end
+end

Partie3/effet_reverb.m

+function y = effet_reverb(x, h)
+% EFFET_REVERB Applique un effet de réverbération à un signal source
+%
+%   y = effet_reverb(x, h)
+%
+%   Entrées :
+%     - x : signal source (vecteur ligne ou colonne)
+%     - h : réponse impulsionnelle estimée (vecteur)
+%
+%   Sortie :
+%     - y : signal x après application de la réverbération (convolué par h)
+
+    % Vérification des entrées
+    if nargin < 2
+        error('Deux arguments sont requis : effet_reverb(x, h)');
+    end
+
+    % Conversion éventuelle en vecteurs colonne
+    if isrow(x)
+        x = x(:);
+    end
+    if isrow(h)
+        h = h(:);
+    end
+
+    % Convolution via un filtre RIF (réponse impulsionnelle finie)
+    y = filter(h, 1, x);
+end

Partie3/effet_reverb_FFT.m

+function y = effet_reverb_FFT(x, h)
+%EFFET_REVERB_FFT Applique l'effet de réverbération via convolution rapide (FFT)
+%
+%   y = effet_reverb_FFT(x, h)
+%
+%   Entrées :
+%     - x : signal source
+%     - h : réponse impulsionnelle estimée
+%
+%   Sortie :
+%     - y : signal réverbéré obtenu via convolution rapide dans le domaine fréquentiel
+
+    % Vérification des entrées
+    if nargin < 2
+        error('Deux arguments sont requis : effet_reverb_FFT(x, h)');
+    end
+
+    % Conversion éventuelle en vecteurs colonne
+    if isrow(x)
+        x = x(:);
+    end
+    if isrow(h)
+        h = h(:);
+    end
+
+    % Détermination de la taille optimale pour la FFT
+    NFFT = 2^nextpow2(length(x) + length(h) - 1);
+
+    % FFT des deux signaux (zéro-padding)
+    Xf = fft(x, NFFT);
+    Hf = fft(h, NFFT);
+
+    % Produit dans le domaine fréquentiel
+    Yf = Xf .* Hf;
+
+    % Revenir dans le domaine temporel
+    y_temp = ifft(Yf);
+
+    % Tronquer à la longueur réelle attendue
+    y = real(y_temp(1 : length(x)));
+
+end

Partie3/karplusStrong.m

+function signal = karplusStrong(freqHz, iterations, fs, g, alpha)
+    % freqHz     : fréquence fondamentale en Hz
+    % iterations : durée en nombre d'échantillons
+    % fs         : fréquence d'échantillonnage
+    % g          : facteur d'amortissement (0 < g < 1)
+    % alpha      : coefficient du filtre de boucle (entre 0 et 1)
+
+    N = floor(fs / freqHz);  % taille de la ligne à retard
+    x = 2 * rand(1, N) - 1;   % bruit blanc centré
+
+    % Initialisation de la ligne à retard
+    y = zeros(1, iterations);
+    y(1:N) = x;               % amorçage avec bruit blanc
+    for k = N+2:iterations
+        y(k) = g * (alpha * y(k - N) + (1 - alpha) * y(k - N - 1));
+    end
+
+    signal = y;
+
+    % Lecture et affichage
+    sound(signal, fs);
+    plot(signal), grid on, title('Karplus-Strong avec perte d’énergie')
+end