Exportar (0) Imprimir
Expandir Tudo

Criando um trabalho de codificação com o SDK de Serviços de Mídia para .NET

Atualizado: julho de 2014

Para fornecer vídeo digital pela Internet, você deve compactar a mídia. Os arquivos de vídeo digital são muito grandes e podem ter um tamanho excessivo para serem distribuídos pela Internet ou para que os dispositivos dos seus clientes os exibam corretamente. Codificação é o processo de compactação de vídeo e áudio para que os seus clientes possam exibir sua mídia.

Trabalhos de codificação são uma das operações de processamento mais comuns nos Serviços de Mídia. Você cria trabalhos de codificação para converter arquivos de mídia de uma codificação para outra. Ao codificar, você pode usar o Media Encoder interno dos Serviços de Mídia. Você também pode usar um codificador fornecido por um parceiro de Serviços de Mídia. Codificadores de terceiros estão disponíveis no Azure Marketplace. É possível especificar os detalhes de trabalhos de codificação usando cadeias de caracteres predefinidas para o seu codificador ou usando arquivos de configuração predefinidos. Para ver os tipos de predefinições disponíveis, consulte Predefinições de tarefa para Windows Azure Media Services. Se você tiver usado um codificador de terceiros, deverá validar seus arquivos.

Durante o trabalho com Serviços de Mídia, um dos cenários comuns é:

  1. Carregar um arquivo de entrada (chamado de arquivo de mezanino). Por exemplo, H.264, MP4 ou WMV (para obter a lista de formatos com suporte, consulte Formatos suportados pelo Media Services Encoder).

  2. Codifique o arquivo de mezanino para conjuntos de taxa de bits adaptáveis MP4 H.264.

    noteObservação
    Convém sempre codificar arquivos de mezanino em um conjunto de MP4 de taxas de bits adaptáveis e, em seguida, converter esse conjunto no formato desejado usando Empacotamento Dinâmico ou Empacotamento estático.

    Se quiser codificar o arquivo de mezanino diretamente para Smooth Streaming, você poderá usar qualquer uma dos predefinições de "Smooth Streaming" descritas em Predefinições do sistema do codificador de Serviços de Mídia. No entanto, isso não é recomendado, a menos que o arquivo de mezanino seja muito pequeno.

    Se quiser converter um arquivo WMV em Smooth Streaming, primeiro você deverá codificar o arquivo para H.264. WMV é um codec de vídeo que, normalmente, tem um formato de contêiner ASF. H.264 é um codec de vídeo que pode ser usado com o formato de contêiner MP4. O Smooth Streaming usa uma variante de MP4 chamada de MP4 fragmentado, ou f-mp4. O Smooth Streaming é um formato de streaming adaptável que requer um conjunto de arquivos de diferentes taxas de bits, todos codificados com fragmentos que estão alinhados nas taxas de bits. Um conjunto de arquivos MP4 que são codificados com fragmentos alinhados pode ser convertido em f-mp4 sem exigir recodificação. Esse não é o caso com arquivos WMV. Para obter mais informações, consulte Visão geral técnica do Smooth Streaming.  

  3. Publique o ativo que contém o conjunto de MP4 de taxas de bits adaptáveis criando o Localizador sob Demanda.

  4. Forneça seu conteúdo aos clientes. Use Empacotamento Dinâmico para fornecer formatos apropriados do seu conteúdo (por exemplo, MPEG DASH, Smooth Streaming e HLS).

    Se quiser proteger seu conteúdo, consulte os tópicos na seção Proteção da mídia.

Este tópico mostra Carregar um arquivo MP4 e produzir conjuntos MP4 de taxas de bits adaptáveis H.264 usando o Azure Media Encoder. Ele também mostra como criar URLs de DASH MPEG, HLS e Smooth Streaming.

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

O exemplo a seguir mostra como criar um trabalho de codificação baseado na cadeia de caracteres predefinida "H264 Adaptive Bitrate MP4 Set 720p". Você pode encontrar uma lista de cadeias de caracteres predefinidas no tópico Predefinições do sistema do codificador de Serviços de Mídia.

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

  1. Carrega um único arquivo .mp4.

  2. Codifica o arquivo .mp4 em um conjunto de MP4s de taxas de bits adaptáveis.

    Depois de codificar seu ativo para um conjunto de taxas de bits adaptáveis H.264, você pode tirar proveito do empacotamento dinâmico. Empacotamento Dinâmico permite distribuir fluxos no protocolo especificado sem a necessidade de empacotamento adicional.

  3. Publica o ativo criando o Localizador sob Demanda.

  4. Obtém URLs de streaming MPEG DASH, Smooth Streaming e HLS. Para obter mais informações, consulte Entregando ativos com o SDK de Serviços de Mídia para .NET.

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

Este exemplo usa Extensões do SDK .NET de Serviços de Mídia do Azure.  

using Microsoft.WindowsAzure.MediaServices.Client;
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 System.Xml.Linq;

namespace MediaServicesPackaging
{
    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)
        {
            // Create and cache the Media Services credentials in a static class variable.
            _cachedCredentials = new MediaServicesCredentials(
                            _mediaServicesAccountName,
                            _mediaServicesAccountKey);

            // Use the cached credentials to create CloudMediaContext.
            _context = new CloudMediaContext(_cachedCredentials);

            // Use the SDK extension method to create a new asset by 
            // uploading a mezzanine file from a local path.
            IAsset asset = _context.Assets.CreateFromFile(
                _singleMP4File,
                AssetCreationOptions.None,
                (af, p) =>
                {
                    Console.WriteLine("Uploading '{0}' - Progress: {1:0.##}%", af.Name, p.Progress);
                });

            // Encode an MP4 file to a set of multibitrate MP4s.
            IAsset assetMultibitrateMP4s =
                EncodeMP4ToMultibitrateMP4s(asset);

            // Publish the asset.
            _context.Locators.Create(
                LocatorType.OnDemandOrigin,
                assetMultibitrateMP4s,
                AccessPermissions.Read,
                TimeSpan.FromDays(30));

            // Get the URLs.
            Console.WriteLine("Smooth Streaming URL:");
            Console.WriteLine(assetMultibitrateMP4s.GetSmoothStreamingUri().ToString());
            Console.WriteLine("MPEG DASH URL:");
            Console.WriteLine(assetMultibitrateMP4s.GetMpegDashUri().ToString());
            Console.WriteLine("HLS URL:");
            Console.WriteLine(assetMultibitrateMP4s.GetHlsUri().ToString());
        }

        public static IAsset EncodeMP4ToMultibitrateMP4s(IAsset asset)
        {
            // Create a new job.
            IJob job = _context.Jobs.Create("Convert MP4 to Smooth Streaming.");

            // In Media Services, a media processor is a component that handles a specific processing task, 
            // such as encoding, format conversion, encrypting, or decrypting media content.
            //
            // Use the SDK extension method to  get a reference to the Azure Media Encoder.
            IMediaProcessor encoder = _context.MediaProcessors.GetLatestMediaProcessorByName(
                MediaProcessorNames.AzureMediaEncoder);

            // Add task 1 - Encode single MP4 into multibitrate MP4s.
            ITask adpativeBitrateTask = job.Tasks.AddNew("MP4 to Adaptive Bitrate Task",
                encoder,
                "H264 Adaptive Bitrate MP4 Set 720p",
                TaskOptions.None);

            // Specify the input Asset
            adpativeBitrateTask.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 in the clear (unencrypted).
            adpativeBitrateTask.OutputAssets.AddNew("Multibitrate MP4s",
                                    AssetCreationOptions.None);

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

            // Get the output asset that contains the smooth stream.
            return job.OutputMediaAssets[0];
        }
    }
}

Crie e execute o programa.

Consulte também

Mostrar:
© 2014 Microsoft