Så här genererar du miniatyrer med Media Encoder Standard med .NET

media services-logotyp


Du kan använda Media Encoder Standard för att generera en eller flera miniatyrer från indata-videon i bild fil formaten JPEG, pngeller BMP . Du kan skicka uppgifter som bara producerar bilder, eller så kan du kombinera miniatyrer med kodning. Den här artikeln innehåller några exempel på XML-och JSON-miniatyrer för sådana scenarier. I slutet av artikeln finns det en exempel kod som visar hur du använder Media Services .NET SDK för att utföra kodnings uppgiften.

Om du vill ha mer information om elementen som används i exempel för för inställningar bör du granska Media Encoder Standard schema.

Se till att gå igenom avsnittet överväganden .

Exempel på en "enskild PNG-fil"-förinställd

Följande JSON-och XML-förinställning kan användas för att skapa en PNG-fil med en enda utdata från de första sekunderna i indata-videon, där kodaren gör ett bästa försök att hitta en "intressant" ram. Observera att måtten för utgående bilder har angetts till 100%, vilket innebär att dessa matchar måtten för inmatnings videon. Observera också hur inställningen "format" i "utdata" krävs för att matcha användningen av "PngLayers" i avsnittet "codecs".

JSON-förinställning

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

XML-förinställd

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

Exempel på en "serie med JPEG-bilder"-förval

Följande JSON-och XML-förinställning kan användas för att skapa en uppsättning 10 bilder vid tidsstämplar på 5%, 15%,..., 95% av tids linjen för indata, där bild storleken anges som en fjärdedel av indata-videon.

JSON-förinställning

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

XML-förinställd

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

Exempel på en för inställning för "en bild vid en speciell tidsstämpel"

Följande JSON-och XML-förinställning kan användas för att skapa en JPEG-bild med det 30 andra märket av indata-videon. Den här inställningen förväntar sig att Indataporten ska vara mer än 30 sekunder lång (annars Miss lyckas jobbet).

JSON-förinställning

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

XML-förinställd

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

Exempel på en inställning för "miniatyrer med olika upplösningar"

Följande för inställningar kan användas för att generera miniatyrer med olika upplösningar i en aktivitet. I exemplet i positionerna 5%, 15%,..., 95% av ingångs tids linjen, genererar kodaren två bilder – en till 100% av video upplösningen och den andra vid 50%.

Observera att {resolution}-makro används i fil namnet; den anger att kodaren ska använda den bredd och höjd som du angav i avsnittet kodning i förvalet när du genererar fil namnet för de utgående bilderna. Detta gör det också lättare att skilja mellan olika avbildningar

JSON-förinställning

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

XML-förinställd

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

Exempel på att skapa en miniatyr vid kodning

Även om alla ovanstående exempel har diskuterat hur du kan skicka en kodnings uppgift som bara genererar bilder, kan du också kombinera video-/ljud kodning med en miniatyr bild. Följande JSON-och XML-förinställning instruerar Media Encoder Standard att generera en miniatyr under kodning.

JSON-förinställning

Information om schema finns i den här artikeln.

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

XML-förinställd

Information om schema finns i den här artikeln.

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

Koda video och generera miniatyr med .NET

I följande kod exempel används Media Services .NET SDK för att utföra följande uppgifter:

  • Skapa ett kodnings jobb.

  • Hämta en referens till Media Encoder Standard Encoder.

  • Läs in den förinställda XML eller JSON som innehåller kodnings för inställningen samt information som behövs för att generera miniatyrer. Du kan spara den här XML- filen eller JSON -filen i en fil och använda följande kod för att läsa in filen.

    // Load the XML (or JSON) from the local file.
    string configuration = File.ReadAllText(fileName);  
    
  • Lägg till en enda kodnings uppgift i jobbet.

  • Ange den inmatade till gång som ska kodas.

  • Skapa en utgående till gång som innehåller den kodade till gången.

  • Lägg till en händelse hanterare för att kontrol lera jobb förloppet.

  • Skicka in jobbet.

I artikeln Media Services utveckling med .net finns anvisningar om hur du konfigurerar din utvecklings miljö.

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

Överväganden

Följande gäller:

  • Om du använder explicita tidsstämplar för start/steg/intervall antas att Indatakällan är minst 1 minut.

  • Jpg/png/BmpImage-element har Start-, steg-och intervall sträng-attribut – dessa kan tolkas som:

    • Ram nummer om de är icke-negativa heltal, till exempel "Start": "120",

    • I förhållande till käll varaktigheten om den uttrycks som% suffix, till exempel "Start": "15%" eller

    • Tidsstämpel om den uttrycks som HH: MM: SS... . Till exempel "Start": "00:01:00"

      Du kan blanda och matcha notationer på samma sätt som du.

      Dessutom stöder start också ett särskilt makro: {Best}, som försöker bestämma den första "intressanta" ramen för innehålls anteckningen: (steg och intervall ignoreras när start är inställt på {Best})

    • Standardvärden: Start: {Best}

  • Utmatnings formatet måste anges explicit för varje bild format: jpg/png/BmpFormat. När den är tillgänglig matchar JpgVideo till JpgFormat och så vidare. OutputFormat introducerar ett nytt bild-codec-särskilt makro: {index}, som måste finnas (en gång och bara en gång) för bild format.

Nästa steg

Du kan kontrol lera jobb förloppet medan kodnings jobbet väntar.

Sökvägar för Media Services-utbildning

Media Services v3 (senaste)

Kolla in den senaste versionen av Azure Media Services!

Media Services v2 (äldre)

Ge feedback

Använd User Voice-forumet för att ge feedback och förslag på hur Azure Media Services kan förbättras. Du kan även gå direkt till någon av följande kategorier:

Se även

Översikt över Media Services kodning