Como gerar miniaturas com o Media Encoder Standard com .NETHow to generate thumbnails using Media Encoder Standard with .NET

logotipo de serviços de mídiamedia services logo


Pode utilizar o Media Encoder Standard para gerar uma ou mais miniaturas a partir do seu vídeo de entrada em formatos JPEG, PNGou ficheiro de imagem BMP.You can use Media Encoder Standard to generate one or more thumbnails from your input video in JPEG, PNG, or BMP image file formats. Pode submeter Tarefas que produzam apenas imagens, ou pode combinar a geração de miniaturas com a codificação.You can submit Tasks that produce only images, or you can combine thumbnail generation with encoding. Este artigo fornece algumas amostras de predefinições de miniatura XML e JSON para tais cenários.This article provides a few sample XML and JSON thumbnail presets for such scenarios. No final do artigo, existe um código de amostra que mostra como utilizar os Serviços de Mídia .NET SDK para realizar a tarefa de codificação.At the end of the article, there is a sample code that shows how to use the Media Services .NET SDK to accomplish the encoding task.

Para obter mais detalhes sobre os elementos que são utilizados nas predefinições da amostra, deve rever o esquema padrão da Media Encoder.For more details on the elements that are used in sample presets, you should review Media Encoder Standard schema.

Certifique-se de rever a secção de Considerações.Make sure to review the Considerations section.

Exemplo de uma predefinição de "ficheiro PNG único"Example of a "single PNG file" preset

A predefinição JSON e XML pode ser usada para produzir um único ficheiro PNG de saída a partir dos primeiros segundos do vídeo de entrada, onde o codificadora faz uma tentativa de melhor esforço para encontrar uma moldura "interessante".The following JSON and XML preset can be used to produce a single output PNG file from the first few seconds of the input video, where the encoder makes a best-effort attempt at finding an “interesting” frame. Note que as dimensões da imagem de saída foram definidas a 100%, o que significa que estas correspondem às dimensões do vídeo de entrada.Note that the output image dimensions have been set to 100%, meaning these match the dimensions of the input video. Note também como a definição de "Formato" em "Outputs" é necessária para corresponder à utilização de "PngLayers" na secção "Codecs".Note also how the “Format” setting in "Outputs" is required to match the use of "PngLayers" in the “Codecs” section.

Predefinição JSONJSON preset

    {
      "Version": 1.0,
      "Codecs": [
        {
          "PngLayers": [
            {
              "Type": "PngLayer",
              "Width": "100%",
              "Height": "100%"
            }
          ],
          "Start": "{Best}",
          "Type": "PngImage"
        }
      ],
      "Outputs": [
        {
          "FileName": "{Basename}_{Index}{Extension}",
          "Format": {
            "Type": "PngFormat"
          }
        }
      ]
    }

Predefinição de XMLXML preset

    <?xml version="1.0" encoding="utf-16"?>
    <Preset xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="https://www.windowsazure.com/media/encoding/Preset/2014/03">
      <Encoding>
        <PngImage Start="{Best}">
          <PngLayers>
            <PngLayer>
              <Width>100%</Width>
              <Height>100%</Height>
            </PngLayer>
          </PngLayers>
        </PngImage>
      </Encoding>
      <Outputs>
        <Output FileName="{Basename}_{Index}{Extension}">
          <PngFormat />
        </Output>
      </Outputs>
    </Preset>

Exemplo de uma predefinição de "série de imagens JPEG"Example of a "series of JPEG images" preset

A predefinição JSON e XML a seguir pode ser usada para produzir um conjunto de 10 imagens em intervalos de tempo de 5%, 15%, ..., 95% da linha temporal de entrada, onde o tamanho da imagem é especificado como um quarto do vídeo de entrada.The following JSON and XML preset can be used to produce a set of 10 images at timestamps of 5%, 15%, …, 95% of the input timeline, where the image size is specified to be one quarter that of the input video.

Predefinição JSONJSON preset

    {
      "Version": 1.0,
      "Codecs": [
        {
          "JpgLayers": [
            {
              "Quality": 90,
              "Type": "JpgLayer",
              "Width": "25%",
              "Height": "25%"
            }
          ],
          "Start": "5%",
          "Step": "10%",
          "Range": "96%",
          "Type": "JpgImage"
        }
      ],
      "Outputs": [
        {
          "FileName": "{Basename}_{Index}{Extension}",
          "Format": {
            "Type": "JpgFormat"
          }
        }
      ]
    }

Predefinição de XMLXML preset

    <?xml version="1.0" encoding="utf-16"?>
    <Preset xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="https://www.windowsazure.com/media/encoding/Preset/2014/03">
      <Encoding>
        <JpgImage Start="5%" Step="10%" Range="96%">
          <JpgLayers>
            <JpgLayer>
              <Width>25%</Width>
              <Height>25%</Height>
              <Quality>90</Quality>
            </JpgLayer>
          </JpgLayers>
        </JpgImage>
      </Encoding>
      <Outputs>
        <Output FileName="{Basename}_{Index}{Extension}">
          <JpgFormat />
        </Output>
      </Outputs>
    </Preset>

Exemplo de uma predefinição de "uma imagem a uma determinada hora"Example of a "one image at a specific timestamp" preset

A predefinição JSON e XML pode ser usada para produzir uma única imagem JPEG na marca de 30 segundos do vídeo de entrada.The following JSON and XML preset can be used to produce a single JPEG image at the 30-second mark of the input video. Esta predefinição espera que o vídeo de entrada tenha mais de 30 segundos de duração (caso contrário o trabalho falha).This preset expects the input video to be more than 30 seconds in duration (else the job fails).

Predefinição JSONJSON preset

    {
      "Version": 1.0,
      "Codecs": [
        {
          "JpgLayers": [
            {
              "Quality": 90,
              "Type": "JpgLayer",
              "Width": "25%",
              "Height": "25%"
            }
          ],
          "Start": "00:00:30",
          "Step": "1",
          "Range": "1",
          "Type": "JpgImage"
        }
      ],
      "Outputs": [
        {
          "FileName": "{Basename}_{Index}{Extension}",
          "Format": {
            "Type": "JpgFormat"
          }
        }
      ]
    }

Predefinição de XMLXML preset

    <?xml version="1.0" encoding="utf-16"?>
    <Preset xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="https://www.windowsazure.com/media/encoding/Preset/2014/03">
      <Encoding>
        <JpgImage Start="00:00:30" Step="00:00:01" Range="00:00:01">
          <JpgLayers>
            <JpgLayer>
              <Width>25%</Width>
              <Height>25%</Height>
              <Quality>90</Quality>
            </JpgLayer>
          </JpgLayers>
        </JpgImage>
      </Encoding>
      <Outputs>
        <Output FileName="{Basename}_{Index}{Extension}">
          <JpgFormat />
        </Output>
      </Outputs>
    </Preset>

Exemplo de "miniaturas em diferentes resoluções" predefinidoExample of a "thumbnails at different resolutions" preset

A predefinição a seguir pode ser usada para gerar miniaturas em diferentes resoluções numa só tarefa.The following preset can be used to generate thumbnails at different resolutions in one task. No exemplo, em posições 5%, 15%, ..., 95% da linha temporal de entrada, o codificader gera duas imagens – uma a 100% da resolução de vídeo de entrada e outra a 50%.In the example, at positions 5%, 15%, …, 95% of the input timeline, the encoder generates two images – one at 100% of the input video resolution and the other at 50%.

Note a utilização de macro {Resolução} no Nome de Ficheiro; indica ao codificadora a utilização da largura e altura especificadas na secção de codificação da predefinição enquanto gera o nome do ficheiro das imagens de saída.Note the use of {Resolution} macro in the FileName; it indicates to the encoder to use the width and height that you specified in the Encoding section of the preset while generating the file name of the output images. Isto também ajuda a distinguir entre as diferentes imagens facilmenteThis also helps you distinguish between the different images easily

Predefinição JSONJSON preset

    {
      "Version": 1.0,
      "Codecs": [
        {
          "JpgLayers": [
        {
          "Quality": 90,
          "Type": "JpgLayer",
          "Width": "100%",
          "Height": "100%"
        },
        {
          "Quality": 90,
          "Type": "JpgLayer",
          "Width": "50%",
          "Height": "50%"
        }

          ],
          "Start": "5%",
          "Step": "10%",
          "Range": "96%",
          "Type": "JpgImage"
        }
      ],
      "Outputs": [
        {
          "FileName": "{Basename}_{Resolution}_{Index}{Extension}",
          "Format": {
        "Type": "JpgFormat"
          }
        }
      ]
    }

Predefinição de XMLXML preset

    <?xml version="1.0" encoding="utf-8"?>
    <Preset xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="https://www.windowsazure.com/media/encoding/Preset/2014/03">
    <Encoding>
    <JpgImage Start="5%" Step="10%" Range="96%"><JpgImage Start="00:00:01" Step="00:00:15">
      <JpgLayers>
       <JpgLayer>
        <Width>100%</Width>
        <Height>100%</Height>
        <Quality>90</Quality>
       </JpgLayer>
       <JpgLayer>
        <Width>50%</Width>
        <Height>50%</Height>
        <Quality>90</Quality>
       </JpgLayer>
      </JpgLayers>
    </JpgImage>
    </Encoding>
    <Outputs>
      <Output FileName="{Basename}_{Resolution}_{Index}{Extension}">
        <JpgFormat/>
      </Output>
    </Outputs>
    </Preset>

Exemplo de gerar uma miniatura enquanto codificaExample of generating a thumbnail while encoding

Embora todos os exemplos acima tenham discutido como pode submeter uma tarefa de codificação que apenas produz imagens, também pode combinar codificação vídeo/áudio com geração de miniaturas.While all of the above examples have discussed how you can submit an encoding task that only produces images, you can also combine video/audio encoding with thumbnail generation. Os seguintes predefinidos JSON e XML dizem ao Media Encoder Standard para gerar uma miniatura durante a codificação.The following JSON and XML preset tell Media Encoder Standard to generate a thumbnail during encoding.

Predefinição JSONJSON preset

Para obter informações sobre esquemas, consulte este artigo.For information about schema, see this article.

    {
      "Version": 1.0,
      "Codecs": [
        {
          "KeyFrameInterval": "00:00:02",
          "SceneChangeDetection": "true",
          "H264Layers": [
            {
              "Profile": "Auto",
              "Level": "auto",
              "Bitrate": 4500,
              "MaxBitrate": 4500,
              "BufferWindow": "00:00:05",
              "Width": 1280,
              "Height": 720,
              "ReferenceFrames": 3,
              "EntropyMode": "Cabac",
              "AdaptiveBFrame": true,
              "Type": "H264Layer",
              "FrameRate": "0/1"
    
            }
          ],
          "Type": "H264Video"
        },
        {
          "JpgLayers": [
            {
              "Quality": 90,
              "Type": "JpgLayer",
              "Width": "100%",
              "Height": "100%"
            }
          ],
          "Start": "{Best}",
          "Type": "JpgImage"
        },
        {
          "Channels": 2,
          "SamplingRate": 48000,
          "Bitrate": 128,
          "Type": "AACAudio"
        }
      ],
      "Outputs": [
        {
          "FileName": "{Basename}_{Index}{Extension}",
          "Format": {
            "Type": "JpgFormat"
          }
        },
        {
          "FileName": "{Basename}_{Resolution}_{VideoBitrate}.mp4",
          "Format": {
            "Type": "MP4Format"
          }
        }
      ]
    }

Predefinição de XMLXML preset

Para obter informações sobre esquemas, consulte este artigo.For information about schema, see this article.

    <?xml version="1.0" encoding="utf-16"?>
    <Preset xmlns:xsd="https://www.w3.org/2001/XMLSchema" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="https://www.windowsazure.com/media/encoding/Preset/2014/03">
      <Encoding>
        <H264Video>
          <KeyFrameInterval>00:00:02</KeyFrameInterval>
          <SceneChangeDetection>true</SceneChangeDetection>
          <H264Layers>
            <H264Layer>
              <Bitrate>4500</Bitrate>
              <Width>1280</Width>
              <Height>720</Height>
              <FrameRate>0/1</FrameRate>
              <Profile>Auto</Profile>
              <Level>auto</Level>
              <BFrames>3</BFrames>
              <ReferenceFrames>3</ReferenceFrames>
              <Slices>0</Slices>
              <AdaptiveBFrame>true</AdaptiveBFrame>
              <EntropyMode>Cabac</EntropyMode>
              <BufferWindow>00:00:05</BufferWindow>
              <MaxBitrate>4500</MaxBitrate>
            </H264Layer>
          </H264Layers>
        </H264Video>
        <AACAudio>
          <Profile>AACLC</Profile>
          <Channels>2</Channels>
          <SamplingRate>48000</SamplingRate>
          <Bitrate>128</Bitrate>
        </AACAudio>
        <JpgImage Start="{Best}">
          <JpgLayers>
            <JpgLayer>
              <Width>100%</Width>
              <Height>100%/Height>
              <Quality>90</Quality>
            </JpgLayer>
          </JpgLayers>
        </JpgImage>
      </Encoding>
      <Outputs>
        <Output FileName="{Basename}_{Resolution}_{VideoBitrate}.mp4">
          <MP4Format />
        </Output>
        <Output FileName="{Basename}_{Index}{Extension}">
          <JpgFormat />
        </Output>
      </Outputs>
    </Preset>   

Codificar vídeo e gerar miniatura com .NETEncode video and generate thumbnail with .NET

O seguinte exemplo de código utiliza os Serviços de Comunicação Social .NET SDK para executar as seguintes tarefas:The following code example uses Media Services .NET SDK to perform the following tasks:

  • Criar um trabalho de codificação.Create an encoding job.

  • Obtenha uma referência ao codificar Media Encoder Standard.Get a reference to the Media Encoder Standard encoder.

  • Carregue o XML predefinido ou o JSON que contenham a predefinição de codificação, bem como as informações necessárias para gerar miniaturas.Load the preset XML or JSON that contain the encoding preset as well as information needed to generate thumbnails. Pode guardar este XML ou JSON num ficheiro e utilizar o seguinte código para carregar o ficheiro.You can save this XML or JSON in a file and use the following code to load the file.

    // Load the XML (or JSON) from the local file.
    string configuration = File.ReadAllText(fileName);  
    
  • Adicione uma única tarefa de codificação ao trabalho.Add a single encoding task to the job.

  • Especifique o ativo de entrada a codificar.Specify the input asset to be encoded.

  • Crie um ativo de saída que contenha o ativo codificado.Create an output asset that contains the encoded asset.

  • Adicione um manipulador de eventos para verificar o progresso do trabalho.Add an event handler to check the job progress.

  • Submeta o trabalho.Submit the job.

Consulte o desenvolvimento dos Serviços de Mídia com artigo .NET para obter instruções sobre como configurar o seu ambiente dev.See the Media Services development with .NET article for directions on how to set up your dev environment.

using System;
using System.Configuration;
using System.IO;
using System.Linq;
using Microsoft.WindowsAzure.MediaServices.Client;
using System.Threading;

namespace EncodeAndGenerateThumbnails
{
    class Program
    {
        // Read values from the App.config file.
        private static readonly string _AADTenantDomain =
        ConfigurationManager.AppSettings["AMSAADTenantDomain"];
        private static readonly string _RESTAPIEndpoint =
        ConfigurationManager.AppSettings["AMSRESTAPIEndpoint"];
        private static readonly string _AMSClientId =
        ConfigurationManager.AppSettings["AMSClientId"];
        private static readonly string _AMSClientSecret =
        ConfigurationManager.AppSettings["AMSClientSecret"];

        private static CloudMediaContext _context = null;

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

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

        static void Main(string[] args)
        {
            AzureAdTokenCredentials tokenCredentials =
                new AzureAdTokenCredentials(_AADTenantDomain,
                    new AzureAdClientSymmetricKey(_AMSClientId, _AMSClientSecret),
                    AzureEnvironments.AzureCloudEnvironment);

            var tokenProvider = new AzureAdTokenProvider(tokenCredentials);

            _context = new CloudMediaContext(new Uri(_RESTAPIEndpoint), tokenProvider);

            // Get an uploaded asset.
            var asset = _context.Assets.FirstOrDefault();

            // Encode and generate the thumbnails.
            EncodeToAdaptiveBitrateMP4Set(asset);

            Console.ReadLine();
        }

        static public IAsset EncodeToAdaptiveBitrateMP4Set(IAsset asset)
        {
            // Declare a new job.
            IJob job = _context.Jobs.Create("Media Encoder Standard Thumbnail Job");
            // Get a media processor reference, and pass to it the name of the 
            // processor to use for the specific task.
            IMediaProcessor processor = GetLatestMediaProcessorByName("Media Encoder Standard");

            // Load the XML (or JSON) from the local file.
            string configuration = File.ReadAllText("ThumbnailPreset_JSON.json");

            // Create a task
            ITask task = job.Tasks.AddNew("Media Encoder Standard Thumbnail task",
                    processor,
                    configuration,
                    TaskOptions.None);

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

            job.StateChanged += new EventHandler<JobStateChangedEventArgs>(JobStateChanged);
            job.Submit();
            job.GetExecutionProgressTask(CancellationToken.None).Wait();

            return job.OutputMediaAssets[0];
        }

        private static void JobStateChanged(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("Job is finished. Please wait while local tasks or downloads complete...");
                    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.
                    break;
                default:
                    break;
            }
        }

        private static IMediaProcessor GetLatestMediaProcessorByName(string mediaProcessorName)
        {
            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;
        }
    }
}

ConsideraçõesConsiderations

As seguintes considerações são aplicáveis:The following considerations apply:

  • A utilização de prazos explícitos para início/passo/alcance pressupõe que a fonte de entrada tenha pelo menos 1 minuto de duração.The use of explicit timestamps for Start/Step/Range assumes that the input source is at least 1 minute long.

  • Os elementos jpg/Png/BmpImage têm atributos de cadeia de arranque, passo e gama - estes podem ser interpretados como:Jpg/Png/BmpImage elements have Start, Step, and Range string attributes – these can be interpreted as:

    • Número de quadro se forem inteiros não negativos, por exemplo "Iniciar": "120",Frame Number if they are non-negative integers, for example "Start": "120",

    • Relativamente à duração da fonte se expressa em %-sufixo, por exemplo "Iniciar": "15%", ORRelative to source duration if expressed as %-suffixed, for example "Start": "15%", OR

    • Tempo de compensação se expresso como HH:MM:SS...Timestamp if expressed as HH:MM:SS… formato.format. Por exemplo " Iniciar" : "00:01:00"For example "Start" : "00:01:00"

      Pode misturar e combinar notações como quiser.You can mix and match notations as you please.

      Além disso, o Start também suporta um Macro:{Best}especial, que tenta determinar a primeira moldura "interessante" do conteúdo NOTA: (Passo e alcance são ignorados quando o Início está definido para {Best})Additionally, Start also supports a special Macro:{Best}, which attempts to determine the first “interesting” frame of the content NOTE: (Step and Range are ignored when Start is set to {Best})

    • Predefinições: Iniciar:{Melhor}Defaults: Start:{Best}

  • O formato de saída deve ser explicitamente fornecido para cada formato de imagem: Jpg/Png/BmpFormat.Output format needs to be explicitly provided for each Image format: Jpg/Png/BmpFormat. Quando presente, o MES corresponde ao JpgVideo com o JpgFormat e assim por diante.When present, MES matches JpgVideo to JpgFormat and so on. OutputFormat introduz um novo macro específico de código de imagem: {Index}, que precisa estar presente (uma vez e apenas uma vez) para os formatos de saída de imagem.OutputFormat introduces a new image-codec specific Macro: {Index}, which needs to be present (once and only once) for image output formats.

Passos seguintesNext steps

Pode verificar o progresso do trabalho enquanto o trabalho de codificação está pendente.You can check the job progress while the encoding job is pending.

Percursos de aprendizagem dos Media ServicesMedia Services learning paths

Serviços de Multimédia do Azure v3 (mais recente)Media Services v3 (latest)

Confira a mais recente versão da Azure Media Services!Check out the latest version of Azure Media Services!

Serviços de Multimédia v2 (legados)Media Services v2 (legacy)

Enviar comentáriosProvide feedback

Utilize o fórum do UserVoice para fornecer comentários e sugestões sobre como melhorar os Serviços de Multimédia do Azure.Use the User Voice forum to provide feedback and make suggestions on how to improve Azure Media Services. Pode também aceder diretamente a uma das seguintes categorias:You also can go directly to one of the following categories:

Consulte tambémSee Also

Visão geral dos serviços de comunicação socialMedia Services Encoding Overview