Reference no: EM132379587

Assignment: COMP110 Introduction to Programming, University of North Carolina

Overview: This assignment has three problems.

• Removing Vocals: Write a function to remove the vocals from a sound object.

• Fading: Write functions to add a fade-in and fade-out effect to a sound object.

• Panning: Write a function to add a panning effect (from left to right) to a sound object.

Before you start coding, make sure you read through this whole document. If any of the instructions aren't clear, feel free to ask about it on Piazza (use the psa2 folder).

Initial Setup

Both you and your partner will need to get the starter code for your group using Git.

1. In VS Code, open the command palette and select the "Git Clone" option.

2. When prompted for the repository URL, enter the following, with X replaced by your group number (e.g. 7 or 12).

3. When prompted for where to save the repository, select the "comp110" folder you created for PSA #1. If you happen to get an error, make sure you click the "Git Log" button when prompted and look for the reported error message. Look at Piazza to see if anyone else got the same error message: if not, create a new post, copying and pasting the output of the Git log.

4. Choose the "Open Repository" option in the window that pops up in the lower-right corner of the screen. The repository should contain a file named comp110_psa2.py, which is where you will put all of the code you write for this assignment. You'll also see another python file, sound.py, that contains our sound module code: do not edit this file in any way. Finally, you'll notice a bunch of WAV audio files that you will use to test your code.

Next, you will need to install a few extra modules using Python's "pip" installer.

1. In VS Code, open up a Terminal window if you don't already have one open. Recall that you can go to "View" and then "Terminal" to open the terminal.

2. Make sure that the VS Code terminal you have open is NOT running a Python REPL. If it is, switch to a terminal that isn't running a REPL.

3. In the terminal, enter the following commands. Note that if you are using Windows, replace "python3" with "python".

python3 -m pip install -U numpy

python3 -m pip install -U scipy

python3 -m pip install -U sounddevice

4. Test that it worked by starting a Python REPL (using the VS Code command palette, like you learned in Lab 2). In the REPL, test out the following imports to make sure you don't get any errors.

import numpy

import scipy

import sounddevice

If you run into any problems, check Piazza to see if you can find the solution there. Otherwise, post a new question with the exact error message you get when doing the imports.

Note that when working on the PSA, you should be careful to only work on one computer at a time (either you or your partner's). If you want to switch between computers, make sure you "Sync" your code, using the same steps as in Problem 2 of PSA #0.

We also recommend that you stage changes, commit those changes, and sync the changes every time you finish one of the computational problems listed in this assignment. This ensures that you won't lose any of your work in case your computer gets lost or a file gets accidentally deleted. When committing, use a descriptive message, such as "completed the remove_vocals function."

Finally, remember when VS Code closes your repository when you exit and restart it. Use the "Open Recent" option (in the "File" menu) to reopen it if you can't find it.

Computational Problems

In lab session 3, you were introduced to the sound module, which provides some classes that allows us to work with digital audio. The following problems all require the use of this module. See the following sections if you need a refresher on digital audio and a reference on how to use the sound module.

Problem 1: Removing Vocals

Start by playing the love.wav file that is located in your repository folder. To do this, start a Python REPL in that folder by doing the following:

1. In VS Code, right click on "love.wav" file and select "Open in Terminal." This will create a new terminal and change it so you are in the folder containing that file.

2. In the newly opened terminal, start a Python REPL by typing in either python3 (if you are using macOS) or python (if you are using Windows). You should now see the familiar Python REPL prompt (i.e. ">>>").

Now enter the following code to import the sound module, create a new sound object, and play it. Make sure your speakers are on (but not too loud) so you can hear it playing.

import sound

love_sound = sound.load_sound("love.wav")

love_sound.play()

Beautiful, isn't it? Now, play the love_novocals.wav file, which demonstrates the vocal removal algorithm applied to the love.wav file.

no_vocals = sound.load_sound("love_novocals.wav")

no_vocals.play()

While it isn't perfect, you should notice that compared to the original, the vocals are (mostly) gone.

Exit the REPL by typing in the following:

exit()

Keep track of which terminal number this was, because you'll want to use that throughout the assignment.

The function you write for this problem, remove_vocals will be able to take a sound object created from that file, and produce a new sound object that is the same as the original sound but with vocals removed. The function header line for this function is given below.
def remove_vocals(snd):

The remove_vocals function takes a sound object snd as a parameter, and creates and returns a new sound with vocals removed using the algorithm described below. The new sound has the same number of samples as snd. (Remember: The original sound, snd, should NOT be modified.)

The algorithm works as follows. Recall that any given sample in snd contains two integer values, one for the left channel and one for the right. We'll refer to these values as left and right, and you can get them from a StereoSample object using the get_left and get_right methods. For each sample in snd, compute (left - right) / 2, and use this value for both the left and right channels of the corresponding sample in the new sound you are creating.

Here's an example. Let's say that snd contains the following three samples, each composed of two values: (left, right):

• (1010, 80)

• (1500, -4200)

• (-65, 28132)

Your program will produce a new sound consisting of the following three samples:

• (465, 465)

• (2850, 2850)

• (-14098, -14098)

If you do the math, you'll notice that the values in the third sample should have both been the fractional number -14098.5; but sample values must be integers. Make sure you use the integer division operator in (i.e. "//") to produce an integer rather than a floating point number. Keep this in mind for all of the functions you write in this assignment.

Testing the remove_vocals Function

Below is a short bit of Python code that shows how you could use the function you just wrote. To run it, you would start the REPL from the same terminal window as earlier and type in the following code.

import sound

import comp110_psa2

love = sound.Sound("love.wav")

love_no_vocals = comp110_psa2.remove_vocals(love)

love_no_vocals.play()

# You can use the stop method if you want to stop the sound

Exit the REPL when you are done testing.

If it worked correctly, you should hear the same "removed vocals" version of the love sound as you played initially. If you didn't notice the correct effect, you'll have to debug your code by track down the cause of the problem, fixing the problem, then test again.

IMPORTANT: It's important that you exit the REPL and restart it before testing again. This is because "import comp110_psa2" creates a copy of the comp110_psa2 module that sticks around until you exit the REPL; any changes you make to comp110_psa2.py won't go into effect until you restart the REPL and do the import again.

This is a bit annoying, but luckily you can save yourself some typing, by using the up and down arrow keys on your keyboard while in the REPL to go through your history of Python statements.

Aside: Why This Algorithm Works

For the curious, a brief explanation of the vocal-removal algorithm is in order. As you noticed from the algorithm, we are simply subtracting one channel from the other and then dividing by 2 (to keep the volume from getting too loud). So why does subtracting the right channel from the left channel magically remove vocals?

When music is recorded, it is sometimes the case that vocals are recorded by a single microphone, and that single vocal track is used for the vocals in both channels. The other instruments in the song are recorded by multiple microphones, so that they sound different in both channels. Subtracting one channel from the other takes away everything that is "in common" between those two channels which, if we're lucky, means removing the vocals.

Of course, things rarely work so well. Try your vocal remover on this badly-behaved wav file (cartoon.wav). Sure, the vocals are gone, but so is the body of the music! Apparently some of the instruments were also recorded "centred," so that they are removed along with the vocals when channels are subtracted. When you're tired of that one, try this harmonized song (harmony.wav). Can you hear the difference once you remove the vocals? Part of the harmony is gone!

Grading remove_vocals

The remove_vocals function is worth (6 pts), broken down as follows.

• Vocals correctly removed using specified algorithm. (3 pts)

• Effect works on all samples in sound. (1 pts)

• Original sound not modified. (2 pts)

Problem 2: Fading In and Out

For this problem, you will be writing three functions that will produce fade-in and fade-out effects. As with Problem 1, these functions should not modify the original sound object: they should create a copy of that original, modify the copy, then return that copy.

Fade-in

Start this problem by implementing the fade_in function, whose function header is given below.

def fade_in(snd, fade_length):

This function takes a sound object and an integer indicating the number of samples to which the fade-in will be applied. For example, if fade_length is 88200, the fade-in should not affect any sample numbered 88200 or higher. (Reminder: The first sample in a sound is numbered 0.)

Before we discuss how to accomplish fade-in, let's get acquainted with some fading-in. Listen to this monotonous sound of water bubbling (waver.wav), by playing it in the Python REPL (as you did with the love.wav file in the previous problem).

The volume in water.wav is stable throughout.

Next, use the REPL to play the water_shortfade.wav file. Notice how the water linearly fades in over the first two seconds, then remains at maximum volume throughout. This sound was created by calling the fade_in function on the original water sound, and the length set to 88200. (88200 corresponds to two seconds, because we're using sounds recorded at 44100 samples per second.)

If we were to call fade_in but with the length set to the total number of samples in the water sound, we get water with a long fade-in. The fade-in is slowly and linearly applied over the entire duration of the sound, so that the maximum volume is reached only at the very last sample.

To apply a fade-in to a sound, we multiply successive samples by larger and larger fractional numbers between 0 and 1. Multiplying samples by 0 silences them, and multiplying by 1 (obviously) keeps them the same. Importantly, multiplying by a factor between 0 and 1 scales their volume by that factor.

Here's an example. Assume fade_length is 4, meaning that I apply my fade-in over the first four samples (samples numbered 0 to 3). Both channels of those samples should be multiplied by the following factors to generate the fade-in:

Sample Number Multiply By...

0 0.0

1 0.25

2 0.5

3 0.75

>3 Do Not Modify the sample

After you implement the fade_in function, test it in the REPL, using the same basic process as you did to test the remove_vocals function in the previous problem. If you aren't getting the correct effect, you'll again have to exit the REPL, debug the problem, fix it, and test again.

Grading fade_in

The fade_in function is worth (6 pts), broken down as follows.

• Correct fading in effect. (2 pts)

• Fading effect only for the specified number of samples. (2 pts)

• Original sound not modified. (1 pts)

• Correct docstring comment at beginning of function and appropriate comments in the function body. The docstring comment must be in the same exact format is the one given to you for remove_vocals. (1 pt)

Fade-out

Now you will need to write a fade_out function, with header line given below.

def fade_out(snd, fade_length):

This function again takes a sound object and an integer indicating the length of the fade. However, this time, the fade is a fade-out (from loud to quiet), and the fade-out begins fade_length samples from the end of the sound rather than from the beginning. For example, if fade_length is 88200 and the length of the sound is samp samples, the fade-out should only affect samples numbered samp-88200 up to samp-1.

Let's use a raining sound to demonstrate (rain.wav). Take a moment to play this sound using the Python REPL.

As with the water bubbling above, the volume is stable throughout. Now, suppose we were to call the fade_out function with a fade length of 88000 samples (i.e. 2 seconds). We get rain with a short fade-out. The first few seconds of the rain are as before. Then two seconds before the end the fade-out starts, with the sound progressing toward zero volume. The final sample of the sound has value 0.

If you play the rain_shortfade.wav file, you can hear what it should sound like when you have correctly implemented fade_out and applied it to the rain sound. Go ahead and play that sound now.

The multiplicative factors for fade_out are the same as for fade_in, but are applied in the reverse order. For example, if fade_length were 4, the channels of the fourth-last sample would be multiplied by 0.75, the channels of the third-last sample would be multiplied by 0.5, the channels of the second-last sample would be multiplied by 0.25, and the channels of the final sample in the sound would be multiplied by

0.0.

Again, after implementing this function, test it using the REPL, debugging as necessary until you get the correct effect.

Grading fade_out

The fade_out function is worth (6 pts), broken down as follows.

• Correct fading out effect. (2 pts)

• Fading effect only for the specified number of samples. (2 pts)

• Original sound not modified. (1 pts)

• Correct docstring comment at beginning of function and appropriate comments in the function body. The docstring comment must be in the same exact format is the one given to you for remove_vocals. (1 pt)

Fade

For the last part of this problem, you will write a function named fade.

def fade(snd, fade_length):

This one combines both fading-in and fading-out. It applies a fade-in of fade_length samples to the beginning of the sound, and applies a fade-out of fade_length samples to the end of the sound. Don't be concerned about what to do when the fades would overlap; don't do anything special to try to recognize or fix this.

To avoid duplication of code, your implementation of fade must make calls to your fade_in and fade_out function.

Try out your fade on one more wav file (grace.wav). This one has a particularly abrupt beginning and end, which your fade function should be able to nicely finesse. This is a large file and can take a minute or two to process on a slow computer; test with smaller files first.

As usual, test it out using the Python REPL, debugging until you get it working perfectly.

Grading fade

The fade function is worth (4 pts), broken down as follows.

• Correct fading out effect. (1 pt)

• Fading effect only for the specified number of samples. (1 pt)

• Uses fade_in and fade_out functions to implement this function. (1 pt)

• Correct docstring comment at beginning of function and appropriate comments in the function body. (1 pt)

Problem 3: Panning from Left to Right

In this problem, you will write a single function that creates a panning effect, where sound moves from the left speaker to the right speaker. As in the previous problems, the function in this part should not modify the sound object it is passed; it should create and return a new sound object.

def left_to_right(snd, pan_length):

This function takes a sound object and an integer indicating the number of samples to which the pan will be applied. For example, if pan_length is 88200, the pan should not affect any sample numbered 88200 or higher.

Let's listen to what panning sounds like. In the REPLY, play the airplane sound (airplane.wave). The entire sound is centred, and does not move in the stereo field as you listen.

Now, if we were to call left_to_right setting the pan length to the total number of samples in the airplane sound, we get this airplane panning from left to right sound. The sound starts completely at the left, then slowly moves to the right, reaching the extreme right by the final sample. Play the airplane_pan.wav file in the REPL to hear what the effect should sound like.

Getting a sound to move from left to right like this requires a fade-out on the left channel and a fade-in on the right channel.

Here's an example. Assume pan_length is 4. The following table indicates the factors by which the channels of these samples should be multiplied:

Sample Number Multiply Left Channel By... Multiply Right Channel By...

0 0.75 0.0

1 0.5 0.25

2 0.25 0.5

3 0.0 0.75

> 3 Do Not Modify the sample Do Not Modify the sample

If you run left_to_right on only a prefix of a sound (i.e. you use a pan_length that is less than the length of snd), you'll get strange (though expected) results. For example, if you pan the first 441000 samples of love.wav, you'll hear it pan from left to right over the first ten seconds, then you'll hear a click followed by the remainder of the song played in the centre.

To understand how this function works, it might help to think of changing the volume using two volume controls: one for the left channel and one for the right. To make the sound seem like it's moving from left to right, you slowly lower the volume in the left ear and raise the volume in the right ear. There is no copying going on between the two channels.

For the record, this technique only works when corresponding samples of both channels are the same: experiment with this dog and lake sound (doglake.wav) to see what happens when channels contain different sounds.

Grading left_to_right

The left_to_right function is worth (4 pts), broken down as follows.

• Correct panning effect. (2 pts)

• Panning effect only for the specified number of samples. (1 pts)

• Correct docstring comment at beginning of function and appropriate comments in the function body. (1 pt)

Submission Instructions

Important: To be safe, you should run your final code on both you and your partner's computers. This will ensure that you are not relying on any special setup on your own computer for the code to work.

To submit your code, you will need to synchronize it using Git. To make sure your changes are saved and synchronized, follow these steps.

1. Open the "Source Control" menu, either by clicking on the 3rd icon on the left (right under the magnifying glass) or by going to "View" and "SCM".

2. Your comp110_psa2.py file should show up under the "Changes" section. Click on the "+" icon to the right of the comp110_psa2.py filename to "stage" the changes. This should move the file to a section named "Staged Changes."

3. Commit your changes by typing in a descriptive message (e.g. "finished the PSA") into the "Message" textbox (above the Staged Changes area). After entering the message, click the checkmark icon above the message box to perform the commit. This should remove the comp110_psa2.py file from the Staged Changes section.

4. Finally, Sync your commit(s) to the server by clicking the "..." (to the right of the checkmark from the last step) and select the "Sync" option. This will likely result in a pop-up notifying you that the sync will do a push and a pull. Select "OK" (or "OK and don't ask again") to complete the sync.

If you run into problems, make sure you are properly connected to the Internet and try the Sync again. If you are still running into problems, check Piazza and ask a new question there if the answer doesn't already exist.

Finally, to make sure that your changes were synced correctly, have your partner do the final step above (namely "..." and then "Sync"). This should fetch the changes you made. You can then test on their computer to make sure it works exactly the same as on your computer. If your partner has trouble accessing and/or running the file, it is likely that the grader will also have problems and your grade will be negatively impacted.

Background: Sound Waves and Digital Audio

Sound waves are variations in air pressure caused by a vibrating object, such as your hands clapping or your vocal cords producing a thorough definition of local and global variables in Python. Over the course of millennia, ears have evolved to detect these sound waves and help animals hear things in their environment. Much more recently, microphones have been developed to convert these mechanical vibrations into electrical form. Once in electrical form, they can be recorded on a computer in digital format, where they can be processed in some way.

The following short videos provide a nice overview of sound waves, including their graphical representation and how the shape of sound waves affect not only the loudness of a sound but also its tone/pitch.

• AudioPedia 101: Sound Waves Hearing (1)

• AudioPedia 101: Sound Waves Hearing (3)

When a microphone records sound, it takes a measure of the air pressure and returns it as a value. These values are called samples and can be positive or negative corresponding to increases or decreases in air pressure (or positive and negative voltages, when converted to electrical form). Each time the air pressure is recorded, we are sampling the sound. Each sample records the sound at an instant in time; the faster we sample, the more accurate is our representation of the sound. The sampling rate refers to how many times per second we sample the sound. Sampling rates of 11025 (bad quality; e.g. for VOIP conversations), 22050, and 44100 (CD quality) are common; the higher the sample rate, the better the audio quality.

Also affecting audio quality is the size of each sample, sometimes referred to as the sample_size or bit depth. The larger the sample size, the more distinct values we can hold per sample, allowing for us to accurately represent smaller variations in volume. Common sample size values are 16-bit (allowing for around 64000 distinct values per sample) and 24-bit (allowing for around 16,000,000 distinct values per sample). Samples are integer numbers, either positive or negative depending on whether the sound wave is above or below the x-axis in the waveform.

Sounds recordings are classified as either monaural (mono) or stereophonic (stereo). The difference is in the number of distinct values (a.k.a. channels) recorded for a sample: mono sounds have a single value while stereo sounds have two values. Stereo sounds typically have a "left channel" and "right channel" that allows you to independently control left and right speakers, thereby adding some direction to your sound. In this assignment, we'll deal exclusively with stereo sounds.

Some of the sound files in this assignment are modified versions of sounds from acoustica.com.

The sound Module

For this class we will be working with a custom Python module named sound. This module (given as part of the starter code) contains functions for working with sound files.

The sound module includes three new types of objects: Sound, StereoSample, and MonoSample. A Sound object is a sequence of sample objects, either StereoSample objects or MonoSample objects depending on the type of sound. For this assignment, you can assume sounds will be stereo, therefore all of the samples will be StereoSample objects. A StereoSample object contains both a left channel value and a right channel value, that you can both get and set.

In the following sections, we will briefly describe how to create and work with these new types of objects.

Creating Sound Objects

To create a sound object, you may use one of the following functions:

• sound.load_sound(filename): Creates a new Sound object from file filename

• sound.create_silent_sound(length): Creates a new Sound object that contains silence for length number of samples.

• sound.copy(snd): Creates a new Sound object that is an exact copy of the existing Sound object (snd) that you give it.

The following Python code demonstrates how to create a Sound object based on a digital audio data found in the meow.wav and create a second sound object that is a copy of that sound.

import sound

meow_sound = sound.load_sound("meow.wav")

print(type(meow_sound)) # prints out <class 'sound.Sound'>

second_meow = sound.copy(meow_sound)

Playing and Stopping Sounds

Once we have a Sound object, we can control its playback using the play and stop methods. For example, to create a new sound and play it, we could use the following Python code.

import sound

meow_sound = sound.load_sound("meow.wav")

meow_sound.play()

Getting and Working with Samples

For this assignment, you will need to modify individual samples of a Sound. To access a specific sample, we can use the Sound object's get_sample method. This method has one parameter: the index in the sequence of samples that you want to get. For example, to get sample number 42, in our meow_sound object, we would do the following.

meow_sound = sound.load_sound("meow.wav")

sample = meow_sound.get_sample(42)

print(type(sample)) # prints out <class 'sound.StereoSample'>

Once you have a StereoSample, you can access its right and left channel values using its get_left and get_right methods, both of which have no parameters. Continuing our previous example, we could print out the left and right channel values of our 42nd sample using the following code.

left_channel_value = sample.get_left()

print(left_channel_value) # prints left channel's value (an integer)

print(sample.get_right()) # prints right channel's value (an integer)

We can also modify the sample's left and right channel values using its set_left and set_right methods. Both of these methods require you give it one parameter: an int value that will become the new value for that channel. For example, if we want to silence the left channel of our sample (i.e. set it to 0), we could do the following.

sample.set_left(0)

Looping Through Many Samples in a Sound

Even a short Sound object contains thousands of samples. To process many of them at once, we could either repeat the same line of code thousands of times (boo!) or make use of a loop (yay!). For example, we could print out the left channel value of the first 20 samples in our meow Sound using the following code.

for i in range(20):

sample = meow_sound.get_sample(i)

print(sample.get_left())

If we want to loop through all of samples in a Sound, we need to know how many samples are there. Luckily we can use the len function to give us that information. For example, "len(meow_sound) would give us the number of samples in the meow Sound. We could therefore print the right channel for all samples in our meow Sound using the following code.

for i in range(len(meow_sound)):

sample = meow_sound.get_sample(i)

print(sample.get_right())