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 di set di impostazioni per un singolo file PNG

È possibile usare il set di impostazioni JSON e XML seguente per produrre un singolo file PNG di output dai primi secondi del video di input, in cui il codificatore tenta in tutti i modi 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. Si noti anche che è necessario che l'impostazione "Format" in "Outputs" corrisponda all'uso 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 di set di impostazioni per una 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": "10%",
      "Range": "96%",
      "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 di set di impostazioni per 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 il video di input abbia una durata maggiore di 30 secondi. In caso contrario, il processo non riesce.

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: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>

Esempio di set di impostazioni per anteprime con risoluzioni diverse

È possibile usare il set di impostazioni seguente per generare anteprime con risoluzioni diverse in un'unica attività. Nell'esempio, in corrispondenza delle posizioni 5%, 15%, …, 95% della sequenza temporale di input, il codificatore genera due immagini, una con risoluzione video di input al 100% e l'altra al 50%.

Si noti l'uso della macro {Resolution} in FileName, che indica al codificatore di usare la larghezza e l'altezza specificate nella sezioneEncoding del set di impostazioni durante la generazione del nome file delle immagini di output. In questo modo, è possibile distinguere facilmente tra le diverse immagini

Set di impostazioni JSON

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

Set di impostazioni XML

<?xml version="1.0" encoding="utf-8"?>
<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%"><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>

Esempio di generazione di un'anteprima durante la codifica

Mentre tutti gli esempi precedenti hanno descritto come inviare un'attività di codifica che produce solo immagini, è anche possibile combinare la codifica audio/video con la generazione di anteprime. Il set di impostazioni JSON e XML seguenti indica a Media Encoder Standard di generare un'anteprima durante la codifica.

Set di impostazioni JSON

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

Set di impostazioni XML

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>   

Codificare il video e generare l'anteprima con .NET

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

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

Altre informazioni sui percorsi di apprendimento di Servizi multimediali di Azure:

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