Week 8 audio processing
This presentation is the property of its rightful owner.
Sponsored Links
1 / 35

CS 177 PowerPoint PPT Presentation


  • 74 Views
  • Uploaded on
  • Presentation posted in: General

Week 8: Audio Processing. CS 177. Sound. Light and sound are both transmitted in waves. Frequency. The human ear can hear between about 12 Hz and 20,000 Hz The higher the frequency of the wave, the higher the frequency of the note Note that the A an octave

Download Presentation

CS 177

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Week 8 audio processing

Week 8: Audio Processing

CS 177


Sound

Sound

  • Light and sound are both transmitted in waves


Frequency

Frequency

  • The human ear can hear between about 12 Hz and 20,000 Hz

  • The higher the frequency of the wave, the higher the frequency of the note

  • Note that the A an octave

    above concert A (A440) has twice

    the frequency

  • Each half-step is an increase in the

    frequency by a factor of about 1.06


Example of frequency change

Example of frequency change

  • We can take a sound:

  • And reproduce that sound at double the frequency (speeding it up):

  • Notice that we have to add twice as much information to have the sound fill the same amount of time


Amplitude

Amplitude

  • The amplitude of a wave is the distance to its peak (measured by its y-value)

  • In sound, amplitude is a measure of volume

  • The larger the amplitude, the louder the sound

Amplitude


Example of amplitude change

Example of amplitude change

  • We can take a sound:

  • And make the sound with half the amplitude:

  • The frequency is exactly the same, but the sound is half as loud


Real sounds

Real sounds

  • Something that looks like a smooth sine wave is called a pure tone

  • No real instruments play anything like that

  • Even the purest real sound has overtones and harmonics

  • Real sound is the result of many messy waves added together:


Digital sampling

Digital Sampling

  • On a computer, we cannot record a wave form directly

  • As usual, we have to figure out a way to store a wave as a series of numbers

  • We are going to use these numbers to approximate the heights of the wave at various points


Sample rate

Sample rate

  • Hertz (Hz) is a unit that means a number of times per second

  • We are going to break down the wave into lots of slices

  • We are going to have 44,100 slices in a second

  • Thus, we are slicing at 44,100 Hz


Sample values

Sample values

  • We slice up a wave and record the height of the wave

  • Each height value is called a sample

  • By getting 44,100 samples per second, we get a pretty accurate picture of the wave


Sample format

Sample format

  • There are many different formats for sampling audio

  • In our system, each sample will be recorded as a double

  • The minimum value of a sample will be -1.0 and the maximum value of a sample is 1.0

  • A series of samples with value 0.0 represents silence

  • Our samples will be stored in an array


Purpose of the stdaudio class

Purpose of the StdAudio class

  • Audio data on computers is sometimes stored in a WAV file

  • A WAV file is much simpler than an MP3 because it has no compression

  • Even so, it contains two channels (for stereo) and can have many different sample rates and formats for recording sound

  • The StdAudio class lets you read and write a WAV file easily and always deal with a single array of sound, sampled at 44,100 Hz


Stdaudio methods

StdAudio methods

  • Everything you’d want to do with sound:

  • To do interesting things, you have to manipulate the array of samples

  • Make sure you have StdAudio.java in your directory before trying to use it


Stdaudio example

StdAudio example

  • Let’s load a file into an array:

  • If the song has these samples:

  • Perhaps samplewill contain:

String file = “song.wav”;

double[] sample = StdAudio.read(file);


Stdaudio example1

StdAudio example

  • With the audio samples loaded into the array named sample, we can play them as follows:

StdAudio.play(sample);


Generating sound with stdaudio

Generating sound with StdAudio

  • Or, we could generate sound from scratch with StdAudio

  • This example from the book creates 1 second of the pitch A440:

  • StdAudio.SAMPLE_RATE is 44100

  • double[] sound = new double[StdAudio.SAMPLE_RATE + 1];

  • for( inti = 0; i < sound.length; i++ )

  • sound[i] = Math.sin(2 * Math.PI * i * 440 / StdAudio.SAMPLE_RATE);

  • StdAudio.play(sound);


Playthattune java

PlayThatTune.java

  • The book provides a short program called Play That Tune (pp. 150 and 205) that will generate a sequence of notes according to an input file

  • It’s a sort of software synthesizer

  • If you know the notes for a song you’d like to play and their durations, you can create a file to play it with PlayThatTune.java

  • java PlayThatTune < song.txt


Play that tune file format

Play That Tune file format

  • As you can see, the file is just a list of numbers giving pitch and duration

  • Although ugly, this form of bookkeeping takes up virtually no space compared to WAV files

  • Drawbacks:

    • You can only play one note at a time

    • All notes have a pure tone with a little bit of harmonics

    • It takes forever to type out an input file

    • No dynamics (volume control)


Sound waves

Sound waves

  • Remember, sound is a wave

  • We are going to start playing with the waveform now to get different effects

  • Phase is a property of a wave that can be determined by its starting position

  • You can think of phase as the alignment of the wave


Inverting phase

Inverting phase

  • What happens if we invert a sound wave?

  • For example, we turn this wave:

  • Into this wave:


Inverting phase in code

Inverting phase in code

  • How would we invert the phase of a wave in code?

  • And what does that crazy, upside-down sound sound like?

  • Exactly the same

  • The human ear is not sensitive to phase

  • double[] sound = StdAudio.read( file );

  • for( inti = 0; i < sound.length; i++ )

  • sound[i] = -sound[i];

  • StdAudio.play(sound);


Concerns with phase

Concerns with phase

  • Phase is still worth knowing about

  • If you hear two copies of the same sound, but one is 180° out of phase, the sounds will cancel each other out

  • This can happen if you hook up one of your stereo speakers backwards


Reversing a sound

Reversing a sound

  • To reverse a sound, we simply send the wave form backwards

  • For example, we take this sound:

  • And turn it into this sound:


Reversing a sound in code

Reversing a sound in code

  • How would we reverse a sound in code?

  • What does it sound like?

  • Sort of like a bizarre foreign language

  • double[] sound = StdAudio.read( file );

  • intstart = 0; int end = sound.length - 1;

  • while( start < end ) {

  • double temp = sound[start];

  • sound[start] = sound[end];

  • sound[end] = temp;

  • start++;

  • end--;

  • }

  • StdAudio.play(sound);


Amplitude1

Amplitude

  • Recall that the amplitude of a wave is the distance to its peak (measured by its y-value)

  • In sound, amplitude is a measure of volume

  • The larger the amplitude, the louder the sound

Amplitude


Example of amplitude change1

Example of amplitude change

  • We can take a sound:

  • And make the same sound with half the amplitude:

  • The frequency is exactly the same, but the sound is half as loud


Reducing volume in code

Reducing volume in code

  • How would we half the volume of a sound in code?

  • This is half the amplitude. Is this exactly half the volume?

  • No… this stuff gets complicated

  • Different frequencies with the same amplitude are actually perceived as different loudnesses

  • But, it’s close enough

  • double[] sound = StdAudio.read( file );

  • for(inti = 0; i < sound.length; i++ )

  • sound[i] = 0.5*sound[i];

  • StdAudio.play(sound);


Increasing volume in code

Increasing volume in code

  • How would we double the volume of a sound in code?

  • Be careful!

  • Remember that the max is 1.0 and the min is -1.0

  • If you go outside of that range, you should limit the values

  • double[] sound = StdAudio.read( file );

  • for(inti = 0; i < sound.length; i++ ) {

  • sound[i] = 2*sound[i];

  • if( sound[i] > 1.0 )

  • sound[i] = 1.0;

  • else if( sound[i] < -1.0 )

  • sound[i] = -1.0;

  • }

  • StdAudio.play(sound);


Speeding up sound

Speeding up sound

  • We can take a sound:

  • And shrink that sound in half the time (while also doubling its frequency):


Speeding up a sound in code

Speeding up a sound in code

  • How would we double the speed of a sound in code?

  • We are just taking every other sample

  • We are throwing out half the information

  • double[] sound = StdAudio.read( file );

  • double[] speed = new double[sound.length/2];

  • for(inti = 0; i < speed.length; i++ )

  • speed[i] = sound[2*i];

  • StdAudio.play(speed);


Slowing down sound

Slowing down sound

  • We can take a sound:

  • And stretch that sound to double the time (while also cutting its frequency in half):


Slowing down a sound in code

Slowing down a sound in code

  • How would we stretch that sound to double in code?

  • Often times, this can sound terrible

  • We are doubling the length of the sound, but we have no extra information

  • We are just filling in holes in the samples with copies

  • double[] sound = StdAudio.read( file );

  • double[] slow = new double[sound.length*2];

  • for(inti = 0; i < slow.length; i++ )

  • slow[i] = sound[i/2];

  • StdAudio.play(slow);


Speeding up or slowing down non integer amounts

Speeding up or slowing down non-integer amounts

  • Integers are easy

  • You can apply the same ideas to non-integer speed-ups and slow-downs

  • Smarter algorithms, like the ones used by professionals, may do some averaging or other tricks to retain sound quality


Adding noise

Adding noise

  • To add noise to a waveform, add small random numbers to the wave

  • Make sure that the random numbers are both positive and negative (with a mean of 0)

  • You can turn this wave:

  • Into this wave:


Removing noise

Removing noise

  • How can we turn this wave…

  • Into this wave?

  • That is much harder!


  • Login