I ordered mine within minutes of it being possible to do so. While more evolutionary than revolutionary, it’s got some nice features: smaller size (with same screen size), one month battery, double storage size, improved contrast, etc. You can read all about it on its own site.

More importantly though, I just watched the Jeff Bezos interview on Charlie Rose tonight. From the few times I’ve seen Jeff speak, he’s really impressed me. Three things he said today that, to me, got at the crux of why the Kindle is so good.

First, talking about iPad vs. Kindle and the design of the Kindle, saying people, “want a purpose built device where no trade offs have been made, where every single design decision as you’re walking down the process has been made to optimize for reading.” Very true. This idea not only differentiates the Kindle from the iPad, but also from the Nook. From reviews and testing one in the store, the Nook’s interface is just plain more complicated than the Kindle. The Nook chose gimmicks like the (relatively useless) color touch screen, where the Kindle tried to make its UI disappear.

This moved right into the whole e-ink display and the ease of reading, as well as the specific size and form factor of the Kindle, he talked about the idea of “long-form reading” and “short-form reading”, saying, “Most of the devices that have been developed by we humans over the last couple of decades have tilted the world towards short-form reading. So, Internet connected computers and smart phones and so on are great for short email messages, they’re great for blog posts. They’re not great for 300 page books.”

Finally, the kicker, what it’s really all about: “We’re not trying to create an experience. We want the author to create the experience.” Bingo.

The link to the Bezos interview isn’t up yet, but should be on this page when available: http://www.charlierose.com/guest/view/2618

[as3]package
{
import flash.media.Sound;
import flash.events.SampleDataEvent;
import flash.events.Event;

public class Tone
{
protected const RATE:Number = 44100;
protected var _position:int = 0;
protected var _sound:Sound;
protected var _numSamples:int = 2048;
protected var _samples:Vector.;
protected var _isPlaying:Boolean = false;

protected var _frequency:Number;

public function Tone(frequency:Number)
{
_frequency = frequency;
_sound = new Sound();
_sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
_samples = new Vector.();
createSamples();
}

protected function createSamples():void
{
var amp:Number = 1.0;
var i:int = 0;
var mult:Number = frequency / RATE * Math.PI * 2;
while(amp > 0.01)
{
_samples[i] = Math.sin(i * mult) * amp;
amp *= 0.9998;
i++;
}
_samples.length = i;
}

public function play():void
{
if(!_isPlaying)
{
_position = 0;
_sound.play();
_isPlaying = true;
}
}

protected function onSampleData(event:SampleDataEvent):void
{
for (var i:int = 0; i < _numSamples; i++)
{
if(_position >= _samples.length)
{
_isPlaying = false;
return;
}
event.data.writeFloat(_samples[_position]);
event.data.writeFloat(_samples[_position]);
_position++;
}
}

public function set frequency(value:Number):void
{
_frequency = value;
createSamples();
}
public function get frequency():Number
{
return _frequency;
}
}
}[/as3]

Note that in the constructor I call createSamples(). This creates the Vector with all samples needed for the duration of the note, including the amplitude of the pseudo-envelope. In the frequency setter, the samples are re-created. The result is that in the onSampleData handler method, I just fill up the byte array with the next so many values out of the _samples vector, stopping when I reach the end of that Vector.

Note also that the amplitude is decreased per sample, rather than per SAMPLE_DATA event, thus it needs to be reduced by a much smaller amount each time. This should also give a smoother envelope, though I’m not sure how noticeable it is.

Here’s a brief bit of code that shows it in action:

[as3]import flash.events.MouseEvent;

var tone:Tone = new Tone(800);
stage.addEventListener(MouseEvent.CLICK, onClick);
function onClick(event:MouseEvent):void
{
tone.frequency = 300 + mouseY;
tone.play();
}[/as3]

It creates a tone. Whenever you click on the stage, it calculates a new frequency for the tone based on the y position of the mouse and plays the tone. Simple enough.

I don’t consider this class anywhere near “complete”. Just a beginning evolution in something. I’d like to add support for more flexible and/or complex envelopes, a stop method, and some other parameters to change the sound. But even so, this is relatively useful as is, IMHO.

The first one is visualizing the wave you are playing. In the SAMPLE_DATA event handler, you are already generating 2048 samples to create a wave form. While you’re creating these, it’s a piece of cake to go ahead and draw some lines based on their values. Look here:

[as3]import flash.media.Sound;
import flash.events.SampleDataEvent;
import flash.events.MouseEvent;
import flash.utils.Timer;
import flash.events.TimerEvent;

var position:int = 0;
var n:Number = 0;
var sound:Sound = new Sound();
sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
sound.play();

function onSampleData(event:SampleDataEvent):void
{
graphics.clear();
graphics.lineStyle(0, 0×999999);
graphics.moveTo(0, stage.stageHeight / 2);
for(var i:int = 0; i < 2048; i++)
{
var phase:Number = position / 44100 * Math.PI * 2;
position ++;
var sample:Number = Math.sin(phase * 440 * Math.pow(2, n / 12));
event.data.writeFloat(sample); // left
event.data.writeFloat(sample); // right
graphics.lineTo(i / 2048 * stage.stageWidth, stage.stageHeight / 2 - sample * stage.stageHeight / 8);
}
}

var timer:Timer = new Timer(500);
timer.addEventListener(TimerEvent.TIMER, onTimer);
timer.start();
function onTimer(event:TimerEvent):void
{
n = Math.floor(Math.random() * 20 - 5);
timer.delay = 125 * (1 + Math.floor(Math.random() * 7));
}[/as3]

All I've done here is clear the graphics, set a line style, and move to the center left of the screen. Then with each sample, move across the screen a bit and up or down depending on the value of the sample. This gives you something looking like this:

You can see the wave change its frequency with each new note.

The next trick is something I learned from Andre Michelle a very short while ago. You notice that the sine wave as is feels very flat and bland. Quite obviously computer generated. That’s because the amplitude, or height, of the wave is always constant: -1.0 to 1.0. That’s just not natural for real world things that make sounds. If you strike a piano keyboard, you’ll notice that it goes very loud at first, then settles down to a steady value as you hold the key, then when you release it, it fades out. These changes in volume are known as the envelope of a sound. It generally has an four phases, known as ADSR. From Wikipedia:

Attack time is the time taken for initial run-up of level from nil to peak.
Decay time is the time taken for the subsequent run down from the attack level to the designated sustain level.
Sustain level is the amplitude of the sound during the main sequence of its duration.
Release time is the time taken for the sound to decay from the sustain level to zero after the key is released.

Many of Andre Michelle’s sound experiments and toys have a very nice, pleasing bell sound to them, so I knew he was using some kind of envelope, but I know that envelopes can be pretty complex to code. So I asked him about it. He gave me a one or two sentence answer which just made me say, “OH! Of course!” Basically, all you need to do is start the sound at full amplitude and reduce it over time. So simple. Essentially, you are throwing away the attack, decay, and sustain and just programming in a release.

In this version of the project, we just set up an amp variable and set it to 1.0. On each SAMPLE_DATA event, reduce the amplitude by a fraction. And multiply the sample value by that amplitude. When a new note begins, reset amp to 1.0.

[as3]import flash.media.Sound;
import flash.events.SampleDataEvent;
import flash.events.MouseEvent;
import flash.utils.Timer;
import flash.events.TimerEvent;

var position:int = 0;
var n:Number = 0;
var amp:Number = 1.0;
var sound:Sound = new Sound();
sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
sound.play();

function onSampleData(event:SampleDataEvent):void
{
graphics.clear();
graphics.lineStyle(0, 0×999999);
graphics.moveTo(0, stage.stageHeight / 2);
for(var i:int = 0; i < 2048; i++)
{
var phase:Number = position / 44100 * Math.PI * 2;
position ++;
var sample:Number = Math.sin(phase * 440 * Math.pow(2, n / 12)) * amp;
event.data.writeFloat(sample); // left
event.data.writeFloat(sample); // right
graphics.lineTo(i / 2048 * stage.stageWidth, stage.stageHeight / 2 – sample * stage.stageHeight / 8);
}
amp *= 0.7;
}

var timer:Timer = new Timer(500);
timer.addEventListener(TimerEvent.TIMER, onTimer);
timer.start();
function onTimer(event:TimerEvent):void
{
amp = 1.0;
n = Math.floor(Math.random() * 20 – 5);
timer.delay = 125 * (1 + Math.floor(Math.random() * 7));
}[/as3]

Here, I’m multiplying amp by 0.7 on each event. This gives a pretty pleasing bell sound. Change that value around to get different characters. Or you could even do some kind of funky vibrato thing like this:

[as3]amp = 0.5 + Math.cos(position * 0.001) * 0.5;[/as3]

OK, that’s all for this time.

Basics of Sound

Sound itself is essentially a change in the pressure of the air. Extremely simple layman’s terms here. Air is composed of various molecules. They are not uniformly smoothly distributed. There can be areas where they are under more pressure and packed more tightly together, and other areas where they are more spaced out. When something like a guitar string vibrates, it moves quickly back and forth at a specific speed. When it moves in one direction, it pushes the molecules of air closer to some other molecules in the same direction. The creates a dense pocket of air. Then the string moves back in the opposite direction, creating a bit of a vacuum. Not a real vacuum, but an area where there are less molecules. It then moves back again, creating another dense pocket.

These areas of dense and undense air move out across the room and eventually hit your ears. The dense air pushes your eardrum in, and the less dense pocket causes it to move out. The result is your eardrum starts vibrating at roughly the same frequency as the guitar string. This causes some bones to vibrate, which stimulate nerves at the same frequency, which send signals to your brain, saying “C Sharp”.

When you record sound, you use a microphone as a sort of electronic ear. It has some kind of diaphragm or other moving part that vibrates and creates and electrical signal which is recorded one way or the other. For playback, this electrical signal is regenerated and causes a speaker to vibrate at the same frequency. This pushes the air the same way the original guitar string did and you hear the same sound.

Synthesizing Sound

However, when we talk about synthesizing sound, we are doing it all from scratch. Flash, your computer’s sound card, and your headphones or speakers will handle generating the correct electrical signal and vibrating the air. But you need to do the math to figure out much and how fast to make things vibrate.

In Part I of this tutorial, we created random values which caused the speaker or headphones to vibrate at a completely chaotic pace, resulting in a radio-static-like fuzz. Creating an actual tone requires a bit more work, and hopefully some understanding of what you are doing.

Digital Sound

In analog sound, such as vinyl records or 8-track tapes (showing my age here), the sound is encoded smoothly as bumps in the groove of the record, or changes in a magnetic field on the tape. Digital sound takes discrete samples of the sound pressure at specific intervals.

Taking one of the simplest sound forms, a sine wave, here is a smooth analog version:

And here is the same wave, represented as 50 samples:

As you can see, the sampled version is not quite as accurate as the smooth wave. However, in high quality digital sound, these intervals are numerous enough that it is virtually impossible for most of the population to notice any difference. When you are synthesizing sound in Flash, you will be dealing with 44,100 samples per second. Remember that number, we’ll be doing some calculations with it.

Now, what we need to do is generate our samples with a series of values that wind up forming a sine wave like you see above. The top peak of the sine wave will be 1.0, the bottom will be –1.0 and the middle 0.0. To start simply, we’ll generate a single sine wave over the course of a full second. To keep track of where we’re at, we’ll use a variable called position. We’ll initialize it to 0 and increment it each time we create a new sample. Thus position will range from 0 to 44100 over the course of the first second of audio.

If we then divide position by 44100, we’ll get values that range from 0.0 up to 1.0 over the course of one second. And if we multiply that by 2PI, We’ll get values from 0 to 2PI, just what we need to generate a sine wave with the Math.sin function. Here’s the code so far:

[as3]import flash.media.Sound;
import flash.events.SampleDataEvent;
import flash.events.MouseEvent;

var position:int = 0;
var sound:Sound = new Sound();
sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
sound.play();

function onSampleData(event:SampleDataEvent):void
{
for(var i:int = 0; i < 2048; i++)
{
var phase:Number = position / 44100 * Math.PI * 2;
position ++;
var sample:Number = Math.sin(phase);
event.data.writeFloat(sample); // left
event.data.writeFloat(sample); // right
}
}[/as3]

If you run that file, you’ll be generating a sine wave that does one full cycle each second. Of course, this, being a 1 Hz sound wave, is far too low for the human ear to hear. To get a specific frequency sound, simply multiply phase by the frequency you want to hear. Humans can hear frequencies generally in the range of 25 to 25,000 Hz. Middle A on the standard musical scale is 440 Hz. So let’s try that. Change the line that calculates the sample to:

[as3]var sample:Number = Math.sin(phase * 440);[/as3]

That gives you A. You can find charts like this all over the net:

A 440
B flat 466
B 494
C 523
C sharp 554
D 587
D sharp 622
E 659
F 698
F sharp 740
G 784
A flat 831
A 880

Or, if you want to get more mathematical about it, the formula for each note, n, above or below 440 is:

440 * 2^(n / 12)

We can implement scales then by setting up an n variable, incrementing it on a timer, and using the above formula to calculate our frequency:

[as3]import flash.media.Sound;
import flash.events.SampleDataEvent;
import flash.events.MouseEvent;
import flash.utils.Timer;
import flash.events.TimerEvent;

var position:int = 0;
var n:Number = 0;
var sound:Sound = new Sound();
sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
sound.play();

function onSampleData(event:SampleDataEvent):void
{
for(var i:int = 0; i < 2048; i++)
{
var phase:Number = position / 44100 * Math.PI * 2;
position ++;
var sample:Number = Math.sin(phase * 440 * Math.pow(2, n / 12));
event.data.writeFloat(sample); // left
event.data.writeFloat(sample); // right
}
}

var timer:Timer = new Timer(500);
timer.addEventListener(TimerEvent.TIMER, onTimer);
timer.start();
function onTimer(event:TimerEvent):void
{
n++;
}[/as3]

Alternately, we can make a poor man’s generative music composer with a little help from Math.random:

[as3]function onTimer(event:TimerEvent):void
{
n = Math.floor(Math.random() * 20 – 5);
timer.delay = 125 * (1 + Math.floor(Math.random() * 8));
}[/as3]

This generates a different note, and a different duration (from 1/8th of a second up to one full second) for each note.

Armed with this alone, you are on your way to making your own sequencer or mini piano or other type instrument. Later, I’ll try to post some stuff on other wave forms, combining waves, envelopes, and other topics.

We’ll start by looking at the basic mechanics of the Sound object, how to code it up, and create some random noise. Later, we’ll start generating some real wave forms and start mixing them together, etc.

Diving right in

Flash 10 has the ability to synthesize sounds. Actually, there was a hack that could be used in Flash 9 to do the same thing, but it became standardized in 10.

Here’s how it works. You create a new Sound object and add an event listener for the SAMPLE_DATA event (SampleDataEvent.SAMPLE_DATA). This event will fire when there is no more sound data for the Sound to play. Then you start the sound playing.

[as3]var sound:Sound = new Sound();
sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
sound.play();[/as3]

At this point, because you have not loaded any actual sound, such as an MP3, WAV, etc. or attached it to any streaming sound data, there is nothing to play and the SAMPLE_DATA event will fire right away. So we’ll need that handler function:

[as3]function onSampleData(event:SampleDataEvent):void
{
}[/as3]

Our goal here is to give the Sound object some more sound data to play. So how do we do that? Well, the SampleDataEvent that gets passed to this function has a data property, which is a ByteArray. We need to fill that ByteArray with some values that represent some sound to play. We do that using the ByteArray.writeFloat method. Generally you want to write values from –1.0 to 1.0 in there. Each float value you write in there is known as a sample. Hence the “SampleDataEvent”. How many samples should you write? Generally between 2048 and 8192.

OK, that’s a big range of values. What’s best? Well, if you stick to a low number like 2048, the Sound will rip through those values very quickly and another SAMPLE_DATA event will fire very quickly, requiring you to fill it up again. If you use a larger number like 8192, the Sound will take 4 times as long to work through those values and thus you’ll be running your event handler function 4 times less often.

So more samples can mean better performance. However, if you have dynamically generated sounds, more samples means more latency. Latency is the time between some change in the UI or program and when that results in a change in the actual sound heard. For example, say you want to change from a 400 hz tone to a 800 hz tone when a user presses a button. The user presses the button, but the Sound has 8000 samples of this 400 hz tone in the buffer, and will continue to play them until they are gone. Only then will it call the SAMPLE_DATA event handler and ask for more data. This is the only point where you can change the tone to 800 hz. Thus, the user may notice a slight lag between when he pressed the button and when the tone changed. If you use smaller numbers of samples – 2048 – the latency or lag will be shorter and less noticeable.

For now, let’s just generate some noise. We’ll write 2048 samples of random values from –1.0 to 1.0. One thing you need to know first is that you’ll actually be writing twice as many floats. For each sample you need to write a value for the left channel and a value for the right channel. Here’s the whole program:

[as3]import flash.media.Sound;
import flash.events.SampleDataEvent;

var sound:Sound = new Sound();
sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
sound.play();

function onSampleData(event:SampleDataEvent):void
{
for(var i:int = 0; i < 2048; i++)
{
var sample:Number = Math.random() * 2.0 - 1.0; // -1 to 1
event.data.writeFloat(sample); // left
event.data.writeFloat(sample); // right
}
}[/as3]

If you run that, you should hear some fuzzy static like a radio tuned between stations. Note that we are generating a single sample and using that same value for left and right. Because both channels have exactly the same value for each sample, we’ve generated monophonic sound. If we want stereo noise, we could do something like this:

[as3]function onSampleData(event:SampleDataEvent):void
{
for(var i:int = 0; i < 2048; i++)
{
var sampleA:Number = Math.random() * 2.0 - 1.0; // -1 to 1
var sampleB:Number = Math.random() * 2.0 - 1.0; // -1 to 1
event.data.writeFloat(sampleA); // left
event.data.writeFloat(sampleB); // right
}
}[/as3]

Here we are writing a different random value for each channel, each sample. Running this, especially using headphones, you should notice a bit more “space” in the noise. It’s subtle and may be hard to discern between runs of the program, so let’s alter it so we can switch quickly.

[as3]import flash.media.Sound;
import flash.events.SampleDataEvent;
import flash.events.MouseEvent;

var sound:Sound = new Sound();
sound.addEventListener(SampleDataEvent.SAMPLE_DATA, onSampleData);
sound.play();

var mono:Boolean = true;
stage.addEventListener(MouseEvent.CLICK, onClick);
function onClick(event:MouseEvent):void
{
mono = !mono;
}

function onSampleData(event:SampleDataEvent):void
{
for(var i:int = 0; i < 2048; i++)
{
var sampleA:Number = Math.random() * 2.0 - 1.0; // -1 to 1
var sampleB:Number = Math.random() * 2.0 - 1.0; // -1 to 1
event.data.writeFloat(sampleA); // left
if(mono)
{
event.data.writeFloat(sampleA); // left again
}
else
{
event.data.writeFloat(sampleB); // right
}
}
}[/as3]

Here we have a Boolean variable, mono, that toggles true/false on a mouse click. If true, we write sampleA to the left and right channels. If mono is not true, then we write sampleA to the left channel and sampleB to the right channel. Run this and click the mouse. Again, the change is subtle but you should be able to notice it.

To see, or rather, to hear, the results of latency, change the 2048 in the for loop to 8192. Now when you click, you’ll notice a significant delay in the time between the click and the change from mono to stereo or vice versa.

One other note about the number of samples. I said, “generally” to use between 2048 and 8192. The fact is if you try to use more than 8192, you’ll get a run time error saying one of the parameters is invalid. so 8192 is a pretty hard limit. You can use less than 2048, but if you do, what happens is that the Sound object will work through those samples and then consider the sound is complete. It will not generate another SAMPLE_DATA event when it is done. Instead, it will generate a COMPLETE event. So if you want the sound to keep playing, you need to keep it supplied with at least 2048 samples at all times.

In the next installment, we’ll start creating some simple waves.

I’m not trying to be an Apple hater, but this letter just cracked me up.

http://www.apple.com/pr/library/2010/07/02appleletter.html

After that, in August, I’m off to FiTC’s San Francisco debut! I’ve always loved SF. When I was younger, it was my goal to eventually live there. That’s probably not in the cards now, and to be honest, my coffee-table-book-concept of the city has been tempered by being there in person, but it’s still a great place that I love to visit. I’ve been there for two Flash Forwards, and a number of times for other things. I’m really glad that FiTC has taken ownership of the city, giving me an excuse to get out there again.

One of the highlights this year is that Shawn has gotten Yugo Nakamura out from Tokyo to speak. Yugo is one of the – if not THE – grandfathers of all Flash rock stars. Although I was able to visit his studio the last time I was in Tokyo, sadly, he was out sick that particular day. I did happen to notice one of my books on his shelf though, which I took down and signed for him. Cheeky, I know, but I have no regrets.

There are the usual assortment of other great speakers as well. I’ll be doing my “Programming Art” presentation. This being my last conference speaking engagement of the year, it’s most likely the last chance you’ll have to see this particular talk.

Another first is that I’ve finally convinced my wife and daughter to come out this time! I’m excited to get to introduce them to some of my world wide friends. I’m hoping that if you all tell them how awesome and godlike I am, they’ll give me a little more respect at home. (Just kidding!) Anyway, this also means I’ll probably be out doing a bit more site seeing during the day, and probably taking it pretty easy at night.

Hope to see you in SF. Oh, and by the way, if you sign up and use the code “bit101″, you should score a 10% discount off your tickets.

Thus far, looks like we have the following showing interest:

Me
Jeni H.
Vic C.
Veronique B.
Brandon M.
Terry P.

But no need to RSVP. I think we’ll just leave from the front of the hotel (Holiday Inn Metrodome) right around 7:00. Just show up there with running gear. I’ll post any changes in this post, so check back right here.

At this point it looks like I’ll at least be going for a run on Monday and Tuesday morning before the conference. Probably 3-4 miles each day. Anyone up for it, contact me at kp – at – bit-101.com

But what the hell, it’s a free download, so if it was a decent IM client, I would be happy and ignore the rest. So I download and start the install process. Here’s what you get first:

In addition to installing itself, it wants to install a browser plugin that is going to give them money every time you buy something from certain merchants. Um… wtf? No thanks. Uncheck that and move on, cautiously at this point.

Next up we get this screen.

I admit, I actually fell for this one. I didn’t read carefully. Didn’t see an opt-out checkbox like on the other screen, clicked the “Accept” button, thinking it was a “Next” button. Moving on innocently, we get to this point:

OK, this is getting frigging ridiculous. They want to change my home page to “Google Powered Digsby” as well as my default search engine. Bug off! Worse even, is they want to use my CPU for grid computing. I didn’t even check what the hell they’d be computing on it, I just did a quick triple opt out and continued on, a bit pissed off at this point.

Then this window pops up.

No, I don’t want a damn Digsby account. I just want to see what the program does. I close that and get to the main interface, and see this:

Apparently, I HAVE to have a Digsby account to use the software at all. Well screw that. Just wasted 10 minutes of life. I close that, intending to uninstall the damn thing, but decide to check my email first. Whoa! There’s a giant “Welcome to Xobni” panel in my Outlook. Baffled, I uninstalled both Xobni and Digsby, and then walked through the Digsby install process again to see how I got duped into Xobni. That’s where I got the screenshots.

In the past, I’ve made critical remarks about software I’ve installed, only to have the developer contact me personally and say something like, “sorry you didn’t like it.” In a few cases, I felt bad – maybe I had been a bit overcritical, off the cuff puts downs, etc. But in this case, I’d say that Digsby leaves the impression of severe sleaze, bordering on malware. By my count, it tried to install 3 other pieces of software and make two browser configuration changes, all opt out. Two different UIs, for opt out, which caught me off-guard and tricked me into installing something I didn’t want. My fail, but that was their intention. So I have no problem slamming this piece of… software.

You have been warned.