What is dynamic packing?

Before talking about dynamic packing, we have to mention what’s the traditional way of doing things. If you want to delivery both Http Live Streaming and Smooth Streaming, you have to store both of them. Therefore, you stream HLS content to iOS devices and Smooth Streaming content to Windows 8 for instance. However, by using dynamic packing feature in WAMS, You only need to store a Mp4 file in your storage, and we dynamically packaging Mp4 file into HLS or Smooth Streaming based on your client request. If it needs HLS stream, we will package Mp4 into HLS on the fly, and serve out to your client. In this case, you no longer need to store a copy of smooth streaming and HLS, hence, we help you save storage cost by half at least. This diagram below demonstrates what I just described:

How dynamic packaging works in WAMS

Pre-requisites

a. Besides of having a media services account, you need to request for at least one On-Demand Streaming Reserved Unit. You could use portal and click on Scale tab. Pricing detail please refers here.

Noted if you don’t have any on-demand streaming reserved unit, you will still be able to access our origin server. However, dynamic packaging feature won’t be unable.  You could still compose Smooth Streaming and HLS URLs, but you won’t get back any content by accessing them.

b. Here is a sample WMV file and you could download here.
c. This is the finished project if you find the following tutorial hard to follow.

1. Open Visual Studio 2012 and create a console application.
2. Add in WindowsAzure.mediaservices through Nuget in your reference folder.
3. Add in the following code in class Program. You could retrieve your account key and account name from portal. SingleInputFilePath is where you store the source file. And the outputPath is where we will place the file which contains the final streaming URLs information.

private static string accKey = "YOUR_ACCOUNT_KEY";
private static string accName = "YOUR_ACCOUNT_NAME";

private static CloudMediaContext context;
private static string singleInputFilePath = Path.GetFullPath(@"C:\tr\azure.wmv");
private static string outputPath = Path.GetFullPath(@"C:\tr");

4. Add in the following methods to upload asset and track your asset upload progress:

private static string CreateAssetAndUploadFile(CloudMediaContext context)
{
    var assetName = Path.GetFileNameWithoutExtension(singleInputFilePath);
    var inputAsset = context.Assets.Create(assetName, AssetCreationOptions.None);
    var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(singleInputFilePath));
    assetFile.UploadProgressChanged += new EventHandler<UploadProgressChangedEventArgs>(assetFile_UploadProgressChanged);
    assetFile.Upload(singleInputFilePath);
    return inputAsset.Id;
}

        static void assetFile_UploadProgressChanged(object sender, UploadProgressChangedEventArgs e)
        {
            Console.WriteLine(string.Format("{0}   Progress: {1:0}   Time: {2}", ((IAssetFile)sender).Name, e.Progress, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));
        }

5. Adding encoding method which transcode our WMV input file into Mp4. Here are various H.264 encoding presents that are available in Windows Azure Media Encoder.

private static IJob EncodeToMp4(CloudMediaContext context, string inputAssetId){
    var inputAsset = context.Assets.Where(a => a.Id == inputAssetId).FirstOrDefault();
    if (inputAsset == null) throw new ArgumentException("Could not find assetId: " + inputAssetId);
    var encodingPreset = "H264 Adaptive Bitrate MP4 Set SD 16x9";
    IJob job = context.Jobs.Create("Encoding " + inputAsset.Name + " to " + encodingPreset);
    IMediaProcessor latestWameMediaProcessor = (from p in context.MediaProcessors where p.Name == "Windows Azure Media Encoder" select p).ToList().OrderBy(wame => new Version(wame.Version)).LastOrDefault();
    ITask encodeTask = job.Tasks.AddNew("Encoding", latestWameMediaProcessor, encodingPreset, TaskOptions.None);
    encodeTask.InputAssets.Add(inputAsset);
    encodeTask.OutputAssets.AddNew(inputAsset.Name + " as " + encodingPreset, AssetCreationOptions.None);

    job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);
    job.Submit();
    job.GetExecutionProgressTask(CancellationToken.None).Wait();

    return job;
}

static void JobStateChanged(object sender, JobStateChangedEventArgs e)
{
    Console.WriteLine(string.Format("{0}\n  State: {1}\n  Time: {2}\n\n",((IJob)sender).Name, e.CurrentState, DateTime.UtcNow.ToString(@"yyyy_M_d__hh_mm_ss")));
}

6. The following steps are different from the traditional way of packing asset. You will create locator for your Mp4 and just by appending either /manifest (for Smooth Streaming) or /manifest(format=m3u8-aapl), we will dynamically packaging your media assets into Smooth Streaming or HLS based on your URL request.

private static string GetDynamicStreamingUrl(CloudMediaContext context, string outputAssetId, LocatorType type){
    var daysForWhichStreamingUrlIsActive = 365;
    var outputAsset = context.Assets.Where(a => a.Id == outputAssetId).FirstOrDefault();
    var accessPolicy = context.AccessPolicies.Create(outputAsset.Name,TimeSpan.FromDays(daysForWhichStreamingUrlIsActive),AccessPermissions.Read | AccessPermissions.List);
    var assetFiles = outputAsset.AssetFiles.ToList();
    if (type == LocatorType.OnDemandOrigin){
    var assetFile = assetFiles.Where(f => f.Name.ToLower().EndsWith(".ism")).FirstOrDefault();
    if (assetFile != null){
    var locator = context.Locators.CreateLocator(LocatorType.OnDemandOrigin, outputAsset, accessPolicy);
    Uri smoothUri = new Uri(locator.Path + assetFile.Name + "/manifest");
    return smoothUri.ToString();
    }
  }
    if (type == LocatorType.Sas){
    var mp4Files = assetFiles.Where(f => f.Name.ToLower().EndsWith(".mp4")).ToList();
    var assetFile = mp4Files.OrderBy(f => f.ContentFileSize).LastOrDefault(); //Get Largest File
    if (assetFile != null)
    {
    var locator = context.Locators.CreateLocator(LocatorType.Sas, outputAsset, accessPolicy);
    var mp4Uri = new UriBuilder(locator.Path);
    mp4Uri.Path += "/" + assetFile.Name;
    return mp4Uri.ToString();
    }
}

return string.Empty;
        }
}

7. Let’s add in a utility method for writing locator URL into the file.

static void WriteToFile(string outFilePath, string fileContent)
{
    StreamWriter sr = File.CreateText(outFilePath);
    sr.Write(fileContent);
    sr.Close();
}

The reason why we want to write locator URLs into a file is because in portal, you will only see the Mp4 SAS URL, which points to the storage. You won’t be able to grab the locator URL unless you write them down.
8. Adding the following lines into main program in order to create the following workflow: upload WMV ->  encode into MP4 -> create locator -> write locator URL for both Smooth Streaming and HLS into a file.

static void Main(string[] args)
 {
    context = new CloudMediaContext(accName, accKey);
    string inputAssetId = CreateAssetAndUploadFile(context);
    IJob job = EncodeToMp4(context, inputAssetId);
    var mp4Asset = job.OutputMediaAssets.FirstOrDefault();
    string mp4StreamingUrl = GetDynamicStreamingUrl(context, mp4Asset.Id, LocatorType.Sas);
    string smoothStreamingUrl = GetDynamicStreamingUrl(context, mp4Asset.Id, LocatorType.OnDemandOrigin);
    string hlsStreamingUrl = smoothStreamingUrl + "(format=m3u8-aapl)";
    string content = "\n Mp4 Url:    \n" + mp4StreamingUrl + "\n Smooth Url: \n" + smoothStreamingUrl + "\n HLS Url:    \n" + hlsStreamingUrl;
    Console.WriteLine("\n Mp4 Url:    \n" + mp4StreamingUrl);
    Console.WriteLine("\n Smooth Url: \n" + smoothStreamingUrl);
    Console.WriteLine("\n HLS Url:    \n" + hlsStreamingUrl);

    string outFilePath = Path.GetFullPath(outputPath + @"\" + "StreamingUrl.txt");
    WriteToFile(outFilePath, content);
    Console.ReadKey();
    Console.ReadKey();
}

9. Now you could press F5 and run this program. This is a printscreen of my console.

10. I have uploaded the whole project here and feel free to try it out yourself!

Additional resources and questions:

• • Technical blog: Dynamic Packaging and Encoding and Streaming Reserved Units by Nick Drouin
• • Ch9 video: Introduction to dynamic packing by Nick Drouin

• Question: What are supported input format and output format? Is MP4 the only input?

• Answer: We support both Smooth Streaming format and Mp4 as input. And for output, we generate Smooth Streaming and HLS v4. Please noted that we dont support encrypted content as source files, neither Storage Encryption nor Common Encryption.

• Question: Could I use an existing Mp4 or Smooth Streaming file as input without encoding?

• Answer: Yes. You could upload existing adaptive bitrate sets and validate them using the Media Packager. Here is a MSDN tutorial on validating your existing asset. Please check it out if you have questions.

The post Demo – how to create HLS and Smooth Streaming assets using dynamic packaging appeared first on Mingfei Yan.

Technology wise, last year my team announced Windows Azure Media Service in NAB, that was a big milestone for us. Since our business grew stronger and this year our biggest news was the partnership announcement with NBC. You can find the original press release here: Microsoft Teams Up With NBC Sports Group to Deliver Compelling Sports Programming Across Digital Platforms Using Windows Azure.

I spent many hours walking around the booth and talking to the participants. There were three big exhibition halls and each of them was a double deck. No wonder this event could host more than 97,000 attendees and +1.500 exhibitors.

Let me try to summarize for you some of my take-away:

• “4K” is the buzz word of NAB 2013 and it gets really loud,
• 4K was everywhere throughout the show floors. 4K camera, 4K display, 4K interactive screen, etc. In the video, I was with my friend standing in front of a gigantic 4K TV screen with some car racing footage. It was as if the car was just in front of us. “I want one in my living room!” My friend whispered. then immediately said “Em, probably not”. No one knows whether 4K will be successfully commercialized, or it is just another false attempt like 3D TV. on the positive, I do see very interesting usage of 4K. In Canon’s booth, they had a live shooting session, and the Canon photographer, using 4K camera, explained that the client could easily print out any single frame of the 4K camera footage. With a 4k camera, a photographer can finish a shooting within 1 day, where it took 3 to 4 days with traditional hardware.
• Multi-screen delivery is a must
• I swung by many tech companies booths and most of them had a collection of devices displayed with video playback. It is clear to me that the content format doesn’t matter as long as it can be displayed on all devices. Here is a video of our partner Axinom, they were demoing a play back solution on multiple devices, including gesture-controlled Xbox video application.
• Cloud computing is still young 
• On day 1, I was having lunch and some people joined me, among them a director and a music producer. I shared with them my works on video solution with cloud computing. These guys never heard about cloud solution! We engaged in a very interesting discussion when the producer asked me about cloud post-production software. His question was basically the following ” does it mean that by pressing a button, I can encode video in the cloud?” I told him that’s absolutely a very valid scenario. After this conversation, I realized that the transition from traditional media hardware to the cloud may take some time, but this transition will be transparent to the end user. Traditional software companies who run on-premises transcoding business, could and would potentially offer cloud solution with no impact on the end user. The existing on-premises ecosystem could move onto cloud infrastructures and it will harvest the first movers advantage in an industry where no one wants to be left behind.

The overall NAB 2013 experience has been overwhelmingly good for me and I am really excited to be part of what will transform the broadcasting industry in the future, the paradigm shift to could computing!

This is a short video I put together to capture the vibe of the event.

The post My Experience of NAB Show 2013 appeared first on Mingfei Yan.

These are pricing details posted on official Windows Azure home page. Please read the official post first and if you still have questions, read this blog which is my best effort for explaining pricing. As said, if you choose to go through general media workflow (encoding your content and host them for streaming purpose), you will incur 4 types of costs.

1. Encoding GB Processed

Encode charges = Input File size + (Each output format size). For instance, I could load a video in WMV format with 2 GB, and after encoding into H.264, I get a output file of 2.5 GB by using Windows Azure Media Encoder. In that case my total encoding charges will be 4.5 GB of data. Price detail please see the table below and please contact winazinqr@microsoft.com for monthly data usage more than 100 TB. Pricing in this table may change over time and please refer to official page.

2. Encoding Reserved Units

The cost of encoding reserved unit is $99/month but your account will be charged on a daily basis using the highest number of Reserved Units that are provisioned in your account on that day. The daily rate is calculated by dividing $99 by 31. For example if you start with 3 Reserved Units but an hour later you go to 5 and then another hour later you drop to 2,  the charge will be based on 5 Reserved Units for that day.

With Reserved Units you get the benefit of parallelization of your tasks. As an example if you have 5 Reserved Units, then the service will run 5 of your tasks in parallel. As soon as one of the task finishes, the next one from your queue will get picked up for processing

If you do not have any reserved units then the wait time for a task to start processing may be several hours. If you have only reserved unit then the service will run one task at a time but will schedule the next one as soon as the current one finishes

In summary, the number of media tasks that will be processed in parallel will be equal to the number of encoding reserved units provisioned in your account at any given time. In Windows Azure portal, you could request for 5 Reserved Units max, but you could follow this post to request for more Reserved Units.

Question: By adding more encoding reserved units, will it speed up the encoding process? 

Answer: With Reserved Units, the time of encoding one single media file will not change. However, if you have multiple files, the total encoding time will be shortened as multiple files will be encoded in parallel.

3. Data storage Cost

Videos will be stored in Windows Azure Blob storage hence you will need to pay for normal storage cost. Please refer to Storage price for Windows Azure.

4. On-Demand Streaming Reserved Units

The cost of On-Demand Streaming Units is $199 each per month. For each reserved unit there is a minimum of 200 Mbps of bandwidth allocated. The SLA currently only applies when one is using 80% or less of available bandwidth. That said, in many cases customers will see significantly more bandwidth available per reserved unit. This is because each reserved unit is made up of 1 or more medium VM’s. Additional VM’s are added to ensure allocated bandwidth per reserved unit isn’t impacted when VM’s fail, are upgraded, etc.  When all VM’s are available, at lower # of reserved units there is significantly more excess network capacity available. As the # of reserved units is increased the excess network capacity drops off and levels out at 6-8% range.

Question: Could you still do streaming without purchasing a on-demand streaming reserved unit?

Answer: Yes. However, without a reserved unit, there is no SLA and streaming is done via a shared pool of resources for which there is no ability to control individual customers usage. So if one customer starts using lots of bandwidth (e.g. viewing of one of their videos goes viral) this will have an impact on all other customers. The shared pool is great for customers that just have limited streaming capabilities and aren’t in need of an SLA.

Question: How do I estimate # of on-demand streaming reserved unit I need?

Answer: For the most conservative estimate you can go directly with SLA limitations - i.e. total bandwidth is 160 Mbps * # of RU’s. To obtain an initial estimate you can take the # of concurrent customers * top bitrate that you are encoding video at. For most video business, I think it is always better to be conservative first and if you end up over provisioning, you could always reduce # of reserved unit.

Use of a CDN complicates this equation as the amount of bandwidth is now directly related to how customer requests are spread across content. This will be unique per each customer. Requests for content that has been recently served by the CDN will be served directly from the CDN’s cache versus request to a customer’s RU’s. To simplify initial determination of impact of CDN one can just estimate % of content that is long tail content (seldom watched so low likelihood of being in CDN cache) versus fat tail content (watched often so being highly likelihood of being in CDN cache). Then use this percentage to adjust down the # of RU’s required.

The post Windows Azure Media Services Pricing Details appeared first on Mingfei Yan.

If you still can’t find a clue, please bring your question to Windows Azure Media Services Forum and we will try our best to help you.

1. Create Asset

• You have to pass in an assetName for asset creation

Code in old API:

IAsset asset = mediaContext.Assets.Create(inputPath);

Code in current API:

var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
var asset = mediaContext.Assets.Create(assetName, assetCreationOptions);

The assetName here will show up in Windows Azure Media Services portal. So I guess you may have a more user-friendly name than mine to be able to manage your assets more efficiently.

Note: Assets.CreateEmptyAsset is deprecated.

• Adding concept of  IAssetFiles under IAsset. 

A new concept is introduced from the GA version. If you want to upload a video file (your AssetFile), you associate it with an asset. And upload your AssetFile to the portal, Here is the code:

static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
     var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
     var asset = mediaContext.Assets.Create(assetName, assetCreationOptions);
     var fileName = Path.GetFileName(singleFilePath);

     var assetFile = asset.AssetFiles.Create(fileName);
     assetFile.Upload(singleFilePath);
     Console.WriteLine("Done uploading of {0} using Upload()", assetFile.Name);

     return asset;
}

singleFilePath is where you put your files in.

Here is the whole process for getting your asset usable for a job (Credit to George Trifonov):

1. Create asset
2. Create file object(s) associated with asset
3. Create assess policy and locator so you can upload files from local filesystem in next step
4. Upload files from local disk to corresponding asset files objects
5. Select which file will a primary file within an asset

Code sample:

var asset = datacontext.Assets.Create(Guid.NewGuid().ToString(), options);
var policy = datacontext.AccessPolicies.Create("Write", TimeSpan.FromMinutes(5), AccessPermissions.Write);
var locator = datacontext.Locators.CreateSasLocator(asset, policy);
FileInfo info = new FileInfo(filePath);
var file = asset.AssetFiles.Create(info.Name);
file.UploadAsync(filePath, new BlobTransferClient()
{
    NumberOfConcurrentTransfers = 5,
    ParallelTransferThreadCount = 5
}, locator, CancellationToken.None).Wait();

file.IsPrimary = true;
file.Update();

2. MediaProcessor Naming change

There are naming string changes when you query Media Processor. In the old API, if you want to query “MP4 to Smooth Streams Task” media processor, you are probably doing this:

var theProcessor = from p in mediaContext.MediaProcessors
                    where p.Name == "MP4 to Smooth Streams Task"
                    select p;

IMediaProcessor processor = theProcessor.First();

But in the current APIs, this won’t work cause “MP4 to Smooth Streams Task” is no longer valid. You could query by following name and ID identifiers.

* We also add in more Task Preset and you could click on different Media Processor name above to check out more information on MSDN.

Here is the code if you want to “Convert Mp4 into Smooth Streaming“:

IJob job = mediaContext.Jobs.Create("My MP4 to Smooth job");

IMediaProcessor processor = mediaContext.MediaProcessors.Where(p => p.Name == "Windows Azure Media Packager").ToList().OrderBy(p => new Version(p.Version)).LastOrDefault();

string configuration = File.ReadAllText(configFilePath);

ITask task = job.Tasks.AddNew("My Mp4 to Smooth Task",
processor,
configuration,
Microsoft.WindowsAzure.MediaServices.Client.TaskOptions.None);

3. Upload/download progress for asset 

Assets don’t deal with uploading/downloading; only IAssetFiles do. If you are tracking the uploading/downloading progress of your video asset, you were using the following in old APIs:

mediaContext.Assets.OnUploadProgress

And you should change to the following:

assetFile.UploadProgressChanged
assetFile.DownloadProgressChanged

4. Using Windows Azure portal to diagnostic your problem

Since a few weeks ago, our Media Services on Windows Azure portal added a Job tab. And that’s where you could have a more detailed view of your job running progress. Meanwhile, you could also report to use the nid to let us help you find out the prob (by posting on our forum is the best way to reach out to us).

Job Progress Tab for Windows Azure Media Services

Lastly, please always refer to our updated MSDN documentation. You could find complete working sample with current SDKs. Good luck!

Update: you could find out more information here [MSDN forum link]. 

Changes since November 2012 (2.0.0.0) release

SDK Changes: The following changes describe fixes that are included in the December 2012 (Version 2.0.1.0) SDK.

Assets

• • IAsset.Locators.Count : This count is now correctly reported on new IAsset interfaces after all locators have been deleted.

IAssetFile

• • IAssetFile.ContentFileSize : This value is now properly set after an upload by IAssetFile.Upload(filepath).
• • IAssetFile.ContentFileSize : This property can now be set when creating an asset file. It was previously read-only.
• • IAssetFile.Upload(filepath) : Fixed an issue where this synchronous upload method was throwing the following error when uploading multiple files to the asset. The error was “Server failed to authenticate the request. Make sure the value of Authorization header is formed correctly including the signature.”
• • IAssetFile.UploadAsync() : Fixed an issue where no more than 5 files could be uploaded simultaneously.
• • IAssetFile.UploadProgressChanged : This event is now provided by the SDK.
• • IAssetFile.DownloadAsync(string, BlobTransferClient, ILocator, CancellationToken): This overload is now provided.
• • IAssetFile.DownloadAsync : Fixed an issue where no more that 5 files could be downloaded simultaneously.
• • IAssetFile.Delete : Fixed an issue where calling delete may throw an exception if no file was uploaded for the IAssetFile.

Jobs

• Jobs : Fixed an issue where chaining a “MP4 to Smooth Streams task” with a “PlayReady Protection Task” using a job template would not create any tasks at all.

Utility Classes

• • EncryptionUtils.GetCertificateFromStore() : This method no longer throws a null reference exception due to a failures finding the certificate based on certificate configuration issues.

General SDK Updates

• • Intellisense : Added missing Intellisense documentation for many types.
• • Microsoft.Practices.TransientFaultHandling.Core : Fixed an issue where the SDK still had a dependancy to an old version of this assembly.

Changes since June 2012 release

SDK Changes

The following changes require any code written against the June 2012 Preview release to be modified:

Assets

IAsset.Create(assetName) is the ONLY asset creation function.  IAsset.Create no longer uploads files as part of the method call.

The IAsset.Publish method and the AssetState.Publish enumeration value have been removed from the Services SDK.  Any code that relies on this value must be re-written.

FileInfo

This class has been removed and replaced by IAssetFile.  See below.

IAssetFiles

Replaces FileInfo and has a different behavior. To use it, instantiate the IAssetFiles object, followed by a file upload either using the Media Services SDK or the Windows Azure Storage SDK. The following IAssetFile.Upload overloads can be used:

•        IAssetFile.Upload(filePath).  Synchronous method.  Blocks the thread and is recommended only when uploading a single file.
•        IAssetFile.UploadAsync(filePath, blobTransferClient, locator, cancellationToken).  Asynchronous method.  This is the preferred upload mechanism. Known bug: using the cancellationToken will indeed cancel the upload; however, the cancellation state of the tasks can be any of a number of states. You must properly catch and handle exceptions.

Locators

The Origin-specific and Windows Azure CDN-specific versions have been removed. The SAS-specific context.Locators.CreateSasLocator(asset, accessPolicy) will be marked deprecated, or removed by GA. See the Locators section under New Functionality for updated behavior.

New Functionality

The following functionality is new in the November 2012 (2.0.0.0) release.

Deleting entities

IAsset, IAssetFile, ILocator, IAccessPolicy, IContentKey objects are now deleted at the object level, i.e. IObject.Delete(), instead of requiring a delete in the Collection, that is cloudMediaContext.ObjCollection.Delete(objInstance).

Locators

Locators must now be created using the CreateLocator method and use the LocatorType.SAS or LocatorType.OnDemandOrigin enum values as an argument for the specific type of locator you want to create.

New properties were added to Locators to make it easier to obtain usable URIs for your content. This redesign of Locators was meant to provide more flexibility for future third-party extensibility and increase ease-of-use for media client applications.

Asynchronous Method Support

Asynchronous support has been added to all methods.

The post Breaking changes for Windows Azure Media Services .NET SDK GA appeared first on Mingfei Yan.

VIDEO DELIVERY THROUGH BROWSER

Today, though people started to watch videos on different devices, video streaming on desktop through browser is the most popular way for video delivery. Most businesses built rich media applications with plugin such as Silverlight or Flash. For instance, Netflix web version is built using Silverlight and Hulu web version is using Flash. This plugin approach works fine for majority of operating systems and browsers.

However, if you want to target browser (IE) on Windows 8, things get a bit tricky. IE10 on Windows 8 desktop mode supports Silverlight and Flash. However, Silverlight doesn’t get supported on WINRT version of Windows 8. And for Metro Mode IE, only HTML5 and white-listed Flash site gets supported. Clearly, plugin is going away on tablet devices.

You may have questions at this point. “So how about using HTML5 to deliver content through modern browser?”

HTML5 only supports progressive download for most of browsers. If you want to implement Adaptive Streaming (e.g. Smooth Streaming), most of browser <video> doesn’t support. The only browser that supports Http Live Streaming is Safari on iOS (MAC or i-Devices). But this is just a propitiatory solution from Apple. Therefore, if you want to use Adaptive Streaming, which enables content protection and live, you would need to work with something else rather than HTML5. Lastly, don’t forget, only 2/3 of browsers support <video>. There are still users using IE 6/7/8 that won’t be able to watch your progressive content.

We provide the following SDK and framework as solution:

• • Smooth Streaming Client SDK 2.0
• • [Recommend] Microsoft Media Platform: Player Framework (MMPPF) for Silverlight
• • HTML5 (browser) Player Framework
• • Microsoft Smooth Streaming Plugin for OSMF (Smooth Streaming for Flash)

Microsoft’s open source media player framework – a component of the Microsoft Media Platform. It built on top of Smooth Streaming Client SDK (download link), enables developers to quickly deploy a robust, scalable, customizable media player for Smooth Streaming delivery. All the features supported by Client SDK are piped through MMPPF. However, with MMPPF you could enjoy some high level features, such as advertisement support (VAST, VPAID, VMAP) and UI control built in. MMPPF for Silverlight is quite well-establish and used by many major events, such as Beijing and Vancouver Olympics, Sunday Night Football on NBCSports, France Télévisions and etc.

Which one should I use?
We always recommend to use MMPPF – the player framework. It has player control built up for you and you could customize it upon your need. Smooth Streaming Client SDK is underneath Player framework. If you want to build a player from scratch, you could use Smooth Streaming Client SDK with higher flexibility, but of course a lot of more development efforts.

If you just need to deliver a simple video experience (progressive playback), you could use HTML5 (browser) player framework. We also provide a fall back experience: HTML5 video is configured the primary experience, Silverlight is configured as the next fallback, and a list of hyperlinks to the media is declared as the last fallback. You could check out a advanced fallback demo here.

Microsoft Smooth Streaming Plugin for OSMF (Smooth Streaming for Flash)

Download: http://www.microsoft.com/en-us/download/details.aspx?id=36057

Our team just realized a preview version of Microsoft Smooth Streaming Plugin for OSMF. Using it, you can add Smooth Streaming capabilities to existing Open Source Media Framework (OSMF) and Strobe Media Playback players.

This version of Smooth Streaming plugin includes the following capabilities and works with OSMF 2.0 APIs:

• • On-demand Smooth Streaming playback (Play, Pause, Seek, Stop)
• • Support for video codecs – H.264
• • Support for Audio codecs – AAC
• • Multiple audio language switching with OSMF built-in APIs
• • Max playback quality selection with OSMF built-in APIs
• You could read the announcement blog post and Two Worlds Collide: Smooth Streaming Meets Flash Player by Streaming Media.

Printscreen of Smooth Streaming OSMF plugin for strobe player

VIDEO DELIVERY FOR IOS DEVICES

We provide two different framework for delivering adaptive streaming content onto iOS devices.

• • iOS azure media player framework – HLS support
• • iOS porting kit for Smooth Streaming w/ PlayReady

iOS azure media player framework – Open Source

Github: https://github.com/WindowsAzure/azure-media-player-framework

Here is a short introduction of this media player framework:

What’s this framework for?

This framework enables developers to build native video application on iOS platform, which could consume secure HLS (Http live Streaming) content from Windows Azure Media Services. Mainly,this framework made easy for developers to integrate client-side advertisements. In the future we will also support various advertisement standards, such as VAST 3.0 and VMAP 1.0.

I have very detailed write up about this framework in another blog, please read “Announcing Windows Azure Media Player Framework Preview for iOS“ if you are interested.

Printscreen for Azure Media Player framework for IOS

iOS porting kit for Smooth Streaming

As I will introduce in the next section (Video delivery for any devices), we developed a porting kit for playing back Smooth Streaming onto any device. Since iOS devices are popular, we further implement this porting kit for iOS system. Therefore, for anyone who uses this porting kit, you will need to pay for Final Product License. Please email sspkinfo@microsoft.com for accessing the porting kit.
Note: according to Apple’s HLS guidence,

If your app delivers video over cellular networks, and the video exceeds either 10 minutes duration or 5 MB of data in a five minute period, you are required to use HTTP Live Streaming. (Progressive download may be used for smaller clips.).

Hence, we came out with another framework for you to build application that consume HLS with advertisement.

VIDEO DELIVERY FOR ANY DEVICES

- [Recommend] Smooth Streaming Porting Kit 

We can’t possibly implement Smooth Streaming Client for any devices. Thus, we abstract Smooth Streaming Specific aspects (Container parsing, heuristics and etc) as Smooth Streaming porting kit. And we add a few interfaces to “communicate” with a specific device. Below is the architecture of Smooth Streaming Porting Kit:

Smooth Streaming Porting Kit

As showed in the diagram above, there are four interfaces here:

• Hardware Abstraction Layer (HAL): Programming interfaces for interaction with hardware A/V decoders (decoding, rendering). If Roku implements this, it will need to write HAL in their own language for communicating to its hardware layer to decode and render video. And then Roku hooks HAL up with porting kit through HAL interface.

• Platform Abstraction Layer (PAL): Programming interfaces for interaction with the operating system (threads, sockets). Similarly, Roku would need to implement PAL in their language for talking to its specific operating system (Linux in this case). And Roku hooks PAL up through PAL interface.

• • DRM Interface: we provide DRM interface that you could write code to hook up with any DRM solution. For instance, Microsoft PlayReady team ships porting kit for any device. If you want to use PlayReady content protection, you will then write code to “glue” our DRM interface with your implementation of PlayReady porting kit.
• • Application Interface: you could build your application on top of Application Interface. If you pass media source in Smooth Streaming format, your device will be able to understand and your application will contain heuristics.
• Is this FREE?
• The answer is no. This porting kit is the only client SDK we provide that has a license fee. And there are two types of licenses involved.
• Interim Product License (IPL): who ports the kit pays this IPL with $50,000 one time fee. For example, if Samsung TV wants to enable Smooth Streaming on his own platform and Samsung hired a 3rd-party company to do it. The 3rd party company needs to pay for IPL. After that the 3rd party company has the rights to resell it to other companies as well for its solution.
• Final Product License (FPL): who ships the final product pays. It is based on a royalty model. For the first 10,000 units, there are no fee paid. For units shipped above 10,000, each device pays $0.1 and the total amount is caped at $50,000 a year. In this case, if Samsung TV at the end releases an app based on the porting kit he hired a 3rd-party to implement, Samsung pays for the FPL.

For more information, you could check on our portal: aka.ms/sspk. And please email sspkinfo@microsoft.com for inquiries.

VIDEO DELIVERY TO WINDOWS 8 PLATFORM

There are three ways of delivering video on Windows 8:

• • Building a video application on Windows 8 (distributed through Windows Store)
• • Via Metro IE
• • Via Desktop IE

Building a video application on Windows 8 (distributed through Windows Store)

• • Smooth Streaming Client SDK for Windows 8
• • [Recommend] Microsoft Media Platform Player framework

We provided both SDK and player framework for you to choose from. By using either of them, you could be able to build a rich media application rapidly. Hulu Plus hits Windows Store a few days ago, which is built on top of our SDK. The video playback is very smooth and seeking is very fast as well. I do enjoy the Pin-to-Start functionality so I could jump into my favorite show right away. The most attractive feature I found is being able to “Snap View” my video in a small windows and use other application side-by-side.
To understand more about building application on – <building video applications on WIndows 8 – things you need to know>.

Snap View function for Hulu on Windows 8

As I mentioned earlier on, you could also deliver video through Metro IE/desktop IE, but there are limitations on the plugin usage. Please refer to “Video delivery through browser” section.

VIDEO DELIVERY TO XBOX

We bring smooth streaming playback and PlayReady protection capability for premium content onto XBOX platform. Similarly w e have Smooth Streaming SDK and Player Framework wrapped around it. And importantly, Xbox SDK and framework are shipped within XBox ADK (Application Development Kit).

Get started through: http://xbox.create.msdn.com

There are many applications already in the marketplace such as Comcast, Sony, HBO and etc. We also shipped a reference application with Metro look and feel, which demos how to build a Xbox application to consume Smooth Streaming with or without PlayReady, how to monetize applications with in-built Ad support and rich analytic and how to integrate with XBox Live.

VIDEO DELIVERY TO WINDOWS PHONE 8/7

The IIS Smooth Streaming Client (Silverlight) for desktop I introduced in earlier section has a separate version for Windows Phone as well. And on top of the SDK, we always recommend you to use Player Framework：

• Player Framework for Windows phone 8 

This is a brand new version of the Player Framework for Windows Phone, available exclusively for Windows Phone 8, and now based upon the Player Framework for Windows 8. While this new version is not backward compatible with Windows Phone 7 (get that http://smf.codeplex.com/releases/view/88970), it does offer the same great feature set plus dozens of new features such as advertising, localization support, and improved skinning. Find out more about Windows Phone 8 player framework features here.

PrintScreen of Windows Phone 8 media player framework

Summary

If you have any questions related to the usage of SDK or framework, please post on our Media Services Forum. I also have a slide deck posted on Slideshare and you could get more information there as well.

The post Client Ecosystem for Windows Azure Media Services appeared first on Mingfei Yan.

Scenario One: You have a .Mp4 file and you want to package into HLS and stream out from Windows Azure Media Services.

Here is how you could do it through Windows Azure Management Portal:

1. Login to https://manage.windowsazure.com/ and if you don’t have a media services account yet, here is how you could obtain a preview account.

2. Here is how the portal looks like. Click on Media Services tab and choose an existing MP4 file you have. If you don’t have any available MP4 file in portal, you could click on UPLOAD button at the bottom to upload a file from your laptop. Note: you could only upload file size less than 200MB through Azure portal. If you want to upload file bigger than 200 MB, please use our Media Services API.

Portal for Media Services

3. After having your MP4 file in place, click on the Encode button below and choose the third profile: Playback on IOS devices and PC/MAC. After you hit okay, it will start to produce two files.

4. Now, after you kick off the encoding job, you will see two new assets get generated. For my case, they are “The Surface Movement_small-mp4-iOS-Output” and “The Surface Movement_small-mp4-iOS-Output-Intermediate-PCMac-Output”. Here, any name with an “Intermediate” is a SMOOTH STREAMING content and the other one is HLS content. We firstly package your H.264 content into Smooth Streaming and then we mark it as HLS content.

Question: If I don’t need Smooth Streaming content, could we delete it?

Answer: Yes, you could. But if you use portal to do the conversion  Smooth Streaming asset will be created.

Question: what profile of HLS content do I generate here?

Answer: The profile we used here is “H264 Smooth Streaming 720p“, and you could check out details here. If you want to encode into other HLS profile, you will need to use our API. For Azure portal, only one profile is provided.

5. After the packing is done, click on the HLS asset (without Intermediate in the name) and click on PUBLISH button at the bottom. Now, your HLS content is hosted on Windows Azure Media Services, and you could grab the link at Publish URL column. That’s the link you put in your video application (iOS native app or HTML5 web app for Safari) and enjoy your video!

6. I will publish another blog post on how to generate HLS content through Azure Media Services .NET SDK.

The post How to generate Http Live Streaming (HLS) content using Windows Azure Media Services appeared first on Mingfei Yan.

Printscreen for Azure Media Player framework for IOS

What’s this framework for?

This framework enables developers to build native video application on iOS platform, which could consume secure HLS (Http live Streaming) content from Windows Azure Media Services. Mainly,this framework made easy for developers to integrate client-side advertisements. In the future we will also support various advertisement standards, such as VAST 3.0 and VMAP 1.0.

Architecture of this player framework

Architecture – Azure Media Player Framework Preview for iOS

1. JavaScript Library: 

• • • Sequencer.js: used to maintain an internal playlsit
  • • Scheduler.js: used to schedule advertisement and main content
  • • Adresolver.js: used to parse different advertisement standards, currently there is nothing available but we will  be adding VAST and VMAP support very soon
• Note: developers are not advised to change existing JavaScript files but encouraged to write additional JavaScript file as plugin.

2. iOS sequencer wrapper: 

• iOS sequencer wrapper bubbles up most of functions implemented in JavaScript library into Objective C layer. We have a hidden UIWebView for calling all JavaScript functions. 
• Note: Developers are not advised to modify these files and APIs should remain the same even with additional plugins.

• 3. iOS AVPlayerFramework:

• As showed in the architecture diagram above, the AVPlayeFramework includes iOS sequencer wrapper and based on AVPlayer native iOS library. This AVPlayerFramework provides additional functionalities such as advertisement insertion based on AVPlayer. All APIs in AVplayerFramework are what developer should use directly for developing its video application. 

• 4. Sample player:

  Sample Player is also shipped along with our player framework as a reference for developer. Here you could learn how to use various functions we provided, such as pre-roll, mid-roll and post-roll advertisement insertion. All the video sources are coming from Windows Azure Media Services. (Here is a blog for how-to produce HLS content with Windows Azure Media Services).

Who should use this SDK?

Developers who want to consume HLS (Http Live Streaming) content from Windows Azure Media Services and Developers who want to enable client-side advertisement insertion with their video application on iOS.

System requirement

iOS 5 and above system will be supported.

Feature List 

Advertisement insertion

• • Pre-roll, Mid-roll and Post-roll support
• • Ad Pod
• • • Advertisement clip could be either Mp4 or Http Live Streaming
• • • Error Notification
• • • Play-once or Sticky Ad

Performance

• •Seamless transition from Advertisement to Main Content and between advertisements

Q&A:

Question: how often will you refresh this framework?

Answer: We will refresh code frequently once we have important features finished. However, we don’t have rigid deadline such as a specific day of month, but our release cycle will be on monthly-basis. Therefore, do check out Readme often to see new features.

Question: If my video application is based on MPMovidPlayer, could I still use this framework?

Answer: Yes. Our IOSAVPlayerFramework is based on AVPlayer. And you could develop another Player Framework on top of IOS Sequencer Wrapper and utilize MPMoviePlayer. However, since MPMoviePlayer is Singleton, you won’t benefit from the seamless switch performance we provided.

Question: I see you have JavaScript library there, could I build a web-based application on top of your JavaScript library? 

Answer: Yes, you could do that, though HTML5 video framework for browser is something we are planning. You could play with it if you can’t wait. Just a friendly notice that, if your main content or advertisement is in HLS format, your video could only be played back in Safari on MAC or i-device. For other browser, you will need to have progressive download content (such as H.264 or WebM).

Question: If I have feature requests, how should I contact you? 

Answer: please go to our feature request user voice.

Question: If I have questions or bugs, how should I contact you? 

Answer:

• 1. Read our documentation carefully. We will be publishing on both Github and MSDN.
• 2. If you can’t find a clue, please post your question on Windows Azure Stackoverflow with tag Azure: http://stackoverflow.com/questions/tagged/azure. We will monitor the forum closely.
• 3. If we aren’t be able to solve the problem you posted, we will put it into back log and fix it according to how badly it impacts. Meanwhile, if you helped us fix the problem, you could contribute code into out Github repository and here is the guidance: http://windowsazure.github.com/guidelines.html.

The post Announcing Windows Azure Media Player framework Preview for IOS appeared first on Mingfei Yan.

Here is all the materials I promised. 

The post Windows Azure Media Services Session info for Build 2012 appeared first on Mingfei Yan.

Building Video application on Windows 8 – what are supported? 

If you are building a video application on Windows 8 and your video source is H.264 (.MP4) for instance:

• • You could use MediaElement class in XAML application to handle the playback. Code sample: 

• <MediaElement Source="Media/video1.mp4" AutoPlay="True" />

• • Or you could use <video> tag in HTML5 application. Code sample: 

• <video width="320" height="240" controls="controls">
    <source src="movie.mp4" type="video/mp4">
  </video>

• Here is a detail list of video format that Windows 8 playback pipeline support (full details in Windows blog) : 
• 
• That’s what happen when developing an application with .Mp4 URL for instance. Windows 8 Media pipeline has Decorder to decode the video, Renderer to render the image and Decrypter to decrypt the video if it is protected. As long as the video format you provides falls into the category I showed in the table above, Windows 8 Media pipeline will handle for you. Meanwhile, Windows 8 team put in a lot of efforts for optimizing all these operations to achieve battery optimization, hardware acceleration and etc.

• Playing Smooth Streaming content using Smooth Streaming Client SDK for Windows 8

• What if you want to deliver adaptive streaming, such as smooth streaming through Windows 8 store app? Yes, this is possible with our smooth streaming SDK as an extension of Windows 8 media platform. When you hand in a application with Smooth Streaming URL (…/manifest), media engine won’t be able to understand. However, Windows 8 SDK has Media Foundation Interface (IMFByteStreamHandler) for fetching media data from given media source. And we build Smooth Streaming extension through that Interface to help media pipeline understand Smooth Streaming by “unwrapping it”. As we know, Smooth Streaming is like a format wrapper of H.264. And once we “unwrap” the format, we feed H.264 video back to Windows 8 media pipeline. And the pipeline could do all the decoding, rendering and decrypting job as showed in diagram below. Since H.264 is a native codec of Windows 8 platform, we could benefit from the video optimization of the platform.
• 

What’s the relationship between Smooth Streaming Client SDK and Media Player Framework?

I think this graph below explains the relationship between these two. Smooth Streaming Extension SDK is built on top of Media Pipeline as I explained in earlier section. Media Framework is one level higher that wrapping around Smooth Streaming Extension SDK. It provides additional functionality, such as player styling, advertisement support, close caption support and etc. If you want to have more control over your media player, I would suggest you use Smooth Streaming Client SDK. But you need to build a media player from scratch. However, if you want to get a media player up and running immediately with UI styling, you should try our Media Framework. And it is very easy to customize the default media player we provided.

I have a few blogs on how to get started with each of them:

< Smooth Streaming Client SDK >
Download: Smooth Streaming Client SDK for Windows 8

• • Building Windows Store Apps with Smooth Streaming Client SDK Beta 2 (link)

< Microsoft Media Platform Player framework >
Download: http://playerframework.codeplex.com/

• • Microsoft Media Platform Player Framework for windows 8 – closed caption support (link)
• • Adding VMAP support for Windows 8 video app using Microsoft Media Platform Player Framework (link)
• • Advertising support for Media Player framework on Windows 8 (link)

Question: If I don’t use Smooth Streaming, could I use Microsoft Media Platform Player Framework for its additional features such as Advertising?

Answer: Yes! MMPPF supports progressive download. You could utilize MMPPF’s functionality such as standard advertisement support, closed caption support, multiple audio support or simply styling your media player. Besides Windows 8 store app, Media player framework also has Silverlight version and HTML5 version for browser. Especially, Silverlight version media player has been released for over 2 years and it is a very well-establish player framework for many events, such as NBC Sunday night football. By using Media Player framework, you could provide consistent video player experience onto different platforms.

Question: Should I build a store application for Windows 8, or a browser version of media player?

Answer: I shall say it depends on your business need. HTML5 <video> in IE, Chrome or Firefox doesn’t support any adaptive streaming format, such as Smooth Streaming. Safari has its proprietary implementation for HTTP live streaming, however, it is only available on IOS platform. Hence, if you want to deliver any content in adaptive streaming, you have to build a Windows 8 app. You may also ask, is there other adaptive streaming format besides Smooth Streaming gets supported by Windows 8? The answer is DASH (Dynamic Adaptive Streaming over HTTP). DASH spec is still in draft stage but DASH is expected to be the standard for adaptive streaming format. We are working on getting DASH supported by Windows 8.

Some awesome application: Hulu Plus

Hulu Plus hits Windows Store a few days ago, which is built on top of our SDK. The video playback is very smooth and seeking is very fast as well. I do enjoy the Pin-to-Start functionality so I could jump into my favorite show right away. The most attractive feature I found is being able to “Snap View ” my video in a small windows and use other application side-by-side.

Summary

Windows 8 is a great device for entertainment. By leveraging on our SDK and framework, we hope you could create amazing video application, which not only deliver content smoothly, but also provide excellent interaction experience for the viewers. Meanwhile, if you are interested in creating, managing and delivery video content from the cloud, you could check out our Media Services in the cloud – Windows Azure Media Services.

The post Building video application on Windows 8 – things you want to know appeared first on Mingfei Yan.

Media services .NET SDK works with .NET 4.0 framework and it includes the following three components:

• • WCF Data Services 5.0 for OData V3 link
  
• • Windows Azure SDK 1.7 (June 2012) link
• • Windows Azure Media Services SDK 1.0 (June 2012) link
• * we utilize Windows Azure Storage client and we support both v1.6 and v1.7 now.

Here is how to use NuGet Package in Visual Studio 2012 RTM:

1. If you don’t have Nuget installed, you could install it using Visual Studio Extension Manager, and here is how.

2. Once you have Nuget package installed, after open a project, you could right-click on Reference folder and choose Manage Nuget Package…

3. Type in windowsazure.mediaservices in search box, choose Windows Azure Media Services .NET SDK and you will get all reference installed and imported.

4. If you want to check more on how to use Windows Azure using .NET SDK, check out my other blog here. If you have any questions, please let me know in my Nuget page: https://nuget.org/packages/windowsazure.mediaservices

Thanks!

The post Introducing Windows Azure Media Services .NET SDK NuGet package appeared first on Mingfei Yan.