Exportar (0) Imprimir
Expandir Tudo

Distribuição de ativos com o SDK do Media Services para .NET

Atualizado: setembro de 2014

Este tópico mostra as três opções mais comuns para distribuição de conteúdo de mídia aos clientes.

  • Conteúdo de transmissão adaptativa em um dos formatos a seguir: MPEG DASH, Apple HTTP Live Streaming (HLS) e Smooth Streaming.

    Depois de criar as URLs de transmissão (conforme mostrado neste tópico), você pode testá-las com os seguintes players:

    Para testar a URL de Smooth Streaming, use o player smf.cloudapp.net/healthmonitor.

    Para testar a URL de MPEG DASH, use o player dashif.org/reference/players/javascript/.

    Para testar a URL de HLS, use o Safari em um dispositivo iOS ou o 3ivx-hls-player

  • Download progressivo de arquivos MP4.

  • Baixar arquivos de ativo no computador local.

Para obter mais informações, conceitos e terminologias relacionados à distribuição de conteúdo de mídia, consulte Distribuição de conteúdo.

WarningAviso
O Serviços de Mídia utiliza o valor da propriedade IAssetFile.Name ao criar URLs para o conteúdo de streaming (por exemplo, http://{WAMSAccount}.origin.mediaservices.windows.net/{GUID}/{IAssetFile.Name}/streamingParameters.) Por esse motivo, a codificação por percentual não é permitida. O valor da propriedade Name não pode conter qualquer um dos seguintes caracteres reservados codificados por percentual: !*'();:@&=+$,/?%#[]". Além disso, pode somente haver um ‘.’ para cada extensão de nome de arquivo.

Os tópicos a seguir mostram como configurar a implantação do Media Services.

  1. Configuração para o Desenvolvimento dos Serviços de Mídia SDK para .NET

    Observe que o código neste tópico usa Extensões do SDK .NET do Azure Media Services.  As extensões do SDK .NET do Media Services são um conjunto de métodos de extensão e funções de auxílio que simplificam seu código e facilitam o desenvolvimento com o Media Services.

  2. Conectar ao Media Services usando o SDK do Media Services

É possível distribuir (download ou transmissão) ativos que já estejam armazenados na conta do Serviços de Mídia (disponíveis através da coleção Assets). E também baixar ou transmitir ativos que resulte de execução de codificação ou trabalho de empacotamento (disponíveis através da coleção OutputMediaAssets). O exemplo neste tópico mostra como acessar e distribuir ativos de saída de mídia do trabalho.

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

  1. Cria um novo ativo e carrega um arquivo mezzanine MP4 a partir de um diretório local.

  2. Prepara um trabalho com uma única tarefa para transcodificar o ativo mezzanine anterior em um ativo com multitaxa de bits.

  3. Envia o trabalho e aguarda até que ele seja concluído.

  4. Obtém o ativo de saída produzido pelo trabalho de codificação.

  5. Publica o ativo de saída ao criar um localizador de origem.

  6. Gera as URLs de streaming suave, HLS e MPEG-DASH da transmissão adaptável.

    Para transmitir o conteúdo baseado no conjunto de arquivos MP4 com taxa de bits adaptativa, primeiro, é necessário obter pelo menos uma unidade reservada de transmissão sob demanda. Para obter mais informações, consulte Empacotamento dinâmico.

  7. Cria um localizador SAS que é usado para download progressivo e para baixar arquivos em um diretório local.

    O conteúdo que você deseja baixar progressivamente não pode ser criptografado.

  8. Gera as URLs de download progressivo para cada arquivo MP4 no ativo.

  9. Baixa o ativo de saída em uma pasta local.

noteObservação
Esta amostra usa extensões .NET do SDK do Media Services.  As extensões de SDK ocultam muitos detalhes. Caso deseje ver como alguns métodos são implementados (por exemplo, como os métodos a seguir desenvolvem as URLs de transmissão: GetSmoothStreamingUri(), GetHlsUri(), andGetMpegDashUri()), faça uma pesquisa com o código localizado no github: azure-sdk-for-media-services-extensions.

Certifique-se de atualizar o código a fim de apontar a pasta em que seu arquivo MP4 de entrada está localizado.

private static readonly string _mediaFiles =
Path.GetFullPath(@"../..\Media");

private static readonly string _singleMP4File =
    Path.Combine(_mediaFiles, @"SingleMP4\BigBuckBunny.mp4");

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


namespace MediaServicesDeliveringContent 
{ 
    class Program 
    {
        private static readonly string _mediaFiles =
            Path.GetFullPath(@"../..\Media");

        private static readonly string _singleMP4File =
            Path.Combine(_mediaFiles, @"SingleMP4\BigBuckBunny.mp4");

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

        // Media Services account information.
        private static readonly string _mediaServicesAccountName =
            ConfigurationManager.AppSettings["MediaServicesAccountName"];
        private static readonly string _mediaServicesAccountKey =
            ConfigurationManager.AppSettings["MediaServicesAccountKey"];
        
        static void Main(string[] args) 
        {
            _cachedCredentials = new MediaServicesCredentials(_mediaServicesAccountName,
                                                                                _mediaServicesAccountKey);
            _context = new CloudMediaContext(_cachedCredentials); 

            Console.WriteLine("Creating new asset from local file..."); 
 
            // Create a new asset and upload a mezzanine file from a local path. 
            IAsset inputAsset = _context.Assets.CreateFromFile(
                _singleMP4File, 
                AssetCreationOptions.None, 
                (af, p) => 
                { 
                    Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress); 
                }); 
 
            Console.WriteLine("Asset created."); 
 
            // Prepare a job with a single task to transcode the previous mezzanine asset 
            // into a multi-bitrate asset. 
            IJob job = _context.Jobs.CreateWithSingleTask( 
                MediaProcessorNames.WindowsAzureMediaEncoder, 
                MediaEncoderTaskPresetStrings.H264AdaptiveBitrateMP4Set720p, 
                inputAsset, 
                "Sample Adaptive Bitrate MP4", 
                AssetCreationOptions.None); 
 
            Console.WriteLine("Submitting transcoding job..."); 
 
            // Submit the job and wait until it is completed. 
            job.Submit(); 
            job = job.StartExecutionProgressTask( 
                j => 
                { 
                    Console.WriteLine("Job state: {0}", j.State); 
                    Console.WriteLine("Job progress: {0:0.##}%", j.GetOverallProgress()); 
                }, 
                CancellationToken.None).Result; 
 
            Console.WriteLine("Transcoding job finished."); 
             
            // The OutputMediaAssets[0] contains the first 
            // (and in this case the only) output asset 
            // produced by the encoding job.
            IAsset outputAsset = job.OutputMediaAssets[0]; 
 
            Console.WriteLine("Publishing output asset..."); 
 
            // Publish the output asset by creating an Origin locator.  
            // Define the Read only access policy and
            // specify that the asset can be accessed for 30 days.  
            _context.Locators.Create( 
                LocatorType.OnDemandOrigin, 
                outputAsset, 
                AccessPermissions.Read, 
                TimeSpan.FromDays(30));

            // Generate the Smooth Streaming, HLS and MPEG-DASH URLs for adaptive streaming.  
            Uri smoothStreamingUri = outputAsset.GetSmoothStreamingUri();
            Uri hlsUri = outputAsset.GetHlsUri();
            Uri mpegDashUri = outputAsset.GetMpegDashUri();

            // To stream your content based on the set of 
            // adaptive bitrate MP4 files, you must first get 
            // at least one On-demand Streaming reserved unit. 
            // For more information, see http://msdn.microsoft.com/en-us/library/jj889436.aspx.
            Console.WriteLine("Output is now available for adaptive streaming:");

            // Show the streaming URLs. 
            Console.WriteLine(smoothStreamingUri);
            Console.WriteLine(hlsUri);
            Console.WriteLine(mpegDashUri);
                
            //
            // Create a SAS locator that is used for progressive download
            // or to download files to a local directory.  
            // The content that you want to progressively download cannot be encrypted.
            _context.Locators.Create( 
                LocatorType.Sas, 
                outputAsset, 
                AccessPermissions.Read, 
                TimeSpan.FromDays(30)); 

            // Get all the MP4 files in the output asset.
            IEnumerable<IAssetFile> mp4AssetFiles = outputAsset
                    .AssetFiles
                    .ToList()
                    .Where(af => af.Name.EndsWith(".mp4", 
                        StringComparison.OrdinalIgnoreCase));

            // Generate the Progressive Download URLs for each MP4. 
            List<Uri> mp4ProgressiveDownloadUris = 
                mp4AssetFiles.Select(af => af.GetSasUri()).ToList();

            Console.WriteLine("You can progressively download the following MP4 files:");
            mp4ProgressiveDownloadUris.ForEach(uri => Console.WriteLine(uri)); 
 
             string outputFolder = Path.Combine(_mediaFiles, @"job-output");

            if (!Directory.Exists(outputFolder)) 
            { 
                Directory.CreateDirectory(outputFolder); 
            } 
 
            Console.WriteLine("Downloading output asset files to local folder..."); 
 
            // Download the output asset to a local folder. 
            outputAsset.DownloadToFolder( 
                outputFolder, 
                (af, p) => 
                { 
                    Console.WriteLine("Downloading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress); 
                }); 
 
            Console.WriteLine("Downloaded files are located in '{0}'.", Path.GetFullPath(outputFolder)); 
        } 
    } 
} 

Consulte também

Mostrar:
© 2014 Microsoft