Exporter (0) Imprimer
Développer tout

Démarrage rapide : utilisation du Kit de développement logiciel (SDK) Media Services pour .NET

Mis à jour: août 2014

Cette rubrique correspond à une procédure pas à pas pour les nouveaux développeurs sur Microsoft Azure Media Services. Elle introduit le flux de travail Media Services élémentaire, ainsi que les tâches et les objets de programmation les plus courants, requis pour le développement des Media Services. Pour comprendre les bases du processus de développement des Media Services et le modèle d'objet de programmation, consultez Vue d’ensemble d'Azure Media Services.

Un projet Visual Studio C# contenant le code requis pour ce didacticiel est disponible ici : Télécharger

Cette procédure pas à pas illustre comment :

noteRemarque
Exemple

TipConseil
Vous avez également la possibilité d'utiliser les extensions du Kit de développement logiciel (SDK) des Services de média Azure pour .NET afin d'accomplir les tâches décrites dans cette rubrique. Les extensions du Kit de développement logiciel (SDK) Media Services pour .NET sont un ensemble de méthodes d'extension et de fonctions d'assistance qui simplifieront votre code et le développement avec les Media Services. Pour plus d'informations, consultez Démarrage rapide : utilisation des extensions du Kit de développement logiciel (SDK) Media Services pour .NET.

Les conditions requises suivantes s'appliquent à cette procédure pas à pas et au développement basé sur le Kit de développement logiciel (SDK) des Microsoft Azure Media Services.

  • Un compte Media Services dans le cadre d'un abonnement Azure nouveau ou existant. Consultez la rubrique Comment créer un compte Services de média.

  • Systèmes d'exploitation : Windows 7, Windows 2008 R2 ou Windows 8.

  • .NET Framework 4.

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

  1. Créez une nouvelle application console C# dans Visual Studio 2013, Visual Studio 2012 ou Visual Studio 2010 SP1. Entrez le nom, l'emplacement et le nom de la solution, puis cliquez sur OK.

  2. Ajoutez des références aux Media Services et à leurs fichiers DLL dépendants.

    Le Kit de développement logiciel (SDK) des Media Services comporte une dépendance sur plusieurs bibliothèques (par exemple, Azure Storage SDK for .NET et WCF Data Services for OData). Vous pouvez utiliser le package Nuget - Services de média Windows Azure pour installer et ajouter le Kit de développement logiciel des Media Services à votre projet, auquel cas toutes les dépendances sont installées et ajoutées automatiquement à votre projet.

    Vous pouvez également obtenir les derniers composants du Kit de développement logiciel (SDK) des Media Services sur le site GitHub, générer la solution et ajouter les références au projet client. Notez que toutes les dépendances nécessaires sont téléchargées et extraites automatiquement.

    Quelle que soit la méthode choisie, vous n'avez pas besoin de télécharger manuellement les dépendances.

    Pour ajouter les références requises à l'aide du package NuGet - Services de média Windows Azure, procédez comme suit :

    1. Assurez-vous d'avoir la dernière version de NuGet installée.

      Pour plus d'informations et obtenir des instructions d'installation, consultez NuGet.

    2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet et choisissez Gérer les packages NuGet.

      La boîte de dialogue Gérer les packages NuGet s'affiche.

    3. Dans la galerie En ligne, recherchez MediaServices, choisissez Azure Media Services .NET SDK, puis cliquez sur le bouton Installer.

      Le projet est modifié et des références aux assemblys Services de média sont ajoutées.

    4. Pour promouvoir un environnement de développement plus propre, envisagez d'activer NuGet Package Restore. Pour plus d'informations, consultez Restauration des packages NuGet.

  3. Ajoutez une référence à l'assembly .NET System.Configuration.

    Pour ajouter des références à l'aide de la boîte de dialogue Gérer les références, procédez comme suit :

    1. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet. Ensuite, sélectionnez Ajouter et Références.

      La boîte de dialogue Gérer les références s'affiche.

    2. Sous les assemblys du .NET Framework, recherchez et sélectionnez l'assembly System.Configuration.

    3. Appuyez sur OK.

  4. Ajoutez la section appSettings dans le fichier app.config et définissez les valeurs pour votre nom de compte et votre clé de compte Media Services. Vous avez obtenu le nom de compte et la clé de compte Media Services au cours du processus d'installation du compte.

    noteRemarque
    Dans Visual Studio 2013 et Visual Studio 2012, le fichier App.config est ajouté par défaut. Dans Visual Studio 2010, vous devez ajouter manuellement le fichier de configuration d'application.

    TipConseil
    Pour trouver les valeurs de nom et de clé, accédez au portail Azure, sélectionnez votre compte Services de média et cliquez sur l'icône « GÉRER LES CLÉS » en bas de la fenêtre du portail. Cliquez sur l'icône à côté d'une zone de texte pour copier sa valeur dans le Presse-papiers système.

    <?xml version="1.0"?>
    <configuration>
      <appSettings>
          <add key="MediaServicesAccountName" value="YouMediaServicesAccountName" />
          <add key="MediaServicesAccountKey" value="YouMediaServicesAccountKey" />
      </appSettings>
    </configuration>
    
  5. Créez un dossier sur votre ordinateur local et copiez des fichiers .wmv et .mp4 dans ce dossier. Dans cet exemple, nous supposons que le nom du dossier est Media et qu'il se trouve sous le répertoire de projet MediaServicesGettingStarted. Le projet qui accompagne cette procédure pas à pas contient le répertoire Media où figurent un fichier .wmv et un fichier .mp4.

  6. Remplacez les instructions using existantes au début du fichier Program.cs par le code ci-dessous.

    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;
    

Pour vous connecter par programmation aux Services de média, vous devez avoir configuré au préalable un compte Azure et configuré les Services de média sur ce compte. La rubrique suivante fournit des détails sur la façon de se connecter au compte Services de média : Connexion à Media Services avec le Kit de développement logiciel (SDK) Media Services pour .NET.

Le code ci-dessous montre comment lire les valeurs de connexion à partir du fichier App.config et comment créer l'objet CloudMediaContext pour se connecter aux Services de média.

  1. Remplacez la définition de la classe Program par défaut par le code ci-dessous.

    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);
           . . .
        }
    }
    
    
    
noteRemarque
Exemple

Le code de cette section effectue les opérations suivantes :

  1. Il crée un élément multimédia vide.

    Quand vous créez des éléments multimédias, vous pouvez spécifier trois options différentes pour les chiffrer.

    • AssetCreationOptions.None. Pour créer un élément multimédia non chiffré, vous devez définir cette option.

    • AssetCreationOptions.CommonEncryptionProtected. Spécifiez cette option si vous possédez des fichiers CENC (protégés par un chiffrement commun). Un ensemble de fichiers chiffrés en PlayReady en est un exemple.

    • AssetCreationOptions.StorageEncrypted. Chiffre un fichier d'entrée en clair avant son téléchargement vers le stockage Azure.

      noteRemarque
      Notez que les Media Services fournissent un chiffrement de stockage sur disque, et non pas sur le réseau comme Digital Rights Manager (DRM).

  2. Il crée une instance AssetFile à télécharger vers le stockage et à associer à l'élément multimédia.

  3. Il crée une instance AccessPolicy qui définit les autorisations et la durée de l'accès à l'élément multimédia.

  4. Il crée une instance de localisateur SAS qui fournit l'accès à l'élément multimédia.

  5. Il télécharge un fichier multimédia unique vers les Media Services. Le processus de création et de téléchargement est également appelé « ingestion d'éléments multimédias ».

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

noteRemarque
Exemple

Dans les Media Services, vous pouvez créer des travaux qui traitent le contenu multimédia de différentes manières : encodage, chiffrement, conversions de format, etc. Un travail des Media Services contient toujours une ou plusieurs tâches spécifiant les détails du traitement. Cette section définit une méthode qui crée une tâche d'encodage unique, puis qui exécute un travail qui effectue la tâche à l'aide de l'Azure Media Encoder. La tâche utilise une chaîne de présélection pour spécifier le type d'encodage à effectuer. Pour consulter les valeurs d'encodage prédéfinies disponibles, reportez-vous à Présélections système de l'encodeur Media Services. Les Media Services prennent en charge les mêmes formats d'entrée et de sortie de fichier multimédia que Microsoft Expression Encoder. Pour afficher la liste des formats pris en charge, consultez Supported File Types for Media Services.

  1. Ajoutez la définition de la méthode CreateEncodingJob suivante à votre classe. Cette méthode accomplit plusieurs étapes requises pour un travail d'encodage :

    • Elle déclare un nouveau travail.

    • Elle déclare un processeur multimédia chargé de traiter le travail. Un processeur multimédia est un composant qui traite l'encodage, le chiffrement, la conversion de format et d'autres travaux associés. Il existe plusieurs types de processeurs multimédias disponibles (vous pouvez passer de l'un à l'autre en utilisant _context.MediaProcessors). La méthode GetLatestMediaProcessorByName, présentée ultérieurement dans cette procédure pas à pas, retourne le processeur Azure Media Encoder.

    • Elle déclare une nouvelle tâche. Chaque travail possède une ou plusieurs tâches. Remarquez qu'avec la tâche, vous passez un nom convivial, une instance de processeur multimédia, une chaîne de configuration de tâche et des options de création de tâche. La chaîne de configuration spécifie les paramètres d'encodage. Par exemple, le paramètre H264 Broadband 720p permet de générer un fichier MP4 unique. Pour plus d'informations sur cette valeur prédéfinie et d'autres, consultez Présélections système de l'encodeur Media Services.

    • Elle ajoute un élément multimédia d'entrée à la tâche. Dans cet exemple, l'élément multimédia d'entrée est celui que vous avez créé à la section précédente.

    • Elle ajoute un élément multimédia de sortie à la tâche. Pour un élément multimédia de sortie, spécifiez un nom convivial, une valeur booléenne pour indiquer s'il convient d'enregistrer la sortie sur le serveur une fois le travail terminé, ainsi qu'une valeur AssetCreationOptions.None pour indiquer que la sortie n'est pas chiffrée pour le stockage et le transport.

    • Elle soumet le travail.

      La soumission d'un travail constitue la dernière étape requise pour effectuer un travail d'encodage.



    La méthode effectue d'autres tâches utiles mais facultatives, telles que le suivi de la progression du travail et la consignation des détails du travail.

    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];
    }
    
noteRemarque
Exemple

Pour diffuser un fichier, vous devez créer un localisateur OnDemandOrigin. Les entités Locator fournissent un point d'entrée pour accéder aux fichiers contenus dans un élément multimédia. Les Services de média prennent en charge deux types de localisateurs : les localisateurs OnDemandOrigin, utilisés pour diffuser du contenu multimédia (par exemple, MPEG DASH, HLS ou Smooth Streaming) et les localisateurs d'URL SAS SAS (signature d'accès partagé), utilisés pour télécharger des fichiers multimédias.

Pour générer l'URL complète, vous devez créer une entité LocatorOnDemandOrigin et ajouter le format de diffusion souhaité. Par exemple :

 

Smooth Streaming

{nom du compte des services de média}.origin.mediaservices.net/{ID du localisateur}/{nom de fichier}.ism/Manifest

Vous pouvez utiliser le lecteur http://smf.cloudapp.net/healthmonitor pour tester votre diffusion en Smooth Streaming.

Manifeste de profil en direct DASH avec contenu multimédia dans un format de diffusion commun

{nom du compte des services de média}.origin.mediaservices.net/{ID du localisateur}/{nom de fichier}.ism/Manifest(format=mpd-time-csf) 

Vous pouvez utiliser le lecteur http://dashif.org/reference/players/javascript/ pour tester votre diffusion en Smooth Streaming.

Apple HTTP Live Streaming (HLS)

{nom du compte des services de média}.origin.mediaservices.net/{ID du localisateur}/{nom de fichier}.ism/Manifest(format=m3u8-aapl)

L'exemple ci-dessous montre les URL Smooth Streaming, HLS et DASH qui sont basées sur le chemin d'accès du localisateur OnDemandOrigin.

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)

Pour plus d'informations, consultez Distribution de contenu.

La méthode ci-dessous obtient l'URL au service d'origine à la demande, ainsi que le fichier manifeste. Une fois que vous possédez cette URL, vous pouvez générer l'URL complète de diffusion, telle que décrite ci-dessus.

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;
}
noteRemarque
Exemple

Pour télécharger un fichier sur votre ordinateur, vous devez commencer par créer un localisateur SAS. Les entités Locator fournissent un point d'entrée pour accéder aux fichiers contenus dans un élément multimédia. Les Services de média prennent en charge deux types de localisateurs : les localisateurs OnDemandOrigin, utilisés pour diffuser du contenu multimédia (par exemple, MPEG DASH, HLS ou Smooth Streaming) et les localisateurs d'URL SAS SAS (signature d'accès partagé), utilisés pour télécharger des fichiers multimédias. Pour créer l'URL, vous devez inclure le nom du fichier entre l'hôte et la signature SAS.

L'exemple ci-dessous montre l'URL qui est basée sur le localisateur SAS :

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

Pour plus d'informations, consultez Distribution de contenu.

La méthode ci-dessous télécharge des fichiers vers l'emplacement de sortie spécifié.

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

noteRemarque
Exemple

Cette section contient la totalité du code décrit dans cette rubrique.

noteRemarque
  • Veillez à mettre à jour les variables suivantes pour pointer vers les dossiers contenant vos fichiers d'entrée (MP4 et WMV) et les dossiers où vous voulez enregistrer les données obtenues.

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

        }
    }
}

Exécutez le programme (appuyez sur F5).

Cette procédure pas à pas a illustré une séquence de tâches de programmation permettant de générer une application de Media Services simple. Vous avez appris les tâches de programmation de Media Services fondamentales, dont notamment l'obtention du contexte serveur, la création d'éléments multimédias, l'encodage des éléments multimédias, ainsi que le téléchargement des éléments multimédias et l'accès à ces derniers sur le serveur. Pour des tâches de développement plus avancées, consultez les sections suivantes :

Microsoft réalise une enquête en ligne pour recueillir votre opinion sur le site Web de MSDN. Si vous choisissez d’y participer, cette enquête en ligne vous sera présentée lorsque vous quitterez le site Web de MSDN.

Si vous souhaitez y participer,
Afficher:
© 2014 Microsoft