com.amazonaws.services.mediaconvert.model.H264Settings Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aws-java-sdk-mediaconvert Show documentation
Show all versions of aws-java-sdk-mediaconvert Show documentation
The AWS Java SDK for AWS Elemental MediaConvert module holds the client classes that are used for communicating with AWS Elemental MediaConvert Service
/*
* Copyright 2019-2024 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.
*/
package com.amazonaws.services.mediaconvert.model;
import java.io.Serializable;
import javax.annotation.Generated;
import com.amazonaws.protocol.StructuredPojo;
import com.amazonaws.protocol.ProtocolMarshaller;
/**
* Required when you set Codec to the value H_264.
*
* @see AWS API
* Documentation
*/
@Generated("com.amazonaws:aws-java-sdk-code-generator")
public class H264Settings implements Serializable, Cloneable, StructuredPojo {
/**
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must set
* H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any adaptive
* quantization filters that you enable. If you don't want MediaConvert to do any adaptive quantization in this
* transcode, set Adaptive quantization to Off. Related settings: The value that you choose here applies to the
* following settings: H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
* H264TemporalAdaptiveQuantization.
*/
private String adaptiveQuantization;
/**
* The Bandwidth reduction filter increases the video quality of your output relative to its bitrate. Use to lower
* the bitrate of your constant quality QVBR output, with little or no perceptual decrease in quality. Or, use to
* increase the video quality of outputs with other rate control modes relative to the bitrate that you specify.
* Bandwidth reduction increases further when your input is low quality or noisy. Outputs that use this feature incur
* pro-tier pricing. When you include Bandwidth reduction filter, you cannot include the Noise reducer preprocessor.
*/
private BandwidthReductionFilter bandwidthReductionFilter;
/**
* Specify the average bitrate in bits per second. Required for VBR and CBR. For MS Smooth outputs, bitrates must be
* unique when rounded down to the nearest multiple of 1000.
*/
private Integer bitrate;
/**
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level to
* specify, choose Auto.
*/
private String codecLevel;
/** H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License. */
private String codecProfile;
/**
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on your
* input video content. To improve the subjective video quality of your output that has high-motion content: Leave
* blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for high-motion video content than
* low-motion content. The maximum number of B- frames is limited by the value that you choose for B-frames between
* reference frames. To use the same number B-frames for all types of content: Choose Static.
*/
private String dynamicSubGop;
/**
* Optionally include or suppress markers at the end of your output that signal the end of the video stream. To
* include end of stream markers: Leave blank or keep the default value, Include. To not include end of stream
* markers: Choose Suppress. This is useful when your output will be inserted into another stream.
*/
private String endOfStreamMarkers;
/** Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC. */
private String entropyEncoding;
/**
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert use PAFF
* encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate interlaced
* fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced outputs.
*/
private String fieldEncoding;
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264FlickerAdaptiveQuantization is
* Disabled. Change this value to Enabled to reduce I-frame pop. I-frame pop appears as a visual flicker that can
* arise when the encoder saves bits by copying some macroblocks many times from frame to frame, and then refreshes
* them at the I-frame. When you enable this setting, the encoder updates these macroblocks slightly more often to
* smooth out the flicker. To manually enable or disable H264FlickerAdaptiveQuantization, you must set Adaptive
* quantization to a value other than AUTO.
*/
private String flickerAdaptiveQuantization;
/**
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you want to
* keep the same frame rate as the input video, choose Follow source. If you want to do frame rate conversion,
* choose a frame rate from the dropdown list or choose Custom. The framerates shown in the dropdown list are decimal
* approximations of fractions. If you choose Custom, specify your frame rate as a fraction.
*/
private String framerateControl;
/**
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For numerically
* simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value, Drop duplicate. For
* numerically complex conversions, to avoid stutter: Choose Interpolate. This results in a smooth picture, but might
* introduce undesirable video artifacts. For complex frame rate conversions, especially if your source video has
* already been converted from its original cadence: Choose FrameFormer to do motion-compensated interpolation.
* FrameFormer uses the best conversion method frame by frame. Note that using FrameFormer increases the transcoding
* time and incurs a significant add-on cost. When you choose FrameFormer, your input video resolution must be at
* least 128x96.
*/
private String framerateConversionAlgorithm;
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateDenominator to specify the denominator of this fraction. In this
* example, use 1001 for the value of FramerateDenominator. When you use the console for transcode jobs that use
* frame rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*/
private Integer framerateDenominator;
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateNumerator to specify the numerator of this fraction. In this
* example, use 24000 for the value of FramerateNumerator. When you use the console for transcode jobs that use frame
* rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*/
private Integer framerateNumerator;
/**
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when your GOP
* structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend that you choose
* Enabled to help improve the video quality of your output relative to its bitrate. To not use reference B-frames:
* Choose Disabled.
*/
private String gopBReference;
/**
* Specify the relative frequency of open to closed GOPs in this output. For example, if you want to allow four open
* GOPs and then require a closed GOP, set this value to 5. We recommend that you have the transcoder automatically
* choose this value for you based on characteristics of your input video. In the console, do this by keeping the
* default empty value. If you do explicitly specify a value, for segmented outputs, don't set this value to 0.
*/
private Integer gopClosedCadence;
/**
* Use this setting only when you set GOP mode control to Specified, frames or Specified, seconds. Specify the GOP
* length using a whole number of frames or a decimal value of seconds. MediaConvert will interpret this value as
* frames or seconds depending on the value you choose for GOP mode control. If you want to allow MediaConvert to
* automatically determine GOP size, leave GOP size blank and set GOP mode control to Auto. If your output group
* specifies HLS, DASH, or CMAF, leave GOP size blank and set GOP mode control to Auto in each output in your output
* group.
*/
private Double gopSize;
/**
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this automatic
* behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode control,
* MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set GOP mode control
* to Auto and leave GOP size blank in each output in your output group. To explicitly specify the GOP length, choose
* Specified, frames or Specified, seconds and then provide the GOP length in the related setting GOP size.
*/
private String gopSizeUnits;
/**
* If your downstream systems have strict buffer requirements: Specify the minimum percentage of the HRD buffer
* that's available at the end of each encoded video segment. For the best video quality: Set to 0 or leave blank to
* automatically determine the final buffer fill percentage.
*/
private Integer hrdBufferFinalFillPercentage;
/** Percentage of the buffer that should initially be filled (HRD buffer model). */
private Integer hrdBufferInitialFillPercentage;
/** Size of buffer (HRD buffer model) in bits. For example, enter five megabits as 5000000. */
private Integer hrdBufferSize;
/**
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive output,
* regardless of the scan type of your input. Use Top field first or Bottom field first to create an output that's
* interlaced with the same field polarity throughout. Use Follow, default top or Follow, default bottom to produce
* outputs with the same field polarity as the source. For jobs that have multiple inputs, the output field polarity
* might change over the course of the output. Follow behavior depends on the input scan type. If the source is
* interlaced, the output will be interlaced with the same polarity as the source. If the source is progressive, the
* output will be interlaced with top field bottom field first, depending on which of the Follow options you choose.
*/
private String interlaceMode;
/**
* Maximum bitrate in bits/second. For example, enter five megabits per second as 5000000. Required when Rate
* control mode is QVBR.
*/
private Integer maxBitrate;
/**
* Use this setting only when you also enable Scene change detection. This setting determines how the encoder
* manages the spacing between I-frames that it inserts as part of the I-frame cadence and the I-frames that it
* inserts for Scene change detection. We recommend that you have the transcoder automatically choose this value for
* you based on characteristics of your input video. To enable this automatic behavior, do this by keeping the
* default empty value. When you explicitly specify a value for this setting, the encoder determines whether to skip
* a cadence-driven I-frame by the value you set. For example, if you set Min I interval to 5 and a cadence-driven
* I-frame would fall within 5 frames of a scene-change I-frame, then the encoder skips the cadence-driven I-frame.
* In this way, one GOP is shrunk slightly and one GOP is stretched slightly. When the cadence-driven I-frames are
* farther from the scene-change I-frame than the value you set, then the encoder leaves all I-frames in place and
* the GOPs surrounding the scene change are smaller than the usual cadence GOPs.
*/
private Integer minIInterval;
/**
* Specify the number of B-frames between reference frames in this output. For the best video quality: Leave blank.
* MediaConvert automatically determines the number of B-frames to use based on the characteristics of your input
* video. To manually specify the number of B-frames between reference frames: Enter an integer from 0 to 7.
*/
private Integer numberBFramesBetweenReferenceFrames;
/**
* Number of reference frames to use. The encoder may use more than requested if using B-frames and/or interlaced
* encoding.
*/
private Integer numberReferenceFrames;
/**
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default behavior,
* Follow source, uses the PAR from your input video for your output. To specify a different PAR in the console,
* choose any value other than Follow source. When you choose SPECIFIED for this setting, you must also specify
* values for the parNumerator and parDenominator settings.
*/
private String parControl;
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parDenominator is 33.
*/
private Integer parDenominator;
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parNumerator is 40.
*/
private Integer parNumerator;
/**
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the output
* video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For a good
* balance between encoding speed and video quality: Leave blank or keep the default value Single pass HQ. For the
* best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs an analysis pass on
* your input followed by an encoding pass. Outputs that use this feature incur pro-tier pricing.
*/
private String qualityTuningLevel;
/**
* Settings for quality-defined variable bitrate encoding with the H.265 codec. Use these settings only when you set
* QVBR for Rate control mode.
*/
private H264QvbrSettings qvbrSettings;
/**
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
*/
private String rateControlMode;
/** Places a PPS header on each encoded picture, even if repeated. */
private String repeatPps;
/**
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In this
* situation, choose Optimized interlacing to create a better quality interlaced output. In this case, each
* progressive frame from the input corresponds to an interlaced field in the output. Keep the default value, Basic
* interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs any frame rate
* conversion first and then interlaces the frames. When you choose Optimized interlacing and you set your output
* frame rate to a value that isn't suitable for optimized interlacing, MediaConvert automatically falls back to
* basic interlacing. Required settings: To use optimized interlacing, you must set Telecine to None or Soft. You
* can't use optimized interlacing for hard telecine outputs. You must also set Interlace mode to a value other than
* Progressive.
*/
private String scanTypeConversionMode;
/**
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This improves
* video quality and is enabled by default. If this output uses QVBR, choose Transition detection for further video
* quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
*/
private String sceneChangeDetect;
/**
* Number of slices per picture. Must be less than or equal to the number of macroblock rows for progressive
* pictures, and less than or equal to half the number of macroblock rows for interlaced pictures.
*/
private Integer slices;
/**
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL to
* create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and resamples
* your audio to keep it synchronized with the video. Note that enabling this setting will slightly reduce the
* duration of your video. Required settings: You must also set Framerate to 25.
*/
private String slowPal;
/**
* Ignore this setting unless you need to comply with a specification that requires a specific value. If you don't
* have a specification requirement, we recommend that you adjust the softness of your output by using a lower value
* for the setting Sharpness or by enabling a noise reducer filter. The Softness setting specifies the quantization
* matrices that the encoder uses. Keep the default value, 0, for flat quantization. Choose the value 1 or 16 to use
* the default JVT softening quantization matricies from the H.264 specification. Choose a value from 17 to 128 to
* use planar interpolation. Increasing values from 17 to 128 result in increasing reduction of high-frequency data.
* The value 128 results in the softest video.
*/
private Integer softness;
/**
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264SpatialAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on spatial variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas that can sustain more distortion
* with no noticeable visual degradation and uses more bits on areas where any small distortion will be noticeable.
* For example, complex textured blocks are encoded with fewer bits and smooth textured blocks are encoded with more
* bits. Enabling this feature will almost always improve your video quality. Note, though, that this feature doesn't
* take into account where the viewer's attention is likely to be. If viewers are likely to be focusing their
* attention on a part of the screen with a lot of complex texture, you might choose to set
* H264SpatialAdaptiveQuantization to Disabled. Related setting: When you enable spatial adaptive quantization, set
* the value for Adaptive quantization depending on your content. For homogeneous content, such as cartoons and video
* games, set it to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable
* or disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*/
private String spatialAdaptiveQuantization;
/** Produces a bitstream compliant with SMPTE RP-2027. */
private String syntax;
/**
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan type is
* interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard telecine produces
* a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to the video player device to
* do the conversion during play back. When you keep the default value, None, MediaConvert does a standard frame rate
* conversion to 29.97 without doing anything with the field polarity to create a smoother picture.
*/
private String telecine;
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264TemporalAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on temporal variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas of the frame that aren't moving and
* uses more bits on complex objects with sharp edges that move a lot. For example, this feature improves the
* readability of text tickers on newscasts and scoreboards on sports matches. Enabling this feature will almost
* always improve your video quality. Note, though, that this feature doesn't take into account where the viewer's
* attention is likely to be. If viewers are likely to be focusing their attention on a part of the screen that
* doesn't have moving objects with sharp edges, such as sports athletes' faces, you might choose to set
* H264TemporalAdaptiveQuantization to Disabled. Related setting: When you enable temporal quantization, adjust the
* strength of the filter with the setting Adaptive quantization. To manually enable or disable
* H264TemporalAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*/
private String temporalAdaptiveQuantization;
/** Inserts timecode for each frame as 4 bytes of an unregistered SEI message. */
private String unregisteredSeiTimecode;
/**
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must set
* H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any adaptive
* quantization filters that you enable. If you don't want MediaConvert to do any adaptive quantization in this
* transcode, set Adaptive quantization to Off. Related settings: The value that you choose here applies to the
* following settings: H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
* H264TemporalAdaptiveQuantization.
*
* @param adaptiveQuantization
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must
* set H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any
* adaptive quantization filters that you enable. If you don't want MediaConvert to do any adaptive
* quantization in this transcode, set Adaptive quantization to Off. Related settings: The value that you
* choose here applies to the following settings: H264FlickerAdaptiveQuantization,
* H264SpatialAdaptiveQuantization, and H264TemporalAdaptiveQuantization.
* @see H264AdaptiveQuantization
*/
public void setAdaptiveQuantization(String adaptiveQuantization) {
this.adaptiveQuantization = adaptiveQuantization;
}
/**
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must set
* H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any adaptive
* quantization filters that you enable. If you don't want MediaConvert to do any adaptive quantization in this
* transcode, set Adaptive quantization to Off. Related settings: The value that you choose here applies to the
* following settings: H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
* H264TemporalAdaptiveQuantization.
*
* @return Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must
* set H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any
* adaptive quantization filters that you enable. If you don't want MediaConvert to do any adaptive
* quantization in this transcode, set Adaptive quantization to Off. Related settings: The value that you
* choose here applies to the following settings: H264FlickerAdaptiveQuantization,
* H264SpatialAdaptiveQuantization, and H264TemporalAdaptiveQuantization.
* @see H264AdaptiveQuantization
*/
public String getAdaptiveQuantization() {
return this.adaptiveQuantization;
}
/**
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must set
* H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any adaptive
* quantization filters that you enable. If you don't want MediaConvert to do any adaptive quantization in this
* transcode, set Adaptive quantization to Off. Related settings: The value that you choose here applies to the
* following settings: H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
* H264TemporalAdaptiveQuantization.
*
* @param adaptiveQuantization
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must
* set H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any
* adaptive quantization filters that you enable. If you don't want MediaConvert to do any adaptive
* quantization in this transcode, set Adaptive quantization to Off. Related settings: The value that you
* choose here applies to the following settings: H264FlickerAdaptiveQuantization,
* H264SpatialAdaptiveQuantization, and H264TemporalAdaptiveQuantization.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264AdaptiveQuantization
*/
public H264Settings withAdaptiveQuantization(String adaptiveQuantization) {
setAdaptiveQuantization(adaptiveQuantization);
return this;
}
/**
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must set
* H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any adaptive
* quantization filters that you enable. If you don't want MediaConvert to do any adaptive quantization in this
* transcode, set Adaptive quantization to Off. Related settings: The value that you choose here applies to the
* following settings: H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
* H264TemporalAdaptiveQuantization.
*
* @param adaptiveQuantization
* Keep the default value, Auto, for this setting to have MediaConvert automatically apply the best types of
* quantization for your video content. When you want to apply your quantization settings manually, you must
* set H264AdaptiveQuantization to a value other than Auto. Use this setting to specify the strength of any
* adaptive quantization filters that you enable. If you don't want MediaConvert to do any adaptive
* quantization in this transcode, set Adaptive quantization to Off. Related settings: The value that you
* choose here applies to the following settings: H264FlickerAdaptiveQuantization,
* H264SpatialAdaptiveQuantization, and H264TemporalAdaptiveQuantization.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264AdaptiveQuantization
*/
public H264Settings withAdaptiveQuantization(H264AdaptiveQuantization adaptiveQuantization) {
this.adaptiveQuantization = adaptiveQuantization.toString();
return this;
}
/**
* The Bandwidth reduction filter increases the video quality of your output relative to its bitrate. Use to lower
* the bitrate of your constant quality QVBR output, with little or no perceptual decrease in quality. Or, use to
* increase the video quality of outputs with other rate control modes relative to the bitrate that you specify.
* Bandwidth reduction increases further when your input is low quality or noisy. Outputs that use this feature incur
* pro-tier pricing. When you include Bandwidth reduction filter, you cannot include the Noise reducer preprocessor.
*
* @param bandwidthReductionFilter
* The Bandwidth reduction filter increases the video quality of your output relative to its bitrate. Use to
* lower the bitrate of your constant quality QVBR output, with little or no perceptual decrease in quality.
* Or, use to increase the video quality of outputs with other rate control modes relative to the bitrate
* that you specify. Bandwidth reduction increases further when your input is low quality or noisy. Outputs
* that use this feature incur pro-tier pricing. When you include Bandwidth reduction filter, you cannot
* include the Noise reducer preprocessor.
*/
public void setBandwidthReductionFilter(BandwidthReductionFilter bandwidthReductionFilter) {
this.bandwidthReductionFilter = bandwidthReductionFilter;
}
/**
* The Bandwidth reduction filter increases the video quality of your output relative to its bitrate. Use to lower
* the bitrate of your constant quality QVBR output, with little or no perceptual decrease in quality. Or, use to
* increase the video quality of outputs with other rate control modes relative to the bitrate that you specify.
* Bandwidth reduction increases further when your input is low quality or noisy. Outputs that use this feature incur
* pro-tier pricing. When you include Bandwidth reduction filter, you cannot include the Noise reducer preprocessor.
*
* @return The Bandwidth reduction filter increases the video quality of your output relative to its bitrate. Use to
* lower the bitrate of your constant quality QVBR output, with little or no perceptual decrease in quality.
* Or, use to increase the video quality of outputs with other rate control modes relative to the bitrate
* that you specify. Bandwidth reduction increases further when your input is low quality or noisy. Outputs
* that use this feature incur pro-tier pricing. When you include Bandwidth reduction filter, you cannot
* include the Noise reducer preprocessor.
*/
public BandwidthReductionFilter getBandwidthReductionFilter() {
return this.bandwidthReductionFilter;
}
/**
* The Bandwidth reduction filter increases the video quality of your output relative to its bitrate. Use to lower
* the bitrate of your constant quality QVBR output, with little or no perceptual decrease in quality. Or, use to
* increase the video quality of outputs with other rate control modes relative to the bitrate that you specify.
* Bandwidth reduction increases further when your input is low quality or noisy. Outputs that use this feature incur
* pro-tier pricing. When you include Bandwidth reduction filter, you cannot include the Noise reducer preprocessor.
*
* @param bandwidthReductionFilter
* The Bandwidth reduction filter increases the video quality of your output relative to its bitrate. Use to
* lower the bitrate of your constant quality QVBR output, with little or no perceptual decrease in quality.
* Or, use to increase the video quality of outputs with other rate control modes relative to the bitrate
* that you specify. Bandwidth reduction increases further when your input is low quality or noisy. Outputs
* that use this feature incur pro-tier pricing. When you include Bandwidth reduction filter, you cannot
* include the Noise reducer preprocessor.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withBandwidthReductionFilter(BandwidthReductionFilter bandwidthReductionFilter) {
setBandwidthReductionFilter(bandwidthReductionFilter);
return this;
}
/**
* Specify the average bitrate in bits per second. Required for VBR and CBR. For MS Smooth outputs, bitrates must be
* unique when rounded down to the nearest multiple of 1000.
*
* @param bitrate
* Specify the average bitrate in bits per second. Required for VBR and CBR. For MS Smooth outputs, bitrates
* must be unique when rounded down to the nearest multiple of 1000.
*/
public void setBitrate(Integer bitrate) {
this.bitrate = bitrate;
}
/**
* Specify the average bitrate in bits per second. Required for VBR and CBR. For MS Smooth outputs, bitrates must be
* unique when rounded down to the nearest multiple of 1000.
*
* @return Specify the average bitrate in bits per second. Required for VBR and CBR. For MS Smooth outputs, bitrates
* must be unique when rounded down to the nearest multiple of 1000.
*/
public Integer getBitrate() {
return this.bitrate;
}
/**
* Specify the average bitrate in bits per second. Required for VBR and CBR. For MS Smooth outputs, bitrates must be
* unique when rounded down to the nearest multiple of 1000.
*
* @param bitrate
* Specify the average bitrate in bits per second. Required for VBR and CBR. For MS Smooth outputs, bitrates
* must be unique when rounded down to the nearest multiple of 1000.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withBitrate(Integer bitrate) {
setBitrate(bitrate);
return this;
}
/**
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level to
* specify, choose Auto.
*
* @param codecLevel
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level
* to specify, choose Auto.
* @see H264CodecLevel
*/
public void setCodecLevel(String codecLevel) {
this.codecLevel = codecLevel;
}
/**
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level to
* specify, choose Auto.
*
* @return Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level
* to specify, choose Auto.
* @see H264CodecLevel
*/
public String getCodecLevel() {
return this.codecLevel;
}
/**
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level to
* specify, choose Auto.
*
* @param codecLevel
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level
* to specify, choose Auto.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264CodecLevel
*/
public H264Settings withCodecLevel(String codecLevel) {
setCodecLevel(codecLevel);
return this;
}
/**
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level to
* specify, choose Auto.
*
* @param codecLevel
* Specify an H.264 level that is consistent with your output video settings. If you aren't sure what level
* to specify, choose Auto.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264CodecLevel
*/
public H264Settings withCodecLevel(H264CodecLevel codecLevel) {
this.codecLevel = codecLevel.toString();
return this;
}
/**
* H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
*
* @param codecProfile
* H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
* @see H264CodecProfile
*/
public void setCodecProfile(String codecProfile) {
this.codecProfile = codecProfile;
}
/**
* H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
*
* @return H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
* @see H264CodecProfile
*/
public String getCodecProfile() {
return this.codecProfile;
}
/**
* H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
*
* @param codecProfile
* H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264CodecProfile
*/
public H264Settings withCodecProfile(String codecProfile) {
setCodecProfile(codecProfile);
return this;
}
/**
* H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
*
* @param codecProfile
* H.264 Profile. High 4:2:2 and 10-bit profiles are only available with the AVC-I License.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264CodecProfile
*/
public H264Settings withCodecProfile(H264CodecProfile codecProfile) {
this.codecProfile = codecProfile.toString();
return this;
}
/**
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on your
* input video content. To improve the subjective video quality of your output that has high-motion content: Leave
* blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for high-motion video content than
* low-motion content. The maximum number of B- frames is limited by the value that you choose for B-frames between
* reference frames. To use the same number B-frames for all types of content: Choose Static.
*
* @param dynamicSubGop
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on
* your input video content. To improve the subjective video quality of your output that has high-motion
* content: Leave blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for
* high-motion video content than low-motion content. The maximum number of B- frames is limited by the value
* that you choose for B-frames between reference frames. To use the same number B-frames for all types of
* content: Choose Static.
* @see H264DynamicSubGop
*/
public void setDynamicSubGop(String dynamicSubGop) {
this.dynamicSubGop = dynamicSubGop;
}
/**
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on your
* input video content. To improve the subjective video quality of your output that has high-motion content: Leave
* blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for high-motion video content than
* low-motion content. The maximum number of B- frames is limited by the value that you choose for B-frames between
* reference frames. To use the same number B-frames for all types of content: Choose Static.
*
* @return Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on
* your input video content. To improve the subjective video quality of your output that has high-motion
* content: Leave blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for
* high-motion video content than low-motion content. The maximum number of B- frames is limited by the
* value that you choose for B-frames between reference frames. To use the same number B-frames for all
* types of content: Choose Static.
* @see H264DynamicSubGop
*/
public String getDynamicSubGop() {
return this.dynamicSubGop;
}
/**
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on your
* input video content. To improve the subjective video quality of your output that has high-motion content: Leave
* blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for high-motion video content than
* low-motion content. The maximum number of B- frames is limited by the value that you choose for B-frames between
* reference frames. To use the same number B-frames for all types of content: Choose Static.
*
* @param dynamicSubGop
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on
* your input video content. To improve the subjective video quality of your output that has high-motion
* content: Leave blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for
* high-motion video content than low-motion content. The maximum number of B- frames is limited by the value
* that you choose for B-frames between reference frames. To use the same number B-frames for all types of
* content: Choose Static.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264DynamicSubGop
*/
public H264Settings withDynamicSubGop(String dynamicSubGop) {
setDynamicSubGop(dynamicSubGop);
return this;
}
/**
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on your
* input video content. To improve the subjective video quality of your output that has high-motion content: Leave
* blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for high-motion video content than
* low-motion content. The maximum number of B- frames is limited by the value that you choose for B-frames between
* reference frames. To use the same number B-frames for all types of content: Choose Static.
*
* @param dynamicSubGop
* Specify whether to allow the number of B-frames in your output GOP structure to vary or not depending on
* your input video content. To improve the subjective video quality of your output that has high-motion
* content: Leave blank or keep the default value Adaptive. MediaConvert will use fewer B-frames for
* high-motion video content than low-motion content. The maximum number of B- frames is limited by the value
* that you choose for B-frames between reference frames. To use the same number B-frames for all types of
* content: Choose Static.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264DynamicSubGop
*/
public H264Settings withDynamicSubGop(H264DynamicSubGop dynamicSubGop) {
this.dynamicSubGop = dynamicSubGop.toString();
return this;
}
/**
* Optionally include or suppress markers at the end of your output that signal the end of the video stream. To
* include end of stream markers: Leave blank or keep the default value, Include. To not include end of stream
* markers: Choose Suppress. This is useful when your output will be inserted into another stream.
*
* @param endOfStreamMarkers
* Optionally include or suppress markers at the end of your output that signal the end of the video stream.
* To include end of stream markers: Leave blank or keep the default value, Include. To not include end of
* stream markers: Choose Suppress. This is useful when your output will be inserted into another stream.
* @see H264EndOfStreamMarkers
*/
public void setEndOfStreamMarkers(String endOfStreamMarkers) {
this.endOfStreamMarkers = endOfStreamMarkers;
}
/**
* Optionally include or suppress markers at the end of your output that signal the end of the video stream. To
* include end of stream markers: Leave blank or keep the default value, Include. To not include end of stream
* markers: Choose Suppress. This is useful when your output will be inserted into another stream.
*
* @return Optionally include or suppress markers at the end of your output that signal the end of the video stream.
* To include end of stream markers: Leave blank or keep the default value, Include. To not include end of
* stream markers: Choose Suppress. This is useful when your output will be inserted into another stream.
* @see H264EndOfStreamMarkers
*/
public String getEndOfStreamMarkers() {
return this.endOfStreamMarkers;
}
/**
* Optionally include or suppress markers at the end of your output that signal the end of the video stream. To
* include end of stream markers: Leave blank or keep the default value, Include. To not include end of stream
* markers: Choose Suppress. This is useful when your output will be inserted into another stream.
*
* @param endOfStreamMarkers
* Optionally include or suppress markers at the end of your output that signal the end of the video stream.
* To include end of stream markers: Leave blank or keep the default value, Include. To not include end of
* stream markers: Choose Suppress. This is useful when your output will be inserted into another stream.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264EndOfStreamMarkers
*/
public H264Settings withEndOfStreamMarkers(String endOfStreamMarkers) {
setEndOfStreamMarkers(endOfStreamMarkers);
return this;
}
/**
* Optionally include or suppress markers at the end of your output that signal the end of the video stream. To
* include end of stream markers: Leave blank or keep the default value, Include. To not include end of stream
* markers: Choose Suppress. This is useful when your output will be inserted into another stream.
*
* @param endOfStreamMarkers
* Optionally include or suppress markers at the end of your output that signal the end of the video stream.
* To include end of stream markers: Leave blank or keep the default value, Include. To not include end of
* stream markers: Choose Suppress. This is useful when your output will be inserted into another stream.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264EndOfStreamMarkers
*/
public H264Settings withEndOfStreamMarkers(H264EndOfStreamMarkers endOfStreamMarkers) {
this.endOfStreamMarkers = endOfStreamMarkers.toString();
return this;
}
/**
* Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
*
* @param entropyEncoding
* Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
* @see H264EntropyEncoding
*/
public void setEntropyEncoding(String entropyEncoding) {
this.entropyEncoding = entropyEncoding;
}
/**
* Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
*
* @return Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
* @see H264EntropyEncoding
*/
public String getEntropyEncoding() {
return this.entropyEncoding;
}
/**
* Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
*
* @param entropyEncoding
* Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264EntropyEncoding
*/
public H264Settings withEntropyEncoding(String entropyEncoding) {
setEntropyEncoding(entropyEncoding);
return this;
}
/**
* Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
*
* @param entropyEncoding
* Entropy encoding mode. Use CABAC (must be in Main or High profile) or CAVLC.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264EntropyEncoding
*/
public H264Settings withEntropyEncoding(H264EntropyEncoding entropyEncoding) {
this.entropyEncoding = entropyEncoding.toString();
return this;
}
/**
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert use PAFF
* encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate interlaced
* fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced outputs.
*
* @param fieldEncoding
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert
* use PAFF encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate
* interlaced fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced
* outputs.
* @see H264FieldEncoding
*/
public void setFieldEncoding(String fieldEncoding) {
this.fieldEncoding = fieldEncoding;
}
/**
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert use PAFF
* encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate interlaced
* fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced outputs.
*
* @return The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert
* use PAFF encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate
* interlaced fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced
* outputs.
* @see H264FieldEncoding
*/
public String getFieldEncoding() {
return this.fieldEncoding;
}
/**
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert use PAFF
* encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate interlaced
* fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced outputs.
*
* @param fieldEncoding
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert
* use PAFF encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate
* interlaced fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced
* outputs.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FieldEncoding
*/
public H264Settings withFieldEncoding(String fieldEncoding) {
setFieldEncoding(fieldEncoding);
return this;
}
/**
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert use PAFF
* encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate interlaced
* fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced outputs.
*
* @param fieldEncoding
* The video encoding method for your MPEG-4 AVC output. Keep the default value, PAFF, to have MediaConvert
* use PAFF encoding for interlaced outputs. Choose Force field to disable PAFF encoding and create separate
* interlaced fields. Choose MBAFF to disable PAFF and have MediaConvert use MBAFF encoding for interlaced
* outputs.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FieldEncoding
*/
public H264Settings withFieldEncoding(H264FieldEncoding fieldEncoding) {
this.fieldEncoding = fieldEncoding.toString();
return this;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264FlickerAdaptiveQuantization is
* Disabled. Change this value to Enabled to reduce I-frame pop. I-frame pop appears as a visual flicker that can
* arise when the encoder saves bits by copying some macroblocks many times from frame to frame, and then refreshes
* them at the I-frame. When you enable this setting, the encoder updates these macroblocks slightly more often to
* smooth out the flicker. To manually enable or disable H264FlickerAdaptiveQuantization, you must set Adaptive
* quantization to a value other than AUTO.
*
* @param flickerAdaptiveQuantization
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264FlickerAdaptiveQuantization is Disabled. Change this value to Enabled to reduce I-frame pop. I-frame
* pop appears as a visual flicker that can arise when the encoder saves bits by copying some macroblocks
* many times from frame to frame, and then refreshes them at the I-frame. When you enable this setting, the
* encoder updates these macroblocks slightly more often to smooth out the flicker. To manually enable or
* disable H264FlickerAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @see H264FlickerAdaptiveQuantization
*/
public void setFlickerAdaptiveQuantization(String flickerAdaptiveQuantization) {
this.flickerAdaptiveQuantization = flickerAdaptiveQuantization;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264FlickerAdaptiveQuantization is
* Disabled. Change this value to Enabled to reduce I-frame pop. I-frame pop appears as a visual flicker that can
* arise when the encoder saves bits by copying some macroblocks many times from frame to frame, and then refreshes
* them at the I-frame. When you enable this setting, the encoder updates these macroblocks slightly more often to
* smooth out the flicker. To manually enable or disable H264FlickerAdaptiveQuantization, you must set Adaptive
* quantization to a value other than AUTO.
*
* @return Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264FlickerAdaptiveQuantization is Disabled. Change this value to Enabled to reduce I-frame pop. I-frame
* pop appears as a visual flicker that can arise when the encoder saves bits by copying some macroblocks
* many times from frame to frame, and then refreshes them at the I-frame. When you enable this setting, the
* encoder updates these macroblocks slightly more often to smooth out the flicker. To manually enable or
* disable H264FlickerAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @see H264FlickerAdaptiveQuantization
*/
public String getFlickerAdaptiveQuantization() {
return this.flickerAdaptiveQuantization;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264FlickerAdaptiveQuantization is
* Disabled. Change this value to Enabled to reduce I-frame pop. I-frame pop appears as a visual flicker that can
* arise when the encoder saves bits by copying some macroblocks many times from frame to frame, and then refreshes
* them at the I-frame. When you enable this setting, the encoder updates these macroblocks slightly more often to
* smooth out the flicker. To manually enable or disable H264FlickerAdaptiveQuantization, you must set Adaptive
* quantization to a value other than AUTO.
*
* @param flickerAdaptiveQuantization
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264FlickerAdaptiveQuantization is Disabled. Change this value to Enabled to reduce I-frame pop. I-frame
* pop appears as a visual flicker that can arise when the encoder saves bits by copying some macroblocks
* many times from frame to frame, and then refreshes them at the I-frame. When you enable this setting, the
* encoder updates these macroblocks slightly more often to smooth out the flicker. To manually enable or
* disable H264FlickerAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FlickerAdaptiveQuantization
*/
public H264Settings withFlickerAdaptiveQuantization(String flickerAdaptiveQuantization) {
setFlickerAdaptiveQuantization(flickerAdaptiveQuantization);
return this;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264FlickerAdaptiveQuantization is
* Disabled. Change this value to Enabled to reduce I-frame pop. I-frame pop appears as a visual flicker that can
* arise when the encoder saves bits by copying some macroblocks many times from frame to frame, and then refreshes
* them at the I-frame. When you enable this setting, the encoder updates these macroblocks slightly more often to
* smooth out the flicker. To manually enable or disable H264FlickerAdaptiveQuantization, you must set Adaptive
* quantization to a value other than AUTO.
*
* @param flickerAdaptiveQuantization
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264FlickerAdaptiveQuantization is Disabled. Change this value to Enabled to reduce I-frame pop. I-frame
* pop appears as a visual flicker that can arise when the encoder saves bits by copying some macroblocks
* many times from frame to frame, and then refreshes them at the I-frame. When you enable this setting, the
* encoder updates these macroblocks slightly more often to smooth out the flicker. To manually enable or
* disable H264FlickerAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FlickerAdaptiveQuantization
*/
public H264Settings withFlickerAdaptiveQuantization(H264FlickerAdaptiveQuantization flickerAdaptiveQuantization) {
this.flickerAdaptiveQuantization = flickerAdaptiveQuantization.toString();
return this;
}
/**
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you want to
* keep the same frame rate as the input video, choose Follow source. If you want to do frame rate conversion,
* choose a frame rate from the dropdown list or choose Custom. The framerates shown in the dropdown list are decimal
* approximations of fractions. If you choose Custom, specify your frame rate as a fraction.
*
* @param framerateControl
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you
* want to keep the same frame rate as the input video, choose Follow source. If you want to do frame rate
* conversion, choose a frame rate from the dropdown list or choose Custom. The framerates shown in the
* dropdown list are decimal approximations of fractions. If you choose Custom, specify your frame rate as a
* fraction.
* @see H264FramerateControl
*/
public void setFramerateControl(String framerateControl) {
this.framerateControl = framerateControl;
}
/**
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you want to
* keep the same frame rate as the input video, choose Follow source. If you want to do frame rate conversion,
* choose a frame rate from the dropdown list or choose Custom. The framerates shown in the dropdown list are decimal
* approximations of fractions. If you choose Custom, specify your frame rate as a fraction.
*
* @return If you are using the console, use the Framerate setting to specify the frame rate for this output. If you
* want to keep the same frame rate as the input video, choose Follow source. If you want to do frame rate
* conversion, choose a frame rate from the dropdown list or choose Custom. The framerates shown in the
* dropdown list are decimal approximations of fractions. If you choose Custom, specify your frame rate as a
* fraction.
* @see H264FramerateControl
*/
public String getFramerateControl() {
return this.framerateControl;
}
/**
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you want to
* keep the same frame rate as the input video, choose Follow source. If you want to do frame rate conversion,
* choose a frame rate from the dropdown list or choose Custom. The framerates shown in the dropdown list are decimal
* approximations of fractions. If you choose Custom, specify your frame rate as a fraction.
*
* @param framerateControl
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you
* want to keep the same frame rate as the input video, choose Follow source. If you want to do frame rate
* conversion, choose a frame rate from the dropdown list or choose Custom. The framerates shown in the
* dropdown list are decimal approximations of fractions. If you choose Custom, specify your frame rate as a
* fraction.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FramerateControl
*/
public H264Settings withFramerateControl(String framerateControl) {
setFramerateControl(framerateControl);
return this;
}
/**
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you want to
* keep the same frame rate as the input video, choose Follow source. If you want to do frame rate conversion,
* choose a frame rate from the dropdown list or choose Custom. The framerates shown in the dropdown list are decimal
* approximations of fractions. If you choose Custom, specify your frame rate as a fraction.
*
* @param framerateControl
* If you are using the console, use the Framerate setting to specify the frame rate for this output. If you
* want to keep the same frame rate as the input video, choose Follow source. If you want to do frame rate
* conversion, choose a frame rate from the dropdown list or choose Custom. The framerates shown in the
* dropdown list are decimal approximations of fractions. If you choose Custom, specify your frame rate as a
* fraction.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FramerateControl
*/
public H264Settings withFramerateControl(H264FramerateControl framerateControl) {
this.framerateControl = framerateControl.toString();
return this;
}
/**
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For numerically
* simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value, Drop duplicate. For
* numerically complex conversions, to avoid stutter: Choose Interpolate. This results in a smooth picture, but might
* introduce undesirable video artifacts. For complex frame rate conversions, especially if your source video has
* already been converted from its original cadence: Choose FrameFormer to do motion-compensated interpolation.
* FrameFormer uses the best conversion method frame by frame. Note that using FrameFormer increases the transcoding
* time and incurs a significant add-on cost. When you choose FrameFormer, your input video resolution must be at
* least 128x96.
*
* @param framerateConversionAlgorithm
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For
* numerically simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value,
* Drop duplicate. For numerically complex conversions, to avoid stutter: Choose Interpolate. This results in
* a smooth picture, but might introduce undesirable video artifacts. For complex frame rate conversions,
* especially if your source video has already been converted from its original cadence: Choose FrameFormer
* to do motion-compensated interpolation. FrameFormer uses the best conversion method frame by frame. Note
* that using FrameFormer increases the transcoding time and incurs a significant add-on cost. When you
* choose FrameFormer, your input video resolution must be at least 128x96.
* @see H264FramerateConversionAlgorithm
*/
public void setFramerateConversionAlgorithm(String framerateConversionAlgorithm) {
this.framerateConversionAlgorithm = framerateConversionAlgorithm;
}
/**
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For numerically
* simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value, Drop duplicate. For
* numerically complex conversions, to avoid stutter: Choose Interpolate. This results in a smooth picture, but might
* introduce undesirable video artifacts. For complex frame rate conversions, especially if your source video has
* already been converted from its original cadence: Choose FrameFormer to do motion-compensated interpolation.
* FrameFormer uses the best conversion method frame by frame. Note that using FrameFormer increases the transcoding
* time and incurs a significant add-on cost. When you choose FrameFormer, your input video resolution must be at
* least 128x96.
*
* @return Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For
* numerically simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value,
* Drop duplicate. For numerically complex conversions, to avoid stutter: Choose Interpolate. This results
* in a smooth picture, but might introduce undesirable video artifacts. For complex frame rate conversions,
* especially if your source video has already been converted from its original cadence: Choose FrameFormer
* to do motion-compensated interpolation. FrameFormer uses the best conversion method frame by frame. Note
* that using FrameFormer increases the transcoding time and incurs a significant add-on cost. When you
* choose FrameFormer, your input video resolution must be at least 128x96.
* @see H264FramerateConversionAlgorithm
*/
public String getFramerateConversionAlgorithm() {
return this.framerateConversionAlgorithm;
}
/**
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For numerically
* simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value, Drop duplicate. For
* numerically complex conversions, to avoid stutter: Choose Interpolate. This results in a smooth picture, but might
* introduce undesirable video artifacts. For complex frame rate conversions, especially if your source video has
* already been converted from its original cadence: Choose FrameFormer to do motion-compensated interpolation.
* FrameFormer uses the best conversion method frame by frame. Note that using FrameFormer increases the transcoding
* time and incurs a significant add-on cost. When you choose FrameFormer, your input video resolution must be at
* least 128x96.
*
* @param framerateConversionAlgorithm
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For
* numerically simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value,
* Drop duplicate. For numerically complex conversions, to avoid stutter: Choose Interpolate. This results in
* a smooth picture, but might introduce undesirable video artifacts. For complex frame rate conversions,
* especially if your source video has already been converted from its original cadence: Choose FrameFormer
* to do motion-compensated interpolation. FrameFormer uses the best conversion method frame by frame. Note
* that using FrameFormer increases the transcoding time and incurs a significant add-on cost. When you
* choose FrameFormer, your input video resolution must be at least 128x96.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FramerateConversionAlgorithm
*/
public H264Settings withFramerateConversionAlgorithm(String framerateConversionAlgorithm) {
setFramerateConversionAlgorithm(framerateConversionAlgorithm);
return this;
}
/**
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For numerically
* simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value, Drop duplicate. For
* numerically complex conversions, to avoid stutter: Choose Interpolate. This results in a smooth picture, but might
* introduce undesirable video artifacts. For complex frame rate conversions, especially if your source video has
* already been converted from its original cadence: Choose FrameFormer to do motion-compensated interpolation.
* FrameFormer uses the best conversion method frame by frame. Note that using FrameFormer increases the transcoding
* time and incurs a significant add-on cost. When you choose FrameFormer, your input video resolution must be at
* least 128x96.
*
* @param framerateConversionAlgorithm
* Choose the method that you want MediaConvert to use when increasing or decreasing the frame rate. For
* numerically simple conversions, such as 60 fps to 30 fps: We recommend that you keep the default value,
* Drop duplicate. For numerically complex conversions, to avoid stutter: Choose Interpolate. This results in
* a smooth picture, but might introduce undesirable video artifacts. For complex frame rate conversions,
* especially if your source video has already been converted from its original cadence: Choose FrameFormer
* to do motion-compensated interpolation. FrameFormer uses the best conversion method frame by frame. Note
* that using FrameFormer increases the transcoding time and incurs a significant add-on cost. When you
* choose FrameFormer, your input video resolution must be at least 128x96.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264FramerateConversionAlgorithm
*/
public H264Settings withFramerateConversionAlgorithm(H264FramerateConversionAlgorithm framerateConversionAlgorithm) {
this.framerateConversionAlgorithm = framerateConversionAlgorithm.toString();
return this;
}
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateDenominator to specify the denominator of this fraction. In this
* example, use 1001 for the value of FramerateDenominator. When you use the console for transcode jobs that use
* frame rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*
* @param framerateDenominator
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a
* fraction. For example, 24000 / 1001 = 23.976 fps. Use FramerateDenominator to specify the denominator of
* this fraction. In this example, use 1001 for the value of FramerateDenominator. When you use the console
* for transcode jobs that use frame rate conversion, provide the value as a decimal number for Framerate. In
* this example, specify 23.976.
*/
public void setFramerateDenominator(Integer framerateDenominator) {
this.framerateDenominator = framerateDenominator;
}
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateDenominator to specify the denominator of this fraction. In this
* example, use 1001 for the value of FramerateDenominator. When you use the console for transcode jobs that use
* frame rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*
* @return When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a
* fraction. For example, 24000 / 1001 = 23.976 fps. Use FramerateDenominator to specify the denominator of
* this fraction. In this example, use 1001 for the value of FramerateDenominator. When you use the console
* for transcode jobs that use frame rate conversion, provide the value as a decimal number for Framerate.
* In this example, specify 23.976.
*/
public Integer getFramerateDenominator() {
return this.framerateDenominator;
}
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateDenominator to specify the denominator of this fraction. In this
* example, use 1001 for the value of FramerateDenominator. When you use the console for transcode jobs that use
* frame rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*
* @param framerateDenominator
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a
* fraction. For example, 24000 / 1001 = 23.976 fps. Use FramerateDenominator to specify the denominator of
* this fraction. In this example, use 1001 for the value of FramerateDenominator. When you use the console
* for transcode jobs that use frame rate conversion, provide the value as a decimal number for Framerate. In
* this example, specify 23.976.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withFramerateDenominator(Integer framerateDenominator) {
setFramerateDenominator(framerateDenominator);
return this;
}
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateNumerator to specify the numerator of this fraction. In this
* example, use 24000 for the value of FramerateNumerator. When you use the console for transcode jobs that use frame
* rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*
* @param framerateNumerator
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a
* fraction. For example, 24000 / 1001 = 23.976 fps. Use FramerateNumerator to specify the numerator of this
* fraction. In this example, use 24000 for the value of FramerateNumerator. When you use the console for
* transcode jobs that use frame rate conversion, provide the value as a decimal number for Framerate. In
* this example, specify 23.976.
*/
public void setFramerateNumerator(Integer framerateNumerator) {
this.framerateNumerator = framerateNumerator;
}
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateNumerator to specify the numerator of this fraction. In this
* example, use 24000 for the value of FramerateNumerator. When you use the console for transcode jobs that use frame
* rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*
* @return When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a
* fraction. For example, 24000 / 1001 = 23.976 fps. Use FramerateNumerator to specify the numerator of this
* fraction. In this example, use 24000 for the value of FramerateNumerator. When you use the console for
* transcode jobs that use frame rate conversion, provide the value as a decimal number for Framerate. In
* this example, specify 23.976.
*/
public Integer getFramerateNumerator() {
return this.framerateNumerator;
}
/**
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a fraction. For
* example, 24000 / 1001 = 23.976 fps. Use FramerateNumerator to specify the numerator of this fraction. In this
* example, use 24000 for the value of FramerateNumerator. When you use the console for transcode jobs that use frame
* rate conversion, provide the value as a decimal number for Framerate. In this example, specify 23.976.
*
* @param framerateNumerator
* When you use the API for transcode jobs that use frame rate conversion, specify the frame rate as a
* fraction. For example, 24000 / 1001 = 23.976 fps. Use FramerateNumerator to specify the numerator of this
* fraction. In this example, use 24000 for the value of FramerateNumerator. When you use the console for
* transcode jobs that use frame rate conversion, provide the value as a decimal number for Framerate. In
* this example, specify 23.976.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withFramerateNumerator(Integer framerateNumerator) {
setFramerateNumerator(framerateNumerator);
return this;
}
/**
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when your GOP
* structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend that you choose
* Enabled to help improve the video quality of your output relative to its bitrate. To not use reference B-frames:
* Choose Disabled.
*
* @param gopBReference
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when
* your GOP structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend
* that you choose Enabled to help improve the video quality of your output relative to its bitrate. To not
* use reference B-frames: Choose Disabled.
* @see H264GopBReference
*/
public void setGopBReference(String gopBReference) {
this.gopBReference = gopBReference;
}
/**
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when your GOP
* structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend that you choose
* Enabled to help improve the video quality of your output relative to its bitrate. To not use reference B-frames:
* Choose Disabled.
*
* @return Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when
* your GOP structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend
* that you choose Enabled to help improve the video quality of your output relative to its bitrate. To not
* use reference B-frames: Choose Disabled.
* @see H264GopBReference
*/
public String getGopBReference() {
return this.gopBReference;
}
/**
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when your GOP
* structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend that you choose
* Enabled to help improve the video quality of your output relative to its bitrate. To not use reference B-frames:
* Choose Disabled.
*
* @param gopBReference
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when
* your GOP structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend
* that you choose Enabled to help improve the video quality of your output relative to its bitrate. To not
* use reference B-frames: Choose Disabled.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264GopBReference
*/
public H264Settings withGopBReference(String gopBReference) {
setGopBReference(gopBReference);
return this;
}
/**
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when your GOP
* structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend that you choose
* Enabled to help improve the video quality of your output relative to its bitrate. To not use reference B-frames:
* Choose Disabled.
*
* @param gopBReference
* Specify whether to allow B-frames to be referenced by other frame types. To use reference B-frames when
* your GOP structure has 1 or more B-frames: Leave blank or keep the default value Enabled. We recommend
* that you choose Enabled to help improve the video quality of your output relative to its bitrate. To not
* use reference B-frames: Choose Disabled.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264GopBReference
*/
public H264Settings withGopBReference(H264GopBReference gopBReference) {
this.gopBReference = gopBReference.toString();
return this;
}
/**
* Specify the relative frequency of open to closed GOPs in this output. For example, if you want to allow four open
* GOPs and then require a closed GOP, set this value to 5. We recommend that you have the transcoder automatically
* choose this value for you based on characteristics of your input video. In the console, do this by keeping the
* default empty value. If you do explicitly specify a value, for segmented outputs, don't set this value to 0.
*
* @param gopClosedCadence
* Specify the relative frequency of open to closed GOPs in this output. For example, if you want to allow
* four open GOPs and then require a closed GOP, set this value to 5. We recommend that you have the
* transcoder automatically choose this value for you based on characteristics of your input video. In the
* console, do this by keeping the default empty value. If you do explicitly specify a value, for segmented
* outputs, don't set this value to 0.
*/
public void setGopClosedCadence(Integer gopClosedCadence) {
this.gopClosedCadence = gopClosedCadence;
}
/**
* Specify the relative frequency of open to closed GOPs in this output. For example, if you want to allow four open
* GOPs and then require a closed GOP, set this value to 5. We recommend that you have the transcoder automatically
* choose this value for you based on characteristics of your input video. In the console, do this by keeping the
* default empty value. If you do explicitly specify a value, for segmented outputs, don't set this value to 0.
*
* @return Specify the relative frequency of open to closed GOPs in this output. For example, if you want to allow
* four open GOPs and then require a closed GOP, set this value to 5. We recommend that you have the
* transcoder automatically choose this value for you based on characteristics of your input video. In the
* console, do this by keeping the default empty value. If you do explicitly specify a value, for segmented
* outputs, don't set this value to 0.
*/
public Integer getGopClosedCadence() {
return this.gopClosedCadence;
}
/**
* Specify the relative frequency of open to closed GOPs in this output. For example, if you want to allow four open
* GOPs and then require a closed GOP, set this value to 5. We recommend that you have the transcoder automatically
* choose this value for you based on characteristics of your input video. In the console, do this by keeping the
* default empty value. If you do explicitly specify a value, for segmented outputs, don't set this value to 0.
*
* @param gopClosedCadence
* Specify the relative frequency of open to closed GOPs in this output. For example, if you want to allow
* four open GOPs and then require a closed GOP, set this value to 5. We recommend that you have the
* transcoder automatically choose this value for you based on characteristics of your input video. In the
* console, do this by keeping the default empty value. If you do explicitly specify a value, for segmented
* outputs, don't set this value to 0.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withGopClosedCadence(Integer gopClosedCadence) {
setGopClosedCadence(gopClosedCadence);
return this;
}
/**
* Use this setting only when you set GOP mode control to Specified, frames or Specified, seconds. Specify the GOP
* length using a whole number of frames or a decimal value of seconds. MediaConvert will interpret this value as
* frames or seconds depending on the value you choose for GOP mode control. If you want to allow MediaConvert to
* automatically determine GOP size, leave GOP size blank and set GOP mode control to Auto. If your output group
* specifies HLS, DASH, or CMAF, leave GOP size blank and set GOP mode control to Auto in each output in your output
* group.
*
* @param gopSize
* Use this setting only when you set GOP mode control to Specified, frames or Specified, seconds. Specify
* the GOP length using a whole number of frames or a decimal value of seconds. MediaConvert will interpret
* this value as frames or seconds depending on the value you choose for GOP mode control. If you want to
* allow MediaConvert to automatically determine GOP size, leave GOP size blank and set GOP mode control to
* Auto. If your output group specifies HLS, DASH, or CMAF, leave GOP size blank and set GOP mode control to
* Auto in each output in your output group.
*/
public void setGopSize(Double gopSize) {
this.gopSize = gopSize;
}
/**
* Use this setting only when you set GOP mode control to Specified, frames or Specified, seconds. Specify the GOP
* length using a whole number of frames or a decimal value of seconds. MediaConvert will interpret this value as
* frames or seconds depending on the value you choose for GOP mode control. If you want to allow MediaConvert to
* automatically determine GOP size, leave GOP size blank and set GOP mode control to Auto. If your output group
* specifies HLS, DASH, or CMAF, leave GOP size blank and set GOP mode control to Auto in each output in your output
* group.
*
* @return Use this setting only when you set GOP mode control to Specified, frames or Specified, seconds. Specify
* the GOP length using a whole number of frames or a decimal value of seconds. MediaConvert will interpret
* this value as frames or seconds depending on the value you choose for GOP mode control. If you want to
* allow MediaConvert to automatically determine GOP size, leave GOP size blank and set GOP mode control to
* Auto. If your output group specifies HLS, DASH, or CMAF, leave GOP size blank and set GOP mode control to
* Auto in each output in your output group.
*/
public Double getGopSize() {
return this.gopSize;
}
/**
* Use this setting only when you set GOP mode control to Specified, frames or Specified, seconds. Specify the GOP
* length using a whole number of frames or a decimal value of seconds. MediaConvert will interpret this value as
* frames or seconds depending on the value you choose for GOP mode control. If you want to allow MediaConvert to
* automatically determine GOP size, leave GOP size blank and set GOP mode control to Auto. If your output group
* specifies HLS, DASH, or CMAF, leave GOP size blank and set GOP mode control to Auto in each output in your output
* group.
*
* @param gopSize
* Use this setting only when you set GOP mode control to Specified, frames or Specified, seconds. Specify
* the GOP length using a whole number of frames or a decimal value of seconds. MediaConvert will interpret
* this value as frames or seconds depending on the value you choose for GOP mode control. If you want to
* allow MediaConvert to automatically determine GOP size, leave GOP size blank and set GOP mode control to
* Auto. If your output group specifies HLS, DASH, or CMAF, leave GOP size blank and set GOP mode control to
* Auto in each output in your output group.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withGopSize(Double gopSize) {
setGopSize(gopSize);
return this;
}
/**
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this automatic
* behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode control,
* MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set GOP mode control
* to Auto and leave GOP size blank in each output in your output group. To explicitly specify the GOP length, choose
* Specified, frames or Specified, seconds and then provide the GOP length in the related setting GOP size.
*
* @param gopSizeUnits
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this
* automatic behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode
* control, MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set
* GOP mode control to Auto and leave GOP size blank in each output in your output group. To explicitly
* specify the GOP length, choose Specified, frames or Specified, seconds and then provide the GOP length in
* the related setting GOP size.
* @see H264GopSizeUnits
*/
public void setGopSizeUnits(String gopSizeUnits) {
this.gopSizeUnits = gopSizeUnits;
}
/**
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this automatic
* behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode control,
* MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set GOP mode control
* to Auto and leave GOP size blank in each output in your output group. To explicitly specify the GOP length, choose
* Specified, frames or Specified, seconds and then provide the GOP length in the related setting GOP size.
*
* @return Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this
* automatic behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode
* control, MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set
* GOP mode control to Auto and leave GOP size blank in each output in your output group. To explicitly
* specify the GOP length, choose Specified, frames or Specified, seconds and then provide the GOP length in
* the related setting GOP size.
* @see H264GopSizeUnits
*/
public String getGopSizeUnits() {
return this.gopSizeUnits;
}
/**
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this automatic
* behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode control,
* MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set GOP mode control
* to Auto and leave GOP size blank in each output in your output group. To explicitly specify the GOP length, choose
* Specified, frames or Specified, seconds and then provide the GOP length in the related setting GOP size.
*
* @param gopSizeUnits
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this
* automatic behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode
* control, MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set
* GOP mode control to Auto and leave GOP size blank in each output in your output group. To explicitly
* specify the GOP length, choose Specified, frames or Specified, seconds and then provide the GOP length in
* the related setting GOP size.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264GopSizeUnits
*/
public H264Settings withGopSizeUnits(String gopSizeUnits) {
setGopSizeUnits(gopSizeUnits);
return this;
}
/**
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this automatic
* behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode control,
* MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set GOP mode control
* to Auto and leave GOP size blank in each output in your output group. To explicitly specify the GOP length, choose
* Specified, frames or Specified, seconds and then provide the GOP length in the related setting GOP size.
*
* @param gopSizeUnits
* Specify how the transcoder determines GOP size for this output. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this
* automatic behavior, choose Auto and and leave GOP size blank. By default, if you don't specify GOP mode
* control, MediaConvert will use automatic behavior. If your output group specifies HLS, DASH, or CMAF, set
* GOP mode control to Auto and leave GOP size blank in each output in your output group. To explicitly
* specify the GOP length, choose Specified, frames or Specified, seconds and then provide the GOP length in
* the related setting GOP size.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264GopSizeUnits
*/
public H264Settings withGopSizeUnits(H264GopSizeUnits gopSizeUnits) {
this.gopSizeUnits = gopSizeUnits.toString();
return this;
}
/**
* If your downstream systems have strict buffer requirements: Specify the minimum percentage of the HRD buffer
* that's available at the end of each encoded video segment. For the best video quality: Set to 0 or leave blank to
* automatically determine the final buffer fill percentage.
*
* @param hrdBufferFinalFillPercentage
* If your downstream systems have strict buffer requirements: Specify the minimum percentage of the HRD
* buffer that's available at the end of each encoded video segment. For the best video quality: Set to 0 or
* leave blank to automatically determine the final buffer fill percentage.
*/
public void setHrdBufferFinalFillPercentage(Integer hrdBufferFinalFillPercentage) {
this.hrdBufferFinalFillPercentage = hrdBufferFinalFillPercentage;
}
/**
* If your downstream systems have strict buffer requirements: Specify the minimum percentage of the HRD buffer
* that's available at the end of each encoded video segment. For the best video quality: Set to 0 or leave blank to
* automatically determine the final buffer fill percentage.
*
* @return If your downstream systems have strict buffer requirements: Specify the minimum percentage of the HRD
* buffer that's available at the end of each encoded video segment. For the best video quality: Set to 0 or
* leave blank to automatically determine the final buffer fill percentage.
*/
public Integer getHrdBufferFinalFillPercentage() {
return this.hrdBufferFinalFillPercentage;
}
/**
* If your downstream systems have strict buffer requirements: Specify the minimum percentage of the HRD buffer
* that's available at the end of each encoded video segment. For the best video quality: Set to 0 or leave blank to
* automatically determine the final buffer fill percentage.
*
* @param hrdBufferFinalFillPercentage
* If your downstream systems have strict buffer requirements: Specify the minimum percentage of the HRD
* buffer that's available at the end of each encoded video segment. For the best video quality: Set to 0 or
* leave blank to automatically determine the final buffer fill percentage.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withHrdBufferFinalFillPercentage(Integer hrdBufferFinalFillPercentage) {
setHrdBufferFinalFillPercentage(hrdBufferFinalFillPercentage);
return this;
}
/**
* Percentage of the buffer that should initially be filled (HRD buffer model).
*
* @param hrdBufferInitialFillPercentage
* Percentage of the buffer that should initially be filled (HRD buffer model).
*/
public void setHrdBufferInitialFillPercentage(Integer hrdBufferInitialFillPercentage) {
this.hrdBufferInitialFillPercentage = hrdBufferInitialFillPercentage;
}
/**
* Percentage of the buffer that should initially be filled (HRD buffer model).
*
* @return Percentage of the buffer that should initially be filled (HRD buffer model).
*/
public Integer getHrdBufferInitialFillPercentage() {
return this.hrdBufferInitialFillPercentage;
}
/**
* Percentage of the buffer that should initially be filled (HRD buffer model).
*
* @param hrdBufferInitialFillPercentage
* Percentage of the buffer that should initially be filled (HRD buffer model).
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withHrdBufferInitialFillPercentage(Integer hrdBufferInitialFillPercentage) {
setHrdBufferInitialFillPercentage(hrdBufferInitialFillPercentage);
return this;
}
/**
* Size of buffer (HRD buffer model) in bits. For example, enter five megabits as 5000000.
*
* @param hrdBufferSize
* Size of buffer (HRD buffer model) in bits. For example, enter five megabits as 5000000.
*/
public void setHrdBufferSize(Integer hrdBufferSize) {
this.hrdBufferSize = hrdBufferSize;
}
/**
* Size of buffer (HRD buffer model) in bits. For example, enter five megabits as 5000000.
*
* @return Size of buffer (HRD buffer model) in bits. For example, enter five megabits as 5000000.
*/
public Integer getHrdBufferSize() {
return this.hrdBufferSize;
}
/**
* Size of buffer (HRD buffer model) in bits. For example, enter five megabits as 5000000.
*
* @param hrdBufferSize
* Size of buffer (HRD buffer model) in bits. For example, enter five megabits as 5000000.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withHrdBufferSize(Integer hrdBufferSize) {
setHrdBufferSize(hrdBufferSize);
return this;
}
/**
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive output,
* regardless of the scan type of your input. Use Top field first or Bottom field first to create an output that's
* interlaced with the same field polarity throughout. Use Follow, default top or Follow, default bottom to produce
* outputs with the same field polarity as the source. For jobs that have multiple inputs, the output field polarity
* might change over the course of the output. Follow behavior depends on the input scan type. If the source is
* interlaced, the output will be interlaced with the same polarity as the source. If the source is progressive, the
* output will be interlaced with top field bottom field first, depending on which of the Follow options you choose.
*
* @param interlaceMode
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive
* output, regardless of the scan type of your input. Use Top field first or Bottom field first to create an
* output that's interlaced with the same field polarity throughout. Use Follow, default top or Follow,
* default bottom to produce outputs with the same field polarity as the source. For jobs that have multiple
* inputs, the output field polarity might change over the course of the output. Follow behavior depends on
* the input scan type. If the source is interlaced, the output will be interlaced with the same polarity as
* the source. If the source is progressive, the output will be interlaced with top field bottom field first,
* depending on which of the Follow options you choose.
* @see H264InterlaceMode
*/
public void setInterlaceMode(String interlaceMode) {
this.interlaceMode = interlaceMode;
}
/**
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive output,
* regardless of the scan type of your input. Use Top field first or Bottom field first to create an output that's
* interlaced with the same field polarity throughout. Use Follow, default top or Follow, default bottom to produce
* outputs with the same field polarity as the source. For jobs that have multiple inputs, the output field polarity
* might change over the course of the output. Follow behavior depends on the input scan type. If the source is
* interlaced, the output will be interlaced with the same polarity as the source. If the source is progressive, the
* output will be interlaced with top field bottom field first, depending on which of the Follow options you choose.
*
* @return Choose the scan line type for the output. Keep the default value, Progressive to create a progressive
* output, regardless of the scan type of your input. Use Top field first or Bottom field first to create an
* output that's interlaced with the same field polarity throughout. Use Follow, default top or Follow,
* default bottom to produce outputs with the same field polarity as the source. For jobs that have multiple
* inputs, the output field polarity might change over the course of the output. Follow behavior depends on
* the input scan type. If the source is interlaced, the output will be interlaced with the same polarity as
* the source. If the source is progressive, the output will be interlaced with top field bottom field
* first, depending on which of the Follow options you choose.
* @see H264InterlaceMode
*/
public String getInterlaceMode() {
return this.interlaceMode;
}
/**
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive output,
* regardless of the scan type of your input. Use Top field first or Bottom field first to create an output that's
* interlaced with the same field polarity throughout. Use Follow, default top or Follow, default bottom to produce
* outputs with the same field polarity as the source. For jobs that have multiple inputs, the output field polarity
* might change over the course of the output. Follow behavior depends on the input scan type. If the source is
* interlaced, the output will be interlaced with the same polarity as the source. If the source is progressive, the
* output will be interlaced with top field bottom field first, depending on which of the Follow options you choose.
*
* @param interlaceMode
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive
* output, regardless of the scan type of your input. Use Top field first or Bottom field first to create an
* output that's interlaced with the same field polarity throughout. Use Follow, default top or Follow,
* default bottom to produce outputs with the same field polarity as the source. For jobs that have multiple
* inputs, the output field polarity might change over the course of the output. Follow behavior depends on
* the input scan type. If the source is interlaced, the output will be interlaced with the same polarity as
* the source. If the source is progressive, the output will be interlaced with top field bottom field first,
* depending on which of the Follow options you choose.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264InterlaceMode
*/
public H264Settings withInterlaceMode(String interlaceMode) {
setInterlaceMode(interlaceMode);
return this;
}
/**
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive output,
* regardless of the scan type of your input. Use Top field first or Bottom field first to create an output that's
* interlaced with the same field polarity throughout. Use Follow, default top or Follow, default bottom to produce
* outputs with the same field polarity as the source. For jobs that have multiple inputs, the output field polarity
* might change over the course of the output. Follow behavior depends on the input scan type. If the source is
* interlaced, the output will be interlaced with the same polarity as the source. If the source is progressive, the
* output will be interlaced with top field bottom field first, depending on which of the Follow options you choose.
*
* @param interlaceMode
* Choose the scan line type for the output. Keep the default value, Progressive to create a progressive
* output, regardless of the scan type of your input. Use Top field first or Bottom field first to create an
* output that's interlaced with the same field polarity throughout. Use Follow, default top or Follow,
* default bottom to produce outputs with the same field polarity as the source. For jobs that have multiple
* inputs, the output field polarity might change over the course of the output. Follow behavior depends on
* the input scan type. If the source is interlaced, the output will be interlaced with the same polarity as
* the source. If the source is progressive, the output will be interlaced with top field bottom field first,
* depending on which of the Follow options you choose.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264InterlaceMode
*/
public H264Settings withInterlaceMode(H264InterlaceMode interlaceMode) {
this.interlaceMode = interlaceMode.toString();
return this;
}
/**
* Maximum bitrate in bits/second. For example, enter five megabits per second as 5000000. Required when Rate
* control mode is QVBR.
*
* @param maxBitrate
* Maximum bitrate in bits/second. For example, enter five megabits per second as 5000000. Required when Rate
* control mode is QVBR.
*/
public void setMaxBitrate(Integer maxBitrate) {
this.maxBitrate = maxBitrate;
}
/**
* Maximum bitrate in bits/second. For example, enter five megabits per second as 5000000. Required when Rate
* control mode is QVBR.
*
* @return Maximum bitrate in bits/second. For example, enter five megabits per second as 5000000. Required when
* Rate control mode is QVBR.
*/
public Integer getMaxBitrate() {
return this.maxBitrate;
}
/**
* Maximum bitrate in bits/second. For example, enter five megabits per second as 5000000. Required when Rate
* control mode is QVBR.
*
* @param maxBitrate
* Maximum bitrate in bits/second. For example, enter five megabits per second as 5000000. Required when Rate
* control mode is QVBR.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withMaxBitrate(Integer maxBitrate) {
setMaxBitrate(maxBitrate);
return this;
}
/**
* Use this setting only when you also enable Scene change detection. This setting determines how the encoder
* manages the spacing between I-frames that it inserts as part of the I-frame cadence and the I-frames that it
* inserts for Scene change detection. We recommend that you have the transcoder automatically choose this value for
* you based on characteristics of your input video. To enable this automatic behavior, do this by keeping the
* default empty value. When you explicitly specify a value for this setting, the encoder determines whether to skip
* a cadence-driven I-frame by the value you set. For example, if you set Min I interval to 5 and a cadence-driven
* I-frame would fall within 5 frames of a scene-change I-frame, then the encoder skips the cadence-driven I-frame.
* In this way, one GOP is shrunk slightly and one GOP is stretched slightly. When the cadence-driven I-frames are
* farther from the scene-change I-frame than the value you set, then the encoder leaves all I-frames in place and
* the GOPs surrounding the scene change are smaller than the usual cadence GOPs.
*
* @param minIInterval
* Use this setting only when you also enable Scene change detection. This setting determines how the encoder
* manages the spacing between I-frames that it inserts as part of the I-frame cadence and the I-frames that
* it inserts for Scene change detection. We recommend that you have the transcoder automatically choose this
* value for you based on characteristics of your input video. To enable this automatic behavior, do this by
* keeping the default empty value. When you explicitly specify a value for this setting, the encoder
* determines whether to skip a cadence-driven I-frame by the value you set. For example, if you set Min I
* interval to 5 and a cadence-driven I-frame would fall within 5 frames of a scene-change I-frame, then the
* encoder skips the cadence-driven I-frame. In this way, one GOP is shrunk slightly and one GOP is stretched
* slightly. When the cadence-driven I-frames are farther from the scene-change I-frame than the value you
* set, then the encoder leaves all I-frames in place and the GOPs surrounding the scene change are smaller
* than the usual cadence GOPs.
*/
public void setMinIInterval(Integer minIInterval) {
this.minIInterval = minIInterval;
}
/**
* Use this setting only when you also enable Scene change detection. This setting determines how the encoder
* manages the spacing between I-frames that it inserts as part of the I-frame cadence and the I-frames that it
* inserts for Scene change detection. We recommend that you have the transcoder automatically choose this value for
* you based on characteristics of your input video. To enable this automatic behavior, do this by keeping the
* default empty value. When you explicitly specify a value for this setting, the encoder determines whether to skip
* a cadence-driven I-frame by the value you set. For example, if you set Min I interval to 5 and a cadence-driven
* I-frame would fall within 5 frames of a scene-change I-frame, then the encoder skips the cadence-driven I-frame.
* In this way, one GOP is shrunk slightly and one GOP is stretched slightly. When the cadence-driven I-frames are
* farther from the scene-change I-frame than the value you set, then the encoder leaves all I-frames in place and
* the GOPs surrounding the scene change are smaller than the usual cadence GOPs.
*
* @return Use this setting only when you also enable Scene change detection. This setting determines how the
* encoder manages the spacing between I-frames that it inserts as part of the I-frame cadence and the
* I-frames that it inserts for Scene change detection. We recommend that you have the transcoder
* automatically choose this value for you based on characteristics of your input video. To enable this
* automatic behavior, do this by keeping the default empty value. When you explicitly specify a value for
* this setting, the encoder determines whether to skip a cadence-driven I-frame by the value you set. For
* example, if you set Min I interval to 5 and a cadence-driven I-frame would fall within 5 frames of a
* scene-change I-frame, then the encoder skips the cadence-driven I-frame. In this way, one GOP is shrunk
* slightly and one GOP is stretched slightly. When the cadence-driven I-frames are farther from the
* scene-change I-frame than the value you set, then the encoder leaves all I-frames in place and the GOPs
* surrounding the scene change are smaller than the usual cadence GOPs.
*/
public Integer getMinIInterval() {
return this.minIInterval;
}
/**
* Use this setting only when you also enable Scene change detection. This setting determines how the encoder
* manages the spacing between I-frames that it inserts as part of the I-frame cadence and the I-frames that it
* inserts for Scene change detection. We recommend that you have the transcoder automatically choose this value for
* you based on characteristics of your input video. To enable this automatic behavior, do this by keeping the
* default empty value. When you explicitly specify a value for this setting, the encoder determines whether to skip
* a cadence-driven I-frame by the value you set. For example, if you set Min I interval to 5 and a cadence-driven
* I-frame would fall within 5 frames of a scene-change I-frame, then the encoder skips the cadence-driven I-frame.
* In this way, one GOP is shrunk slightly and one GOP is stretched slightly. When the cadence-driven I-frames are
* farther from the scene-change I-frame than the value you set, then the encoder leaves all I-frames in place and
* the GOPs surrounding the scene change are smaller than the usual cadence GOPs.
*
* @param minIInterval
* Use this setting only when you also enable Scene change detection. This setting determines how the encoder
* manages the spacing between I-frames that it inserts as part of the I-frame cadence and the I-frames that
* it inserts for Scene change detection. We recommend that you have the transcoder automatically choose this
* value for you based on characteristics of your input video. To enable this automatic behavior, do this by
* keeping the default empty value. When you explicitly specify a value for this setting, the encoder
* determines whether to skip a cadence-driven I-frame by the value you set. For example, if you set Min I
* interval to 5 and a cadence-driven I-frame would fall within 5 frames of a scene-change I-frame, then the
* encoder skips the cadence-driven I-frame. In this way, one GOP is shrunk slightly and one GOP is stretched
* slightly. When the cadence-driven I-frames are farther from the scene-change I-frame than the value you
* set, then the encoder leaves all I-frames in place and the GOPs surrounding the scene change are smaller
* than the usual cadence GOPs.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withMinIInterval(Integer minIInterval) {
setMinIInterval(minIInterval);
return this;
}
/**
* Specify the number of B-frames between reference frames in this output. For the best video quality: Leave blank.
* MediaConvert automatically determines the number of B-frames to use based on the characteristics of your input
* video. To manually specify the number of B-frames between reference frames: Enter an integer from 0 to 7.
*
* @param numberBFramesBetweenReferenceFrames
* Specify the number of B-frames between reference frames in this output. For the best video quality: Leave
* blank. MediaConvert automatically determines the number of B-frames to use based on the characteristics of
* your input video. To manually specify the number of B-frames between reference frames: Enter an integer
* from 0 to 7.
*/
public void setNumberBFramesBetweenReferenceFrames(Integer numberBFramesBetweenReferenceFrames) {
this.numberBFramesBetweenReferenceFrames = numberBFramesBetweenReferenceFrames;
}
/**
* Specify the number of B-frames between reference frames in this output. For the best video quality: Leave blank.
* MediaConvert automatically determines the number of B-frames to use based on the characteristics of your input
* video. To manually specify the number of B-frames between reference frames: Enter an integer from 0 to 7.
*
* @return Specify the number of B-frames between reference frames in this output. For the best video quality: Leave
* blank. MediaConvert automatically determines the number of B-frames to use based on the characteristics
* of your input video. To manually specify the number of B-frames between reference frames: Enter an
* integer from 0 to 7.
*/
public Integer getNumberBFramesBetweenReferenceFrames() {
return this.numberBFramesBetweenReferenceFrames;
}
/**
* Specify the number of B-frames between reference frames in this output. For the best video quality: Leave blank.
* MediaConvert automatically determines the number of B-frames to use based on the characteristics of your input
* video. To manually specify the number of B-frames between reference frames: Enter an integer from 0 to 7.
*
* @param numberBFramesBetweenReferenceFrames
* Specify the number of B-frames between reference frames in this output. For the best video quality: Leave
* blank. MediaConvert automatically determines the number of B-frames to use based on the characteristics of
* your input video. To manually specify the number of B-frames between reference frames: Enter an integer
* from 0 to 7.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withNumberBFramesBetweenReferenceFrames(Integer numberBFramesBetweenReferenceFrames) {
setNumberBFramesBetweenReferenceFrames(numberBFramesBetweenReferenceFrames);
return this;
}
/**
* Number of reference frames to use. The encoder may use more than requested if using B-frames and/or interlaced
* encoding.
*
* @param numberReferenceFrames
* Number of reference frames to use. The encoder may use more than requested if using B-frames and/or
* interlaced encoding.
*/
public void setNumberReferenceFrames(Integer numberReferenceFrames) {
this.numberReferenceFrames = numberReferenceFrames;
}
/**
* Number of reference frames to use. The encoder may use more than requested if using B-frames and/or interlaced
* encoding.
*
* @return Number of reference frames to use. The encoder may use more than requested if using B-frames and/or
* interlaced encoding.
*/
public Integer getNumberReferenceFrames() {
return this.numberReferenceFrames;
}
/**
* Number of reference frames to use. The encoder may use more than requested if using B-frames and/or interlaced
* encoding.
*
* @param numberReferenceFrames
* Number of reference frames to use. The encoder may use more than requested if using B-frames and/or
* interlaced encoding.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withNumberReferenceFrames(Integer numberReferenceFrames) {
setNumberReferenceFrames(numberReferenceFrames);
return this;
}
/**
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default behavior,
* Follow source, uses the PAR from your input video for your output. To specify a different PAR in the console,
* choose any value other than Follow source. When you choose SPECIFIED for this setting, you must also specify
* values for the parNumerator and parDenominator settings.
*
* @param parControl
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default
* behavior, Follow source, uses the PAR from your input video for your output. To specify a different PAR in
* the console, choose any value other than Follow source. When you choose SPECIFIED for this setting, you
* must also specify values for the parNumerator and parDenominator settings.
* @see H264ParControl
*/
public void setParControl(String parControl) {
this.parControl = parControl;
}
/**
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default behavior,
* Follow source, uses the PAR from your input video for your output. To specify a different PAR in the console,
* choose any value other than Follow source. When you choose SPECIFIED for this setting, you must also specify
* values for the parNumerator and parDenominator settings.
*
* @return Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default
* behavior, Follow source, uses the PAR from your input video for your output. To specify a different PAR
* in the console, choose any value other than Follow source. When you choose SPECIFIED for this setting,
* you must also specify values for the parNumerator and parDenominator settings.
* @see H264ParControl
*/
public String getParControl() {
return this.parControl;
}
/**
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default behavior,
* Follow source, uses the PAR from your input video for your output. To specify a different PAR in the console,
* choose any value other than Follow source. When you choose SPECIFIED for this setting, you must also specify
* values for the parNumerator and parDenominator settings.
*
* @param parControl
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default
* behavior, Follow source, uses the PAR from your input video for your output. To specify a different PAR in
* the console, choose any value other than Follow source. When you choose SPECIFIED for this setting, you
* must also specify values for the parNumerator and parDenominator settings.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264ParControl
*/
public H264Settings withParControl(String parControl) {
setParControl(parControl);
return this;
}
/**
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default behavior,
* Follow source, uses the PAR from your input video for your output. To specify a different PAR in the console,
* choose any value other than Follow source. When you choose SPECIFIED for this setting, you must also specify
* values for the parNumerator and parDenominator settings.
*
* @param parControl
* Optional. Specify how the service determines the pixel aspect ratio (PAR) for this output. The default
* behavior, Follow source, uses the PAR from your input video for your output. To specify a different PAR in
* the console, choose any value other than Follow source. When you choose SPECIFIED for this setting, you
* must also specify values for the parNumerator and parDenominator settings.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264ParControl
*/
public H264Settings withParControl(H264ParControl parControl) {
this.parControl = parControl.toString();
return this;
}
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parDenominator is 33.
*
* @param parDenominator
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other
* than Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input
* video PAR, provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify
* the ratio 40:33. In this example, the value for parDenominator is 33.
*/
public void setParDenominator(Integer parDenominator) {
this.parDenominator = parDenominator;
}
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parDenominator is 33.
*
* @return Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value
* other than Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your
* input video PAR, provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would
* specify the ratio 40:33. In this example, the value for parDenominator is 33.
*/
public Integer getParDenominator() {
return this.parDenominator;
}
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parDenominator is 33.
*
* @param parDenominator
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other
* than Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input
* video PAR, provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify
* the ratio 40:33. In this example, the value for parDenominator is 33.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withParDenominator(Integer parDenominator) {
setParDenominator(parDenominator);
return this;
}
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parNumerator is 40.
*
* @param parNumerator
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other
* than Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input
* video PAR, provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify
* the ratio 40:33. In this example, the value for parNumerator is 40.
*/
public void setParNumerator(Integer parNumerator) {
this.parNumerator = parNumerator;
}
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parNumerator is 40.
*
* @return Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value
* other than Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your
* input video PAR, provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would
* specify the ratio 40:33. In this example, the value for parNumerator is 40.
*/
public Integer getParNumerator() {
return this.parNumerator;
}
/**
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other than
* Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input video PAR,
* provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify the ratio 40:33. In
* this example, the value for parNumerator is 40.
*
* @param parNumerator
* Required when you set Pixel aspect ratio to SPECIFIED. On the console, this corresponds to any value other
* than Follow source. When you specify an output pixel aspect ratio (PAR) that is different from your input
* video PAR, provide your output PAR as a ratio. For example, for D1/DV NTSC widescreen, you would specify
* the ratio 40:33. In this example, the value for parNumerator is 40.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withParNumerator(Integer parNumerator) {
setParNumerator(parNumerator);
return this;
}
/**
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the output
* video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For a good
* balance between encoding speed and video quality: Leave blank or keep the default value Single pass HQ. For the
* best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs an analysis pass on
* your input followed by an encoding pass. Outputs that use this feature incur pro-tier pricing.
*
* @param qualityTuningLevel
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the
* output video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For
* a good balance between encoding speed and video quality: Leave blank or keep the default value Single pass
* HQ. For the best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs
* an analysis pass on your input followed by an encoding pass. Outputs that use this feature incur pro-tier
* pricing.
* @see H264QualityTuningLevel
*/
public void setQualityTuningLevel(String qualityTuningLevel) {
this.qualityTuningLevel = qualityTuningLevel;
}
/**
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the output
* video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For a good
* balance between encoding speed and video quality: Leave blank or keep the default value Single pass HQ. For the
* best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs an analysis pass on
* your input followed by an encoding pass. Outputs that use this feature incur pro-tier pricing.
*
* @return The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the
* output video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass.
* For a good balance between encoding speed and video quality: Leave blank or keep the default value Single
* pass HQ. For the best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert
* performs an analysis pass on your input followed by an encoding pass. Outputs that use this feature incur
* pro-tier pricing.
* @see H264QualityTuningLevel
*/
public String getQualityTuningLevel() {
return this.qualityTuningLevel;
}
/**
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the output
* video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For a good
* balance between encoding speed and video quality: Leave blank or keep the default value Single pass HQ. For the
* best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs an analysis pass on
* your input followed by an encoding pass. Outputs that use this feature incur pro-tier pricing.
*
* @param qualityTuningLevel
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the
* output video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For
* a good balance between encoding speed and video quality: Leave blank or keep the default value Single pass
* HQ. For the best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs
* an analysis pass on your input followed by an encoding pass. Outputs that use this feature incur pro-tier
* pricing.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264QualityTuningLevel
*/
public H264Settings withQualityTuningLevel(String qualityTuningLevel) {
setQualityTuningLevel(qualityTuningLevel);
return this;
}
/**
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the output
* video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For a good
* balance between encoding speed and video quality: Leave blank or keep the default value Single pass HQ. For the
* best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs an analysis pass on
* your input followed by an encoding pass. Outputs that use this feature incur pro-tier pricing.
*
* @param qualityTuningLevel
* The Quality tuning level you choose represents a trade-off between the encoding speed of your job and the
* output video quality. For the fastest encoding speed at the cost of video quality: Choose Single pass. For
* a good balance between encoding speed and video quality: Leave blank or keep the default value Single pass
* HQ. For the best video quality, at the cost of encoding speed: Choose Multi pass HQ. MediaConvert performs
* an analysis pass on your input followed by an encoding pass. Outputs that use this feature incur pro-tier
* pricing.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264QualityTuningLevel
*/
public H264Settings withQualityTuningLevel(H264QualityTuningLevel qualityTuningLevel) {
this.qualityTuningLevel = qualityTuningLevel.toString();
return this;
}
/**
* Settings for quality-defined variable bitrate encoding with the H.265 codec. Use these settings only when you set
* QVBR for Rate control mode.
*
* @param qvbrSettings
* Settings for quality-defined variable bitrate encoding with the H.265 codec. Use these settings only when
* you set QVBR for Rate control mode.
*/
public void setQvbrSettings(H264QvbrSettings qvbrSettings) {
this.qvbrSettings = qvbrSettings;
}
/**
* Settings for quality-defined variable bitrate encoding with the H.265 codec. Use these settings only when you set
* QVBR for Rate control mode.
*
* @return Settings for quality-defined variable bitrate encoding with the H.265 codec. Use these settings only when
* you set QVBR for Rate control mode.
*/
public H264QvbrSettings getQvbrSettings() {
return this.qvbrSettings;
}
/**
* Settings for quality-defined variable bitrate encoding with the H.265 codec. Use these settings only when you set
* QVBR for Rate control mode.
*
* @param qvbrSettings
* Settings for quality-defined variable bitrate encoding with the H.265 codec. Use these settings only when
* you set QVBR for Rate control mode.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withQvbrSettings(H264QvbrSettings qvbrSettings) {
setQvbrSettings(qvbrSettings);
return this;
}
/**
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
*
* @param rateControlMode
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
* @see H264RateControlMode
*/
public void setRateControlMode(String rateControlMode) {
this.rateControlMode = rateControlMode;
}
/**
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
*
* @return Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
* @see H264RateControlMode
*/
public String getRateControlMode() {
return this.rateControlMode;
}
/**
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
*
* @param rateControlMode
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264RateControlMode
*/
public H264Settings withRateControlMode(String rateControlMode) {
setRateControlMode(rateControlMode);
return this;
}
/**
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
*
* @param rateControlMode
* Use this setting to specify whether this output has a variable bitrate (VBR), constant bitrate (CBR) or
* quality-defined variable bitrate (QVBR).
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264RateControlMode
*/
public H264Settings withRateControlMode(H264RateControlMode rateControlMode) {
this.rateControlMode = rateControlMode.toString();
return this;
}
/**
* Places a PPS header on each encoded picture, even if repeated.
*
* @param repeatPps
* Places a PPS header on each encoded picture, even if repeated.
* @see H264RepeatPps
*/
public void setRepeatPps(String repeatPps) {
this.repeatPps = repeatPps;
}
/**
* Places a PPS header on each encoded picture, even if repeated.
*
* @return Places a PPS header on each encoded picture, even if repeated.
* @see H264RepeatPps
*/
public String getRepeatPps() {
return this.repeatPps;
}
/**
* Places a PPS header on each encoded picture, even if repeated.
*
* @param repeatPps
* Places a PPS header on each encoded picture, even if repeated.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264RepeatPps
*/
public H264Settings withRepeatPps(String repeatPps) {
setRepeatPps(repeatPps);
return this;
}
/**
* Places a PPS header on each encoded picture, even if repeated.
*
* @param repeatPps
* Places a PPS header on each encoded picture, even if repeated.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264RepeatPps
*/
public H264Settings withRepeatPps(H264RepeatPps repeatPps) {
this.repeatPps = repeatPps.toString();
return this;
}
/**
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In this
* situation, choose Optimized interlacing to create a better quality interlaced output. In this case, each
* progressive frame from the input corresponds to an interlaced field in the output. Keep the default value, Basic
* interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs any frame rate
* conversion first and then interlaces the frames. When you choose Optimized interlacing and you set your output
* frame rate to a value that isn't suitable for optimized interlacing, MediaConvert automatically falls back to
* basic interlacing. Required settings: To use optimized interlacing, you must set Telecine to None or Soft. You
* can't use optimized interlacing for hard telecine outputs. You must also set Interlace mode to a value other than
* Progressive.
*
* @param scanTypeConversionMode
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In
* this situation, choose Optimized interlacing to create a better quality interlaced output. In this case,
* each progressive frame from the input corresponds to an interlaced field in the output. Keep the default
* value, Basic interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs
* any frame rate conversion first and then interlaces the frames. When you choose Optimized interlacing and
* you set your output frame rate to a value that isn't suitable for optimized interlacing, MediaConvert
* automatically falls back to basic interlacing. Required settings: To use optimized interlacing, you must
* set Telecine to None or Soft. You can't use optimized interlacing for hard telecine outputs. You must also
* set Interlace mode to a value other than Progressive.
* @see H264ScanTypeConversionMode
*/
public void setScanTypeConversionMode(String scanTypeConversionMode) {
this.scanTypeConversionMode = scanTypeConversionMode;
}
/**
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In this
* situation, choose Optimized interlacing to create a better quality interlaced output. In this case, each
* progressive frame from the input corresponds to an interlaced field in the output. Keep the default value, Basic
* interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs any frame rate
* conversion first and then interlaces the frames. When you choose Optimized interlacing and you set your output
* frame rate to a value that isn't suitable for optimized interlacing, MediaConvert automatically falls back to
* basic interlacing. Required settings: To use optimized interlacing, you must set Telecine to None or Soft. You
* can't use optimized interlacing for hard telecine outputs. You must also set Interlace mode to a value other than
* Progressive.
*
* @return Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In
* this situation, choose Optimized interlacing to create a better quality interlaced output. In this case,
* each progressive frame from the input corresponds to an interlaced field in the output. Keep the default
* value, Basic interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs
* any frame rate conversion first and then interlaces the frames. When you choose Optimized interlacing and
* you set your output frame rate to a value that isn't suitable for optimized interlacing, MediaConvert
* automatically falls back to basic interlacing. Required settings: To use optimized interlacing, you must
* set Telecine to None or Soft. You can't use optimized interlacing for hard telecine outputs. You must
* also set Interlace mode to a value other than Progressive.
* @see H264ScanTypeConversionMode
*/
public String getScanTypeConversionMode() {
return this.scanTypeConversionMode;
}
/**
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In this
* situation, choose Optimized interlacing to create a better quality interlaced output. In this case, each
* progressive frame from the input corresponds to an interlaced field in the output. Keep the default value, Basic
* interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs any frame rate
* conversion first and then interlaces the frames. When you choose Optimized interlacing and you set your output
* frame rate to a value that isn't suitable for optimized interlacing, MediaConvert automatically falls back to
* basic interlacing. Required settings: To use optimized interlacing, you must set Telecine to None or Soft. You
* can't use optimized interlacing for hard telecine outputs. You must also set Interlace mode to a value other than
* Progressive.
*
* @param scanTypeConversionMode
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In
* this situation, choose Optimized interlacing to create a better quality interlaced output. In this case,
* each progressive frame from the input corresponds to an interlaced field in the output. Keep the default
* value, Basic interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs
* any frame rate conversion first and then interlaces the frames. When you choose Optimized interlacing and
* you set your output frame rate to a value that isn't suitable for optimized interlacing, MediaConvert
* automatically falls back to basic interlacing. Required settings: To use optimized interlacing, you must
* set Telecine to None or Soft. You can't use optimized interlacing for hard telecine outputs. You must also
* set Interlace mode to a value other than Progressive.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264ScanTypeConversionMode
*/
public H264Settings withScanTypeConversionMode(String scanTypeConversionMode) {
setScanTypeConversionMode(scanTypeConversionMode);
return this;
}
/**
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In this
* situation, choose Optimized interlacing to create a better quality interlaced output. In this case, each
* progressive frame from the input corresponds to an interlaced field in the output. Keep the default value, Basic
* interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs any frame rate
* conversion first and then interlaces the frames. When you choose Optimized interlacing and you set your output
* frame rate to a value that isn't suitable for optimized interlacing, MediaConvert automatically falls back to
* basic interlacing. Required settings: To use optimized interlacing, you must set Telecine to None or Soft. You
* can't use optimized interlacing for hard telecine outputs. You must also set Interlace mode to a value other than
* Progressive.
*
* @param scanTypeConversionMode
* Use this setting for interlaced outputs, when your output frame rate is half of your input frame rate. In
* this situation, choose Optimized interlacing to create a better quality interlaced output. In this case,
* each progressive frame from the input corresponds to an interlaced field in the output. Keep the default
* value, Basic interlacing, for all other output frame rates. With basic interlacing, MediaConvert performs
* any frame rate conversion first and then interlaces the frames. When you choose Optimized interlacing and
* you set your output frame rate to a value that isn't suitable for optimized interlacing, MediaConvert
* automatically falls back to basic interlacing. Required settings: To use optimized interlacing, you must
* set Telecine to None or Soft. You can't use optimized interlacing for hard telecine outputs. You must also
* set Interlace mode to a value other than Progressive.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264ScanTypeConversionMode
*/
public H264Settings withScanTypeConversionMode(H264ScanTypeConversionMode scanTypeConversionMode) {
this.scanTypeConversionMode = scanTypeConversionMode.toString();
return this;
}
/**
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This improves
* video quality and is enabled by default. If this output uses QVBR, choose Transition detection for further video
* quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
*
* @param sceneChangeDetect
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This
* improves video quality and is enabled by default. If this output uses QVBR, choose Transition detection
* for further video quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
* @see H264SceneChangeDetect
*/
public void setSceneChangeDetect(String sceneChangeDetect) {
this.sceneChangeDetect = sceneChangeDetect;
}
/**
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This improves
* video quality and is enabled by default. If this output uses QVBR, choose Transition detection for further video
* quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
*
* @return Enable this setting to insert I-frames at scene changes that the service automatically detects. This
* improves video quality and is enabled by default. If this output uses QVBR, choose Transition detection
* for further video quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
* @see H264SceneChangeDetect
*/
public String getSceneChangeDetect() {
return this.sceneChangeDetect;
}
/**
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This improves
* video quality and is enabled by default. If this output uses QVBR, choose Transition detection for further video
* quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
*
* @param sceneChangeDetect
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This
* improves video quality and is enabled by default. If this output uses QVBR, choose Transition detection
* for further video quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264SceneChangeDetect
*/
public H264Settings withSceneChangeDetect(String sceneChangeDetect) {
setSceneChangeDetect(sceneChangeDetect);
return this;
}
/**
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This improves
* video quality and is enabled by default. If this output uses QVBR, choose Transition detection for further video
* quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
*
* @param sceneChangeDetect
* Enable this setting to insert I-frames at scene changes that the service automatically detects. This
* improves video quality and is enabled by default. If this output uses QVBR, choose Transition detection
* for further video quality improvement. For more information about QVBR, see
* https://docs.aws.amazon.com/console/mediaconvert/cbr-vbr-qvbr.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264SceneChangeDetect
*/
public H264Settings withSceneChangeDetect(H264SceneChangeDetect sceneChangeDetect) {
this.sceneChangeDetect = sceneChangeDetect.toString();
return this;
}
/**
* Number of slices per picture. Must be less than or equal to the number of macroblock rows for progressive
* pictures, and less than or equal to half the number of macroblock rows for interlaced pictures.
*
* @param slices
* Number of slices per picture. Must be less than or equal to the number of macroblock rows for progressive
* pictures, and less than or equal to half the number of macroblock rows for interlaced pictures.
*/
public void setSlices(Integer slices) {
this.slices = slices;
}
/**
* Number of slices per picture. Must be less than or equal to the number of macroblock rows for progressive
* pictures, and less than or equal to half the number of macroblock rows for interlaced pictures.
*
* @return Number of slices per picture. Must be less than or equal to the number of macroblock rows for progressive
* pictures, and less than or equal to half the number of macroblock rows for interlaced pictures.
*/
public Integer getSlices() {
return this.slices;
}
/**
* Number of slices per picture. Must be less than or equal to the number of macroblock rows for progressive
* pictures, and less than or equal to half the number of macroblock rows for interlaced pictures.
*
* @param slices
* Number of slices per picture. Must be less than or equal to the number of macroblock rows for progressive
* pictures, and less than or equal to half the number of macroblock rows for interlaced pictures.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withSlices(Integer slices) {
setSlices(slices);
return this;
}
/**
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL to
* create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and resamples
* your audio to keep it synchronized with the video. Note that enabling this setting will slightly reduce the
* duration of your video. Required settings: You must also set Framerate to 25.
*
* @param slowPal
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL
* to create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and
* resamples your audio to keep it synchronized with the video. Note that enabling this setting will slightly
* reduce the duration of your video. Required settings: You must also set Framerate to 25.
* @see H264SlowPal
*/
public void setSlowPal(String slowPal) {
this.slowPal = slowPal;
}
/**
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL to
* create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and resamples
* your audio to keep it synchronized with the video. Note that enabling this setting will slightly reduce the
* duration of your video. Required settings: You must also set Framerate to 25.
*
* @return Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL
* to create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and
* resamples your audio to keep it synchronized with the video. Note that enabling this setting will
* slightly reduce the duration of your video. Required settings: You must also set Framerate to 25.
* @see H264SlowPal
*/
public String getSlowPal() {
return this.slowPal;
}
/**
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL to
* create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and resamples
* your audio to keep it synchronized with the video. Note that enabling this setting will slightly reduce the
* duration of your video. Required settings: You must also set Framerate to 25.
*
* @param slowPal
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL
* to create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and
* resamples your audio to keep it synchronized with the video. Note that enabling this setting will slightly
* reduce the duration of your video. Required settings: You must also set Framerate to 25.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264SlowPal
*/
public H264Settings withSlowPal(String slowPal) {
setSlowPal(slowPal);
return this;
}
/**
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL to
* create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and resamples
* your audio to keep it synchronized with the video. Note that enabling this setting will slightly reduce the
* duration of your video. Required settings: You must also set Framerate to 25.
*
* @param slowPal
* Ignore this setting unless your input frame rate is 23.976 or 24 frames per second (fps). Enable slow PAL
* to create a 25 fps output. When you enable slow PAL, MediaConvert relabels the video frames to 25 fps and
* resamples your audio to keep it synchronized with the video. Note that enabling this setting will slightly
* reduce the duration of your video. Required settings: You must also set Framerate to 25.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264SlowPal
*/
public H264Settings withSlowPal(H264SlowPal slowPal) {
this.slowPal = slowPal.toString();
return this;
}
/**
* Ignore this setting unless you need to comply with a specification that requires a specific value. If you don't
* have a specification requirement, we recommend that you adjust the softness of your output by using a lower value
* for the setting Sharpness or by enabling a noise reducer filter. The Softness setting specifies the quantization
* matrices that the encoder uses. Keep the default value, 0, for flat quantization. Choose the value 1 or 16 to use
* the default JVT softening quantization matricies from the H.264 specification. Choose a value from 17 to 128 to
* use planar interpolation. Increasing values from 17 to 128 result in increasing reduction of high-frequency data.
* The value 128 results in the softest video.
*
* @param softness
* Ignore this setting unless you need to comply with a specification that requires a specific value. If you
* don't have a specification requirement, we recommend that you adjust the softness of your output by using
* a lower value for the setting Sharpness or by enabling a noise reducer filter. The Softness setting
* specifies the quantization matrices that the encoder uses. Keep the default value, 0, for flat
* quantization. Choose the value 1 or 16 to use the default JVT softening quantization matricies from the
* H.264 specification. Choose a value from 17 to 128 to use planar interpolation. Increasing values from 17
* to 128 result in increasing reduction of high-frequency data. The value 128 results in the softest video.
*/
public void setSoftness(Integer softness) {
this.softness = softness;
}
/**
* Ignore this setting unless you need to comply with a specification that requires a specific value. If you don't
* have a specification requirement, we recommend that you adjust the softness of your output by using a lower value
* for the setting Sharpness or by enabling a noise reducer filter. The Softness setting specifies the quantization
* matrices that the encoder uses. Keep the default value, 0, for flat quantization. Choose the value 1 or 16 to use
* the default JVT softening quantization matricies from the H.264 specification. Choose a value from 17 to 128 to
* use planar interpolation. Increasing values from 17 to 128 result in increasing reduction of high-frequency data.
* The value 128 results in the softest video.
*
* @return Ignore this setting unless you need to comply with a specification that requires a specific value. If you
* don't have a specification requirement, we recommend that you adjust the softness of your output by using
* a lower value for the setting Sharpness or by enabling a noise reducer filter. The Softness setting
* specifies the quantization matrices that the encoder uses. Keep the default value, 0, for flat
* quantization. Choose the value 1 or 16 to use the default JVT softening quantization matricies from the
* H.264 specification. Choose a value from 17 to 128 to use planar interpolation. Increasing values from 17
* to 128 result in increasing reduction of high-frequency data. The value 128 results in the softest video.
*/
public Integer getSoftness() {
return this.softness;
}
/**
* Ignore this setting unless you need to comply with a specification that requires a specific value. If you don't
* have a specification requirement, we recommend that you adjust the softness of your output by using a lower value
* for the setting Sharpness or by enabling a noise reducer filter. The Softness setting specifies the quantization
* matrices that the encoder uses. Keep the default value, 0, for flat quantization. Choose the value 1 or 16 to use
* the default JVT softening quantization matricies from the H.264 specification. Choose a value from 17 to 128 to
* use planar interpolation. Increasing values from 17 to 128 result in increasing reduction of high-frequency data.
* The value 128 results in the softest video.
*
* @param softness
* Ignore this setting unless you need to comply with a specification that requires a specific value. If you
* don't have a specification requirement, we recommend that you adjust the softness of your output by using
* a lower value for the setting Sharpness or by enabling a noise reducer filter. The Softness setting
* specifies the quantization matrices that the encoder uses. Keep the default value, 0, for flat
* quantization. Choose the value 1 or 16 to use the default JVT softening quantization matricies from the
* H.264 specification. Choose a value from 17 to 128 to use planar interpolation. Increasing values from 17
* to 128 result in increasing reduction of high-frequency data. The value 128 results in the softest video.
* @return Returns a reference to this object so that method calls can be chained together.
*/
public H264Settings withSoftness(Integer softness) {
setSoftness(softness);
return this;
}
/**
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264SpatialAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on spatial variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas that can sustain more distortion
* with no noticeable visual degradation and uses more bits on areas where any small distortion will be noticeable.
* For example, complex textured blocks are encoded with fewer bits and smooth textured blocks are encoded with more
* bits. Enabling this feature will almost always improve your video quality. Note, though, that this feature doesn't
* take into account where the viewer's attention is likely to be. If viewers are likely to be focusing their
* attention on a part of the screen with a lot of complex texture, you might choose to set
* H264SpatialAdaptiveQuantization to Disabled. Related setting: When you enable spatial adaptive quantization, set
* the value for Adaptive quantization depending on your content. For homogeneous content, such as cartoons and video
* games, set it to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable
* or disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @param spatialAdaptiveQuantization
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264SpatialAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on spatial variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas that can sustain more distortion with no noticeable visual degradation and uses more
* bits on areas where any small distortion will be noticeable. For example, complex textured blocks are
* encoded with fewer bits and smooth textured blocks are encoded with more bits. Enabling this feature will
* almost always improve your video quality. Note, though, that this feature doesn't take into account where
* the viewer's attention is likely to be. If viewers are likely to be focusing their attention on a part of
* the screen with a lot of complex texture, you might choose to set H264SpatialAdaptiveQuantization to
* Disabled. Related setting: When you enable spatial adaptive quantization, set the value for Adaptive
* quantization depending on your content. For homogeneous content, such as cartoons and video games, set it
* to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable or
* disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @see H264SpatialAdaptiveQuantization
*/
public void setSpatialAdaptiveQuantization(String spatialAdaptiveQuantization) {
this.spatialAdaptiveQuantization = spatialAdaptiveQuantization;
}
/**
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264SpatialAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on spatial variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas that can sustain more distortion
* with no noticeable visual degradation and uses more bits on areas where any small distortion will be noticeable.
* For example, complex textured blocks are encoded with fewer bits and smooth textured blocks are encoded with more
* bits. Enabling this feature will almost always improve your video quality. Note, though, that this feature doesn't
* take into account where the viewer's attention is likely to be. If viewers are likely to be focusing their
* attention on a part of the screen with a lot of complex texture, you might choose to set
* H264SpatialAdaptiveQuantization to Disabled. Related setting: When you enable spatial adaptive quantization, set
* the value for Adaptive quantization depending on your content. For homogeneous content, such as cartoons and video
* games, set it to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable
* or disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @return Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264SpatialAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on spatial variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas that can sustain more distortion with no noticeable visual degradation and uses more
* bits on areas where any small distortion will be noticeable. For example, complex textured blocks are
* encoded with fewer bits and smooth textured blocks are encoded with more bits. Enabling this feature will
* almost always improve your video quality. Note, though, that this feature doesn't take into account where
* the viewer's attention is likely to be. If viewers are likely to be focusing their attention on a part of
* the screen with a lot of complex texture, you might choose to set H264SpatialAdaptiveQuantization to
* Disabled. Related setting: When you enable spatial adaptive quantization, set the value for Adaptive
* quantization depending on your content. For homogeneous content, such as cartoons and video games, set it
* to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable or
* disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @see H264SpatialAdaptiveQuantization
*/
public String getSpatialAdaptiveQuantization() {
return this.spatialAdaptiveQuantization;
}
/**
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264SpatialAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on spatial variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas that can sustain more distortion
* with no noticeable visual degradation and uses more bits on areas where any small distortion will be noticeable.
* For example, complex textured blocks are encoded with fewer bits and smooth textured blocks are encoded with more
* bits. Enabling this feature will almost always improve your video quality. Note, though, that this feature doesn't
* take into account where the viewer's attention is likely to be. If viewers are likely to be focusing their
* attention on a part of the screen with a lot of complex texture, you might choose to set
* H264SpatialAdaptiveQuantization to Disabled. Related setting: When you enable spatial adaptive quantization, set
* the value for Adaptive quantization depending on your content. For homogeneous content, such as cartoons and video
* games, set it to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable
* or disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @param spatialAdaptiveQuantization
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264SpatialAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on spatial variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas that can sustain more distortion with no noticeable visual degradation and uses more
* bits on areas where any small distortion will be noticeable. For example, complex textured blocks are
* encoded with fewer bits and smooth textured blocks are encoded with more bits. Enabling this feature will
* almost always improve your video quality. Note, though, that this feature doesn't take into account where
* the viewer's attention is likely to be. If viewers are likely to be focusing their attention on a part of
* the screen with a lot of complex texture, you might choose to set H264SpatialAdaptiveQuantization to
* Disabled. Related setting: When you enable spatial adaptive quantization, set the value for Adaptive
* quantization depending on your content. For homogeneous content, such as cartoons and video games, set it
* to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable or
* disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264SpatialAdaptiveQuantization
*/
public H264Settings withSpatialAdaptiveQuantization(String spatialAdaptiveQuantization) {
setSpatialAdaptiveQuantization(spatialAdaptiveQuantization);
return this;
}
/**
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264SpatialAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on spatial variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas that can sustain more distortion
* with no noticeable visual degradation and uses more bits on areas where any small distortion will be noticeable.
* For example, complex textured blocks are encoded with fewer bits and smooth textured blocks are encoded with more
* bits. Enabling this feature will almost always improve your video quality. Note, though, that this feature doesn't
* take into account where the viewer's attention is likely to be. If viewers are likely to be focusing their
* attention on a part of the screen with a lot of complex texture, you might choose to set
* H264SpatialAdaptiveQuantization to Disabled. Related setting: When you enable spatial adaptive quantization, set
* the value for Adaptive quantization depending on your content. For homogeneous content, such as cartoons and video
* games, set it to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable
* or disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @param spatialAdaptiveQuantization
* Only use this setting when you change the default value, Auto, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264SpatialAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on spatial variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas that can sustain more distortion with no noticeable visual degradation and uses more
* bits on areas where any small distortion will be noticeable. For example, complex textured blocks are
* encoded with fewer bits and smooth textured blocks are encoded with more bits. Enabling this feature will
* almost always improve your video quality. Note, though, that this feature doesn't take into account where
* the viewer's attention is likely to be. If viewers are likely to be focusing their attention on a part of
* the screen with a lot of complex texture, you might choose to set H264SpatialAdaptiveQuantization to
* Disabled. Related setting: When you enable spatial adaptive quantization, set the value for Adaptive
* quantization depending on your content. For homogeneous content, such as cartoons and video games, set it
* to Low. For content with a wider variety of textures, set it to High or Higher. To manually enable or
* disable H264SpatialAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264SpatialAdaptiveQuantization
*/
public H264Settings withSpatialAdaptiveQuantization(H264SpatialAdaptiveQuantization spatialAdaptiveQuantization) {
this.spatialAdaptiveQuantization = spatialAdaptiveQuantization.toString();
return this;
}
/**
* Produces a bitstream compliant with SMPTE RP-2027.
*
* @param syntax
* Produces a bitstream compliant with SMPTE RP-2027.
* @see H264Syntax
*/
public void setSyntax(String syntax) {
this.syntax = syntax;
}
/**
* Produces a bitstream compliant with SMPTE RP-2027.
*
* @return Produces a bitstream compliant with SMPTE RP-2027.
* @see H264Syntax
*/
public String getSyntax() {
return this.syntax;
}
/**
* Produces a bitstream compliant with SMPTE RP-2027.
*
* @param syntax
* Produces a bitstream compliant with SMPTE RP-2027.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264Syntax
*/
public H264Settings withSyntax(String syntax) {
setSyntax(syntax);
return this;
}
/**
* Produces a bitstream compliant with SMPTE RP-2027.
*
* @param syntax
* Produces a bitstream compliant with SMPTE RP-2027.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264Syntax
*/
public H264Settings withSyntax(H264Syntax syntax) {
this.syntax = syntax.toString();
return this;
}
/**
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan type is
* interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard telecine produces
* a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to the video player device to
* do the conversion during play back. When you keep the default value, None, MediaConvert does a standard frame rate
* conversion to 29.97 without doing anything with the field polarity to create a smoother picture.
*
* @param telecine
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan
* type is interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard
* telecine produces a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to
* the video player device to do the conversion during play back. When you keep the default value, None,
* MediaConvert does a standard frame rate conversion to 29.97 without doing anything with the field polarity
* to create a smoother picture.
* @see H264Telecine
*/
public void setTelecine(String telecine) {
this.telecine = telecine;
}
/**
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan type is
* interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard telecine produces
* a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to the video player device to
* do the conversion during play back. When you keep the default value, None, MediaConvert does a standard frame rate
* conversion to 29.97 without doing anything with the field polarity to create a smoother picture.
*
* @return When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan
* type is interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard
* telecine produces a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to
* the video player device to do the conversion during play back. When you keep the default value, None,
* MediaConvert does a standard frame rate conversion to 29.97 without doing anything with the field
* polarity to create a smoother picture.
* @see H264Telecine
*/
public String getTelecine() {
return this.telecine;
}
/**
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan type is
* interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard telecine produces
* a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to the video player device to
* do the conversion during play back. When you keep the default value, None, MediaConvert does a standard frame rate
* conversion to 29.97 without doing anything with the field polarity to create a smoother picture.
*
* @param telecine
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan
* type is interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard
* telecine produces a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to
* the video player device to do the conversion during play back. When you keep the default value, None,
* MediaConvert does a standard frame rate conversion to 29.97 without doing anything with the field polarity
* to create a smoother picture.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264Telecine
*/
public H264Settings withTelecine(String telecine) {
setTelecine(telecine);
return this;
}
/**
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan type is
* interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard telecine produces
* a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to the video player device to
* do the conversion during play back. When you keep the default value, None, MediaConvert does a standard frame rate
* conversion to 29.97 without doing anything with the field polarity to create a smoother picture.
*
* @param telecine
* When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 fps, and your output scan
* type is interlaced, you can optionally enable hard or soft telecine to create a smoother picture. Hard
* telecine produces a 29.97i output. Soft telecine produces an output with a 23.976 output that signals to
* the video player device to do the conversion during play back. When you keep the default value, None,
* MediaConvert does a standard frame rate conversion to 29.97 without doing anything with the field polarity
* to create a smoother picture.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264Telecine
*/
public H264Settings withTelecine(H264Telecine telecine) {
this.telecine = telecine.toString();
return this;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264TemporalAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on temporal variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas of the frame that aren't moving and
* uses more bits on complex objects with sharp edges that move a lot. For example, this feature improves the
* readability of text tickers on newscasts and scoreboards on sports matches. Enabling this feature will almost
* always improve your video quality. Note, though, that this feature doesn't take into account where the viewer's
* attention is likely to be. If viewers are likely to be focusing their attention on a part of the screen that
* doesn't have moving objects with sharp edges, such as sports athletes' faces, you might choose to set
* H264TemporalAdaptiveQuantization to Disabled. Related setting: When you enable temporal quantization, adjust the
* strength of the filter with the setting Adaptive quantization. To manually enable or disable
* H264TemporalAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @param temporalAdaptiveQuantization
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264TemporalAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on temporal variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas of the frame that aren't moving and uses more bits on complex objects with sharp edges
* that move a lot. For example, this feature improves the readability of text tickers on newscasts and
* scoreboards on sports matches. Enabling this feature will almost always improve your video quality. Note,
* though, that this feature doesn't take into account where the viewer's attention is likely to be. If
* viewers are likely to be focusing their attention on a part of the screen that doesn't have moving objects
* with sharp edges, such as sports athletes' faces, you might choose to set H264TemporalAdaptiveQuantization
* to Disabled. Related setting: When you enable temporal quantization, adjust the strength of the filter
* with the setting Adaptive quantization. To manually enable or disable H264TemporalAdaptiveQuantization,
* you must set Adaptive quantization to a value other than AUTO.
* @see H264TemporalAdaptiveQuantization
*/
public void setTemporalAdaptiveQuantization(String temporalAdaptiveQuantization) {
this.temporalAdaptiveQuantization = temporalAdaptiveQuantization;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264TemporalAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on temporal variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas of the frame that aren't moving and
* uses more bits on complex objects with sharp edges that move a lot. For example, this feature improves the
* readability of text tickers on newscasts and scoreboards on sports matches. Enabling this feature will almost
* always improve your video quality. Note, though, that this feature doesn't take into account where the viewer's
* attention is likely to be. If viewers are likely to be focusing their attention on a part of the screen that
* doesn't have moving objects with sharp edges, such as sports athletes' faces, you might choose to set
* H264TemporalAdaptiveQuantization to Disabled. Related setting: When you enable temporal quantization, adjust the
* strength of the filter with the setting Adaptive quantization. To manually enable or disable
* H264TemporalAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @return Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264TemporalAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on temporal variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas of the frame that aren't moving and uses more bits on complex objects with sharp
* edges that move a lot. For example, this feature improves the readability of text tickers on newscasts
* and scoreboards on sports matches. Enabling this feature will almost always improve your video quality.
* Note, though, that this feature doesn't take into account where the viewer's attention is likely to be.
* If viewers are likely to be focusing their attention on a part of the screen that doesn't have moving
* objects with sharp edges, such as sports athletes' faces, you might choose to set
* H264TemporalAdaptiveQuantization to Disabled. Related setting: When you enable temporal quantization,
* adjust the strength of the filter with the setting Adaptive quantization. To manually enable or disable
* H264TemporalAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
* @see H264TemporalAdaptiveQuantization
*/
public String getTemporalAdaptiveQuantization() {
return this.temporalAdaptiveQuantization;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264TemporalAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on temporal variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas of the frame that aren't moving and
* uses more bits on complex objects with sharp edges that move a lot. For example, this feature improves the
* readability of text tickers on newscasts and scoreboards on sports matches. Enabling this feature will almost
* always improve your video quality. Note, though, that this feature doesn't take into account where the viewer's
* attention is likely to be. If viewers are likely to be focusing their attention on a part of the screen that
* doesn't have moving objects with sharp edges, such as sports athletes' faces, you might choose to set
* H264TemporalAdaptiveQuantization to Disabled. Related setting: When you enable temporal quantization, adjust the
* strength of the filter with the setting Adaptive quantization. To manually enable or disable
* H264TemporalAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @param temporalAdaptiveQuantization
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264TemporalAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on temporal variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas of the frame that aren't moving and uses more bits on complex objects with sharp edges
* that move a lot. For example, this feature improves the readability of text tickers on newscasts and
* scoreboards on sports matches. Enabling this feature will almost always improve your video quality. Note,
* though, that this feature doesn't take into account where the viewer's attention is likely to be. If
* viewers are likely to be focusing their attention on a part of the screen that doesn't have moving objects
* with sharp edges, such as sports athletes' faces, you might choose to set H264TemporalAdaptiveQuantization
* to Disabled. Related setting: When you enable temporal quantization, adjust the strength of the filter
* with the setting Adaptive quantization. To manually enable or disable H264TemporalAdaptiveQuantization,
* you must set Adaptive quantization to a value other than AUTO.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264TemporalAdaptiveQuantization
*/
public H264Settings withTemporalAdaptiveQuantization(String temporalAdaptiveQuantization) {
setTemporalAdaptiveQuantization(temporalAdaptiveQuantization);
return this;
}
/**
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization. When you
* keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from your JSON job
* specification, MediaConvert automatically applies the best types of quantization for your video content. When you
* set H264AdaptiveQuantization to a value other than AUTO, the default value for H264TemporalAdaptiveQuantization is
* Enabled. Keep this default value to adjust quantization within each frame based on temporal variation of content
* complexity. When you enable this feature, the encoder uses fewer bits on areas of the frame that aren't moving and
* uses more bits on complex objects with sharp edges that move a lot. For example, this feature improves the
* readability of text tickers on newscasts and scoreboards on sports matches. Enabling this feature will almost
* always improve your video quality. Note, though, that this feature doesn't take into account where the viewer's
* attention is likely to be. If viewers are likely to be focusing their attention on a part of the screen that
* doesn't have moving objects with sharp edges, such as sports athletes' faces, you might choose to set
* H264TemporalAdaptiveQuantization to Disabled. Related setting: When you enable temporal quantization, adjust the
* strength of the filter with the setting Adaptive quantization. To manually enable or disable
* H264TemporalAdaptiveQuantization, you must set Adaptive quantization to a value other than AUTO.
*
* @param temporalAdaptiveQuantization
* Only use this setting when you change the default value, AUTO, for the setting H264AdaptiveQuantization.
* When you keep all defaults, excluding H264AdaptiveQuantization and all other adaptive quantization from
* your JSON job specification, MediaConvert automatically applies the best types of quantization for your
* video content. When you set H264AdaptiveQuantization to a value other than AUTO, the default value for
* H264TemporalAdaptiveQuantization is Enabled. Keep this default value to adjust quantization within each
* frame based on temporal variation of content complexity. When you enable this feature, the encoder uses
* fewer bits on areas of the frame that aren't moving and uses more bits on complex objects with sharp edges
* that move a lot. For example, this feature improves the readability of text tickers on newscasts and
* scoreboards on sports matches. Enabling this feature will almost always improve your video quality. Note,
* though, that this feature doesn't take into account where the viewer's attention is likely to be. If
* viewers are likely to be focusing their attention on a part of the screen that doesn't have moving objects
* with sharp edges, such as sports athletes' faces, you might choose to set H264TemporalAdaptiveQuantization
* to Disabled. Related setting: When you enable temporal quantization, adjust the strength of the filter
* with the setting Adaptive quantization. To manually enable or disable H264TemporalAdaptiveQuantization,
* you must set Adaptive quantization to a value other than AUTO.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264TemporalAdaptiveQuantization
*/
public H264Settings withTemporalAdaptiveQuantization(H264TemporalAdaptiveQuantization temporalAdaptiveQuantization) {
this.temporalAdaptiveQuantization = temporalAdaptiveQuantization.toString();
return this;
}
/**
* Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
*
* @param unregisteredSeiTimecode
* Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
* @see H264UnregisteredSeiTimecode
*/
public void setUnregisteredSeiTimecode(String unregisteredSeiTimecode) {
this.unregisteredSeiTimecode = unregisteredSeiTimecode;
}
/**
* Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
*
* @return Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
* @see H264UnregisteredSeiTimecode
*/
public String getUnregisteredSeiTimecode() {
return this.unregisteredSeiTimecode;
}
/**
* Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
*
* @param unregisteredSeiTimecode
* Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264UnregisteredSeiTimecode
*/
public H264Settings withUnregisteredSeiTimecode(String unregisteredSeiTimecode) {
setUnregisteredSeiTimecode(unregisteredSeiTimecode);
return this;
}
/**
* Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
*
* @param unregisteredSeiTimecode
* Inserts timecode for each frame as 4 bytes of an unregistered SEI message.
* @return Returns a reference to this object so that method calls can be chained together.
* @see H264UnregisteredSeiTimecode
*/
public H264Settings withUnregisteredSeiTimecode(H264UnregisteredSeiTimecode unregisteredSeiTimecode) {
this.unregisteredSeiTimecode = unregisteredSeiTimecode.toString();
return this;
}
/**
* Returns a string representation of this object. This is useful for testing and debugging. Sensitive data will be
* redacted from this string using a placeholder value.
*
* @return A string representation of this object.
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("{");
if (getAdaptiveQuantization() != null)
sb.append("AdaptiveQuantization: ").append(getAdaptiveQuantization()).append(",");
if (getBandwidthReductionFilter() != null)
sb.append("BandwidthReductionFilter: ").append(getBandwidthReductionFilter()).append(",");
if (getBitrate() != null)
sb.append("Bitrate: ").append(getBitrate()).append(",");
if (getCodecLevel() != null)
sb.append("CodecLevel: ").append(getCodecLevel()).append(",");
if (getCodecProfile() != null)
sb.append("CodecProfile: ").append(getCodecProfile()).append(",");
if (getDynamicSubGop() != null)
sb.append("DynamicSubGop: ").append(getDynamicSubGop()).append(",");
if (getEndOfStreamMarkers() != null)
sb.append("EndOfStreamMarkers: ").append(getEndOfStreamMarkers()).append(",");
if (getEntropyEncoding() != null)
sb.append("EntropyEncoding: ").append(getEntropyEncoding()).append(",");
if (getFieldEncoding() != null)
sb.append("FieldEncoding: ").append(getFieldEncoding()).append(",");
if (getFlickerAdaptiveQuantization() != null)
sb.append("FlickerAdaptiveQuantization: ").append(getFlickerAdaptiveQuantization()).append(",");
if (getFramerateControl() != null)
sb.append("FramerateControl: ").append(getFramerateControl()).append(",");
if (getFramerateConversionAlgorithm() != null)
sb.append("FramerateConversionAlgorithm: ").append(getFramerateConversionAlgorithm()).append(",");
if (getFramerateDenominator() != null)
sb.append("FramerateDenominator: ").append(getFramerateDenominator()).append(",");
if (getFramerateNumerator() != null)
sb.append("FramerateNumerator: ").append(getFramerateNumerator()).append(",");
if (getGopBReference() != null)
sb.append("GopBReference: ").append(getGopBReference()).append(",");
if (getGopClosedCadence() != null)
sb.append("GopClosedCadence: ").append(getGopClosedCadence()).append(",");
if (getGopSize() != null)
sb.append("GopSize: ").append(getGopSize()).append(",");
if (getGopSizeUnits() != null)
sb.append("GopSizeUnits: ").append(getGopSizeUnits()).append(",");
if (getHrdBufferFinalFillPercentage() != null)
sb.append("HrdBufferFinalFillPercentage: ").append(getHrdBufferFinalFillPercentage()).append(",");
if (getHrdBufferInitialFillPercentage() != null)
sb.append("HrdBufferInitialFillPercentage: ").append(getHrdBufferInitialFillPercentage()).append(",");
if (getHrdBufferSize() != null)
sb.append("HrdBufferSize: ").append(getHrdBufferSize()).append(",");
if (getInterlaceMode() != null)
sb.append("InterlaceMode: ").append(getInterlaceMode()).append(",");
if (getMaxBitrate() != null)
sb.append("MaxBitrate: ").append(getMaxBitrate()).append(",");
if (getMinIInterval() != null)
sb.append("MinIInterval: ").append(getMinIInterval()).append(",");
if (getNumberBFramesBetweenReferenceFrames() != null)
sb.append("NumberBFramesBetweenReferenceFrames: ").append(getNumberBFramesBetweenReferenceFrames()).append(",");
if (getNumberReferenceFrames() != null)
sb.append("NumberReferenceFrames: ").append(getNumberReferenceFrames()).append(",");
if (getParControl() != null)
sb.append("ParControl: ").append(getParControl()).append(",");
if (getParDenominator() != null)
sb.append("ParDenominator: ").append(getParDenominator()).append(",");
if (getParNumerator() != null)
sb.append("ParNumerator: ").append(getParNumerator()).append(",");
if (getQualityTuningLevel() != null)
sb.append("QualityTuningLevel: ").append(getQualityTuningLevel()).append(",");
if (getQvbrSettings() != null)
sb.append("QvbrSettings: ").append(getQvbrSettings()).append(",");
if (getRateControlMode() != null)
sb.append("RateControlMode: ").append(getRateControlMode()).append(",");
if (getRepeatPps() != null)
sb.append("RepeatPps: ").append(getRepeatPps()).append(",");
if (getScanTypeConversionMode() != null)
sb.append("ScanTypeConversionMode: ").append(getScanTypeConversionMode()).append(",");
if (getSceneChangeDetect() != null)
sb.append("SceneChangeDetect: ").append(getSceneChangeDetect()).append(",");
if (getSlices() != null)
sb.append("Slices: ").append(getSlices()).append(",");
if (getSlowPal() != null)
sb.append("SlowPal: ").append(getSlowPal()).append(",");
if (getSoftness() != null)
sb.append("Softness: ").append(getSoftness()).append(",");
if (getSpatialAdaptiveQuantization() != null)
sb.append("SpatialAdaptiveQuantization: ").append(getSpatialAdaptiveQuantization()).append(",");
if (getSyntax() != null)
sb.append("Syntax: ").append(getSyntax()).append(",");
if (getTelecine() != null)
sb.append("Telecine: ").append(getTelecine()).append(",");
if (getTemporalAdaptiveQuantization() != null)
sb.append("TemporalAdaptiveQuantization: ").append(getTemporalAdaptiveQuantization()).append(",");
if (getUnregisteredSeiTimecode() != null)
sb.append("UnregisteredSeiTimecode: ").append(getUnregisteredSeiTimecode());
sb.append("}");
return sb.toString();
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (obj instanceof H264Settings == false)
return false;
H264Settings other = (H264Settings) obj;
if (other.getAdaptiveQuantization() == null ^ this.getAdaptiveQuantization() == null)
return false;
if (other.getAdaptiveQuantization() != null && other.getAdaptiveQuantization().equals(this.getAdaptiveQuantization()) == false)
return false;
if (other.getBandwidthReductionFilter() == null ^ this.getBandwidthReductionFilter() == null)
return false;
if (other.getBandwidthReductionFilter() != null && other.getBandwidthReductionFilter().equals(this.getBandwidthReductionFilter()) == false)
return false;
if (other.getBitrate() == null ^ this.getBitrate() == null)
return false;
if (other.getBitrate() != null && other.getBitrate().equals(this.getBitrate()) == false)
return false;
if (other.getCodecLevel() == null ^ this.getCodecLevel() == null)
return false;
if (other.getCodecLevel() != null && other.getCodecLevel().equals(this.getCodecLevel()) == false)
return false;
if (other.getCodecProfile() == null ^ this.getCodecProfile() == null)
return false;
if (other.getCodecProfile() != null && other.getCodecProfile().equals(this.getCodecProfile()) == false)
return false;
if (other.getDynamicSubGop() == null ^ this.getDynamicSubGop() == null)
return false;
if (other.getDynamicSubGop() != null && other.getDynamicSubGop().equals(this.getDynamicSubGop()) == false)
return false;
if (other.getEndOfStreamMarkers() == null ^ this.getEndOfStreamMarkers() == null)
return false;
if (other.getEndOfStreamMarkers() != null && other.getEndOfStreamMarkers().equals(this.getEndOfStreamMarkers()) == false)
return false;
if (other.getEntropyEncoding() == null ^ this.getEntropyEncoding() == null)
return false;
if (other.getEntropyEncoding() != null && other.getEntropyEncoding().equals(this.getEntropyEncoding()) == false)
return false;
if (other.getFieldEncoding() == null ^ this.getFieldEncoding() == null)
return false;
if (other.getFieldEncoding() != null && other.getFieldEncoding().equals(this.getFieldEncoding()) == false)
return false;
if (other.getFlickerAdaptiveQuantization() == null ^ this.getFlickerAdaptiveQuantization() == null)
return false;
if (other.getFlickerAdaptiveQuantization() != null && other.getFlickerAdaptiveQuantization().equals(this.getFlickerAdaptiveQuantization()) == false)
return false;
if (other.getFramerateControl() == null ^ this.getFramerateControl() == null)
return false;
if (other.getFramerateControl() != null && other.getFramerateControl().equals(this.getFramerateControl()) == false)
return false;
if (other.getFramerateConversionAlgorithm() == null ^ this.getFramerateConversionAlgorithm() == null)
return false;
if (other.getFramerateConversionAlgorithm() != null && other.getFramerateConversionAlgorithm().equals(this.getFramerateConversionAlgorithm()) == false)
return false;
if (other.getFramerateDenominator() == null ^ this.getFramerateDenominator() == null)
return false;
if (other.getFramerateDenominator() != null && other.getFramerateDenominator().equals(this.getFramerateDenominator()) == false)
return false;
if (other.getFramerateNumerator() == null ^ this.getFramerateNumerator() == null)
return false;
if (other.getFramerateNumerator() != null && other.getFramerateNumerator().equals(this.getFramerateNumerator()) == false)
return false;
if (other.getGopBReference() == null ^ this.getGopBReference() == null)
return false;
if (other.getGopBReference() != null && other.getGopBReference().equals(this.getGopBReference()) == false)
return false;
if (other.getGopClosedCadence() == null ^ this.getGopClosedCadence() == null)
return false;
if (other.getGopClosedCadence() != null && other.getGopClosedCadence().equals(this.getGopClosedCadence()) == false)
return false;
if (other.getGopSize() == null ^ this.getGopSize() == null)
return false;
if (other.getGopSize() != null && other.getGopSize().equals(this.getGopSize()) == false)
return false;
if (other.getGopSizeUnits() == null ^ this.getGopSizeUnits() == null)
return false;
if (other.getGopSizeUnits() != null && other.getGopSizeUnits().equals(this.getGopSizeUnits()) == false)
return false;
if (other.getHrdBufferFinalFillPercentage() == null ^ this.getHrdBufferFinalFillPercentage() == null)
return false;
if (other.getHrdBufferFinalFillPercentage() != null && other.getHrdBufferFinalFillPercentage().equals(this.getHrdBufferFinalFillPercentage()) == false)
return false;
if (other.getHrdBufferInitialFillPercentage() == null ^ this.getHrdBufferInitialFillPercentage() == null)
return false;
if (other.getHrdBufferInitialFillPercentage() != null
&& other.getHrdBufferInitialFillPercentage().equals(this.getHrdBufferInitialFillPercentage()) == false)
return false;
if (other.getHrdBufferSize() == null ^ this.getHrdBufferSize() == null)
return false;
if (other.getHrdBufferSize() != null && other.getHrdBufferSize().equals(this.getHrdBufferSize()) == false)
return false;
if (other.getInterlaceMode() == null ^ this.getInterlaceMode() == null)
return false;
if (other.getInterlaceMode() != null && other.getInterlaceMode().equals(this.getInterlaceMode()) == false)
return false;
if (other.getMaxBitrate() == null ^ this.getMaxBitrate() == null)
return false;
if (other.getMaxBitrate() != null && other.getMaxBitrate().equals(this.getMaxBitrate()) == false)
return false;
if (other.getMinIInterval() == null ^ this.getMinIInterval() == null)
return false;
if (other.getMinIInterval() != null && other.getMinIInterval().equals(this.getMinIInterval()) == false)
return false;
if (other.getNumberBFramesBetweenReferenceFrames() == null ^ this.getNumberBFramesBetweenReferenceFrames() == null)
return false;
if (other.getNumberBFramesBetweenReferenceFrames() != null
&& other.getNumberBFramesBetweenReferenceFrames().equals(this.getNumberBFramesBetweenReferenceFrames()) == false)
return false;
if (other.getNumberReferenceFrames() == null ^ this.getNumberReferenceFrames() == null)
return false;
if (other.getNumberReferenceFrames() != null && other.getNumberReferenceFrames().equals(this.getNumberReferenceFrames()) == false)
return false;
if (other.getParControl() == null ^ this.getParControl() == null)
return false;
if (other.getParControl() != null && other.getParControl().equals(this.getParControl()) == false)
return false;
if (other.getParDenominator() == null ^ this.getParDenominator() == null)
return false;
if (other.getParDenominator() != null && other.getParDenominator().equals(this.getParDenominator()) == false)
return false;
if (other.getParNumerator() == null ^ this.getParNumerator() == null)
return false;
if (other.getParNumerator() != null && other.getParNumerator().equals(this.getParNumerator()) == false)
return false;
if (other.getQualityTuningLevel() == null ^ this.getQualityTuningLevel() == null)
return false;
if (other.getQualityTuningLevel() != null && other.getQualityTuningLevel().equals(this.getQualityTuningLevel()) == false)
return false;
if (other.getQvbrSettings() == null ^ this.getQvbrSettings() == null)
return false;
if (other.getQvbrSettings() != null && other.getQvbrSettings().equals(this.getQvbrSettings()) == false)
return false;
if (other.getRateControlMode() == null ^ this.getRateControlMode() == null)
return false;
if (other.getRateControlMode() != null && other.getRateControlMode().equals(this.getRateControlMode()) == false)
return false;
if (other.getRepeatPps() == null ^ this.getRepeatPps() == null)
return false;
if (other.getRepeatPps() != null && other.getRepeatPps().equals(this.getRepeatPps()) == false)
return false;
if (other.getScanTypeConversionMode() == null ^ this.getScanTypeConversionMode() == null)
return false;
if (other.getScanTypeConversionMode() != null && other.getScanTypeConversionMode().equals(this.getScanTypeConversionMode()) == false)
return false;
if (other.getSceneChangeDetect() == null ^ this.getSceneChangeDetect() == null)
return false;
if (other.getSceneChangeDetect() != null && other.getSceneChangeDetect().equals(this.getSceneChangeDetect()) == false)
return false;
if (other.getSlices() == null ^ this.getSlices() == null)
return false;
if (other.getSlices() != null && other.getSlices().equals(this.getSlices()) == false)
return false;
if (other.getSlowPal() == null ^ this.getSlowPal() == null)
return false;
if (other.getSlowPal() != null && other.getSlowPal().equals(this.getSlowPal()) == false)
return false;
if (other.getSoftness() == null ^ this.getSoftness() == null)
return false;
if (other.getSoftness() != null && other.getSoftness().equals(this.getSoftness()) == false)
return false;
if (other.getSpatialAdaptiveQuantization() == null ^ this.getSpatialAdaptiveQuantization() == null)
return false;
if (other.getSpatialAdaptiveQuantization() != null && other.getSpatialAdaptiveQuantization().equals(this.getSpatialAdaptiveQuantization()) == false)
return false;
if (other.getSyntax() == null ^ this.getSyntax() == null)
return false;
if (other.getSyntax() != null && other.getSyntax().equals(this.getSyntax()) == false)
return false;
if (other.getTelecine() == null ^ this.getTelecine() == null)
return false;
if (other.getTelecine() != null && other.getTelecine().equals(this.getTelecine()) == false)
return false;
if (other.getTemporalAdaptiveQuantization() == null ^ this.getTemporalAdaptiveQuantization() == null)
return false;
if (other.getTemporalAdaptiveQuantization() != null && other.getTemporalAdaptiveQuantization().equals(this.getTemporalAdaptiveQuantization()) == false)
return false;
if (other.getUnregisteredSeiTimecode() == null ^ this.getUnregisteredSeiTimecode() == null)
return false;
if (other.getUnregisteredSeiTimecode() != null && other.getUnregisteredSeiTimecode().equals(this.getUnregisteredSeiTimecode()) == false)
return false;
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int hashCode = 1;
hashCode = prime * hashCode + ((getAdaptiveQuantization() == null) ? 0 : getAdaptiveQuantization().hashCode());
hashCode = prime * hashCode + ((getBandwidthReductionFilter() == null) ? 0 : getBandwidthReductionFilter().hashCode());
hashCode = prime * hashCode + ((getBitrate() == null) ? 0 : getBitrate().hashCode());
hashCode = prime * hashCode + ((getCodecLevel() == null) ? 0 : getCodecLevel().hashCode());
hashCode = prime * hashCode + ((getCodecProfile() == null) ? 0 : getCodecProfile().hashCode());
hashCode = prime * hashCode + ((getDynamicSubGop() == null) ? 0 : getDynamicSubGop().hashCode());
hashCode = prime * hashCode + ((getEndOfStreamMarkers() == null) ? 0 : getEndOfStreamMarkers().hashCode());
hashCode = prime * hashCode + ((getEntropyEncoding() == null) ? 0 : getEntropyEncoding().hashCode());
hashCode = prime * hashCode + ((getFieldEncoding() == null) ? 0 : getFieldEncoding().hashCode());
hashCode = prime * hashCode + ((getFlickerAdaptiveQuantization() == null) ? 0 : getFlickerAdaptiveQuantization().hashCode());
hashCode = prime * hashCode + ((getFramerateControl() == null) ? 0 : getFramerateControl().hashCode());
hashCode = prime * hashCode + ((getFramerateConversionAlgorithm() == null) ? 0 : getFramerateConversionAlgorithm().hashCode());
hashCode = prime * hashCode + ((getFramerateDenominator() == null) ? 0 : getFramerateDenominator().hashCode());
hashCode = prime * hashCode + ((getFramerateNumerator() == null) ? 0 : getFramerateNumerator().hashCode());
hashCode = prime * hashCode + ((getGopBReference() == null) ? 0 : getGopBReference().hashCode());
hashCode = prime * hashCode + ((getGopClosedCadence() == null) ? 0 : getGopClosedCadence().hashCode());
hashCode = prime * hashCode + ((getGopSize() == null) ? 0 : getGopSize().hashCode());
hashCode = prime * hashCode + ((getGopSizeUnits() == null) ? 0 : getGopSizeUnits().hashCode());
hashCode = prime * hashCode + ((getHrdBufferFinalFillPercentage() == null) ? 0 : getHrdBufferFinalFillPercentage().hashCode());
hashCode = prime * hashCode + ((getHrdBufferInitialFillPercentage() == null) ? 0 : getHrdBufferInitialFillPercentage().hashCode());
hashCode = prime * hashCode + ((getHrdBufferSize() == null) ? 0 : getHrdBufferSize().hashCode());
hashCode = prime * hashCode + ((getInterlaceMode() == null) ? 0 : getInterlaceMode().hashCode());
hashCode = prime * hashCode + ((getMaxBitrate() == null) ? 0 : getMaxBitrate().hashCode());
hashCode = prime * hashCode + ((getMinIInterval() == null) ? 0 : getMinIInterval().hashCode());
hashCode = prime * hashCode + ((getNumberBFramesBetweenReferenceFrames() == null) ? 0 : getNumberBFramesBetweenReferenceFrames().hashCode());
hashCode = prime * hashCode + ((getNumberReferenceFrames() == null) ? 0 : getNumberReferenceFrames().hashCode());
hashCode = prime * hashCode + ((getParControl() == null) ? 0 : getParControl().hashCode());
hashCode = prime * hashCode + ((getParDenominator() == null) ? 0 : getParDenominator().hashCode());
hashCode = prime * hashCode + ((getParNumerator() == null) ? 0 : getParNumerator().hashCode());
hashCode = prime * hashCode + ((getQualityTuningLevel() == null) ? 0 : getQualityTuningLevel().hashCode());
hashCode = prime * hashCode + ((getQvbrSettings() == null) ? 0 : getQvbrSettings().hashCode());
hashCode = prime * hashCode + ((getRateControlMode() == null) ? 0 : getRateControlMode().hashCode());
hashCode = prime * hashCode + ((getRepeatPps() == null) ? 0 : getRepeatPps().hashCode());
hashCode = prime * hashCode + ((getScanTypeConversionMode() == null) ? 0 : getScanTypeConversionMode().hashCode());
hashCode = prime * hashCode + ((getSceneChangeDetect() == null) ? 0 : getSceneChangeDetect().hashCode());
hashCode = prime * hashCode + ((getSlices() == null) ? 0 : getSlices().hashCode());
hashCode = prime * hashCode + ((getSlowPal() == null) ? 0 : getSlowPal().hashCode());
hashCode = prime * hashCode + ((getSoftness() == null) ? 0 : getSoftness().hashCode());
hashCode = prime * hashCode + ((getSpatialAdaptiveQuantization() == null) ? 0 : getSpatialAdaptiveQuantization().hashCode());
hashCode = prime * hashCode + ((getSyntax() == null) ? 0 : getSyntax().hashCode());
hashCode = prime * hashCode + ((getTelecine() == null) ? 0 : getTelecine().hashCode());
hashCode = prime * hashCode + ((getTemporalAdaptiveQuantization() == null) ? 0 : getTemporalAdaptiveQuantization().hashCode());
hashCode = prime * hashCode + ((getUnregisteredSeiTimecode() == null) ? 0 : getUnregisteredSeiTimecode().hashCode());
return hashCode;
}
@Override
public H264Settings clone() {
try {
return (H264Settings) super.clone();
} catch (CloneNotSupportedException e) {
throw new IllegalStateException("Got a CloneNotSupportedException from Object.clone() " + "even though we're Cloneable!", e);
}
}
@com.amazonaws.annotation.SdkInternalApi
@Override
public void marshall(ProtocolMarshaller protocolMarshaller) {
com.amazonaws.services.mediaconvert.model.transform.H264SettingsMarshaller.getInstance().marshall(this, protocolMarshaller);
}
}