{-# 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.MediaLive.Types.H265Settings
-- 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.MediaLive.Types.H265Settings where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaLive.Types.AfdSignaling
import Amazonka.MediaLive.Types.FixedAfd
import Amazonka.MediaLive.Types.H265AdaptiveQuantization
import Amazonka.MediaLive.Types.H265AlternativeTransferFunction
import Amazonka.MediaLive.Types.H265ColorMetadata
import Amazonka.MediaLive.Types.H265ColorSpaceSettings
import Amazonka.MediaLive.Types.H265FilterSettings
import Amazonka.MediaLive.Types.H265FlickerAq
import Amazonka.MediaLive.Types.H265GopSizeUnits
import Amazonka.MediaLive.Types.H265Level
import Amazonka.MediaLive.Types.H265LookAheadRateControl
import Amazonka.MediaLive.Types.H265Profile
import Amazonka.MediaLive.Types.H265RateControlMode
import Amazonka.MediaLive.Types.H265ScanType
import Amazonka.MediaLive.Types.H265SceneChangeDetect
import Amazonka.MediaLive.Types.H265Tier
import Amazonka.MediaLive.Types.H265TimecodeInsertionBehavior
import qualified Amazonka.Prelude as Prelude

-- | H265 Settings
--
-- /See:/ 'newH265Settings' smart constructor.
data H265Settings = H265Settings'
  { -- | Scene change detection.
    H265Settings -> Maybe H265SceneChangeDetect
sceneChangeDetect :: Prelude.Maybe H265SceneChangeDetect,
    -- | Sets the scan type of the output to progressive or top-field-first
    -- interlaced.
    H265Settings -> Maybe H265ScanType
scanType :: Prelude.Maybe H265ScanType,
    -- | Determines how timecodes should be inserted into the video elementary
    -- stream. - \'disabled\': Do not include timecodes - \'picTimingSei\':
    -- Pass through picture timing SEI messages from the source specified in
    -- Timecode Config
    H265Settings -> Maybe H265TimecodeInsertionBehavior
timecodeInsertion :: Prelude.Maybe H265TimecodeInsertionBehavior,
    -- | Pixel Aspect Ratio numerator.
    H265Settings -> Maybe Natural
parNumerator :: Prelude.Maybe Prelude.Natural,
    -- | Indicates that AFD values will be written into the output stream. If
    -- afdSignaling is \"auto\", the system will try to preserve the input AFD
    -- value (in cases where multiple AFD values are valid). If set to
    -- \"fixed\", the AFD value will be the value configured in the fixedAfd
    -- parameter.
    H265Settings -> Maybe AfdSignaling
afdSignaling :: Prelude.Maybe AfdSignaling,
    -- | GOP size (keyframe interval) in units of either frames or seconds per
    -- gopSizeUnits. If gopSizeUnits is frames, gopSize must be an integer and
    -- must be greater than or equal to 1. If gopSizeUnits is seconds, gopSize
    -- must be greater than 0, but need not be an integer.
    H265Settings -> Maybe Double
gopSize :: Prelude.Maybe Prelude.Double,
    -- | Indicates if the gopSize is specified in frames or seconds. If seconds
    -- the system will convert the gopSize into a frame count at run time.
    H265Settings -> Maybe H265GopSizeUnits
gopSizeUnits :: Prelude.Maybe H265GopSizeUnits,
    -- | Number of slices per picture. Must be less than or equal to the number
    -- of macroblock rows for progressive pictures, and less than or equal to
    -- half the number of macroblock rows for interlaced pictures. This field
    -- is optional; when no value is specified the encoder will choose the
    -- number of slices based on encode resolution.
    H265Settings -> Maybe Natural
slices :: Prelude.Maybe Prelude.Natural,
    -- | H.265 Profile.
    H265Settings -> Maybe H265Profile
profile :: Prelude.Maybe H265Profile,
    -- | Whether or not EML should insert an Alternative Transfer Function SEI
    -- message to support backwards compatibility with non-HDR decoders and
    -- displays.
    H265Settings -> Maybe H265AlternativeTransferFunction
alternativeTransferFunction :: Prelude.Maybe H265AlternativeTransferFunction,
    -- | Rate control mode. QVBR: Quality will match the specified quality level
    -- except when it is constrained by the maximum bitrate. Recommended if you
    -- or your viewers pay for bandwidth. CBR: Quality varies, depending on the
    -- video complexity. Recommended only if you distribute your assets to
    -- devices that cannot handle variable bitrates. Multiplex: This rate
    -- control mode is only supported (and is required) when the video is being
    -- delivered to a MediaLive Multiplex in which case the rate control
    -- configuration is controlled by the properties within the Multiplex
    -- Program.
    H265Settings -> Maybe H265RateControlMode
rateControlMode :: Prelude.Maybe H265RateControlMode,
    -- | Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if
    -- multiplex rate control is used. 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. Note: Maximum GOP stretch = GOP
    -- size + Min-I-interval - 1
    H265Settings -> Maybe Natural
minIInterval :: Prelude.Maybe Prelude.Natural,
    -- | Controls the target quality for the video encode. Applies only when the
    -- rate control mode is QVBR. Set values for the QVBR quality level field
    -- and Max bitrate field that suit your most important viewing devices.
    -- Recommended values are: - Primary screen: Quality level: 8 to 10. Max
    -- bitrate: 4M - PC or tablet: Quality level: 7. Max bitrate: 1.5M to 3M -
    -- Smartphone: Quality level: 6. Max bitrate: 1M to 1.5M
    H265Settings -> Maybe Natural
qvbrQualityLevel :: Prelude.Maybe Prelude.Natural,
    -- | Color Space settings
    H265Settings -> Maybe H265ColorSpaceSettings
colorSpaceSettings :: Prelude.Maybe H265ColorSpaceSettings,
    -- | If set to enabled, adjust quantization within each frame to reduce
    -- flicker or \'pop\' on I-frames.
    H265Settings -> Maybe H265FlickerAq
flickerAq :: Prelude.Maybe H265FlickerAq,
    -- | Size of buffer (HRD buffer model) in bits.
    H265Settings -> Maybe Natural
bufSize :: Prelude.Maybe Prelude.Natural,
    -- | H.265 Tier.
    H265Settings -> Maybe H265Tier
tier :: Prelude.Maybe H265Tier,
    -- | Four bit AFD value to write on all frames of video in the output stream.
    -- Only valid when afdSignaling is set to \'Fixed\'.
    H265Settings -> Maybe FixedAfd
fixedAfd :: Prelude.Maybe FixedAfd,
    -- | Optional filters that you can apply to an encode.
    H265Settings -> Maybe H265FilterSettings
filterSettings :: Prelude.Maybe H265FilterSettings,
    -- | Average bitrate in bits\/second. Required when the rate control mode is
    -- VBR or CBR. Not used for QVBR. In an MS Smooth output group, each output
    -- must have a unique value when its bitrate is rounded down to the nearest
    -- multiple of 1000.
    H265Settings -> Maybe Natural
bitrate :: Prelude.Maybe Prelude.Natural,
    -- | Includes colorspace metadata in the output.
    H265Settings -> Maybe H265ColorMetadata
colorMetadata :: Prelude.Maybe H265ColorMetadata,
    -- | Amount of lookahead. A value of low can decrease latency and memory
    -- usage, while high can produce better quality for certain content.
    H265Settings -> Maybe H265LookAheadRateControl
lookAheadRateControl :: Prelude.Maybe H265LookAheadRateControl,
    -- | Adaptive quantization. Allows intra-frame quantizers to vary to improve
    -- visual quality.
    H265Settings -> Maybe H265AdaptiveQuantization
adaptiveQuantization :: Prelude.Maybe H265AdaptiveQuantization,
    -- | H.265 Level.
    H265Settings -> Maybe H265Level
level :: Prelude.Maybe H265Level,
    -- | For QVBR: See the tooltip for Quality level
    H265Settings -> Maybe Natural
maxBitrate :: Prelude.Maybe Prelude.Natural,
    -- | 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.
    H265Settings -> Maybe Natural
gopClosedCadence :: Prelude.Maybe Prelude.Natural,
    -- | Pixel Aspect Ratio denominator.
    H265Settings -> Maybe Natural
parDenominator :: Prelude.Maybe Prelude.Natural,
    -- | Framerate numerator - framerate is a fraction, e.g. 24000 \/ 1001 =
    -- 23.976 fps.
    H265Settings -> Natural
framerateNumerator :: Prelude.Natural,
    -- | Framerate denominator.
    H265Settings -> Natural
framerateDenominator :: Prelude.Natural
  }
  deriving (H265Settings -> H265Settings -> Bool
(H265Settings -> H265Settings -> Bool)
-> (H265Settings -> H265Settings -> Bool) -> Eq H265Settings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: H265Settings -> H265Settings -> Bool
$c/= :: H265Settings -> H265Settings -> Bool
== :: H265Settings -> H265Settings -> Bool
$c== :: H265Settings -> H265Settings -> Bool
Prelude.Eq, ReadPrec [H265Settings]
ReadPrec H265Settings
Int -> ReadS H265Settings
ReadS [H265Settings]
(Int -> ReadS H265Settings)
-> ReadS [H265Settings]
-> ReadPrec H265Settings
-> ReadPrec [H265Settings]
-> Read H265Settings
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [H265Settings]
$creadListPrec :: ReadPrec [H265Settings]
readPrec :: ReadPrec H265Settings
$creadPrec :: ReadPrec H265Settings
readList :: ReadS [H265Settings]
$creadList :: ReadS [H265Settings]
readsPrec :: Int -> ReadS H265Settings
$creadsPrec :: Int -> ReadS H265Settings
Prelude.Read, Int -> H265Settings -> ShowS
[H265Settings] -> ShowS
H265Settings -> String
(Int -> H265Settings -> ShowS)
-> (H265Settings -> String)
-> ([H265Settings] -> ShowS)
-> Show H265Settings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [H265Settings] -> ShowS
$cshowList :: [H265Settings] -> ShowS
show :: H265Settings -> String
$cshow :: H265Settings -> String
showsPrec :: Int -> H265Settings -> ShowS
$cshowsPrec :: Int -> H265Settings -> ShowS
Prelude.Show, (forall x. H265Settings -> Rep H265Settings x)
-> (forall x. Rep H265Settings x -> H265Settings)
-> Generic H265Settings
forall x. Rep H265Settings x -> H265Settings
forall x. H265Settings -> Rep H265Settings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep H265Settings x -> H265Settings
$cfrom :: forall x. H265Settings -> Rep H265Settings x
Prelude.Generic)

-- |
-- Create a value of 'H265Settings' 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:
--
-- 'sceneChangeDetect', 'h265Settings_sceneChangeDetect' - Scene change detection.
--
-- 'scanType', 'h265Settings_scanType' - Sets the scan type of the output to progressive or top-field-first
-- interlaced.
--
-- 'timecodeInsertion', 'h265Settings_timecodeInsertion' - Determines how timecodes should be inserted into the video elementary
-- stream. - \'disabled\': Do not include timecodes - \'picTimingSei\':
-- Pass through picture timing SEI messages from the source specified in
-- Timecode Config
--
-- 'parNumerator', 'h265Settings_parNumerator' - Pixel Aspect Ratio numerator.
--
-- 'afdSignaling', 'h265Settings_afdSignaling' - Indicates that AFD values will be written into the output stream. If
-- afdSignaling is \"auto\", the system will try to preserve the input AFD
-- value (in cases where multiple AFD values are valid). If set to
-- \"fixed\", the AFD value will be the value configured in the fixedAfd
-- parameter.
--
-- 'gopSize', 'h265Settings_gopSize' - GOP size (keyframe interval) in units of either frames or seconds per
-- gopSizeUnits. If gopSizeUnits is frames, gopSize must be an integer and
-- must be greater than or equal to 1. If gopSizeUnits is seconds, gopSize
-- must be greater than 0, but need not be an integer.
--
-- 'gopSizeUnits', 'h265Settings_gopSizeUnits' - Indicates if the gopSize is specified in frames or seconds. If seconds
-- the system will convert the gopSize into a frame count at run time.
--
-- 'slices', 'h265Settings_slices' - Number of slices per picture. Must be less than or equal to the number
-- of macroblock rows for progressive pictures, and less than or equal to
-- half the number of macroblock rows for interlaced pictures. This field
-- is optional; when no value is specified the encoder will choose the
-- number of slices based on encode resolution.
--
-- 'profile', 'h265Settings_profile' - H.265 Profile.
--
-- 'alternativeTransferFunction', 'h265Settings_alternativeTransferFunction' - Whether or not EML should insert an Alternative Transfer Function SEI
-- message to support backwards compatibility with non-HDR decoders and
-- displays.
--
-- 'rateControlMode', 'h265Settings_rateControlMode' - Rate control mode. QVBR: Quality will match the specified quality level
-- except when it is constrained by the maximum bitrate. Recommended if you
-- or your viewers pay for bandwidth. CBR: Quality varies, depending on the
-- video complexity. Recommended only if you distribute your assets to
-- devices that cannot handle variable bitrates. Multiplex: This rate
-- control mode is only supported (and is required) when the video is being
-- delivered to a MediaLive Multiplex in which case the rate control
-- configuration is controlled by the properties within the Multiplex
-- Program.
--
-- 'minIInterval', 'h265Settings_minIInterval' - Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if
-- multiplex rate control is used. 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. Note: Maximum GOP stretch = GOP
-- size + Min-I-interval - 1
--
-- 'qvbrQualityLevel', 'h265Settings_qvbrQualityLevel' - Controls the target quality for the video encode. Applies only when the
-- rate control mode is QVBR. Set values for the QVBR quality level field
-- and Max bitrate field that suit your most important viewing devices.
-- Recommended values are: - Primary screen: Quality level: 8 to 10. Max
-- bitrate: 4M - PC or tablet: Quality level: 7. Max bitrate: 1.5M to 3M -
-- Smartphone: Quality level: 6. Max bitrate: 1M to 1.5M
--
-- 'colorSpaceSettings', 'h265Settings_colorSpaceSettings' - Color Space settings
--
-- 'flickerAq', 'h265Settings_flickerAq' - If set to enabled, adjust quantization within each frame to reduce
-- flicker or \'pop\' on I-frames.
--
-- 'bufSize', 'h265Settings_bufSize' - Size of buffer (HRD buffer model) in bits.
--
-- 'tier', 'h265Settings_tier' - H.265 Tier.
--
-- 'fixedAfd', 'h265Settings_fixedAfd' - Four bit AFD value to write on all frames of video in the output stream.
-- Only valid when afdSignaling is set to \'Fixed\'.
--
-- 'filterSettings', 'h265Settings_filterSettings' - Optional filters that you can apply to an encode.
--
-- 'bitrate', 'h265Settings_bitrate' - Average bitrate in bits\/second. Required when the rate control mode is
-- VBR or CBR. Not used for QVBR. In an MS Smooth output group, each output
-- must have a unique value when its bitrate is rounded down to the nearest
-- multiple of 1000.
--
-- 'colorMetadata', 'h265Settings_colorMetadata' - Includes colorspace metadata in the output.
--
-- 'lookAheadRateControl', 'h265Settings_lookAheadRateControl' - Amount of lookahead. A value of low can decrease latency and memory
-- usage, while high can produce better quality for certain content.
--
-- 'adaptiveQuantization', 'h265Settings_adaptiveQuantization' - Adaptive quantization. Allows intra-frame quantizers to vary to improve
-- visual quality.
--
-- 'level', 'h265Settings_level' - H.265 Level.
--
-- 'maxBitrate', 'h265Settings_maxBitrate' - For QVBR: See the tooltip for Quality level
--
-- 'gopClosedCadence', 'h265Settings_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', 'h265Settings_parDenominator' - Pixel Aspect Ratio denominator.
--
-- 'framerateNumerator', 'h265Settings_framerateNumerator' - Framerate numerator - framerate is a fraction, e.g. 24000 \/ 1001 =
-- 23.976 fps.
--
-- 'framerateDenominator', 'h265Settings_framerateDenominator' - Framerate denominator.
newH265Settings ::
  -- | 'framerateNumerator'
  Prelude.Natural ->
  -- | 'framerateDenominator'
  Prelude.Natural ->
  H265Settings
newH265Settings :: Natural -> Natural -> H265Settings
newH265Settings
  Natural
pFramerateNumerator_
  Natural
pFramerateDenominator_ =
    H265Settings' :: Maybe H265SceneChangeDetect
-> Maybe H265ScanType
-> Maybe H265TimecodeInsertionBehavior
-> Maybe Natural
-> Maybe AfdSignaling
-> Maybe Double
-> Maybe H265GopSizeUnits
-> Maybe Natural
-> Maybe H265Profile
-> Maybe H265AlternativeTransferFunction
-> Maybe H265RateControlMode
-> Maybe Natural
-> Maybe Natural
-> Maybe H265ColorSpaceSettings
-> Maybe H265FlickerAq
-> Maybe Natural
-> Maybe H265Tier
-> Maybe FixedAfd
-> Maybe H265FilterSettings
-> Maybe Natural
-> Maybe H265ColorMetadata
-> Maybe H265LookAheadRateControl
-> Maybe H265AdaptiveQuantization
-> Maybe H265Level
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Natural
-> Natural
-> H265Settings
H265Settings'
      { $sel:sceneChangeDetect:H265Settings' :: Maybe H265SceneChangeDetect
sceneChangeDetect = Maybe H265SceneChangeDetect
forall a. Maybe a
Prelude.Nothing,
        $sel:scanType:H265Settings' :: Maybe H265ScanType
scanType = Maybe H265ScanType
forall a. Maybe a
Prelude.Nothing,
        $sel:timecodeInsertion:H265Settings' :: Maybe H265TimecodeInsertionBehavior
timecodeInsertion = Maybe H265TimecodeInsertionBehavior
forall a. Maybe a
Prelude.Nothing,
        $sel:parNumerator:H265Settings' :: Maybe Natural
parNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:afdSignaling:H265Settings' :: Maybe AfdSignaling
afdSignaling = Maybe AfdSignaling
forall a. Maybe a
Prelude.Nothing,
        $sel:gopSize:H265Settings' :: Maybe Double
gopSize = Maybe Double
forall a. Maybe a
Prelude.Nothing,
        $sel:gopSizeUnits:H265Settings' :: Maybe H265GopSizeUnits
gopSizeUnits = Maybe H265GopSizeUnits
forall a. Maybe a
Prelude.Nothing,
        $sel:slices:H265Settings' :: Maybe Natural
slices = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:profile:H265Settings' :: Maybe H265Profile
profile = Maybe H265Profile
forall a. Maybe a
Prelude.Nothing,
        $sel:alternativeTransferFunction:H265Settings' :: Maybe H265AlternativeTransferFunction
alternativeTransferFunction = Maybe H265AlternativeTransferFunction
forall a. Maybe a
Prelude.Nothing,
        $sel:rateControlMode:H265Settings' :: Maybe H265RateControlMode
rateControlMode = Maybe H265RateControlMode
forall a. Maybe a
Prelude.Nothing,
        $sel:minIInterval:H265Settings' :: Maybe Natural
minIInterval = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:qvbrQualityLevel:H265Settings' :: Maybe Natural
qvbrQualityLevel = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:colorSpaceSettings:H265Settings' :: Maybe H265ColorSpaceSettings
colorSpaceSettings = Maybe H265ColorSpaceSettings
forall a. Maybe a
Prelude.Nothing,
        $sel:flickerAq:H265Settings' :: Maybe H265FlickerAq
flickerAq = Maybe H265FlickerAq
forall a. Maybe a
Prelude.Nothing,
        $sel:bufSize:H265Settings' :: Maybe Natural
bufSize = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:tier:H265Settings' :: Maybe H265Tier
tier = Maybe H265Tier
forall a. Maybe a
Prelude.Nothing,
        $sel:fixedAfd:H265Settings' :: Maybe FixedAfd
fixedAfd = Maybe FixedAfd
forall a. Maybe a
Prelude.Nothing,
        $sel:filterSettings:H265Settings' :: Maybe H265FilterSettings
filterSettings = Maybe H265FilterSettings
forall a. Maybe a
Prelude.Nothing,
        $sel:bitrate:H265Settings' :: Maybe Natural
bitrate = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:colorMetadata:H265Settings' :: Maybe H265ColorMetadata
colorMetadata = Maybe H265ColorMetadata
forall a. Maybe a
Prelude.Nothing,
        $sel:lookAheadRateControl:H265Settings' :: Maybe H265LookAheadRateControl
lookAheadRateControl = Maybe H265LookAheadRateControl
forall a. Maybe a
Prelude.Nothing,
        $sel:adaptiveQuantization:H265Settings' :: Maybe H265AdaptiveQuantization
adaptiveQuantization = Maybe H265AdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
        $sel:level:H265Settings' :: Maybe H265Level
level = Maybe H265Level
forall a. Maybe a
Prelude.Nothing,
        $sel:maxBitrate:H265Settings' :: Maybe Natural
maxBitrate = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:gopClosedCadence:H265Settings' :: Maybe Natural
gopClosedCadence = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:parDenominator:H265Settings' :: Maybe Natural
parDenominator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
        $sel:framerateNumerator:H265Settings' :: Natural
framerateNumerator = Natural
pFramerateNumerator_,
        $sel:framerateDenominator:H265Settings' :: Natural
framerateDenominator = Natural
pFramerateDenominator_
      }

-- | Scene change detection.
h265Settings_sceneChangeDetect :: Lens.Lens' H265Settings (Prelude.Maybe H265SceneChangeDetect)
h265Settings_sceneChangeDetect :: (Maybe H265SceneChangeDetect -> f (Maybe H265SceneChangeDetect))
-> H265Settings -> f H265Settings
h265Settings_sceneChangeDetect = (H265Settings -> Maybe H265SceneChangeDetect)
-> (H265Settings -> Maybe H265SceneChangeDetect -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265SceneChangeDetect)
     (Maybe H265SceneChangeDetect)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265SceneChangeDetect
sceneChangeDetect :: Maybe H265SceneChangeDetect
$sel:sceneChangeDetect:H265Settings' :: H265Settings -> Maybe H265SceneChangeDetect
sceneChangeDetect} -> Maybe H265SceneChangeDetect
sceneChangeDetect) (\s :: H265Settings
s@H265Settings' {} Maybe H265SceneChangeDetect
a -> H265Settings
s {$sel:sceneChangeDetect:H265Settings' :: Maybe H265SceneChangeDetect
sceneChangeDetect = Maybe H265SceneChangeDetect
a} :: H265Settings)

-- | Sets the scan type of the output to progressive or top-field-first
-- interlaced.
h265Settings_scanType :: Lens.Lens' H265Settings (Prelude.Maybe H265ScanType)
h265Settings_scanType :: (Maybe H265ScanType -> f (Maybe H265ScanType))
-> H265Settings -> f H265Settings
h265Settings_scanType = (H265Settings -> Maybe H265ScanType)
-> (H265Settings -> Maybe H265ScanType -> H265Settings)
-> Lens
     H265Settings H265Settings (Maybe H265ScanType) (Maybe H265ScanType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265ScanType
scanType :: Maybe H265ScanType
$sel:scanType:H265Settings' :: H265Settings -> Maybe H265ScanType
scanType} -> Maybe H265ScanType
scanType) (\s :: H265Settings
s@H265Settings' {} Maybe H265ScanType
a -> H265Settings
s {$sel:scanType:H265Settings' :: Maybe H265ScanType
scanType = Maybe H265ScanType
a} :: H265Settings)

-- | Determines how timecodes should be inserted into the video elementary
-- stream. - \'disabled\': Do not include timecodes - \'picTimingSei\':
-- Pass through picture timing SEI messages from the source specified in
-- Timecode Config
h265Settings_timecodeInsertion :: Lens.Lens' H265Settings (Prelude.Maybe H265TimecodeInsertionBehavior)
h265Settings_timecodeInsertion :: (Maybe H265TimecodeInsertionBehavior
 -> f (Maybe H265TimecodeInsertionBehavior))
-> H265Settings -> f H265Settings
h265Settings_timecodeInsertion = (H265Settings -> Maybe H265TimecodeInsertionBehavior)
-> (H265Settings
    -> Maybe H265TimecodeInsertionBehavior -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265TimecodeInsertionBehavior)
     (Maybe H265TimecodeInsertionBehavior)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265TimecodeInsertionBehavior
timecodeInsertion :: Maybe H265TimecodeInsertionBehavior
$sel:timecodeInsertion:H265Settings' :: H265Settings -> Maybe H265TimecodeInsertionBehavior
timecodeInsertion} -> Maybe H265TimecodeInsertionBehavior
timecodeInsertion) (\s :: H265Settings
s@H265Settings' {} Maybe H265TimecodeInsertionBehavior
a -> H265Settings
s {$sel:timecodeInsertion:H265Settings' :: Maybe H265TimecodeInsertionBehavior
timecodeInsertion = Maybe H265TimecodeInsertionBehavior
a} :: H265Settings)

-- | Pixel Aspect Ratio numerator.
h265Settings_parNumerator :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_parNumerator :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_parNumerator = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
parNumerator :: Maybe Natural
$sel:parNumerator:H265Settings' :: H265Settings -> Maybe Natural
parNumerator} -> Maybe Natural
parNumerator) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:parNumerator:H265Settings' :: Maybe Natural
parNumerator = Maybe Natural
a} :: H265Settings)

-- | Indicates that AFD values will be written into the output stream. If
-- afdSignaling is \"auto\", the system will try to preserve the input AFD
-- value (in cases where multiple AFD values are valid). If set to
-- \"fixed\", the AFD value will be the value configured in the fixedAfd
-- parameter.
h265Settings_afdSignaling :: Lens.Lens' H265Settings (Prelude.Maybe AfdSignaling)
h265Settings_afdSignaling :: (Maybe AfdSignaling -> f (Maybe AfdSignaling))
-> H265Settings -> f H265Settings
h265Settings_afdSignaling = (H265Settings -> Maybe AfdSignaling)
-> (H265Settings -> Maybe AfdSignaling -> H265Settings)
-> Lens
     H265Settings H265Settings (Maybe AfdSignaling) (Maybe AfdSignaling)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe AfdSignaling
afdSignaling :: Maybe AfdSignaling
$sel:afdSignaling:H265Settings' :: H265Settings -> Maybe AfdSignaling
afdSignaling} -> Maybe AfdSignaling
afdSignaling) (\s :: H265Settings
s@H265Settings' {} Maybe AfdSignaling
a -> H265Settings
s {$sel:afdSignaling:H265Settings' :: Maybe AfdSignaling
afdSignaling = Maybe AfdSignaling
a} :: H265Settings)

-- | GOP size (keyframe interval) in units of either frames or seconds per
-- gopSizeUnits. If gopSizeUnits is frames, gopSize must be an integer and
-- must be greater than or equal to 1. If gopSizeUnits is seconds, gopSize
-- must be greater than 0, but need not be an integer.
h265Settings_gopSize :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Double)
h265Settings_gopSize :: (Maybe Double -> f (Maybe Double))
-> H265Settings -> f H265Settings
h265Settings_gopSize = (H265Settings -> Maybe Double)
-> (H265Settings -> Maybe Double -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Double) (Maybe Double)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Double
gopSize :: Maybe Double
$sel:gopSize:H265Settings' :: H265Settings -> Maybe Double
gopSize} -> Maybe Double
gopSize) (\s :: H265Settings
s@H265Settings' {} Maybe Double
a -> H265Settings
s {$sel:gopSize:H265Settings' :: Maybe Double
gopSize = Maybe Double
a} :: H265Settings)

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

-- | Number of slices per picture. Must be less than or equal to the number
-- of macroblock rows for progressive pictures, and less than or equal to
-- half the number of macroblock rows for interlaced pictures. This field
-- is optional; when no value is specified the encoder will choose the
-- number of slices based on encode resolution.
h265Settings_slices :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_slices :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_slices = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
slices :: Maybe Natural
$sel:slices:H265Settings' :: H265Settings -> Maybe Natural
slices} -> Maybe Natural
slices) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:slices:H265Settings' :: Maybe Natural
slices = Maybe Natural
a} :: H265Settings)

-- | H.265 Profile.
h265Settings_profile :: Lens.Lens' H265Settings (Prelude.Maybe H265Profile)
h265Settings_profile :: (Maybe H265Profile -> f (Maybe H265Profile))
-> H265Settings -> f H265Settings
h265Settings_profile = (H265Settings -> Maybe H265Profile)
-> (H265Settings -> Maybe H265Profile -> H265Settings)
-> Lens
     H265Settings H265Settings (Maybe H265Profile) (Maybe H265Profile)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265Profile
profile :: Maybe H265Profile
$sel:profile:H265Settings' :: H265Settings -> Maybe H265Profile
profile} -> Maybe H265Profile
profile) (\s :: H265Settings
s@H265Settings' {} Maybe H265Profile
a -> H265Settings
s {$sel:profile:H265Settings' :: Maybe H265Profile
profile = Maybe H265Profile
a} :: H265Settings)

-- | Whether or not EML should insert an Alternative Transfer Function SEI
-- message to support backwards compatibility with non-HDR decoders and
-- displays.
h265Settings_alternativeTransferFunction :: Lens.Lens' H265Settings (Prelude.Maybe H265AlternativeTransferFunction)
h265Settings_alternativeTransferFunction :: (Maybe H265AlternativeTransferFunction
 -> f (Maybe H265AlternativeTransferFunction))
-> H265Settings -> f H265Settings
h265Settings_alternativeTransferFunction = (H265Settings -> Maybe H265AlternativeTransferFunction)
-> (H265Settings
    -> Maybe H265AlternativeTransferFunction -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265AlternativeTransferFunction)
     (Maybe H265AlternativeTransferFunction)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265AlternativeTransferFunction
alternativeTransferFunction :: Maybe H265AlternativeTransferFunction
$sel:alternativeTransferFunction:H265Settings' :: H265Settings -> Maybe H265AlternativeTransferFunction
alternativeTransferFunction} -> Maybe H265AlternativeTransferFunction
alternativeTransferFunction) (\s :: H265Settings
s@H265Settings' {} Maybe H265AlternativeTransferFunction
a -> H265Settings
s {$sel:alternativeTransferFunction:H265Settings' :: Maybe H265AlternativeTransferFunction
alternativeTransferFunction = Maybe H265AlternativeTransferFunction
a} :: H265Settings)

-- | Rate control mode. QVBR: Quality will match the specified quality level
-- except when it is constrained by the maximum bitrate. Recommended if you
-- or your viewers pay for bandwidth. CBR: Quality varies, depending on the
-- video complexity. Recommended only if you distribute your assets to
-- devices that cannot handle variable bitrates. Multiplex: This rate
-- control mode is only supported (and is required) when the video is being
-- delivered to a MediaLive Multiplex in which case the rate control
-- configuration is controlled by the properties within the Multiplex
-- Program.
h265Settings_rateControlMode :: Lens.Lens' H265Settings (Prelude.Maybe H265RateControlMode)
h265Settings_rateControlMode :: (Maybe H265RateControlMode -> f (Maybe H265RateControlMode))
-> H265Settings -> f H265Settings
h265Settings_rateControlMode = (H265Settings -> Maybe H265RateControlMode)
-> (H265Settings -> Maybe H265RateControlMode -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265RateControlMode)
     (Maybe H265RateControlMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265RateControlMode
rateControlMode :: Maybe H265RateControlMode
$sel:rateControlMode:H265Settings' :: H265Settings -> Maybe H265RateControlMode
rateControlMode} -> Maybe H265RateControlMode
rateControlMode) (\s :: H265Settings
s@H265Settings' {} Maybe H265RateControlMode
a -> H265Settings
s {$sel:rateControlMode:H265Settings' :: Maybe H265RateControlMode
rateControlMode = Maybe H265RateControlMode
a} :: H265Settings)

-- | Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if
-- multiplex rate control is used. 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. Note: Maximum GOP stretch = GOP
-- size + Min-I-interval - 1
h265Settings_minIInterval :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_minIInterval :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_minIInterval = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
minIInterval :: Maybe Natural
$sel:minIInterval:H265Settings' :: H265Settings -> Maybe Natural
minIInterval} -> Maybe Natural
minIInterval) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:minIInterval:H265Settings' :: Maybe Natural
minIInterval = Maybe Natural
a} :: H265Settings)

-- | Controls the target quality for the video encode. Applies only when the
-- rate control mode is QVBR. Set values for the QVBR quality level field
-- and Max bitrate field that suit your most important viewing devices.
-- Recommended values are: - Primary screen: Quality level: 8 to 10. Max
-- bitrate: 4M - PC or tablet: Quality level: 7. Max bitrate: 1.5M to 3M -
-- Smartphone: Quality level: 6. Max bitrate: 1M to 1.5M
h265Settings_qvbrQualityLevel :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_qvbrQualityLevel :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_qvbrQualityLevel = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
qvbrQualityLevel :: Maybe Natural
$sel:qvbrQualityLevel:H265Settings' :: H265Settings -> Maybe Natural
qvbrQualityLevel} -> Maybe Natural
qvbrQualityLevel) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:qvbrQualityLevel:H265Settings' :: Maybe Natural
qvbrQualityLevel = Maybe Natural
a} :: H265Settings)

-- | Color Space settings
h265Settings_colorSpaceSettings :: Lens.Lens' H265Settings (Prelude.Maybe H265ColorSpaceSettings)
h265Settings_colorSpaceSettings :: (Maybe H265ColorSpaceSettings -> f (Maybe H265ColorSpaceSettings))
-> H265Settings -> f H265Settings
h265Settings_colorSpaceSettings = (H265Settings -> Maybe H265ColorSpaceSettings)
-> (H265Settings -> Maybe H265ColorSpaceSettings -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265ColorSpaceSettings)
     (Maybe H265ColorSpaceSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265ColorSpaceSettings
colorSpaceSettings :: Maybe H265ColorSpaceSettings
$sel:colorSpaceSettings:H265Settings' :: H265Settings -> Maybe H265ColorSpaceSettings
colorSpaceSettings} -> Maybe H265ColorSpaceSettings
colorSpaceSettings) (\s :: H265Settings
s@H265Settings' {} Maybe H265ColorSpaceSettings
a -> H265Settings
s {$sel:colorSpaceSettings:H265Settings' :: Maybe H265ColorSpaceSettings
colorSpaceSettings = Maybe H265ColorSpaceSettings
a} :: H265Settings)

-- | If set to enabled, adjust quantization within each frame to reduce
-- flicker or \'pop\' on I-frames.
h265Settings_flickerAq :: Lens.Lens' H265Settings (Prelude.Maybe H265FlickerAq)
h265Settings_flickerAq :: (Maybe H265FlickerAq -> f (Maybe H265FlickerAq))
-> H265Settings -> f H265Settings
h265Settings_flickerAq = (H265Settings -> Maybe H265FlickerAq)
-> (H265Settings -> Maybe H265FlickerAq -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265FlickerAq)
     (Maybe H265FlickerAq)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265FlickerAq
flickerAq :: Maybe H265FlickerAq
$sel:flickerAq:H265Settings' :: H265Settings -> Maybe H265FlickerAq
flickerAq} -> Maybe H265FlickerAq
flickerAq) (\s :: H265Settings
s@H265Settings' {} Maybe H265FlickerAq
a -> H265Settings
s {$sel:flickerAq:H265Settings' :: Maybe H265FlickerAq
flickerAq = Maybe H265FlickerAq
a} :: H265Settings)

-- | Size of buffer (HRD buffer model) in bits.
h265Settings_bufSize :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_bufSize :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_bufSize = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
bufSize :: Maybe Natural
$sel:bufSize:H265Settings' :: H265Settings -> Maybe Natural
bufSize} -> Maybe Natural
bufSize) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:bufSize:H265Settings' :: Maybe Natural
bufSize = Maybe Natural
a} :: H265Settings)

-- | H.265 Tier.
h265Settings_tier :: Lens.Lens' H265Settings (Prelude.Maybe H265Tier)
h265Settings_tier :: (Maybe H265Tier -> f (Maybe H265Tier))
-> H265Settings -> f H265Settings
h265Settings_tier = (H265Settings -> Maybe H265Tier)
-> (H265Settings -> Maybe H265Tier -> H265Settings)
-> Lens H265Settings H265Settings (Maybe H265Tier) (Maybe H265Tier)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265Tier
tier :: Maybe H265Tier
$sel:tier:H265Settings' :: H265Settings -> Maybe H265Tier
tier} -> Maybe H265Tier
tier) (\s :: H265Settings
s@H265Settings' {} Maybe H265Tier
a -> H265Settings
s {$sel:tier:H265Settings' :: Maybe H265Tier
tier = Maybe H265Tier
a} :: H265Settings)

-- | Four bit AFD value to write on all frames of video in the output stream.
-- Only valid when afdSignaling is set to \'Fixed\'.
h265Settings_fixedAfd :: Lens.Lens' H265Settings (Prelude.Maybe FixedAfd)
h265Settings_fixedAfd :: (Maybe FixedAfd -> f (Maybe FixedAfd))
-> H265Settings -> f H265Settings
h265Settings_fixedAfd = (H265Settings -> Maybe FixedAfd)
-> (H265Settings -> Maybe FixedAfd -> H265Settings)
-> Lens H265Settings H265Settings (Maybe FixedAfd) (Maybe FixedAfd)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe FixedAfd
fixedAfd :: Maybe FixedAfd
$sel:fixedAfd:H265Settings' :: H265Settings -> Maybe FixedAfd
fixedAfd} -> Maybe FixedAfd
fixedAfd) (\s :: H265Settings
s@H265Settings' {} Maybe FixedAfd
a -> H265Settings
s {$sel:fixedAfd:H265Settings' :: Maybe FixedAfd
fixedAfd = Maybe FixedAfd
a} :: H265Settings)

-- | Optional filters that you can apply to an encode.
h265Settings_filterSettings :: Lens.Lens' H265Settings (Prelude.Maybe H265FilterSettings)
h265Settings_filterSettings :: (Maybe H265FilterSettings -> f (Maybe H265FilterSettings))
-> H265Settings -> f H265Settings
h265Settings_filterSettings = (H265Settings -> Maybe H265FilterSettings)
-> (H265Settings -> Maybe H265FilterSettings -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265FilterSettings)
     (Maybe H265FilterSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265FilterSettings
filterSettings :: Maybe H265FilterSettings
$sel:filterSettings:H265Settings' :: H265Settings -> Maybe H265FilterSettings
filterSettings} -> Maybe H265FilterSettings
filterSettings) (\s :: H265Settings
s@H265Settings' {} Maybe H265FilterSettings
a -> H265Settings
s {$sel:filterSettings:H265Settings' :: Maybe H265FilterSettings
filterSettings = Maybe H265FilterSettings
a} :: H265Settings)

-- | Average bitrate in bits\/second. Required when the rate control mode is
-- VBR or CBR. Not used for QVBR. In an MS Smooth output group, each output
-- must have a unique value when its bitrate is rounded down to the nearest
-- multiple of 1000.
h265Settings_bitrate :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_bitrate :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_bitrate = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
bitrate :: Maybe Natural
$sel:bitrate:H265Settings' :: H265Settings -> Maybe Natural
bitrate} -> Maybe Natural
bitrate) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:bitrate:H265Settings' :: Maybe Natural
bitrate = Maybe Natural
a} :: H265Settings)

-- | Includes colorspace metadata in the output.
h265Settings_colorMetadata :: Lens.Lens' H265Settings (Prelude.Maybe H265ColorMetadata)
h265Settings_colorMetadata :: (Maybe H265ColorMetadata -> f (Maybe H265ColorMetadata))
-> H265Settings -> f H265Settings
h265Settings_colorMetadata = (H265Settings -> Maybe H265ColorMetadata)
-> (H265Settings -> Maybe H265ColorMetadata -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265ColorMetadata)
     (Maybe H265ColorMetadata)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265ColorMetadata
colorMetadata :: Maybe H265ColorMetadata
$sel:colorMetadata:H265Settings' :: H265Settings -> Maybe H265ColorMetadata
colorMetadata} -> Maybe H265ColorMetadata
colorMetadata) (\s :: H265Settings
s@H265Settings' {} Maybe H265ColorMetadata
a -> H265Settings
s {$sel:colorMetadata:H265Settings' :: Maybe H265ColorMetadata
colorMetadata = Maybe H265ColorMetadata
a} :: H265Settings)

-- | Amount of lookahead. A value of low can decrease latency and memory
-- usage, while high can produce better quality for certain content.
h265Settings_lookAheadRateControl :: Lens.Lens' H265Settings (Prelude.Maybe H265LookAheadRateControl)
h265Settings_lookAheadRateControl :: (Maybe H265LookAheadRateControl
 -> f (Maybe H265LookAheadRateControl))
-> H265Settings -> f H265Settings
h265Settings_lookAheadRateControl = (H265Settings -> Maybe H265LookAheadRateControl)
-> (H265Settings -> Maybe H265LookAheadRateControl -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265LookAheadRateControl)
     (Maybe H265LookAheadRateControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265LookAheadRateControl
lookAheadRateControl :: Maybe H265LookAheadRateControl
$sel:lookAheadRateControl:H265Settings' :: H265Settings -> Maybe H265LookAheadRateControl
lookAheadRateControl} -> Maybe H265LookAheadRateControl
lookAheadRateControl) (\s :: H265Settings
s@H265Settings' {} Maybe H265LookAheadRateControl
a -> H265Settings
s {$sel:lookAheadRateControl:H265Settings' :: Maybe H265LookAheadRateControl
lookAheadRateControl = Maybe H265LookAheadRateControl
a} :: H265Settings)

-- | Adaptive quantization. Allows intra-frame quantizers to vary to improve
-- visual quality.
h265Settings_adaptiveQuantization :: Lens.Lens' H265Settings (Prelude.Maybe H265AdaptiveQuantization)
h265Settings_adaptiveQuantization :: (Maybe H265AdaptiveQuantization
 -> f (Maybe H265AdaptiveQuantization))
-> H265Settings -> f H265Settings
h265Settings_adaptiveQuantization = (H265Settings -> Maybe H265AdaptiveQuantization)
-> (H265Settings -> Maybe H265AdaptiveQuantization -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265AdaptiveQuantization)
     (Maybe H265AdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265AdaptiveQuantization
adaptiveQuantization :: Maybe H265AdaptiveQuantization
$sel:adaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265AdaptiveQuantization
adaptiveQuantization} -> Maybe H265AdaptiveQuantization
adaptiveQuantization) (\s :: H265Settings
s@H265Settings' {} Maybe H265AdaptiveQuantization
a -> H265Settings
s {$sel:adaptiveQuantization:H265Settings' :: Maybe H265AdaptiveQuantization
adaptiveQuantization = Maybe H265AdaptiveQuantization
a} :: H265Settings)

-- | H.265 Level.
h265Settings_level :: Lens.Lens' H265Settings (Prelude.Maybe H265Level)
h265Settings_level :: (Maybe H265Level -> f (Maybe H265Level))
-> H265Settings -> f H265Settings
h265Settings_level = (H265Settings -> Maybe H265Level)
-> (H265Settings -> Maybe H265Level -> H265Settings)
-> Lens
     H265Settings H265Settings (Maybe H265Level) (Maybe H265Level)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265Level
level :: Maybe H265Level
$sel:level:H265Settings' :: H265Settings -> Maybe H265Level
level} -> Maybe H265Level
level) (\s :: H265Settings
s@H265Settings' {} Maybe H265Level
a -> H265Settings
s {$sel:level:H265Settings' :: Maybe H265Level
level = Maybe H265Level
a} :: H265Settings)

-- | For QVBR: See the tooltip for Quality level
h265Settings_maxBitrate :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_maxBitrate :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_maxBitrate = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
maxBitrate :: Maybe Natural
$sel:maxBitrate:H265Settings' :: H265Settings -> Maybe Natural
maxBitrate} -> Maybe Natural
maxBitrate) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:maxBitrate:H265Settings' :: Maybe Natural
maxBitrate = Maybe Natural
a} :: H265Settings)

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

-- | Pixel Aspect Ratio denominator.
h265Settings_parDenominator :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_parDenominator :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_parDenominator = (H265Settings -> Maybe Natural)
-> (H265Settings -> Maybe Natural -> H265Settings)
-> Lens H265Settings H265Settings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe Natural
parDenominator :: Maybe Natural
$sel:parDenominator:H265Settings' :: H265Settings -> Maybe Natural
parDenominator} -> Maybe Natural
parDenominator) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:parDenominator:H265Settings' :: Maybe Natural
parDenominator = Maybe Natural
a} :: H265Settings)

-- | Framerate numerator - framerate is a fraction, e.g. 24000 \/ 1001 =
-- 23.976 fps.
h265Settings_framerateNumerator :: Lens.Lens' H265Settings Prelude.Natural
h265Settings_framerateNumerator :: (Natural -> f Natural) -> H265Settings -> f H265Settings
h265Settings_framerateNumerator = (H265Settings -> Natural)
-> (H265Settings -> Natural -> H265Settings)
-> Lens H265Settings H265Settings Natural Natural
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Natural
framerateNumerator :: Natural
$sel:framerateNumerator:H265Settings' :: H265Settings -> Natural
framerateNumerator} -> Natural
framerateNumerator) (\s :: H265Settings
s@H265Settings' {} Natural
a -> H265Settings
s {$sel:framerateNumerator:H265Settings' :: Natural
framerateNumerator = Natural
a} :: H265Settings)

-- | Framerate denominator.
h265Settings_framerateDenominator :: Lens.Lens' H265Settings Prelude.Natural
h265Settings_framerateDenominator :: (Natural -> f Natural) -> H265Settings -> f H265Settings
h265Settings_framerateDenominator = (H265Settings -> Natural)
-> (H265Settings -> Natural -> H265Settings)
-> Lens H265Settings H265Settings Natural Natural
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Natural
framerateDenominator :: Natural
$sel:framerateDenominator:H265Settings' :: H265Settings -> Natural
framerateDenominator} -> Natural
framerateDenominator) (\s :: H265Settings
s@H265Settings' {} Natural
a -> H265Settings
s {$sel:framerateDenominator:H265Settings' :: Natural
framerateDenominator = Natural
a} :: H265Settings)

instance Core.FromJSON H265Settings where
  parseJSON :: Value -> Parser H265Settings
parseJSON =
    String
-> (Object -> Parser H265Settings) -> Value -> Parser H265Settings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"H265Settings"
      ( \Object
x ->
          Maybe H265SceneChangeDetect
-> Maybe H265ScanType
-> Maybe H265TimecodeInsertionBehavior
-> Maybe Natural
-> Maybe AfdSignaling
-> Maybe Double
-> Maybe H265GopSizeUnits
-> Maybe Natural
-> Maybe H265Profile
-> Maybe H265AlternativeTransferFunction
-> Maybe H265RateControlMode
-> Maybe Natural
-> Maybe Natural
-> Maybe H265ColorSpaceSettings
-> Maybe H265FlickerAq
-> Maybe Natural
-> Maybe H265Tier
-> Maybe FixedAfd
-> Maybe H265FilterSettings
-> Maybe Natural
-> Maybe H265ColorMetadata
-> Maybe H265LookAheadRateControl
-> Maybe H265AdaptiveQuantization
-> Maybe H265Level
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Natural
-> Natural
-> H265Settings
H265Settings'
            (Maybe H265SceneChangeDetect
 -> Maybe H265ScanType
 -> Maybe H265TimecodeInsertionBehavior
 -> Maybe Natural
 -> Maybe AfdSignaling
 -> Maybe Double
 -> Maybe H265GopSizeUnits
 -> Maybe Natural
 -> Maybe H265Profile
 -> Maybe H265AlternativeTransferFunction
 -> Maybe H265RateControlMode
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe H265ColorSpaceSettings
 -> Maybe H265FlickerAq
 -> Maybe Natural
 -> Maybe H265Tier
 -> Maybe FixedAfd
 -> Maybe H265FilterSettings
 -> Maybe Natural
 -> Maybe H265ColorMetadata
 -> Maybe H265LookAheadRateControl
 -> Maybe H265AdaptiveQuantization
 -> Maybe H265Level
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe Natural
 -> Natural
 -> Natural
 -> H265Settings)
-> Parser (Maybe H265SceneChangeDetect)
-> Parser
     (Maybe H265ScanType
      -> Maybe H265TimecodeInsertionBehavior
      -> Maybe Natural
      -> Maybe AfdSignaling
      -> Maybe Double
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe H265SceneChangeDetect)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"sceneChangeDetect")
            Parser
  (Maybe H265ScanType
   -> Maybe H265TimecodeInsertionBehavior
   -> Maybe Natural
   -> Maybe AfdSignaling
   -> Maybe Double
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265ScanType)
-> Parser
     (Maybe H265TimecodeInsertionBehavior
      -> Maybe Natural
      -> Maybe AfdSignaling
      -> Maybe Double
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265ScanType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"scanType")
            Parser
  (Maybe H265TimecodeInsertionBehavior
   -> Maybe Natural
   -> Maybe AfdSignaling
   -> Maybe Double
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265TimecodeInsertionBehavior)
-> Parser
     (Maybe Natural
      -> Maybe AfdSignaling
      -> Maybe Double
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265TimecodeInsertionBehavior)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"timecodeInsertion")
            Parser
  (Maybe Natural
   -> Maybe AfdSignaling
   -> Maybe Double
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe AfdSignaling
      -> Maybe Double
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
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 AfdSignaling
   -> Maybe Double
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe AfdSignaling)
-> Parser
     (Maybe Double
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe AfdSignaling)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"afdSignaling")
            Parser
  (Maybe Double
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Double)
-> Parser
     (Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
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 H265GopSizeUnits
   -> Maybe Natural
   -> Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265GopSizeUnits)
-> Parser
     (Maybe Natural
      -> Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265GopSizeUnits)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"gopSizeUnits")
            Parser
  (Maybe Natural
   -> Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265Profile
      -> Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"slices")
            Parser
  (Maybe H265Profile
   -> Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265Profile)
-> Parser
     (Maybe H265AlternativeTransferFunction
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265Profile)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"profile")
            Parser
  (Maybe H265AlternativeTransferFunction
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265AlternativeTransferFunction)
-> Parser
     (Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265AlternativeTransferFunction)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"alternativeTransferFunction")
            Parser
  (Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265RateControlMode)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265RateControlMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"rateControlMode")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
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 Natural
   -> Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265ColorSpaceSettings
      -> Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
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
"qvbrQualityLevel")
            Parser
  (Maybe H265ColorSpaceSettings
   -> Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265ColorSpaceSettings)
-> Parser
     (Maybe H265FlickerAq
      -> Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265ColorSpaceSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"colorSpaceSettings")
            Parser
  (Maybe H265FlickerAq
   -> Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265FlickerAq)
-> Parser
     (Maybe Natural
      -> Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265FlickerAq)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"flickerAq")
            Parser
  (Maybe Natural
   -> Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265Tier
      -> Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
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
"bufSize")
            Parser
  (Maybe H265Tier
   -> Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265Tier)
-> Parser
     (Maybe FixedAfd
      -> Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265Tier)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"tier")
            Parser
  (Maybe FixedAfd
   -> Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe FixedAfd)
-> Parser
     (Maybe H265FilterSettings
      -> Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe FixedAfd)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"fixedAfd")
            Parser
  (Maybe H265FilterSettings
   -> Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265FilterSettings)
-> Parser
     (Maybe Natural
      -> Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265FilterSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"filterSettings")
            Parser
  (Maybe Natural
   -> Maybe H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265ColorMetadata
      -> Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
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 H265ColorMetadata
   -> Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265ColorMetadata)
-> Parser
     (Maybe H265LookAheadRateControl
      -> Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265ColorMetadata)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"colorMetadata")
            Parser
  (Maybe H265LookAheadRateControl
   -> Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265LookAheadRateControl)
-> Parser
     (Maybe H265AdaptiveQuantization
      -> Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265LookAheadRateControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"lookAheadRateControl")
            Parser
  (Maybe H265AdaptiveQuantization
   -> Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265AdaptiveQuantization)
-> Parser
     (Maybe H265Level
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265AdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"adaptiveQuantization")
            Parser
  (Maybe H265Level
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe H265Level)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Natural
      -> Natural
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265Level)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"level")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Natural
   -> Natural
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe Natural -> Natural -> Natural -> H265Settings)
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 Natural
   -> Maybe Natural -> Natural -> Natural -> H265Settings)
-> Parser (Maybe Natural)
-> Parser (Maybe Natural -> Natural -> Natural -> H265Settings)
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 -> Natural -> Natural -> H265Settings)
-> Parser (Maybe Natural)
-> Parser (Natural -> Natural -> H265Settings)
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 (Natural -> Natural -> H265Settings)
-> Parser Natural -> Parser (Natural -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser Natural
forall a. FromJSON a => Object -> Text -> Parser a
Core..: Text
"framerateNumerator")
            Parser (Natural -> H265Settings)
-> Parser Natural -> Parser H265Settings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser Natural
forall a. FromJSON a => Object -> Text -> Parser a
Core..: Text
"framerateDenominator")
      )

instance Prelude.Hashable H265Settings

instance Prelude.NFData H265Settings

instance Core.ToJSON H265Settings where
  toJSON :: H265Settings -> Value
toJSON H265Settings' {Natural
Maybe Double
Maybe Natural
Maybe AfdSignaling
Maybe FixedAfd
Maybe H265AdaptiveQuantization
Maybe H265AlternativeTransferFunction
Maybe H265ColorMetadata
Maybe H265FlickerAq
Maybe H265GopSizeUnits
Maybe H265Level
Maybe H265LookAheadRateControl
Maybe H265Profile
Maybe H265RateControlMode
Maybe H265ScanType
Maybe H265SceneChangeDetect
Maybe H265Tier
Maybe H265TimecodeInsertionBehavior
Maybe H265ColorSpaceSettings
Maybe H265FilterSettings
framerateDenominator :: Natural
framerateNumerator :: Natural
parDenominator :: Maybe Natural
gopClosedCadence :: Maybe Natural
maxBitrate :: Maybe Natural
level :: Maybe H265Level
adaptiveQuantization :: Maybe H265AdaptiveQuantization
lookAheadRateControl :: Maybe H265LookAheadRateControl
colorMetadata :: Maybe H265ColorMetadata
bitrate :: Maybe Natural
filterSettings :: Maybe H265FilterSettings
fixedAfd :: Maybe FixedAfd
tier :: Maybe H265Tier
bufSize :: Maybe Natural
flickerAq :: Maybe H265FlickerAq
colorSpaceSettings :: Maybe H265ColorSpaceSettings
qvbrQualityLevel :: Maybe Natural
minIInterval :: Maybe Natural
rateControlMode :: Maybe H265RateControlMode
alternativeTransferFunction :: Maybe H265AlternativeTransferFunction
profile :: Maybe H265Profile
slices :: Maybe Natural
gopSizeUnits :: Maybe H265GopSizeUnits
gopSize :: Maybe Double
afdSignaling :: Maybe AfdSignaling
parNumerator :: Maybe Natural
timecodeInsertion :: Maybe H265TimecodeInsertionBehavior
scanType :: Maybe H265ScanType
sceneChangeDetect :: Maybe H265SceneChangeDetect
$sel:framerateDenominator:H265Settings' :: H265Settings -> Natural
$sel:framerateNumerator:H265Settings' :: H265Settings -> Natural
$sel:parDenominator:H265Settings' :: H265Settings -> Maybe Natural
$sel:gopClosedCadence:H265Settings' :: H265Settings -> Maybe Natural
$sel:maxBitrate:H265Settings' :: H265Settings -> Maybe Natural
$sel:level:H265Settings' :: H265Settings -> Maybe H265Level
$sel:adaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265AdaptiveQuantization
$sel:lookAheadRateControl:H265Settings' :: H265Settings -> Maybe H265LookAheadRateControl
$sel:colorMetadata:H265Settings' :: H265Settings -> Maybe H265ColorMetadata
$sel:bitrate:H265Settings' :: H265Settings -> Maybe Natural
$sel:filterSettings:H265Settings' :: H265Settings -> Maybe H265FilterSettings
$sel:fixedAfd:H265Settings' :: H265Settings -> Maybe FixedAfd
$sel:tier:H265Settings' :: H265Settings -> Maybe H265Tier
$sel:bufSize:H265Settings' :: H265Settings -> Maybe Natural
$sel:flickerAq:H265Settings' :: H265Settings -> Maybe H265FlickerAq
$sel:colorSpaceSettings:H265Settings' :: H265Settings -> Maybe H265ColorSpaceSettings
$sel:qvbrQualityLevel:H265Settings' :: H265Settings -> Maybe Natural
$sel:minIInterval:H265Settings' :: H265Settings -> Maybe Natural
$sel:rateControlMode:H265Settings' :: H265Settings -> Maybe H265RateControlMode
$sel:alternativeTransferFunction:H265Settings' :: H265Settings -> Maybe H265AlternativeTransferFunction
$sel:profile:H265Settings' :: H265Settings -> Maybe H265Profile
$sel:slices:H265Settings' :: H265Settings -> Maybe Natural
$sel:gopSizeUnits:H265Settings' :: H265Settings -> Maybe H265GopSizeUnits
$sel:gopSize:H265Settings' :: H265Settings -> Maybe Double
$sel:afdSignaling:H265Settings' :: H265Settings -> Maybe AfdSignaling
$sel:parNumerator:H265Settings' :: H265Settings -> Maybe Natural
$sel:timecodeInsertion:H265Settings' :: H265Settings -> Maybe H265TimecodeInsertionBehavior
$sel:scanType:H265Settings' :: H265Settings -> Maybe H265ScanType
$sel:sceneChangeDetect:H265Settings' :: H265Settings -> Maybe H265SceneChangeDetect
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"sceneChangeDetect" Text -> H265SceneChangeDetect -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265SceneChangeDetect -> Pair)
-> Maybe H265SceneChangeDetect -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265SceneChangeDetect
sceneChangeDetect,
            (Text
"scanType" Text -> H265ScanType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265ScanType -> Pair) -> Maybe H265ScanType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265ScanType
scanType,
            (Text
"timecodeInsertion" Text -> H265TimecodeInsertionBehavior -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265TimecodeInsertionBehavior -> Pair)
-> Maybe H265TimecodeInsertionBehavior -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265TimecodeInsertionBehavior
timecodeInsertion,
            (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
"afdSignaling" Text -> AfdSignaling -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (AfdSignaling -> Pair) -> Maybe AfdSignaling -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe AfdSignaling
afdSignaling,
            (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
"gopSizeUnits" Text -> H265GopSizeUnits -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265GopSizeUnits -> Pair) -> Maybe H265GopSizeUnits -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265GopSizeUnits
gopSizeUnits,
            (Text
"slices" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
slices,
            (Text
"profile" Text -> H265Profile -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265Profile -> Pair) -> Maybe H265Profile -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265Profile
profile,
            (Text
"alternativeTransferFunction" Text -> H265AlternativeTransferFunction -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265AlternativeTransferFunction -> Pair)
-> Maybe H265AlternativeTransferFunction -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265AlternativeTransferFunction
alternativeTransferFunction,
            (Text
"rateControlMode" Text -> H265RateControlMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265RateControlMode -> Pair)
-> Maybe H265RateControlMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265RateControlMode
rateControlMode,
            (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
"qvbrQualityLevel" 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
qvbrQualityLevel,
            (Text
"colorSpaceSettings" Text -> H265ColorSpaceSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265ColorSpaceSettings -> Pair)
-> Maybe H265ColorSpaceSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265ColorSpaceSettings
colorSpaceSettings,
            (Text
"flickerAq" Text -> H265FlickerAq -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265FlickerAq -> Pair) -> Maybe H265FlickerAq -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265FlickerAq
flickerAq,
            (Text
"bufSize" 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
bufSize,
            (Text
"tier" Text -> H265Tier -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265Tier -> Pair) -> Maybe H265Tier -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265Tier
tier,
            (Text
"fixedAfd" Text -> FixedAfd -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (FixedAfd -> Pair) -> Maybe FixedAfd -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe FixedAfd
fixedAfd,
            (Text
"filterSettings" Text -> H265FilterSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265FilterSettings -> Pair)
-> Maybe H265FilterSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265FilterSettings
filterSettings,
            (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
"colorMetadata" Text -> H265ColorMetadata -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265ColorMetadata -> Pair)
-> Maybe H265ColorMetadata -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265ColorMetadata
colorMetadata,
            (Text
"lookAheadRateControl" Text -> H265LookAheadRateControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265LookAheadRateControl -> Pair)
-> Maybe H265LookAheadRateControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265LookAheadRateControl
lookAheadRateControl,
            (Text
"adaptiveQuantization" Text -> H265AdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265AdaptiveQuantization -> Pair)
-> Maybe H265AdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265AdaptiveQuantization
adaptiveQuantization,
            (Text
"level" Text -> H265Level -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265Level -> Pair) -> Maybe H265Level -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265Level
level,
            (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
"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,
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              (Text
"framerateNumerator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Natural
framerateNumerator),
            Pair -> Maybe Pair
forall a. a -> Maybe a
Prelude.Just
              ( Text
"framerateDenominator"
                  Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..= Natural
framerateDenominator
              )
          ]
      )