{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.MediaConvert.Types.H264Settings
-- Copyright   : (c) 2013-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.MediaConvert.Types.H264Settings where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaConvert.Types.H264AdaptiveQuantization
import Amazonka.MediaConvert.Types.H264CodecLevel
import Amazonka.MediaConvert.Types.H264CodecProfile
import Amazonka.MediaConvert.Types.H264DynamicSubGop
import Amazonka.MediaConvert.Types.H264EntropyEncoding
import Amazonka.MediaConvert.Types.H264FieldEncoding
import Amazonka.MediaConvert.Types.H264FlickerAdaptiveQuantization
import Amazonka.MediaConvert.Types.H264FramerateControl
import Amazonka.MediaConvert.Types.H264FramerateConversionAlgorithm
import Amazonka.MediaConvert.Types.H264GopBReference
import Amazonka.MediaConvert.Types.H264GopSizeUnits
import Amazonka.MediaConvert.Types.H264InterlaceMode
import Amazonka.MediaConvert.Types.H264ParControl
import Amazonka.MediaConvert.Types.H264QualityTuningLevel
import Amazonka.MediaConvert.Types.H264QvbrSettings
import Amazonka.MediaConvert.Types.H264RateControlMode
import Amazonka.MediaConvert.Types.H264RepeatPps
import Amazonka.MediaConvert.Types.H264ScanTypeConversionMode
import Amazonka.MediaConvert.Types.H264SceneChangeDetect
import Amazonka.MediaConvert.Types.H264SlowPal
import Amazonka.MediaConvert.Types.H264SpatialAdaptiveQuantization
import Amazonka.MediaConvert.Types.H264Syntax
import Amazonka.MediaConvert.Types.H264Telecine
import Amazonka.MediaConvert.Types.H264TemporalAdaptiveQuantization
import Amazonka.MediaConvert.Types.H264UnregisteredSeiTimecode
import qualified Amazonka.Prelude as Prelude

-- | Required when you set (Codec) under (VideoDescription)>(CodecSettings)
-- to the value H_264.
--
-- /See:/ 'newH264Settings' smart constructor.
data H264Settings = H264Settings'
  { -- | Inserts timecode for each frame as 4 bytes of an unregistered SEI
    -- message.
    H264Settings -> Maybe H264UnregisteredSeiTimecode
unregisteredSeiTimecode :: Prelude.Maybe H264UnregisteredSeiTimecode,
    -- | Optional. Use Quality tuning level (qualityTuningLevel) to choose how
    -- you want to trade off encoding speed for output video quality. The
    -- default behavior is faster, lower quality, single-pass encoding.
    H264Settings -> Maybe H264QualityTuningLevel
qualityTuningLevel :: Prelude.Maybe H264QualityTuningLevel,
    -- | 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 (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 (DISABLED). Related
    -- setting: When you enable temporal quantization, adjust the strength of
    -- the filter with the setting Adaptive quantization
    -- (adaptiveQuantization). To manually enable or disable
    -- H264TemporalAdaptiveQuantization, you must set Adaptive quantization
    -- (H264AdaptiveQuantization) to a value other than AUTO.
    H264Settings -> Maybe H264TemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Prelude.Maybe H264TemporalAdaptiveQuantization,
    -- | 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
    -- (TRANSITION_DETECTION) for further video quality improvement. For more
    -- information about QVBR, see
    -- https:\/\/docs.aws.amazon.com\/console\/mediaconvert\/cbr-vbr-qvbr.
    H264Settings -> Maybe H264SceneChangeDetect
sceneChangeDetect :: Prelude.Maybe H264SceneChangeDetect,
    -- | Percentage of the buffer that should initially be filled (HRD buffer
    -- model).
    H264Settings -> Maybe Natural
hrdBufferInitialFillPercentage :: Prelude.Maybe Prelude.Natural,
    -- | 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. In your JSON job
    -- specification, set (framerateControl) to (SPECIFIED),
    -- (framerateNumerator) to 25 and (framerateDenominator) to 1.
    H264Settings -> Maybe H264SlowPal
slowPal :: Prelude.Maybe H264SlowPal,
    -- | Required when you set Pixel aspect ratio (parControl) 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.
    H264Settings -> Maybe Natural
parNumerator :: Prelude.Maybe Prelude.Natural,
    -- | GOP Length (keyframe interval) in frames or seconds. Must be greater
    -- than zero.
    H264Settings -> Maybe Double
gopSize :: Prelude.Maybe Prelude.Double,
    -- | Specify the number of B-frames that MediaConvert puts between reference
    -- frames in this output. Valid values are whole numbers from 0 through 7.
    -- When you don\'t specify a value, MediaConvert defaults to 2.
    H264Settings -> Maybe Natural
numberBFramesBetweenReferenceFrames :: Prelude.Maybe Prelude.Natural,
    -- | Indicates if the GOP Size in H264 is specified in frames or seconds. If
    -- seconds the system will convert the GOP Size into a frame count at run
    -- time.
    H264Settings -> Maybe H264GopSizeUnits
gopSizeUnits :: Prelude.Maybe H264GopSizeUnits,
    -- | Size of buffer (HRD buffer model) in bits. For example, enter five
    -- megabits as 5000000.
    H264Settings -> Maybe Natural
hrdBufferSize :: Prelude.Maybe Prelude.Natural,
    -- | 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.
    H264Settings -> Maybe Natural
slices :: Prelude.Maybe Prelude.Natural,
    -- | Use this setting to specify whether this output has a variable bitrate
    -- (VBR), constant bitrate (CBR) or quality-defined variable bitrate
    -- (QVBR).
    H264Settings -> Maybe H264RateControlMode
rateControlMode :: Prelude.Maybe H264RateControlMode,
    -- | Number of reference frames to use. The encoder may use more than
    -- requested if using B-frames and\/or interlaced encoding.
    H264Settings -> Maybe Natural
numberReferenceFrames :: Prelude.Maybe Prelude.Natural,
    -- | 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
    -- (HARD) produces a 29.97i output. Soft telecine (SOFT) 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
    -- (NONE), MediaConvert does a standard frame rate conversion to 29.97
    -- without doing anything with the field polarity to create a smoother
    -- picture.
    H264Settings -> Maybe H264Telecine
telecine :: Prelude.Maybe H264Telecine,
    -- | Choose Adaptive to improve subjective video quality for high-motion
    -- content. This will cause the service to use fewer B-frames (which infer
    -- information based on other frames) for high-motion portions of the video
    -- and more B-frames for low-motion portions. The maximum number of
    -- B-frames is limited by the value you provide for the setting B frames
    -- between reference frames (numberBFramesBetweenReferenceFrames).
    H264Settings -> Maybe H264DynamicSubGop
dynamicSubGop :: Prelude.Maybe H264DynamicSubGop,
    -- | Enforces separation between repeated (cadence) I-frames and I-frames
    -- inserted by Scene Change Detection. If a scene change I-frame is within
    -- I-interval frames of a cadence I-frame, the GOP is shrunk and\/or
    -- stretched to the scene change I-frame. GOP stretch requires enabling
    -- lookahead as well as setting I-interval. The normal cadence resumes for
    -- the next GOP. This setting is only used when Scene Change Detect is
    -- enabled. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
    H264Settings -> Maybe Natural
minIInterval :: Prelude.Maybe Prelude.Natural,
    -- | Choose the scan line type for the output. Keep the default value,
    -- Progressive (PROGRESSIVE) to create a progressive output, regardless of
    -- the scan type of your input. Use Top field first (TOP_FIELD) or Bottom
    -- field first (BOTTOM_FIELD) to create an output that\'s interlaced with
    -- the same field polarity throughout. Use Follow, default top
    -- (FOLLOW_TOP_FIELD) or Follow, default bottom (FOLLOW_BOTTOM_FIELD) 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.
    H264Settings -> Maybe H264InterlaceMode
interlaceMode :: Prelude.Maybe H264InterlaceMode,
    -- | Optional. Specify how the service determines the pixel aspect ratio
    -- (PAR) for this output. The default behavior, Follow source
    -- (INITIALIZE_FROM_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. To specify a different PAR by editing the JSON
    -- job specification, choose SPECIFIED. When you choose SPECIFIED for this
    -- setting, you must also specify values for the parNumerator and
    -- parDenominator settings.
    H264Settings -> Maybe H264ParControl
parControl :: Prelude.Maybe H264ParControl,
    -- | Places a PPS header on each encoded picture, even if repeated.
    H264Settings -> Maybe H264RepeatPps
repeatPps :: Prelude.Maybe H264RepeatPps,
    -- | Use this setting for interlaced outputs, when your output frame rate is
    -- half of your input frame rate. In this situation, choose Optimized
    -- interlacing (INTERLACED_OPTIMIZE) 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 (INTERLACED), 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 (telecine) to None (NONE) or Soft (SOFT). You can\'t use
    -- optimized interlacing for hard telecine outputs. You must also set
    -- Interlace mode (interlaceMode) to a value other than Progressive
    -- (PROGRESSIVE).
    H264Settings -> Maybe H264ScanTypeConversionMode
scanTypeConversionMode :: Prelude.Maybe H264ScanTypeConversionMode,
    -- | 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 (DISABLED). Change this
    -- value to Enabled (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 (H264AdaptiveQuantization) to a value other than AUTO.
    H264Settings -> Maybe H264FlickerAdaptiveQuantization
flickerAdaptiveQuantization :: Prelude.Maybe H264FlickerAdaptiveQuantization,
    -- | Settings for quality-defined variable bitrate encoding with the H.265
    -- codec. Use these settings only when you set QVBR for Rate control mode
    -- (RateControlMode).
    H264Settings -> Maybe H264QvbrSettings
qvbrSettings :: Prelude.Maybe H264QvbrSettings,
    -- | 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 (sharpness) or by enabling
    -- a noise reducer filter (noiseReducerFilter). The Softness (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.
    H264Settings -> Maybe Natural
softness :: Prelude.Maybe Prelude.Natural,
    -- | H.264 Profile. High 4:2:2 and 10-bit profiles are only available with
    -- the AVC-I License.
    H264Settings -> Maybe H264CodecProfile
codecProfile :: Prelude.Maybe H264CodecProfile,
    -- | 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.
    H264Settings -> Maybe Natural
bitrate :: Prelude.Maybe Prelude.Natural,
    -- | 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.
    H264Settings -> Maybe Natural
framerateDenominator :: Prelude.Maybe Prelude.Natural,
    -- | Choose the method that you want MediaConvert to use when increasing or
    -- decreasing the frame rate. We recommend using drop duplicate
    -- (DUPLICATE_DROP) for numerically simple conversions, such as 60 fps to
    -- 30 fps. For numerically complex conversions, you can use interpolate
    -- (INTERPOLATE) to avoid stutter. 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, use FrameFormer (FRAMEFORMER) to do
    -- motion-compensated interpolation. FrameFormer chooses the best
    -- conversion method frame by frame. Note that using FrameFormer increases
    -- the transcoding time and incurs a significant add-on cost.
    H264Settings -> Maybe H264FramerateConversionAlgorithm
framerateConversionAlgorithm :: Prelude.Maybe H264FramerateConversionAlgorithm,
    -- | Specify an H.264 level that is consistent with your output video
    -- settings. If you aren\'t sure what level to specify, choose Auto (AUTO).
    H264Settings -> Maybe H264CodecLevel
codecLevel :: Prelude.Maybe H264CodecLevel,
    -- | Entropy encoding mode. Use CABAC (must be in Main or High profile) or
    -- CAVLC.
    H264Settings -> Maybe H264EntropyEncoding
entropyEncoding :: Prelude.Maybe H264EntropyEncoding,
    -- | 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.
    -- If you are creating your transcoding job specification as a JSON file
    -- without the console, use FramerateControl to specify which value the
    -- service uses for the frame rate for this output. Choose
    -- INITIALIZE_FROM_SOURCE if you want the service to use the frame rate
    -- from the input. Choose SPECIFIED if you want the service to use the
    -- frame rate you specify in the settings FramerateNumerator and
    -- FramerateDenominator.
    H264Settings -> Maybe H264FramerateControl
framerateControl :: Prelude.Maybe H264FramerateControl,
    -- | Keep the default value, Auto (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 (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 (H264AdaptiveQuantization) to Off (OFF). Related settings:
    -- The value that you choose here applies to the following settings:
    -- H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
    -- H264TemporalAdaptiveQuantization.
    H264Settings -> Maybe H264AdaptiveQuantization
adaptiveQuantization :: Prelude.Maybe H264AdaptiveQuantization,
    -- | 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.
    H264Settings -> Maybe Natural
framerateNumerator :: Prelude.Maybe Prelude.Natural,
    -- | If enable, use reference B frames for GOP structures that have B frames
    -- > 1.
    H264Settings -> Maybe H264GopBReference
gopBReference :: Prelude.Maybe H264GopBReference,
    -- | Maximum bitrate in bits\/second. For example, enter five megabits per
    -- second as 5000000. Required when Rate control mode is QVBR.
    H264Settings -> Maybe Natural
maxBitrate :: Prelude.Maybe Prelude.Natural,
    -- | Produces a bitstream compliant with SMPTE RP-2027.
    H264Settings -> Maybe H264Syntax
syntax :: Prelude.Maybe H264Syntax,
    -- | 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 (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.
    H264Settings -> Maybe H264FieldEncoding
fieldEncoding :: Prelude.Maybe H264FieldEncoding,
    -- | Frequency of closed GOPs. In streaming applications, it is recommended
    -- that this be set to 1 so a decoder joining mid-stream will receive an
    -- IDR frame as quickly as possible. Setting this value to 0 will break
    -- output segmenting.
    H264Settings -> Maybe Natural
gopClosedCadence :: Prelude.Maybe Prelude.Natural,
    -- | Required when you set Pixel aspect ratio (parControl) 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.
    H264Settings -> Maybe Natural
parDenominator :: Prelude.Maybe Prelude.Natural,
    -- | Only use this setting when you change the default value, Auto (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 (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 (DISABLED). Related setting:
    -- When you enable spatial adaptive quantization, set the value for
    -- Adaptive quantization (H264AdaptiveQuantization) 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
    -- (H264AdaptiveQuantization) to a value other than AUTO.
    H264Settings -> Maybe H264SpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Prelude.Maybe H264SpatialAdaptiveQuantization
  }
  deriving (H264Settings -> H264Settings -> Bool
(H264Settings -> H264Settings -> Bool)
-> (H264Settings -> H264Settings -> Bool) -> Eq H264Settings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: H264Settings -> H264Settings -> Bool
$c/= :: H264Settings -> H264Settings -> Bool
== :: H264Settings -> H264Settings -> Bool
$c== :: H264Settings -> H264Settings -> Bool
Prelude.Eq, ReadPrec [H264Settings]
ReadPrec H264Settings
Int -> ReadS H264Settings
ReadS [H264Settings]
(Int -> ReadS H264Settings)
-> ReadS [H264Settings]
-> ReadPrec H264Settings
-> ReadPrec [H264Settings]
-> Read H264Settings
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [H264Settings]
$creadListPrec :: ReadPrec [H264Settings]
readPrec :: ReadPrec H264Settings
$creadPrec :: ReadPrec H264Settings
readList :: ReadS [H264Settings]
$creadList :: ReadS [H264Settings]
readsPrec :: Int -> ReadS H264Settings
$creadsPrec :: Int -> ReadS H264Settings
Prelude.Read, Int -> H264Settings -> ShowS
[H264Settings] -> ShowS
H264Settings -> String
(Int -> H264Settings -> ShowS)
-> (H264Settings -> String)
-> ([H264Settings] -> ShowS)
-> Show H264Settings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [H264Settings] -> ShowS
$cshowList :: [H264Settings] -> ShowS
show :: H264Settings -> String
$cshow :: H264Settings -> String
showsPrec :: Int -> H264Settings -> ShowS
$cshowsPrec :: Int -> H264Settings -> ShowS
Prelude.Show, (forall x. H264Settings -> Rep H264Settings x)
-> (forall x. Rep H264Settings x -> H264Settings)
-> Generic H264Settings
forall x. Rep H264Settings x -> H264Settings
forall x. H264Settings -> Rep H264Settings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep H264Settings x -> H264Settings
$cfrom :: forall x. H264Settings -> Rep H264Settings x
Prelude.Generic)

-- |
-- Create a value of 'H264Settings' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'unregisteredSeiTimecode', 'h264Settings_unregisteredSeiTimecode' - Inserts timecode for each frame as 4 bytes of an unregistered SEI
-- message.
--
-- 'qualityTuningLevel', 'h264Settings_qualityTuningLevel' - Optional. Use Quality tuning level (qualityTuningLevel) to choose how
-- you want to trade off encoding speed for output video quality. The
-- default behavior is faster, lower quality, single-pass encoding.
--
-- 'temporalAdaptiveQuantization', 'h264Settings_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 (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 (DISABLED). Related
-- setting: When you enable temporal quantization, adjust the strength of
-- the filter with the setting Adaptive quantization
-- (adaptiveQuantization). To manually enable or disable
-- H264TemporalAdaptiveQuantization, you must set Adaptive quantization
-- (H264AdaptiveQuantization) to a value other than AUTO.
--
-- 'sceneChangeDetect', 'h264Settings_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
-- (TRANSITION_DETECTION) for further video quality improvement. For more
-- information about QVBR, see
-- https:\/\/docs.aws.amazon.com\/console\/mediaconvert\/cbr-vbr-qvbr.
--
-- 'hrdBufferInitialFillPercentage', 'h264Settings_hrdBufferInitialFillPercentage' - Percentage of the buffer that should initially be filled (HRD buffer
-- model).
--
-- 'slowPal', 'h264Settings_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. In your JSON job
-- specification, set (framerateControl) to (SPECIFIED),
-- (framerateNumerator) to 25 and (framerateDenominator) to 1.
--
-- 'parNumerator', 'h264Settings_parNumerator' - Required when you set Pixel aspect ratio (parControl) 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.
--
-- 'gopSize', 'h264Settings_gopSize' - GOP Length (keyframe interval) in frames or seconds. Must be greater
-- than zero.
--
-- 'numberBFramesBetweenReferenceFrames', 'h264Settings_numberBFramesBetweenReferenceFrames' - Specify the number of B-frames that MediaConvert puts between reference
-- frames in this output. Valid values are whole numbers from 0 through 7.
-- When you don\'t specify a value, MediaConvert defaults to 2.
--
-- 'gopSizeUnits', 'h264Settings_gopSizeUnits' - Indicates if the GOP Size in H264 is specified in frames or seconds. If
-- seconds the system will convert the GOP Size into a frame count at run
-- time.
--
-- 'hrdBufferSize', 'h264Settings_hrdBufferSize' - Size of buffer (HRD buffer model) in bits. For example, enter five
-- megabits as 5000000.
--
-- 'slices', 'h264Settings_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.
--
-- 'rateControlMode', 'h264Settings_rateControlMode' - Use this setting to specify whether this output has a variable bitrate
-- (VBR), constant bitrate (CBR) or quality-defined variable bitrate
-- (QVBR).
--
-- 'numberReferenceFrames', 'h264Settings_numberReferenceFrames' - Number of reference frames to use. The encoder may use more than
-- requested if using B-frames and\/or interlaced encoding.
--
-- 'telecine', 'h264Settings_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
-- (HARD) produces a 29.97i output. Soft telecine (SOFT) 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
-- (NONE), MediaConvert does a standard frame rate conversion to 29.97
-- without doing anything with the field polarity to create a smoother
-- picture.
--
-- 'dynamicSubGop', 'h264Settings_dynamicSubGop' - Choose Adaptive to improve subjective video quality for high-motion
-- content. This will cause the service to use fewer B-frames (which infer
-- information based on other frames) for high-motion portions of the video
-- and more B-frames for low-motion portions. The maximum number of
-- B-frames is limited by the value you provide for the setting B frames
-- between reference frames (numberBFramesBetweenReferenceFrames).
--
-- 'minIInterval', 'h264Settings_minIInterval' - Enforces separation between repeated (cadence) I-frames and I-frames
-- inserted by Scene Change Detection. If a scene change I-frame is within
-- I-interval frames of a cadence I-frame, the GOP is shrunk and\/or
-- stretched to the scene change I-frame. GOP stretch requires enabling
-- lookahead as well as setting I-interval. The normal cadence resumes for
-- the next GOP. This setting is only used when Scene Change Detect is
-- enabled. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
--
-- 'interlaceMode', 'h264Settings_interlaceMode' - Choose the scan line type for the output. Keep the default value,
-- Progressive (PROGRESSIVE) to create a progressive output, regardless of
-- the scan type of your input. Use Top field first (TOP_FIELD) or Bottom
-- field first (BOTTOM_FIELD) to create an output that\'s interlaced with
-- the same field polarity throughout. Use Follow, default top
-- (FOLLOW_TOP_FIELD) or Follow, default bottom (FOLLOW_BOTTOM_FIELD) 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.
--
-- 'parControl', 'h264Settings_parControl' - Optional. Specify how the service determines the pixel aspect ratio
-- (PAR) for this output. The default behavior, Follow source
-- (INITIALIZE_FROM_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. To specify a different PAR by editing the JSON
-- job specification, choose SPECIFIED. When you choose SPECIFIED for this
-- setting, you must also specify values for the parNumerator and
-- parDenominator settings.
--
-- 'repeatPps', 'h264Settings_repeatPps' - Places a PPS header on each encoded picture, even if repeated.
--
-- 'scanTypeConversionMode', 'h264Settings_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 (INTERLACED_OPTIMIZE) 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 (INTERLACED), 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 (telecine) to None (NONE) or Soft (SOFT). You can\'t use
-- optimized interlacing for hard telecine outputs. You must also set
-- Interlace mode (interlaceMode) to a value other than Progressive
-- (PROGRESSIVE).
--
-- 'flickerAdaptiveQuantization', 'h264Settings_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 (DISABLED). Change this
-- value to Enabled (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 (H264AdaptiveQuantization) to a value other than AUTO.
--
-- 'qvbrSettings', 'h264Settings_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
-- (RateControlMode).
--
-- 'softness', 'h264Settings_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 (sharpness) or by enabling
-- a noise reducer filter (noiseReducerFilter). The Softness (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.
--
-- 'codecProfile', 'h264Settings_codecProfile' - H.264 Profile. High 4:2:2 and 10-bit profiles are only available with
-- the AVC-I License.
--
-- 'bitrate', 'h264Settings_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.
--
-- 'framerateDenominator', 'h264Settings_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.
--
-- 'framerateConversionAlgorithm', 'h264Settings_framerateConversionAlgorithm' - Choose the method that you want MediaConvert to use when increasing or
-- decreasing the frame rate. We recommend using drop duplicate
-- (DUPLICATE_DROP) for numerically simple conversions, such as 60 fps to
-- 30 fps. For numerically complex conversions, you can use interpolate
-- (INTERPOLATE) to avoid stutter. 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, use FrameFormer (FRAMEFORMER) to do
-- motion-compensated interpolation. FrameFormer chooses the best
-- conversion method frame by frame. Note that using FrameFormer increases
-- the transcoding time and incurs a significant add-on cost.
--
-- 'codecLevel', 'h264Settings_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 (AUTO).
--
-- 'entropyEncoding', 'h264Settings_entropyEncoding' - Entropy encoding mode. Use CABAC (must be in Main or High profile) or
-- CAVLC.
--
-- 'framerateControl', 'h264Settings_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.
-- If you are creating your transcoding job specification as a JSON file
-- without the console, use FramerateControl to specify which value the
-- service uses for the frame rate for this output. Choose
-- INITIALIZE_FROM_SOURCE if you want the service to use the frame rate
-- from the input. Choose SPECIFIED if you want the service to use the
-- frame rate you specify in the settings FramerateNumerator and
-- FramerateDenominator.
--
-- 'adaptiveQuantization', 'h264Settings_adaptiveQuantization' - Keep the default value, Auto (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 (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 (H264AdaptiveQuantization) to Off (OFF). Related settings:
-- The value that you choose here applies to the following settings:
-- H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
-- H264TemporalAdaptiveQuantization.
--
-- 'framerateNumerator', 'h264Settings_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.
--
-- 'gopBReference', 'h264Settings_gopBReference' - If enable, use reference B frames for GOP structures that have B frames
-- > 1.
--
-- 'maxBitrate', 'h264Settings_maxBitrate' - Maximum bitrate in bits\/second. For example, enter five megabits per
-- second as 5000000. Required when Rate control mode is QVBR.
--
-- 'syntax', 'h264Settings_syntax' - Produces a bitstream compliant with SMPTE RP-2027.
--
-- 'fieldEncoding', 'h264Settings_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 (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.
--
-- 'gopClosedCadence', 'h264Settings_gopClosedCadence' - Frequency of closed GOPs. In streaming applications, it is recommended
-- that this be set to 1 so a decoder joining mid-stream will receive an
-- IDR frame as quickly as possible. Setting this value to 0 will break
-- output segmenting.
--
-- 'parDenominator', 'h264Settings_parDenominator' - Required when you set Pixel aspect ratio (parControl) 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.
--
-- 'spatialAdaptiveQuantization', 'h264Settings_spatialAdaptiveQuantization' - Only use this setting when you change the default value, Auto (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 (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 (DISABLED). Related setting:
-- When you enable spatial adaptive quantization, set the value for
-- Adaptive quantization (H264AdaptiveQuantization) 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
-- (H264AdaptiveQuantization) to a value other than AUTO.
newH264Settings ::
  H264Settings
newH264Settings :: H264Settings
newH264Settings =
  H264Settings' :: Maybe H264UnregisteredSeiTimecode
-> Maybe H264QualityTuningLevel
-> Maybe H264TemporalAdaptiveQuantization
-> Maybe H264SceneChangeDetect
-> Maybe Natural
-> Maybe H264SlowPal
-> Maybe Natural
-> Maybe Double
-> Maybe Natural
-> Maybe H264GopSizeUnits
-> Maybe Natural
-> Maybe Natural
-> Maybe H264RateControlMode
-> Maybe Natural
-> Maybe H264Telecine
-> Maybe H264DynamicSubGop
-> Maybe Natural
-> Maybe H264InterlaceMode
-> Maybe H264ParControl
-> Maybe H264RepeatPps
-> Maybe H264ScanTypeConversionMode
-> Maybe H264FlickerAdaptiveQuantization
-> Maybe H264QvbrSettings
-> Maybe Natural
-> Maybe H264CodecProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe H264FramerateConversionAlgorithm
-> Maybe H264CodecLevel
-> Maybe H264EntropyEncoding
-> Maybe H264FramerateControl
-> Maybe H264AdaptiveQuantization
-> Maybe Natural
-> Maybe H264GopBReference
-> Maybe Natural
-> Maybe H264Syntax
-> Maybe H264FieldEncoding
-> Maybe Natural
-> Maybe Natural
-> Maybe H264SpatialAdaptiveQuantization
-> H264Settings
H264Settings'
    { $sel:unregisteredSeiTimecode:H264Settings' :: Maybe H264UnregisteredSeiTimecode
unregisteredSeiTimecode =
        Maybe H264UnregisteredSeiTimecode
forall a. Maybe a
Prelude.Nothing,
      $sel:qualityTuningLevel:H264Settings' :: Maybe H264QualityTuningLevel
qualityTuningLevel = Maybe H264QualityTuningLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:temporalAdaptiveQuantization:H264Settings' :: Maybe H264TemporalAdaptiveQuantization
temporalAdaptiveQuantization = Maybe H264TemporalAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:sceneChangeDetect:H264Settings' :: Maybe H264SceneChangeDetect
sceneChangeDetect = Maybe H264SceneChangeDetect
forall a. Maybe a
Prelude.Nothing,
      $sel:hrdBufferInitialFillPercentage:H264Settings' :: Maybe Natural
hrdBufferInitialFillPercentage = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:slowPal:H264Settings' :: Maybe H264SlowPal
slowPal = Maybe H264SlowPal
forall a. Maybe a
Prelude.Nothing,
      $sel:parNumerator:H264Settings' :: Maybe Natural
parNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopSize:H264Settings' :: Maybe Double
gopSize = Maybe Double
forall a. Maybe a
Prelude.Nothing,
      $sel:numberBFramesBetweenReferenceFrames:H264Settings' :: Maybe Natural
numberBFramesBetweenReferenceFrames =
        Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopSizeUnits:H264Settings' :: Maybe H264GopSizeUnits
gopSizeUnits = Maybe H264GopSizeUnits
forall a. Maybe a
Prelude.Nothing,
      $sel:hrdBufferSize:H264Settings' :: Maybe Natural
hrdBufferSize = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:slices:H264Settings' :: Maybe Natural
slices = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:rateControlMode:H264Settings' :: Maybe H264RateControlMode
rateControlMode = Maybe H264RateControlMode
forall a. Maybe a
Prelude.Nothing,
      $sel:numberReferenceFrames:H264Settings' :: Maybe Natural
numberReferenceFrames = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:telecine:H264Settings' :: Maybe H264Telecine
telecine = Maybe H264Telecine
forall a. Maybe a
Prelude.Nothing,
      $sel:dynamicSubGop:H264Settings' :: Maybe H264DynamicSubGop
dynamicSubGop = Maybe H264DynamicSubGop
forall a. Maybe a
Prelude.Nothing,
      $sel:minIInterval:H264Settings' :: Maybe Natural
minIInterval = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:interlaceMode:H264Settings' :: Maybe H264InterlaceMode
interlaceMode = Maybe H264InterlaceMode
forall a. Maybe a
Prelude.Nothing,
      $sel:parControl:H264Settings' :: Maybe H264ParControl
parControl = Maybe H264ParControl
forall a. Maybe a
Prelude.Nothing,
      $sel:repeatPps:H264Settings' :: Maybe H264RepeatPps
repeatPps = Maybe H264RepeatPps
forall a. Maybe a
Prelude.Nothing,
      $sel:scanTypeConversionMode:H264Settings' :: Maybe H264ScanTypeConversionMode
scanTypeConversionMode = Maybe H264ScanTypeConversionMode
forall a. Maybe a
Prelude.Nothing,
      $sel:flickerAdaptiveQuantization:H264Settings' :: Maybe H264FlickerAdaptiveQuantization
flickerAdaptiveQuantization = Maybe H264FlickerAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:qvbrSettings:H264Settings' :: Maybe H264QvbrSettings
qvbrSettings = Maybe H264QvbrSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:softness:H264Settings' :: Maybe Natural
softness = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:codecProfile:H264Settings' :: Maybe H264CodecProfile
codecProfile = Maybe H264CodecProfile
forall a. Maybe a
Prelude.Nothing,
      $sel:bitrate:H264Settings' :: Maybe Natural
bitrate = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateDenominator:H264Settings' :: Maybe Natural
framerateDenominator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateConversionAlgorithm:H264Settings' :: Maybe H264FramerateConversionAlgorithm
framerateConversionAlgorithm = Maybe H264FramerateConversionAlgorithm
forall a. Maybe a
Prelude.Nothing,
      $sel:codecLevel:H264Settings' :: Maybe H264CodecLevel
codecLevel = Maybe H264CodecLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:entropyEncoding:H264Settings' :: Maybe H264EntropyEncoding
entropyEncoding = Maybe H264EntropyEncoding
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateControl:H264Settings' :: Maybe H264FramerateControl
framerateControl = Maybe H264FramerateControl
forall a. Maybe a
Prelude.Nothing,
      $sel:adaptiveQuantization:H264Settings' :: Maybe H264AdaptiveQuantization
adaptiveQuantization = Maybe H264AdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateNumerator:H264Settings' :: Maybe Natural
framerateNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopBReference:H264Settings' :: Maybe H264GopBReference
gopBReference = Maybe H264GopBReference
forall a. Maybe a
Prelude.Nothing,
      $sel:maxBitrate:H264Settings' :: Maybe Natural
maxBitrate = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:syntax:H264Settings' :: Maybe H264Syntax
syntax = Maybe H264Syntax
forall a. Maybe a
Prelude.Nothing,
      $sel:fieldEncoding:H264Settings' :: Maybe H264FieldEncoding
fieldEncoding = Maybe H264FieldEncoding
forall a. Maybe a
Prelude.Nothing,
      $sel:gopClosedCadence:H264Settings' :: Maybe Natural
gopClosedCadence = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:parDenominator:H264Settings' :: Maybe Natural
parDenominator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:spatialAdaptiveQuantization:H264Settings' :: Maybe H264SpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe H264SpatialAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing
    }

-- | Inserts timecode for each frame as 4 bytes of an unregistered SEI
-- message.
h264Settings_unregisteredSeiTimecode :: Lens.Lens' H264Settings (Prelude.Maybe H264UnregisteredSeiTimecode)
h264Settings_unregisteredSeiTimecode :: (Maybe H264UnregisteredSeiTimecode
 -> f (Maybe H264UnregisteredSeiTimecode))
-> H264Settings -> f H264Settings
h264Settings_unregisteredSeiTimecode = (H264Settings -> Maybe H264UnregisteredSeiTimecode)
-> (H264Settings
    -> Maybe H264UnregisteredSeiTimecode -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264UnregisteredSeiTimecode)
     (Maybe H264UnregisteredSeiTimecode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264UnregisteredSeiTimecode
unregisteredSeiTimecode :: Maybe H264UnregisteredSeiTimecode
$sel:unregisteredSeiTimecode:H264Settings' :: H264Settings -> Maybe H264UnregisteredSeiTimecode
unregisteredSeiTimecode} -> Maybe H264UnregisteredSeiTimecode
unregisteredSeiTimecode) (\s :: H264Settings
s@H264Settings' {} Maybe H264UnregisteredSeiTimecode
a -> H264Settings
s {$sel:unregisteredSeiTimecode:H264Settings' :: Maybe H264UnregisteredSeiTimecode
unregisteredSeiTimecode = Maybe H264UnregisteredSeiTimecode
a} :: H264Settings)

-- | Optional. Use Quality tuning level (qualityTuningLevel) to choose how
-- you want to trade off encoding speed for output video quality. The
-- default behavior is faster, lower quality, single-pass encoding.
h264Settings_qualityTuningLevel :: Lens.Lens' H264Settings (Prelude.Maybe H264QualityTuningLevel)
h264Settings_qualityTuningLevel :: (Maybe H264QualityTuningLevel -> f (Maybe H264QualityTuningLevel))
-> H264Settings -> f H264Settings
h264Settings_qualityTuningLevel = (H264Settings -> Maybe H264QualityTuningLevel)
-> (H264Settings -> Maybe H264QualityTuningLevel -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264QualityTuningLevel)
     (Maybe H264QualityTuningLevel)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264QualityTuningLevel
qualityTuningLevel :: Maybe H264QualityTuningLevel
$sel:qualityTuningLevel:H264Settings' :: H264Settings -> Maybe H264QualityTuningLevel
qualityTuningLevel} -> Maybe H264QualityTuningLevel
qualityTuningLevel) (\s :: H264Settings
s@H264Settings' {} Maybe H264QualityTuningLevel
a -> H264Settings
s {$sel:qualityTuningLevel:H264Settings' :: Maybe H264QualityTuningLevel
qualityTuningLevel = Maybe H264QualityTuningLevel
a} :: H264Settings)

-- | 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 (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 (DISABLED). Related
-- setting: When you enable temporal quantization, adjust the strength of
-- the filter with the setting Adaptive quantization
-- (adaptiveQuantization). To manually enable or disable
-- H264TemporalAdaptiveQuantization, you must set Adaptive quantization
-- (H264AdaptiveQuantization) to a value other than AUTO.
h264Settings_temporalAdaptiveQuantization :: Lens.Lens' H264Settings (Prelude.Maybe H264TemporalAdaptiveQuantization)
h264Settings_temporalAdaptiveQuantization :: (Maybe H264TemporalAdaptiveQuantization
 -> f (Maybe H264TemporalAdaptiveQuantization))
-> H264Settings -> f H264Settings
h264Settings_temporalAdaptiveQuantization = (H264Settings -> Maybe H264TemporalAdaptiveQuantization)
-> (H264Settings
    -> Maybe H264TemporalAdaptiveQuantization -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264TemporalAdaptiveQuantization)
     (Maybe H264TemporalAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264TemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Maybe H264TemporalAdaptiveQuantization
$sel:temporalAdaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264TemporalAdaptiveQuantization
temporalAdaptiveQuantization} -> Maybe H264TemporalAdaptiveQuantization
temporalAdaptiveQuantization) (\s :: H264Settings
s@H264Settings' {} Maybe H264TemporalAdaptiveQuantization
a -> H264Settings
s {$sel:temporalAdaptiveQuantization:H264Settings' :: Maybe H264TemporalAdaptiveQuantization
temporalAdaptiveQuantization = Maybe H264TemporalAdaptiveQuantization
a} :: H264Settings)

-- | 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
-- (TRANSITION_DETECTION) for further video quality improvement. For more
-- information about QVBR, see
-- https:\/\/docs.aws.amazon.com\/console\/mediaconvert\/cbr-vbr-qvbr.
h264Settings_sceneChangeDetect :: Lens.Lens' H264Settings (Prelude.Maybe H264SceneChangeDetect)
h264Settings_sceneChangeDetect :: (Maybe H264SceneChangeDetect -> f (Maybe H264SceneChangeDetect))
-> H264Settings -> f H264Settings
h264Settings_sceneChangeDetect = (H264Settings -> Maybe H264SceneChangeDetect)
-> (H264Settings -> Maybe H264SceneChangeDetect -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264SceneChangeDetect)
     (Maybe H264SceneChangeDetect)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264SceneChangeDetect
sceneChangeDetect :: Maybe H264SceneChangeDetect
$sel:sceneChangeDetect:H264Settings' :: H264Settings -> Maybe H264SceneChangeDetect
sceneChangeDetect} -> Maybe H264SceneChangeDetect
sceneChangeDetect) (\s :: H264Settings
s@H264Settings' {} Maybe H264SceneChangeDetect
a -> H264Settings
s {$sel:sceneChangeDetect:H264Settings' :: Maybe H264SceneChangeDetect
sceneChangeDetect = Maybe H264SceneChangeDetect
a} :: H264Settings)

-- | Percentage of the buffer that should initially be filled (HRD buffer
-- model).
h264Settings_hrdBufferInitialFillPercentage :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_hrdBufferInitialFillPercentage :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_hrdBufferInitialFillPercentage = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
hrdBufferInitialFillPercentage :: Maybe Natural
$sel:hrdBufferInitialFillPercentage:H264Settings' :: H264Settings -> Maybe Natural
hrdBufferInitialFillPercentage} -> Maybe Natural
hrdBufferInitialFillPercentage) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:hrdBufferInitialFillPercentage:H264Settings' :: Maybe Natural
hrdBufferInitialFillPercentage = Maybe Natural
a} :: H264Settings)

-- | 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. In your JSON job
-- specification, set (framerateControl) to (SPECIFIED),
-- (framerateNumerator) to 25 and (framerateDenominator) to 1.
h264Settings_slowPal :: Lens.Lens' H264Settings (Prelude.Maybe H264SlowPal)
h264Settings_slowPal :: (Maybe H264SlowPal -> f (Maybe H264SlowPal))
-> H264Settings -> f H264Settings
h264Settings_slowPal = (H264Settings -> Maybe H264SlowPal)
-> (H264Settings -> Maybe H264SlowPal -> H264Settings)
-> Lens
     H264Settings H264Settings (Maybe H264SlowPal) (Maybe H264SlowPal)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264SlowPal
slowPal :: Maybe H264SlowPal
$sel:slowPal:H264Settings' :: H264Settings -> Maybe H264SlowPal
slowPal} -> Maybe H264SlowPal
slowPal) (\s :: H264Settings
s@H264Settings' {} Maybe H264SlowPal
a -> H264Settings
s {$sel:slowPal:H264Settings' :: Maybe H264SlowPal
slowPal = Maybe H264SlowPal
a} :: H264Settings)

-- | Required when you set Pixel aspect ratio (parControl) 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.
h264Settings_parNumerator :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_parNumerator :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_parNumerator = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
parNumerator :: Maybe Natural
$sel:parNumerator:H264Settings' :: H264Settings -> Maybe Natural
parNumerator} -> Maybe Natural
parNumerator) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:parNumerator:H264Settings' :: Maybe Natural
parNumerator = Maybe Natural
a} :: H264Settings)

-- | GOP Length (keyframe interval) in frames or seconds. Must be greater
-- than zero.
h264Settings_gopSize :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Double)
h264Settings_gopSize :: (Maybe Double -> f (Maybe Double))
-> H264Settings -> f H264Settings
h264Settings_gopSize = (H264Settings -> Maybe Double)
-> (H264Settings -> Maybe Double -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Double) (Maybe Double)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Double
gopSize :: Maybe Double
$sel:gopSize:H264Settings' :: H264Settings -> Maybe Double
gopSize} -> Maybe Double
gopSize) (\s :: H264Settings
s@H264Settings' {} Maybe Double
a -> H264Settings
s {$sel:gopSize:H264Settings' :: Maybe Double
gopSize = Maybe Double
a} :: H264Settings)

-- | Specify the number of B-frames that MediaConvert puts between reference
-- frames in this output. Valid values are whole numbers from 0 through 7.
-- When you don\'t specify a value, MediaConvert defaults to 2.
h264Settings_numberBFramesBetweenReferenceFrames :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_numberBFramesBetweenReferenceFrames :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_numberBFramesBetweenReferenceFrames = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
numberBFramesBetweenReferenceFrames :: Maybe Natural
$sel:numberBFramesBetweenReferenceFrames:H264Settings' :: H264Settings -> Maybe Natural
numberBFramesBetweenReferenceFrames} -> Maybe Natural
numberBFramesBetweenReferenceFrames) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:numberBFramesBetweenReferenceFrames:H264Settings' :: Maybe Natural
numberBFramesBetweenReferenceFrames = Maybe Natural
a} :: H264Settings)

-- | Indicates if the GOP Size in H264 is specified in frames or seconds. If
-- seconds the system will convert the GOP Size into a frame count at run
-- time.
h264Settings_gopSizeUnits :: Lens.Lens' H264Settings (Prelude.Maybe H264GopSizeUnits)
h264Settings_gopSizeUnits :: (Maybe H264GopSizeUnits -> f (Maybe H264GopSizeUnits))
-> H264Settings -> f H264Settings
h264Settings_gopSizeUnits = (H264Settings -> Maybe H264GopSizeUnits)
-> (H264Settings -> Maybe H264GopSizeUnits -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264GopSizeUnits)
     (Maybe H264GopSizeUnits)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264GopSizeUnits
gopSizeUnits :: Maybe H264GopSizeUnits
$sel:gopSizeUnits:H264Settings' :: H264Settings -> Maybe H264GopSizeUnits
gopSizeUnits} -> Maybe H264GopSizeUnits
gopSizeUnits) (\s :: H264Settings
s@H264Settings' {} Maybe H264GopSizeUnits
a -> H264Settings
s {$sel:gopSizeUnits:H264Settings' :: Maybe H264GopSizeUnits
gopSizeUnits = Maybe H264GopSizeUnits
a} :: H264Settings)

-- | Size of buffer (HRD buffer model) in bits. For example, enter five
-- megabits as 5000000.
h264Settings_hrdBufferSize :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_hrdBufferSize :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_hrdBufferSize = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
hrdBufferSize :: Maybe Natural
$sel:hrdBufferSize:H264Settings' :: H264Settings -> Maybe Natural
hrdBufferSize} -> Maybe Natural
hrdBufferSize) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:hrdBufferSize:H264Settings' :: Maybe Natural
hrdBufferSize = Maybe Natural
a} :: H264Settings)

-- | 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.
h264Settings_slices :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_slices :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_slices = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
slices :: Maybe Natural
$sel:slices:H264Settings' :: H264Settings -> Maybe Natural
slices} -> Maybe Natural
slices) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:slices:H264Settings' :: Maybe Natural
slices = Maybe Natural
a} :: H264Settings)

-- | Use this setting to specify whether this output has a variable bitrate
-- (VBR), constant bitrate (CBR) or quality-defined variable bitrate
-- (QVBR).
h264Settings_rateControlMode :: Lens.Lens' H264Settings (Prelude.Maybe H264RateControlMode)
h264Settings_rateControlMode :: (Maybe H264RateControlMode -> f (Maybe H264RateControlMode))
-> H264Settings -> f H264Settings
h264Settings_rateControlMode = (H264Settings -> Maybe H264RateControlMode)
-> (H264Settings -> Maybe H264RateControlMode -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264RateControlMode)
     (Maybe H264RateControlMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264RateControlMode
rateControlMode :: Maybe H264RateControlMode
$sel:rateControlMode:H264Settings' :: H264Settings -> Maybe H264RateControlMode
rateControlMode} -> Maybe H264RateControlMode
rateControlMode) (\s :: H264Settings
s@H264Settings' {} Maybe H264RateControlMode
a -> H264Settings
s {$sel:rateControlMode:H264Settings' :: Maybe H264RateControlMode
rateControlMode = Maybe H264RateControlMode
a} :: H264Settings)

-- | Number of reference frames to use. The encoder may use more than
-- requested if using B-frames and\/or interlaced encoding.
h264Settings_numberReferenceFrames :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_numberReferenceFrames :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_numberReferenceFrames = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
numberReferenceFrames :: Maybe Natural
$sel:numberReferenceFrames:H264Settings' :: H264Settings -> Maybe Natural
numberReferenceFrames} -> Maybe Natural
numberReferenceFrames) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:numberReferenceFrames:H264Settings' :: Maybe Natural
numberReferenceFrames = Maybe Natural
a} :: H264Settings)

-- | 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
-- (HARD) produces a 29.97i output. Soft telecine (SOFT) 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
-- (NONE), MediaConvert does a standard frame rate conversion to 29.97
-- without doing anything with the field polarity to create a smoother
-- picture.
h264Settings_telecine :: Lens.Lens' H264Settings (Prelude.Maybe H264Telecine)
h264Settings_telecine :: (Maybe H264Telecine -> f (Maybe H264Telecine))
-> H264Settings -> f H264Settings
h264Settings_telecine = (H264Settings -> Maybe H264Telecine)
-> (H264Settings -> Maybe H264Telecine -> H264Settings)
-> Lens
     H264Settings H264Settings (Maybe H264Telecine) (Maybe H264Telecine)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264Telecine
telecine :: Maybe H264Telecine
$sel:telecine:H264Settings' :: H264Settings -> Maybe H264Telecine
telecine} -> Maybe H264Telecine
telecine) (\s :: H264Settings
s@H264Settings' {} Maybe H264Telecine
a -> H264Settings
s {$sel:telecine:H264Settings' :: Maybe H264Telecine
telecine = Maybe H264Telecine
a} :: H264Settings)

-- | Choose Adaptive to improve subjective video quality for high-motion
-- content. This will cause the service to use fewer B-frames (which infer
-- information based on other frames) for high-motion portions of the video
-- and more B-frames for low-motion portions. The maximum number of
-- B-frames is limited by the value you provide for the setting B frames
-- between reference frames (numberBFramesBetweenReferenceFrames).
h264Settings_dynamicSubGop :: Lens.Lens' H264Settings (Prelude.Maybe H264DynamicSubGop)
h264Settings_dynamicSubGop :: (Maybe H264DynamicSubGop -> f (Maybe H264DynamicSubGop))
-> H264Settings -> f H264Settings
h264Settings_dynamicSubGop = (H264Settings -> Maybe H264DynamicSubGop)
-> (H264Settings -> Maybe H264DynamicSubGop -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264DynamicSubGop)
     (Maybe H264DynamicSubGop)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264DynamicSubGop
dynamicSubGop :: Maybe H264DynamicSubGop
$sel:dynamicSubGop:H264Settings' :: H264Settings -> Maybe H264DynamicSubGop
dynamicSubGop} -> Maybe H264DynamicSubGop
dynamicSubGop) (\s :: H264Settings
s@H264Settings' {} Maybe H264DynamicSubGop
a -> H264Settings
s {$sel:dynamicSubGop:H264Settings' :: Maybe H264DynamicSubGop
dynamicSubGop = Maybe H264DynamicSubGop
a} :: H264Settings)

-- | Enforces separation between repeated (cadence) I-frames and I-frames
-- inserted by Scene Change Detection. If a scene change I-frame is within
-- I-interval frames of a cadence I-frame, the GOP is shrunk and\/or
-- stretched to the scene change I-frame. GOP stretch requires enabling
-- lookahead as well as setting I-interval. The normal cadence resumes for
-- the next GOP. This setting is only used when Scene Change Detect is
-- enabled. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
h264Settings_minIInterval :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_minIInterval :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_minIInterval = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
minIInterval :: Maybe Natural
$sel:minIInterval:H264Settings' :: H264Settings -> Maybe Natural
minIInterval} -> Maybe Natural
minIInterval) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:minIInterval:H264Settings' :: Maybe Natural
minIInterval = Maybe Natural
a} :: H264Settings)

-- | Choose the scan line type for the output. Keep the default value,
-- Progressive (PROGRESSIVE) to create a progressive output, regardless of
-- the scan type of your input. Use Top field first (TOP_FIELD) or Bottom
-- field first (BOTTOM_FIELD) to create an output that\'s interlaced with
-- the same field polarity throughout. Use Follow, default top
-- (FOLLOW_TOP_FIELD) or Follow, default bottom (FOLLOW_BOTTOM_FIELD) 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.
h264Settings_interlaceMode :: Lens.Lens' H264Settings (Prelude.Maybe H264InterlaceMode)
h264Settings_interlaceMode :: (Maybe H264InterlaceMode -> f (Maybe H264InterlaceMode))
-> H264Settings -> f H264Settings
h264Settings_interlaceMode = (H264Settings -> Maybe H264InterlaceMode)
-> (H264Settings -> Maybe H264InterlaceMode -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264InterlaceMode)
     (Maybe H264InterlaceMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264InterlaceMode
interlaceMode :: Maybe H264InterlaceMode
$sel:interlaceMode:H264Settings' :: H264Settings -> Maybe H264InterlaceMode
interlaceMode} -> Maybe H264InterlaceMode
interlaceMode) (\s :: H264Settings
s@H264Settings' {} Maybe H264InterlaceMode
a -> H264Settings
s {$sel:interlaceMode:H264Settings' :: Maybe H264InterlaceMode
interlaceMode = Maybe H264InterlaceMode
a} :: H264Settings)

-- | Optional. Specify how the service determines the pixel aspect ratio
-- (PAR) for this output. The default behavior, Follow source
-- (INITIALIZE_FROM_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. To specify a different PAR by editing the JSON
-- job specification, choose SPECIFIED. When you choose SPECIFIED for this
-- setting, you must also specify values for the parNumerator and
-- parDenominator settings.
h264Settings_parControl :: Lens.Lens' H264Settings (Prelude.Maybe H264ParControl)
h264Settings_parControl :: (Maybe H264ParControl -> f (Maybe H264ParControl))
-> H264Settings -> f H264Settings
h264Settings_parControl = (H264Settings -> Maybe H264ParControl)
-> (H264Settings -> Maybe H264ParControl -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264ParControl)
     (Maybe H264ParControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264ParControl
parControl :: Maybe H264ParControl
$sel:parControl:H264Settings' :: H264Settings -> Maybe H264ParControl
parControl} -> Maybe H264ParControl
parControl) (\s :: H264Settings
s@H264Settings' {} Maybe H264ParControl
a -> H264Settings
s {$sel:parControl:H264Settings' :: Maybe H264ParControl
parControl = Maybe H264ParControl
a} :: H264Settings)

-- | Places a PPS header on each encoded picture, even if repeated.
h264Settings_repeatPps :: Lens.Lens' H264Settings (Prelude.Maybe H264RepeatPps)
h264Settings_repeatPps :: (Maybe H264RepeatPps -> f (Maybe H264RepeatPps))
-> H264Settings -> f H264Settings
h264Settings_repeatPps = (H264Settings -> Maybe H264RepeatPps)
-> (H264Settings -> Maybe H264RepeatPps -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264RepeatPps)
     (Maybe H264RepeatPps)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264RepeatPps
repeatPps :: Maybe H264RepeatPps
$sel:repeatPps:H264Settings' :: H264Settings -> Maybe H264RepeatPps
repeatPps} -> Maybe H264RepeatPps
repeatPps) (\s :: H264Settings
s@H264Settings' {} Maybe H264RepeatPps
a -> H264Settings
s {$sel:repeatPps:H264Settings' :: Maybe H264RepeatPps
repeatPps = Maybe H264RepeatPps
a} :: H264Settings)

-- | Use this setting for interlaced outputs, when your output frame rate is
-- half of your input frame rate. In this situation, choose Optimized
-- interlacing (INTERLACED_OPTIMIZE) 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 (INTERLACED), 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 (telecine) to None (NONE) or Soft (SOFT). You can\'t use
-- optimized interlacing for hard telecine outputs. You must also set
-- Interlace mode (interlaceMode) to a value other than Progressive
-- (PROGRESSIVE).
h264Settings_scanTypeConversionMode :: Lens.Lens' H264Settings (Prelude.Maybe H264ScanTypeConversionMode)
h264Settings_scanTypeConversionMode :: (Maybe H264ScanTypeConversionMode
 -> f (Maybe H264ScanTypeConversionMode))
-> H264Settings -> f H264Settings
h264Settings_scanTypeConversionMode = (H264Settings -> Maybe H264ScanTypeConversionMode)
-> (H264Settings
    -> Maybe H264ScanTypeConversionMode -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264ScanTypeConversionMode)
     (Maybe H264ScanTypeConversionMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264ScanTypeConversionMode
scanTypeConversionMode :: Maybe H264ScanTypeConversionMode
$sel:scanTypeConversionMode:H264Settings' :: H264Settings -> Maybe H264ScanTypeConversionMode
scanTypeConversionMode} -> Maybe H264ScanTypeConversionMode
scanTypeConversionMode) (\s :: H264Settings
s@H264Settings' {} Maybe H264ScanTypeConversionMode
a -> H264Settings
s {$sel:scanTypeConversionMode:H264Settings' :: Maybe H264ScanTypeConversionMode
scanTypeConversionMode = Maybe H264ScanTypeConversionMode
a} :: H264Settings)

-- | 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 (DISABLED). Change this
-- value to Enabled (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 (H264AdaptiveQuantization) to a value other than AUTO.
h264Settings_flickerAdaptiveQuantization :: Lens.Lens' H264Settings (Prelude.Maybe H264FlickerAdaptiveQuantization)
h264Settings_flickerAdaptiveQuantization :: (Maybe H264FlickerAdaptiveQuantization
 -> f (Maybe H264FlickerAdaptiveQuantization))
-> H264Settings -> f H264Settings
h264Settings_flickerAdaptiveQuantization = (H264Settings -> Maybe H264FlickerAdaptiveQuantization)
-> (H264Settings
    -> Maybe H264FlickerAdaptiveQuantization -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264FlickerAdaptiveQuantization)
     (Maybe H264FlickerAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264FlickerAdaptiveQuantization
flickerAdaptiveQuantization :: Maybe H264FlickerAdaptiveQuantization
$sel:flickerAdaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264FlickerAdaptiveQuantization
flickerAdaptiveQuantization} -> Maybe H264FlickerAdaptiveQuantization
flickerAdaptiveQuantization) (\s :: H264Settings
s@H264Settings' {} Maybe H264FlickerAdaptiveQuantization
a -> H264Settings
s {$sel:flickerAdaptiveQuantization:H264Settings' :: Maybe H264FlickerAdaptiveQuantization
flickerAdaptiveQuantization = Maybe H264FlickerAdaptiveQuantization
a} :: H264Settings)

-- | Settings for quality-defined variable bitrate encoding with the H.265
-- codec. Use these settings only when you set QVBR for Rate control mode
-- (RateControlMode).
h264Settings_qvbrSettings :: Lens.Lens' H264Settings (Prelude.Maybe H264QvbrSettings)
h264Settings_qvbrSettings :: (Maybe H264QvbrSettings -> f (Maybe H264QvbrSettings))
-> H264Settings -> f H264Settings
h264Settings_qvbrSettings = (H264Settings -> Maybe H264QvbrSettings)
-> (H264Settings -> Maybe H264QvbrSettings -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264QvbrSettings)
     (Maybe H264QvbrSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264QvbrSettings
qvbrSettings :: Maybe H264QvbrSettings
$sel:qvbrSettings:H264Settings' :: H264Settings -> Maybe H264QvbrSettings
qvbrSettings} -> Maybe H264QvbrSettings
qvbrSettings) (\s :: H264Settings
s@H264Settings' {} Maybe H264QvbrSettings
a -> H264Settings
s {$sel:qvbrSettings:H264Settings' :: Maybe H264QvbrSettings
qvbrSettings = Maybe H264QvbrSettings
a} :: H264Settings)

-- | 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 (sharpness) or by enabling
-- a noise reducer filter (noiseReducerFilter). The Softness (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.
h264Settings_softness :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_softness :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_softness = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
softness :: Maybe Natural
$sel:softness:H264Settings' :: H264Settings -> Maybe Natural
softness} -> Maybe Natural
softness) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:softness:H264Settings' :: Maybe Natural
softness = Maybe Natural
a} :: H264Settings)

-- | H.264 Profile. High 4:2:2 and 10-bit profiles are only available with
-- the AVC-I License.
h264Settings_codecProfile :: Lens.Lens' H264Settings (Prelude.Maybe H264CodecProfile)
h264Settings_codecProfile :: (Maybe H264CodecProfile -> f (Maybe H264CodecProfile))
-> H264Settings -> f H264Settings
h264Settings_codecProfile = (H264Settings -> Maybe H264CodecProfile)
-> (H264Settings -> Maybe H264CodecProfile -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264CodecProfile)
     (Maybe H264CodecProfile)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264CodecProfile
codecProfile :: Maybe H264CodecProfile
$sel:codecProfile:H264Settings' :: H264Settings -> Maybe H264CodecProfile
codecProfile} -> Maybe H264CodecProfile
codecProfile) (\s :: H264Settings
s@H264Settings' {} Maybe H264CodecProfile
a -> H264Settings
s {$sel:codecProfile:H264Settings' :: Maybe H264CodecProfile
codecProfile = Maybe H264CodecProfile
a} :: H264Settings)

-- | 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.
h264Settings_bitrate :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_bitrate :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_bitrate = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
bitrate :: Maybe Natural
$sel:bitrate:H264Settings' :: H264Settings -> Maybe Natural
bitrate} -> Maybe Natural
bitrate) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:bitrate:H264Settings' :: Maybe Natural
bitrate = Maybe Natural
a} :: H264Settings)

-- | 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.
h264Settings_framerateDenominator :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_framerateDenominator :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_framerateDenominator = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
framerateDenominator :: Maybe Natural
$sel:framerateDenominator:H264Settings' :: H264Settings -> Maybe Natural
framerateDenominator} -> Maybe Natural
framerateDenominator) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:framerateDenominator:H264Settings' :: Maybe Natural
framerateDenominator = Maybe Natural
a} :: H264Settings)

-- | Choose the method that you want MediaConvert to use when increasing or
-- decreasing the frame rate. We recommend using drop duplicate
-- (DUPLICATE_DROP) for numerically simple conversions, such as 60 fps to
-- 30 fps. For numerically complex conversions, you can use interpolate
-- (INTERPOLATE) to avoid stutter. 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, use FrameFormer (FRAMEFORMER) to do
-- motion-compensated interpolation. FrameFormer chooses the best
-- conversion method frame by frame. Note that using FrameFormer increases
-- the transcoding time and incurs a significant add-on cost.
h264Settings_framerateConversionAlgorithm :: Lens.Lens' H264Settings (Prelude.Maybe H264FramerateConversionAlgorithm)
h264Settings_framerateConversionAlgorithm :: (Maybe H264FramerateConversionAlgorithm
 -> f (Maybe H264FramerateConversionAlgorithm))
-> H264Settings -> f H264Settings
h264Settings_framerateConversionAlgorithm = (H264Settings -> Maybe H264FramerateConversionAlgorithm)
-> (H264Settings
    -> Maybe H264FramerateConversionAlgorithm -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264FramerateConversionAlgorithm)
     (Maybe H264FramerateConversionAlgorithm)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264FramerateConversionAlgorithm
framerateConversionAlgorithm :: Maybe H264FramerateConversionAlgorithm
$sel:framerateConversionAlgorithm:H264Settings' :: H264Settings -> Maybe H264FramerateConversionAlgorithm
framerateConversionAlgorithm} -> Maybe H264FramerateConversionAlgorithm
framerateConversionAlgorithm) (\s :: H264Settings
s@H264Settings' {} Maybe H264FramerateConversionAlgorithm
a -> H264Settings
s {$sel:framerateConversionAlgorithm:H264Settings' :: Maybe H264FramerateConversionAlgorithm
framerateConversionAlgorithm = Maybe H264FramerateConversionAlgorithm
a} :: H264Settings)

-- | Specify an H.264 level that is consistent with your output video
-- settings. If you aren\'t sure what level to specify, choose Auto (AUTO).
h264Settings_codecLevel :: Lens.Lens' H264Settings (Prelude.Maybe H264CodecLevel)
h264Settings_codecLevel :: (Maybe H264CodecLevel -> f (Maybe H264CodecLevel))
-> H264Settings -> f H264Settings
h264Settings_codecLevel = (H264Settings -> Maybe H264CodecLevel)
-> (H264Settings -> Maybe H264CodecLevel -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264CodecLevel)
     (Maybe H264CodecLevel)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264CodecLevel
codecLevel :: Maybe H264CodecLevel
$sel:codecLevel:H264Settings' :: H264Settings -> Maybe H264CodecLevel
codecLevel} -> Maybe H264CodecLevel
codecLevel) (\s :: H264Settings
s@H264Settings' {} Maybe H264CodecLevel
a -> H264Settings
s {$sel:codecLevel:H264Settings' :: Maybe H264CodecLevel
codecLevel = Maybe H264CodecLevel
a} :: H264Settings)

-- | Entropy encoding mode. Use CABAC (must be in Main or High profile) or
-- CAVLC.
h264Settings_entropyEncoding :: Lens.Lens' H264Settings (Prelude.Maybe H264EntropyEncoding)
h264Settings_entropyEncoding :: (Maybe H264EntropyEncoding -> f (Maybe H264EntropyEncoding))
-> H264Settings -> f H264Settings
h264Settings_entropyEncoding = (H264Settings -> Maybe H264EntropyEncoding)
-> (H264Settings -> Maybe H264EntropyEncoding -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264EntropyEncoding)
     (Maybe H264EntropyEncoding)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264EntropyEncoding
entropyEncoding :: Maybe H264EntropyEncoding
$sel:entropyEncoding:H264Settings' :: H264Settings -> Maybe H264EntropyEncoding
entropyEncoding} -> Maybe H264EntropyEncoding
entropyEncoding) (\s :: H264Settings
s@H264Settings' {} Maybe H264EntropyEncoding
a -> H264Settings
s {$sel:entropyEncoding:H264Settings' :: Maybe H264EntropyEncoding
entropyEncoding = Maybe H264EntropyEncoding
a} :: H264Settings)

-- | 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.
-- If you are creating your transcoding job specification as a JSON file
-- without the console, use FramerateControl to specify which value the
-- service uses for the frame rate for this output. Choose
-- INITIALIZE_FROM_SOURCE if you want the service to use the frame rate
-- from the input. Choose SPECIFIED if you want the service to use the
-- frame rate you specify in the settings FramerateNumerator and
-- FramerateDenominator.
h264Settings_framerateControl :: Lens.Lens' H264Settings (Prelude.Maybe H264FramerateControl)
h264Settings_framerateControl :: (Maybe H264FramerateControl -> f (Maybe H264FramerateControl))
-> H264Settings -> f H264Settings
h264Settings_framerateControl = (H264Settings -> Maybe H264FramerateControl)
-> (H264Settings -> Maybe H264FramerateControl -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264FramerateControl)
     (Maybe H264FramerateControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264FramerateControl
framerateControl :: Maybe H264FramerateControl
$sel:framerateControl:H264Settings' :: H264Settings -> Maybe H264FramerateControl
framerateControl} -> Maybe H264FramerateControl
framerateControl) (\s :: H264Settings
s@H264Settings' {} Maybe H264FramerateControl
a -> H264Settings
s {$sel:framerateControl:H264Settings' :: Maybe H264FramerateControl
framerateControl = Maybe H264FramerateControl
a} :: H264Settings)

-- | Keep the default value, Auto (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 (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 (H264AdaptiveQuantization) to Off (OFF). Related settings:
-- The value that you choose here applies to the following settings:
-- H264FlickerAdaptiveQuantization, H264SpatialAdaptiveQuantization, and
-- H264TemporalAdaptiveQuantization.
h264Settings_adaptiveQuantization :: Lens.Lens' H264Settings (Prelude.Maybe H264AdaptiveQuantization)
h264Settings_adaptiveQuantization :: (Maybe H264AdaptiveQuantization
 -> f (Maybe H264AdaptiveQuantization))
-> H264Settings -> f H264Settings
h264Settings_adaptiveQuantization = (H264Settings -> Maybe H264AdaptiveQuantization)
-> (H264Settings -> Maybe H264AdaptiveQuantization -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264AdaptiveQuantization)
     (Maybe H264AdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264AdaptiveQuantization
adaptiveQuantization :: Maybe H264AdaptiveQuantization
$sel:adaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264AdaptiveQuantization
adaptiveQuantization} -> Maybe H264AdaptiveQuantization
adaptiveQuantization) (\s :: H264Settings
s@H264Settings' {} Maybe H264AdaptiveQuantization
a -> H264Settings
s {$sel:adaptiveQuantization:H264Settings' :: Maybe H264AdaptiveQuantization
adaptiveQuantization = Maybe H264AdaptiveQuantization
a} :: H264Settings)

-- | 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.
h264Settings_framerateNumerator :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_framerateNumerator :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_framerateNumerator = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
framerateNumerator :: Maybe Natural
$sel:framerateNumerator:H264Settings' :: H264Settings -> Maybe Natural
framerateNumerator} -> Maybe Natural
framerateNumerator) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:framerateNumerator:H264Settings' :: Maybe Natural
framerateNumerator = Maybe Natural
a} :: H264Settings)

-- | If enable, use reference B frames for GOP structures that have B frames
-- > 1.
h264Settings_gopBReference :: Lens.Lens' H264Settings (Prelude.Maybe H264GopBReference)
h264Settings_gopBReference :: (Maybe H264GopBReference -> f (Maybe H264GopBReference))
-> H264Settings -> f H264Settings
h264Settings_gopBReference = (H264Settings -> Maybe H264GopBReference)
-> (H264Settings -> Maybe H264GopBReference -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264GopBReference)
     (Maybe H264GopBReference)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264GopBReference
gopBReference :: Maybe H264GopBReference
$sel:gopBReference:H264Settings' :: H264Settings -> Maybe H264GopBReference
gopBReference} -> Maybe H264GopBReference
gopBReference) (\s :: H264Settings
s@H264Settings' {} Maybe H264GopBReference
a -> H264Settings
s {$sel:gopBReference:H264Settings' :: Maybe H264GopBReference
gopBReference = Maybe H264GopBReference
a} :: H264Settings)

-- | Maximum bitrate in bits\/second. For example, enter five megabits per
-- second as 5000000. Required when Rate control mode is QVBR.
h264Settings_maxBitrate :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_maxBitrate :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_maxBitrate = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
maxBitrate :: Maybe Natural
$sel:maxBitrate:H264Settings' :: H264Settings -> Maybe Natural
maxBitrate} -> Maybe Natural
maxBitrate) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:maxBitrate:H264Settings' :: Maybe Natural
maxBitrate = Maybe Natural
a} :: H264Settings)

-- | Produces a bitstream compliant with SMPTE RP-2027.
h264Settings_syntax :: Lens.Lens' H264Settings (Prelude.Maybe H264Syntax)
h264Settings_syntax :: (Maybe H264Syntax -> f (Maybe H264Syntax))
-> H264Settings -> f H264Settings
h264Settings_syntax = (H264Settings -> Maybe H264Syntax)
-> (H264Settings -> Maybe H264Syntax -> H264Settings)
-> Lens
     H264Settings H264Settings (Maybe H264Syntax) (Maybe H264Syntax)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264Syntax
syntax :: Maybe H264Syntax
$sel:syntax:H264Settings' :: H264Settings -> Maybe H264Syntax
syntax} -> Maybe H264Syntax
syntax) (\s :: H264Settings
s@H264Settings' {} Maybe H264Syntax
a -> H264Settings
s {$sel:syntax:H264Settings' :: Maybe H264Syntax
syntax = Maybe H264Syntax
a} :: H264Settings)

-- | 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 (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.
h264Settings_fieldEncoding :: Lens.Lens' H264Settings (Prelude.Maybe H264FieldEncoding)
h264Settings_fieldEncoding :: (Maybe H264FieldEncoding -> f (Maybe H264FieldEncoding))
-> H264Settings -> f H264Settings
h264Settings_fieldEncoding = (H264Settings -> Maybe H264FieldEncoding)
-> (H264Settings -> Maybe H264FieldEncoding -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264FieldEncoding)
     (Maybe H264FieldEncoding)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264FieldEncoding
fieldEncoding :: Maybe H264FieldEncoding
$sel:fieldEncoding:H264Settings' :: H264Settings -> Maybe H264FieldEncoding
fieldEncoding} -> Maybe H264FieldEncoding
fieldEncoding) (\s :: H264Settings
s@H264Settings' {} Maybe H264FieldEncoding
a -> H264Settings
s {$sel:fieldEncoding:H264Settings' :: Maybe H264FieldEncoding
fieldEncoding = Maybe H264FieldEncoding
a} :: H264Settings)

-- | Frequency of closed GOPs. In streaming applications, it is recommended
-- that this be set to 1 so a decoder joining mid-stream will receive an
-- IDR frame as quickly as possible. Setting this value to 0 will break
-- output segmenting.
h264Settings_gopClosedCadence :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_gopClosedCadence :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_gopClosedCadence = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
gopClosedCadence :: Maybe Natural
$sel:gopClosedCadence:H264Settings' :: H264Settings -> Maybe Natural
gopClosedCadence} -> Maybe Natural
gopClosedCadence) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:gopClosedCadence:H264Settings' :: Maybe Natural
gopClosedCadence = Maybe Natural
a} :: H264Settings)

-- | Required when you set Pixel aspect ratio (parControl) 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.
h264Settings_parDenominator :: Lens.Lens' H264Settings (Prelude.Maybe Prelude.Natural)
h264Settings_parDenominator :: (Maybe Natural -> f (Maybe Natural))
-> H264Settings -> f H264Settings
h264Settings_parDenominator = (H264Settings -> Maybe Natural)
-> (H264Settings -> Maybe Natural -> H264Settings)
-> Lens H264Settings H264Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe Natural
parDenominator :: Maybe Natural
$sel:parDenominator:H264Settings' :: H264Settings -> Maybe Natural
parDenominator} -> Maybe Natural
parDenominator) (\s :: H264Settings
s@H264Settings' {} Maybe Natural
a -> H264Settings
s {$sel:parDenominator:H264Settings' :: Maybe Natural
parDenominator = Maybe Natural
a} :: H264Settings)

-- | Only use this setting when you change the default value, Auto (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 (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 (DISABLED). Related setting:
-- When you enable spatial adaptive quantization, set the value for
-- Adaptive quantization (H264AdaptiveQuantization) 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
-- (H264AdaptiveQuantization) to a value other than AUTO.
h264Settings_spatialAdaptiveQuantization :: Lens.Lens' H264Settings (Prelude.Maybe H264SpatialAdaptiveQuantization)
h264Settings_spatialAdaptiveQuantization :: (Maybe H264SpatialAdaptiveQuantization
 -> f (Maybe H264SpatialAdaptiveQuantization))
-> H264Settings -> f H264Settings
h264Settings_spatialAdaptiveQuantization = (H264Settings -> Maybe H264SpatialAdaptiveQuantization)
-> (H264Settings
    -> Maybe H264SpatialAdaptiveQuantization -> H264Settings)
-> Lens
     H264Settings
     H264Settings
     (Maybe H264SpatialAdaptiveQuantization)
     (Maybe H264SpatialAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H264Settings' {Maybe H264SpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe H264SpatialAdaptiveQuantization
$sel:spatialAdaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264SpatialAdaptiveQuantization
spatialAdaptiveQuantization} -> Maybe H264SpatialAdaptiveQuantization
spatialAdaptiveQuantization) (\s :: H264Settings
s@H264Settings' {} Maybe H264SpatialAdaptiveQuantization
a -> H264Settings
s {$sel:spatialAdaptiveQuantization:H264Settings' :: Maybe H264SpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe H264SpatialAdaptiveQuantization
a} :: H264Settings)

instance Core.FromJSON H264Settings where
  parseJSON :: Value -> Parser H264Settings
parseJSON =
    String
-> (Object -> Parser H264Settings) -> Value -> Parser H264Settings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"H264Settings"
      ( \Object
x ->
          Maybe H264UnregisteredSeiTimecode
-> Maybe H264QualityTuningLevel
-> Maybe H264TemporalAdaptiveQuantization
-> Maybe H264SceneChangeDetect
-> Maybe Natural
-> Maybe H264SlowPal
-> Maybe Natural
-> Maybe Double
-> Maybe Natural
-> Maybe H264GopSizeUnits
-> Maybe Natural
-> Maybe Natural
-> Maybe H264RateControlMode
-> Maybe Natural
-> Maybe H264Telecine
-> Maybe H264DynamicSubGop
-> Maybe Natural
-> Maybe H264InterlaceMode
-> Maybe H264ParControl
-> Maybe H264RepeatPps
-> Maybe H264ScanTypeConversionMode
-> Maybe H264FlickerAdaptiveQuantization
-> Maybe H264QvbrSettings
-> Maybe Natural
-> Maybe H264CodecProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe H264FramerateConversionAlgorithm
-> Maybe H264CodecLevel
-> Maybe H264EntropyEncoding
-> Maybe H264FramerateControl
-> Maybe H264AdaptiveQuantization
-> Maybe Natural
-> Maybe H264GopBReference
-> Maybe Natural
-> Maybe H264Syntax
-> Maybe H264FieldEncoding
-> Maybe Natural
-> Maybe Natural
-> Maybe H264SpatialAdaptiveQuantization
-> H264Settings
H264Settings'
            (Maybe H264UnregisteredSeiTimecode
 -> Maybe H264QualityTuningLevel
 -> Maybe H264TemporalAdaptiveQuantization
 -> Maybe H264SceneChangeDetect
 -> Maybe Natural
 -> Maybe H264SlowPal
 -> Maybe Natural
 -> Maybe Double
 -> Maybe Natural
 -> Maybe H264GopSizeUnits
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe H264RateControlMode
 -> Maybe Natural
 -> Maybe H264Telecine
 -> Maybe H264DynamicSubGop
 -> Maybe Natural
 -> Maybe H264InterlaceMode
 -> Maybe H264ParControl
 -> Maybe H264RepeatPps
 -> Maybe H264ScanTypeConversionMode
 -> Maybe H264FlickerAdaptiveQuantization
 -> Maybe H264QvbrSettings
 -> Maybe Natural
 -> Maybe H264CodecProfile
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe H264FramerateConversionAlgorithm
 -> Maybe H264CodecLevel
 -> Maybe H264EntropyEncoding
 -> Maybe H264FramerateControl
 -> Maybe H264AdaptiveQuantization
 -> Maybe Natural
 -> Maybe H264GopBReference
 -> Maybe Natural
 -> Maybe H264Syntax
 -> Maybe H264FieldEncoding
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe H264SpatialAdaptiveQuantization
 -> H264Settings)
-> Parser (Maybe H264UnregisteredSeiTimecode)
-> Parser
     (Maybe H264QualityTuningLevel
      -> Maybe H264TemporalAdaptiveQuantization
      -> Maybe H264SceneChangeDetect
      -> Maybe Natural
      -> Maybe H264SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe H264UnregisteredSeiTimecode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"unregisteredSeiTimecode")
            Parser
  (Maybe H264QualityTuningLevel
   -> Maybe H264TemporalAdaptiveQuantization
   -> Maybe H264SceneChangeDetect
   -> Maybe Natural
   -> Maybe H264SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264QualityTuningLevel)
-> Parser
     (Maybe H264TemporalAdaptiveQuantization
      -> Maybe H264SceneChangeDetect
      -> Maybe Natural
      -> Maybe H264SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264QualityTuningLevel)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"qualityTuningLevel")
            Parser
  (Maybe H264TemporalAdaptiveQuantization
   -> Maybe H264SceneChangeDetect
   -> Maybe Natural
   -> Maybe H264SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264TemporalAdaptiveQuantization)
-> Parser
     (Maybe H264SceneChangeDetect
      -> Maybe Natural
      -> Maybe H264SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264TemporalAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"temporalAdaptiveQuantization")
            Parser
  (Maybe H264SceneChangeDetect
   -> Maybe Natural
   -> Maybe H264SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264SceneChangeDetect)
-> Parser
     (Maybe Natural
      -> Maybe H264SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264SceneChangeDetect)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"sceneChangeDetect")
            Parser
  (Maybe Natural
   -> Maybe H264SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"hrdBufferInitialFillPercentage")
            Parser
  (Maybe H264SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264SlowPal)
-> Parser
     (Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264SlowPal)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"slowPal")
            Parser
  (Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Double
      -> Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"parNumerator")
            Parser
  (Maybe Double
   -> Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Double)
-> Parser
     (Maybe Natural
      -> Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Double)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"gopSize")
            Parser
  (Maybe Natural
   -> Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"numberBFramesBetweenReferenceFrames")
            Parser
  (Maybe H264GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264GopSizeUnits)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264GopSizeUnits)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"gopSizeUnits")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"hrdBufferSize")
            Parser
  (Maybe Natural
   -> Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264RateControlMode
      -> Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"slices")
            Parser
  (Maybe H264RateControlMode
   -> Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264RateControlMode)
-> Parser
     (Maybe Natural
      -> Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264RateControlMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"rateControlMode")
            Parser
  (Maybe Natural
   -> Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264Telecine
      -> Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"numberReferenceFrames")
            Parser
  (Maybe H264Telecine
   -> Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264Telecine)
-> Parser
     (Maybe H264DynamicSubGop
      -> Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264Telecine)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"telecine")
            Parser
  (Maybe H264DynamicSubGop
   -> Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264DynamicSubGop)
-> Parser
     (Maybe Natural
      -> Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264DynamicSubGop)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"dynamicSubGop")
            Parser
  (Maybe Natural
   -> Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264InterlaceMode
      -> Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"minIInterval")
            Parser
  (Maybe H264InterlaceMode
   -> Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264InterlaceMode)
-> Parser
     (Maybe H264ParControl
      -> Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264InterlaceMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"interlaceMode")
            Parser
  (Maybe H264ParControl
   -> Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264ParControl)
-> Parser
     (Maybe H264RepeatPps
      -> Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264ParControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"parControl")
            Parser
  (Maybe H264RepeatPps
   -> Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264RepeatPps)
-> Parser
     (Maybe H264ScanTypeConversionMode
      -> Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264RepeatPps)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"repeatPps")
            Parser
  (Maybe H264ScanTypeConversionMode
   -> Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264ScanTypeConversionMode)
-> Parser
     (Maybe H264FlickerAdaptiveQuantization
      -> Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264ScanTypeConversionMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"scanTypeConversionMode")
            Parser
  (Maybe H264FlickerAdaptiveQuantization
   -> Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264FlickerAdaptiveQuantization)
-> Parser
     (Maybe H264QvbrSettings
      -> Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264FlickerAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"flickerAdaptiveQuantization")
            Parser
  (Maybe H264QvbrSettings
   -> Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264QvbrSettings)
-> Parser
     (Maybe Natural
      -> Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264QvbrSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"qvbrSettings")
            Parser
  (Maybe Natural
   -> Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"softness")
            Parser
  (Maybe H264CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264CodecProfile)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264CodecProfile)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"codecProfile")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"bitrate")
            Parser
  (Maybe Natural
   -> Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264FramerateConversionAlgorithm
      -> Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateDenominator")
            Parser
  (Maybe H264FramerateConversionAlgorithm
   -> Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264FramerateConversionAlgorithm)
-> Parser
     (Maybe H264CodecLevel
      -> Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264FramerateConversionAlgorithm)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateConversionAlgorithm")
            Parser
  (Maybe H264CodecLevel
   -> Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264CodecLevel)
-> Parser
     (Maybe H264EntropyEncoding
      -> Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264CodecLevel)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"codecLevel")
            Parser
  (Maybe H264EntropyEncoding
   -> Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264EntropyEncoding)
-> Parser
     (Maybe H264FramerateControl
      -> Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264EntropyEncoding)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"entropyEncoding")
            Parser
  (Maybe H264FramerateControl
   -> Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264FramerateControl)
-> Parser
     (Maybe H264AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264FramerateControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateControl")
            Parser
  (Maybe H264AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264AdaptiveQuantization)
-> Parser
     (Maybe Natural
      -> Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264AdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"adaptiveQuantization")
            Parser
  (Maybe Natural
   -> Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264GopBReference
      -> Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateNumerator")
            Parser
  (Maybe H264GopBReference
   -> Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264GopBReference)
-> Parser
     (Maybe Natural
      -> Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264GopBReference)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"gopBReference")
            Parser
  (Maybe Natural
   -> Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H264Syntax
      -> Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"maxBitrate")
            Parser
  (Maybe H264Syntax
   -> Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264Syntax)
-> Parser
     (Maybe H264FieldEncoding
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264Syntax)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"syntax")
            Parser
  (Maybe H264FieldEncoding
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe H264FieldEncoding)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization
      -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264FieldEncoding)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"fieldEncoding")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization
   -> H264Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe H264SpatialAdaptiveQuantization -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"gopClosedCadence")
            Parser
  (Maybe Natural
   -> Maybe H264SpatialAdaptiveQuantization -> H264Settings)
-> Parser (Maybe Natural)
-> Parser (Maybe H264SpatialAdaptiveQuantization -> H264Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"parDenominator")
            Parser (Maybe H264SpatialAdaptiveQuantization -> H264Settings)
-> Parser (Maybe H264SpatialAdaptiveQuantization)
-> Parser H264Settings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H264SpatialAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"spatialAdaptiveQuantization")
      )

instance Prelude.Hashable H264Settings

instance Prelude.NFData H264Settings

instance Core.ToJSON H264Settings where
  toJSON :: H264Settings -> Value
toJSON H264Settings' {Maybe Double
Maybe Natural
Maybe H264AdaptiveQuantization
Maybe H264CodecLevel
Maybe H264CodecProfile
Maybe H264DynamicSubGop
Maybe H264EntropyEncoding
Maybe H264FieldEncoding
Maybe H264FlickerAdaptiveQuantization
Maybe H264FramerateControl
Maybe H264FramerateConversionAlgorithm
Maybe H264GopBReference
Maybe H264GopSizeUnits
Maybe H264InterlaceMode
Maybe H264ParControl
Maybe H264QualityTuningLevel
Maybe H264QvbrSettings
Maybe H264RateControlMode
Maybe H264RepeatPps
Maybe H264ScanTypeConversionMode
Maybe H264SceneChangeDetect
Maybe H264SlowPal
Maybe H264SpatialAdaptiveQuantization
Maybe H264Syntax
Maybe H264Telecine
Maybe H264TemporalAdaptiveQuantization
Maybe H264UnregisteredSeiTimecode
spatialAdaptiveQuantization :: Maybe H264SpatialAdaptiveQuantization
parDenominator :: Maybe Natural
gopClosedCadence :: Maybe Natural
fieldEncoding :: Maybe H264FieldEncoding
syntax :: Maybe H264Syntax
maxBitrate :: Maybe Natural
gopBReference :: Maybe H264GopBReference
framerateNumerator :: Maybe Natural
adaptiveQuantization :: Maybe H264AdaptiveQuantization
framerateControl :: Maybe H264FramerateControl
entropyEncoding :: Maybe H264EntropyEncoding
codecLevel :: Maybe H264CodecLevel
framerateConversionAlgorithm :: Maybe H264FramerateConversionAlgorithm
framerateDenominator :: Maybe Natural
bitrate :: Maybe Natural
codecProfile :: Maybe H264CodecProfile
softness :: Maybe Natural
qvbrSettings :: Maybe H264QvbrSettings
flickerAdaptiveQuantization :: Maybe H264FlickerAdaptiveQuantization
scanTypeConversionMode :: Maybe H264ScanTypeConversionMode
repeatPps :: Maybe H264RepeatPps
parControl :: Maybe H264ParControl
interlaceMode :: Maybe H264InterlaceMode
minIInterval :: Maybe Natural
dynamicSubGop :: Maybe H264DynamicSubGop
telecine :: Maybe H264Telecine
numberReferenceFrames :: Maybe Natural
rateControlMode :: Maybe H264RateControlMode
slices :: Maybe Natural
hrdBufferSize :: Maybe Natural
gopSizeUnits :: Maybe H264GopSizeUnits
numberBFramesBetweenReferenceFrames :: Maybe Natural
gopSize :: Maybe Double
parNumerator :: Maybe Natural
slowPal :: Maybe H264SlowPal
hrdBufferInitialFillPercentage :: Maybe Natural
sceneChangeDetect :: Maybe H264SceneChangeDetect
temporalAdaptiveQuantization :: Maybe H264TemporalAdaptiveQuantization
qualityTuningLevel :: Maybe H264QualityTuningLevel
unregisteredSeiTimecode :: Maybe H264UnregisteredSeiTimecode
$sel:spatialAdaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264SpatialAdaptiveQuantization
$sel:parDenominator:H264Settings' :: H264Settings -> Maybe Natural
$sel:gopClosedCadence:H264Settings' :: H264Settings -> Maybe Natural
$sel:fieldEncoding:H264Settings' :: H264Settings -> Maybe H264FieldEncoding
$sel:syntax:H264Settings' :: H264Settings -> Maybe H264Syntax
$sel:maxBitrate:H264Settings' :: H264Settings -> Maybe Natural
$sel:gopBReference:H264Settings' :: H264Settings -> Maybe H264GopBReference
$sel:framerateNumerator:H264Settings' :: H264Settings -> Maybe Natural
$sel:adaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264AdaptiveQuantization
$sel:framerateControl:H264Settings' :: H264Settings -> Maybe H264FramerateControl
$sel:entropyEncoding:H264Settings' :: H264Settings -> Maybe H264EntropyEncoding
$sel:codecLevel:H264Settings' :: H264Settings -> Maybe H264CodecLevel
$sel:framerateConversionAlgorithm:H264Settings' :: H264Settings -> Maybe H264FramerateConversionAlgorithm
$sel:framerateDenominator:H264Settings' :: H264Settings -> Maybe Natural
$sel:bitrate:H264Settings' :: H264Settings -> Maybe Natural
$sel:codecProfile:H264Settings' :: H264Settings -> Maybe H264CodecProfile
$sel:softness:H264Settings' :: H264Settings -> Maybe Natural
$sel:qvbrSettings:H264Settings' :: H264Settings -> Maybe H264QvbrSettings
$sel:flickerAdaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264FlickerAdaptiveQuantization
$sel:scanTypeConversionMode:H264Settings' :: H264Settings -> Maybe H264ScanTypeConversionMode
$sel:repeatPps:H264Settings' :: H264Settings -> Maybe H264RepeatPps
$sel:parControl:H264Settings' :: H264Settings -> Maybe H264ParControl
$sel:interlaceMode:H264Settings' :: H264Settings -> Maybe H264InterlaceMode
$sel:minIInterval:H264Settings' :: H264Settings -> Maybe Natural
$sel:dynamicSubGop:H264Settings' :: H264Settings -> Maybe H264DynamicSubGop
$sel:telecine:H264Settings' :: H264Settings -> Maybe H264Telecine
$sel:numberReferenceFrames:H264Settings' :: H264Settings -> Maybe Natural
$sel:rateControlMode:H264Settings' :: H264Settings -> Maybe H264RateControlMode
$sel:slices:H264Settings' :: H264Settings -> Maybe Natural
$sel:hrdBufferSize:H264Settings' :: H264Settings -> Maybe Natural
$sel:gopSizeUnits:H264Settings' :: H264Settings -> Maybe H264GopSizeUnits
$sel:numberBFramesBetweenReferenceFrames:H264Settings' :: H264Settings -> Maybe Natural
$sel:gopSize:H264Settings' :: H264Settings -> Maybe Double
$sel:parNumerator:H264Settings' :: H264Settings -> Maybe Natural
$sel:slowPal:H264Settings' :: H264Settings -> Maybe H264SlowPal
$sel:hrdBufferInitialFillPercentage:H264Settings' :: H264Settings -> Maybe Natural
$sel:sceneChangeDetect:H264Settings' :: H264Settings -> Maybe H264SceneChangeDetect
$sel:temporalAdaptiveQuantization:H264Settings' :: H264Settings -> Maybe H264TemporalAdaptiveQuantization
$sel:qualityTuningLevel:H264Settings' :: H264Settings -> Maybe H264QualityTuningLevel
$sel:unregisteredSeiTimecode:H264Settings' :: H264Settings -> Maybe H264UnregisteredSeiTimecode
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"unregisteredSeiTimecode" Text -> H264UnregisteredSeiTimecode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264UnregisteredSeiTimecode -> Pair)
-> Maybe H264UnregisteredSeiTimecode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264UnregisteredSeiTimecode
unregisteredSeiTimecode,
            (Text
"qualityTuningLevel" Text -> H264QualityTuningLevel -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264QualityTuningLevel -> Pair)
-> Maybe H264QualityTuningLevel -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264QualityTuningLevel
qualityTuningLevel,
            (Text
"temporalAdaptiveQuantization" Text -> H264TemporalAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264TemporalAdaptiveQuantization -> Pair)
-> Maybe H264TemporalAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264TemporalAdaptiveQuantization
temporalAdaptiveQuantization,
            (Text
"sceneChangeDetect" Text -> H264SceneChangeDetect -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264SceneChangeDetect -> Pair)
-> Maybe H264SceneChangeDetect -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264SceneChangeDetect
sceneChangeDetect,
            (Text
"hrdBufferInitialFillPercentage" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
hrdBufferInitialFillPercentage,
            (Text
"slowPal" Text -> H264SlowPal -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264SlowPal -> Pair) -> Maybe H264SlowPal -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264SlowPal
slowPal,
            (Text
"parNumerator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
parNumerator,
            (Text
"gopSize" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Double
gopSize,
            (Text
"numberBFramesBetweenReferenceFrames" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
numberBFramesBetweenReferenceFrames,
            (Text
"gopSizeUnits" Text -> H264GopSizeUnits -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264GopSizeUnits -> Pair) -> Maybe H264GopSizeUnits -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264GopSizeUnits
gopSizeUnits,
            (Text
"hrdBufferSize" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
hrdBufferSize,
            (Text
"slices" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
slices,
            (Text
"rateControlMode" Text -> H264RateControlMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264RateControlMode -> Pair)
-> Maybe H264RateControlMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264RateControlMode
rateControlMode,
            (Text
"numberReferenceFrames" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
numberReferenceFrames,
            (Text
"telecine" Text -> H264Telecine -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264Telecine -> Pair) -> Maybe H264Telecine -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264Telecine
telecine,
            (Text
"dynamicSubGop" Text -> H264DynamicSubGop -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264DynamicSubGop -> Pair)
-> Maybe H264DynamicSubGop -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264DynamicSubGop
dynamicSubGop,
            (Text
"minIInterval" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
minIInterval,
            (Text
"interlaceMode" Text -> H264InterlaceMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264InterlaceMode -> Pair)
-> Maybe H264InterlaceMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264InterlaceMode
interlaceMode,
            (Text
"parControl" Text -> H264ParControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264ParControl -> Pair) -> Maybe H264ParControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264ParControl
parControl,
            (Text
"repeatPps" Text -> H264RepeatPps -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264RepeatPps -> Pair) -> Maybe H264RepeatPps -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264RepeatPps
repeatPps,
            (Text
"scanTypeConversionMode" Text -> H264ScanTypeConversionMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264ScanTypeConversionMode -> Pair)
-> Maybe H264ScanTypeConversionMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264ScanTypeConversionMode
scanTypeConversionMode,
            (Text
"flickerAdaptiveQuantization" Text -> H264FlickerAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264FlickerAdaptiveQuantization -> Pair)
-> Maybe H264FlickerAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264FlickerAdaptiveQuantization
flickerAdaptiveQuantization,
            (Text
"qvbrSettings" Text -> H264QvbrSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264QvbrSettings -> Pair) -> Maybe H264QvbrSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264QvbrSettings
qvbrSettings,
            (Text
"softness" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
softness,
            (Text
"codecProfile" Text -> H264CodecProfile -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264CodecProfile -> Pair) -> Maybe H264CodecProfile -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264CodecProfile
codecProfile,
            (Text
"bitrate" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
bitrate,
            (Text
"framerateDenominator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
framerateDenominator,
            (Text
"framerateConversionAlgorithm" Text -> H264FramerateConversionAlgorithm -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264FramerateConversionAlgorithm -> Pair)
-> Maybe H264FramerateConversionAlgorithm -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264FramerateConversionAlgorithm
framerateConversionAlgorithm,
            (Text
"codecLevel" Text -> H264CodecLevel -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264CodecLevel -> Pair) -> Maybe H264CodecLevel -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264CodecLevel
codecLevel,
            (Text
"entropyEncoding" Text -> H264EntropyEncoding -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264EntropyEncoding -> Pair)
-> Maybe H264EntropyEncoding -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264EntropyEncoding
entropyEncoding,
            (Text
"framerateControl" Text -> H264FramerateControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264FramerateControl -> Pair)
-> Maybe H264FramerateControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264FramerateControl
framerateControl,
            (Text
"adaptiveQuantization" Text -> H264AdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264AdaptiveQuantization -> Pair)
-> Maybe H264AdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264AdaptiveQuantization
adaptiveQuantization,
            (Text
"framerateNumerator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
framerateNumerator,
            (Text
"gopBReference" Text -> H264GopBReference -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264GopBReference -> Pair)
-> Maybe H264GopBReference -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264GopBReference
gopBReference,
            (Text
"maxBitrate" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxBitrate,
            (Text
"syntax" Text -> H264Syntax -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264Syntax -> Pair) -> Maybe H264Syntax -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264Syntax
syntax,
            (Text
"fieldEncoding" Text -> H264FieldEncoding -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H264FieldEncoding -> Pair)
-> Maybe H264FieldEncoding -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264FieldEncoding
fieldEncoding,
            (Text
"gopClosedCadence" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
gopClosedCadence,
            (Text
"parDenominator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
parDenominator,
            (Text
"spatialAdaptiveQuantization" Text -> H264SpatialAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H264SpatialAdaptiveQuantization -> Pair)
-> Maybe H264SpatialAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H264SpatialAdaptiveQuantization
spatialAdaptiveQuantization
          ]
      )