(0) exportieren Drucken
Alle erweitern

Schnelleinstieg: Verwenden des Media Services .NET SDKs

Letzte Aktualisierung: Februar 2014

Dieses Thema stellt exemplarische Vorgehensweisen für Microsoft Azure Media Services für neue Entwickler zur Verfügung. Es stellt den grundlegenden Mediendienste-Workflow und die gängigsten Programmierobjekte und -aufgaben vor, die für die Mediendienste-Entwicklung erforderlich sind. Lesen Sie Azure Media Services – Übersicht, um sich über die Grundlagen des Mediendienste-Entwicklungsvorgangs und das Programmierobjektmodell zu informieren.

Ein C# Visual Studio-Projekt, das den Code für dieses Lernprogramm enthält, ist hier verfügbar: Herunterladen

Diese Anleitung demonstriert Folgendes:

noteHinweis
Beispiel

TipTipp
Außerdem haben Sie die Wahl, Azure Media Services .NET SDK-Erweiterungen für die Ausführung der in diesem Thema beschriebenen Aufgaben zu verwenden. Die Mediendienste .NET SDK-Erweiterungen sind eine Sammlung von Erweiterungsmethoden und Hilfsfunktionen, die Ihren Code vereinfachen und die Entwicklung mit Mediendienste erleichtern. Weitere Informationen finden Sie unter Schnelleinstieg: Verwenden von Media Services .NET SDK-Erweiterungen.

Die folgenden Voraussetzungen sind für die exemplarischen Vorgehensweisen und für die Entwicklung basierend auf dem Microsoft Azure Media Services SDK erforderlich.

  • Ein Mediendienste-Konto in einem neuen oder vorhandenen Azure-Abonnement. Lesen Sie hierzu das Thema Erstellen eines Media Services-Kontos.

  • Betriebssysteme: Windows 7, Windows 2008 R2 oder Windows 8.

  • .NET Framework 4.5 oder .NET Framework 4.

  • Visual Studio 2013, Visual Studio 2012 oder Visual Studio 2010 SP1 (Professional, Premium, Ultimate oder Express).

  1. Erstellen Sie eine neue C#-Konsolenanwendung in Visual Studio 2013, Visual Studio 2012 oder Visual Studio 2010 SP1. Geben Sie die Angaben Name, Speicherort und Projektname ein, und klicken Sie dann auf OK.

  2. Fügen Sie Verweise auf Mediendienste und davon abhängige DLLs hinzu.

    Das Mediendienste SDK weist eine Abhängigkeit mit mehreren Bibliotheken auf (z. B. mit Azure Storage SDK for .NET und WCF Data Services for OData). Sie können windowsazure.mediaservices NuGet zum Installieren und Hinzufügen des Mediendienste SDKs zu Ihrem Projekt verwenden. In diesem Fall werden alle Abhängigkeiten installiert und Ihrem Projekt automatisch hinzugefügt.

    Alternativ können Sie auch die Aktuellste Version des Mediendienste SDKs von GitHub abrufen, das Projekt erstellen und die Verweise dann dem Clientprojekt hinzufügen. Beachten Sie, dass alle erforderlichen Abhängigkeiten automatisch heruntergeladen und extrahiert werden.

    Mit beiden Methoden müssen Sie Abhängigkeiten nicht manuell herunterladen.

    Gehen Sie folgendermaßen vor, um erforderliche Verweise mithilfe des windowsazure.mediaservices-NuGet-Pakets hinzuzufügen.

    1. Stellen Sie sicher, dass die aktuellste Version von NuGet installiert ist.

      Weitere Informationen sowie Installationsanweisungen finden Sie unter NuGet.

    2. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Namen des Projekts, und wählen Sie dann NuGet-Pakete verwalten aus.

      Das Dialogfeld NuGet-Pakete verwalten wird angezeigt.

    3. Suchen Sie im Onlinekatalog nach dem Eintrag MediaServices, wählen Sie Azure Media Services .NET SDK aus, und klicken Sie dann auf die Schaltfläche Install.

      Das Projekt wird geändert, und Verweise auf die Media Services-Assemblys werden hinzugefügt.

    4. Wenn Sie eine möglichst saubere Entwicklerumgebung bereitstellen möchten, können Sie wahlweise NuGet Package Restore aktivieren. Weitere Informationen finden Sie unter NuGet-Paketwiederherstellung.

  3. Hinzufügen eines Verweises auf die System.Configuration .NET-Assembly.

    Gehen Sie folgendermaßen vor, um mithilfe des Dialogfelds Verweise verwalten Verweise hinzuzufügen:

    1. Klicken Sie im Projektmappen-Explorer mit der rechten Maustaste auf den Projektnamen. Wählen Sie danach Hinzufügen und Verweise.

      Das Dialogfeld Verweise verwalten wird angezeigt.

    2. Suchen Sie und wählen Sie die System.Configuration-Assembly aus den .NET Framework-Assemblys.

    3. Drücken Sie auf OK.

  4. Fügen Sie der Datei app.config einen appSettings-Abschnitt hinzu und geben Sie dann Ihren Mediendienste-Kontonamen und -Kontoschlüssel ein. Sie haben den Mediendienste-Kontonamen und -schlüssel während des Einrichtungsvorgangs des Kontos abgerufen.

    noteHinweis
    In Visual Studio 2013 und Visual Studio 2012 wird die Datei App.config standardmäßig hinzugefügt. In Visual Studio 2010 müssen Sie die Anwendungskonfigurationsdatei manuell hinzufügen.

    TipTipp
    Wenn Sie diese Namen- und Schlüsselwerte ermitteln möchten, navigieren Sie zum Azure-Portal, wählen Sie Ihr Media Services-Konto aus, und klicken Sie dann unten im Portalfenster auf das Symbol "SCHLÜSSEL VERWALTEN". Wenn Sie auf das Symbol neben jedem Textfeld klicken, wird der Wert in die Zwischenablage des Systems kopiert.

    <?xml version="1.0"?>
    <configuration>
      <appSettings>
          <add key="MediaServicesAccountName" value="YouMediaServicesAccountName" />
          <add key="MediaServicesAccountKey" value="YouMediaServicesAccountKey" />
      </appSettings>
    </configuration>
    
  5. Erstellen Sie einen Ordner auf Ihrem lokalen Computer und kopieren Sie eine .wmv- und .mp4-Dateien in diesen Ordner. In diesem Beispiel wird davon ausgegangen, dass der Ordner Media heißt und sich unterhalb des MediaServicesGettingStarted-Projektordners befindet. Das zugehörige Project zu dieser Anleitung enthält einen Media-Ordner mit einer .wmv- und .mp4-Dateien.

  6. Überschreiben Sie die vorhandenen using-Anweisungen am Anfang der Datei Program.cs mit dem folgenden Code:

    using System;
    using System.Linq;
    using System.Configuration;
    using System.IO;
    using System.Text;
    using System.Threading;
    using System.Threading.Tasks;
    using System.Collections.Generic;
    using Microsoft.WindowsAzure;
    using Microsoft.WindowsAzure.MediaServices.Client;
    

Um sich programmgesteuert mit Media Services verbinden zu können, müssen Sie zuvor ein Azure-Konto einrichten und Media Services für dieses Konto konfigurieren. Das folgende Thema beschreibt den Verbindungsaufbau mit einem Media Services-Konto: Herstellen einer Verbindung mit Media Services mit dem Media Services SDK.

Der folgende Code zeigt, wie Sie die Verbindungswerte aus der Datei App.config lesen und das CloudMediaContext-Objekt für die Verbindung mit Media Services erstellen können.

  1. Ersetzen Sie die Standard-Programmklassendefinition durch den folgenden Code.

    class Program
    {
        // Read values from the App.config file.
        private static readonly string _mediaServicesAccountName = 
            ConfigurationManager.AppSettings["MediaServicesAccountName"];
        private static readonly string _mediaServicesAccountKey =
            ConfigurationManager.AppSettings["MediaServicesAccountKey"];
    
        // Field for service context.
        private static CloudMediaContext _context = null;
        private static MediaServicesCredentials _cachedCredentials = null;
    
        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);
           . . .
        }
    }
    
    
    
noteHinweis
Beispiel

Der Code in diesem Abschnitt führt die folgenden Aufgaben aus:

  1. Erstellen eines leeren Medienobjekts

    Wenn Sie Medienobjekte erstellen, können Sie drei verschiedene Optionen für deren Verschlüsselung angeben.

    • AssetCreationOptions.None. Wählen Sie diese Option aus, wenn Sie Ihr Medienobjekt nicht verschlüsseln möchten.

    • AssetCreationOptions.CommonEncryptionProtected. Verwenden Sie diese Option für Common Encryption Protected (CENC)-Dateien. Ein Beispiel ist ein Satz von Dateien, die bereits mit PlayReady verschlüsselt sind.

    • AssetCreationOptions.StorageEncrypted. Verschlüsselt eine unverschlüsselte Eingabedatei vor dem Hochladen in den Azure-Speicher.

      noteHinweis
      Beachten Sie, dass Mediendienste Speicherverschlüsselung auf dem Datenträger und nicht über das Netzwerk wie bei der Verwaltung digitaler Rechte (DRM) bereitstellt.

  2. Erstellt eine AssetFile-Instanz, der wir in den Speicher hochladen und zum Medienobjekt zuweisen werden.

  3. Erstellen einer AccessPolicy-Instanz, die die Zugriffsberechtigungen für und die Zugriffsdauer auf das Medienobjekt definiert.

  4. Erstellt eine SAS Locator-Instanz, die Zugriff auf das Medienobjekt bietet.

  5. Lädt eine einzelne Mediendatei in Mediendienste hoch. Der Vorgang des Erstellens und Hochladens wird auch als "Erfasssen von Medienobjekten" bezeichnet.

static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
{
    var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
    var asset = CreateEmptyAsset(assetName, assetCreationOptions);

    var fileName = Path.GetFileName(singleFilePath);

    var assetFile = asset.AssetFiles.Create(fileName);

    Console.WriteLine("Created assetFile {0}", assetFile.Name);

    var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
                                                        AccessPermissions.Write | AccessPermissions.List);

    var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);

    Console.WriteLine("Upload {0}", assetFile.Name);

    assetFile.Upload(singleFilePath);
    Console.WriteLine("Done uploading {0}", assetFile.Name);

    locator.Delete();
    accessPolicy.Delete();

    return asset;
}

static private IAsset CreateEmptyAsset(string assetName, AssetCreationOptions assetCreationOptions)
{
    var asset = _context.Assets.Create(assetName, assetCreationOptions);

    Console.WriteLine("Asset name: " + asset.Name);
    Console.WriteLine("Time created: " + asset.Created.Date.ToString());

    return asset;
}

noteHinweis
Beispiel

In Mediendienste können Sie Aufträge erstellen, die Medieninhalte auf verschiedene Weise verarbeiten: Codierung, Verschüsselung, Ausführen von Formatkonvertierungen usw. Ein Mediendienste-Auftrag enthält immer mindestens eine Aufgabe, die die Details der Verarbeitung angibt. In diesem Abschnitt definieren Sie eine Methode, die eine einzelne Codierungs-Aufgabe erstellt und anschließend einen Auftrag ausführt, der die Aufgabe mithilfe von Azure Media Encoder ausführt. Die Aufgabe verwendet eine vordefinierte Zeichenfolge, um den auszuführenden Codierungstyp anzugeben. Die verfügbaren vordefinierten Codierungswerte finden Sie unter Systemvoreinstellungenvon Media Services Encoder. Mediendienste unterstützt die gleichen Mediendatei-Eingabe- und -Ausgabeformate wie Microsoft Expression Encoder. Eine Liste der unterstützter Formate finden Sie unter Supported File Types for Media Services.

  1. Fügen Sie Ihrer Klasse die folgende CreateEncodingJob-Methodendefinition hinzu. Diese Methode führt mehrere erforderliche Schritte für einen Codierungsauftrag aus:

    • Deklarieren eines neuen Auftrags.

    • Deklarieren eines Medienprozessors für die Verarbeitung des Auftrags. Ein Medienprozessor ist eine Komponente, die die Codierung, Verschlüsselung, Formatkonvertierung und weitere in Beziehung stehende Verarbeitungsaufträge übernimmt. Es sind mehrere Medienprozessortypen verfügbar (Sie können durch diese mithilfe von _context.MediaProcessors iterieren). Die Methode GetLatestMediaProcessorByName, die später in dieser exemplarischen Vorgehensweise vorgestellt wird, gibt den Azure Media Encoder-Prozessor zurück.

    • Deklarieren einer neuen Aufgabe. Jeder Auftrag besitzt mindestens eine Aufgabe. Beachten Sie, dass mit der Aufgabe ein Anzeigename, eine Medienprozessorinstanz, eine Aufgaben-Konfigurationszeichenfolge und Aufgabenerstellungsoptionen übergeben werden. Die Konfigurationszeichenfolge gibt Codierungseinstellungen an. Die Einstellung H264 Broadband 720p produziert z. B. eine einzige MP4-Datei. Weitere Informationen zu dieser und anderen vordefinierten Einstellungen finden Sie unter Systemvoreinstellungenvon Media Services Encoder.

    • Fügen Sie der Aufgabe ein Eingabemedienobjekt hinzu. In diesem Beispiel handelt es sich bei dem Eingabemedienobjekt um das Medienobjekt, das Sie im vorherigen Abschnitt erstellt haben.

    • Fügen Sie der Aufgabe ein Ausgabemedienobjekt hinzu. Geben Sie für ein Ausgabemedienobjekt einen Anzeigenamen, einen booleschen Wert für das Speichern der Ausgabe auf dem Server nach Auftragsabschluss und einen Wert AssetCreationOptions.None an, um anzugeben, dass die Ausgabe für die Speicherung und den Transport nicht verschlüsselt wird.

    • Übermitteln des Auftrags.

      Das Übermitteln des Auftrags ist der letzte erforderliche Schritt für einen Codierungsauftrag.



    Die Methode führt noch weitere sinnvolle, jedoch optionale Aufgaben aus und kann den Auftragsstatus verfolgen und Auftragsdetails protokollieren.

    static public IAsset CreateEncodingJob(IAsset asset, string preset)
    {
        // Declare a new job.
        IJob job = _context.Jobs.Create(preset + " encoding job");
        // Get a media processor reference, and pass to it the name of the 
        // processor to use for the specific task.
        IMediaProcessor processor = GetLatestMediaProcessorByName("Azure Media Encoder");
    
        // Create a task with the encoding details, using a string preset.
        ITask task = job.Tasks.AddNew(preset + " encoding task",
            processor,
            preset, 
            Microsoft.WindowsAzure.MediaServices.Client.TaskOptions.ProtectedConfiguration);
    
        // Specify the input asset to be encoded.
        task.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 not encrypted. 
        task.OutputAssets.AddNew("Output asset",
            AssetCreationOptions.None);
    
        // Use the following event handler to check job progress.  
        job.StateChanged += new
                EventHandler<JobStateChangedEventArgs>(StateChanged);
    
        // Launch the job.
        job.Submit();
    
        // Optionally log job details. This displays basic job details
        // to the console and saves them to a JobDetails-{JobId}.txt file 
        // in your output folder.
        LogJobDetails(job.Id);
    
        // Check job execution and wait for job to finish. 
        Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None);
        progressJobTask.Wait();
    
        // If job state is Error the event handling 
        // method for job progress should log errors.  Here we check 
        // for error state and exit if needed.
        if (job.State == JobState.Error)
        {
            throw new Exception("\nExiting method due to job error.");
        }
    
        return job.OutputMediaAssets[0];
    }
    
noteHinweis
Beispiel

Sie müssen einen OnDemandOrigin-Locator erstellen, um Dateien zu streamen. Ein Locator stellt einen Einstiegspunkt für den Zugriff auf die in einem Medienobjekt enthaltenen Dateien zur Verfügung. Media Services unterstützt zwei Locatortypen: OnDemandOrigin-Locators dienen zum Streamen von Medien (z. B., MPEG DASH, HLS oder Smooth Streaming), und Access Signature (SAS) URL-Locators dienen zum Download von Dateien.

Um die komplette URL zu generieren, erstellen Sie einen OnDemandOriginLocator und fügen das gewünschte Streaming-Format an. Beispiel:

 

Smooth Streaming

{media services account name}.origin.mediaservices.net/{locator ID}/{filename}.ism/Manifest

Sie können den http://smf.cloudapp.net/healthmonitor-Player verwenden, um Ihr Smooth Streaming zu testen.

DASH Live Profilmanifest mit Common Streaming Format-Medien

{media services account name}.origin.mediaservices.net/{locator ID}/{filename}.ism/Manifest(format=mpd-time-csf) 

Sie können den http://dashif.org/reference/players/javascript/-Player verwenden, um Ihr Smooth Streaming zu testen.

Apple HTTP Live Streaming (HLS)

{media services account name}.origin.mediaservices.net/{locator ID}/{filename}.ism/Manifest(format=m3u8-aapl)

Das folgende Beispiel zeigt die URLs für Smooth Streaming, HLS und DASH basierend auf dem Pfad des OnDemandOrigin-Locators.

http://test001.origin.mediaservices.windows.net/fecebb23-46f6-490d-8b70-203e86b0df58/BigBuckBunny.ism/Manifest
http://test001.origin.mediaservices.windows.net/fecebb23-46f6-490d-8b70-203e86b0df58/BigBuckBunny.ism/Manifest(format=m3u8-aapl)
http://test001.origin.mediaservices.windows.net/fecebb23-46f6-490d-8b70-203e86b0df58/BigBuckBunny.ism/Manifest(format=mpd-time-csf)

Weitere Informationen finden Sie unter Bereitstellen von Inhalten.

Die folgende Methode ruft die URL zum On-Demand-Ursprungsdiensts plus die Manifestdatei ab. Sobald Sie diese URL haben, können Sie die komplette Streaming-URL wie oben beschrieben generieren.

static public string GetStreamingOriginLocatorURL(IAsset assetToStream)
{
    // Get a reference to the streaming manifest file from the  
    // collection of files in the asset. 
    var theManifest =
                        from f in assetToStream.AssetFiles
                        where f.Name.EndsWith(".ism")
                        select f;

    // Cast the reference to a true IAssetFile type. 
    IAssetFile manifestFile = theManifest.First();

    // Create a 30-day readonly access policy. 
    IAccessPolicy policy = _context.AccessPolicies.Create("Streaming policy",
        TimeSpan.FromDays(30),
        AccessPermissions.Read);

    // Create a locator to the streaming content on an origin. 
    ILocator originLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, 
        assetToStream,
        policy,
        DateTime.UtcNow.AddMinutes(-5));

    // Display the base path to the streaming asset on the origin server.
    Console.WriteLine("Streaming asset base path on origin: ");
    Console.WriteLine(originLocator.Path);
    Console.WriteLine();

    // Create a full URL to the manifest file. 
    return originLocator.Path + manifestFile.Name;
}
noteHinweis
Beispiel

Sie müssen zunächst einen SAS-Locator erstellen, um Dateien auf Ihren Computer herunterzuladen. Ein Locator stellt einen Einstiegspunkt für den Zugriff auf die in einem Medienobjekt enthaltenen Dateien zur Verfügung. Media Services unterstützt zwei Locatortypen: OnDemandOrigin-Locators dienen zum Streamen von Medien (z. B., MPEG DASH, HLS oder Smooth Streaming), und Access Signature (SAS) URL-Locators dienen zum Download von Dateien. Um die URL zu generieren, müssen Sie den Dateinamen zwischen dem Host und der SAS-Signatur einbetten.

Das folgende Beispiel zeigt die URL basierend auf dem SAS-Locator:

https://test001.blob.core.windows.net/asset-ca7a4c3f-9eb5-4fd8-a898-459cb17761bd/BigBuckBunny.mp4?sv=2012-02-12&se=2014-05-03T01%3A23%3A50Z&sr=c&si=7c093e7c-7dab-45b4-beb4-2bfdff764bb5&sig=msEHP90c6JHXEOtTyIWqD7xio91GtVg0UIzjdpFscHk%3D

Weitere Informationen finden Sie unter Bereitstellen von Inhalten.

Die folgende Methode lädt Dateien in den angegebenen Ausgabeordner herunter.

static public IAsset DownloadAssetToLocal(IAsset asset, string outputFolder)
{
    IAccessPolicy accessPolicy = _context.AccessPolicies.Create("File Download Policy", TimeSpan.FromDays(30), AccessPermissions.Read);
    ILocator locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
    BlobTransferClient blobTransfer = new BlobTransferClient
    {
        NumberOfConcurrentTransfers = 10,
        ParallelTransferThreadCount = 10
    };

    Console.WriteLine("Files will be downloaded to:");
    Console.WriteLine("{0}", outputFolder);
    Console.WriteLine();

    var downloadTasks = new List<Task>();
    foreach (IAssetFile outputFile in asset.AssetFiles)
    {
        // Use the following event handler to check download progress.
        outputFile.DownloadProgressChanged += DownloadProgress;

        string localDownloadPath = Path.Combine(outputFolder, outputFile.Name);

        downloadTasks.Add(outputFile.DownloadAsync(Path.GetFullPath(localDownloadPath), blobTransfer, locator, CancellationToken.None));

        outputFile.DownloadProgressChanged -= DownloadProgress;
    }

    Task.WaitAll(downloadTasks.ToArray());

    return asset;
}

static private void DownloadProgress(object sender, DownloadProgressChangedEventArgs e)
{
    Console.WriteLine(string.Format("{0} % download progress. ", e.Progress));
}

noteHinweis
Beispiel

Dieser Abschnitt enthält den kompletten in diesem Thema besprochenen Code.

noteHinweis
  • Stellen Sie sicher, dass die folgenden Variablen auf die Ordner zeigen, in denen sich Ihre Eingabe (MP4 und WMV) befindet und in die Sie die Ausgabe schreiben möchten.

    private static readonly string _supportFiles =
        Path.GetFullPath(@"../..\Media");
    
    // 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 _singleWMVInputFilePath =
        Path.GetFullPath(_supportFiles + @"\interview1.wmv");
    
    private static readonly string _singleMP4InputFilePath =
        Path.GetFullPath(_supportFiles + @"\BigBuckBunny.mp4");
    
    private static readonly string _outputFilesFolder =
        Path.GetFullPath(_supportFiles + @"\OutputFiles");
    

using System;
using System.Linq;
using System.Configuration;
using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Generic;
using Microsoft.WindowsAzure;
using Microsoft.WindowsAzure.MediaServices.Client;
 
namespace MediaServicesGettingStarted
    {
    class Program
    {
        private static readonly string _supportFiles =
            Path.GetFullPath(@"../..\Media");

        // 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 _singleWMVInputFilePath =
            Path.GetFullPath(_supportFiles + @"\interview1.wmv");

        private static readonly string _singleMP4InputFilePath =
            Path.GetFullPath(_supportFiles + @"\BigBuckBunny.mp4");

        private static readonly string _outputFilesFolder =
            Path.GetFullPath(_supportFiles + @"\OutputFiles");
        // Read values from the App.config file.
        private static readonly string _mediaServicesAccountName = 
            ConfigurationManager.AppSettings["MediaServicesAccountName"];
        private static readonly string _mediaServicesAccountKey =
            ConfigurationManager.AppSettings["MediaServicesAccountKey"];

        // Field for service context.
        private static CloudMediaContext _context = null;
        private static MediaServicesCredentials _cachedCredentials = null;

        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);

            IAsset singleWMVAsset = CreateAssetAndUploadSingleFile(AssetCreationOptions.None, 
                _singleWMVInputFilePath);

            // EncodeToH264 creates a job with one task
            // that converts a mezzanine file (in this case interview1.wmv)
            // into an MP4 file (in this case, "H264 Broadband 720p").
            IAsset MP4Asset = CreateEncodingJob(singleWMVAsset, "H264 Broadband 720p");

            // BuildSasUrlForMP4File creates a SAS Locator
            // and builds the SAS Url that can be used to 
            // progressively download the MP4 file.
            string fullSASURL = BuildSasUrlForMP4File(MP4Asset);

            Console.WriteLine("Progressive download URL: {0}", fullSASURL);

            // Download all the files in the asset locally
            // (that includes the mainifest.xml file).
            DownloadAssetToLocal(MP4Asset, _outputFilesFolder);

            Console.WriteLine();

            IAsset singleMP4Asset = CreateAssetAndUploadSingleFile(AssetCreationOptions.None,
                                                     _singleMP4InputFilePath);
            // EncodeToAdaptiveBitrate creates a job with one task
            // that encodes a mezzanine file (in this case BigBuckBunny.mp4)
            // into an adaptive bitrate MP4 set (in this case, "H264 Adaptive Bitrate MP4 Set 720p").
            IAsset adaptiveBitrateAsset = CreateEncodingJob(singleMP4Asset, "H264 Adaptive Bitrate MP4 Set 720p");

            // Get the Streaming Origin Locator URL.
            string streamingURL = GetStreamingOriginLocatorURL(adaptiveBitrateAsset);

            // Add Smooth Streaming, HLS, and DASH format to the streaming URL.  
            // NOTE: To be able to play these streams based on the 
            // adaptiveBitrateAsset asset, you MUST have at least one
            // On-demand Streaming reserved unit. 
            // For more information, see: 
            //    Dynamic Packaging (http://msdn.microsoft.com/en-us/library/azure/jj889436.aspx)
            Console.WriteLine("Smooth Streaming format:");
            Console.WriteLine("{0}", streamingURL + "/Manifest");
            Console.WriteLine("Apple HLS format:");
            Console.WriteLine("{0}", streamingURL + "/Manifest(format=m3u8-aapl)");
            Console.WriteLine("MPEG DASH format:");
            Console.WriteLine("{0}", streamingURL + "/Manifest(format=mpd-time-csf)"); 

        }

        static public IAsset CreateAssetAndUploadSingleFile(AssetCreationOptions assetCreationOptions, string singleFilePath)
        {
            var assetName = "UploadSingleFile_" + DateTime.UtcNow.ToString();
            var asset = CreateEmptyAsset(assetName, assetCreationOptions);

            var fileName = Path.GetFileName(singleFilePath);

            var assetFile = asset.AssetFiles.Create(fileName);

            Console.WriteLine("Created assetFile {0}", assetFile.Name);

            var accessPolicy = _context.AccessPolicies.Create(assetName, TimeSpan.FromDays(30),
                                                                AccessPermissions.Write | AccessPermissions.List);

            var locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);

            Console.WriteLine("Upload {0}", assetFile.Name);

            assetFile.Upload(singleFilePath);
            Console.WriteLine("Done uploading {0}", assetFile.Name);

            locator.Delete();
            accessPolicy.Delete();

            return asset;
        }

        static private IAsset CreateEmptyAsset(string assetName, AssetCreationOptions assetCreationOptions)
        {
            var asset = _context.Assets.Create(assetName, assetCreationOptions);

            Console.WriteLine("Asset name: " + asset.Name);
            Console.WriteLine("Time created: " + asset.Created.Date.ToString());

            return asset;
        }

        static public IAsset CreateEncodingJob(IAsset asset, string preset)
        {
            // Declare a new job.
            IJob job = _context.Jobs.Create(preset + " encoding job");
            // Get a media processor reference, and pass to it the name of the 
            // processor to use for the specific task.
            IMediaProcessor processor = GetLatestMediaProcessorByName("Azure Media Encoder");

            // Create a task with the encoding details, using a string preset.
            ITask task = job.Tasks.AddNew(preset + " encoding task",
                processor,
                preset, 
                Microsoft.WindowsAzure.MediaServices.Client.TaskOptions.ProtectedConfiguration);

            // Specify the input asset to be encoded.
            task.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 not encrypted. 
            task.OutputAssets.AddNew("Output asset",
                AssetCreationOptions.None);

            // Use the following event handler to check job progress.  
            job.StateChanged += new
                    EventHandler<JobStateChangedEventArgs>(StateChanged);

            // Launch the job.
            job.Submit();

            // Optionally log job details. This displays basic job details
            // to the console and saves them to a JobDetails-{JobId}.txt file 
            // in your output folder.
            LogJobDetails(job.Id);

            // Check job execution and wait for job to finish. 
            Task progressJobTask = job.GetExecutionProgressTask(CancellationToken.None);
            progressJobTask.Wait();

            // If job state is Error the event handling 
            // method for job progress should log errors.  Here we check 
            // for error state and exit if needed.
            if (job.State == JobState.Error)
            {
                throw new Exception("\nExiting method due to job error.");
            }

            return job.OutputMediaAssets[0];
        }
    
        static public string GetStreamingOriginLocatorURL(IAsset assetToStream)
        {
            // Get a reference to the streaming manifest file from the  
            // collection of files in the asset. 
            var theManifest =
                                from f in assetToStream.AssetFiles
                                where f.Name.EndsWith(".ism")
                                select f;

            // Cast the reference to a true IAssetFile type. 
            IAssetFile manifestFile = theManifest.First();

            // Create a 30-day readonly access policy. 
            IAccessPolicy policy = _context.AccessPolicies.Create("Streaming policy",
                TimeSpan.FromDays(30),
                AccessPermissions.Read);

            // Create a locator to the streaming content on an origin. 
            ILocator originLocator = _context.Locators.CreateLocator(LocatorType.OnDemandOrigin, 
                assetToStream,
                policy,
                DateTime.UtcNow.AddMinutes(-5));

            // Display the base path to the streaming asset on the origin server.
            Console.WriteLine("Streaming asset base path on origin: ");
            Console.WriteLine(originLocator.Path);
            Console.WriteLine();

            // Create a full URL to the manifest file. Use this for playback
            // in smooth streaming and HLS media clients. 
            return originLocator.Path + manifestFile.Name;
        }

        static public string BuildSasUrlForMP4File(IAsset asset)
        {
            // Declare an access policy for permissions on the asset. 
            // You can call an async or sync create method. 
            IAccessPolicy policy =
                _context.AccessPolicies.Create("My 30 days readonly policy",
                    TimeSpan.FromDays(30),
                    AccessPermissions.Read);

            // Create a SAS locator to enable direct access to the asset 
            // in blob storage. You can call a sync or async create method.  
            // You can set the optional startTime param as 5 minutes 
            // earlier than Now to compensate for differences in time  
            // between the client and server clocks. 

            ILocator locator = _context.Locators.CreateLocator(LocatorType.Sas,
                asset,
                policy,
                DateTime.UtcNow.AddMinutes(-5));

            var mp4File = asset.AssetFiles.ToList().
                           Where(f => f.Name.EndsWith(".mp4", StringComparison.OrdinalIgnoreCase)).
                           FirstOrDefault();


            // Take the locator path, add the file name, and build 
            // a full SAS URL to access this file. This is the only 
            // code required to build the full URL.
            var uriBuilder = new UriBuilder(locator.Path);
            uriBuilder.Path += "/" + mp4File.Name;

            Console.WriteLine("Full URL to file: ");
            Console.WriteLine(uriBuilder.Uri.AbsoluteUri);
            Console.WriteLine();

            //Return the SAS URL.
            return uriBuilder.Uri.AbsoluteUri;
        }

        static public IAsset DownloadAssetToLocal(IAsset asset, string outputFolder)
        {
            IAccessPolicy accessPolicy = _context.AccessPolicies.Create("File Download Policy", TimeSpan.FromDays(30), AccessPermissions.Read);
            ILocator locator = _context.Locators.CreateLocator(LocatorType.Sas, asset, accessPolicy);
            BlobTransferClient blobTransfer = new BlobTransferClient
            {
                NumberOfConcurrentTransfers = 10,
                ParallelTransferThreadCount = 10
            };

            Console.WriteLine("Files will be downloaded to:");
            Console.WriteLine("{0}", outputFolder);
            Console.WriteLine();

            var downloadTasks = new List<Task>();
            foreach (IAssetFile outputFile in asset.AssetFiles)
            {
                // Use the following event handler to check download progress.
                outputFile.DownloadProgressChanged += DownloadProgress;

                string localDownloadPath = Path.Combine(outputFolder, outputFile.Name);

                downloadTasks.Add(outputFile.DownloadAsync(Path.GetFullPath(localDownloadPath), blobTransfer, locator, CancellationToken.None));

                outputFile.DownloadProgressChanged -= DownloadProgress;
            }

            Task.WaitAll(downloadTasks.ToArray());

            return asset;
        }

        static private void DownloadProgress(object sender, DownloadProgressChangedEventArgs e)
        {
            Console.WriteLine(string.Format("{0} % download progress. ", e.Progress));
        }


        static private IMediaProcessor GetLatestMediaProcessorByName(string mediaProcessorName)
        {
            // The possible strings that can be passed into the 
            // method for the mediaProcessor parameter:
            //   Azure Media Encoder
            //   Azure Media Packager
            //   Azure Media Encryptor
            //   Storage Decryption

            var processor = _context.MediaProcessors.Where(p => p.Name == mediaProcessorName).
                ToList().OrderBy(p => new Version(p.Version)).LastOrDefault();

            if (processor == null)
                throw new ArgumentException(string.Format("Unknown media processor", mediaProcessorName));

            return processor;
        }

        static private void StateChanged(object sender, JobStateChangedEventArgs e)
        {
            Console.WriteLine("Job state changed event:");
            Console.WriteLine("  Previous state: " + e.PreviousState);
            Console.WriteLine("  Current state: " + e.CurrentState);

            switch (e.CurrentState)
            {
                case JobState.Finished:
                    Console.WriteLine();
                    Console.WriteLine("********************");
                    Console.WriteLine("Job is finished.");
                    Console.WriteLine("Please wait while local tasks or downloads complete...");
                    Console.WriteLine("********************");
                    Console.WriteLine();
                    Console.WriteLine();
                    break;
                case JobState.Canceling:
                case JobState.Queued:
                case JobState.Scheduled:
                case JobState.Processing:
                    Console.WriteLine("Please wait...\n");
                    break;
                case JobState.Canceled:
                case JobState.Error:
                    // Cast sender as a job.
                    IJob job = (IJob)sender;
                    // Display or log error details as needed.
                    LogJobStop(job.Id);
                    break;
                default:
                    break;
            }
        }

        static private void LogJobStop(string jobId)
        {
            StringBuilder builder = new StringBuilder();
            IJob job = GetJob(jobId);

            builder.AppendLine("\nThe job stopped due to cancellation or an error.");
            builder.AppendLine("***************************");
            builder.AppendLine("Job ID: " + job.Id);
            builder.AppendLine("Job Name: " + job.Name);
            builder.AppendLine("Job State: " + job.State.ToString());
            builder.AppendLine("Job started (server UTC time): " + job.StartTime.ToString());
            builder.AppendLine("Media Services account name: " + _mediaServicesAccountName);
            // Log job errors if they exist.  
            if (job.State == JobState.Error)
            {
                builder.Append("Error Details: \n");
                foreach (ITask task in job.Tasks)
                {
                    foreach (ErrorDetail detail in task.ErrorDetails)
                    {
                        builder.AppendLine("  Task Id: " + task.Id);
                        builder.AppendLine("    Error Code: " + detail.Code);
                        builder.AppendLine("    Error Message: " + detail.Message + "\n");
                    }
                }
            }
            builder.AppendLine("***************************\n");
            // Write the output to a local file and to the console. The template 
            // for an error output file is:  JobStop-{JobId}.txt
            string outputFile = _outputFilesFolder + @"\JobStop-" + JobIdAsFileName(job.Id) + ".txt";
            WriteToFile(outputFile, builder.ToString());
            Console.Write(builder.ToString());
        }

        static private void LogJobDetails(string jobId)
        {
            StringBuilder builder = new StringBuilder();
            IJob job = GetJob(jobId);

            builder.AppendLine("\nJob ID: " + job.Id);
            builder.AppendLine("Job Name: " + job.Name);
            builder.AppendLine("Job submitted (client UTC time): " + DateTime.UtcNow.ToString());
            builder.AppendLine("Media Services account name: " + _mediaServicesAccountName);

            // Write the output to a local file and to the console. The template 
            // for an error output file is:  JobDetails-{JobId}.txt
            string outputFile = _outputFilesFolder + @"\JobDetails-" + JobIdAsFileName(job.Id) + ".txt";
            WriteToFile(outputFile, builder.ToString());
            Console.Write(builder.ToString());
        }

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

        static private string JobIdAsFileName(string jobID)
        {
            return jobID.Replace(":", "_");
        }
        static IJob GetJob(string jobId)
        {
            // Use a Linq select query to get an updated 
            // reference by Id. 
            var jobInstance =
                from j in _context.Jobs
                where j.Id == jobId
                select j;
            // Return the job reference as an Ijob. 
            IJob job = jobInstance.FirstOrDefault();

            return job;
        }
        static IAsset GetAsset(string assetId)
        {
            // Use a LINQ Select query to get an asset.
            var assetInstance =
                from a in _context.Assets
                where a.Id == assetId
                select a;
            // Reference the asset as an IAsset.
            IAsset asset = assetInstance.FirstOrDefault();

            return asset;
        }

        //////////////////////////////////////////////////
        // Delete tasks
        //////////////////////////////////////////////////

        static void DeleteAsset(IAsset asset)
        {
            // Delete Asset's locators before
            // deleting the asset.
            foreach (var l in asset.Locators)
            {
                Console.WriteLine("Deleting the Locator {0}", l.Id); 
                l.Delete();
            }

            Console.WriteLine("Deleting the Asset {0}", asset.Id);
            // delete the asset
            asset.Delete();
        }

        static void DeleteAllAccessPoliciesInThisAccount(string existingPolicyId)
        {
            // To delete a specific access policy, get a reference to the policy.  
            // based on the policy Id passed to the method.
            var policy = _context.AccessPolicies.
                Where(p => p.Id == existingPolicyId).FirstOrDefault();

            Console.WriteLine("Deleting policy {0}", existingPolicyId);
            policy.Delete();

        }
    }
}

Ausführen des Programms (drücken Sie F5).

Diese exemplarische Vorgehensweise hat eine Folge von Programmieraufgaben zum Erstellen einer einfachen Mediendienste-Anwendung vorgestellt. Sie haben sich mit den grundlegenden Mediendienste-Programmieraufgaben vertraut gemacht, z. B. mit dem Abrufen des Serverkontexts, dem Erstellen von Medienobjekten, dem Codieren von Medienobjekten und dem Herunterladen von Medienobjekten oder Zugreifen auf Medienobjekte auf dem Server. Die fortgeschritteneren Entwicklungsaufgaben finden Sie in den folgenden Abschnitten:

Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2014 Microsoft