Using Azure Media Packager to accomplish static packaging tasks (2023)

  • Artikel
  • 32Minuten Lesedauer

Using Azure Media Packager to accomplish static packaging tasks (1)

Warning

Update your Azure Media Services REST API and SDKs to v3 by 29 February 2024. Version 3 of Azure Media Services REST API and client SDKs for .NET and Java offers more capabilities than version 2. We’re retiring version 2 of the Azure Media Services REST API and client SDKs for .NET and Java.

Action Required: To minimize disruption to your workloads, review the migration guide to transition your code from the version 2 API and SDKs to version 3 API and SDK before February 29th, 2024. After February 29th, 2024, Azure Media Services will no longer accept traffic on the version 2 REST API, the ARM account management API version 2015-10-01, or from the version 2 .NET client SDKs. This includes any 3rd party open-source client SDKS that may call the version 2 API. Learn about the latest version, starting with the Media Services v3 Overview.

Overview

In order to deliver digital video over the internet, you must compress the media. Digital video files are large and may be too large to deliver over the internet or for your customers’ devices to display properly. Encoding is the process of compressing video and audio so your customers can view your media. Once a video has been encoded, it can be placed into different file containers. The process of placing encoded media into a container is called packaging. For example, you can take an MP4 file and convert it into Smooth Streaming or HLS content by using the Azure Media Packager.

(Video) Resolving Application Packaging Workflow Challenges

Media Services supports dynamic and static packaging. When using static packaging, you need to create a copy of your content in each format required by your customers. With dynamic packaging, all you need is to create an asset that contains a set of adaptive bitrate MP4 or Smooth Streaming files. Then, based on the specified format in the manifest or fragment request, the On-Demand Streaming server ensures that your users receive the stream in the protocol they have chosen. As a result, you only need to store and pay for the files in single storage format and Media Services service will build and serve the appropriate response based on requests from a client.

However, there are some scenarios that require static packaging:

  • Validating adaptive bitrate MP4s encoded with external encoders (for example, using third-party encoders).

You can also use static packaging to perform the following tasks: However it is better to use dynamic encryption.

  • Using static encryption to protect your Smooth and MPEG DASH with PlayReady
  • Using static encryption to protect HLSv3 with AES-128
  • Using static encryption to protect HLSv3 with PlayReady

Validating Adaptive Bitrate MP4s Encoded with External Encoders

If you want to use a set of adaptive bitrate (multi-bitrate) MP4 files that were not encoded with Media Services' encoders, you should validate your files before further processing. The Media Services Packager can validate an asset that contains a set of MP4 files and check whether the asset can be packaged to Smooth Streaming or HLS. If the validation task fails, the job that was processing the task completes with an error. The XML that defines the preset for the validation task can be found in the Task Preset for Azure Media Packager article.

Note

Use the Media Encoder Standard to produce or the Media Services Packager to validate your content in order to avoid runtime issues. If the On-Demand Streaming server is not able to parse your source files at runtime, you receive HTTP 1.1 error “415 Unsupported Media Type.” Repeatedly causing the server to fail to parse your source files affects performance of the On-Demand Streaming server and may reduce the bandwidth available to serving other requests. Azure Media Services offers a Service Level Agreement (SLA) on its On-Demand Streaming services; however, this SLA cannot be honored if the server is misused in the fashion described above.

This section shows how to process the validation task. It also shows how to see the status and the error message of the job that completes with JobStatus.Error.

(Video) Pessimism Pays - AI for the consumer client, HoloLens request rejected, Azure DevOps

To validate your MP4 files with Media Services Packager, you must create your own manifest (.ism) file and upload it together with the source files into the Media Services account. Below is a sample of the .ism file produced by the Media Encoder Standard. The file names are case-sensitive. Also, make sure the text in the .ism file is encoded with UTF-8.

 <?xml version="1.0" encoding="utf-8" standalone="yes"?> <smil xmlns="https://www.w3.org/2001/SMIL20/Language"> <head> <!-- Tells the server that these input files are MP4s – specific to Dynamic Packaging --> <meta name="formats" content="mp4" /> </head> <body> <switch> <video src="BigBuckBunny_1000.mp4" /> <video src="BigBuckBunny_1500.mp4" /> <video src="BigBuckBunny_2250.mp4" /> <video src="BigBuckBunny_3400.mp4" /> <video src="BigBuckBunny_400.mp4" /> <video src="BigBuckBunny_650.mp4" /> <audio src="BigBuckBunny_400.mp4" /> </switch> </body> </smil>

Once you have the adaptive bitrate MP4 set, you can take advantage of Dynamic Packaging. Dynamic Packaging allows you to deliver streams in the specified protocol without further packaging. For more information, see dynamic packaging.

The following code sample uses Azure Media Services .NET SDK Extensions. Make sure to update the code to point to the folder where your input MP4 files and .ism file are located. And also to where your MediaPackager_ValidateTask.xml file is located. This XML file is defined in Task Preset for Azure Media Packager article.

 using Microsoft.WindowsAzure.MediaServices.Client; using System; using System.Collections.Generic; using System.Configuration; using System.IO; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using System.Xml.Linq; namespace MediaServicesStaticPackaging { class Program { private static readonly string _mediaFiles = Path.GetFullPath(@"../..\Media"); // The MultibitrateMP4Files folder should also // contain the .ism manifest file. private static readonly string _multibitrateMP4s = Path.Combine(_mediaFiles, @"MultibitrateMP4Files"); // XML Configuration files path. private static readonly string _configurationXMLFiles = @"../..\Configurations"; private static MediaServicesCredentials _cachedCredentials = null; private static CloudMediaContext _context = null; // Read values from the App.config file. private static readonly string _AADTenantDomain = ConfigurationManager.AppSettings["AMSAADTenantDomain"]; private static readonly string _RESTAPIEndpoint = ConfigurationManager.AppSettings["AMSRESTAPIEndpoint"]; private static readonly string _AMSClientId = ConfigurationManager.AppSettings["AMSClientId"]; private static readonly string _AMSClientSecret = ConfigurationManager.AppSettings["AMSClientSecret"]; static void Main(string[] args) { AzureAdTokenCredentials tokenCredentials = new AzureAdTokenCredentials(_AADTenantDomain, new AzureAdClientSymmetricKey(_AMSClientId, _AMSClientSecret), AzureEnvironments.AzureCloudEnvironment); var tokenProvider = new AzureAdTokenProvider(tokenCredentials); _context = new CloudMediaContext(new Uri(_RESTAPIEndpoint), tokenProvider); // Ingest a set of multibitrate MP4s. // // Use the SDK extension method to create a new asset by // uploading files from a local directory. IAsset multibitrateMP4sAsset = _context.Assets.CreateFromFolder( _multibitrateMP4s, AssetCreationOptions.None, (af, p) => { Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress); }); // Use Azure Media Packager to validate the files. IAsset validatedMP4s = ValidateMultibitrateMP4s(multibitrateMP4sAsset); // Publish the asset. _context.Locators.Create( LocatorType.OnDemandOrigin, validatedMP4s, AccessPermissions.Read, TimeSpan.FromDays(30)); // Get the streaming URLs. Console.WriteLine("Smooth Streaming URL:"); Console.WriteLine(validatedMP4s.GetSmoothStreamingUri().ToString()); Console.WriteLine("MPEG DASH URL:"); Console.WriteLine(validatedMP4s.GetMpegDashUri().ToString()); Console.WriteLine("HLS URL:"); Console.WriteLine(validatedMP4s.GetHlsUri().ToString()); } public static IAsset ValidateMultibitrateMP4s(IAsset multibitrateMP4sAsset) { // Set .ism as a primary file // in a multibitrate MP4 set. SetISMFileAsPrimary(multibitrateMP4sAsset); // Create a new job. IJob job = _context.Jobs.Create("MP4 validation and conversion to Smooth Stream job."); // Read the task configuration data into a string. string configMp4Validation = File.ReadAllText(Path.Combine( _configurationXMLFiles, "MediaPackager_ValidateTask.xml")); // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor processor = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaPackager); // Create a task with the conversion details, using the configuration data. ITask task = job.Tasks.AddNew("Mp4 Validation Task", processor, configMp4Validation, TaskOptions.None); // Specify the input asset to be validated. task.InputAssets.Add(multibitrateMP4sAsset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). task.OutputAssets.AddNew("Validated output asset", AssetCreationOptions.None); // Submit the job and wait until it is completed. job.Submit(); job = job.StartExecutionProgressTask( j => { Console.WriteLine("Job state: {0}", j.State); Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); }, CancellationToken.None).Result; // If the validation task fails and job completes with JobState.Error, // display the error message and throw an exception. if (job.State == JobState.Error) { Console.WriteLine(" Job ID: " + job.Id); Console.WriteLine(" Name: " + job.Name); Console.WriteLine(" State: " + job.State); foreach (var jobTask in job.Tasks) { Console.WriteLine(" Task Id: " + jobTask.Id); Console.WriteLine(" Name: " + jobTask.Name); Console.WriteLine(" Progress: " + jobTask.Progress); Console.WriteLine(" Configuration: " + jobTask.Configuration); Console.WriteLine(" Running time: " + jobTask.RunningDuration); if (jobTask.ErrorDetails != null) { foreach (var errordetail in jobTask.ErrorDetails) { Console.WriteLine(" Error Message:" + errordetail.Message); Console.WriteLine(" Error Code:" + errordetail.Code); } } } throw new Exception("The specified multi-bitrate MP4 set is not valid."); } return job.OutputMediaAssets[0]; } static void SetISMFileAsPrimary(IAsset asset) { var ismAssetFiles = asset.AssetFiles.ToList(). Where(f => f.Name.EndsWith(".ism", StringComparison.OrdinalIgnoreCase)); // The following code assigns the first .ism file as the primary file in the asset. // An asset should have one .ism file. ismAssetFiles.First().IsPrimary = true; ismAssetFiles.First().Update(); } } }

Using Static Encryption to Protect your Smooth and MPEG DASH with PlayReady

If you want to protect your content with PlayReady, you have a choice of using dynamic encryption or static encryption (as described in this section).

The example in this section encodes a mezzanine file (in this case MP4) into adaptive bitrate MP4 files. It then packages MP4s into Smooth Streaming and then encrypts Smooth Streaming with PlayReady. As a result you are able to stream Smooth Streaming or MPEG DASH.

Media Services now provides a service for delivering Microsoft PlayReady licenses. The example in this article shows how to configure the Media Services PlayReady license delivery service (see the ConfigureLicenseDeliveryService method defined in the code below). For more information about Media Services PlayReady license delivery service, see Using PlayReady Dynamic Encryption and License Delivery Service.

Note

(Video) Creating NuGet Packages the easy way with .NET Standard in C#

To deliver MPEG DASH encrypted with PlayReady, make sure to use CENC options by setting the useSencBox and adjustSubSamples properties (described in the Task Preset for Azure Media Encryptor article) to true.

Make sure to update the following code to point to the folder where your input MP4 file is located.

And also to where your MediaPackager_MP4ToSmooth.xml and MediaEncryptor_PlayReadyProtection.xml files are located. MediaPackager_MP4ToSmooth.xml is defined in Task Preset for Azure Media Packager and MediaEncryptor_PlayReadyProtection.xml is defined in the Task Preset for Azure Media Encryptor article.

The example defines the UpdatePlayReadyConfigurationXMLFile method that you can use to dynamically update the MediaEncryptor_PlayReadyProtection.xml file. If you have the key seed available, you can use the CommonEncryption.GeneratePlayReadyContentKey method to generate the content key based on the keySeedValue and KeyId values.

 using System; using System.Collections.Generic; using System.Configuration; using System.IO; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using Microsoft.WindowsAzure.MediaServices.Client; using System.Xml.Linq; using Microsoft.WindowsAzure.MediaServices.Client.ContentKeyAuthorization; using Microsoft.WindowsAzure.MediaServices.Client.DynamicEncryption; namespace PlayReadyStaticEncryptAndKeyDeliverySvc { class Program { private static readonly string _mediaFiles = Path.GetFullPath(@"../..\Media"); private static readonly string _singleMP4File = Path.Combine(_mediaFiles, @"BigBuckBunny.mp4"); // XML Configuration files path. private static readonly string _configurationXMLFiles = @"../..\Configurations\"; // Read values from the App.config file. private static readonly string _AADTenantDomain = ConfigurationManager.AppSettings["AMSAADTenantDomain"]; private static readonly string _RESTAPIEndpoint = ConfigurationManager.AppSettings["AMSRESTAPIEndpoint"]; private static readonly string _AMSClientId = ConfigurationManager.AppSettings["AMSClientId"]; private static readonly string _AMSClientSecret = ConfigurationManager.AppSettings["AMSClientSecret"]; static void Main(string[] args) { AzureAdTokenCredentials tokenCredentials = new AzureAdTokenCredentials(_AADTenantDomain, new AzureAdClientSymmetricKey(_AMSClientId, _AMSClientSecret), AzureEnvironments.AzureCloudEnvironment); var tokenProvider = new AzureAdTokenProvider(tokenCredentials); _context = new CloudMediaContext(new Uri(_RESTAPIEndpoint), tokenProvider); // Encoding and encrypting assets ////////////////////// // Load a single MP4 file. IAsset asset = IngestSingleMP4File(_singleMP4File, AssetCreationOptions.None); // Encode an MP4 file to a set of multibitrate MP4s. // Then, package a set of MP4s to clear Smooth Streaming. IAsset clearSmoothStreamAsset = ConvertMP4ToMultibitrateMP4sToSmoothStreaming(asset); // Create a common encryption content key that is used // a) to set the key values in the MediaEncryptor_PlayReadyProtection.xml file // that is used for encryption. // b) to configure the license delivery service and // Guid keyId; byte[] contentKey; IContentKey key = CreateCommonEncryptionKey(out keyId, out contentKey); // The content key authorization policy must be configured by you // and met by the client in order for the PlayReady license // to be delivered to the client. // In this example the Media Services PlayReady license delivery service is used. ConfigureLicenseDeliveryService(key); // Get the Media Services PlayReady license delivery URL. // This URL will be assigned to the licenseAcquisitionUrl property // of the MediaEncryptor_PlayReadyProtection.xml file. Uri acquisitionUrl = key.GetKeyDeliveryUrl(ContentKeyDeliveryType.PlayReadyLicense); // Update the MediaEncryptor_PlayReadyProtection.xml file with the key and URL info. UpdatePlayReadyConfigurationXMLFile(keyId, contentKey, acquisitionUrl); // Encrypt your clear Smooth Streaming to Smooth Streaming with PlayReady. IAsset outputAsset = CreateSmoothStreamEncryptedWithPlayReady(clearSmoothStreamAsset); // You can use the http://smf.cloudapp.net/healthmonitor player // to test the smoothStreamURL URL. string smoothStreamURL = outputAsset.GetSmoothStreamingUri().ToString(); Console.WriteLine("Smooth Streaming URL:"); Console.WriteLine(smoothStreamURL); // You can use the http://dashif.org/reference/players/javascript/ player // to test the dashURL URL. string dashURL = outputAsset.GetMpegDashUri().ToString(); Console.WriteLine("MPEG DASH URL:"); Console.WriteLine(dashURL); } /// <summary> /// Creates a job with 2 tasks: /// 1 task - encodes a single MP4 to multibitrate MP4s, /// 2 task - packages MP4s to Smooth Streaming. /// </summary> /// <returns>The output asset.</returns> public static IAsset ConvertMP4ToMultibitrateMP4sToSmoothStreaming(IAsset asset) { // Create a new job. IJob job = _context.Jobs.Create("Convert MP4 to Smooth Streaming."); // Add task 1 - Encode single MP4 into multibitrate MP4s. IAsset MP4sAsset = EncodeMP4IntoMultibitrateMP4sTask(job, asset); // Add task 2 - Package a multibitrate MP4 set to Clear Smooth Stream. IAsset packagedAsset = PackageMP4ToSmoothStreamingTask(job, MP4sAsset); // Submit the job and wait until it is completed. job.Submit(); job = job.StartExecutionProgressTask( j => { Console.WriteLine("Job state: {0}", j.State); Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); }, CancellationToken.None).Result; // Get the output asset that contains the Smooth Streaming asset. return job.OutputMediaAssets[1]; } /// <summary> /// Encrypts Smooth Stream with PlayReady. /// Then creates a Smooth Streaming Url. /// </summary> /// <param name="clearSmoothAsset">Asset that contains clear Smooth Streaming.</param> /// <returns>The output asset.</returns> public static IAsset CreateSmoothStreamEncryptedWithPlayReady(IAsset clearSmoothStreamAsset) { // Create a job. IJob job = _context.Jobs.Create("Encrypt to PlayReady Smooth Streaming."); // Add task 1 - Encrypt Smooth Streaming with PlayReady IAsset encryptedSmoothAsset = EncryptSmoothStreamWithPlayReadyTask(job, clearSmoothStreamAsset); // Submit the job and wait until it is completed. job.Submit(); job = job.StartExecutionProgressTask( j => { Console.WriteLine("Job state: {0}", j.State); Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); }, CancellationToken.None).Result; // The OutputMediaAssets[0] contains the desired asset. _context.Locators.Create( LocatorType.OnDemandOrigin, job.OutputMediaAssets[0], AccessPermissions.Read, TimeSpan.FromDays(30)); return job.OutputMediaAssets[0]; } /// <summary> /// Create a common encryption content key that is used /// to set the key values in the MediaEncryptor_PlayReadyProtection.xml file /// that is used for encryption. /// </summary> /// <param name="keyId"></param> /// <param name="contentKey"></param> /// <returns></returns> public static IContentKey CreateCommonEncryptionKey(out Guid keyId, out byte[] contentKey) { keyId = Guid.NewGuid(); contentKey = GetRandomBuffer(16); IContentKey key = _context.ContentKeys.Create( keyId, contentKey, "ContentKey", ContentKeyType.CommonEncryption); return key; } /// <summary> /// Update your configuration .xml file dynamically. /// </summary> public static void UpdatePlayReadyConfigurationXMLFile(Guid keyId, byte[] keyValue, Uri licenseAcquisitionUrl) { string xmlFileName = Path.Combine(_configurationXMLFiles, @"MediaEncryptor_PlayReadyProtection.xml"); XNamespace xmlns = "http://schemas.microsoft.com/iis/media/v4/TM/TaskDefinition#"; // Prepare the encryption task template XDocument doc = XDocument.Load(xmlFileName); var licenseAcquisitionUrlEl = doc .Descendants(xmlns + "property") .Where(p => p.Attribute("name").Value == "licenseAcquisitionUrl") .FirstOrDefault(); var contentKeyEl = doc .Descendants(xmlns + "property") .Where(p => p.Attribute("name").Value == "contentKey") .FirstOrDefault(); var keyIdEl = doc .Descendants(xmlns + "property") .Where(p => p.Attribute("name").Value == "keyId") .FirstOrDefault(); // Update the "value" property. if (licenseAcquisitionUrlEl != null) licenseAcquisitionUrlEl.Attribute("value").SetValue(licenseAcquisitionUrl.ToString()); if (contentKeyEl != null) contentKeyEl.Attribute("value").SetValue(Convert.ToBase64String(keyValue)); if (keyIdEl != null) keyIdEl.Attribute("value").SetValue(keyId); doc.Save(xmlFileName); } /// <summary> /// Uploads a single file. /// </summary> /// <param name="fileDir">The location of the files.</param> /// <param name="assetCreationOptions"> /// You can specify the following encryption options for the AssetCreationOptions. /// None: no encryption. /// StorageEncrypted: storage encryption. Encrypts a clear input file /// before it is uploaded to Azure storage. /// CommonEncryptionProtected: for Common Encryption Protected (CENC) files. /// For example, a set of files that are already PlayReady encrypted. /// EnvelopeEncryptionProtected: for HLS with AES encryption files. /// NOTE: The files must have been encoded and encrypted by Transform Manager. /// </param> /// <returns>Returns an asset that contains a single file.</returns> /// </summary> /// <returns></returns> private static IAsset IngestSingleMP4File(string fileDir, AssetCreationOptions assetCreationOptions) { // Use the SDK extension method to create a new asset by // uploading a mezzanine file from a local path. IAsset asset = _context.Assets.CreateFromFile( fileDir, assetCreationOptions, (af, p) => { Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress); }); return asset; } /// <summary> /// Creates a task to encode to Adaptive Bitrate. /// Adds the new task to a job. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset EncodeMP4IntoMultibitrateMP4sTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Media Encoder Standard. IMediaProcessor encoder = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.MediaEncoderStandard); ITask adaptiveBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task", encoder, "Adaptive Streaming", TaskOptions.None); // Specify the input Asset adaptiveBitrateTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset abrAsset = adaptiveBitrateTask.OutputAssets.AddNew("Multibitrate MP4s", AssetCreationOptions.None); return abrAsset; } /// <summary> /// Creates a task to convert the MP4 file(s) to a Smooth Streaming asset. /// Adds the new task to a job. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset PackageMP4ToSmoothStreamingTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor packager = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaPackager); // Azure Media Packager does not accept string presets, so load xml configuration string smoothConfig = File.ReadAllText(Path.Combine( _configurationXMLFiles, "MediaPackager_MP4toSmooth.xml")); // Create a new Task to convert adaptive bitrate to Smooth Streaming. ITask smoothStreamingTask = job.Tasks.AddNew("MP4 to Smooth Task", packager, smoothConfig, TaskOptions.None); // Specify the input Asset, which is the output Asset from the first task smoothStreamingTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset smoothOutputAsset = smoothStreamingTask.OutputAssets.AddNew("Clear Smooth Stream", AssetCreationOptions.None); return smoothOutputAsset; } /// <summary> /// Creates a task to encrypt Smooth Streaming with PlayReady. /// Note: To deliver DASH, make sure to set the useSencBox and adjustSubSamples /// configuration properties to true. /// In this example, MediaEncryptor_PlayReadyProtection.xml contains configuration. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset EncryptSmoothStreamWithPlayReadyTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Azure Media Encryptor. IMediaProcessor playreadyProcessor = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaEncryptor); // Read the configuration XML. // // Note that the configuration defined in MediaEncryptor_PlayReadyProtection.xml // is using keySeedValue. It is recommended that you do this only for testing // and not in production. For more information, see // https://msdn.microsoft.com/library/windowsazure/dn189154.aspx. // string configPlayReady = File.ReadAllText(Path.Combine(_configurationXMLFiles, @"MediaEncryptor_PlayReadyProtection.xml")); ITask playreadyTask = job.Tasks.AddNew("My PlayReady Task", playreadyProcessor, configPlayReady, TaskOptions.ProtectedConfiguration); playreadyTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.CommonEncryptionProtected. IAsset playreadyAsset = playreadyTask.OutputAssets.AddNew( "PlayReady Smooth Streaming", AssetCreationOptions.CommonEncryptionProtected); return playreadyAsset; } /// <summary> /// Configures authorization policy for the content key. /// </summary> /// <param name="contentKey">The content key.</param> static public void ConfigureLicenseDeliveryService(IContentKey contentKey) { // Create ContentKeyAuthorizationPolicy with Open restrictions // and create authorization policy List<ContentKeyAuthorizationPolicyRestriction> restrictions = new List<ContentKeyAuthorizationPolicyRestriction> { new ContentKeyAuthorizationPolicyRestriction { Name = "Open", KeyRestrictionType = (int)ContentKeyRestrictionType.Open, Requirements = null } }; // Configure PlayReady license template. string newLicenseTemplate = ConfigurePlayReadyLicenseTemplate(); IContentKeyAuthorizationPolicyOption policyOption = _context.ContentKeyAuthorizationPolicyOptions.Create("", ContentKeyDeliveryType.PlayReadyLicense, restrictions, newLicenseTemplate); IContentKeyAuthorizationPolicy contentKeyAuthorizationPolicy = _context. ContentKeyAuthorizationPolicies. CreateAsync("Deliver Common Content Key with no restrictions"). Result; contentKeyAuthorizationPolicy.Options.Add(policyOption); // Associate the content key authorization policy with the content key. contentKey.AuthorizationPolicyId = contentKeyAuthorizationPolicy.Id; contentKey = contentKey.UpdateAsync().Result; } static private string ConfigurePlayReadyLicenseTemplate() { // The following code configures PlayReady License Template using .NET classes // and returns the XML string. PlayReadyLicenseResponseTemplate responseTemplate = new PlayReadyLicenseResponseTemplate(); PlayReadyLicenseTemplate licenseTemplate = new PlayReadyLicenseTemplate(); responseTemplate.LicenseTemplates.Add(licenseTemplate); return MediaServicesLicenseTemplateSerializer.Serialize(responseTemplate); } static private byte[] GetRandomBuffer(int length) { var returnValue = new byte[length]; using (var rng = new System.Security.Cryptography.RNGCryptoServiceProvider()) { rng.GetBytes(returnValue); } return returnValue; } } }

Using Static Encryption to Protect HLSv3 with AES-128

If you want to encrypt your HLS with AES-128, you have a choice of using dynamic encryption or static encryption (as shown in this section). If you decide to use dynamic encryption, see Using AES-128 Dynamic Encryption and Key Delivery Service.

Note

In order to convert your content into HLS, you must first convert/encode your content into Smooth Streaming.Also, for the HLS to get encrypted with AES make sure to set the following properties in your MediaPackager_SmoothToHLS.xml file: set the encrypt property to true, set the key value, and the keyuri value to point to your authentication\authorization server.Media Services creates a key file and places it in the asset container. You should copy the /asset-containerguid/*.key file to your server (or create your own key file) and then delete the *.key file from the asset container.

(Video) Identity Governance Automation with Azure Logic Apps

The example in this section encodes a mezzanine file (in this case MP4) into multibitrate MP4 files and then packages MP4s into Smooth Streaming. It then packages Smooth Streaming into HTTP Live Streaming (HLS) encrypted with Advanced Encryption Standard (AES) 128-bit stream encryption. Make sure to update the following code to point to the folder where your input MP4 file is located. And also to where your MediaPackager_MP4ToSmooth.xml and MediaPackager_SmoothToHLS.xml configuration files are located. You can find the definition for these files in the Task Preset for Azure Media Packager article.

 using System; using System.Collections.Generic; using System.Configuration; using System.IO; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using Microsoft.WindowsAzure.MediaServices.Client; using System.Xml.Linq; namespace MediaServicesContentProtection { class Program { // Paths to support files (within the above base path). You can use // the provided sample media files from the "SupportFiles" folder, or // provide paths to your own media files below to run these samples. private static readonly string _mediaFiles = Path.GetFullPath(@"../..\Media"); private static readonly string _singleMP4File = Path.Combine(_mediaFiles, @"SingleMP4\BigBuckBunny.mp4"); // XML Configuration files path. private static readonly string _configurationXMLFiles = @"../..\Configurations\"; // Read values from the App.config file. private static readonly string _AADTenantDomain = ConfigurationManager.AppSettings["AMSAADTenantDomain"]; private static readonly string _RESTAPIEndpoint = ConfigurationManager.AppSettings["AMSRESTAPIEndpoint"]; private static readonly string _AMSClientId = ConfigurationManager.AppSettings["AMSClientId"]; private static readonly string _AMSClientSecret = ConfigurationManager.AppSettings["AMSClientSecret"]; static void Main(string[] args) { AzureAdTokenCredentials tokenCredentials = new AzureAdTokenCredentials(_AADTenantDomain, new AzureAdClientSymmetricKey(_AMSClientId, _AMSClientSecret), AzureEnvironments.AzureCloudEnvironment); var tokenProvider = new AzureAdTokenProvider(tokenCredentials); _context = new CloudMediaContext(new Uri(_RESTAPIEndpoint), tokenProvider); // Encoding and encrypting assets ////////////////////// // Load an MP4 file. IAsset asset = IngestSingleMP4File(_singleMP4File, AssetCreationOptions.None); // Encode an MP4 file to a set of multibitrate MP4s. // Then, package a set of MP4s to clear Smooth Streaming. IAsset clearSmoothStreamAsset = ConvertMP4ToMultibitrateMP4sToSmoothStreaming(asset); // Create HLS encrypted with AES. IAsset HLSEncryptedWithAESAsset = CreateHLSEncryptedWithAES(clearSmoothStreamAsset); // You can use the following player to test the HLS with AES stream. // https://apps.microsoft.com/windows/app/3ivx-hls-player/f79ce7d0-2993-4658-bc4e-83dc182a0614 string hlsWithAESURL = HLSEncryptedWithAESAsset.GetHlsUri().ToString(); Console.WriteLine("HLS with AES URL:"); Console.WriteLine(hlsWithAESURL); } /// <summary> /// Creates a job with 2 tasks: /// 1 task - encodes a single MP4 to multibitrate MP4s, /// 2 task - packages MP4s to Smooth Streaming. /// </summary> /// <returns>The output asset.</returns> public static IAsset ConvertMP4ToMultibitrateMP4sToSmoothStreaming(IAsset asset) { // Create a new job. IJob job = _context.Jobs.Create("Convert MP4 to Smooth Streaming."); // Add task 1 - Encode single MP4 into multibitrate MP4s. IAsset MP4sAsset = EncodeSingleMP4IntoMultibitrateMP4sTask(job, asset); // Add task 2 - Package a multibitrate MP4 set to Clear Smooth Streaming. IAsset packagedAsset = PackageMP4ToSmoothStreamingTask(job, MP4sAsset); // Submit the job and wait until it is completed. job.Submit(); job = job.StartExecutionProgressTask( j => { Console.WriteLine("Job state: {0}", j.State); Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); }, CancellationToken.None).Result; // Get the output asset that contains Smooth Streaming. return job.OutputMediaAssets[1]; } /// <summary> /// Encrypts an HLS with AES-128. /// </summary> /// <param name="clearSmoothAsset">Asset that contains clear Smooth Streaming.</param> /// <returns>The output asset.</returns> public static IAsset CreateHLSEncryptedWithAES(IAsset clearSmoothStreamAsset) { IJob job = _context.Jobs.Create("Encrypt to HLS with AES."); // Add task 1 - Package clear Smooth Streaming to HLS with AES. PackageSmoothStreamToHLS(job, clearSmoothStreamAsset); // Submit the job and wait until it is completed. job.Submit(); job = job.StartExecutionProgressTask( j => { Console.WriteLine("Job state: {0}", j.State); Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); }, CancellationToken.None).Result; // The OutputMediaAssets[0] contains the desired asset. _context.Locators.Create( LocatorType.OnDemandOrigin, job.OutputMediaAssets[0], AccessPermissions.Read, TimeSpan.FromDays(30)); return job.OutputMediaAssets[0]; } /// <summary> /// Uploads a single file. /// </summary> /// <param name="fileDir">The location of the files.</param> /// <param name="assetCreationOptions"> /// You can specify the following encryption options for the AssetCreationOptions. /// None: no encryption. /// StorageEncrypted: storage encryption. Encrypts a clear input file /// before it is uploaded to Azure storage. /// CommonEncryptionProtected: for Common Encryption Protected (CENC) files. /// For example, a set of files that are already PlayReady encrypted. /// EnvelopeEncryptionProtected: for HLS with AES encryption files. /// NOTE: The files must have been encoded and encrypted by Transform Manager. /// </param> /// <returns>Returns an asset that contains a single file.</returns> /// </summary> /// <returns></returns> private static IAsset IngestSingleMP4File(string fileDir, AssetCreationOptions assetCreationOptions) { // Use the SDK extension method to create a new asset by // uploading a mezzanine file from a local path. IAsset asset = _context.Assets.CreateFromFile( fileDir, assetCreationOptions, (af, p) => { Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress); }); return asset; } /// <summary> /// Creates a task to encode to Adaptive Bitrate. /// Adds the new task to a job. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset EncodeSingleMP4IntoMultibitrateMP4sTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Media Encoder Standard. IMediaProcessor encoder = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.MediaEncoderStandard); ITask adaptiveBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task", encoder, "Adaptive Streaming", TaskOptions.None); // Specify the input Asset adaptiveBitrateTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset abrAsset = adaptiveBitrateTask.OutputAssets.AddNew("Multibitrate MP4s", AssetCreationOptions.None); return abrAsset; } /// <summary> /// Creates a task to convert the MP4 file(s) to a Smooth Streaming asset. /// Adds the new task to a job. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset PackageMP4ToSmoothStreamingTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor packager = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaPackager); // Azure Media Packager does not accept string presets, so load xml configuration string smoothConfig = File.ReadAllText(Path.Combine( _configurationXMLFiles, "MediaPackager_MP4toSmooth.xml")); // Create a new Task to convert adaptive bitrate to Smooth Streaming. ITask smoothStreamingTask = job.Tasks.AddNew("MP4 to Smooth Task", packager, smoothConfig, TaskOptions.None); // Specify the input Asset, which is the output Asset from the first task smoothStreamingTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset smoothOutputAsset = smoothStreamingTask.OutputAssets.AddNew("Clear Smooth Streaming", AssetCreationOptions.None); return smoothOutputAsset; } /// <summary> /// Converts Smooth Streaming to HLS. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The Smooth Streaming asset.</param> /// <returns>The asset that was packaged to HLS.</returns> private static IAsset PackageSmoothStreamToHLS(IJob job, IAsset smoothStreamAsset) { // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor processor = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaPackager); // Read the configuration data into a string. // For the HLS to get encrypted with AES make sure to set the // encrypt configuration property to true. // // In production, it is recommended to do the following: // Set a Key url for your authn/authz server. // Copy the /asset-containerguid/*.key file to your server (or craft a key file for yourself). // Delete *.key from the asset container. // string configuration = File.ReadAllText(Path.Combine(_configurationXMLFiles, @"MediaPackager_SmoothToHLS.xml")); // Create a task with the encoding details, using a configuration file. ITask task = job.Tasks.AddNew("My Smooth Streaming to HLS Task", processor, configuration, TaskOptions.ProtectedConfiguration); // Specify the input asset to be encoded. task.InputAssets.Add(smoothStreamAsset); // Add an output asset to contain the results of the job. IAsset outputAsset = task.OutputAssets.AddNew("HLS asset", AssetCreationOptions.None); return outputAsset; } } }

Using Static Encryption to Protect HLSv3 with PlayReady

If you want to protect your content with PlayReady, you have a choice of using dynamic encryption or static encryption (as described in this section).

Note

In order to protect your content using PlayReady you must first convert/encode your content into a Smooth Streaming format.

The example in this section encodes a mezzanine file (in this case MP4) into multibitrate MP4 files. It then packages MP4s into Smooth Streaming and encrypts Smooth Streaming with PlayReady. To produce HTTP Live Streaming (HLS) encrypted with PlayReady, the PlayReady Smooth Streaming asset needs to be packaged into HLS. This article demonstrates how to perform all these steps.

Media Services now provides a service for delivering Microsoft PlayReady licenses. The example in this article shows how to configure the Media Services PlayReady license delivery service (see the ConfigureLicenseDeliveryService method defined in the code below).

Make sure to update the following code to point to the folder where your input MP4 file is located. And also to where your MediaPackager_MP4ToSmooth.xml, MediaPackager_SmoothToHLS.xml, and MediaEncryptor_PlayReadyProtection.xml files are located. MediaPackager_MP4ToSmooth.xml and MediaPackager_SmoothToHLS.xml are defined in Task Preset for Azure Media Packager and MediaEncryptor_PlayReadyProtection.xml is defined in the Task Preset for Azure Media Encryptor article.

(Video) Build a Company in Azure

 using System; using System.Collections.Generic; using System.Configuration; using System.IO; using System.Linq; using System.Text; using System.Threading; using System.Threading.Tasks; using Microsoft.WindowsAzure.MediaServices.Client; using System.Xml.Linq; using Microsoft.WindowsAzure.MediaServices.Client.ContentKeyAuthorization; using Microsoft.WindowsAzure.MediaServices.Client.DynamicEncryption; namespace MediaServicesContentProtection { class Program { // Paths to support files (within the above base path). You can use // the provided sample media files from the "SupportFiles" folder, or // provide paths to your own media files below to run these samples. private static readonly string _mediaFiles = Path.GetFullPath(@"../..\Media"); private static readonly string _singleMP4File = Path.Combine(_mediaFiles, @"SingleMP4\BigBuckBunny.mp4"); // XML Configuration files path. private static readonly string _configurationXMLFiles = @"../..\Configurations\"; // Read values from the App.config file. private static readonly string _AADTenantDomain = ConfigurationManager.AppSettings["AMSAADTenantDomain"]; private static readonly string _RESTAPIEndpoint = ConfigurationManager.AppSettings["AMSRESTAPIEndpoint"]; private static readonly string _AMSClientId = ConfigurationManager.AppSettings["AMSClientId"]; private static readonly string _AMSClientSecret = ConfigurationManager.AppSettings["AMSClientSecret"]; static void Main(string[] args) { AzureAdTokenCredentials tokenCredentials = new AzureAdTokenCredentials(_AADTenantDomain, new AzureAdClientSymmetricKey(_AMSClientId, _AMSClientSecret), AzureEnvironments.AzureCloudEnvironment); var tokenProvider = new AzureAdTokenProvider(tokenCredentials); _context = new CloudMediaContext(new Uri(_RESTAPIEndpoint), tokenProvider); // Load an MP4 file. IAsset asset = IngestSingleMP4File(_singleMP4File, AssetCreationOptions.None); // Encode an MP4 file to a set of multibitrate MP4s. // Then, package a set of MP4s to clear Smooth Streaming. IAsset clearSmoothStreamAsset = ConvertMP4ToMultibitrateMP4sToSmoothStreaming(asset); // Create a common encryption content key that is used // a) to set the key values in the MediaEncryptor_PlayReadyProtection.xml file // that is used for encryption. // b) to configure the license delivery service and // Guid keyId; byte[] contentKey; IContentKey key = CreateCommonEncryptionKey(out keyId, out contentKey); // The content key authorization policy must be configured by you // and met by the client in order for the PlayReady license // to be delivered to the client. // In this example the Media Services PlayReady license delivery service is used. ConfigureLicenseDeliveryService(key); // Get the Media Services PlayReady license delivery URL. // This URL will be assigned to the licenseAcquisitionUrl property // of the MediaEncryptor_PlayReadyProtection.xml file. Uri acquisitionUrl = key.GetKeyDeliveryUrl(ContentKeyDeliveryType.PlayReadyLicense); // Update the MediaEncryptor_PlayReadyProtection.xml file with the key and URL info. UpdatePlayReadyConfigurationXMLFile(keyId, contentKey, acquisitionUrl); // Create HLS encrypted with PlayReady. IAsset playReadyHLSAsset = CreateHLSEncryptedWithPlayReady(clearSmoothStreamAsset); // string hlsWithPlayReadyURL = playReadyHLSAsset.GetHlsUri().ToString(); Console.WriteLine("HLS with PlayReady URL:"); Console.WriteLine(hlsWithPlayReadyURL); } /// <summary> /// Creates a job with 2 tasks: /// 1 task - encodes a single MP4 to multibitrate MP4s, /// 2 task - packages MP4s to Smooth Streaming. /// </summary> /// <returns>The output asset.</returns> public static IAsset ConvertMP4ToMultibitrateMP4sToSmoothStreaming(IAsset asset) { // Create a new job. IJob job = _context.Jobs.Create("Convert MP4 to Smooth Streaming."); // Add task 1 - Encode single MP4 into multibitrate MP4s. IAsset MP4sAsset = EncodeSingleMP4IntoMultibitrateMP4sTask(job, asset); // Add task 2 - Package a multibitrate MP4 set to Clear Smooth Streaming. IAsset packagedAsset = PackageMP4ToSmoothStreamingTask(job, MP4sAsset); // Submit the job and wait until it is completed. job.Submit(); job = job.StartExecutionProgressTask( j => { Console.WriteLine("Job state: {0}", j.State); Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); }, CancellationToken.None).Result; // Get the output asset that contains Smooth Streaming. return job.OutputMediaAssets[1]; } /// <summary> /// Create a common encryption content key that is used /// to set the key values in the MediaEncryptor_PlayReadyProtection.xml file /// that is used for encryption. /// </summary> /// <param name="keyId"></param> /// <param name="contentKey"></param> /// <returns></returns> public static IContentKey CreateCommonEncryptionKey(out Guid keyId, out byte[] contentKey) { keyId = Guid.NewGuid(); contentKey = GetRandomBuffer(16); IContentKey key = _context.ContentKeys.Create( keyId, contentKey, "ContentKey", ContentKeyType.CommonEncryption); return key; } /// <summary> /// Update your configuration .xml file dynamically. /// </summary> public static void UpdatePlayReadyConfigurationXMLFile(Guid keyId, byte[] keyValue, Uri licenseAcquisitionUrl) { string xmlFileName = Path.Combine(_configurationXMLFiles, @"MediaEncryptor_PlayReadyProtection.xml"); XNamespace xmlns = "http://schemas.microsoft.com/iis/media/v4/TM/TaskDefinition#"; // Prepare the encryption task template XDocument doc = XDocument.Load(xmlFileName); var licenseAcquisitionUrlEl = doc .Descendants(xmlns + "property") .Where(p => p.Attribute("name").Value == "licenseAcquisitionUrl") .FirstOrDefault(); var contentKeyEl = doc .Descendants(xmlns + "property") .Where(p => p.Attribute("name").Value == "contentKey") .FirstOrDefault(); var keyIdEl = doc .Descendants(xmlns + "property") .Where(p => p.Attribute("name").Value == "keyId") .FirstOrDefault(); // Update the "value" property. if (licenseAcquisitionUrlEl != null) licenseAcquisitionUrlEl.Attribute("value").SetValue(licenseAcquisitionUrl.ToString()); if (contentKeyEl != null) contentKeyEl.Attribute("value").SetValue(Convert.ToBase64String(keyValue)); if (keyIdEl != null) keyIdEl.Attribute("value").SetValue(keyId); doc.Save(xmlFileName); } /// <summary> // Encrypts clear Smooth Streaming to Smooth Streaming with PlayReady. // Then, packages the PlayReady Smooth Streaming to HLS with PlayReady. /// </summary> /// <param name="clearSmoothAsset">Asset that contains clear Smooth Streaming.</param> /// <returns>The output asset.</returns> public static IAsset CreateHLSEncryptedWithPlayReady(IAsset clearSmoothStreamAsset) { IJob job = _context.Jobs.Create("Encrypt to HLS with PlayReady."); // Add task 1 - Encrypt Smooth Streaming with PlayReady IAsset encryptedSmoothAsset = EncryptSmoothStreamWithPlayReadyTask(job, clearSmoothStreamAsset); // Add task 2 - Package to HLS with PlayReady. PackageSmoothStreamToHLS(job, encryptedSmoothAsset); // Submit the job and wait until it is completed. job.Submit(); job = job.StartExecutionProgressTask( j => { Console.WriteLine("Job state: {0}", j.State); Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); }, CancellationToken.None).Result; // Since we had two tasks, the OutputMediaAssets[1] // contains the desired asset. _context.Locators.Create( LocatorType.OnDemandOrigin, job.OutputMediaAssets[1], AccessPermissions.Read, TimeSpan.FromDays(30)); return job.OutputMediaAssets[1]; } /// <summary> /// Uploads a single file. /// </summary> /// <param name="fileDir">The location of the files.</param> /// <param name="assetCreationOptions"> /// You can specify the following encryption options for the AssetCreationOptions. /// None: no encryption. /// StorageEncrypted: storage encryption. Encrypts a clear input file /// before it is uploaded to Azure storage. /// CommonEncryptionProtected: for Common Encryption Protected (CENC) files. /// For example, a set of files that are already PlayReady encrypted. /// EnvelopeEncryptionProtected: for HLS with AES encryption files. /// NOTE: The files must have been encoded and encrypted by Transform Manager. /// </param> /// <returns>Returns an asset that contains a single file.</returns> /// </summary> /// <returns></returns> private static IAsset IngestSingleMP4File(string fileDir, AssetCreationOptions assetCreationOptions) { // Use the SDK extension method to create a new asset by // uploading a mezzanine file from a local path. IAsset asset = _context.Assets.CreateFromFile( fileDir, assetCreationOptions, (af, p) => { Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress); }); return asset; } /// <summary> /// Creates a task to encode to Adaptive Bitrate. /// Adds the new task to a job. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset EncodeSingleMP4IntoMultibitrateMP4sTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Media Encoder Standard. IMediaProcessor encoder = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.MediaEncoderStandard); ITask adaptiveBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task", encoder, "Adaptive Streaming", TaskOptions.None); // Specify the input Asset adaptiveBitrateTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset abrAsset = adaptiveBitrateTask.OutputAssets.AddNew("Multibitrate MP4s", AssetCreationOptions.None); return abrAsset; } /// <summary> /// Creates a task to convert the MP4 file(s) to a Smooth Streaming asset. /// Adds the new task to a job. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset PackageMP4ToSmoothStreamingTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor packager = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaPackager); // Azure Media Packager does not accept string presets, so load xml configuration string smoothConfig = File.ReadAllText(Path.Combine( _configurationXMLFiles, "MediaPackager_MP4toSmooth.xml")); // Create a new Task to convert adaptive bitrate to Smooth Streaming. ITask smoothStreamingTask = job.Tasks.AddNew("MP4 to Smooth Task", packager, smoothConfig, TaskOptions.None); // Specify the input Asset, which is the output Asset from the first task smoothStreamingTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.None, which // means the output asset is in the clear (unencrypted). IAsset smoothOutputAsset = smoothStreamingTask.OutputAssets.AddNew("Clear Smooth Streaming", AssetCreationOptions.None); return smoothOutputAsset; } /// <summary> /// Converts Smooth Stream to HLS. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The Smooth Stream asset.</param> /// <returns>The asset that was packaged to HLS.</returns> private static IAsset PackageSmoothStreamToHLS(IJob job, IAsset smoothStreamAsset) { // Get the SDK extension method to get a reference to the Azure Media Packager. IMediaProcessor processor = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaPackager); // Read the configuration data into a string. // string configuration = File.ReadAllText( Path.Combine(_configurationXMLFiles, @"MediaPackager_SmoothToHLS.xml")); // Create a task with the encoding details, using a configuration file. ITask task = job.Tasks.AddNew("My Smooth to HLS Task", processor, configuration, TaskOptions.ProtectedConfiguration); // Specify the input asset to be encoded. task.InputAssets.Add(smoothStreamAsset); // Add an output asset to contain the results of the job. IAsset outputAsset = task.OutputAssets.AddNew("HLS asset", AssetCreationOptions.None); return outputAsset; } /// <summary> /// Creates a task to encrypt Smooth Streaming with PlayReady. /// Note: Do deliver DASH, make sure to set the useSencBox and adjustSubSamples /// configuration properties to true. /// </summary> /// <param name="job">The job to which to add the new task.</param> /// <param name="asset">The input asset.</param> /// <returns>The output asset.</returns> private static IAsset EncryptSmoothStreamWithPlayReadyTask(IJob job, IAsset asset) { // Get the SDK extension method to get a reference to the Azure Media Encryptor. IMediaProcessor playreadyProcessor = _context.MediaProcessors.GetLatestMediaProcessorByName( MediaProcessorNames.WindowsAzureMediaEncryptor); // Read the configuration XML. // // Note that the configuration defined in MediaEncryptor_PlayReadyProtection.xml // is using keySeedValue. It is recommended that you do this only for testing // and not in production. For more information, see // https://msdn.microsoft.com/library/windowsazure/dn189154.aspx. // string configPlayReady = File.ReadAllText(Path.Combine(_configurationXMLFiles, @"MediaEncryptor_PlayReadyProtection.xml")); ITask playreadyTask = job.Tasks.AddNew("My PlayReady Task", playreadyProcessor, configPlayReady, TaskOptions.ProtectedConfiguration); playreadyTask.InputAssets.Add(asset); // Add an output asset to contain the results of the job. // This output is specified as AssetCreationOptions.CommonEncryptionProtected. IAsset playreadyAsset = playreadyTask.OutputAssets.AddNew( "PlayReady Smooth Streaming", AssetCreationOptions.CommonEncryptionProtected); return playreadyAsset; } /// <summary> /// Configures authorization policy for the content key. /// </summary> /// <param name="contentKey">The content key.</param> static public void ConfigureLicenseDeliveryService(IContentKey contentKey) { // Create ContentKeyAuthorizationPolicy with Open restrictions // and create authorization policy List<ContentKeyAuthorizationPolicyRestriction> restrictions = new List<ContentKeyAuthorizationPolicyRestriction> { new ContentKeyAuthorizationPolicyRestriction { Name = "Open", KeyRestrictionType = (int)ContentKeyRestrictionType.Open, Requirements = null } }; // Configure PlayReady license template. string newLicenseTemplate = ConfigurePlayReadyLicenseTemplate(); IContentKeyAuthorizationPolicyOption policyOption = _context.ContentKeyAuthorizationPolicyOptions.Create("", ContentKeyDeliveryType.PlayReadyLicense, restrictions, newLicenseTemplate); IContentKeyAuthorizationPolicy contentKeyAuthorizationPolicy = _context. ContentKeyAuthorizationPolicies. CreateAsync("Deliver Common Content Key with no restrictions"). Result; contentKeyAuthorizationPolicy.Options.Add(policyOption); // Associate the content key authorization policy with the content key. contentKey.AuthorizationPolicyId = contentKeyAuthorizationPolicy.Id; contentKey = contentKey.UpdateAsync().Result; } static private string ConfigurePlayReadyLicenseTemplate() { // The following code configures PlayReady License Template using .NET classes // and returns the XML string. PlayReadyLicenseResponseTemplate responseTemplate = new PlayReadyLicenseResponseTemplate(); PlayReadyLicenseTemplate licenseTemplate = new PlayReadyLicenseTemplate(); responseTemplate.LicenseTemplates.Add(licenseTemplate); return MediaServicesLicenseTemplateSerializer.Serialize(responseTemplate); } static private byte[] GetRandomBuffer(int length) { var returnValue = new byte[length]; using (var rng = new System.Security.Cryptography.RNGCryptoServiceProvider()) { rng.GetBytes(returnValue); } return returnValue; } } }

Additional notes

  • Widevine is a service provided by Google Inc. and subject to the terms of service and Privacy Policy of Google, Inc.

Videos

1. Best practices for Azure Container Instances (ACI) with GitHub Actions | Azure Friday
(Microsoft Azure)
2. Azure Media Services
(Azure Power Lunch)
3. Azure Table Storage Tutorial | Easy and scalable NoSQL database
(Adam Marczak - Azure for Everyone)
4. Azure DevOps Tutorial for Beginners | CI/CD with Azure Pipelines
(TechWorld with Nana)
5. Azure Master Class v2 - Module 2 - Identity
(John Savill's Technical Training)
6. Disaster Recovery in Microsoft Azure
(John Savill's Technical Training)
Top Articles
Latest Posts
Article information

Author: Eusebia Nader

Last Updated: 11/06/2022

Views: 5259

Rating: 5 / 5 (60 voted)

Reviews: 91% of readers found this page helpful

Author information

Name: Eusebia Nader

Birthday: 1994-11-11

Address: Apt. 721 977 Ebert Meadows, Jereville, GA 73618-6603

Phone: +2316203969400

Job: International Farming Consultant

Hobby: Reading, Photography, Shooting, Singing, Magic, Kayaking, Mushroom hunting

Introduction: My name is Eusebia Nader, I am a encouraging, brainy, lively, nice, famous, healthy, clever person who loves writing and wants to share my knowledge and understanding with you.