/******************************************************************************* * Copyright 2012-2019 Amazon.com, Inc. or its affiliates. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"). You may not use * this file except in compliance with the License. A copy of the License is located at * * http://aws.amazon.com/apache2.0 * * or in the "license" file accompanying this file. * This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. * ***************************************************************************** * * AWS Tools for Windows (TM) PowerShell (TM) * */ using System; using System.Collections.Generic; using System.Linq; using System.Management.Automation; using System.Text; using Amazon.PowerShell.Common; using Amazon.Runtime; using Amazon.ElasticTranscoder; using Amazon.ElasticTranscoder.Model; namespace Amazon.PowerShell.Cmdlets.ETS { /// <summary> /// The CreatePreset operation creates a preset with settings that you specify. /// /// <important><para> /// Elastic Transcoder checks the CreatePreset settings to ensure that they meet Elastic /// Transcoder requirements and to determine whether they comply with H.264 standards. /// If your settings are not valid for Elastic Transcoder, Elastic Transcoder returns /// an HTTP 400 response (<code>ValidationException</code>) and does not create the preset. /// If the settings are valid for Elastic Transcoder but aren't strictly compliant with /// the H.264 standard, Elastic Transcoder creates the preset and returns a warning message /// in the response. This helps you determine whether your settings comply with the H.264 /// standard while giving you greater flexibility with respect to the video that Elastic /// Transcoder produces. /// </para></important><para> /// Elastic Transcoder uses the H.264 video-compression format. For more information, /// see the International Telecommunication Union publication <i>Recommendation ITU-T /// H.264: Advanced video coding for generic audiovisual services</i>. /// </para> /// </summary> [Cmdlet("New", "ETSPreset", SupportsShouldProcess = true, ConfirmImpact = ConfirmImpact.Medium)] [OutputType("Amazon.ElasticTranscoder.Model.CreatePresetResponse")] [AWSCmdlet("Calls the Amazon Elastic Transcoder CreatePreset API operation.", Operation = new[] {"CreatePreset"}, SelectReturnType = typeof(Amazon.ElasticTranscoder.Model.CreatePresetResponse))] [AWSCmdletOutput("Amazon.ElasticTranscoder.Model.CreatePresetResponse", "This cmdlet returns an Amazon.ElasticTranscoder.Model.CreatePresetResponse object containing multiple properties. The object can also be referenced from properties attached to the cmdlet entry in the $AWSHistory stack." )] public partial class NewETSPresetCmdlet : AmazonElasticTranscoderClientCmdlet, IExecutor { #region Parameter Thumbnails_AspectRatio /// <summary> /// <para> /// <important><para>To better control resolution and aspect ratio of thumbnails, we recommend that you /// use the values <code>MaxWidth</code>, <code>MaxHeight</code>, <code>SizingPolicy</code>, /// and <code>PaddingPolicy</code> instead of <code>Resolution</code> and <code>AspectRatio</code>. /// The two groups of settings are mutually exclusive. Do not use them together.</para></important><para>The aspect ratio of thumbnails. Valid values include:</para><para><code>auto</code>, <code>1:1</code>, <code>4:3</code>, <code>3:2</code>, <code>16:9</code></para><para>If you specify <code>auto</code>, Elastic Transcoder tries to preserve the aspect /// ratio of the video in the output file.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_AspectRatio { get; set; } #endregion #region Parameter Video_AspectRatio /// <summary> /// <para> /// <important><para>To better control resolution and aspect ratio of output videos, we recommend that /// you use the values <code>MaxWidth</code>, <code>MaxHeight</code>, <code>SizingPolicy</code>, /// <code>PaddingPolicy</code>, and <code>DisplayAspectRatio</code> instead of <code>Resolution</code> /// and <code>AspectRatio</code>. The two groups of settings are mutually exclusive. Do /// not use them together.</para></important><para>The display aspect ratio of the video in the output file. Valid values include:</para><para><code>auto</code>, <code>1:1</code>, <code>4:3</code>, <code>3:2</code>, <code>16:9</code></para><para>If you specify <code>auto</code>, Elastic Transcoder tries to preserve the aspect /// ratio of the input file.</para><para>If you specify an aspect ratio for the output file that differs from aspect ratio /// of the input file, Elastic Transcoder adds pillarboxing (black bars on the sides) /// or letterboxing (black bars on the top and bottom) to maintain the aspect ratio of /// the active region of the video.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_AspectRatio { get; set; } #endregion #region Parameter Audio_AudioPackingMode /// <summary> /// <para> /// <para>The method of organizing audio channels and tracks. Use <code>Audio:Channels</code> /// to specify the number of channels in your output, and <code>Audio:AudioPackingMode</code> /// to specify the number of tracks and their relation to the channels. If you do not /// specify an <code>Audio:AudioPackingMode</code>, Elastic Transcoder uses <code>SingleTrack</code>.</para><para>The following values are valid:</para><para><code>SingleTrack</code>, <code>OneChannelPerTrack</code>, and <code>OneChannelPerTrackWithMosTo8Tracks</code></para><para>When you specify <code>SingleTrack</code>, Elastic Transcoder creates a single track /// for your output. The track can have up to eight channels. Use <code>SingleTrack</code> /// for all non-<code>mxf</code> containers.</para><para>The outputs of <code>SingleTrack</code> for a specific channel value and inputs are /// as follows:</para><ul><li><para><code>0</code><b> channels with any input:</b> Audio omitted from the output</para></li><li><para><code>1, 2, or auto </code><b>channels with no audio input:</b> Audio omitted from /// the output</para></li><li><para><code>1 </code><b>channel with any input with audio:</b> One track with one channel, /// downmixed if necessary</para></li><li><para><code>2 </code><b>channels with one track with one channel:</b> One track with two /// identical channels</para></li><li><para><code>2 or auto </code><b>channels with two tracks with one channel each:</b> One /// track with two channels</para></li><li><para><code>2 or auto </code><b>channels with one track with two channels:</b> One track /// with two channels</para></li><li><para><code>2 </code><b>channels with one track with multiple channels:</b> One track /// with two channels</para></li><li><para><code>auto </code><b>channels with one track with one channel:</b> One track with /// one channel</para></li><li><para><code>auto </code><b>channels with one track with multiple channels:</b> One track /// with multiple channels</para></li></ul><para>When you specify <code>OneChannelPerTrack</code>, Elastic Transcoder creates a new /// track for every channel in your output. Your output can have up to eight single-channel /// tracks.</para><para>The outputs of <code>OneChannelPerTrack</code> for a specific channel value and inputs /// are as follows:</para><ul><li><para><code>0 </code><b>channels with any input:</b> Audio omitted from the output</para></li><li><para><code>1, 2, or auto </code><b>channels with no audio input:</b> Audio omitted from /// the output</para></li><li><para><code>1 </code><b>channel with any input with audio:</b> One track with one channel, /// downmixed if necessary</para></li><li><para><code>2 </code><b>channels with one track with one channel:</b> Two tracks with /// one identical channel each</para></li><li><para><code>2 or auto </code><b>channels with two tracks with one channel each:</b> Two /// tracks with one channel each</para></li><li><para><code>2 or auto </code><b>channels with one track with two channels:</b> Two tracks /// with one channel each</para></li><li><para><code>2 </code><b>channels with one track with multiple channels:</b> Two tracks /// with one channel each</para></li><li><para><code>auto </code><b>channels with one track with one channel:</b> One track with /// one channel</para></li><li><para><code>auto </code><b>channels with one track with multiple channels:</b> Up to eight /// tracks with one channel each</para></li></ul><para>When you specify <code>OneChannelPerTrackWithMosTo8Tracks</code>, Elastic Transcoder /// creates eight single-channel tracks for your output. All tracks that do not contain /// audio data from an input channel are MOS, or Mit Out Sound, tracks.</para><para>The outputs of <code>OneChannelPerTrackWithMosTo8Tracks</code> for a specific channel /// value and inputs are as follows:</para><ul><li><para><code>0 </code><b>channels with any input:</b> Audio omitted from the output</para></li><li><para><code>1, 2, or auto </code><b>channels with no audio input:</b> Audio omitted from /// the output</para></li><li><para><code>1 </code><b>channel with any input with audio:</b> One track with one channel, /// downmixed if necessary, plus six MOS tracks</para></li><li><para><code>2 </code><b>channels with one track with one channel:</b> Two tracks with /// one identical channel each, plus six MOS tracks</para></li><li><para><code>2 or auto </code><b>channels with two tracks with one channel each:</b> Two /// tracks with one channel each, plus six MOS tracks</para></li><li><para><code>2 or auto </code><b>channels with one track with two channels:</b> Two tracks /// with one channel each, plus six MOS tracks</para></li><li><para><code>2 </code><b>channels with one track with multiple channels:</b> Two tracks /// with one channel each, plus six MOS tracks</para></li><li><para><code>auto </code><b>channels with one track with one channel:</b> One track with /// one channel, plus seven MOS tracks</para></li><li><para><code>auto </code><b>channels with one track with multiple channels:</b> Up to eight /// tracks with one channel each, plus MOS tracks until there are eight tracks in all</para></li></ul> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Audio_AudioPackingMode { get; set; } #endregion #region Parameter CodecOptions_BitDepth /// <summary> /// <para> /// <para>You can only choose an audio bit depth when you specify <code>flac</code> or <code>pcm</code> /// for the value of Audio:Codec.</para><para>The bit depth of a sample is how many bits of information are included in the audio /// samples. The higher the bit depth, the better the audio, but the larger the file.</para><para>Valid values are <code>16</code> and <code>24</code>.</para><para>The most common bit depth is <code>24</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Audio_CodecOptions_BitDepth")] public System.String CodecOptions_BitDepth { get; set; } #endregion #region Parameter CodecOptions_BitOrder /// <summary> /// <para> /// <para>You can only choose an audio bit order when you specify <code>pcm</code> for the value /// of Audio:Codec.</para><para>The order the bits of a PCM sample are stored in.</para><para>The supported value is <code>LittleEndian</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Audio_CodecOptions_BitOrder")] public System.String CodecOptions_BitOrder { get; set; } #endregion #region Parameter Audio_BitRate /// <summary> /// <para> /// <para>The bit rate of the audio stream in the output file, in kilobits/second. Enter an /// integer between 64 and 320, inclusive.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Audio_BitRate { get; set; } #endregion #region Parameter Video_BitRate /// <summary> /// <para> /// <para>The bit rate of the video stream in the output file, in kilobits/second. Valid values /// depend on the values of <code>Level</code> and <code>Profile</code>. If you specify /// <code>auto</code>, Elastic Transcoder uses the detected bit rate of the input source. /// If you specify a value other than <code>auto</code>, we recommend that you specify /// a value less than or equal to the maximum H.264-compliant value listed for your level /// and profile:</para><para><i>Level - Maximum video bit rate in kilobits/second (baseline and main Profile) /// : maximum video bit rate in kilobits/second (high Profile)</i></para><ul><li><para>1 - 64 : 80</para></li><li><para>1b - 128 : 160</para></li><li><para>1.1 - 192 : 240</para></li><li><para>1.2 - 384 : 480</para></li><li><para>1.3 - 768 : 960</para></li><li><para>2 - 2000 : 2500</para></li><li><para>3 - 10000 : 12500</para></li><li><para>3.1 - 14000 : 17500</para></li><li><para>3.2 - 20000 : 25000</para></li><li><para>4 - 20000 : 25000</para></li><li><para>4.1 - 50000 : 62500</para></li></ul> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_BitRate { get; set; } #endregion #region Parameter Audio_Channel /// <summary> /// <para> /// <para>The number of audio channels in the output file. The following values are valid:</para><para><code>auto</code>, <code>0</code>, <code>1</code>, <code>2</code></para><para>One channel carries the information played by a single speaker. For example, a stereo /// track with two channels sends one channel to the left speaker, and the other channel /// to the right speaker. The output channels are organized into tracks. If you want Elastic /// Transcoder to automatically detect the number of audio channels in the input file /// and use that value for the output file, select <code>auto</code>.</para><para>The output of a specific channel value and inputs are as follows:</para><ul><li><para><code>auto</code><b> channel specified, with any input:</b> Pass through up to eight /// input channels.</para></li><li><para><code>0</code><b> channels specified, with any input:</b> Audio omitted from the /// output.</para></li><li><para><code>1</code><b> channel specified, with at least one input channel:</b> Mono sound.</para></li><li><para><code>2</code><b> channels specified, with any input:</b> Two identical mono channels /// or stereo. For more information about tracks, see <code>Audio:AudioPackingMode.</code></para></li></ul><para> For more information about how Elastic Transcoder organizes channels and tracks, /// see <code>Audio:AudioPackingMode</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Audio_Channels")] public System.String Audio_Channel { get; set; } #endregion #region Parameter Audio_Codec /// <summary> /// <para> /// <para>The audio codec for the output file. Valid values include <code>aac</code>, <code>flac</code>, /// <code>mp2</code>, <code>mp3</code>, <code>pcm</code>, and <code>vorbis</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Audio_Codec { get; set; } #endregion #region Parameter Video_Codec /// <summary> /// <para> /// <para>The video codec for the output file. Valid values include <code>gif</code>, <code>H.264</code>, /// <code>mpeg2</code>, <code>vp8</code>, and <code>vp9</code>. You can only specify <code>vp8</code> /// and <code>vp9</code> when the container type is <code>webm</code>, <code>gif</code> /// when the container type is <code>gif</code>, and <code>mpeg2</code> when the container /// type is <code>mpg</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_Codec { get; set; } #endregion #region Parameter Video_CodecOption /// <summary> /// <para> /// <para><b>Profile (H.264/VP8/VP9 Only)</b></para><para>The H.264 profile that you want to use for the output file. Elastic Transcoder supports /// the following profiles:</para><ul><li><para><code>baseline</code>: The profile most commonly used for videoconferencing and for /// mobile applications.</para></li><li><para><code>main</code>: The profile used for standard-definition digital TV broadcasts.</para></li><li><para><code>high</code>: The profile used for high-definition digital TV broadcasts and /// for Blu-ray discs.</para></li></ul><para><b>Level (H.264 Only)</b></para><para>The H.264 level that you want to use for the output file. Elastic Transcoder supports /// the following levels:</para><para><code>1</code>, <code>1b</code>, <code>1.1</code>, <code>1.2</code>, <code>1.3</code>, /// <code>2</code>, <code>2.1</code>, <code>2.2</code>, <code>3</code>, <code>3.1</code>, /// <code>3.2</code>, <code>4</code>, <code>4.1</code></para><para><b>MaxReferenceFrames (H.264 Only)</b></para><para>Applicable only when the value of Video:Codec is H.264. The maximum number of previously /// decoded frames to use as a reference for decoding future frames. Valid values are /// integers 0 through 16, but we recommend that you not use a value greater than the /// following:</para><para><code>Min(Floor(Maximum decoded picture buffer in macroblocks * 256 / (Width in pixels /// * Height in pixels)), 16)</code></para><para>where <i>Width in pixels</i> and <i>Height in pixels</i> represent either MaxWidth /// and MaxHeight, or Resolution. <i>Maximum decoded picture buffer in macroblocks</i> /// depends on the value of the <code>Level</code> object. See the list below. (A macroblock /// is a block of pixels measuring 16x16.) </para><ul><li><para>1 - 396</para></li><li><para>1b - 396</para></li><li><para>1.1 - 900</para></li><li><para>1.2 - 2376</para></li><li><para>1.3 - 2376</para></li><li><para>2 - 2376</para></li><li><para>2.1 - 4752</para></li><li><para>2.2 - 8100</para></li><li><para>3 - 8100</para></li><li><para>3.1 - 18000</para></li><li><para>3.2 - 20480</para></li><li><para>4 - 32768</para></li><li><para>4.1 - 32768</para></li></ul><para><b>MaxBitRate (Optional, H.264/MPEG2/VP8/VP9 only)</b></para><para>The maximum number of bits per second in a video buffer; the size of the buffer is /// specified by <code>BufferSize</code>. Specify a value between 16 and 62,500. You can /// reduce the bandwidth required to stream a video by reducing the maximum bit rate, /// but this also reduces the quality of the video.</para><para><b>BufferSize (Optional, H.264/MPEG2/VP8/VP9 only)</b></para><para>The maximum number of bits in any x seconds of the output video. This window is commonly /// 10 seconds, the standard segment duration when you're using FMP4 or MPEG-TS for the /// container type of the output video. Specify an integer greater than 0. If you specify /// <code>MaxBitRate</code> and omit <code>BufferSize</code>, Elastic Transcoder sets /// <code>BufferSize</code> to 10 times the value of <code>MaxBitRate</code>.</para><para><b>InterlacedMode (Optional, H.264/MPEG2 Only)</b></para><para>The interlace mode for the output video.</para><para>Interlaced video is used to double the perceived frame rate for a video by interlacing /// two fields (one field on every other line, the other field on the other lines) so /// that the human eye registers multiple pictures per frame. Interlacing reduces the /// bandwidth required for transmitting a video, but can result in blurred images and /// flickering.</para><para>Valid values include <code>Progressive</code> (no interlacing, top to bottom), <code>TopFirst</code> /// (top field first), <code>BottomFirst</code> (bottom field first), and <code>Auto</code>.</para><para>If <code>InterlaceMode</code> is not specified, Elastic Transcoder uses <code>Progressive</code> /// for the output. If <code>Auto</code> is specified, Elastic Transcoder interlaces the /// output.</para><para><b>ColorSpaceConversionMode (Optional, H.264/MPEG2 Only)</b></para><para>The color space conversion Elastic Transcoder applies to the output video. Color spaces /// are the algorithms used by the computer to store information about how to render color. /// <code>Bt.601</code> is the standard for standard definition video, while <code>Bt.709</code> /// is the standard for high definition video.</para><para>Valid values include <code>None</code>, <code>Bt709toBt601</code>, <code>Bt601toBt709</code>, /// and <code>Auto</code>.</para><para>If you chose <code>Auto</code> for <code>ColorSpaceConversionMode</code> and your /// output is interlaced, your frame rate is one of <code>23.97</code>, <code>24</code>, /// <code>25</code>, <code>29.97</code>, <code>50</code>, or <code>60</code>, your <code>SegmentDuration</code> /// is null, and you are using one of the resolution changes from the list below, Elastic /// Transcoder applies the following color space conversions:</para><ul><li><para><i>Standard to HD, 720x480 to 1920x1080</i> - Elastic Transcoder applies <code>Bt601ToBt709</code></para></li><li><para><i>Standard to HD, 720x576 to 1920x1080</i> - Elastic Transcoder applies <code>Bt601ToBt709</code></para></li><li><para><i>HD to Standard, 1920x1080 to 720x480</i> - Elastic Transcoder applies <code>Bt709ToBt601</code></para></li><li><para><i>HD to Standard, 1920x1080 to 720x576</i> - Elastic Transcoder applies <code>Bt709ToBt601</code></para></li></ul><note><para>Elastic Transcoder may change the behavior of the <code>ColorspaceConversionMode</code><code>Auto</code> mode in the future. All outputs in a playlist must use the same /// <code>ColorSpaceConversionMode</code>.</para></note><para>If you do not specify a <code>ColorSpaceConversionMode</code>, Elastic Transcoder /// does not change the color space of a file. If you are unsure what <code>ColorSpaceConversionMode</code> /// was applied to your output file, you can check the <code>AppliedColorSpaceConversion</code> /// parameter included in your job response. If your job does not have an <code>AppliedColorSpaceConversion</code> /// in its response, no <code>ColorSpaceConversionMode</code> was applied.</para><para><b>ChromaSubsampling</b></para><para>The sampling pattern for the chroma (color) channels of the output video. Valid values /// include <code>yuv420p</code> and <code>yuv422p</code>.</para><para><code>yuv420p</code> samples the chroma information of every other horizontal and /// every other vertical line, <code>yuv422p</code> samples the color information of every /// horizontal line and every other vertical line.</para><para><b>LoopCount (Gif Only)</b></para><para>The number of times you want the output gif to loop. Valid values include <code>Infinite</code> /// and integers between <code>0</code> and <code>100</code>, inclusive.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Video_CodecOptions")] public System.Collections.Hashtable Video_CodecOption { get; set; } #endregion #region Parameter Container /// <summary> /// <para> /// <para>The container type for the output file. Valid values include <code>flac</code>, <code>flv</code>, /// <code>fmp4</code>, <code>gif</code>, <code>mp3</code>, <code>mp4</code>, <code>mpg</code>, /// <code>mxf</code>, <code>oga</code>, <code>ogg</code>, <code>ts</code>, and <code>webm</code>.</para> /// </para> /// </summary> #if !MODULAR [System.Management.Automation.Parameter(Position = 2, ValueFromPipelineByPropertyName = true)] #else [System.Management.Automation.Parameter(Position = 2, ValueFromPipelineByPropertyName = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String Container { get; set; } #endregion #region Parameter Description /// <summary> /// <para> /// <para>A description of the preset.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(Position = 1, ValueFromPipelineByPropertyName = true)] public System.String Description { get; set; } #endregion #region Parameter Video_DisplayAspectRatio /// <summary> /// <para> /// <para>The value that Elastic Transcoder adds to the metadata in the output file.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_DisplayAspectRatio { get; set; } #endregion #region Parameter Video_FixedGOP /// <summary> /// <para> /// <para>Applicable only when the value of Video:Codec is one of <code>H.264</code>, <code>MPEG2</code>, /// or <code>VP8</code>.</para><para>Whether to use a fixed value for <code>FixedGOP</code>. Valid values are <code>true</code> /// and <code>false</code>:</para><ul><li><para><code>true</code>: Elastic Transcoder uses the value of <code>KeyframesMaxDist</code> /// for the distance between key frames (the number of frames in a group of pictures, /// or GOP).</para></li><li><para><code>false</code>: The distance between key frames can vary.</para></li></ul><important><para><code>FixedGOP</code> must be set to <code>true</code> for <code>fmp4</code> containers.</para></important> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_FixedGOP { get; set; } #endregion #region Parameter Thumbnails_Format /// <summary> /// <para> /// <para>The format of thumbnails, if any. Valid values are <code>jpg</code> and <code>png</code>. /// </para><para>You specify whether you want Elastic Transcoder to create thumbnails when you create /// a job.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_Format { get; set; } #endregion #region Parameter Video_FrameRate /// <summary> /// <para> /// <para>The frames per second for the video stream in the output file. Valid values include:</para><para><code>auto</code>, <code>10</code>, <code>15</code>, <code>23.97</code>, <code>24</code>, /// <code>25</code>, <code>29.97</code>, <code>30</code>, <code>60</code></para><para>If you specify <code>auto</code>, Elastic Transcoder uses the detected frame rate /// of the input source. If you specify a frame rate, we recommend that you perform the /// following calculation:</para><para><code>Frame rate = maximum recommended decoding speed in luma samples/second / (width /// in pixels * height in pixels)</code></para><para>where:</para><ul><li><para><i>width in pixels</i> and <i>height in pixels</i> represent the Resolution of the /// output video.</para></li><li><para><i>maximum recommended decoding speed in Luma samples/second</i> is less than or /// equal to the maximum value listed in the following table, based on the value that /// you specified for Level.</para></li></ul><para>The maximum recommended decoding speed in Luma samples/second for each level is described /// in the following list (<i>Level - Decoding speed</i>):</para><ul><li><para>1 - 380160</para></li><li><para>1b - 380160</para></li><li><para>1.1 - 76800</para></li><li><para>1.2 - 1536000</para></li><li><para>1.3 - 3041280</para></li><li><para>2 - 3041280</para></li><li><para>2.1 - 5068800</para></li><li><para>2.2 - 5184000</para></li><li><para>3 - 10368000</para></li><li><para>3.1 - 27648000</para></li><li><para>3.2 - 55296000</para></li><li><para>4 - 62914560</para></li><li><para>4.1 - 62914560</para></li></ul> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_FrameRate { get; set; } #endregion #region Parameter Thumbnails_Interval /// <summary> /// <para> /// <para>The approximate number of seconds between thumbnails. Specify an integer value.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_Interval { get; set; } #endregion #region Parameter Video_KeyframesMaxDist /// <summary> /// <para> /// <para>Applicable only when the value of Video:Codec is one of <code>H.264</code>, <code>MPEG2</code>, /// or <code>VP8</code>.</para><para>The maximum number of frames between key frames. Key frames are fully encoded frames; /// the frames between key frames are encoded based, in part, on the content of the key /// frames. The value is an integer formatted as a string; valid values are between 1 /// (every frame is a key frame) and 100000, inclusive. A higher value results in higher /// compression but may also discernibly decrease video quality.</para><para>For <code>Smooth</code> outputs, the <code>FrameRate</code> must have a constant ratio /// to the <code>KeyframesMaxDist</code>. This allows <code>Smooth</code> playlists to /// switch between different quality levels while the file is being played.</para><para>For example, an input file can have a <code>FrameRate</code> of 30 with a <code>KeyframesMaxDist</code> /// of 90. The output file then needs to have a ratio of 1:3. Valid outputs would have /// <code>FrameRate</code> of 30, 25, and 10, and <code>KeyframesMaxDist</code> of 90, /// 75, and 30, respectively.</para><para>Alternately, this can be achieved by setting <code>FrameRate</code> to auto and having /// the same values for <code>MaxFrameRate</code> and <code>KeyframesMaxDist</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_KeyframesMaxDist { get; set; } #endregion #region Parameter Video_MaxFrameRate /// <summary> /// <para> /// <para>If you specify <code>auto</code> for <code>FrameRate</code>, Elastic Transcoder uses /// the frame rate of the input video for the frame rate of the output video. Specify /// the maximum frame rate that you want Elastic Transcoder to use when the frame rate /// of the input video is greater than the desired maximum frame rate of the output video. /// Valid values include: <code>10</code>, <code>15</code>, <code>23.97</code>, <code>24</code>, /// <code>25</code>, <code>29.97</code>, <code>30</code>, <code>60</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_MaxFrameRate { get; set; } #endregion #region Parameter Thumbnails_MaxHeight /// <summary> /// <para> /// <para>The maximum height of thumbnails in pixels. If you specify auto, Elastic Transcoder /// uses 1080 (Full HD) as the default value. If you specify a numeric value, enter an /// even integer between 32 and 3072.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_MaxHeight { get; set; } #endregion #region Parameter Video_MaxHeight /// <summary> /// <para> /// <para>The maximum height of the output video in pixels. If you specify <code>auto</code>, /// Elastic Transcoder uses 1080 (Full HD) as the default value. If you specify a numeric /// value, enter an even integer between 96 and 3072.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_MaxHeight { get; set; } #endregion #region Parameter Thumbnails_MaxWidth /// <summary> /// <para> /// <para>The maximum width of thumbnails in pixels. If you specify auto, Elastic Transcoder /// uses 1920 (Full HD) as the default value. If you specify a numeric value, enter an /// even integer between 32 and 4096.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_MaxWidth { get; set; } #endregion #region Parameter Video_MaxWidth /// <summary> /// <para> /// <para> The maximum width of the output video in pixels. If you specify <code>auto</code>, /// Elastic Transcoder uses 1920 (Full HD) as the default value. If you specify a numeric /// value, enter an even integer between 128 and 4096. </para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_MaxWidth { get; set; } #endregion #region Parameter Name /// <summary> /// <para> /// <para>The name of the preset. We recommend that the name be unique within the AWS account, /// but uniqueness is not enforced.</para> /// </para> /// </summary> #if !MODULAR [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true)] #else [System.Management.Automation.Parameter(Position = 0, ValueFromPipelineByPropertyName = true, ValueFromPipeline = true, Mandatory = true)] [System.Management.Automation.AllowEmptyString] [System.Management.Automation.AllowNull] #endif [Amazon.PowerShell.Common.AWSRequiredParameter] public System.String Name { get; set; } #endregion #region Parameter Thumbnails_PaddingPolicy /// <summary> /// <para> /// <para>When you set <code>PaddingPolicy</code> to <code>Pad</code>, Elastic Transcoder may /// add black bars to the top and bottom and/or left and right sides of thumbnails to /// make the total size of the thumbnails match the values that you specified for thumbnail /// <code>MaxWidth</code> and <code>MaxHeight</code> settings.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_PaddingPolicy { get; set; } #endregion #region Parameter Video_PaddingPolicy /// <summary> /// <para> /// <para>When you set <code>PaddingPolicy</code> to <code>Pad</code>, Elastic Transcoder may /// add black bars to the top and bottom and/or left and right sides of the output video /// to make the total size of the output video match the values that you specified for /// <code>MaxWidth</code> and <code>MaxHeight</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_PaddingPolicy { get; set; } #endregion #region Parameter CodecOptions_Profile /// <summary> /// <para> /// <para>You can only choose an audio profile when you specify AAC for the value of Audio:Codec.</para><para>Specify the AAC profile for the output file. Elastic Transcoder supports the following /// profiles:</para><ul><li><para><code>auto</code>: If you specify <code>auto</code>, Elastic Transcoder selects the /// profile based on the bit rate selected for the output file.</para></li><li><para><code>AAC-LC</code>: The most common AAC profile. Use for bit rates larger than 64 /// kbps.</para></li><li><para><code>HE-AAC</code>: Not supported on some older players and devices. Use for bit /// rates between 40 and 80 kbps.</para></li><li><para><code>HE-AACv2</code>: Not supported on some players and devices. Use for bit rates /// less than 48 kbps.</para></li></ul><para>All outputs in a <code>Smooth</code> playlist must have the same value for <code>Profile</code>.</para><note><para>If you created any presets before AAC profiles were added, Elastic Transcoder automatically /// updated your presets to use AAC-LC. You can change the value as required.</para></note> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Audio_CodecOptions_Profile")] public System.String CodecOptions_Profile { get; set; } #endregion #region Parameter Thumbnails_Resolution /// <summary> /// <para> /// <important><para>To better control resolution and aspect ratio of thumbnails, we recommend that you /// use the values <code>MaxWidth</code>, <code>MaxHeight</code>, <code>SizingPolicy</code>, /// and <code>PaddingPolicy</code> instead of <code>Resolution</code> and <code>AspectRatio</code>. /// The two groups of settings are mutually exclusive. Do not use them together.</para></important><para>The width and height of thumbnail files in pixels. Specify a value in the format <code><i>width</i></code> x <code><i>height</i></code> where both values are even integers. /// The values cannot exceed the width and height that you specified in the <code>Video:Resolution</code> /// object.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_Resolution { get; set; } #endregion #region Parameter Video_Resolution /// <summary> /// <para> /// <important><para>To better control resolution and aspect ratio of output videos, we recommend that /// you use the values <code>MaxWidth</code>, <code>MaxHeight</code>, <code>SizingPolicy</code>, /// <code>PaddingPolicy</code>, and <code>DisplayAspectRatio</code> instead of <code>Resolution</code> /// and <code>AspectRatio</code>. The two groups of settings are mutually exclusive. Do /// not use them together.</para></important><para>The width and height of the video in the output file, in pixels. Valid values are /// <code>auto</code> and <i>width</i> x <i>height</i>:</para><ul><li><para><code>auto</code>: Elastic Transcoder attempts to preserve the width and height of /// the input file, subject to the following rules.</para></li><li><para><code><i>width</i> x <i>height</i></code>: The width and height of the output video /// in pixels.</para></li></ul><para>Note the following about specifying the width and height:</para><ul><li><para>The width must be an even integer between 128 and 4096, inclusive.</para></li><li><para>The height must be an even integer between 96 and 3072, inclusive.</para></li><li><para>If you specify a resolution that is less than the resolution of the input file, Elastic /// Transcoder rescales the output file to the lower resolution.</para></li><li><para>If you specify a resolution that is greater than the resolution of the input file, /// Elastic Transcoder rescales the output to the higher resolution.</para></li><li><para>We recommend that you specify a resolution for which the product of width and height /// is less than or equal to the applicable value in the following list (<i>List - Max /// width x height value</i>):</para><ul><li><para>1 - 25344</para></li><li><para>1b - 25344</para></li><li><para>1.1 - 101376</para></li><li><para>1.2 - 101376</para></li><li><para>1.3 - 101376</para></li><li><para>2 - 101376</para></li><li><para>2.1 - 202752</para></li><li><para>2.2 - 404720</para></li><li><para>3 - 404720</para></li><li><para>3.1 - 921600</para></li><li><para>3.2 - 1310720</para></li><li><para>4 - 2097152</para></li><li><para>4.1 - 2097152</para></li></ul></li></ul> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_Resolution { get; set; } #endregion #region Parameter Audio_SampleRate /// <summary> /// <para> /// <para>The sample rate of the audio stream in the output file, in Hertz. Valid values include:</para><para><code>auto</code>, <code>22050</code>, <code>32000</code>, <code>44100</code>, <code>48000</code>, /// <code>96000</code></para><para>If you specify <code>auto</code>, Elastic Transcoder automatically detects the sample /// rate.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Audio_SampleRate { get; set; } #endregion #region Parameter CodecOptions_Signed /// <summary> /// <para> /// <para>You can only choose whether an audio sample is signed when you specify <code>pcm</code> /// for the value of Audio:Codec.</para><para>Whether audio samples are represented with negative and positive numbers (signed) /// or only positive numbers (unsigned).</para><para>The supported value is <code>Signed</code>.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Audio_CodecOptions_Signed")] public System.String CodecOptions_Signed { get; set; } #endregion #region Parameter Thumbnails_SizingPolicy /// <summary> /// <para> /// <para>Specify one of the following values to control scaling of thumbnails:</para><ul><li><para><code>Fit</code>: Elastic Transcoder scales thumbnails so they match the value that /// you specified in thumbnail MaxWidth or MaxHeight settings without exceeding the other /// value. </para></li><li><para><code>Fill</code>: Elastic Transcoder scales thumbnails so they match the value that /// you specified in thumbnail <code>MaxWidth</code> or <code>MaxHeight</code> settings /// and matches or exceeds the other value. Elastic Transcoder centers the image in thumbnails /// and then crops in the dimension (if any) that exceeds the maximum value.</para></li><li><para><code>Stretch</code>: Elastic Transcoder stretches thumbnails to match the values /// that you specified for thumbnail <code>MaxWidth</code> and <code>MaxHeight</code> /// settings. If the relative proportions of the input video and thumbnails are different, /// the thumbnails will be distorted.</para></li><li><para><code>Keep</code>: Elastic Transcoder does not scale thumbnails. If either dimension /// of the input video exceeds the values that you specified for thumbnail <code>MaxWidth</code> /// and <code>MaxHeight</code> settings, Elastic Transcoder crops the thumbnails.</para></li><li><para><code>ShrinkToFit</code>: Elastic Transcoder scales thumbnails down so that their /// dimensions match the values that you specified for at least one of thumbnail <code>MaxWidth</code> /// and <code>MaxHeight</code> without exceeding either value. If you specify this option, /// Elastic Transcoder does not scale thumbnails up.</para></li><li><para><code>ShrinkToFill</code>: Elastic Transcoder scales thumbnails down so that their /// dimensions match the values that you specified for at least one of <code>MaxWidth</code> /// and <code>MaxHeight</code> without dropping below either value. If you specify this /// option, Elastic Transcoder does not scale thumbnails up.</para></li></ul> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Thumbnails_SizingPolicy { get; set; } #endregion #region Parameter Video_SizingPolicy /// <summary> /// <para> /// <para>Specify one of the following values to control scaling of the output video:</para><ul><li><para><code>Fit</code>: Elastic Transcoder scales the output video so it matches the value /// that you specified in either <code>MaxWidth</code> or <code>MaxHeight</code> without /// exceeding the other value.</para></li><li><para><code>Fill</code>: Elastic Transcoder scales the output video so it matches the value /// that you specified in either <code>MaxWidth</code> or <code>MaxHeight</code> and matches /// or exceeds the other value. Elastic Transcoder centers the output video and then crops /// it in the dimension (if any) that exceeds the maximum value.</para></li><li><para><code>Stretch</code>: Elastic Transcoder stretches the output video to match the /// values that you specified for <code>MaxWidth</code> and <code>MaxHeight</code>. If /// the relative proportions of the input video and the output video are different, the /// output video will be distorted.</para></li><li><para><code>Keep</code>: Elastic Transcoder does not scale the output video. If either /// dimension of the input video exceeds the values that you specified for <code>MaxWidth</code> /// and <code>MaxHeight</code>, Elastic Transcoder crops the output video.</para></li><li><para><code>ShrinkToFit</code>: Elastic Transcoder scales the output video down so that /// its dimensions match the values that you specified for at least one of <code>MaxWidth</code> /// and <code>MaxHeight</code> without exceeding either value. If you specify this option, /// Elastic Transcoder does not scale the video up.</para></li><li><para><code>ShrinkToFill</code>: Elastic Transcoder scales the output video down so that /// its dimensions match the values that you specified for at least one of <code>MaxWidth</code> /// and <code>MaxHeight</code> without dropping below either value. If you specify this /// option, Elastic Transcoder does not scale the video up.</para></li></ul> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public System.String Video_SizingPolicy { get; set; } #endregion #region Parameter Video_Watermark /// <summary> /// <para> /// <para>Settings for the size, location, and opacity of graphics that you want Elastic Transcoder /// to overlay over videos that are transcoded using this preset. You can specify settings /// for up to four watermarks. Watermarks appear in the specified size and location, and /// with the specified opacity for the duration of the transcoded video.</para><para>Watermarks can be in .png or .jpg format. If you want to display a watermark that /// is not rectangular, use the .png format, which supports transparency.</para><para>When you create a job that uses this preset, you specify the .png or .jpg graphics /// that you want Elastic Transcoder to include in the transcoded videos. You can specify /// fewer graphics in the job than you specify watermark settings in the preset, which /// allows you to use the same preset for up to four watermarks that have different dimensions.</para> /// </para> /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] [Alias("Video_Watermarks")] public Amazon.ElasticTranscoder.Model.PresetWatermark[] Video_Watermark { get; set; } #endregion #region Parameter Select /// <summary> /// Use the -Select parameter to control the cmdlet output. The default value is '*'. /// Specifying -Select '*' will result in the cmdlet returning the whole service response (Amazon.ElasticTranscoder.Model.CreatePresetResponse). /// Specifying the name of a property of type Amazon.ElasticTranscoder.Model.CreatePresetResponse will result in that property being returned. /// Specifying -Select '^ParameterName' will result in the cmdlet returning the selected cmdlet parameter value. /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public string Select { get; set; } = "*"; #endregion #region Parameter PassThru /// <summary> /// Changes the cmdlet behavior to return the value passed to the Name parameter. /// The -PassThru parameter is deprecated, use -Select '^Name' instead. This parameter will be removed in a future version. /// </summary> [System.Obsolete("The -PassThru parameter is deprecated, use -Select '^Name' instead. This parameter will be removed in a future version.")] [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter PassThru { get; set; } #endregion #region Parameter Force /// <summary> /// This parameter overrides confirmation prompts to force /// the cmdlet to continue its operation. This parameter should always /// be used with caution. /// </summary> [System.Management.Automation.Parameter(ValueFromPipelineByPropertyName = true)] public SwitchParameter Force { get; set; } #endregion protected override void ProcessRecord() { this._AWSSignerType = "v4"; base.ProcessRecord(); var resourceIdentifiersText = FormatParameterValuesForConfirmationMsg(nameof(this.Name), MyInvocation.BoundParameters); if (!ConfirmShouldProceed(this.Force.IsPresent, resourceIdentifiersText, "New-ETSPreset (CreatePreset)")) { return; } var context = new CmdletContext(); // allow for manipulation of parameters prior to loading into context PreExecutionContextLoad(context); #pragma warning disable CS0618, CS0612 //A class member was marked with the Obsolete attribute if (ParameterWasBound(nameof(this.Select))) { context.Select = CreateSelectDelegate<Amazon.ElasticTranscoder.Model.CreatePresetResponse, NewETSPresetCmdlet>(Select) ?? throw new System.ArgumentException("Invalid value for -Select parameter.", nameof(this.Select)); if (this.PassThru.IsPresent) { throw new System.ArgumentException("-PassThru cannot be used when -Select is specified.", nameof(this.Select)); } } else if (this.PassThru.IsPresent) { context.Select = (response, cmdlet) => this.Name; } #pragma warning restore CS0618, CS0612 //A class member was marked with the Obsolete attribute context.Audio_AudioPackingMode = this.Audio_AudioPackingMode; context.Audio_BitRate = this.Audio_BitRate; context.Audio_Channel = this.Audio_Channel; context.Audio_Codec = this.Audio_Codec; context.CodecOptions_BitDepth = this.CodecOptions_BitDepth; context.CodecOptions_BitOrder = this.CodecOptions_BitOrder; context.CodecOptions_Profile = this.CodecOptions_Profile; context.CodecOptions_Signed = this.CodecOptions_Signed; context.Audio_SampleRate = this.Audio_SampleRate; context.Container = this.Container; #if MODULAR if (this.Container == null && ParameterWasBound(nameof(this.Container))) { WriteWarning("You are passing $null as a value for parameter Container which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.Description = this.Description; context.Name = this.Name; #if MODULAR if (this.Name == null && ParameterWasBound(nameof(this.Name))) { WriteWarning("You are passing $null as a value for parameter Name which is marked as required. In case you believe this parameter was incorrectly marked as required, report this by opening an issue at https://github.com/aws/aws-tools-for-powershell/issues."); } #endif context.Thumbnails_AspectRatio = this.Thumbnails_AspectRatio; context.Thumbnails_Format = this.Thumbnails_Format; context.Thumbnails_Interval = this.Thumbnails_Interval; context.Thumbnails_MaxHeight = this.Thumbnails_MaxHeight; context.Thumbnails_MaxWidth = this.Thumbnails_MaxWidth; context.Thumbnails_PaddingPolicy = this.Thumbnails_PaddingPolicy; context.Thumbnails_Resolution = this.Thumbnails_Resolution; context.Thumbnails_SizingPolicy = this.Thumbnails_SizingPolicy; context.Video_AspectRatio = this.Video_AspectRatio; context.Video_BitRate = this.Video_BitRate; context.Video_Codec = this.Video_Codec; if (this.Video_CodecOption != null) { context.Video_CodecOption = new Dictionary<System.String, System.String>(StringComparer.Ordinal); foreach (var hashKey in this.Video_CodecOption.Keys) { context.Video_CodecOption.Add((String)hashKey, (String)(this.Video_CodecOption[hashKey])); } } context.Video_DisplayAspectRatio = this.Video_DisplayAspectRatio; context.Video_FixedGOP = this.Video_FixedGOP; context.Video_FrameRate = this.Video_FrameRate; context.Video_KeyframesMaxDist = this.Video_KeyframesMaxDist; context.Video_MaxFrameRate = this.Video_MaxFrameRate; context.Video_MaxHeight = this.Video_MaxHeight; context.Video_MaxWidth = this.Video_MaxWidth; context.Video_PaddingPolicy = this.Video_PaddingPolicy; context.Video_Resolution = this.Video_Resolution; context.Video_SizingPolicy = this.Video_SizingPolicy; if (this.Video_Watermark != null) { context.Video_Watermark = new List<Amazon.ElasticTranscoder.Model.PresetWatermark>(this.Video_Watermark); } // allow further manipulation of loaded context prior to processing PostExecutionContextLoad(context); var output = Execute(context) as CmdletOutput; ProcessOutput(output); } #region IExecutor Members public object Execute(ExecutorContext context) { var cmdletContext = context as CmdletContext; // create request var request = new Amazon.ElasticTranscoder.Model.CreatePresetRequest(); // populate Audio var requestAudioIsNull = true; request.Audio = new Amazon.ElasticTranscoder.Model.AudioParameters(); System.String requestAudio_audio_AudioPackingMode = null; if (cmdletContext.Audio_AudioPackingMode != null) { requestAudio_audio_AudioPackingMode = cmdletContext.Audio_AudioPackingMode; } if (requestAudio_audio_AudioPackingMode != null) { request.Audio.AudioPackingMode = requestAudio_audio_AudioPackingMode; requestAudioIsNull = false; } System.String requestAudio_audio_BitRate = null; if (cmdletContext.Audio_BitRate != null) { requestAudio_audio_BitRate = cmdletContext.Audio_BitRate; } if (requestAudio_audio_BitRate != null) { request.Audio.BitRate = requestAudio_audio_BitRate; requestAudioIsNull = false; } System.String requestAudio_audio_Channel = null; if (cmdletContext.Audio_Channel != null) { requestAudio_audio_Channel = cmdletContext.Audio_Channel; } if (requestAudio_audio_Channel != null) { request.Audio.Channels = requestAudio_audio_Channel; requestAudioIsNull = false; } System.String requestAudio_audio_Codec = null; if (cmdletContext.Audio_Codec != null) { requestAudio_audio_Codec = cmdletContext.Audio_Codec; } if (requestAudio_audio_Codec != null) { request.Audio.Codec = requestAudio_audio_Codec; requestAudioIsNull = false; } System.String requestAudio_audio_SampleRate = null; if (cmdletContext.Audio_SampleRate != null) { requestAudio_audio_SampleRate = cmdletContext.Audio_SampleRate; } if (requestAudio_audio_SampleRate != null) { request.Audio.SampleRate = requestAudio_audio_SampleRate; requestAudioIsNull = false; } Amazon.ElasticTranscoder.Model.AudioCodecOptions requestAudio_audio_CodecOptions = null; // populate CodecOptions var requestAudio_audio_CodecOptionsIsNull = true; requestAudio_audio_CodecOptions = new Amazon.ElasticTranscoder.Model.AudioCodecOptions(); System.String requestAudio_audio_CodecOptions_codecOptions_BitDepth = null; if (cmdletContext.CodecOptions_BitDepth != null) { requestAudio_audio_CodecOptions_codecOptions_BitDepth = cmdletContext.CodecOptions_BitDepth; } if (requestAudio_audio_CodecOptions_codecOptions_BitDepth != null) { requestAudio_audio_CodecOptions.BitDepth = requestAudio_audio_CodecOptions_codecOptions_BitDepth; requestAudio_audio_CodecOptionsIsNull = false; } System.String requestAudio_audio_CodecOptions_codecOptions_BitOrder = null; if (cmdletContext.CodecOptions_BitOrder != null) { requestAudio_audio_CodecOptions_codecOptions_BitOrder = cmdletContext.CodecOptions_BitOrder; } if (requestAudio_audio_CodecOptions_codecOptions_BitOrder != null) { requestAudio_audio_CodecOptions.BitOrder = requestAudio_audio_CodecOptions_codecOptions_BitOrder; requestAudio_audio_CodecOptionsIsNull = false; } System.String requestAudio_audio_CodecOptions_codecOptions_Profile = null; if (cmdletContext.CodecOptions_Profile != null) { requestAudio_audio_CodecOptions_codecOptions_Profile = cmdletContext.CodecOptions_Profile; } if (requestAudio_audio_CodecOptions_codecOptions_Profile != null) { requestAudio_audio_CodecOptions.Profile = requestAudio_audio_CodecOptions_codecOptions_Profile; requestAudio_audio_CodecOptionsIsNull = false; } System.String requestAudio_audio_CodecOptions_codecOptions_Signed = null; if (cmdletContext.CodecOptions_Signed != null) { requestAudio_audio_CodecOptions_codecOptions_Signed = cmdletContext.CodecOptions_Signed; } if (requestAudio_audio_CodecOptions_codecOptions_Signed != null) { requestAudio_audio_CodecOptions.Signed = requestAudio_audio_CodecOptions_codecOptions_Signed; requestAudio_audio_CodecOptionsIsNull = false; } // determine if requestAudio_audio_CodecOptions should be set to null if (requestAudio_audio_CodecOptionsIsNull) { requestAudio_audio_CodecOptions = null; } if (requestAudio_audio_CodecOptions != null) { request.Audio.CodecOptions = requestAudio_audio_CodecOptions; requestAudioIsNull = false; } // determine if request.Audio should be set to null if (requestAudioIsNull) { request.Audio = null; } if (cmdletContext.Container != null) { request.Container = cmdletContext.Container; } if (cmdletContext.Description != null) { request.Description = cmdletContext.Description; } if (cmdletContext.Name != null) { request.Name = cmdletContext.Name; } // populate Thumbnails var requestThumbnailsIsNull = true; request.Thumbnails = new Amazon.ElasticTranscoder.Model.Thumbnails(); System.String requestThumbnails_thumbnails_AspectRatio = null; if (cmdletContext.Thumbnails_AspectRatio != null) { requestThumbnails_thumbnails_AspectRatio = cmdletContext.Thumbnails_AspectRatio; } if (requestThumbnails_thumbnails_AspectRatio != null) { request.Thumbnails.AspectRatio = requestThumbnails_thumbnails_AspectRatio; requestThumbnailsIsNull = false; } System.String requestThumbnails_thumbnails_Format = null; if (cmdletContext.Thumbnails_Format != null) { requestThumbnails_thumbnails_Format = cmdletContext.Thumbnails_Format; } if (requestThumbnails_thumbnails_Format != null) { request.Thumbnails.Format = requestThumbnails_thumbnails_Format; requestThumbnailsIsNull = false; } System.String requestThumbnails_thumbnails_Interval = null; if (cmdletContext.Thumbnails_Interval != null) { requestThumbnails_thumbnails_Interval = cmdletContext.Thumbnails_Interval; } if (requestThumbnails_thumbnails_Interval != null) { request.Thumbnails.Interval = requestThumbnails_thumbnails_Interval; requestThumbnailsIsNull = false; } System.String requestThumbnails_thumbnails_MaxHeight = null; if (cmdletContext.Thumbnails_MaxHeight != null) { requestThumbnails_thumbnails_MaxHeight = cmdletContext.Thumbnails_MaxHeight; } if (requestThumbnails_thumbnails_MaxHeight != null) { request.Thumbnails.MaxHeight = requestThumbnails_thumbnails_MaxHeight; requestThumbnailsIsNull = false; } System.String requestThumbnails_thumbnails_MaxWidth = null; if (cmdletContext.Thumbnails_MaxWidth != null) { requestThumbnails_thumbnails_MaxWidth = cmdletContext.Thumbnails_MaxWidth; } if (requestThumbnails_thumbnails_MaxWidth != null) { request.Thumbnails.MaxWidth = requestThumbnails_thumbnails_MaxWidth; requestThumbnailsIsNull = false; } System.String requestThumbnails_thumbnails_PaddingPolicy = null; if (cmdletContext.Thumbnails_PaddingPolicy != null) { requestThumbnails_thumbnails_PaddingPolicy = cmdletContext.Thumbnails_PaddingPolicy; } if (requestThumbnails_thumbnails_PaddingPolicy != null) { request.Thumbnails.PaddingPolicy = requestThumbnails_thumbnails_PaddingPolicy; requestThumbnailsIsNull = false; } System.String requestThumbnails_thumbnails_Resolution = null; if (cmdletContext.Thumbnails_Resolution != null) { requestThumbnails_thumbnails_Resolution = cmdletContext.Thumbnails_Resolution; } if (requestThumbnails_thumbnails_Resolution != null) { request.Thumbnails.Resolution = requestThumbnails_thumbnails_Resolution; requestThumbnailsIsNull = false; } System.String requestThumbnails_thumbnails_SizingPolicy = null; if (cmdletContext.Thumbnails_SizingPolicy != null) { requestThumbnails_thumbnails_SizingPolicy = cmdletContext.Thumbnails_SizingPolicy; } if (requestThumbnails_thumbnails_SizingPolicy != null) { request.Thumbnails.SizingPolicy = requestThumbnails_thumbnails_SizingPolicy; requestThumbnailsIsNull = false; } // determine if request.Thumbnails should be set to null if (requestThumbnailsIsNull) { request.Thumbnails = null; } // populate Video var requestVideoIsNull = true; request.Video = new Amazon.ElasticTranscoder.Model.VideoParameters(); System.String requestVideo_video_AspectRatio = null; if (cmdletContext.Video_AspectRatio != null) { requestVideo_video_AspectRatio = cmdletContext.Video_AspectRatio; } if (requestVideo_video_AspectRatio != null) { request.Video.AspectRatio = requestVideo_video_AspectRatio; requestVideoIsNull = false; } System.String requestVideo_video_BitRate = null; if (cmdletContext.Video_BitRate != null) { requestVideo_video_BitRate = cmdletContext.Video_BitRate; } if (requestVideo_video_BitRate != null) { request.Video.BitRate = requestVideo_video_BitRate; requestVideoIsNull = false; } System.String requestVideo_video_Codec = null; if (cmdletContext.Video_Codec != null) { requestVideo_video_Codec = cmdletContext.Video_Codec; } if (requestVideo_video_Codec != null) { request.Video.Codec = requestVideo_video_Codec; requestVideoIsNull = false; } Dictionary<System.String, System.String> requestVideo_video_CodecOption = null; if (cmdletContext.Video_CodecOption != null) { requestVideo_video_CodecOption = cmdletContext.Video_CodecOption; } if (requestVideo_video_CodecOption != null) { request.Video.CodecOptions = requestVideo_video_CodecOption; requestVideoIsNull = false; } System.String requestVideo_video_DisplayAspectRatio = null; if (cmdletContext.Video_DisplayAspectRatio != null) { requestVideo_video_DisplayAspectRatio = cmdletContext.Video_DisplayAspectRatio; } if (requestVideo_video_DisplayAspectRatio != null) { request.Video.DisplayAspectRatio = requestVideo_video_DisplayAspectRatio; requestVideoIsNull = false; } System.String requestVideo_video_FixedGOP = null; if (cmdletContext.Video_FixedGOP != null) { requestVideo_video_FixedGOP = cmdletContext.Video_FixedGOP; } if (requestVideo_video_FixedGOP != null) { request.Video.FixedGOP = requestVideo_video_FixedGOP; requestVideoIsNull = false; } System.String requestVideo_video_FrameRate = null; if (cmdletContext.Video_FrameRate != null) { requestVideo_video_FrameRate = cmdletContext.Video_FrameRate; } if (requestVideo_video_FrameRate != null) { request.Video.FrameRate = requestVideo_video_FrameRate; requestVideoIsNull = false; } System.String requestVideo_video_KeyframesMaxDist = null; if (cmdletContext.Video_KeyframesMaxDist != null) { requestVideo_video_KeyframesMaxDist = cmdletContext.Video_KeyframesMaxDist; } if (requestVideo_video_KeyframesMaxDist != null) { request.Video.KeyframesMaxDist = requestVideo_video_KeyframesMaxDist; requestVideoIsNull = false; } System.String requestVideo_video_MaxFrameRate = null; if (cmdletContext.Video_MaxFrameRate != null) { requestVideo_video_MaxFrameRate = cmdletContext.Video_MaxFrameRate; } if (requestVideo_video_MaxFrameRate != null) { request.Video.MaxFrameRate = requestVideo_video_MaxFrameRate; requestVideoIsNull = false; } System.String requestVideo_video_MaxHeight = null; if (cmdletContext.Video_MaxHeight != null) { requestVideo_video_MaxHeight = cmdletContext.Video_MaxHeight; } if (requestVideo_video_MaxHeight != null) { request.Video.MaxHeight = requestVideo_video_MaxHeight; requestVideoIsNull = false; } System.String requestVideo_video_MaxWidth = null; if (cmdletContext.Video_MaxWidth != null) { requestVideo_video_MaxWidth = cmdletContext.Video_MaxWidth; } if (requestVideo_video_MaxWidth != null) { request.Video.MaxWidth = requestVideo_video_MaxWidth; requestVideoIsNull = false; } System.String requestVideo_video_PaddingPolicy = null; if (cmdletContext.Video_PaddingPolicy != null) { requestVideo_video_PaddingPolicy = cmdletContext.Video_PaddingPolicy; } if (requestVideo_video_PaddingPolicy != null) { request.Video.PaddingPolicy = requestVideo_video_PaddingPolicy; requestVideoIsNull = false; } System.String requestVideo_video_Resolution = null; if (cmdletContext.Video_Resolution != null) { requestVideo_video_Resolution = cmdletContext.Video_Resolution; } if (requestVideo_video_Resolution != null) { request.Video.Resolution = requestVideo_video_Resolution; requestVideoIsNull = false; } System.String requestVideo_video_SizingPolicy = null; if (cmdletContext.Video_SizingPolicy != null) { requestVideo_video_SizingPolicy = cmdletContext.Video_SizingPolicy; } if (requestVideo_video_SizingPolicy != null) { request.Video.SizingPolicy = requestVideo_video_SizingPolicy; requestVideoIsNull = false; } List<Amazon.ElasticTranscoder.Model.PresetWatermark> requestVideo_video_Watermark = null; if (cmdletContext.Video_Watermark != null) { requestVideo_video_Watermark = cmdletContext.Video_Watermark; } if (requestVideo_video_Watermark != null) { request.Video.Watermarks = requestVideo_video_Watermark; requestVideoIsNull = false; } // determine if request.Video should be set to null if (requestVideoIsNull) { request.Video = null; } CmdletOutput output; // issue call var client = Client ?? CreateClient(_CurrentCredentials, _RegionEndpoint); try { var response = CallAWSServiceOperation(client, request); object pipelineOutput = null; pipelineOutput = cmdletContext.Select(response, this); output = new CmdletOutput { PipelineOutput = pipelineOutput, ServiceResponse = response }; } catch (Exception e) { output = new CmdletOutput { ErrorResponse = e }; } return output; } public ExecutorContext CreateContext() { return new CmdletContext(); } #endregion #region AWS Service Operation Call private Amazon.ElasticTranscoder.Model.CreatePresetResponse CallAWSServiceOperation(IAmazonElasticTranscoder client, Amazon.ElasticTranscoder.Model.CreatePresetRequest request) { Utils.Common.WriteVerboseEndpointMessage(this, client.Config, "Amazon Elastic Transcoder", "CreatePreset"); try { #if DESKTOP return client.CreatePreset(request); #elif CORECLR return client.CreatePresetAsync(request).GetAwaiter().GetResult(); #else #error "Unknown build edition" #endif } catch (AmazonServiceException exc) { var webException = exc.InnerException as System.Net.WebException; if (webException != null) { throw new Exception(Utils.Common.FormatNameResolutionFailureMessage(client.Config, webException.Message), webException); } throw; } } #endregion internal partial class CmdletContext : ExecutorContext { public System.String Audio_AudioPackingMode { get; set; } public System.String Audio_BitRate { get; set; } public System.String Audio_Channel { get; set; } public System.String Audio_Codec { get; set; } public System.String CodecOptions_BitDepth { get; set; } public System.String CodecOptions_BitOrder { get; set; } public System.String CodecOptions_Profile { get; set; } public System.String CodecOptions_Signed { get; set; } public System.String Audio_SampleRate { get; set; } public System.String Container { get; set; } public System.String Description { get; set; } public System.String Name { get; set; } public System.String Thumbnails_AspectRatio { get; set; } public System.String Thumbnails_Format { get; set; } public System.String Thumbnails_Interval { get; set; } public System.String Thumbnails_MaxHeight { get; set; } public System.String Thumbnails_MaxWidth { get; set; } public System.String Thumbnails_PaddingPolicy { get; set; } public System.String Thumbnails_Resolution { get; set; } public System.String Thumbnails_SizingPolicy { get; set; } public System.String Video_AspectRatio { get; set; } public System.String Video_BitRate { get; set; } public System.String Video_Codec { get; set; } public Dictionary<System.String, System.String> Video_CodecOption { get; set; } public System.String Video_DisplayAspectRatio { get; set; } public System.String Video_FixedGOP { get; set; } public System.String Video_FrameRate { get; set; } public System.String Video_KeyframesMaxDist { get; set; } public System.String Video_MaxFrameRate { get; set; } public System.String Video_MaxHeight { get; set; } public System.String Video_MaxWidth { get; set; } public System.String Video_PaddingPolicy { get; set; } public System.String Video_Resolution { get; set; } public System.String Video_SizingPolicy { get; set; } public List<Amazon.ElasticTranscoder.Model.PresetWatermark> Video_Watermark { get; set; } public System.Func<Amazon.ElasticTranscoder.Model.CreatePresetResponse, NewETSPresetCmdlet, object> Select { get; set; } = (response, cmdlet) => response; } } }