(0) exportieren Drucken
Alle erweitern
Dieser Artikel wurde noch nicht bewertet - Dieses Thema bewerten.

Schützen von Smooth Stream und MPEG DASH mit PlayReady

Letzte Aktualisierung: Februar 2014

Bei der Arbeit mit Media Services ist eines der gängigen Szenarien:

  1. Hochladen einer Eingabedatei (Zwischendatei genannt). Zum Beispiel H.265, MP4 oder WMV (die Liste der unterstützten Formate finden Sie unter Von Media Services Encoder unterstützte Formate).

  2. Codieren der Zwischendatei zu einer Sammlung von MP4-Dateien mit mehreren Bitraten.

  3. Packen der MP4-Dateien mit mehreren Bitraten zu Smooth Stream.

  4. Verschlüsseln von Smooth Stream.

  5. Erstellen eines on Demand-Locators, der einen Link zu einem Medienobjekt auf dem Server bereitstellt. Dann Erstellen einer vollständigen URL. Im Falle von Smooth Streaming: {media services account name}.origin.mediaservices.net/{locator ID}/{filename}.ism/Manifest. Im Falle von MPEG DASH: {media services account name}.origin.mediaservices.net/{locator ID}/{filename}.ism/Manifest(format=mpd-time-csf) .

Im Beispiel in diesesm Thema wird eine Zwischendatei (in diesem Fall MP4) in MP4-Dateien mit mehreren Bitraten codiert. Danach werden die MP4-Dateien in Smooth Stream gepackt und Smooth Stream dann mit PlayReady codiert. Als Ergebnis können Sie Smooth Streaming von MPEG DASH streamen.

noteHinweis
Zum Schützen Ihres Inhalts mithilfe von PlayReady müssen Sie zuerst Ihren Inhalt zu einem Smooth Streaming-Format konvertieren/codieren.

noteHinweis
Zurzeit können Sie die dynamische Paketerstellung nicht verwenden, um Smooth Streaming oder durch PlayReady verschlüsseltes HLS zu übermitteln. Sie können die dynamische Paketerstellung verwenden, um mit PlayReady verschlüsseltes MPEG DASH zu übermitteln.

Damit Sie dynamische Paketerstellung nutzen können, müssen Sie zuerst mindestens eine reservierte Streamingeinheit on Demand abrufen. Weitere Informationen finden Sie unter Skalieren eines Mediendiensts.

Sie können das folgende Projekt herunterladen, das den in diesem Beispiel gezeigten Code und vieles mehr enthält: Media Services-Inhaltsschutz.

Einrichten Ihres Projekts

  1. Installation für die Entwicklung mit dem Media Services SDK für .NET

    Beachten Sie, dass bei diesem Beispiel Windows Azure Media Services .NET SDK-Erweiterungen verwendet werden. Die Media Services .NET SDK-Erweiterungen sind eine Sammlung von Erweiterungsmethoden und Hilfsfunktionen, die Ihren Code vereinfachen und die Entwicklung mit Media Services erleichtern.

  2. Herstellen einer Verbindung mit Media Services mit dem Media Services SDK

Erstellen von mit PlayReady verschlüsseltem Smooth Streaming und MPEG DASH

  1. Überschreiben Sie den Code in Ihrer Datei Program.cs mit dem im example-Abschnitt gezeigten Code.

    Stellen Sie sicher, dass der folgende Code so aktualisiert wird, dass er auf den Ordner zeigt, in dem sich Ihre MP4-Eingabedatei befindet.

    Und auch darauf, wo sich Ihre Dateien MediaPackager_MP4ToSmooth.xml und MediaEncryptor_PlayReadyProtection.xml befinden. MediaPackager_MP4ToSmooth.xml wird im Thema Vordefinierte Einstellungen für Aufgaben für Windows Azure Media Packager und MediaEncryptor_PlayReadyProtection.xml wird im Thema Vordefinierte Einstellungen für Aufgaben für Windows Azure Media Encryptor definiert.

    noteHinweis
    Stellen Sie zum Streamen von mit PlayReady verschlüsseltem MPEG DASH sicher, dass die Eigenschaften useSencBox und adjustSubSamples der MediaEncryptor_PlayReadyProtection.xml-Konfiguration auf true festgelegt sind.

    private static readonly string _mediaFiles =
    Path.GetFullPath(@"../..\Media");
    
    private static readonly string _singleMP4File =
         Path.Combine(_mediaFiles, @"SingleMP4\BigBuckBunny.mp4");
    
    // XML Configruation files path.
    private static readonly string _configurationXMLFiles = @"../..\Configurations\";
    
    
  2. Erstellen und Ausführen Ihres Programms.

Beispiel

Das Beispiel führt Folgendes aus:

  1. Erfassen einer einzigen MP4-Datei.

  2. Verschlüsseln der MP4-Datei in MP4-Dateien mit mehreren Bitraten mithilfe der "H264 Adaptive Bitrate MP4 Set 720p",Encoder-Voreinstellung. Dann verpacken der MP4-Dateien mit mehreren Bitraten in Smooth Streaming. Die Konfigurationen MediaPackager_MP4ToSmooth.xml und MediaPackager_SmoothToHLS.xml werden für diese Paketerstellungsaufgaben verwendet.

  3. Verschlüsseln von Smooth Stream mit PlayReady. Die Konfiguration MediaEncryptor_PlayReadyProtection.xml wird für diese Aufgabe verwendet.

    noteHinweis
    Im Beispiel wird die UpdatePlayReadyConfigurationXMLFile-Methode definiert, die Sie zur Aktualisierung der MediaEncryptor_PlayReadyProtection.xml-Datei verwenden können.

  4. Erstellen des OnDemand-Locators und Abrufen der Streaming-URL.

    Die Erweiterungsmethoden GetSmoothStreamingUri und GetMpegDashUri geben die Streaming-URLs in folgender Form zurück: {media services account name}.origin.mediaservices.net/{locator ID}/{filename}.ism/Manifest für Smooth Streaming und {media services account name}.origin.mediaservices.net/{locator ID}/{filename}.ism/Manifest(format=mpd-time-csf)  für MPEG DASH.

    Sie können den http://smf.cloudapp.net/healthmonitor-Player verwenden, um Smooth Streaming zu testen. Sie können dashif.org verwenden, um den DASH-Datenstrom zu testen (wählen Sie die neueste Version des Players).

Weitere Einzelheiten finden Sie in den Codekommentaren.

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;

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 Configruation files path.
        private static readonly string _configurationXMLFiles = @"../..\Configurations\";


        private static MediaServicesCredentials _cachedCredentials = null;
        private static CloudMediaContext _context = null;

        // Media Services account information.
        private static readonly string _mediaServicesAccountName = 
            ConfigurationManager.AppSettings["MediaServiceAccountName"];
        private static readonly string _mediaServicesAccountKey = 
            ConfigurationManager.AppSettings["MediaServiceAccountKey"];

        static void Main(string[] args)
        {
            // Create and cache the Media Services credentials in a static class variable.
            _cachedCredentials = new MediaServicesCredentials(
                            _mediaServicesAccountName, 
                            _mediaServicesAccountKey);
            // Used the chached credentials to create CloudMediaContext.
            _context = new CloudMediaContext(_cachedCredentials);

            // 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 Stream.
            IAsset clearSmoothStreamAsset = 
                ConvertMP4ToMultibitrateMP4sToSmoothStreaming(asset);

            // Encrypt your clear Smooth Stream to Smooth Stream 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 singe MP4 to multibitrate MP4s,
        /// 2 task - packages MP4s to Smooth Stream.
        /// </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 stream.
            return job.OutputMediaAssets[1];
        }

        /// <summary>
        /// Encrypts Smooth Stream with PlayReady.
        /// Then creates a Smooth Streaming Url.
        /// </summary>
        /// <param name="clearSmoothAsset">Asset that contains a clear Smooth Stream.</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>
        /// Update your configuration .xml file dynamically.
        /// </summary>
        public static void UpdatePlayReadyConfigurationXMLFile(string keyDeliveryServiceUriStr)
        {
            Guid keyId = Guid.NewGuid();
            byte[] keyValue = GetRandomBuffer(16);
            Uri keyDeliveryServiceUri = 
                new Uri(keyDeliveryServiceUriStr);

            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 for each element.
            if (licenseAcquisitionUrlEl != null)
                licenseAcquisitionUrlEl.Attribute("value").SetValue(keyDeliveryServiceUri);

            if (contentKeyEl != null)
                contentKeyEl.Attribute("value").SetValue(Convert.ToBase64String(keyValue));

            if (keyIdEl != null)
                keyIdEl.Attribute("value").SetValue(keyId);

            doc.Save(xmlFileName);
        }

        private static byte[] GetRandomBuffer(int length)
        {
            var returnValue = new byte[length];

            using (var rng = 
                new System.Security.Cryptography.RNGCryptoServiceProvider())
            {
                rng.GetBytes(returnValue);
            }

            return returnValue;
        }

        /// <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 Windows Azure Media Encoder.
            IMediaProcessor encoder = _context.MediaProcessors.GetLatestMediaProcessorByName(
                MediaProcessorNames.WindowsAzureMediaEncoder);

            ITask adpativeBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task",
               encoder,
               "H264 Adaptive Bitrate MP4 Set 720p",
               TaskOptions.None);

            // Specify the input Asset
            adpativeBitrateTask.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 = adpativeBitrateTask.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 Windows Azure Media Packager.
            IMediaProcessor packager = _context.MediaProcessors.GetLatestMediaProcessorByName(
                MediaProcessorNames.WindowsAzureMediaPackager);

            // Windows 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 Stream 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 Windows 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 
            // http://msdn.microsoft.com/en-us/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;
        }
    }
}

Siehe auch


Erstellungsdatum:

2014-04-09
Fanden Sie dies hilfreich?
(1500 verbleibende Zeichen)
Vielen Dank für Ihr Feedback.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft. Alle Rechte vorbehalten.