Exportar (0) Imprimir
Expandir Tudo

Guia de início rápido: Usar o .NET do SDK do Media Services

Atualizado: fevereiro de 2014

Este tópico é um tutorial passo a passo para novos desenvolvedores no Serviços de Mídia do Microsoft Azure. Ele introduz o fluxo de trabalho padrão do Serviços de Mídia e os objetos e as tarefas de programação mais comuns necessários para o desenvolvimento no Serviços de Mídia. Para obter as noções básicas do processo de desenvolvimento e modelo de programação por objeto do Serviços de Mídia, consulte Visão geral do Azure Media Services.

Um projeto do Visual Studio C# que contém o código para este tutorial está disponível aqui: Baixar

Este passo a passo demonstra como:

TipDica
E também há a opção de usar as extensões SDK .NET do Azure Media Services para realizar tarefas descritas neste tópico. As extensões do SDK .NET do Serviços de Mídia são um conjunto de métodos de extensão e funções de auxílio que irão simplificar seu código e facilitar o desenvolvimento Serviços de Mídia. Para obter mais informações, consulte Guia de início rápido: Usar extensões .NET do SDK do Media Services..

Os seguintes pré-requisitos são necessários para o tutorial passo a passo e para o desenvolvimento baseado no SDK do Serviços de Mídia do Microsoft Azure.

  • Uma conta do Serviços de Mídia em uma nova assinatura do Azure ou em uma existente. Consulte o tópico Como criar uma conta do Media Services.

  • Sistemas operacionais: Windows 7, Windows 2008 R2 ou Windows 8.

  • .NET Framework 4.5 ou .NET Framework 4.

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

  1. Criar um novo aplicativo de console C# no Visual Studio 2013, Visual Studio 2012 ou Visual Studio 2010 SP1. Insira o Nome, a Localização e o Nome da solução e, em seguida, clique em OK.

  2. Adicione referências ao Serviços de Mídia e a seus DLLs dependentes.

    O SDK do Serviços de Mídia possui dependência em diversas bibliotecas (por exemplo, Azure Storage SDK for .NET e WCF Data Services for OData). É possível usar o windowsazure.mediaservices nuget para instalar e adicionar o SDK do Serviços de Mídia ao projeto, e nesse caso todas as dependências são instaladas e adicionadas ao projeto automaticamente.

    Como alternativa, é possível obter os mais recentes bits de SDK do Serviços de Mídia de GitHub, criar a solução e adicionar as referências ao projeto cliente. Observe que todas as dependências necessárias são baixadas e extraídas automaticamente.

    Qualquer que seja o método, não é necessário baixar as dependências manualmente.

    Para adicionar as referências necessárias usando o pacote NuGet windowsazure.mediaservices, siga as instruções abaixo:

    1. Certifique-se de que você possui a versão mais recente do NuGet instalada.

      Para obter maiores informações e instruções de instalação, consulte  NuGet.

    2. Em Gerenciador de Soluções, clique com o botão direito do mouse no nome do projeto e escolha Gerenciar pacotes NuGet….

      A caixa de diálogo Gerenciar pacotes NuGet é exibida.

    3. Na galeria Online, pesquise MediaServices, escolha Azure Media Services .NET SDK e, em seguida, clique no botão Instalar.

      O projeto é modificado e as referências às montagens do Media Services são adicionadas.

    4. Para promover um ambiente desenvolvedor de limpeza, considere ativar o NuGet Package Restore. Para obter mais informações, consulte Restaurar pacote NuGet.

  3. Adicione uma referência ao assembly System.Configuration do .NET.

    Para adicionar referências usando a caixa de diálogo Gerenciar Referências, faça o seguinte:

    1. Em Gerenciador de Soluções, clique com o botão direito no nome do projeto. Em seguida, selecione Adicionar e Referências.

      A caixa de diálogo Gerenciar Referências aparece.

    2. Nos assemblies do .NET Framework, localize e selecione o assembly System.Configuration.

    3. Pressione OK.

  4. Adicione a seção appSettings ao arquivo app.config e defina os valores de seu nome de conta e sua chave de conta do Serviços de Mídia. Você obteve o nome de conta e a chave de conta do Serviços de Mídia durante o processo de configuração de conta.

    noteObservação
    No Visual Studio 2013 e no Visual Studio 2012, o arquivo App.config é adicionado por padrão. No Visual Studio 2010, você tem que adicionar manualmente o arquivo de configuração do aplicativo.

    TipDica
    Para encontrar os valores de nome e chave, acesse o Portal do Azure, selecione sua conta do Media Service e clique no ícone “GERENCIAR CHAVES”, na parte inferior da janela do portal. Clicar no ícone ao lado de cada caixa de texto copia o valor para a área de transferência do sistema.

    <?xml version="1.0"?>
    <configuration>
      <appSettings>
          <add key="MediaServicesAccountName" value="YouMediaServicesAccountName" />
          <add key="MediaServicesAccountKey" value="YouMediaServicesAccountKey" />
      </appSettings>
    </configuration>
    
  5. Crie uma pasta no computador local e copie um arquivo .wmv e um arquivo .mp4 para essa pasta. Este exemplo pressupõe que o nome da pasta seja Media e que ela esteja localizada no diretório de projeto MediaServicesGettingStarted. O projeto que acompanha este passo a passo contém o diretório Media com um arquivo .wmv e um arquivo .mp4.

  6. Substitua as declarações using existentes no início do arquivo Program.cs pelo seguinte código.

    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;
    

Para se conectar aos Serviços de Mídia de forma programática, você precisa ter previamente criado uma conta do Azure e configurado os Serviços de Mídia nessa conta. O tópico a seguir apresenta detalhes sobre como se conectar à conta dos Serviços de Mídia: Conectar ao Media Services com o SDK do Media Services.

O código a seguir demonstra como ler os valores de conexão no arquivo App.config e como criar o objeto CloudMediaContext para se conectar aos Serviços de Mídia.

  1. Substitua a definição da classe Program padrão pelo código a seguir.

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

O código nesta sessão faz o seguinte:

  1. Cria um ativo vazio

    Quando você cria ativos, é possível especificar três opções diferentes para criptografá-los.

    • AssetCreationOptions.None. Se você quiser criar um ativo não criptografado, deverá definir essa opção.

    • AssetCreationOptions.CommonEncryptionProtected. Especifique esta opção se você tiver arquivos protegidos por CENC (criptografia comum). Um exemplo é um conjunto de arquivos criptografados com PlayReady.

    • AssetCreationOptions.StorageEncrypted. Criptografa um arquivo de entrada não criptografado antes de carregá-lo no armazenamento Azure.

      noteObservação
      Observe que o Serviços de Mídia fornece criptografia de armazenamento em disco, e não na transmissão como o Gerenciador de Direitos Digitais (DRM).

  2. Cria uma instância AssetFile que desejamos carregar no armazenamento e associar ao ativo.

  3. Cria uma instância AccessPolicy que define as permissões e a duração de acesso ao ativo.

  4. Cria um instância do Localizador de SAS que dá acesso ao ativo.

  5. Carrega um único arquivo de mídia no Serviços de Mídia. O processo de criar e carregar também é chamado de ingestão de ativos.

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

No Serviços de Mídia, é possível criar trabalhos que processam conteúdo de mídia de diversas maneiras: codificando, criptografando, convertendo formatos e assim por diante. Um trabalho do Serviços de Mídia sempre contém uma ou mais tarefas que especificam os detalhes do trabalho em processamento. Esta seção define um método que cria uma única tarefa de codificação e, em seguida, executa um trabalho que realiza a tarefa usando o Azure Media Encoder. A tarefa usa uma cadeia de caracteres de predefinição para especificar o tipo de codificação a ser realizada. Para consultar os valores de codificação predefinidos disponíveis, consulte Predefinições de sistema do Media Services Encoder. O Serviços de Mídia suporta os mesmos formatos de entrada e saída de arquivo de mídia que o Microsoft Expression Encoder. Para obter uma lista de formatos com suporte, consulte Supported File Types for Media Services.

  1. Adicione a seguinte definição de método CreateEncodingJob à classe. Este método realiza diversas etapas necessárias para um trabalho de codificação:

    • Declare um novo trabalho.

    • Declare um processador de mídia para manipular o trabalho. Um processador de mídia é um componente que manipula a codificação, criptografia, conversão de formato e outros trabalhos de processamento relacionados. Existem diversos tipos de processadores de mídia disponíveis (é possível iterar por todos eles usando _context.MediaProcessors). O método GetLatestMediaProcessorByName, mostrado mais tarde neste tutorial passo a passo, retorna o processador Azure Media Encoder.

    • Declare uma nova tarefa. Todo trabalho tem uma ou mais tarefas. Observe que com a tarefa, você passa para ele um nome amigável, uma instância de processador de mídia, uma cadeia de caracteres de configuração e opções de criação de tarefa. A cadeia de caracteres de configuração especifica as configurações de codificação. Por exemplo, a configuração H264 Broadband 720p produz um único arquivo MP4. Para obter mais informações sobre esta e outras predefinições, consulte Predefinições de sistema do Media Services Encoder.

    • Adicione um ativo de entrada à tarefa. Neste exemplo, o ativo de entrada é aquele que você criou na seção anterior.

    • Adicione um ativo de saída à tarefa. Para um ativo de saída, especifique um nome amigável, um valor booleano para indicar se a saída deve ser salva no servidor após a conclusão do trabalho e um valor AssetCreationOptions.None para indicar que a saída não é criptografada para armazenamento e transporte.

    • Envie o trabalho.

      Enviar um trabalho é a última etapa necessária para realizar um trabalho de codificação.



    O método executa outras tarefas úteis, mas opcionais, como rastrear o progresso de trabalhos e registrar detalhes de trabalhos.

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

Para transmitir um arquivo, é necessário criar um localizador OnDemandOrigin. Um Locator oferece um ponto de entrada para acessar os arquivos presentes nesse ativo. Os Serviços de Mídia oferecem suporte a dois tipos de localizadores: Localizadores OnDemandOrigin, que são usados para transmitir mídia (por exemplo, MPEG DASH, HLS ou Smooth Streaming) e localizadores de URL de assinatura de acesso (SAS), que são usados para baixar arquivos de mídia.

Para gerar a URL completa, você deve criar um LocatorOnDemandOrigin e adicionar o formato de streaming desejado. Por exemplo:

 

Smooth Streaming

{nome da conta de serviços de mídia}.origin.mediaservices.net/{ID do localizador}/{nome do arquivo}.ism/Manifest

É possível usar o player http://smf.cloudapp.net/healthmonitor para testar o Smooth Streaming.

Manifesto de perfil ativo DASH com mídia no formato de streaming comum

{nome da conta de serviços de mídia}.origin.mediaservices.net/{ID do localizador}/{nome do arquivo}.ism/Manifest(format=mpd-time-csf) 

Você pode usar o player http://dashif.org/reference/players/javascript/ para testar o Smooth Streaming.

Apple HTTP Live Streaming (HLS)

{nome da conta de serviços de mídia}.origin.mediaservices.net/{ID do localizador}/{nome do arquivo}.ism/Manifest(format=m3u8-aapl)

O exemplo a seguir mostra URLs Smooth Streaming, HLS e DASH baseadas no caminho do localizador 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)

Para obter mais informações, consulte Distribuição de conteúdo.

O método a seguir obtém a URL para o serviço de origem sob demanda, bem como para o arquivo de manifesto. Depois que você tiver essa URL, poderá montar a URL de streaming completa, conforme descrito acima.

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

Para baixar um arquivo no computador, primeiro é necessário criar um localizador de SAS. Um Locator oferece um ponto de entrada para acessar os arquivos presentes nesse ativo. Os Serviços de Mídia oferecem suporte a dois tipos de localizadores: Localizadores OnDemandOrigin, que são usados para transmitir mídia (por exemplo, MPEG DASH, HLS ou Smooth Streaming) e localizadores de URL de assinatura de acesso (SAS), que são usados para baixar arquivos de mídia. Para montar a URL, é necessário incorporar o nome do arquivo entre o host e a assinatura SAS.

O exemplo a seguir mostra a URL baseada no localizador de 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

Para obter mais informações, consulte Distribuição de conteúdo.

O método a seguir baixa arquivos no local de saída especificado.

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

Esta seção contém a listagem completa do código descrito neste tópico.

noteObservação
  • Atualize as variáveis a seguir para apontarem para as pastas em que seus arquivos de saída (MP4 e WMV) estão localizados e em que você deseja que a saída seja gerada.

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

        }
    }
}

Execute o programa (pressione F5).

Este tutorial passo a passo demonstrou uma sequência de tarefas de programação para criar um aplicativo Serviços de Mídia simples. Você aprendeu as tarefas fundamentais de programação do Serviços de Mídia, incluindo como obter o contexto do servidor, criar ativos, codificar ativos e baixar ou acessar ativos no servidor. Para obter tarefas de desenvolvimento mais avançadas, consulte as seguintes seções:


Data de criação:

2014-06-06

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft