Come generare anteprime utilizzando Media Encoder Standard con .NET

È possibile usare Media Encoder Standard per generare una o più anteprime dal video di input in un formato file di immagine a scelta tra JPEG, PNG e BMP. È possibile inviare attività che producono solo immagini oppure combinare la generazione di anteprime con la codifica. Questo argomento offre alcuni set di impostazioni di anteprima XML e JSON di esempio per questi scenari. Nella sezione finale dell'argomento è disponibile un codice di esempio che illustra come usare Media Services .NET SDK per eseguire l'attività di codifica.

Per altre informazioni sugli elementi usati nei set di impostazioni di esempio, è necessario rivedere l'argomento Schema di Media Encoder Standard.

Assicurarsi di esaminare la sezione Considerazioni .

Esempio: singolo file PNG

Il set di impostazioni JSON e XML seguente consente di produrre un singolo file PNG di output nei primi secondi del video di input, in cui il codificatore effettua un tentativo con massimo sforzo di trovare un frame "interessante". Osservare come le dimensioni dell'immagine di output siano state impostate su 100% in modo che corrispondano alle dimensioni del video di input. Osservare anche come sia necessario che l'impostazione "Formato" in "Output" corrisposta al tipo di utilizzo di "PngLayers" nella sezione "Codec".

Set di impostazioni JSON

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

Set di impostazioni XML

<?xml version="1.0" encoding="utf-16"?>
<Preset xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="http://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>

Esempio: serie di immagini JPEG

Il set di impostazioni JSON e XML consente di produrre un set di 10 immagini in corrispondenza dei timestamp 5%, 15%,..., 95% della sequenza temporale di input e in cui le dimensioni dell'immagine sono impostate su un quarto del video di input.

Set di impostazioni JSON

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

Set di impostazioni XML

<?xml version="1.0" encoding="utf-16"?>
<Preset xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="http://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>

Esempio: un'immagine in corrispondenza di un timestamp specifico

Il set di impostazioni JSON e XML seguente consente di produrre una singola immagine JPEG ogni 30 secondi di riproduzione del video di input. Questo set di impostazioni prevede che l'input abbia una durata superiore a 30 secondi (in caso contrario, il processo avrà esito negativo).

Set di impostazioni JSON

{
  "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"
      }
    }
  ]
}

Set di impostazioni XML

<?xml version="1.0" encoding="utf-16"?>
<Preset xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="http://www.windowsazure.com/media/encoding/Preset/2014/03">
  <Encoding>
    <JpgImage Start="00:00:30" Step="00:00:02" 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>

Esempio: codificare il video e generare l'anteprima

Il seguente codice usa l'SDK .NET di Servizi multimediali per eseguire le seguenti attività:

  • Creare un processo di codifica.
  • Ottenere un riferimento al codificatore Media Encoder Standard.
  • Caricare il set di impostazioni XML o JSON che contiene la codifica dei set di impostazioni e le informazioni necessarie per generare anteprime. È possibile salvare questo XML o JSON in un file e usare il codice seguente per caricare il file.

      // Load the XML (or JSON) from the local file.
      string configuration = File.ReadAllText(fileName);  
    
  • Aggiungere una singola attività di codifica al processo.
  • Specificare l’asset di input da codificare.
  • Creare un asset di output che conterrà l'asset codificato.
  • Aggiungere un gestore eventi per controllare l'avanzamento del processo.
  • Inviare il processo.

Vedere l'argomento Sviluppo di applicazioni di Servizi multimediali con .NET per istruzioni su come configurare l'ambiente di sviluppo.

    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["AADTenantDomain"];
        private static readonly string _RESTAPIEndpoint =
        ConfigurationManager.AppSettings["MediaServiceRESTAPIEndpoint"];

        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)
        {
        var tokenCredentials = new AzureAdTokenCredentials(_AADTenantDomain, 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 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 encoding 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;
        }
    }
    }

Anteprima JSON predefinito

Per informazioni sullo schema, vedere questo argomento.

{
  "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"
      }
    }
  ]
}

Anteprima XML predefinito

Per informazioni sullo schema, vedere questo argomento.

<?xml version="1.0" encoding="utf-16"?>
<Preset xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Version="1.0" xmlns="http://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>

Considerazioni

Si applicano le considerazioni seguenti:

  • L'utilizzo di timestamp espliciti per Inizio/Passaggio/Intervallo presuppone che l'origine dell'input duri almeno 1 minuto.
  • Gli elementi Jpg/Png/BmpImage hanno gli attributi inizio, passaggio e intervallo della stringa, che possono essere interpretati come:

    • Se sono numeri interi non negativi, numero di frame, ad esempio "Start": "120",
    • Relativi alla durata di origine se espressi con il suffisso %, ad esempio. "Start": "15%", OPPURE
    • Timestamp se espresso come HH:MM:SS (formato). ed esempio "Start" : "00:01:00"

      È possibile combinare e associare le notazioni a piacimento.

      Inoltre, Inizio supporta anche una Macro speciale: {Best}, che tenta di determinare il primo fotogramma "interessante" della NOTA contenuto: (Passaggio e Intervallo vengono ignorati quando Inizio è impostato su {Best})

    • Impostazioni predefinite: Start: {Best}
  • Il formato di output deve essere specificato in modo esplicito per ogni formato immagine: Jpg/Png/BmpFormat. Quando è presente, MES collegherà JpgVideo a JpgFormat e così via. OutputFormat presenta una nuova Macro specifica di codec di immagine : {Index}, che deve essere presente (una volta e una sola volta) per i formati immagine.

Passaggi successivi

Mentre è in corso il processo di codifica, è possibile controllarne lo stato di avanzamento.

Percorsi di apprendimento di Servizi multimediali

I percorsi di apprendimento di Servizi multimediali di Azure sono disponibili qui:

Fornire commenti e suggerimenti

Usare il forum di suggerimenti degli utenti per fornire commenti e suggerimenti su come migliorare Servizi multimediali di Azure. È anche possibile passare direttamente a una delle categorie seguenti:

Vedere anche

Panoramica sulla codifica dei servizi multimediali