Exportar (0) Imprimir
Expandir Tudo

Entregando ativos com o SDK de Serviços de Mídia para .NET

Atualizado: setembro de 2014

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

  • Conteúdo de streaming adaptável em um dos seguintes formatos: MPEG DASH, Apple HTTP Live Streaming (HLS) e Smooth Streaming.

    Assim que você tiver gerado as URLs de streaming (conforme mostrado neste tópico), poderá testá-las usando 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 do HLS, use o Safari em um dispositivo iOS ou 3ivx-hls-player.

  • Download progressivo de arquivos MP4.

  • Baixando arquivos de ativo para o computador local.

Para obter mais informações, conceitos e terminologia relacionados à distribuição de conteúdo de mídia, consulte Entregando 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 realizar a configuração para desenvolvimento de Serviços de Mídia.

  1. Configuração para o desenvolvimento com os Serviços de Mídia SDK para .NET

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

  2. Conectar-se aos Serviços de Mídia usando o SDK de Serviços de Mídia

É possível distribuir (baixar ou transmitir) ativos que já estão armazenados em sua conta de Serviços de Mídia (disponível por meio da coleção de Assets). Você também pode baixar ou transmitir ativos que resultam da execução de codificação ou trabalho de empacotamento (disponíveis por meio da coleção OutputMediaAssets). O exemplo neste tópico mostra como acessar e entregar ativos de mídia de saída do trabalho.

O código nesta seção faz o seguinte:

  1. Cria um novo ativo e carregar um arquivo de mezanino MP4 de um diretório local.

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

  3. Envia o trabalho e aguarda até sua conclusão.

  4. Obtém a saída do ativo que produziu o trabalho de codificação.

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

  6. Gera as URLs de streaming do Smooth, HLS e MPEG-DASH para streaming adaptável.

    Para transmitir o conteúdo com base no conjunto de arquivos MP4 com taxa de bits adaptável, primeiro é necessário obter pelo menos uma unidade reservada de streaming por demanda. Para obter mais informações, consulte Empacotamento Dinâmico.

  7. Cria um localizador SAS que é usado para download progressivo e para baixar arquivos para 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 para uma pasta local.

noteObservação
Este exemplo usa Extensões do SDK .NET de Serviços de Mídia do Azure. As extensões SDK ocultam muitos detalhes. Se você deseja ver como alguns métodos são implementados (por exemplo, como os métodos a seguir criam as URLs de streaming: GetSmoothStreamingUri(), GetHlsUri(), andGetMpegDashUri()), você pode navegar pelo código localizado no github: azure-sdk-for-media-services-extensions.

Atualize o código de forma que ele aponte para a pasta na qual o 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.AzureMediaEncoder, 
                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