Ezequiel Jadib’s Blog

A month ago, Microsoft published the alpha version of the IIS Transform Manager. The Transform Manager provides simple integrated video encoding and batch conversion of video files to the IIS Smooth Streaming format.  It does this quite nicely, as it provides an extensible platform for scheduling and running multiple tasks in sequence on an IIS server using a local task scheduler. It enables "watch folder" job submission, queuing, management, integrated media transcoding/transmuxing, and batch-encryption of on-demand audio and video files. You can get more information from here, here and here.

My friend John Deutscher is leading these efforts. John has a lot of experience with media management software and a passion to make developers lives’ easier. He was also one of the masterminds behind the Rough Cut Editor (RCE), a lightweight, Web-based Silverlight video editing tool. As a client tool, it submits edit decision lists, but does not include the logic for transcoding. But it’s highly extensible, and from time-to-time, we’ve been asked about extending the tool to add an encoding workflow process.

The real question here is whether the RCE should take care of that. Instead, Why not take advantage of the tools available out there and use them to manage the complexity of the encoding process?

This post is result of exploring the feasibility of using the IIS Transform Manager to take an RCE Project XML file (which includes the EDL) as input, and creating the necessary task to output a new encoded video that represents the RCE edits?

So with that goal in mind, I started to build a proof of concept of the scenario, depicted in the following diagram:

PoC Diagram - (icons from picol.org)

The Ingredients

• Internet Information Services (IIS) 7 or higher
• Microsoft .NET Framework 3.5 Service Pack 1
• Microsoft .NET Framework 4 (required for use with Expression Encoder 4.0)
• Silverlight Runtime
• IIS Transform Manager 1.0 (Alpha)
• Microsoft Silverlight Rough Cut Editor configured to use the File System Data Provider (check the related topic on the RCE documentation)
• Microsoft Expression Encoder 4 Trial or Pro
• Sample videos (required for use with the RCE and the File System Data Provider)

The Recipe

OK. Let’s assume we have all the ingredients in place and that we are ready to start.

The first thing to do is to create the Transform Manager Task. This task will parse the RCE Project XML, extract the edits metadata and use that information with the Expression Encoder 4 API to perform the encoding.

I will not copy all the code for the Task in the post (you can download that from here. Make sure to include into the libs folder the EE4 and IIS Transform Manager assemblies in order to build the project), but instead let me highlight a few things:

1. To create a custom Task for the IIS Transform Manager you must implement the ITransformTask interface (Microsoft.Web.Media.TransformManager.Sdk.dll)
2. Once you have created the task, you must create a task definition xml file (the task definition schema can be found here).
   The following is the Task Definition for the RCE Project task:
   

   <taskDefinition xmlns="http://schemas.microsoft.com/iis/media/v4/TM/TaskDefinition#"> <name>RCE Project Task</name> <id>7F8A89DA-1DF9-409A-9869-A5CDCA017998</id> <properties namespace="http://schemas.microsoft.com/RCE/V1#" prefix="rce"> <property name="preset" value="" /> </properties> <description xml:lang="en">Invokes Expression Encoder 4 to produce a video based on the edits metadata defined on an RCE Project File</description> <inputDirectory></inputDirectory> <outputDirectory>RCEProjectTaskOutput</outputDirectory> <taskCode> <type architecture="x86" >RCE.TransformManager.Tasks.RCEProjectTask, RCE.TransformManager.Tasks, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null</type> </taskCode> </taskDefinition>

   As you can see, it defines a property called preset, which is intended to be used to provide the Expression Encoder 4 preset.

   - The input directory points to the directory where the source videos are located (which is the same directory used on the RCE File System Data Provider configuration)

   - The output directory will be later used by an XCopy task defined on the Job Template that will copy the resulting files back to the source videos directory (making the resulting video available to the RCE)

3. Register the task with the IIS Transform Manager. A great tutorial on how to do custom task registration can be found here, but it basically involves two steps:

   - Copy the custom task assembly to C:\Program Files\IIS\Transform Manager (on a x86 computer) or to to C:\Program Files (x86)\IIS\Transform Manager (on a x64 computer)

   - Copy the custom task definition XML file to the %ProgramData%\Microsoft\IIS\Transform Manager\Configuration\Task Definitions directory

Once you have your Transform Manager task ready and configured, launch the Internet Information Services and configure the IIS Transform Manager.

First, stop and start the IIS Transform Manager service so it can detect the new task, then follow these steps to create a job template.

1. Create a New Job Template (Transform Manager > Job Templates > New) and fill the Name field.
2. Click Add to launch the Add Task dialog.
3. Select the RCE Project Task and the XCopy Task and click OK.
4. Make sure that the task definitions list shows the RCE Project task on top of the XCopy task (use the Move Up / Move Down buttons to adjust it)
5. Select the RCE Project Task and click Edit.
6. Fill the input directory field and the preset property. Click OK to save.

   Note: I’m using one of the predefined presets of EE4 (VC1-ScreenEncoding VBR for Silverlight), but you can use any you prefer.

7. Select the XCopy task and click Edit.
8. Fill the fields as described below. Click OK to save.
   • Input Directory: RCEProjectTaskOutput
   • Arguments: RCEProjectTaskOutput\* "d:\media\demo\videos" /E /Y /INote: (replace d:\media\demo\videos with the input directory you defined on the RCE Project Task)

      

9. Click OK to save the job template.

Now it is time to add the Watch Folder. For the sake of simplicity, in the PoC, I will use the folder where the RCE exports the project output. This folder is located at

RCE.Web\encode\Queue.

1. Create a new watch folder (Transform Manager > Watch Folders > New)
2. Fill the watch folder settings:
   • Name. The name of the folder
   • Physical Path. The watch folder path (%RCEDirectory%/RCE.Web\encode\Queue)
   • File Filter. Use *.jobreq here, which is the extension the RCE Export operation output.
   • Job Template. Select the RCE Job Template
3. Click OK to save the watch folder.
4. Finally, select the watch folder and click Enable and then click Start. This will leave the watch folder ready to use.

Great!. Everything is cooked. Let’s see how it tastes.

1. Launch the RCE and perform a couple of edits. I’ve four videos on my library and I created an edit of around 1 minutes and 56 seconds using two of those videos.
2. Select the Output Tab, and click Export to export the RCE project.
3. Open the IIS and go to the Job Monitor option of the IIS Transform Manager. You will see that your job is running!!
4. Once the encoding is completed, the second task of the job is going to be executed, copying the new file on the folder you configured.
5. Refresh the RCE (press F5), and you’ll see a new video on the library, with the exact same duration of the edit you created.

The End

We just proved that the RCE and the IIS Transform Manager can easily work together. The IIS Transform Manager’s extensibility allowed us to create a simple task to integrate the RCE export process with it and to output a new encoded video that represents the RCE edits. And this is just the beginning…

Hope this helps,

Happy Transforming!

THE CODE AND THIS POSTING IS PROVIDED "AS IS" WITH NO WARRANTIES, AND CONFERS NO RIGHTS.

Yesterday, I exchanged some emails with my friend Chandler from iStreamPlanet. He was having some trouble with the Smooth Streaming Media Element (SSME). He described the issue as:

• When I set the position on the Smooth Streaming Media Element, the displayed frame is not updated.
• I can only get the frame displayed to update when playback is resumed.

The default behavior of the SSME doesn’t allow to seek inside fragment (chunks) boundaries, so if you seek to any position in within the same 2-seconds chunk of video, you always get the same frame displayed. The change to enable this is really simple, but is one of those hidden gems of the SSME.

The Smooth Streaming Media Element can be configured using an XML file in which you can set a wide range of settings. One of these settings is actually the one to enable accurate seeks on the SSME.

4 Steps to success

1. In your Silverlight project, add an Xml file and named it config.xml. You add the file to the Silverlight project, because it needs to be part of the XAP package.
2. Copy the following content into the file:
   

   <?xml version=”1.0″ encoding=”utf-8″ ?> <LiveSmoothStreamingSettings>   <BufferingEngineSettings ForceAccurateSeeks=”true”/> </LiveSmoothStreamingSettings>

3. Save the file.
4. Add the following attribute in XAML for the SSME.
   

   e.g., <XYZ:SmoohtStreamingMediaElement ConfigPath=”config.xml”>

   Alternatively, you can set this programatically:

   this.ConfigPath = “Config.xml”;

Hope this helps.

Enjoy!

Weeks ago Microsoft published the Silverlight Rough Cut Editor (RCE), an application we created with Microsoft and that was used for the Vancouver 2010 Winter Olympics.

One of the main features used during the Olympics was the ability to generate Composite Stream Manifests (CSM) based on projects the editors created using the Rough Cut Editor.

Today, we are happy to announce that the Composite Stream Manifest generator code was just published on the RCE site on Code Gallery: http://code.msdn.microsoft.com/RCE.

Once you download the source code package, you will find the following folder structure:

The ManifestGenerator folder contains the source code for the CSM generator and a WCF service ready to consume which converts your RCE projects into Composite Stream Manifests.

The WCF service contains two operations:

[ServiceContract]
public interface IManifestGeneratorService
{
    [OperationContract]
    string GetSubClipManifest(Uri manifestUri, double markIn, double markOut);

    [OperationContract]
    string GetManifest(string projectXml, string pbpDataStreamName, string adsDataStreamName);
}

• The GetSubClipManifest operation will generate a CSM of one clip. This operation is useful when you want to quickly generate a CSM based on a Mark In and Mark Out you set to a clip. The parameters expected are the clip manifest Uri and the mark in and mark out values (in ticks).
• The GetManifest operation will generate a CSM based on an RCE project. This operation will allow you to convert all the cuts you made on the RCE into a manifest that can be played by the Smooth Streaming Media Element. The parameters expected are the RCE project xml and the desired names for the ads and markers text streams.

The package also contains a test page that will allow you to test the service without having to deal with the WCF service. Thanks to JPG for the UI.

I hope this helps you to generate Composite Stream manifests. If you have questions, suggestions or comments, please visit us on the RCE forums.

Happy editing!.

Ez.

On April 21th, Microsoft LATAM hosted a virtual event with 60 technical sessions about products, technologies and services being launched.

Julian and I had the opportunity of being speakers at the event, where we talked about the Managed Extensibility Framework (MEF) and we explored the capabilities of this framework. We went through the basic principles of MEF and we also showed how it can be used to create more decoupled, testable and maintainable applications.

If you want to see the video (is in Spanish) please visit this link.

More Information about MEF

If you want to dig deeper on MEF, I recommend you to read Glenn Block’s blog.

Enjoy

One of the greatest features added on the Beta 2 version of the IIS Smooth Streaming Player Development Kit (SSPDK) is the support for Composite Stream Manifests for Rough Cut Editing. This a powerful feature which I really recommend looking at, and if you want to learn the basics of the CSMs you must take a look at the following posts:

• Composite Manifest Support for Rough Cut Editing scenarios in SSME by Vishal Sood
• New Composite Manifest support for building Rough Cut Editing (RCE) scenarios with Smooth Streaming by John Deutscher

I’ve been working with CSMs for three months now, so in this post I would like to share with you the lessons I’ve learnt during the process of creation and usage of the CSMs.

There are a few common mistakes and issues you might face during that process, so I hope this post will be helpful for the community. 

Configure IIS to serve .CSM files

In order to do that, you have to add a mime type entry on IIS for the .CSM extension on every IIS server that is serving up the .csm files. The mime type for the .csm must be “text/xml”. You can do this on the IIS Manager. Also you can achieve the same by editing the applicationHost.config and adding the following line:

 <mimeMap fileExtension=”.csm” mimeType=”text/xml” />

“Error encountered on HEAD request to manifest uri <your manifest> for <position> clip in RCE manifest”

This will likely be the first issue you will encounter after trying to use a CSM. When using a CSM the Smooth Streaming Media Element (SSME) attempts to do a HEAD request on the manifest for each clip to make sure that the content hasn’t been moved (and if it has, it will used the new URL on the response).

There are two changes you have to make in order to fix this issue.

The first one is related to an existing known-issue on the applicationHost.config file of IIS. This server bug prevents the On-Demand smooth streaming handler from responding to HEAD request. To fix this go to the Smooth Streaming Readme page and check the Known Issues section, specifically the “Configuring the SmoothHandler handler mapping to process HTTP Head requests” item.

The second change must be done on the clientaccesspolicy.xml file, essentially to indicate that HEAD requests are allowed. To fix this make sure that your clientaccesspolicy.xml file includes http-methods=”*”or http-methods=”GET,HEAD,POST”:

<?xml version=”1.0″ encoding=”utf-8″?>
<access-policy>
  <cross-domain-access>
    <policy>
      <allow-from http-methods=”*” http-request-headers=”*”>     
        <domain uri=”*”/>
      </allow-from>     
      <grant-to>     
        <resource path=”/” include-subpaths=”true”/>
      </grant-to>     
    </policy>
  </cross-domain-access>
</access-policy>

“Caught exception trying to parse main manifest: V2 Manifest: Audio stream requires CodecPrivateData attribute”

This is because the CSM contains a clip that is referring a V1 Manifest, which is not a valid source for a CSM.

“Caught exception trying to parse main manifest: First video (audio) chunk in clip <position> [start time = <start time>, duration = <duration>] does not contain clip start position <clipStartPosition>”

This message indicates that the first chunk time + the first chunk duration of the reported stream is smaller or larger that the clip’s begin position. Therefore the first chunk time + the first chunk duration of the stream must contain the clip’s begin position.

“Caught exception trying to parse main manifest: Last video (audio) chunk in clip <position> [start time = <start time>, duration = <duration>] does not contain clip end position <clipEndPosition>”

This message indicates that the last chunk time + the last chunk duration of the reported stream is smaller or larger that the clip’s end position. Therefore the last chunk time + the last chunk duration of the stream must contain the clip’s end position.

Different Audio encoding settings in the CSM clips

If you have clips with different audio encoding settings, then the playback will suddenly stop. Due to a limitation on Silverlight, the audio settings have to be the same. The Silverlight pipeline is not able to handle audio property changes on the fly. So make sure that the audio of the clips are being encoded at same bit rate.

Sparse stream data within the clip

This will likely not cause any issue, but as today having sparse stream data within a clip is not supported I decided to include it on this list.

As you see, there are a couple of things to have in mind when creating and using composite stream manifests. I hope this post encourages you to use this amazing feature.

Happy streaming!

Many people have been asking me how to manage publishing point programmatically on IIS Media Services 3.0 (instead of the 2.0 bits, as I explained in this post)

So, I started to dig and I came up with the following code:

// Live Streaming Section Path
const string LiveStreamingSectionPath = “system.webServer/media/liveStreaming“;
 
// Change this settings with your values
 
// Site name
string siteName = “Default Web Site“;
// Application name
string applicationName = “/SmoothStreaming“;
// Publishing point filename
string fileName = “LiveSmooth.isml“;
 
ServerManager serverManager = new ServerManager();
 
// Gets the site from IIS
Site site = serverManager.Sites[siteName];
 
// Gets the application from IIS
Application application = site.Applications[applicationName];
 
// Gets the LiveStreamingSection from the site configuration 
ConfigurationSection section = site.GetWebConfiguration().GetSection(LiveStreamingSectionPath);
 
// Gets the ConfigurationMethodInstance to get the available publishing points
ConfigurationMethodInstance instance = section.Methods["GetPublishingPoints"].CreateInstance();
 
// Sets the input parameters of the GetPublishingPoints method
instance.Input["siteName"] = site.Name;
instance.Input["virtualPath"] = applicationName;
 
// Executes the method
instance.Execute();
 
// Gets the PublishingPointCollection type.
Type type = Type.GetType("Microsoft.Web.Management.Media.LiveStreaming.PublishingPointCollection, Microsoft.Web.Management.Media.LiveStreaming“);
 
// Gets the PublishingPointCollection associated with the method output
ConfigurationElement collection = instance.Output.GetCollection(type);
 
// Gets an item from the collection using the Publishing Point fileName as parameter. 
// The item is of type PublishingPoint.
object pubPoint = collection.GetType()
                            .InvokeMember("Item“,
                                          BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance,
                                          null, collection, new object[] { fileName }, null);
 
// Invokes the desired method of the Publishing Point. 
// In this case we are calling the Start method (others supported functions are “Shutdown” and “Stop”)
pubPoint.GetType().InvokeMember("Start“,
                                BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod,
                                null, pubPoint, null);

Remember that in order to use the previous code, you must have references to the following assemblies:

• Microsoft.Web.Administration.dll (can be found at IIS Directory %windir%\System32\inetSrv)
• Microsoft.Web.Management.Media.LiveStreaming.dll (can be found in the GAC after installing the Live Smooth Streaming bits)

Hope this helps.

Happy streaming!

Hey Folks! Time ago I blogged about how to add the Slow Motion capability to your Smooth Streaming player by using the Smooth Streaming Media Element published by the IIS team.

Now it’s time to share with you how to provide the rewind and fast forward options to enable a real rich video experience.

Again, adding support for these features is easy, and if you understood what we did for providing the Slow Motion experience, then the following will be a piece of cake.

For rewind, the trick is getting all the playback rates under 0.0 and for fast forward, all the playback rates above 1.0.

Show me the code!

Rewind

/// <summary>
/// Toogles the PlaybackRate of the Smooth Streaming Media Element.
/// Uses the PlaybackRates under 0.0 to support Rewind.
/// </summary>
public void OnRewind()
{
    // PlaybackRate index to set on the SSME.
    int newPlaybackRateIndex = 0;
    // Verify the state of the SmoothPlayer
    if (this.SmoothPlayer.CurrentState == SmoothStreamingMediaElementState.Paused
        || this.SmoothPlayer.CurrentState == SmoothStreamingMediaElementState.Playing
        || this.SmoothPlayer.CurrentState == SmoothStreamingMediaElementState.Buffering)
    {
        // Get the current PlaybackRate of the SSME
        double playbackRate = this.PlaybackRate;
        // The first time we get the Rewind PlaybackRates from
        // the SSME supported PlayBackRates. Rewind PlaybackRates 
        // are under 0.0
        if (this.rewindPlaybackRates == null)
        {
            this.rewindPlaybackRates = new List<double>();
            IList<double> supportedPlaybackRates = this.SmoothPlayer.SupportedPlaybackRates;
            for (int i = 0; i < supportedPlaybackRates.Count - 1; i++)
            {
                if (supportedPlaybackRates[i] < 0.0)
                {
                    this.rewindPlaybackRates.Add(supportedPlaybackRates[i]);
                }
            }
            this.rewindPlaybackRates.Add(1.0);
        }
        // Verify if the current PlaybackRate is within the 
        // allowables values. Get the index of the new 
        // PlaybackRate to set.
        if (playbackRate >= 0.0)
        {
            newPlaybackRateIndex = 0;
        }
        else
        {
            for (int i = 0; i < this.rewindPlaybackRates.Count - 1; i++)
            {
                if (this.rewindPlaybackRates[i] == playbackRate)
                {
                    newPlaybackRateIndex = (i + 1) % this.rewindPlaybackRates.Count;
                    break;
                }
            }
        }
        this.SmoothPlayer.SetPlaybackRate(this.rewindPlaybackRates[newPlaybackRateIndex]);
    }
}

Fast Forward

/// <summary>
/// Toogles the PlaybackRate of the Smooth Streaming Media Element.
/// Uses the PlaybackRates greather than 1.0 to support Fast forward.
/// </summary>
public void OnFastForward()
{
    // PlaybackRate index to set on the SSME.
    int newPlaybackRateIndex = 0;
    // Verify the state of the SmoothPlayer
    if (this.SmoothPlayer.CurrentState == SmoothStreamingMediaElementState.Paused
        || this.SmoothPlayer.CurrentState == SmoothStreamingMediaElementState.Playing
        || this.SmoothPlayer.CurrentState == SmoothStreamingMediaElementState.Buffering)
    {
        // Get the current PlaybackRate of the SSME
        double playbackRate = this.PlaybackRate;
        // The first time we get the Fast Forward PlaybackRates from
        // the SSME supported PlayBackRates. Fast Forward PlaybackRates 
        // are above 1.0
        if (this.fastForwardPlaybackRates == null)
        {
            this.fastForwardPlaybackRates = new List<double>();
            IList<double> supportedPlaybackRates = this.SmoothPlayer.SupportedPlaybackRates;
            for (int i = 0; i < supportedPlaybackRates.Count - 1; i++)
            {
                if (supportedPlaybackRates[i] > 1.0)
                {
                    this.fastForwardPlaybackRates.Add(supportedPlaybackRates[i]);
                }
            }
            this.fastForwardPlaybackRates.Add(1.0);
        }
        // Verify if the current PlaybackRate is within the 
        // allowables values. Get the index of the new 
        // PlaybackRate to set.
        if (playbackRate <= 1.0)
        {
            newPlaybackRateIndex = 0;
        }
        else
        {
            for (int i = 0; i < this.fastForwardPlaybackRates.Count - 1; i++)
            {
                if (this.fastForwardPlaybackRates[i] == playbackRate)
                {
                    newPlaybackRateIndex = (i + 1) % this.fastForwardPlaybackRates.Count;
                    break;
                }
            }
        }
        this.SmoothPlayer.SetPlaybackRate(this.fastForwardPlaybackRates[newPlaybackRateIndex]);
    }
}

For more information about the SSME Beta 2 release, check Vishal’s post : IIS Smooth Streaming Player Development Kit Beta 2 released

Enjoy it!

The week started with really great news from the IIS Team. The IIS Media Services 3.0 streaming was released. Among others features the release includes the RTW bits of Live Smooth Streaming.

Also, in the efforts to bring the Smooth Streaming experience to everyone the IIS team published the IIS Smooth Streaming Player Development Kit 1.0 – Beta 1 which is intended to aid the development of rich Smooth Streaming experiences.

Bunch of posts to review if you are not aware of the new releases:

• IIS Media Services 3.0, including IIS Live Smooth Streaming, has been released – Chris Knowlton
• RTW of Live Smooth Streaming is now… Live. – John Bocharov
• IIS Media Services 3.0 and Player SDK released! – Alex Zambelli
• IIS Smooth Streaming Player Development Kit 1.0 – Beta 1 Released – Vishal Sood

I’m very excited with this release, as we have been using the Smooth Streaming Media Element almost from its beginning mainly for the work we did for the NBC Sunday Night Football event. (see here & here). I will start sharing with you how to take advantage of the SSME.

In this post I will show you how easy is to bring an Slow Motion experience using the SSME. Vishal blogged a great SSME getting started guide that I encourage you  to review before digging into the details of this post.

Adding support for Slow Motion to your Smooth Player is really easy, and basically what you have to do is getting the playback rates between 0.0 and 1.0, and move across them every time you click your Slow Motion button on the player.

Below you will find a code snippet ready to be used that will help you to implement the Slow Motion logic.

private List<double> slowMotionPlaybackRates;
/// <summary>
/// Toogles the PlaybackRate of the Smooth Streaming Media Element.
/// Uses the PlaybackRates between 0.0 and 1.0 to support Slow Motion.
/// </summary>
public void OnSlowMotion()
{
    // PlaybackRate index to set on the SSME.
    int newPlaybackRateIndex = 0;
    // Verify the state of the SmoothPlayer
    if (this.SmoothPlayer.CurrentState == MediaElementState.Paused
        || this.SmoothPlayer.CurrentState == MediaElementState.Playing
        || this.SmoothPlayer.CurrentState == MediaElementState.Buffering)
    {
        // Get the current PlaybackRate of the SSME
        double playbackRate = this.SmoothPlayer.PlaybackRate;
        // The first time we get the SlowMotion PlaybackRates from
        // the SSME supported PlayBackRates. SlowMotion PlaybackRates 
        // are between 0.0 and 1.0.
        if (this.slowMotionPlaybackRates == null)
        {
            this.slowMotionPlaybackRates = new List<double>();
            IList<double> supportedPlaybackRates = this.SmoothPlayer.SupportedPlaybackRates;
            for (int i = 0; i < supportedPlaybackRates.Count; i++)
            {
                if (supportedPlaybackRates[i] > 0.0 && supportedPlaybackRates[i] < 1.0)
                {
                    this.slowMotionPlaybackRates.Add(supportedPlaybackRates[i]);
                }
            }
            this.slowMotionPlaybackRates.Add(1.0);
        }
        // Verify if the current PlaybackRate is within the 
        // allowables values. Get the index of the new 
        // PlaybackRate to set.
        if (playbackRate <= 0.0 || playbackRate >= 1.0)
        {
            newPlaybackRateIndex = 0;
        }
        else
        {
            for (int i = 0; i < this.slowMotionPlaybackRates.Count; i++)
            {
                if (this.slowMotionPlaybackRates[i] == playbackRate)
                {
                    newPlaybackRateIndex = (i + 1) % this.slowMotionPlaybackRates.Count;
                    break;
                }
            }
        }
        this.SmoothPlayer.SetPlaybackRate(this.slowMotionPlaybackRates[newPlaybackRateIndex]);
    }
}

Hope you find the code snippet useful. Stay tuned!, new posts are coming.

PS: If you face any issue with the Smooth Streaming Development Kit or if you just want to provide feedback to the IIS team, please use this thread.

This post announces an event being held at Buenos Aires, Argentina.

On September 26th, a new CodeCamp will take place at Buenos Aires. This year, I will join my teammate Diego Poza and together we will talk about how to develop composite applications for WPF & Silverlight using PRISM. Our presentation starts at 4:15 PM and will last 1 hour.

During the presentation we will go over PRISM Core Concepts and show a real-world implementation. Don’t miss the surprises at the end of the session.

On a related topic, Southworks is one of the sponsors of the event and several other southies will be presenting as well:

• Matias and Johnny will be presenting about Mega Datacenters with Windows Azure. Johnny will also join Zaiden and together they will present about VS 2010 and C# 4.0
• Martin Salias will be in functional mode explaining the main advantages of F#.
• Nico Paez will be talking about open source tools for .NET
• Beto, our IT Pro, will be off the charts. He will present in four sessions talking about Hyper-V, Windows Server 2008 R2 and SSME (SCOM, SCVMM, SCDPM).

Are you going to miss this amazing event? Register Now!

Where: Universidad de Palermo, Mario Bravo 1050, Buenos Aires

Time: From 9:30 AM to 19:00 PM

See you in the event and in the Southworks booth.

Last week, we recorded with Matias Woloski an screencast for the Windows 7×7 campaign (Alberto Ortega blogged about the campaign), showing how to take advantage of some of the new features of Windows 7 in a Windows Presentation Foundation application.

During the screencast we showed how the user experience can be enhanced by using the new capabilities of the Windows 7 Taskbar.

Thanks to Damian Schenkelman who helped us with the application.

Resources

• Screencast (in Spanish)
• Code
• Windows 7 Screencast – Taskbar, OverlayImage, ProgressBar, Thumbnails
• Developing applications with WPF and Windows 7 (Part I) 

Enjoy!