MP3 Music Player in Python

CSE 120 Final Report

Lincoln May

Table of Contents

1
 1. Introduction and Goals

2. Code Explanation

3. Challenges Faced 6

4. What I learned

Appendix A: Source Code

Appendix B: Progress Chart

14

2
Introduction and Goal:

When first reading about the final project for CSE 120, I was extremely

excited with the broadness of the project. It was great to have the ability to

choose to do the project on your own personal interests, which has been

uncommon in my university experience thus far. That being said, there was

an overwhelming number of projects and ideas to choose from. But after

giving it thought, I knew I wanted to do something related to music. An idea

that I had was to recreate a music app similar to Spotify or Apple Music. After

doing a little research on this idea, I saw that you could use pygame, a

library used for developing games in python, to play mp3 files. While

researching I also came across Tkinter, an interface used for developing

graphical user-interfaces. That is when I determined my goal was to build an

mp3 music player application using pygame and Tkinter. I wanted users to

be able to import their own folder of mp3 files and be able to play, pause,

and navigate through their music collection. I wanted the user interface to be

simple and intuitive. It includes buttons to play, pause, next and previous

track functionalities. There is also a list of songs displayed allowing users to

3
see what songs are next up and a volume slider to allow the users to easily

control the volume.

Code Explanation:

The first few lines of code import the necessary libraries for the project.

Pygame is used for the music playback functionalities, while Tkinter is used

to provide tools for creating the graphical user interface. The filedialog

module is used to open a dialog for directory selection, and OS handles file

and directory operations.

The next segment of code initializes pygame mixer which is used for

audio playback. Similarly, I also do some of the initialization for Tkinter. I

create the main window for my application and set the title to “Music

Player”. I then set the dimension of the window and add a menu bar, which

will later be used for file selection.

After most of the setup has been taken care of, I create a load song

function. This Function allows the user to select a directory containing mp3

files. It uses filedialog.askdirectory() to open a directory selection dialog. It

then scans the selected directory for MP3 files, adds them to the songs list,

and populates the song_list window with these songs. The first song in the

list is selected by default.

4
 The play song function manages the playback of the selected song. If

the song is not paused, it loads and plays the currently selected song from

the directory using pygame.mixer.music.load() and

pygame.mixer.music.play(). If the song is paused, it simply unpauses the

playback using pygame.mixer.music.unpause().

The pause song function pauses the current song playback. It uses

pygame.mixer.music.pause() to pause the song and sets the paused flag to

true to indicate that the song has been paused.

The next song function moves to the next song in the list and starts

playing it. It calculates the index of the next song, updates the curr_song

variable, and loads and plays the new song using the play song function. It

also updates the selection in the song_list window to reflect the currently

playing song.

The previous song function moves to the previous song in the list and

starts playing it. It also calculates the index of the previous song, updates

the curr_song variable, and loads and plays the new song using the play

song function, updating the selection in the song_list window to reflect the

currently playing song.

The set volume function adjusts the playback volume. It takes a value

from the volume slider, converts it to a range between 0 and 1, and sets the

volume using pygame.mixer.music.set_volume().

5
 The next segment sets up the menu and the list box in the main

window. The menu allows the user to select a folder containing MP3 files

using the load_song function. The song_list List box displays the list of songs

and is styled with black background and white text.

The final segment creates and positions the control buttons and the

volume slider. The buttons for previous, play, pause, and next functionalities

are created using tk.Button and they are open-source PNG images from the

internet. They are arranged in a grid within a frame to be more user-friendly.

The volume slider is created using tk.Scale, oriented horizontally, and linked

to the set_volume function. The default volume is set to 70%. Then I call

root.mainloop() to start the main event of the application.

Challenges Faced:

Overall, this project was very fun to develop but there was some

challenges faced along the way. One of the main challenges I faced initially

was that both Tkinter and pygame were completely new to me. I expected to

come across new things while working on this project but it was still

challenging learning how to use pygame and Tkinter. Luckily pygame was

not too complicated, but tkinter was a bit confusing. I have some experience

working with JavaFX, which I found similar to Tkinter. But I seem to have a

hard time understanding both. After a little research and practice I was able

to understand Tkinter to the extent needed for this project.

6
 Another challenge I faced while developing this project was using

filedialog and os modules. One significant challenge was ensuring that files

were handled correctly by Tkinter and the os module. Additionally, it was a

challenge to only append mp3 files to the song list, avoiding potential errors

or crashes from unsupported formats. Implementing the directory selection

dialog with filedialog.askdirectory() also introduced difficulties in user

interaction, this is because the user has to be aware that only mp3 files are

supported and it will result in errors if the user tries importing a different

type of file. Lastly, dynamically updating the graphical user interface to

reflect when the previous or next song buttons were selected was also

difficult to work out. I had to make sure that the program would not

unexpectedly crash if the song list was empty.

These challenges were tricky to deal with but ultimately they

strengthened my understanding of pygame, Tkinter, and accessing files. Not

only did they strengthen my understanding of python, but they also worked

to strengthen my ability to write code in general.

What I Learned:

Learning to integrate Tkinter for the graphical user interface and

pygame for music playback was a significant aspect of this project. These

libraries serve different purposes and combining them effectively required a

deep understanding of their functionalities and how they interact. Tkinter

7
provides the tools to build a user-friendly interface, while pygame handles

the audio playback. The challenge was to synchronize these libraries,

ensuring that the user interface responds correctly to audio events and user

inputs. Understanding this integration was crucial for the project's success

and helped in creating a user-friendly interface.

The project also deepened my understanding of event-driven

programming, this is very important for building interactive applications.

Tkinter relies heavily on events and callbacks to interact with the user, such

as button clicks and slider adjustments. This required me to design the

program logic in a way that responds to these events in real-time, ensuring

that user inputs are processed immediately and correctly. Working with

Tkinter enhanced my ability to think in terms of events and handlers, which

are fundamental concepts in GUI development.

Handling file operations in Python, including reading from directories

and managing file paths, was another important learning outcome of this

project. Using the os module, I was able to navigate directories, filter files by

their extensions, and manage file paths efficiently. This skill is crucial for any

application that interacts with the file system, and it ensured that the music

player could dynamically load and manage songs from different directories

without running into errors.

8
.

APPENDIX A: SOURCE CODE

Main.py:

import pygame

import tkinter as tk

from tkinter import filedialog, END, Scale

import os

pygame.mixer.init()

9
root = tk.Tk()

root.title("Music Player")

root.geometry("500x400")

menubar = tk.Menu(root)

root.config(menu=menubar)

def load_song():

global curr_song

root.directory = filedialog.askdirectory()

for song in os.listdir(root.directory):

name, ext = os.path.splitext(song)

if ext == '.mp3':

songs.append(song)

for song in songs:

song_list.insert("end", song)

if songs:

song_list.selection_set(0)

curr_song = songs[song_list.curselection()[0]]

def play_song():

global curr_song, paused

10
 if not paused:

pygame.mixer.music.load(os.path.join(root.directory, curr_song))

pygame.mixer.music.play()

else:

pygame.mixer.music.unpause()

paused = False

def pause_song():

global paused

pygame.mixer.music.pause()

paused = True

def next_song():

global curr_song, paused

try:

current_index = songs.index(curr_song)

next_index = (current_index + 1) % len(songs)

curr_song = songs[next_index]

song_list.selection_clear(0, END)

song_list.selection_set(next_index)

song_list.activate(next_index)

pygame.mixer.music.load(os.path.join(root.directory, curr_song))

pygame.mixer.music.play()

11
 paused = False

except IndexError:

pass

def prev_song():

global curr_song, paused

try:

current_index = songs.index(curr_song)

prev_index = (current_index - 1) % len(songs)

curr_song = songs[prev_index]

song_list.selection_clear(0, END)

song_list.selection_set(prev_index)

song_list.activate(prev_index)

pygame.mixer.music.load(os.path.join(root.directory, curr_song))

pygame.mixer.music.play()

paused = False

except IndexError:

pass

def set_volume(val):

volume = int(val) / 100

pygame.mixer.music.set_volume(volume)

12
organize_menu = tk.Menu(menubar, tearoff=False)

organize_menu.add_command(label="Select Folder", command=load_song)

menubar.add_cascade(label="Import Music", menu=organize_menu)

song_list = tk.Listbox(root, bg="black", fg="white", width=100, height=15)

song_list.pack()

songs = []

curr_song = ""

paused = False

play_img = tk.PhotoImage(file="play.png")

pause_img = tk.PhotoImage(file="pause.png")

prev_img = tk.PhotoImage(file="previous.png")

next_img = tk.PhotoImage(file="next.png")

control_frame = tk.Frame(root, bg="white")

control_frame.pack()

prev_button = tk.Button(control_frame, image=prev_img,

command=prev_song, borderwidth=0)

play_button = tk.Button(control_frame, image=play_img,

command=play_song, borderwidth=0)

pause_button = tk.Button(control_frame, image=pause_img,

command=pause_song, borderwidth=0)

next_button = tk.Button(control_frame, image=next_img,

command=next_song, borderwidth=0)

13
prev_button.grid(row=0, column=0, padx=10, pady=10)

play_button.grid(row=0, column=1, padx=10, pady=10)

pause_button.grid(row=0, column=2, padx=10, pady=10)

next_button.grid(row=0, column=3, padx=10, pady=10)

volume_slider = Scale(root, from_=0, to=100, orient='horizontal',

command=set_volume)

volume_slider.set(70)

volume_slider.pack(pady=10)

root.mainloop()

APPENDIX B: PROGRESS CHART

Date Progress Made

The goal of my first week of the project was to do develop

an
Week 1, 6/2 Interesting idea for a project that was also feasible in the
scope of a project for this class. I decided on the idea to
make an mp3 player and did slight research to ensure it
would work for my final project.

In the second week of working with the project, my goal

was to do deeper research into what is required for the
Week 2, 6/9 project, such as what libraries and tools would be
necessary to complete the project. I did research on
pygame and tkinter to see what it would be like working
with them as I progress.

14
 In the third week of the project, I got familiar with pygame
and tkinter before I was to start building my project. I
Week 3, 6/16 messed around with tkinter in the ide to get more familiar
with the syntax and usage and did the same with pygame
to a lesser extent.

Week 4 is when I started developing my project. I started

building the general layout in tkinter which was not too
Week 4, 6/23 complicated. Then I started developing some of the
functions for playing the music. I worked on the load
music, play, and pause logic.

This week I continued working on logic. I worked on the

logic behind the previous and next song buttons. I was
Week 5, 6/30 closing in on being done with the developing, but I decided
I wanted to add some more features, so I added a volume
slider.

In week seven, I mostly did testing of the project making

some slight changes. I downloaded some mp3 files off the
Week 6, 7/7 internet and added them to a folder so I could test the
mp3 player. Making some slight tweaks to the previous
and next button logic the mp3 player was in good shape.

In the last week of the project, I focused on writing the

Week 7, 7/14 final report.

15