Introduction to Dynamic Packaging with Windows Azure Media Services

Sign in to queue

The Discussion

  • User profile image
    NickDrouin

    using Microsoft.WindowsAzure.MediaServices.Client;
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Linq;
    using System.Text;
    using System.Threading;
    
    namespace ConsoleApplication1
    {
        class Program
        {
            static void Main(string[] args)
            {
    
                // Create .Net console app
                // Set project properties to use the full .Net Framework (not Client Profile)
                // With NuGet Package Manager, install windowsazure.mediaservices
                // add: using Microsoft.WindowsAzure.MediaServices.Client; 
    
                var context = new CloudMediaContext("yourwamsaccountname", "H6Gd...wamskey...df4=");
    
                string inputAssetId = CreateAssetAndUploadFile(context);
    
                IJob job = EncodeToMultiBitrateMp4(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)";
    
                Console.WriteLine("\n Mp4 Url:    \n" + mp4StreamingUrl);
                Console.WriteLine("\n Smooth Url: \n" + smoothStreamingUrl);
                Console.WriteLine("\n HLS Url:    \n" + hlsStreamingUrl);
    
                Console.ReadKey();
                Console.ReadKey();
    
            }
    

     

            private static string CreateAssetAndUploadFile(CloudMediaContext context)
            {
                var inputFilePath = @"C:\demo\bing_social_search.mp4";
    
                var assetName = Path.GetFileNameWithoutExtension(inputFilePath);
    
                var inputAsset = context.Assets.Create(assetName, AssetCreationOptions.None);
    
                var assetFile = inputAsset.AssetFiles.Create(Path.GetFileName(inputFilePath));
    
                assetFile.UploadProgressChanged += new EventHandler<UploadProgressChangedEventArgs>(assetFile_UploadProgressChanged);
                assetFile.Upload(inputFilePath);
    
                assetFile.MimeType = "video/mp4";
                assetFile.Update();
    
                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")));
            }
     

     

            private static IJob EncodeToMultiBitrateMp4(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"; // http://msdn.microsoft.com/en-us/library/windowsazure/jj129582.aspx#H264Encoding
    
                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")));
            }
    

     

            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;
            }
      }//close out class
    ]//Namespace
    

     

Add Your 2 Cents