{-# 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.Mpeg2Settings
-- 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.Mpeg2Settings where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaConvert.Types.Mpeg2AdaptiveQuantization
import Amazonka.MediaConvert.Types.Mpeg2CodecLevel
import Amazonka.MediaConvert.Types.Mpeg2CodecProfile
import Amazonka.MediaConvert.Types.Mpeg2DynamicSubGop
import Amazonka.MediaConvert.Types.Mpeg2FramerateControl
import Amazonka.MediaConvert.Types.Mpeg2FramerateConversionAlgorithm
import Amazonka.MediaConvert.Types.Mpeg2GopSizeUnits
import Amazonka.MediaConvert.Types.Mpeg2InterlaceMode
import Amazonka.MediaConvert.Types.Mpeg2IntraDcPrecision
import Amazonka.MediaConvert.Types.Mpeg2ParControl
import Amazonka.MediaConvert.Types.Mpeg2QualityTuningLevel
import Amazonka.MediaConvert.Types.Mpeg2RateControlMode
import Amazonka.MediaConvert.Types.Mpeg2ScanTypeConversionMode
import Amazonka.MediaConvert.Types.Mpeg2SceneChangeDetect
import Amazonka.MediaConvert.Types.Mpeg2SlowPal
import Amazonka.MediaConvert.Types.Mpeg2SpatialAdaptiveQuantization
import Amazonka.MediaConvert.Types.Mpeg2Syntax
import Amazonka.MediaConvert.Types.Mpeg2Telecine
import Amazonka.MediaConvert.Types.Mpeg2TemporalAdaptiveQuantization
import qualified Amazonka.Prelude as Prelude

-- | Required when you set (Codec) under (VideoDescription)>(CodecSettings)
-- to the value MPEG2.
--
-- /See:/ 'newMpeg2Settings' smart constructor.
data Mpeg2Settings = Mpeg2Settings'
  { -- | 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.
    Mpeg2Settings -> Maybe Mpeg2QualityTuningLevel
qualityTuningLevel :: Prelude.Maybe Mpeg2QualityTuningLevel,
    -- | Keep the default value, Enabled (ENABLED), 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 disable this feature. Related setting: When you enable
    -- temporal quantization, adjust the strength of the filter with the
    -- setting Adaptive quantization (adaptiveQuantization).
    Mpeg2Settings -> Maybe Mpeg2TemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Prelude.Maybe Mpeg2TemporalAdaptiveQuantization,
    -- | Enable this setting to insert I-frames at scene changes that the service
    -- automatically detects. This improves video quality and is enabled by
    -- default.
    Mpeg2Settings -> Maybe Mpeg2SceneChangeDetect
sceneChangeDetect :: Prelude.Maybe Mpeg2SceneChangeDetect,
    -- | Percentage of the buffer that should initially be filled (HRD buffer
    -- model).
    Mpeg2Settings -> 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.
    Mpeg2Settings -> Maybe Mpeg2SlowPal
slowPal :: Prelude.Maybe Mpeg2SlowPal,
    -- | 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.
    Mpeg2Settings -> Maybe Natural
parNumerator :: Prelude.Maybe Prelude.Natural,
    -- | Specify the interval between keyframes, in seconds or frames, for this
    -- output. Default: 12 Related settings: When you specify the GOP size in
    -- seconds, set GOP mode control (GopSizeUnits) to Specified, seconds
    -- (SECONDS). The default value for GOP mode control (GopSizeUnits) is
    -- Frames (FRAMES).
    Mpeg2Settings -> 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.
    Mpeg2Settings -> Maybe Natural
numberBFramesBetweenReferenceFrames :: Prelude.Maybe Prelude.Natural,
    -- | Specify the units for GOP size (GopSize). If you don\'t specify a value
    -- here, by default the encoder measures GOP size in frames.
    Mpeg2Settings -> Maybe Mpeg2GopSizeUnits
gopSizeUnits :: Prelude.Maybe Mpeg2GopSizeUnits,
    -- | Size of buffer (HRD buffer model) in bits. For example, enter five
    -- megabits as 5000000.
    Mpeg2Settings -> Maybe Natural
hrdBufferSize :: Prelude.Maybe Prelude.Natural,
    -- | Use Rate control mode (Mpeg2RateControlMode) to specify whether the
    -- bitrate is variable (vbr) or constant (cbr).
    Mpeg2Settings -> Maybe Mpeg2RateControlMode
rateControlMode :: Prelude.Maybe Mpeg2RateControlMode,
    -- | 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.
    Mpeg2Settings -> Maybe Mpeg2Telecine
telecine :: Prelude.Maybe Mpeg2Telecine,
    -- | Use Intra DC precision (Mpeg2IntraDcPrecision) to set quantization
    -- precision for intra-block DC coefficients. If you choose the value auto,
    -- the service will automatically select the precision based on the
    -- per-frame compression ratio.
    Mpeg2Settings -> Maybe Mpeg2IntraDcPrecision
intraDcPrecision :: Prelude.Maybe Mpeg2IntraDcPrecision,
    -- | 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).
    Mpeg2Settings -> Maybe Mpeg2DynamicSubGop
dynamicSubGop :: Prelude.Maybe Mpeg2DynamicSubGop,
    -- | 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
    Mpeg2Settings -> 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.
    Mpeg2Settings -> Maybe Mpeg2InterlaceMode
interlaceMode :: Prelude.Maybe Mpeg2InterlaceMode,
    -- | 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.
    Mpeg2Settings -> Maybe Mpeg2ParControl
parControl :: Prelude.Maybe Mpeg2ParControl,
    -- | 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).
    Mpeg2Settings -> Maybe Mpeg2ScanTypeConversionMode
scanTypeConversionMode :: Prelude.Maybe Mpeg2ScanTypeConversionMode,
    -- | 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, to use the AWS Elemental default matrices. 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.
    Mpeg2Settings -> Maybe Natural
softness :: Prelude.Maybe Prelude.Natural,
    -- | Use Profile (Mpeg2CodecProfile) to set the MPEG-2 profile for the video
    -- output.
    Mpeg2Settings -> Maybe Mpeg2CodecProfile
codecProfile :: Prelude.Maybe Mpeg2CodecProfile,
    -- | 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.
    Mpeg2Settings -> 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.
    Mpeg2Settings -> 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.
    Mpeg2Settings -> Maybe Mpeg2FramerateConversionAlgorithm
framerateConversionAlgorithm :: Prelude.Maybe Mpeg2FramerateConversionAlgorithm,
    -- | Use Level (Mpeg2CodecLevel) to set the MPEG-2 level for the video
    -- output.
    Mpeg2Settings -> Maybe Mpeg2CodecLevel
codecLevel :: Prelude.Maybe Mpeg2CodecLevel,
    -- | 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.
    Mpeg2Settings -> Maybe Mpeg2FramerateControl
framerateControl :: Prelude.Maybe Mpeg2FramerateControl,
    -- | Specify the strength of any adaptive quantization filters that you
    -- enable. The value that you choose here applies to the following
    -- settings: Spatial adaptive quantization (spatialAdaptiveQuantization),
    -- and Temporal adaptive quantization (temporalAdaptiveQuantization).
    Mpeg2Settings -> Maybe Mpeg2AdaptiveQuantization
adaptiveQuantization :: Prelude.Maybe Mpeg2AdaptiveQuantization,
    -- | 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.
    Mpeg2Settings -> Maybe Natural
framerateNumerator :: Prelude.Maybe Prelude.Natural,
    -- | Maximum bitrate in bits\/second. For example, enter five megabits per
    -- second as 5000000.
    Mpeg2Settings -> Maybe Natural
maxBitrate :: Prelude.Maybe Prelude.Natural,
    -- | Specify whether this output\'s video uses the D10 syntax. Keep the
    -- default value to not use the syntax. Related settings: When you choose
    -- D10 (D_10) for your MXF profile (profile), you must also set this value
    -- to to D10 (D_10).
    Mpeg2Settings -> Maybe Mpeg2Syntax
syntax :: Prelude.Maybe Mpeg2Syntax,
    -- | 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.
    Mpeg2Settings -> 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.
    Mpeg2Settings -> Maybe Natural
parDenominator :: Prelude.Maybe Prelude.Natural,
    -- | Keep the default value, Enabled (ENABLED), 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
    -- disable this feature. Related setting: When you enable spatial adaptive
    -- quantization, set the value for Adaptive quantization
    -- (adaptiveQuantization) 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.
    Mpeg2Settings -> Maybe Mpeg2SpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Prelude.Maybe Mpeg2SpatialAdaptiveQuantization
  }
  deriving (Mpeg2Settings -> Mpeg2Settings -> Bool
(Mpeg2Settings -> Mpeg2Settings -> Bool)
-> (Mpeg2Settings -> Mpeg2Settings -> Bool) -> Eq Mpeg2Settings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Mpeg2Settings -> Mpeg2Settings -> Bool
$c/= :: Mpeg2Settings -> Mpeg2Settings -> Bool
== :: Mpeg2Settings -> Mpeg2Settings -> Bool
$c== :: Mpeg2Settings -> Mpeg2Settings -> Bool
Prelude.Eq, ReadPrec [Mpeg2Settings]
ReadPrec Mpeg2Settings
Int -> ReadS Mpeg2Settings
ReadS [Mpeg2Settings]
(Int -> ReadS Mpeg2Settings)
-> ReadS [Mpeg2Settings]
-> ReadPrec Mpeg2Settings
-> ReadPrec [Mpeg2Settings]
-> Read Mpeg2Settings
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Mpeg2Settings]
$creadListPrec :: ReadPrec [Mpeg2Settings]
readPrec :: ReadPrec Mpeg2Settings
$creadPrec :: ReadPrec Mpeg2Settings
readList :: ReadS [Mpeg2Settings]
$creadList :: ReadS [Mpeg2Settings]
readsPrec :: Int -> ReadS Mpeg2Settings
$creadsPrec :: Int -> ReadS Mpeg2Settings
Prelude.Read, Int -> Mpeg2Settings -> ShowS
[Mpeg2Settings] -> ShowS
Mpeg2Settings -> String
(Int -> Mpeg2Settings -> ShowS)
-> (Mpeg2Settings -> String)
-> ([Mpeg2Settings] -> ShowS)
-> Show Mpeg2Settings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Mpeg2Settings] -> ShowS
$cshowList :: [Mpeg2Settings] -> ShowS
show :: Mpeg2Settings -> String
$cshow :: Mpeg2Settings -> String
showsPrec :: Int -> Mpeg2Settings -> ShowS
$cshowsPrec :: Int -> Mpeg2Settings -> ShowS
Prelude.Show, (forall x. Mpeg2Settings -> Rep Mpeg2Settings x)
-> (forall x. Rep Mpeg2Settings x -> Mpeg2Settings)
-> Generic Mpeg2Settings
forall x. Rep Mpeg2Settings x -> Mpeg2Settings
forall x. Mpeg2Settings -> Rep Mpeg2Settings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Mpeg2Settings x -> Mpeg2Settings
$cfrom :: forall x. Mpeg2Settings -> Rep Mpeg2Settings x
Prelude.Generic)

-- |
-- Create a value of 'Mpeg2Settings' 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:
--
-- 'qualityTuningLevel', 'mpeg2Settings_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', 'mpeg2Settings_temporalAdaptiveQuantization' - Keep the default value, Enabled (ENABLED), 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 disable this feature. Related setting: When you enable
-- temporal quantization, adjust the strength of the filter with the
-- setting Adaptive quantization (adaptiveQuantization).
--
-- 'sceneChangeDetect', 'mpeg2Settings_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.
--
-- 'hrdBufferInitialFillPercentage', 'mpeg2Settings_hrdBufferInitialFillPercentage' - Percentage of the buffer that should initially be filled (HRD buffer
-- model).
--
-- 'slowPal', 'mpeg2Settings_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', 'mpeg2Settings_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', 'mpeg2Settings_gopSize' - Specify the interval between keyframes, in seconds or frames, for this
-- output. Default: 12 Related settings: When you specify the GOP size in
-- seconds, set GOP mode control (GopSizeUnits) to Specified, seconds
-- (SECONDS). The default value for GOP mode control (GopSizeUnits) is
-- Frames (FRAMES).
--
-- 'numberBFramesBetweenReferenceFrames', 'mpeg2Settings_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', 'mpeg2Settings_gopSizeUnits' - Specify the units for GOP size (GopSize). If you don\'t specify a value
-- here, by default the encoder measures GOP size in frames.
--
-- 'hrdBufferSize', 'mpeg2Settings_hrdBufferSize' - Size of buffer (HRD buffer model) in bits. For example, enter five
-- megabits as 5000000.
--
-- 'rateControlMode', 'mpeg2Settings_rateControlMode' - Use Rate control mode (Mpeg2RateControlMode) to specify whether the
-- bitrate is variable (vbr) or constant (cbr).
--
-- 'telecine', 'mpeg2Settings_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.
--
-- 'intraDcPrecision', 'mpeg2Settings_intraDcPrecision' - Use Intra DC precision (Mpeg2IntraDcPrecision) to set quantization
-- precision for intra-block DC coefficients. If you choose the value auto,
-- the service will automatically select the precision based on the
-- per-frame compression ratio.
--
-- 'dynamicSubGop', 'mpeg2Settings_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', 'mpeg2Settings_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', 'mpeg2Settings_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', 'mpeg2Settings_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.
--
-- 'scanTypeConversionMode', 'mpeg2Settings_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).
--
-- 'softness', 'mpeg2Settings_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, to use the AWS Elemental default matrices. 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', 'mpeg2Settings_codecProfile' - Use Profile (Mpeg2CodecProfile) to set the MPEG-2 profile for the video
-- output.
--
-- 'bitrate', 'mpeg2Settings_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', 'mpeg2Settings_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', 'mpeg2Settings_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', 'mpeg2Settings_codecLevel' - Use Level (Mpeg2CodecLevel) to set the MPEG-2 level for the video
-- output.
--
-- 'framerateControl', 'mpeg2Settings_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', 'mpeg2Settings_adaptiveQuantization' - Specify the strength of any adaptive quantization filters that you
-- enable. The value that you choose here applies to the following
-- settings: Spatial adaptive quantization (spatialAdaptiveQuantization),
-- and Temporal adaptive quantization (temporalAdaptiveQuantization).
--
-- 'framerateNumerator', 'mpeg2Settings_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.
--
-- 'maxBitrate', 'mpeg2Settings_maxBitrate' - Maximum bitrate in bits\/second. For example, enter five megabits per
-- second as 5000000.
--
-- 'syntax', 'mpeg2Settings_syntax' - Specify whether this output\'s video uses the D10 syntax. Keep the
-- default value to not use the syntax. Related settings: When you choose
-- D10 (D_10) for your MXF profile (profile), you must also set this value
-- to to D10 (D_10).
--
-- 'gopClosedCadence', 'mpeg2Settings_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', 'mpeg2Settings_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', 'mpeg2Settings_spatialAdaptiveQuantization' - Keep the default value, Enabled (ENABLED), 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
-- disable this feature. Related setting: When you enable spatial adaptive
-- quantization, set the value for Adaptive quantization
-- (adaptiveQuantization) 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.
newMpeg2Settings ::
  Mpeg2Settings
newMpeg2Settings :: Mpeg2Settings
newMpeg2Settings =
  Mpeg2Settings' :: Maybe Mpeg2QualityTuningLevel
-> Maybe Mpeg2TemporalAdaptiveQuantization
-> Maybe Mpeg2SceneChangeDetect
-> Maybe Natural
-> Maybe Mpeg2SlowPal
-> Maybe Natural
-> Maybe Double
-> Maybe Natural
-> Maybe Mpeg2GopSizeUnits
-> Maybe Natural
-> Maybe Mpeg2RateControlMode
-> Maybe Mpeg2Telecine
-> Maybe Mpeg2IntraDcPrecision
-> Maybe Mpeg2DynamicSubGop
-> Maybe Natural
-> Maybe Mpeg2InterlaceMode
-> Maybe Mpeg2ParControl
-> Maybe Mpeg2ScanTypeConversionMode
-> Maybe Natural
-> Maybe Mpeg2CodecProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe Mpeg2FramerateConversionAlgorithm
-> Maybe Mpeg2CodecLevel
-> Maybe Mpeg2FramerateControl
-> Maybe Mpeg2AdaptiveQuantization
-> Maybe Natural
-> Maybe Natural
-> Maybe Mpeg2Syntax
-> Maybe Natural
-> Maybe Natural
-> Maybe Mpeg2SpatialAdaptiveQuantization
-> Mpeg2Settings
Mpeg2Settings'
    { $sel:qualityTuningLevel:Mpeg2Settings' :: Maybe Mpeg2QualityTuningLevel
qualityTuningLevel =
        Maybe Mpeg2QualityTuningLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:temporalAdaptiveQuantization:Mpeg2Settings' :: Maybe Mpeg2TemporalAdaptiveQuantization
temporalAdaptiveQuantization = Maybe Mpeg2TemporalAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:sceneChangeDetect:Mpeg2Settings' :: Maybe Mpeg2SceneChangeDetect
sceneChangeDetect = Maybe Mpeg2SceneChangeDetect
forall a. Maybe a
Prelude.Nothing,
      $sel:hrdBufferInitialFillPercentage:Mpeg2Settings' :: Maybe Natural
hrdBufferInitialFillPercentage = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:slowPal:Mpeg2Settings' :: Maybe Mpeg2SlowPal
slowPal = Maybe Mpeg2SlowPal
forall a. Maybe a
Prelude.Nothing,
      $sel:parNumerator:Mpeg2Settings' :: Maybe Natural
parNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopSize:Mpeg2Settings' :: Maybe Double
gopSize = Maybe Double
forall a. Maybe a
Prelude.Nothing,
      $sel:numberBFramesBetweenReferenceFrames:Mpeg2Settings' :: Maybe Natural
numberBFramesBetweenReferenceFrames =
        Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopSizeUnits:Mpeg2Settings' :: Maybe Mpeg2GopSizeUnits
gopSizeUnits = Maybe Mpeg2GopSizeUnits
forall a. Maybe a
Prelude.Nothing,
      $sel:hrdBufferSize:Mpeg2Settings' :: Maybe Natural
hrdBufferSize = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:rateControlMode:Mpeg2Settings' :: Maybe Mpeg2RateControlMode
rateControlMode = Maybe Mpeg2RateControlMode
forall a. Maybe a
Prelude.Nothing,
      $sel:telecine:Mpeg2Settings' :: Maybe Mpeg2Telecine
telecine = Maybe Mpeg2Telecine
forall a. Maybe a
Prelude.Nothing,
      $sel:intraDcPrecision:Mpeg2Settings' :: Maybe Mpeg2IntraDcPrecision
intraDcPrecision = Maybe Mpeg2IntraDcPrecision
forall a. Maybe a
Prelude.Nothing,
      $sel:dynamicSubGop:Mpeg2Settings' :: Maybe Mpeg2DynamicSubGop
dynamicSubGop = Maybe Mpeg2DynamicSubGop
forall a. Maybe a
Prelude.Nothing,
      $sel:minIInterval:Mpeg2Settings' :: Maybe Natural
minIInterval = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:interlaceMode:Mpeg2Settings' :: Maybe Mpeg2InterlaceMode
interlaceMode = Maybe Mpeg2InterlaceMode
forall a. Maybe a
Prelude.Nothing,
      $sel:parControl:Mpeg2Settings' :: Maybe Mpeg2ParControl
parControl = Maybe Mpeg2ParControl
forall a. Maybe a
Prelude.Nothing,
      $sel:scanTypeConversionMode:Mpeg2Settings' :: Maybe Mpeg2ScanTypeConversionMode
scanTypeConversionMode = Maybe Mpeg2ScanTypeConversionMode
forall a. Maybe a
Prelude.Nothing,
      $sel:softness:Mpeg2Settings' :: Maybe Natural
softness = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:codecProfile:Mpeg2Settings' :: Maybe Mpeg2CodecProfile
codecProfile = Maybe Mpeg2CodecProfile
forall a. Maybe a
Prelude.Nothing,
      $sel:bitrate:Mpeg2Settings' :: Maybe Natural
bitrate = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateDenominator:Mpeg2Settings' :: Maybe Natural
framerateDenominator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateConversionAlgorithm:Mpeg2Settings' :: Maybe Mpeg2FramerateConversionAlgorithm
framerateConversionAlgorithm = Maybe Mpeg2FramerateConversionAlgorithm
forall a. Maybe a
Prelude.Nothing,
      $sel:codecLevel:Mpeg2Settings' :: Maybe Mpeg2CodecLevel
codecLevel = Maybe Mpeg2CodecLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateControl:Mpeg2Settings' :: Maybe Mpeg2FramerateControl
framerateControl = Maybe Mpeg2FramerateControl
forall a. Maybe a
Prelude.Nothing,
      $sel:adaptiveQuantization:Mpeg2Settings' :: Maybe Mpeg2AdaptiveQuantization
adaptiveQuantization = Maybe Mpeg2AdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateNumerator:Mpeg2Settings' :: Maybe Natural
framerateNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:maxBitrate:Mpeg2Settings' :: Maybe Natural
maxBitrate = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:syntax:Mpeg2Settings' :: Maybe Mpeg2Syntax
syntax = Maybe Mpeg2Syntax
forall a. Maybe a
Prelude.Nothing,
      $sel:gopClosedCadence:Mpeg2Settings' :: Maybe Natural
gopClosedCadence = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:parDenominator:Mpeg2Settings' :: Maybe Natural
parDenominator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:spatialAdaptiveQuantization:Mpeg2Settings' :: Maybe Mpeg2SpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe Mpeg2SpatialAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing
    }

-- | 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.
mpeg2Settings_qualityTuningLevel :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2QualityTuningLevel)
mpeg2Settings_qualityTuningLevel :: (Maybe Mpeg2QualityTuningLevel
 -> f (Maybe Mpeg2QualityTuningLevel))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_qualityTuningLevel = (Mpeg2Settings -> Maybe Mpeg2QualityTuningLevel)
-> (Mpeg2Settings
    -> Maybe Mpeg2QualityTuningLevel -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2QualityTuningLevel)
     (Maybe Mpeg2QualityTuningLevel)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2QualityTuningLevel
qualityTuningLevel :: Maybe Mpeg2QualityTuningLevel
$sel:qualityTuningLevel:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2QualityTuningLevel
qualityTuningLevel} -> Maybe Mpeg2QualityTuningLevel
qualityTuningLevel) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2QualityTuningLevel
a -> Mpeg2Settings
s {$sel:qualityTuningLevel:Mpeg2Settings' :: Maybe Mpeg2QualityTuningLevel
qualityTuningLevel = Maybe Mpeg2QualityTuningLevel
a} :: Mpeg2Settings)

-- | Keep the default value, Enabled (ENABLED), 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 disable this feature. Related setting: When you enable
-- temporal quantization, adjust the strength of the filter with the
-- setting Adaptive quantization (adaptiveQuantization).
mpeg2Settings_temporalAdaptiveQuantization :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2TemporalAdaptiveQuantization)
mpeg2Settings_temporalAdaptiveQuantization :: (Maybe Mpeg2TemporalAdaptiveQuantization
 -> f (Maybe Mpeg2TemporalAdaptiveQuantization))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_temporalAdaptiveQuantization = (Mpeg2Settings -> Maybe Mpeg2TemporalAdaptiveQuantization)
-> (Mpeg2Settings
    -> Maybe Mpeg2TemporalAdaptiveQuantization -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2TemporalAdaptiveQuantization)
     (Maybe Mpeg2TemporalAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2TemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Maybe Mpeg2TemporalAdaptiveQuantization
$sel:temporalAdaptiveQuantization:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2TemporalAdaptiveQuantization
temporalAdaptiveQuantization} -> Maybe Mpeg2TemporalAdaptiveQuantization
temporalAdaptiveQuantization) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2TemporalAdaptiveQuantization
a -> Mpeg2Settings
s {$sel:temporalAdaptiveQuantization:Mpeg2Settings' :: Maybe Mpeg2TemporalAdaptiveQuantization
temporalAdaptiveQuantization = Maybe Mpeg2TemporalAdaptiveQuantization
a} :: Mpeg2Settings)

-- | Enable this setting to insert I-frames at scene changes that the service
-- automatically detects. This improves video quality and is enabled by
-- default.
mpeg2Settings_sceneChangeDetect :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2SceneChangeDetect)
mpeg2Settings_sceneChangeDetect :: (Maybe Mpeg2SceneChangeDetect -> f (Maybe Mpeg2SceneChangeDetect))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_sceneChangeDetect = (Mpeg2Settings -> Maybe Mpeg2SceneChangeDetect)
-> (Mpeg2Settings -> Maybe Mpeg2SceneChangeDetect -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2SceneChangeDetect)
     (Maybe Mpeg2SceneChangeDetect)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2SceneChangeDetect
sceneChangeDetect :: Maybe Mpeg2SceneChangeDetect
$sel:sceneChangeDetect:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2SceneChangeDetect
sceneChangeDetect} -> Maybe Mpeg2SceneChangeDetect
sceneChangeDetect) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2SceneChangeDetect
a -> Mpeg2Settings
s {$sel:sceneChangeDetect:Mpeg2Settings' :: Maybe Mpeg2SceneChangeDetect
sceneChangeDetect = Maybe Mpeg2SceneChangeDetect
a} :: Mpeg2Settings)

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

-- | 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.
mpeg2Settings_slowPal :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2SlowPal)
mpeg2Settings_slowPal :: (Maybe Mpeg2SlowPal -> f (Maybe Mpeg2SlowPal))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_slowPal = (Mpeg2Settings -> Maybe Mpeg2SlowPal)
-> (Mpeg2Settings -> Maybe Mpeg2SlowPal -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2SlowPal)
     (Maybe Mpeg2SlowPal)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2SlowPal
slowPal :: Maybe Mpeg2SlowPal
$sel:slowPal:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2SlowPal
slowPal} -> Maybe Mpeg2SlowPal
slowPal) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2SlowPal
a -> Mpeg2Settings
s {$sel:slowPal:Mpeg2Settings' :: Maybe Mpeg2SlowPal
slowPal = Maybe Mpeg2SlowPal
a} :: Mpeg2Settings)

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

-- | Specify the interval between keyframes, in seconds or frames, for this
-- output. Default: 12 Related settings: When you specify the GOP size in
-- seconds, set GOP mode control (GopSizeUnits) to Specified, seconds
-- (SECONDS). The default value for GOP mode control (GopSizeUnits) is
-- Frames (FRAMES).
mpeg2Settings_gopSize :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Prelude.Double)
mpeg2Settings_gopSize :: (Maybe Double -> f (Maybe Double))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_gopSize = (Mpeg2Settings -> Maybe Double)
-> (Mpeg2Settings -> Maybe Double -> Mpeg2Settings)
-> Lens Mpeg2Settings Mpeg2Settings (Maybe Double) (Maybe Double)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Double
gopSize :: Maybe Double
$sel:gopSize:Mpeg2Settings' :: Mpeg2Settings -> Maybe Double
gopSize} -> Maybe Double
gopSize) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Double
a -> Mpeg2Settings
s {$sel:gopSize:Mpeg2Settings' :: Maybe Double
gopSize = Maybe Double
a} :: Mpeg2Settings)

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

-- | Specify the units for GOP size (GopSize). If you don\'t specify a value
-- here, by default the encoder measures GOP size in frames.
mpeg2Settings_gopSizeUnits :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2GopSizeUnits)
mpeg2Settings_gopSizeUnits :: (Maybe Mpeg2GopSizeUnits -> f (Maybe Mpeg2GopSizeUnits))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_gopSizeUnits = (Mpeg2Settings -> Maybe Mpeg2GopSizeUnits)
-> (Mpeg2Settings -> Maybe Mpeg2GopSizeUnits -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2GopSizeUnits)
     (Maybe Mpeg2GopSizeUnits)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2GopSizeUnits
gopSizeUnits :: Maybe Mpeg2GopSizeUnits
$sel:gopSizeUnits:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2GopSizeUnits
gopSizeUnits} -> Maybe Mpeg2GopSizeUnits
gopSizeUnits) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2GopSizeUnits
a -> Mpeg2Settings
s {$sel:gopSizeUnits:Mpeg2Settings' :: Maybe Mpeg2GopSizeUnits
gopSizeUnits = Maybe Mpeg2GopSizeUnits
a} :: Mpeg2Settings)

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

-- | Use Rate control mode (Mpeg2RateControlMode) to specify whether the
-- bitrate is variable (vbr) or constant (cbr).
mpeg2Settings_rateControlMode :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2RateControlMode)
mpeg2Settings_rateControlMode :: (Maybe Mpeg2RateControlMode -> f (Maybe Mpeg2RateControlMode))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_rateControlMode = (Mpeg2Settings -> Maybe Mpeg2RateControlMode)
-> (Mpeg2Settings -> Maybe Mpeg2RateControlMode -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2RateControlMode)
     (Maybe Mpeg2RateControlMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2RateControlMode
rateControlMode :: Maybe Mpeg2RateControlMode
$sel:rateControlMode:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2RateControlMode
rateControlMode} -> Maybe Mpeg2RateControlMode
rateControlMode) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2RateControlMode
a -> Mpeg2Settings
s {$sel:rateControlMode:Mpeg2Settings' :: Maybe Mpeg2RateControlMode
rateControlMode = Maybe Mpeg2RateControlMode
a} :: Mpeg2Settings)

-- | 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.
mpeg2Settings_telecine :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2Telecine)
mpeg2Settings_telecine :: (Maybe Mpeg2Telecine -> f (Maybe Mpeg2Telecine))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_telecine = (Mpeg2Settings -> Maybe Mpeg2Telecine)
-> (Mpeg2Settings -> Maybe Mpeg2Telecine -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2Telecine)
     (Maybe Mpeg2Telecine)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2Telecine
telecine :: Maybe Mpeg2Telecine
$sel:telecine:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2Telecine
telecine} -> Maybe Mpeg2Telecine
telecine) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2Telecine
a -> Mpeg2Settings
s {$sel:telecine:Mpeg2Settings' :: Maybe Mpeg2Telecine
telecine = Maybe Mpeg2Telecine
a} :: Mpeg2Settings)

-- | Use Intra DC precision (Mpeg2IntraDcPrecision) to set quantization
-- precision for intra-block DC coefficients. If you choose the value auto,
-- the service will automatically select the precision based on the
-- per-frame compression ratio.
mpeg2Settings_intraDcPrecision :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2IntraDcPrecision)
mpeg2Settings_intraDcPrecision :: (Maybe Mpeg2IntraDcPrecision -> f (Maybe Mpeg2IntraDcPrecision))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_intraDcPrecision = (Mpeg2Settings -> Maybe Mpeg2IntraDcPrecision)
-> (Mpeg2Settings -> Maybe Mpeg2IntraDcPrecision -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2IntraDcPrecision)
     (Maybe Mpeg2IntraDcPrecision)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2IntraDcPrecision
intraDcPrecision :: Maybe Mpeg2IntraDcPrecision
$sel:intraDcPrecision:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2IntraDcPrecision
intraDcPrecision} -> Maybe Mpeg2IntraDcPrecision
intraDcPrecision) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2IntraDcPrecision
a -> Mpeg2Settings
s {$sel:intraDcPrecision:Mpeg2Settings' :: Maybe Mpeg2IntraDcPrecision
intraDcPrecision = Maybe Mpeg2IntraDcPrecision
a} :: Mpeg2Settings)

-- | 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).
mpeg2Settings_dynamicSubGop :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2DynamicSubGop)
mpeg2Settings_dynamicSubGop :: (Maybe Mpeg2DynamicSubGop -> f (Maybe Mpeg2DynamicSubGop))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_dynamicSubGop = (Mpeg2Settings -> Maybe Mpeg2DynamicSubGop)
-> (Mpeg2Settings -> Maybe Mpeg2DynamicSubGop -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2DynamicSubGop)
     (Maybe Mpeg2DynamicSubGop)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2DynamicSubGop
dynamicSubGop :: Maybe Mpeg2DynamicSubGop
$sel:dynamicSubGop:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2DynamicSubGop
dynamicSubGop} -> Maybe Mpeg2DynamicSubGop
dynamicSubGop) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2DynamicSubGop
a -> Mpeg2Settings
s {$sel:dynamicSubGop:Mpeg2Settings' :: Maybe Mpeg2DynamicSubGop
dynamicSubGop = Maybe Mpeg2DynamicSubGop
a} :: Mpeg2Settings)

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

-- | 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.
mpeg2Settings_interlaceMode :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2InterlaceMode)
mpeg2Settings_interlaceMode :: (Maybe Mpeg2InterlaceMode -> f (Maybe Mpeg2InterlaceMode))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_interlaceMode = (Mpeg2Settings -> Maybe Mpeg2InterlaceMode)
-> (Mpeg2Settings -> Maybe Mpeg2InterlaceMode -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2InterlaceMode)
     (Maybe Mpeg2InterlaceMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2InterlaceMode
interlaceMode :: Maybe Mpeg2InterlaceMode
$sel:interlaceMode:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2InterlaceMode
interlaceMode} -> Maybe Mpeg2InterlaceMode
interlaceMode) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2InterlaceMode
a -> Mpeg2Settings
s {$sel:interlaceMode:Mpeg2Settings' :: Maybe Mpeg2InterlaceMode
interlaceMode = Maybe Mpeg2InterlaceMode
a} :: Mpeg2Settings)

-- | 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.
mpeg2Settings_parControl :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2ParControl)
mpeg2Settings_parControl :: (Maybe Mpeg2ParControl -> f (Maybe Mpeg2ParControl))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_parControl = (Mpeg2Settings -> Maybe Mpeg2ParControl)
-> (Mpeg2Settings -> Maybe Mpeg2ParControl -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2ParControl)
     (Maybe Mpeg2ParControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2ParControl
parControl :: Maybe Mpeg2ParControl
$sel:parControl:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2ParControl
parControl} -> Maybe Mpeg2ParControl
parControl) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2ParControl
a -> Mpeg2Settings
s {$sel:parControl:Mpeg2Settings' :: Maybe Mpeg2ParControl
parControl = Maybe Mpeg2ParControl
a} :: Mpeg2Settings)

-- | 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).
mpeg2Settings_scanTypeConversionMode :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2ScanTypeConversionMode)
mpeg2Settings_scanTypeConversionMode :: (Maybe Mpeg2ScanTypeConversionMode
 -> f (Maybe Mpeg2ScanTypeConversionMode))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_scanTypeConversionMode = (Mpeg2Settings -> Maybe Mpeg2ScanTypeConversionMode)
-> (Mpeg2Settings
    -> Maybe Mpeg2ScanTypeConversionMode -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2ScanTypeConversionMode)
     (Maybe Mpeg2ScanTypeConversionMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2ScanTypeConversionMode
scanTypeConversionMode :: Maybe Mpeg2ScanTypeConversionMode
$sel:scanTypeConversionMode:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2ScanTypeConversionMode
scanTypeConversionMode} -> Maybe Mpeg2ScanTypeConversionMode
scanTypeConversionMode) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2ScanTypeConversionMode
a -> Mpeg2Settings
s {$sel:scanTypeConversionMode:Mpeg2Settings' :: Maybe Mpeg2ScanTypeConversionMode
scanTypeConversionMode = Maybe Mpeg2ScanTypeConversionMode
a} :: Mpeg2Settings)

-- | 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, to use the AWS Elemental default matrices. 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.
mpeg2Settings_softness :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Prelude.Natural)
mpeg2Settings_softness :: (Maybe Natural -> f (Maybe Natural))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_softness = (Mpeg2Settings -> Maybe Natural)
-> (Mpeg2Settings -> Maybe Natural -> Mpeg2Settings)
-> Lens Mpeg2Settings Mpeg2Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Natural
softness :: Maybe Natural
$sel:softness:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
softness} -> Maybe Natural
softness) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Natural
a -> Mpeg2Settings
s {$sel:softness:Mpeg2Settings' :: Maybe Natural
softness = Maybe Natural
a} :: Mpeg2Settings)

-- | Use Profile (Mpeg2CodecProfile) to set the MPEG-2 profile for the video
-- output.
mpeg2Settings_codecProfile :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2CodecProfile)
mpeg2Settings_codecProfile :: (Maybe Mpeg2CodecProfile -> f (Maybe Mpeg2CodecProfile))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_codecProfile = (Mpeg2Settings -> Maybe Mpeg2CodecProfile)
-> (Mpeg2Settings -> Maybe Mpeg2CodecProfile -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2CodecProfile)
     (Maybe Mpeg2CodecProfile)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2CodecProfile
codecProfile :: Maybe Mpeg2CodecProfile
$sel:codecProfile:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2CodecProfile
codecProfile} -> Maybe Mpeg2CodecProfile
codecProfile) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2CodecProfile
a -> Mpeg2Settings
s {$sel:codecProfile:Mpeg2Settings' :: Maybe Mpeg2CodecProfile
codecProfile = Maybe Mpeg2CodecProfile
a} :: Mpeg2Settings)

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

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

-- | 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.
mpeg2Settings_framerateConversionAlgorithm :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2FramerateConversionAlgorithm)
mpeg2Settings_framerateConversionAlgorithm :: (Maybe Mpeg2FramerateConversionAlgorithm
 -> f (Maybe Mpeg2FramerateConversionAlgorithm))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_framerateConversionAlgorithm = (Mpeg2Settings -> Maybe Mpeg2FramerateConversionAlgorithm)
-> (Mpeg2Settings
    -> Maybe Mpeg2FramerateConversionAlgorithm -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2FramerateConversionAlgorithm)
     (Maybe Mpeg2FramerateConversionAlgorithm)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2FramerateConversionAlgorithm
framerateConversionAlgorithm :: Maybe Mpeg2FramerateConversionAlgorithm
$sel:framerateConversionAlgorithm:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2FramerateConversionAlgorithm
framerateConversionAlgorithm} -> Maybe Mpeg2FramerateConversionAlgorithm
framerateConversionAlgorithm) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2FramerateConversionAlgorithm
a -> Mpeg2Settings
s {$sel:framerateConversionAlgorithm:Mpeg2Settings' :: Maybe Mpeg2FramerateConversionAlgorithm
framerateConversionAlgorithm = Maybe Mpeg2FramerateConversionAlgorithm
a} :: Mpeg2Settings)

-- | Use Level (Mpeg2CodecLevel) to set the MPEG-2 level for the video
-- output.
mpeg2Settings_codecLevel :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2CodecLevel)
mpeg2Settings_codecLevel :: (Maybe Mpeg2CodecLevel -> f (Maybe Mpeg2CodecLevel))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_codecLevel = (Mpeg2Settings -> Maybe Mpeg2CodecLevel)
-> (Mpeg2Settings -> Maybe Mpeg2CodecLevel -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2CodecLevel)
     (Maybe Mpeg2CodecLevel)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2CodecLevel
codecLevel :: Maybe Mpeg2CodecLevel
$sel:codecLevel:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2CodecLevel
codecLevel} -> Maybe Mpeg2CodecLevel
codecLevel) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2CodecLevel
a -> Mpeg2Settings
s {$sel:codecLevel:Mpeg2Settings' :: Maybe Mpeg2CodecLevel
codecLevel = Maybe Mpeg2CodecLevel
a} :: Mpeg2Settings)

-- | 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.
mpeg2Settings_framerateControl :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2FramerateControl)
mpeg2Settings_framerateControl :: (Maybe Mpeg2FramerateControl -> f (Maybe Mpeg2FramerateControl))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_framerateControl = (Mpeg2Settings -> Maybe Mpeg2FramerateControl)
-> (Mpeg2Settings -> Maybe Mpeg2FramerateControl -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2FramerateControl)
     (Maybe Mpeg2FramerateControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2FramerateControl
framerateControl :: Maybe Mpeg2FramerateControl
$sel:framerateControl:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2FramerateControl
framerateControl} -> Maybe Mpeg2FramerateControl
framerateControl) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2FramerateControl
a -> Mpeg2Settings
s {$sel:framerateControl:Mpeg2Settings' :: Maybe Mpeg2FramerateControl
framerateControl = Maybe Mpeg2FramerateControl
a} :: Mpeg2Settings)

-- | Specify the strength of any adaptive quantization filters that you
-- enable. The value that you choose here applies to the following
-- settings: Spatial adaptive quantization (spatialAdaptiveQuantization),
-- and Temporal adaptive quantization (temporalAdaptiveQuantization).
mpeg2Settings_adaptiveQuantization :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2AdaptiveQuantization)
mpeg2Settings_adaptiveQuantization :: (Maybe Mpeg2AdaptiveQuantization
 -> f (Maybe Mpeg2AdaptiveQuantization))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_adaptiveQuantization = (Mpeg2Settings -> Maybe Mpeg2AdaptiveQuantization)
-> (Mpeg2Settings
    -> Maybe Mpeg2AdaptiveQuantization -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2AdaptiveQuantization)
     (Maybe Mpeg2AdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2AdaptiveQuantization
adaptiveQuantization :: Maybe Mpeg2AdaptiveQuantization
$sel:adaptiveQuantization:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2AdaptiveQuantization
adaptiveQuantization} -> Maybe Mpeg2AdaptiveQuantization
adaptiveQuantization) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2AdaptiveQuantization
a -> Mpeg2Settings
s {$sel:adaptiveQuantization:Mpeg2Settings' :: Maybe Mpeg2AdaptiveQuantization
adaptiveQuantization = Maybe Mpeg2AdaptiveQuantization
a} :: Mpeg2Settings)

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

-- | Maximum bitrate in bits\/second. For example, enter five megabits per
-- second as 5000000.
mpeg2Settings_maxBitrate :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Prelude.Natural)
mpeg2Settings_maxBitrate :: (Maybe Natural -> f (Maybe Natural))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_maxBitrate = (Mpeg2Settings -> Maybe Natural)
-> (Mpeg2Settings -> Maybe Natural -> Mpeg2Settings)
-> Lens Mpeg2Settings Mpeg2Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Natural
maxBitrate :: Maybe Natural
$sel:maxBitrate:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
maxBitrate} -> Maybe Natural
maxBitrate) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Natural
a -> Mpeg2Settings
s {$sel:maxBitrate:Mpeg2Settings' :: Maybe Natural
maxBitrate = Maybe Natural
a} :: Mpeg2Settings)

-- | Specify whether this output\'s video uses the D10 syntax. Keep the
-- default value to not use the syntax. Related settings: When you choose
-- D10 (D_10) for your MXF profile (profile), you must also set this value
-- to to D10 (D_10).
mpeg2Settings_syntax :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2Syntax)
mpeg2Settings_syntax :: (Maybe Mpeg2Syntax -> f (Maybe Mpeg2Syntax))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_syntax = (Mpeg2Settings -> Maybe Mpeg2Syntax)
-> (Mpeg2Settings -> Maybe Mpeg2Syntax -> Mpeg2Settings)
-> Lens
     Mpeg2Settings Mpeg2Settings (Maybe Mpeg2Syntax) (Maybe Mpeg2Syntax)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2Syntax
syntax :: Maybe Mpeg2Syntax
$sel:syntax:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2Syntax
syntax} -> Maybe Mpeg2Syntax
syntax) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2Syntax
a -> Mpeg2Settings
s {$sel:syntax:Mpeg2Settings' :: Maybe Mpeg2Syntax
syntax = Maybe Mpeg2Syntax
a} :: Mpeg2Settings)

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

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

-- | Keep the default value, Enabled (ENABLED), 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
-- disable this feature. Related setting: When you enable spatial adaptive
-- quantization, set the value for Adaptive quantization
-- (adaptiveQuantization) 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.
mpeg2Settings_spatialAdaptiveQuantization :: Lens.Lens' Mpeg2Settings (Prelude.Maybe Mpeg2SpatialAdaptiveQuantization)
mpeg2Settings_spatialAdaptiveQuantization :: (Maybe Mpeg2SpatialAdaptiveQuantization
 -> f (Maybe Mpeg2SpatialAdaptiveQuantization))
-> Mpeg2Settings -> f Mpeg2Settings
mpeg2Settings_spatialAdaptiveQuantization = (Mpeg2Settings -> Maybe Mpeg2SpatialAdaptiveQuantization)
-> (Mpeg2Settings
    -> Maybe Mpeg2SpatialAdaptiveQuantization -> Mpeg2Settings)
-> Lens
     Mpeg2Settings
     Mpeg2Settings
     (Maybe Mpeg2SpatialAdaptiveQuantization)
     (Maybe Mpeg2SpatialAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Mpeg2Settings' {Maybe Mpeg2SpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe Mpeg2SpatialAdaptiveQuantization
$sel:spatialAdaptiveQuantization:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2SpatialAdaptiveQuantization
spatialAdaptiveQuantization} -> Maybe Mpeg2SpatialAdaptiveQuantization
spatialAdaptiveQuantization) (\s :: Mpeg2Settings
s@Mpeg2Settings' {} Maybe Mpeg2SpatialAdaptiveQuantization
a -> Mpeg2Settings
s {$sel:spatialAdaptiveQuantization:Mpeg2Settings' :: Maybe Mpeg2SpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe Mpeg2SpatialAdaptiveQuantization
a} :: Mpeg2Settings)

instance Core.FromJSON Mpeg2Settings where
  parseJSON :: Value -> Parser Mpeg2Settings
parseJSON =
    String
-> (Object -> Parser Mpeg2Settings)
-> Value
-> Parser Mpeg2Settings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"Mpeg2Settings"
      ( \Object
x ->
          Maybe Mpeg2QualityTuningLevel
-> Maybe Mpeg2TemporalAdaptiveQuantization
-> Maybe Mpeg2SceneChangeDetect
-> Maybe Natural
-> Maybe Mpeg2SlowPal
-> Maybe Natural
-> Maybe Double
-> Maybe Natural
-> Maybe Mpeg2GopSizeUnits
-> Maybe Natural
-> Maybe Mpeg2RateControlMode
-> Maybe Mpeg2Telecine
-> Maybe Mpeg2IntraDcPrecision
-> Maybe Mpeg2DynamicSubGop
-> Maybe Natural
-> Maybe Mpeg2InterlaceMode
-> Maybe Mpeg2ParControl
-> Maybe Mpeg2ScanTypeConversionMode
-> Maybe Natural
-> Maybe Mpeg2CodecProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe Mpeg2FramerateConversionAlgorithm
-> Maybe Mpeg2CodecLevel
-> Maybe Mpeg2FramerateControl
-> Maybe Mpeg2AdaptiveQuantization
-> Maybe Natural
-> Maybe Natural
-> Maybe Mpeg2Syntax
-> Maybe Natural
-> Maybe Natural
-> Maybe Mpeg2SpatialAdaptiveQuantization
-> Mpeg2Settings
Mpeg2Settings'
            (Maybe Mpeg2QualityTuningLevel
 -> Maybe Mpeg2TemporalAdaptiveQuantization
 -> Maybe Mpeg2SceneChangeDetect
 -> Maybe Natural
 -> Maybe Mpeg2SlowPal
 -> Maybe Natural
 -> Maybe Double
 -> Maybe Natural
 -> Maybe Mpeg2GopSizeUnits
 -> Maybe Natural
 -> Maybe Mpeg2RateControlMode
 -> Maybe Mpeg2Telecine
 -> Maybe Mpeg2IntraDcPrecision
 -> Maybe Mpeg2DynamicSubGop
 -> Maybe Natural
 -> Maybe Mpeg2InterlaceMode
 -> Maybe Mpeg2ParControl
 -> Maybe Mpeg2ScanTypeConversionMode
 -> Maybe Natural
 -> Maybe Mpeg2CodecProfile
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe Mpeg2FramerateConversionAlgorithm
 -> Maybe Mpeg2CodecLevel
 -> Maybe Mpeg2FramerateControl
 -> Maybe Mpeg2AdaptiveQuantization
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe Mpeg2Syntax
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe Mpeg2SpatialAdaptiveQuantization
 -> Mpeg2Settings)
-> Parser (Maybe Mpeg2QualityTuningLevel)
-> Parser
     (Maybe Mpeg2TemporalAdaptiveQuantization
      -> Maybe Mpeg2SceneChangeDetect
      -> Maybe Natural
      -> Maybe Mpeg2SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe Mpeg2QualityTuningLevel)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"qualityTuningLevel")
            Parser
  (Maybe Mpeg2TemporalAdaptiveQuantization
   -> Maybe Mpeg2SceneChangeDetect
   -> Maybe Natural
   -> Maybe Mpeg2SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2TemporalAdaptiveQuantization)
-> Parser
     (Maybe Mpeg2SceneChangeDetect
      -> Maybe Natural
      -> Maybe Mpeg2SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2TemporalAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"temporalAdaptiveQuantization")
            Parser
  (Maybe Mpeg2SceneChangeDetect
   -> Maybe Natural
   -> Maybe Mpeg2SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2SceneChangeDetect)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2SceneChangeDetect)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"sceneChangeDetect")
            Parser
  (Maybe Natural
   -> Maybe Mpeg2SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Mpeg2SlowPal
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2SlowPal
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2SlowPal)
-> Parser
     (Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2SlowPal)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"slowPal")
            Parser
  (Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Double
      -> Maybe Natural
      -> Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Double)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Mpeg2GopSizeUnits
      -> Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2GopSizeUnits
   -> Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2GopSizeUnits)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2GopSizeUnits)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"gopSizeUnits")
            Parser
  (Maybe Natural
   -> Maybe Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Mpeg2RateControlMode
      -> Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2RateControlMode
   -> Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2RateControlMode)
-> Parser
     (Maybe Mpeg2Telecine
      -> Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2RateControlMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"rateControlMode")
            Parser
  (Maybe Mpeg2Telecine
   -> Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2Telecine)
-> Parser
     (Maybe Mpeg2IntraDcPrecision
      -> Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2Telecine)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"telecine")
            Parser
  (Maybe Mpeg2IntraDcPrecision
   -> Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2IntraDcPrecision)
-> Parser
     (Maybe Mpeg2DynamicSubGop
      -> Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2IntraDcPrecision)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"intraDcPrecision")
            Parser
  (Maybe Mpeg2DynamicSubGop
   -> Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2DynamicSubGop)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2DynamicSubGop)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"dynamicSubGop")
            Parser
  (Maybe Natural
   -> Maybe Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Mpeg2InterlaceMode
      -> Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2InterlaceMode
   -> Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2InterlaceMode)
-> Parser
     (Maybe Mpeg2ParControl
      -> Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2InterlaceMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"interlaceMode")
            Parser
  (Maybe Mpeg2ParControl
   -> Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2ParControl)
-> Parser
     (Maybe Mpeg2ScanTypeConversionMode
      -> Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2ParControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"parControl")
            Parser
  (Maybe Mpeg2ScanTypeConversionMode
   -> Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2ScanTypeConversionMode)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2ScanTypeConversionMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"scanTypeConversionMode")
            Parser
  (Maybe Natural
   -> Maybe Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Mpeg2CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2CodecProfile)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2CodecProfile)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"codecProfile")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Mpeg2FramerateConversionAlgorithm
      -> Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2FramerateConversionAlgorithm
   -> Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2FramerateConversionAlgorithm)
-> Parser
     (Maybe Mpeg2CodecLevel
      -> Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2FramerateConversionAlgorithm)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateConversionAlgorithm")
            Parser
  (Maybe Mpeg2CodecLevel
   -> Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2CodecLevel)
-> Parser
     (Maybe Mpeg2FramerateControl
      -> Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2CodecLevel)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"codecLevel")
            Parser
  (Maybe Mpeg2FramerateControl
   -> Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2FramerateControl)
-> Parser
     (Maybe Mpeg2AdaptiveQuantization
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2FramerateControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateControl")
            Parser
  (Maybe Mpeg2AdaptiveQuantization
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2AdaptiveQuantization)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2AdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"adaptiveQuantization")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Natural
   -> Maybe Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Mpeg2Syntax
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
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 Mpeg2Syntax
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Mpeg2Syntax)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization
      -> Mpeg2Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2Syntax)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"syntax")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe Mpeg2SpatialAdaptiveQuantization
   -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe Mpeg2SpatialAdaptiveQuantization -> Mpeg2Settings)
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 Mpeg2SpatialAdaptiveQuantization -> Mpeg2Settings)
-> Parser (Maybe Natural)
-> Parser (Maybe Mpeg2SpatialAdaptiveQuantization -> Mpeg2Settings)
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 Mpeg2SpatialAdaptiveQuantization -> Mpeg2Settings)
-> Parser (Maybe Mpeg2SpatialAdaptiveQuantization)
-> Parser Mpeg2Settings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Mpeg2SpatialAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"spatialAdaptiveQuantization")
      )

instance Prelude.Hashable Mpeg2Settings

instance Prelude.NFData Mpeg2Settings

instance Core.ToJSON Mpeg2Settings where
  toJSON :: Mpeg2Settings -> Value
toJSON Mpeg2Settings' {Maybe Double
Maybe Natural
Maybe Mpeg2AdaptiveQuantization
Maybe Mpeg2CodecLevel
Maybe Mpeg2CodecProfile
Maybe Mpeg2DynamicSubGop
Maybe Mpeg2FramerateControl
Maybe Mpeg2FramerateConversionAlgorithm
Maybe Mpeg2GopSizeUnits
Maybe Mpeg2InterlaceMode
Maybe Mpeg2IntraDcPrecision
Maybe Mpeg2ParControl
Maybe Mpeg2QualityTuningLevel
Maybe Mpeg2RateControlMode
Maybe Mpeg2ScanTypeConversionMode
Maybe Mpeg2SceneChangeDetect
Maybe Mpeg2SlowPal
Maybe Mpeg2SpatialAdaptiveQuantization
Maybe Mpeg2Syntax
Maybe Mpeg2Telecine
Maybe Mpeg2TemporalAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe Mpeg2SpatialAdaptiveQuantization
parDenominator :: Maybe Natural
gopClosedCadence :: Maybe Natural
syntax :: Maybe Mpeg2Syntax
maxBitrate :: Maybe Natural
framerateNumerator :: Maybe Natural
adaptiveQuantization :: Maybe Mpeg2AdaptiveQuantization
framerateControl :: Maybe Mpeg2FramerateControl
codecLevel :: Maybe Mpeg2CodecLevel
framerateConversionAlgorithm :: Maybe Mpeg2FramerateConversionAlgorithm
framerateDenominator :: Maybe Natural
bitrate :: Maybe Natural
codecProfile :: Maybe Mpeg2CodecProfile
softness :: Maybe Natural
scanTypeConversionMode :: Maybe Mpeg2ScanTypeConversionMode
parControl :: Maybe Mpeg2ParControl
interlaceMode :: Maybe Mpeg2InterlaceMode
minIInterval :: Maybe Natural
dynamicSubGop :: Maybe Mpeg2DynamicSubGop
intraDcPrecision :: Maybe Mpeg2IntraDcPrecision
telecine :: Maybe Mpeg2Telecine
rateControlMode :: Maybe Mpeg2RateControlMode
hrdBufferSize :: Maybe Natural
gopSizeUnits :: Maybe Mpeg2GopSizeUnits
numberBFramesBetweenReferenceFrames :: Maybe Natural
gopSize :: Maybe Double
parNumerator :: Maybe Natural
slowPal :: Maybe Mpeg2SlowPal
hrdBufferInitialFillPercentage :: Maybe Natural
sceneChangeDetect :: Maybe Mpeg2SceneChangeDetect
temporalAdaptiveQuantization :: Maybe Mpeg2TemporalAdaptiveQuantization
qualityTuningLevel :: Maybe Mpeg2QualityTuningLevel
$sel:spatialAdaptiveQuantization:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2SpatialAdaptiveQuantization
$sel:parDenominator:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:gopClosedCadence:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:syntax:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2Syntax
$sel:maxBitrate:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:framerateNumerator:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:adaptiveQuantization:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2AdaptiveQuantization
$sel:framerateControl:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2FramerateControl
$sel:codecLevel:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2CodecLevel
$sel:framerateConversionAlgorithm:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2FramerateConversionAlgorithm
$sel:framerateDenominator:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:bitrate:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:codecProfile:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2CodecProfile
$sel:softness:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:scanTypeConversionMode:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2ScanTypeConversionMode
$sel:parControl:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2ParControl
$sel:interlaceMode:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2InterlaceMode
$sel:minIInterval:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:dynamicSubGop:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2DynamicSubGop
$sel:intraDcPrecision:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2IntraDcPrecision
$sel:telecine:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2Telecine
$sel:rateControlMode:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2RateControlMode
$sel:hrdBufferSize:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:gopSizeUnits:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2GopSizeUnits
$sel:numberBFramesBetweenReferenceFrames:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:gopSize:Mpeg2Settings' :: Mpeg2Settings -> Maybe Double
$sel:parNumerator:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:slowPal:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2SlowPal
$sel:hrdBufferInitialFillPercentage:Mpeg2Settings' :: Mpeg2Settings -> Maybe Natural
$sel:sceneChangeDetect:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2SceneChangeDetect
$sel:temporalAdaptiveQuantization:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2TemporalAdaptiveQuantization
$sel:qualityTuningLevel:Mpeg2Settings' :: Mpeg2Settings -> Maybe Mpeg2QualityTuningLevel
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"qualityTuningLevel" Text -> Mpeg2QualityTuningLevel -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2QualityTuningLevel -> Pair)
-> Maybe Mpeg2QualityTuningLevel -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2QualityTuningLevel
qualityTuningLevel,
            (Text
"temporalAdaptiveQuantization" Text -> Mpeg2TemporalAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2TemporalAdaptiveQuantization -> Pair)
-> Maybe Mpeg2TemporalAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2TemporalAdaptiveQuantization
temporalAdaptiveQuantization,
            (Text
"sceneChangeDetect" Text -> Mpeg2SceneChangeDetect -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2SceneChangeDetect -> Pair)
-> Maybe Mpeg2SceneChangeDetect -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2SceneChangeDetect
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 -> Mpeg2SlowPal -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2SlowPal -> Pair) -> Maybe Mpeg2SlowPal -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2SlowPal
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 -> Mpeg2GopSizeUnits -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2GopSizeUnits -> Pair)
-> Maybe Mpeg2GopSizeUnits -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2GopSizeUnits
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
"rateControlMode" Text -> Mpeg2RateControlMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2RateControlMode -> Pair)
-> Maybe Mpeg2RateControlMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2RateControlMode
rateControlMode,
            (Text
"telecine" Text -> Mpeg2Telecine -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2Telecine -> Pair) -> Maybe Mpeg2Telecine -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2Telecine
telecine,
            (Text
"intraDcPrecision" Text -> Mpeg2IntraDcPrecision -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2IntraDcPrecision -> Pair)
-> Maybe Mpeg2IntraDcPrecision -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2IntraDcPrecision
intraDcPrecision,
            (Text
"dynamicSubGop" Text -> Mpeg2DynamicSubGop -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2DynamicSubGop -> Pair)
-> Maybe Mpeg2DynamicSubGop -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2DynamicSubGop
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 -> Mpeg2InterlaceMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2InterlaceMode -> Pair)
-> Maybe Mpeg2InterlaceMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2InterlaceMode
interlaceMode,
            (Text
"parControl" Text -> Mpeg2ParControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2ParControl -> Pair) -> Maybe Mpeg2ParControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2ParControl
parControl,
            (Text
"scanTypeConversionMode" Text -> Mpeg2ScanTypeConversionMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2ScanTypeConversionMode -> Pair)
-> Maybe Mpeg2ScanTypeConversionMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2ScanTypeConversionMode
scanTypeConversionMode,
            (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 -> Mpeg2CodecProfile -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2CodecProfile -> Pair)
-> Maybe Mpeg2CodecProfile -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2CodecProfile
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 -> Mpeg2FramerateConversionAlgorithm -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2FramerateConversionAlgorithm -> Pair)
-> Maybe Mpeg2FramerateConversionAlgorithm -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2FramerateConversionAlgorithm
framerateConversionAlgorithm,
            (Text
"codecLevel" Text -> Mpeg2CodecLevel -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2CodecLevel -> Pair) -> Maybe Mpeg2CodecLevel -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2CodecLevel
codecLevel,
            (Text
"framerateControl" Text -> Mpeg2FramerateControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2FramerateControl -> Pair)
-> Maybe Mpeg2FramerateControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2FramerateControl
framerateControl,
            (Text
"adaptiveQuantization" Text -> Mpeg2AdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2AdaptiveQuantization -> Pair)
-> Maybe Mpeg2AdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2AdaptiveQuantization
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
"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 -> Mpeg2Syntax -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Mpeg2Syntax -> Pair) -> Maybe Mpeg2Syntax -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2Syntax
syntax,
            (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 -> Mpeg2SpatialAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Mpeg2SpatialAdaptiveQuantization -> Pair)
-> Maybe Mpeg2SpatialAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Mpeg2SpatialAdaptiveQuantization
spatialAdaptiveQuantization
          ]
      )