I ran across SoundSnap today – what a great resource for finding free sound effects and music loops. For those participating in the GGMUG Silverlight Game Development Contest, this might come in handy for you, so please check it out!

http://www.soundsnap.com/

By the way, the GGMUG is a great venue to meet new people who are passionate about .NET development. If you live on the East side of town, and just can’t make it to those Alpharetta meetings held by the other user groups, then please check this new group out if you haven’t already.

Audio support is all too often one of the last things a developer thinks of when it comes to building a user interface. Fortunately, Silverlight offers some basic building blocks that make it fairly trivial to add event-driven sounds to our applications. I have taken the built-in functionality one step further, and created a simple run-time audio engine that makes it even easier.

First, I will discuss the requirements that I had in mind when I created this engine. Second, I will discuss the ideal API for a complete solution. Third, I submit the simple effects engine that I developed in order to meet those requirements and API.

Sound Effects Engine Requirements

• Must be able to play looping “background music” tracks.
• Must be able to play smaller sound effects on demand.
• Must support concurrent (and overlapping) sounds effects without interfering with already-playing audio.
• Must adequately handle the possibility of download delays when pulling down external audio files.
• Should cache audio files between playbacks.
• Should allow serving of audio from high-bandwidth CDN such as Silverlight Streaming.

An Ideal Sound Effects API

• Should be very approachable. If possible, only a single line of code to play any audio (similar to PlaySound() API).
• Should support any formats supported by Silverlight.
• Should be efficient.
• Should offer download and playback completion callbacks (for chaining and synchronization).
• Should support aggressive background pre-caching of audio files.

The SilverlightToolbox Solution

To address the simplicity requirements, this sound effects engine is implemented as a single static C# class that can be easily included into any Silverlight project. It can exist in a referenced class library, or can be linked directly into the main project.

To address looping background music, a single method SetBackgroundLoop() is supplied. This will begin playback of a single audio clip, and will automatically repeat it. Only one track can be played as the background loop – calling this method again will terminate the running track and start the new one. You can also pass String.Empty to stop all background music.

To address typical sound effect clips. two overloads of the PlaySoundEffect() method are supplied. The simpler of the two methods will simply play a clip once it has been downloaded. The extended version allows you to specify a callback for when the clip has been downloaded and started playing, and a second callback that can be used for notification that the clip has ended.

To address the scenario where multiple sound effects might be played at the same time, the engine internally maintains a queue of MediaElements. When a new sound needs to played, it pulls an unused element and puts it into service. Once the sound is finished, the element is returned to the queue. This allows Silverlight itself to handle media mixing, and by caching those MediaElements, it does so without placing undue stress on the environment.

To address the issue of download delays, the startedCallback and completedCallback parameters of PlaySoundEffect() were introduced.

To address caching of audio files, a WebClient is used (which in turn leverages the browser’s cache). Furthermore, the engine will reuse any downloaded file streams (and is smart enough to not re-queue the same file if it already queued for download).

By using a MediaElement for playback, audio tracks are automatically supported from streaming sources and Content Delivery Networks, and can be of any type supported by Silverlight.

To support chaining of audio effects, and to support synchronization of UI with audio, the PlaySoundEffect() method accepts callback events that are fired when the clip has been downloaded, and again when it has completed playback. To further help with UI synchronization, a second utility class is provided (DelayedAction) which provides a simple wrapper for BackgroundWorker that can be used to easily delay execution of a block of code after a specified amount of time.

To support pre-caching of audio files, the PreloadMedia() method can be used.

Typical usage:

In order for the sound effects engine to function properly, it must be provided with a top-level XAML container (MediaElement currently will not perform playback without a parent object). This is done by calling the Initialize() method, typically from your program’s startup code:

SoundEffects.Initialize(this.LayoutRoot);

After this has been done, background music can be played, and we can also queue up some sound effect clips for later:

SoundEffects.SetBackgroundLoop("cautious-path.wma");
SoundEffects.PreloadMedia("pop1.wma");

Then, at various points throughout the application, we can play the sound effect (for example, in response to a control event):

SoundEffects.PlaySoundEffect("pop1.wma");

If at any point we need to delay the sound effect slightly, we can control this be introducing a short delay:

DelayedAction.Execute(2.0, () => SoundEffects.PlaySoundEffect("pop1.wma"));

Complete Source Code for DelayedAction.cs:

               1:
              using System;

               2:
              using System.ComponentModel;

               3:
              using System.Threading;

               4:  

               5:
              namespace Wintellect.SilverlightToolbox

               6: {

               7:
              public
              class DelayedAction

               8: {

               9:
              class DelayedCallback

               10: {

               11:
              public TimeSpan
Delay { get; set; }

               12:
              public Action
Callback { get; set; }

               13: }

               14:  

               15:
              public
              static
              void Execute(double seconds,
Action callback)

               16: {

               17: BackgroundWorker
Delay = new BackgroundWorker();

               18: Delay.DoWork
+= (s, e) =>

               19: {

               20: DelayedCallback
DelayCallback = (DelayedCallback)e.Argument;

               21: Thread.Sleep(DelayCallback.Delay);

               22: e.Result
= DelayCallback.Callback;

               23: };

               24: Delay.RunWorkerCompleted
+= (s, e) =>

               25: {

               26: Action
Callback = e.Result as Action;

               27: Callback();

               28: };

               29: Delay.RunWorkerAsync(new DelayedCallback

               30: {

               31: Delay
= TimeSpan.FromSeconds(seconds),

               32: Callback
= callback

               33: });

               34: }

               35: }

               36: }

Complete Source Code for SoundEffects.cs:

               1:
              using System;

               2:
              using System.Collections.Generic;

               3:
              using System.IO;

               4:
              using System.Net;

               5:
              using System.Windows;

               6:
              using System.Windows.Controls;

               7:
              using System.Windows.Media;

               8:  

               9:
              namespace Wintellect.SilverlightToolbox

               10: {

               11:
              public
              static
              class SoundEffects

               12: {

               13:
              static Panel
Root;

               14:
              static MediaElement
BackgroundLoop = new MediaElement();

               15:
              static WebClient
EffectDownloader = new WebClient();

               16:  

               17:
              static Queue<MediaElement>
AvailableSoundEffectGenerators = new Queue<MediaElement>();

               18:
              static Dictionary<string,
Stream> DownloadedEffects = new Dictionary<string,
Stream>();

               19:
              static Queue<string>
PendingDownloads = new Queue<string>();

               20:
              static Queue<QueuedEffect>
PendingEffects = new Queue<QueuedEffect>();

               21:
              static Dictionary<MediaElement,
Action> PendingStartupCallbacks = new Dictionary<MediaElement,
Action>();

               22:
              static Dictionary<MediaElement,
Action> PendingCompletionCallbacks = new Dictionary<MediaElement,
Action>();

               23:  

               24:
              enum TargetType

               25: {

               26: BackgroundMusic,

               27: SoundEffect,

               28: }

               29:  

               30:
              class QueuedEffect

               31: {

               32:
              public
              string MediaName
{ get; set; }

               33:
              public TargetType
Target { get; set; }

               34:
              public Action
StartedCallback { get; set; }

               35:
              public Action
CompletedCallback { get; set; }

               36: }

               37:  

               38:
              public
              static
              void Initialize(Panel
root)

               39: {

               40: Root
= root;

               41: InitializeTarget(root,
BackgroundLoop);

               42: EffectDownloader.OpenReadCompleted
+= (s, e) =>

               43: {

               44: DownloadedEffects[(string)e.UserState]
= e.Result;

               45: DownloadEffects();

               46: PlayEffect();

               47: };

               48: }

               49:  

               50:
              static
              void DownloadEffects()

               51: {

               52:
              if (PendingDownloads.Count
== 0)

               53:
              return;

               54:
              string MediaName
= PendingDownloads.Dequeue();

               55: EffectDownloader.OpenReadAsync(new Uri(MediaName,
UriKind.Relative), MediaName);

               56: }

               57:  

               58:
              static
              void InitializeTarget(Panel
root, MediaElement target)

               59: {

               60: target.Width
= 0;

               61: target.Height
= 0;

               62: target.Visibility
= Visibility.Collapsed;

               63: root.Children.Add(target);

               64: target.AutoPlay
= false;

               65: target.MediaOpened
+= (s, e) =>

               66: {

               67: MediaElement
Target = s as MediaElement;

               68: Target.Volume
= 0.35;

               69: Target.Play();

               70:
              if (PendingStartupCallbacks.ContainsKey(Target))

               71: {

               72: Target.Dispatcher.BeginInvoke(PendingStartupCallbacks[Target]);

               73: PendingStartupCallbacks.Remove(Target);

               74: }

               75: };

               76: target.MediaEnded
+= (s, e) =>

               77: {

               78: MediaElement
Target = s as MediaElement;

               79: Target.Stop();

               80:
              if (s
== BackgroundLoop)

               81: Target.Play();

               82:
              else
            

               83: AvailableSoundEffectGenerators.Enqueue(Target);

               84:  

               85:
              if (PendingCompletionCallbacks.ContainsKey(Target))

               86: {

               87: Target.Dispatcher.BeginInvoke(PendingCompletionCallbacks[Target]);

               88: PendingCompletionCallbacks.Remove(Target);

               89: }

               90: };

               91: }

               92:  

               93:
              static MediaElement
GetUnusedEffectGenerator()

               94: {

               95:
              if (AvailableSoundEffectGenerators.Count
> 0)

               96:
              return AvailableSoundEffectGenerators.Dequeue();

               97:
              else
            

               98: {

               99: MediaElement
Result = new MediaElement();

               100: InitializeTarget(Root,
Result);

               101:
              return Result;

               102: }

               103: }

               104:  

               105:
              static
              void PlayEffect()

               106: {

               107:
              lock (PendingEffects)

               108: {

               109:
              if (PendingEffects.Count
== 0)

               110:
              return;

               111: QueuedEffect
Effect = PendingEffects.Dequeue();

               112:
              if (DownloadedEffects.ContainsKey(Effect.MediaName))

               113: {

               114: MediaElement
TargetElement = null;

               115:
              switch (Effect.Target)

               116: {

               117:
              case TargetType.BackgroundMusic:

               118: {
TargetElement = BackgroundLoop; break; }

               119:
              case TargetType.SoundEffect:

               120: {
TargetElement = GetUnusedEffectGenerator(); break;
}

               121: }

               122:
              if (Effect.StartedCallback
!= null)

               123: PendingStartupCallbacks.Add(TargetElement,
Effect.StartedCallback);

               124:
              if (Effect.CompletedCallback
!= null)

               125: PendingCompletionCallbacks.Add(TargetElement,
Effect.CompletedCallback);

               126: TargetElement.SetSource(DownloadedEffects[Effect.MediaName]);

               127: }

               128:
              else
            

               129: {

               130: PendingEffects.Enqueue(Effect);

               131: }

               132: }

               133: }

               134:  

               135:
              static
              void PlaySound(TargetType
target, string mediaName, Action startedCallback,
Action completedCallback)

               136: {

               137:
              if (target
== TargetType.BackgroundMusic)

               138:
              if (BackgroundLoop.CurrentState
!= MediaElementState.Stopped)

               139: BackgroundLoop.Stop();

               140:  

               141:
              if (mediaName
!= String.Empty)

               142: {

               143:
              lock (PendingEffects)

               144: {

               145:
              if (!DownloadedEffects.ContainsKey(mediaName))

               146: {

               147: PendingDownloads.Enqueue(mediaName);

               148: }

               149: PendingEffects.Enqueue(new QueuedEffect

               150: {

               151: MediaName
= mediaName,

               152: Target
= target,

               153: StartedCallback
= startedCallback,

               154: CompletedCallback
= completedCallback

               155: });

               156: }

               157: DownloadEffects();

               158: PlayEffect();

               159: }

               160: }

               161:  

               162:
              public
              static
              void SetBackgroundLoop(string mediaName)

               163: {

               164: PlaySound(TargetType.BackgroundMusic,
mediaName, null, null);

               165: }

               166:  

               167:
              public
              static
              void PlaySoundEffect(string effectName)

               168: {

               169: PlaySound(TargetType.SoundEffect,
effectName, null, null);

               170: }

               171:  

               172:
              public
              static
              void PlaySoundEffect(string effectName,
Action startedCallback, Action completedCallback)

               173: {

               174: PlaySound(TargetType.SoundEffect,
effectName, startedCallback, completedCallback);

               175: }

               176:  

               177:
              public
              static
              void PreloadMedia(string mediaName)

               178: {

               179:
              if (!DownloadedEffects.ContainsKey(mediaName))

               180: {

               181: PendingDownloads.Enqueue(mediaName);

               182: DownloadEffects();

               183: }

               184: }

               185: }

               186: }

I have been running a Media Center PC as the hub of my home media network for a few years now - first MCE 2005 and then VMC (Vista Media Center) once it became available. In fact, I am about to install my 3rd XBOX 360 in my house (I use those as media extenders wherever I have a TV). I love my media setup - and more importantly - so does my wife.

I pretty much just let things run and don't think too often about it... but this week I ran across this completely awesome application which makes my setup even better... Lifextender.

Lifextender has a very simple premise, which is stated on the home page of it's website: "Lifextender is a dead-simple commercial-removal application". The program basically runs in the background where it monitors your system for new recordings. It then analyzes those recordings and removes any commercial pods that it finds. It is pretty good - I would say the success rate is about 95%. When it makes it mistake, it seems to always err on the side of caution and has never removed something I didn't want it to. The modified recordings are about 75% of the size of of the originals - which means it is literally giving me back 15 minutes of my life for every "hour" of commercial-infested programming that I watch.

And oh did I mention - It's also FREE (free as in beer)!

All of that being said, I have to admit that another huge reason for my recent silence was that I bought an Xbox 360 and now have a super-sweet HD home theater system to play it on!

I finally have my home system the way I want it. Media Center system is actually in another room - I only have the XBox as a video source in here (using XBMCE). I had all of the surround speakers installed into the walls and ceiling - thats the white panels on the wall. I still need to take the grills down and paint them to match the wall color, which will make them blend in much better.

I also took the opportunity to run a 6 source / 6 zone structural audio system. Thats just a weird way to say that I can play any one of 6 audio sources (including the media center) to any one of 6 rooms in the house. Each room has it's own volume control and source selection keypad, and a pair of stereo speakers flush mounted in the ceiling, as well as a pair of outdoor speakers for the courtyard. I know it sounds excessive, but it wasnt terribly expensive to do while the house was still being framed, and it's a fantastic upgrade for resale value if we decide to move again in a few more years. Not only that, but it's super cool to have.

Last May, I posted about how I was signing up for an internet-based file backup service. I saw it as insurance for my personal data, and an investment in my personal sanity. Today was the day I had to "cash in" on that investment.

The server that I have been using to store my personal files at home has been on its last leg for a while now. I went through the trouble of installing a RAID controller months ago and configuring for mirrored drives (faster recovery with mirrored, and besides I didnt have enough drive bays to support raid 5).

The strong winds yesterday caused the power in my home to waver on and off, which was the death blow for my ailing rackmounted UPS. And in it's final moments, as a last act, the UPS must have sent a spike into the server... because at this point, the server refuses to boot, or even to POST test. The redundant drives, while protecting me from a disk failure, are pretty useless without a server to power them up.

Thats when the internet backup came to the rescue. I was able to restore every byte of lost data (last successful backup was only the day before). Our digital photos, old emails, online banking files, corporate documents, source code repositories,... everything was salvaged!

I am very glad that I had the foresight nearly a year ago to plan for a significant data loss, and by taking the right steps managed to mitigate the risk, saving my personal digital valuables which would surely be lost today if I had not. I would definately recommend a data protection/backup service such as Storage Guardian to anyone with personal data that they consider important (which is pretty much everyone that owns a computer, isnt it?).

I wanted to go see Serenity in the theaters, but a friend of mine insisted that I watch the Firefly series first, to get the story background. He insisted that it would be worth the time to watch the first season. So one of the things I got for xmas this year was the first season of Firefly on DVD.

Wow, this show was fantastic! I now see why people who have seen the show have become loyal fans. I popped in the first disc last night around 10pm. I figured I would watch maybe one or two episodes then call it a night. At 5:30 in the morning I finished the second DVD (episodes 4 through 7) and finally went to bed... that leaves two more DVDs to get through yet... but this show was pretty darn good. It was nothing like what I expected. I was simply told that it was a sci-fi story that I would enjoy.

This is like Tombstone plus star trek plus the dukes of hazzard (the show, not the movie) all rolled into one... I never imagined I would like a "western" flavored series, but I certainly dig this one. I just need to find 8 more hours of spare time so I can watch the other episodes....

Then I can start thinking about when I will ever have time to watch the Lost and Battlestar Galactica first seasons on DVD that I also missed during broadcast but now have on DVD...

Over two weeks ago I bought a new HP Z552 media center system and a Linksys WMCE54AG Media Center Extender. I had such high hopes. I was going to be able to record my favorite shows for playback on my own schedule. I was going to centralize my digital photos and videos. I was looking forward to being able to play back any of this either on my main TV (rear-projection unit), or on my bedroom TV. I figured that by paying a premium price for the OEM'd system (over $1800 for both MCE and the extender), I would ensure a positive and hassle-free experience with MCE.

Today I am dismantling the whole thing and taking it back.

Here's why:

• The "IR Blaster" sucks with changing channels on my cable set-top box. Half the time it does not work at all, and often attempting to change the channel will trigger the set-top box to enter "program guide" mode, where it is impossible to change channels (without pressing the "exit" button on the original cable remote). This is certainly a nuisance when watching TV in the main room, but it is downright unacceptable when it happens while using the Extender (I have to walk down to my TV room in the basement to press that "exit" button before regaining control).
• Wireless is Useless. The Extender unit has integrated wireless, as does the MCE system itself. Installation manual recommends against connecting both to a WiFi access point (due to double hops). However, the Extender simply would not associate with the MCE if I attach the Extender to my access point while the MCE is directly attached via wired Ethernet. The only way to get the Extender functioning is to enable "access point mode" on the MCE system itself, so that Over-The-Air traffic goes directly from MCE to Extender. The catch here is that while the wireless connection is in Access Point Mode, the wired ethernet connection fails to operate, preventing access to/from any other networked computers including the internet (so the program schedule etc will not download).
• The tuner configuration is a nightmare. I have Comcast cable with a Motorola set-top box that is used rather widespread among their customers. Yet the MCE tuner configuration could not recognize it. My only two options were to guess the model number (it's not printed anywheres on the set-top box) from a list of about 20 Motorola devices, or to "train" the MCE to understand the IR codes used by that remote. It takes forever to get this configured correctly, and setting up more than one tuner is incrementally more difficult.
• The MCE system is nowhere near silent. HP chose to not use silent fans in the housing, and they also chose to not provide sufficient dampening on the hard drive.
• The MCE system is rather slow. I expected more performance out of a machine with these specs. It's really not much faster than my 3 year old laptop. I suspect the hard drive is a very cheap unit, and this impacts performance the most.
• The Extender is not very stable. While the video quality is good most of the time, it encounters "network congestion" often enough to be annoying (once an hour or so). There is nothing else attached to the network that connects the MCE to the Extender, so this must be related to some other issue. The Extender also has a habit of freezing up for as long as a minute at a time for no apparent reason... which is especially annoying if you are attempting to channel surf.
• Which brings up another problem - channel surfing is nearly impossible with the instability of the IR Blaster link. Changing channels quickly (quicker than once every 15 seconds) is a sure way to get the cable box to go into that dreaded guide mode.

Basically, the MCE platform has a lot of promise, that's for sure. I will almost definately try to return to it once these issues are addressed in future versions, but for now I just do not have the patience for these kinds of problems. Perhaps if the hardware did not cost me nearly $2000 I would be a little more forgiving - but for now I am going back to a primitive non-digital entertainment architecture.

And to be fair, my experience is due moreso to the abysmally poor products from Linksys and HP than to the core MCE operating system. But in order to achieve an adequate "wife acceptance factor" in my home, the MCE unit MUST look like it belongs next to a television... and very few vendors offer a system in that form factor (as opposed to the standard tower/desktop PC form factor). So for now, as far as I am concerned, this hardware is fairly representative of all MCE systems, since it's the only one I would accept in my living room.

Picture this:

Scenario 1 - You are a consultant. You write software for various clients, often remotely. Your clients pay you a lot of money, and you keep them very happy with the exceptional work you perform for them. Because you are a meticulous developer, and understand the value of versioning, you have been using Visual Sourcesafe for 6 years to store every code revision you have ever made for your clients. You also keep every one of your important emails for the last 10 years. Your Outlook .pst file contains every significant conversation you have ever had with your clients - and it also contains personal knowledge such as your complete contacts list and website registration confirmations for dozens of sites, including your 401K portfolio on Ameritrade.

Scenario 2 - You know nothing about code. You drive trucks for a living. However, you DO like to have gadgets and gizmos, and you really love your new Media Center Edition machine. In fact - it's so great that you have digitized ALL of your CD collection and even bought a portable media center for while out on the road. At this point you have over 5 gigs of music digitized, as well as the last season of stargate and family guy to watch as you have time. You never use your CDs anymore, and honestly have no clue where many of them are - since many have been "loaned" or misplaced.

Both of these fictional situations is missing something extremely important. Even though your digitized data is extremely valuable to you, and difficult if not impossible to recreate, you have no backup and recovery strategy!

How to correct this oversight?

There are several options. You could always purchase a simple external drive or tape system and perform regular backups. This is fairly easy, but is really only slightly better than having no backup at all... your backups are still in the same location as the protected systems. A house fire (not as uncommon as you might think) would wipe you out. If you are a consultant supporting a client with deep pockets (who would be forced to sue for negligence if you lost their source code), you cannot afford such a risk.

A better solution is off-site backup services. With off-site services, your valuable data is stored in a remote facility (usually encrypted). For a monthly fee, you can configure your systems to regulary upload changes. Fees tend to be quite small - especially for the individual consumer who often only needs a few Gig of storage. Setup and maintenance also tend to be fairly simple - about on par with traditional tape or disk based backup systems.

I have recently been evaluating two vendors in this space: NetCentric Solutions and Storage Guardian. NetCentric's offering is very easy to install and configure, but has fewer features and a slightly higher price tag. Storage Guardian's offering on the other hand is more difficult to install and configure (due to being more complex) but is much more flexible in deployment.

NetCentric supports File-system backups only, and is quite simple to get running. They also have a nice feature that allows you to access your backup sets from any internet location, essentially using your backup set as a file-sharing mechanism. The NetCentric product costs about $40 a month for up to 5G of compressed data.

Storage Guardian is a more "network aware" product. Rather than a simple single-install program like NetCentric, this product follows a client/server design, with a server process that performs the actual backups (oddly called "ds-client") and a client program that performs set management and inspection (called "ds-user"). This product has the ability to perform direct backups of SQL Server and Exchange databases, as well as NT/2K/XP/2K3 System State, permissions and registries. The installation is slightly complicated, and it is recommended that the installation guide actually be read carefully prior to attempted install. The Storage Guardian product costs about $30 a month for up to 10G of compressed data.

I ended up going with the Storage Guardian product for my personal needs. I really liked the ability to directly back up my Exchange and SQL databases. If you don't need those two things however, the NetCentric solution may be a better fit - since it's considerably easier to configure. My current volume needs are about 5G, so the Storage Guardian solution also allows me a little more room to grow.

In the end, $30 a month for peace of mind is a great bargain.

Apple just announced this really slick looking machine... the Mac Mini. I love the form factor, it reminds me of the old SPARC stations we used in college.

I sure would love to see a similar form factor MCE machine, priced around the same ($499). Right now, the best we can do with Media Center is the HP z540/z545 or a “build your own” using something like a D.Vine case from Ahanix.

Perhaps, like me, you are contemplating building your own Media Center PC. Perhaps the HP set-top boxes are just too expensive. And the other products from Dell, Viewsonic, etc just look ugly or are too noisy. Well, Microsoft held a live Webcast session a couple days ago, covering the entire build process for putting together an OEM MCE system. Pretty much all you need to know about hardware selection, common issues, and configuration is covered. I tuned in, and found it to be quite informative to someone (like me) who has yet to attempt the building of one. And now, the recorded webcast has been made available for viewing. This link will take you to the registration page if you are interested (60 minute duration webcast).

I just saw that there is already a linux-based offering in the PMC space. A company called ARCHOS is releasing the Pocket Media Assistant PMA400 this month (product specification page here). The feature list is very impressive, and it even claims to be capable of dealing with DRM-locked Windows Media files. And for under $800, it's quite an interesting device... especially considering it supports PDA functionality (touch screen!), wifi, wired ethernet, and even can record direct from cable/satellite.

This kind of competition is great, it will help push the envelope in the portable media and media center arenas.

Bill Gates did the keynote for CES in Las Vegas, where he demo'd Windows Media Center Edition. Of course, like any Microsoft demo he ever does, it crashes at some point (I think they stage the crashes on purpose, to get media interest higher). The entire keynote is taped and can be viewed online at:

http://metahost.savvislive.com/microsoft/20050105/ms_ces_20050105_300.asx

***This link has been slashdotted, so the playback is a little rough right now. I recommend setting your media player to a 64k stream max with a sixty second network buffer before trying to view this...