OBJECTIVE

The primary objective of this experiment is to design and simulate a real-time

audio processing system using MATLAB. The aim is to provide students and
researchers with practical exposure to signal processing concepts by using a real-
world audio file. The simulation involves breaking the audio into small time
frames and analyzing each frame in both time and frequency domains. By doing
so, the process imitates how real-time systems, such as voice recognition and
audio monitoring systems, function. This hands-on project also introduces
important concepts like digital signal sampling, Fourier analysis, and
visualization. Understanding real-time audio processing helps bridge theoretical
knowledge with practical implementation. This experiment serves as a foundation
for more advanced topics like speech enhancement, real-time classification, and
adaptive filtering. Additionally, it offers a starting point for implementing real-
time DSP applications in audio communications, music signal processing, and
hearing aids. Overall, the project demonstrates the practicality of MATLAB in
simulating real-time systems, developing visualization skills for data analysis,
and promoting an understanding of fundamental digital signal processing
operations on real-world data. This fulfills educational objectives while also
providing a functional prototype for further development.

SOFTWARE USED

This experiment uses MATLAB, a powerful tool for numerical computation and
visualization. Key MATLAB functions include audioread for loading audio files,
uigetfile for file selection, fft for spectral analysis, and subplot, plot, and drawnow
for visualization. These tools enable real-time simulation of audio processing
tasks in a controlled environment.

1
 CODE

function real_time_audio_processing()
% Select audio file
[file, path] = uigetfile({'*.wav;*.mp3', 'Audio Files (*.wav, *.mp3)'});
if isequal(file, 0)
disp('No file selected.');
return;
end

% Read audio file

[data, Fs] = audioread(fullfile(path, file));
data = mean(data, 2); % Convert to mono if stereo

% Parameters
frameDuration = 0.1; % seconds
frameSize = round(Fs * frameDuration);
totalSamples = length(data);
numFrames = floor(totalSamples / frameSize);

% Create figure
figure('Name','Uploaded Audio Processing');

% Loop over frames

for i = 1:numFrames
idxStart = (i-1)*frameSize + 1;
idxEnd = idxStart + frameSize - 1;
frame = data(idxStart:idxEnd);

2
 t = (0:frameSize-1) / Fs;

% FFT
NFFT = 2^nextpow2(length(frame));
Y = fft(frame, NFFT);
f = Fs/2 * linspace(0, 1, NFFT/2 + 1);
mag = abs(Y(1:NFFT/2 + 1));

% Plot time domain

subplot(2,1,1);
plot(t*1000, frame);
title('Time Domain');
xlabel('Time (ms)');
ylabel('Amplitude');
ylim([-1 1]);

% Plot frequency domain

subplot(2,1,2);
plot(f, mag);
title('Frequency Domain');
xlabel('Frequency (Hz)');
ylabel('|Magnitude|');
xlim([0 Fs/2]);

drawnow;
pause(frameDuration); % mimic real-time feel
end

3
 EXPLAINATION OF CODE

The MATLAB code utilizes several key functions and constructs essential for
real-time audio processing simulation. The function keyword defines a reusable
function called real_time_audio_processing. The uigetfile function is used to
open a file browser window allowing the user to select an audio file with .wav or
.mp3 extensions. Once selected, the file is read using audioread, which loads both
the audio data and its sampling frequency, Fs. If the audio file has two channels
(stereo), it is converted to mono using mean(data, 2). Frame parameters are set
using frameDuration, and the frame size is calculated by multiplying with Fs. The
number of frames is computed using floor(totalSamples/frameSize) to ensure
integer segmentation.

Within a for loop, each frame is extracted and its time vector calculated. The Fast
Fourier Transform (FFT) is performed using fft, and the result is processed to
obtain frequency and magnitude data. nextpow2 optimizes the FFT length, and
linspace generates a frequency vector. The subplot function creates side-by-side
plots of the time-domain waveform and frequency-domain spectrum for each
frame. Functions like xlabel, ylabel, title, xlim, and ylim are used for plot
customization. drawnow ensures the plots are updated in real time, while
pause(frameDuration) provides a delay to simulate real-time playback. Together,
these components demonstrate an interactive and intuitive real-time audio
processing tool.

4
FLOWCHART

5
 OUTPUT

The simulation displays two subplots: the upper subplot shows the signal
amplitude over time, and the lower subplot displays the frequency spectrum of
each frame. Users can observe how the signal's amplitude and frequency content
evolve over time. This dynamic visualization helps in detecting changes such as
pitch variations, noise, or silence in the audio stream. It is a simple yet effective
demonstration of real-time signal behavior.

6
 ADVANTAGES

One of the main advantages of using MATLAB for real-time audio processing is
its rich library of built-in functions and toolboxes that simplify complex
operations like signal visualization, Fourier analysis, and file I/O. The high-level
syntax allows rapid prototyping of signal processing algorithms without worrying
about low-level memory management or threading. The simulation can be easily
adapted for various types of audio inputs, making it a flexible tool for educational,
research, and prototyping purposes. The dynamic plotting of time and frequency
domains provides immediate visual feedback, which enhances understanding and
aids in debugging.
Another key benefit is MATLAB’s interactive environment. Real-time plotting
with drawnow and pause functions creates an illusion of live processing, which
is excellent for demonstrations. Additionally, the system is extensible: users can
integrate filtering, speech detection, or even machine learning models to build
more advanced applications. MATLAB’s compatibility with audio formats like
.wav and .mp3 ensures broad usability.

LIMITATION

Despite its strengths, the real-time audio processing simulation in MATLAB

comes with several limitations. First and foremost, the system is not truly real-
time. It simulates real-time behavior by introducing pauses using the pause
function, which depends on CPU scheduling and may not mimic consistent
playback on different machines. This means the system isn’t suitable for latency-
sensitive applications like live communication or audio effects in professional
environments.
MATLAB also consumes relatively high system resources. For longer audio files
or high-resolution FFTs, the system may lag or become unresponsive, especially
on lower-end machines. Unlike compiled languages like C or real-time operating
systems (RTOS), MATLAB’s interpreted nature limits its speed and
responsiveness. It is therefore not ideal for deployment in embedded systems or
mobile platforms.

7
 CONCLUSION

This lab experiment effectively demonstrates real-time audio processing using

MATLAB. By reading and analyzing an audio file in short frames, we
successfully simulate a real-time system that processes data incrementally. The
use of time-domain and frequency-domain analysis helps in visualizing both the
amplitude variations and spectral characteristics of the audio signal. This dual-
domain visualization is especially beneficial for students and researchers to
understand how real-time digital signal processing works. The modular structure
of the code, including file selection, frame-based processing, FFT computation,
and live plotting, makes the system extensible for advanced tasks like audio
classification or enhancement.
The implementation also shows how basic DSP concepts such as frame
segmentation, Fourier analysis, and magnitude computation are applied in a real-
time context. Moreover, the visualization component strengthens the
comprehension of signal characteristics and transitions over time. Overall, this
experiment achieves its objective of demonstrating real-time signal capture and
processing. It also reinforces the utility of MATLAB in designing educational
simulations and rapid DSP prototypes. The real-time mimic using pause and
drawnow showcases how software-based environments can simulate hardware
behaviors for learning and experimentation. This makes it a valuable starting
point for future projects in audio signal processing.