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

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

-- |
-- Module      : Amazonka.MediaConvert.Types.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.MediaConvert.Types.H265Settings where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaConvert.Types.H265AdaptiveQuantization
import Amazonka.MediaConvert.Types.H265AlternateTransferFunctionSei
import Amazonka.MediaConvert.Types.H265CodecLevel
import Amazonka.MediaConvert.Types.H265CodecProfile
import Amazonka.MediaConvert.Types.H265DynamicSubGop
import Amazonka.MediaConvert.Types.H265FlickerAdaptiveQuantization
import Amazonka.MediaConvert.Types.H265FramerateControl
import Amazonka.MediaConvert.Types.H265FramerateConversionAlgorithm
import Amazonka.MediaConvert.Types.H265GopBReference
import Amazonka.MediaConvert.Types.H265GopSizeUnits
import Amazonka.MediaConvert.Types.H265InterlaceMode
import Amazonka.MediaConvert.Types.H265ParControl
import Amazonka.MediaConvert.Types.H265QualityTuningLevel
import Amazonka.MediaConvert.Types.H265QvbrSettings
import Amazonka.MediaConvert.Types.H265RateControlMode
import Amazonka.MediaConvert.Types.H265SampleAdaptiveOffsetFilterMode
import Amazonka.MediaConvert.Types.H265ScanTypeConversionMode
import Amazonka.MediaConvert.Types.H265SceneChangeDetect
import Amazonka.MediaConvert.Types.H265SlowPal
import Amazonka.MediaConvert.Types.H265SpatialAdaptiveQuantization
import Amazonka.MediaConvert.Types.H265Telecine
import Amazonka.MediaConvert.Types.H265TemporalAdaptiveQuantization
import Amazonka.MediaConvert.Types.H265TemporalIds
import Amazonka.MediaConvert.Types.H265Tiles
import Amazonka.MediaConvert.Types.H265UnregisteredSeiTimecode
import Amazonka.MediaConvert.Types.H265WriteMp4PackagingType
import qualified Amazonka.Prelude as Prelude

-- | Settings for H265 codec
--
-- /See:/ 'newH265Settings' smart constructor.
data H265Settings = H265Settings'
  { -- | Inserts timecode for each frame as 4 bytes of an unregistered SEI
    -- message.
    H265Settings -> Maybe H265UnregisteredSeiTimecode
unregisteredSeiTimecode :: Prelude.Maybe H265UnregisteredSeiTimecode,
    -- | Optional. Use Quality tuning level (qualityTuningLevel) to choose how
    -- you want to trade off encoding speed for output video quality. The
    -- default behavior is faster, lower quality, single-pass encoding.
    H265Settings -> Maybe H265QualityTuningLevel
qualityTuningLevel :: Prelude.Maybe H265QualityTuningLevel,
    -- | Keep the default value, Enabled (ENABLED), to adjust quantization within
    -- each frame based on temporal variation of content complexity. When you
    -- enable this feature, the encoder uses fewer bits on areas of the frame
    -- that aren\'t moving and uses more bits on complex objects with sharp
    -- edges that move a lot. For example, this feature improves the
    -- readability of text tickers on newscasts and scoreboards on sports
    -- matches. Enabling this feature will almost always improve your video
    -- quality. Note, though, that this feature doesn\'t take into account
    -- where the viewer\'s attention is likely to be. If viewers are likely to
    -- be focusing their attention on a part of the screen that doesn\'t have
    -- moving objects with sharp edges, such as sports athletes\' faces, you
    -- might choose to disable this feature. Related setting: When you enable
    -- temporal quantization, adjust the strength of the filter with the
    -- setting Adaptive quantization (adaptiveQuantization).
    H265Settings -> Maybe H265TemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Prelude.Maybe H265TemporalAdaptiveQuantization,
    -- | Enable this setting to insert I-frames at scene changes that the service
    -- automatically detects. This improves video quality and is enabled by
    -- default. If this output uses QVBR, choose Transition detection
    -- (TRANSITION_DETECTION) for further video quality improvement. For more
    -- information about QVBR, see
    -- https:\/\/docs.aws.amazon.com\/console\/mediaconvert\/cbr-vbr-qvbr.
    H265Settings -> Maybe H265SceneChangeDetect
sceneChangeDetect :: Prelude.Maybe H265SceneChangeDetect,
    -- | Percentage of the buffer that should initially be filled (HRD buffer
    -- model).
    H265Settings -> Maybe Natural
hrdBufferInitialFillPercentage :: Prelude.Maybe Prelude.Natural,
    -- | Enable use of tiles, allowing horizontal as well as vertical subdivision
    -- of the encoded pictures.
    H265Settings -> Maybe H265Tiles
tiles :: Prelude.Maybe H265Tiles,
    -- | Ignore this setting unless your input frame rate is 23.976 or 24 frames
    -- per second (fps). Enable slow PAL to create a 25 fps output. When you
    -- enable slow PAL, MediaConvert relabels the video frames to 25 fps and
    -- resamples your audio to keep it synchronized with the video. Note that
    -- enabling this setting will slightly reduce the duration of your video.
    -- Required settings: You must also set Framerate to 25. In your JSON job
    -- specification, set (framerateControl) to (SPECIFIED),
    -- (framerateNumerator) to 25 and (framerateDenominator) to 1.
    H265Settings -> Maybe H265SlowPal
slowPal :: Prelude.Maybe H265SlowPal,
    -- | Enables temporal layer identifiers in the encoded bitstream. Up to 3
    -- layers are supported depending on GOP structure: I- and P-frames form
    -- one layer, reference B-frames can form a second layer and non-reference
    -- b-frames can form a third layer. Decoders can optionally decode only the
    -- lower temporal layers to generate a lower frame rate output. For
    -- example, given a bitstream with temporal IDs and with b-frames = 1 (i.e.
    -- IbPbPb display order), a decoder could decode all the frames for full
    -- frame rate output or only the I and P frames (lowest temporal layer) for
    -- a half frame rate output.
    H265Settings -> Maybe H265TemporalIds
temporalIds :: Prelude.Maybe H265TemporalIds,
    -- | Required when you set Pixel aspect ratio (parControl) to SPECIFIED. On
    -- the console, this corresponds to any value other than Follow source.
    -- When you specify an output pixel aspect ratio (PAR) that is different
    -- from your input video PAR, provide your output PAR as a ratio. For
    -- example, for D1\/DV NTSC widescreen, you would specify the ratio 40:33.
    -- In this example, the value for parNumerator is 40.
    H265Settings -> Maybe Natural
parNumerator :: Prelude.Maybe Prelude.Natural,
    -- | GOP Length (keyframe interval) in frames or seconds. Must be greater
    -- than zero.
    H265Settings -> Maybe Double
gopSize :: Prelude.Maybe Prelude.Double,
    -- | Specify the number of B-frames that MediaConvert puts between reference
    -- frames in this output. Valid values are whole numbers from 0 through 7.
    -- When you don\'t specify a value, MediaConvert defaults to 2.
    H265Settings -> Maybe Natural
numberBFramesBetweenReferenceFrames :: Prelude.Maybe Prelude.Natural,
    -- | Indicates if the GOP Size in H265 is specified in frames or seconds. If
    -- seconds the system will convert the GOP Size into a frame count at run
    -- time.
    H265Settings -> Maybe H265GopSizeUnits
gopSizeUnits :: Prelude.Maybe H265GopSizeUnits,
    -- | Size of buffer (HRD buffer model) in bits. For example, enter five
    -- megabits as 5000000.
    H265Settings -> Maybe Natural
hrdBufferSize :: Prelude.Maybe Prelude.Natural,
    -- | Number of slices per picture. Must be less than or equal to the number
    -- of macroblock rows for progressive pictures, and less than or equal to
    -- half the number of macroblock rows for interlaced pictures.
    H265Settings -> Maybe Natural
slices :: Prelude.Maybe Prelude.Natural,
    -- | Enables Alternate Transfer Function SEI message for outputs using Hybrid
    -- Log Gamma (HLG) Electro-Optical Transfer Function (EOTF).
    H265Settings -> Maybe H265AlternateTransferFunctionSei
alternateTransferFunctionSei :: Prelude.Maybe H265AlternateTransferFunctionSei,
    -- | Use this setting to specify whether this output has a variable bitrate
    -- (VBR), constant bitrate (CBR) or quality-defined variable bitrate
    -- (QVBR).
    H265Settings -> Maybe H265RateControlMode
rateControlMode :: Prelude.Maybe H265RateControlMode,
    -- | Number of reference frames to use. The encoder may use more than
    -- requested if using B-frames and\/or interlaced encoding.
    H265Settings -> Maybe Natural
numberReferenceFrames :: Prelude.Maybe Prelude.Natural,
    -- | This field applies only if the Streams > Advanced > Framerate
    -- (framerate) field is set to 29.970. This field works with the Streams >
    -- Advanced > Preprocessors > Deinterlacer field (deinterlace_mode) and the
    -- Streams > Advanced > Interlaced Mode field (interlace_mode) to identify
    -- the scan type for the output: Progressive, Interlaced, Hard Telecine or
    -- Soft Telecine. - Hard: produces 29.97i output from 23.976 input. - Soft:
    -- produces 23.976; the player converts this output to 29.97i.
    H265Settings -> Maybe H265Telecine
telecine :: Prelude.Maybe H265Telecine,
    -- | Choose Adaptive to improve subjective video quality for high-motion
    -- content. This will cause the service to use fewer B-frames (which infer
    -- information based on other frames) for high-motion portions of the video
    -- and more B-frames for low-motion portions. The maximum number of
    -- B-frames is limited by the value you provide for the setting B frames
    -- between reference frames (numberBFramesBetweenReferenceFrames).
    H265Settings -> Maybe H265DynamicSubGop
dynamicSubGop :: Prelude.Maybe H265DynamicSubGop,
    -- | Enforces separation between repeated (cadence) I-frames and I-frames
    -- inserted by Scene Change Detection. If a scene change I-frame is within
    -- I-interval frames of a cadence I-frame, the GOP is shrunk and\/or
    -- stretched to the scene change I-frame. GOP stretch requires enabling
    -- lookahead as well as setting I-interval. The normal cadence resumes for
    -- the next GOP. This setting is only used when Scene Change Detect is
    -- enabled. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
    H265Settings -> Maybe Natural
minIInterval :: Prelude.Maybe Prelude.Natural,
    -- | Choose the scan line type for the output. Keep the default value,
    -- Progressive (PROGRESSIVE) to create a progressive output, regardless of
    -- the scan type of your input. Use Top field first (TOP_FIELD) or Bottom
    -- field first (BOTTOM_FIELD) to create an output that\'s interlaced with
    -- the same field polarity throughout. Use Follow, default top
    -- (FOLLOW_TOP_FIELD) or Follow, default bottom (FOLLOW_BOTTOM_FIELD) to
    -- produce outputs with the same field polarity as the source. For jobs
    -- that have multiple inputs, the output field polarity might change over
    -- the course of the output. Follow behavior depends on the input scan
    -- type. If the source is interlaced, the output will be interlaced with
    -- the same polarity as the source. If the source is progressive, the
    -- output will be interlaced with top field bottom field first, depending
    -- on which of the Follow options you choose.
    H265Settings -> Maybe H265InterlaceMode
interlaceMode :: Prelude.Maybe H265InterlaceMode,
    -- | Optional. Specify how the service determines the pixel aspect ratio
    -- (PAR) for this output. The default behavior, Follow source
    -- (INITIALIZE_FROM_SOURCE), uses the PAR from your input video for your
    -- output. To specify a different PAR in the console, choose any value
    -- other than Follow source. To specify a different PAR by editing the JSON
    -- job specification, choose SPECIFIED. When you choose SPECIFIED for this
    -- setting, you must also specify values for the parNumerator and
    -- parDenominator settings.
    H265Settings -> Maybe H265ParControl
parControl :: Prelude.Maybe H265ParControl,
    -- | Use this setting for interlaced outputs, when your output frame rate is
    -- half of your input frame rate. In this situation, choose Optimized
    -- interlacing (INTERLACED_OPTIMIZE) to create a better quality interlaced
    -- output. In this case, each progressive frame from the input corresponds
    -- to an interlaced field in the output. Keep the default value, Basic
    -- interlacing (INTERLACED), for all other output frame rates. With basic
    -- interlacing, MediaConvert performs any frame rate conversion first and
    -- then interlaces the frames. When you choose Optimized interlacing and
    -- you set your output frame rate to a value that isn\'t suitable for
    -- optimized interlacing, MediaConvert automatically falls back to basic
    -- interlacing. Required settings: To use optimized interlacing, you must
    -- set Telecine (telecine) to None (NONE) or Soft (SOFT). You can\'t use
    -- optimized interlacing for hard telecine outputs. You must also set
    -- Interlace mode (interlaceMode) to a value other than Progressive
    -- (PROGRESSIVE).
    H265Settings -> Maybe H265ScanTypeConversionMode
scanTypeConversionMode :: Prelude.Maybe H265ScanTypeConversionMode,
    -- | Enable this setting to have the encoder reduce I-frame pop. I-frame pop
    -- appears as a visual flicker that can arise when the encoder saves bits
    -- by copying some macroblocks many times from frame to frame, and then
    -- refreshes them at the I-frame. When you enable this setting, the encoder
    -- updates these macroblocks slightly more often to smooth out the flicker.
    -- This setting is disabled by default. Related setting: In addition to
    -- enabling this setting, you must also set adaptiveQuantization to a value
    -- other than Off (OFF).
    H265Settings -> Maybe H265FlickerAdaptiveQuantization
flickerAdaptiveQuantization :: Prelude.Maybe H265FlickerAdaptiveQuantization,
    -- | Settings for quality-defined variable bitrate encoding with the H.265
    -- codec. Use these settings only when you set QVBR for Rate control mode
    -- (RateControlMode).
    H265Settings -> Maybe H265QvbrSettings
qvbrSettings :: Prelude.Maybe H265QvbrSettings,
    -- | Specify Sample Adaptive Offset (SAO) filter strength. Adaptive mode
    -- dynamically selects best strength based on content
    H265Settings -> Maybe H265SampleAdaptiveOffsetFilterMode
sampleAdaptiveOffsetFilterMode :: Prelude.Maybe H265SampleAdaptiveOffsetFilterMode,
    -- | Represents the Profile and Tier, per the HEVC (H.265) specification.
    -- Selections are grouped as [Profile] \/ [Tier], so \"Main\/High\"
    -- represents Main Profile with High Tier. 4:2:2 profiles are only
    -- available with the HEVC 4:2:2 License.
    H265Settings -> Maybe H265CodecProfile
codecProfile :: Prelude.Maybe H265CodecProfile,
    -- | Specify the average bitrate in bits per second. Required for VBR and
    -- CBR. For MS Smooth outputs, bitrates must be unique when rounded down to
    -- the nearest multiple of 1000.
    H265Settings -> Maybe Natural
bitrate :: Prelude.Maybe Prelude.Natural,
    -- | When you use the API for transcode jobs that use frame rate conversion,
    -- specify the frame rate as a fraction. For example, 24000 \/ 1001 =
    -- 23.976 fps. Use FramerateDenominator to specify the denominator of this
    -- fraction. In this example, use 1001 for the value of
    -- FramerateDenominator. When you use the console for transcode jobs that
    -- use frame rate conversion, provide the value as a decimal number for
    -- Framerate. In this example, specify 23.976.
    H265Settings -> Maybe Natural
framerateDenominator :: Prelude.Maybe Prelude.Natural,
    -- | Choose the method that you want MediaConvert to use when increasing or
    -- decreasing the frame rate. We recommend using drop duplicate
    -- (DUPLICATE_DROP) for numerically simple conversions, such as 60 fps to
    -- 30 fps. For numerically complex conversions, you can use interpolate
    -- (INTERPOLATE) to avoid stutter. This results in a smooth picture, but
    -- might introduce undesirable video artifacts. For complex frame rate
    -- conversions, especially if your source video has already been converted
    -- from its original cadence, use FrameFormer (FRAMEFORMER) to do
    -- motion-compensated interpolation. FrameFormer chooses the best
    -- conversion method frame by frame. Note that using FrameFormer increases
    -- the transcoding time and incurs a significant add-on cost.
    H265Settings -> Maybe H265FramerateConversionAlgorithm
framerateConversionAlgorithm :: Prelude.Maybe H265FramerateConversionAlgorithm,
    -- | H.265 Level.
    H265Settings -> Maybe H265CodecLevel
codecLevel :: Prelude.Maybe H265CodecLevel,
    -- | If you are using the console, use the Framerate setting to specify the
    -- frame rate for this output. If you want to keep the same frame rate as
    -- the input video, choose Follow source. If you want to do frame rate
    -- conversion, choose a frame rate from the dropdown list or choose Custom.
    -- The framerates shown in the dropdown list are decimal approximations of
    -- fractions. If you choose Custom, specify your frame rate as a fraction.
    -- If you are creating your transcoding job specification as a JSON file
    -- without the console, use FramerateControl to specify which value the
    -- service uses for the frame rate for this output. Choose
    -- INITIALIZE_FROM_SOURCE if you want the service to use the frame rate
    -- from the input. Choose SPECIFIED if you want the service to use the
    -- frame rate you specify in the settings FramerateNumerator and
    -- FramerateDenominator.
    H265Settings -> Maybe H265FramerateControl
framerateControl :: Prelude.Maybe H265FramerateControl,
    -- | If the location of parameter set NAL units doesn\'t matter in your
    -- workflow, ignore this setting. Use this setting only with CMAF or DASH
    -- outputs, or with standalone file outputs in an MPEG-4 container (MP4
    -- outputs). Choose HVC1 to mark your output as HVC1. This makes your
    -- output compliant with the following specification: ISO IECJTC1 SC29
    -- N13798 Text ISO\/IEC FDIS 14496-15 3rd Edition. For these outputs, the
    -- service stores parameter set NAL units in the sample headers but not in
    -- the samples directly. For MP4 outputs, when you choose HVC1, your output
    -- video might not work properly with some downstream systems and video
    -- players. The service defaults to marking your output as HEV1. For these
    -- outputs, the service writes parameter set NAL units directly into the
    -- samples.
    H265Settings -> Maybe H265WriteMp4PackagingType
writeMp4PackagingType :: Prelude.Maybe H265WriteMp4PackagingType,
    -- | Specify the strength of any adaptive quantization filters that you
    -- enable. The value that you choose here applies to the following
    -- settings: Flicker adaptive quantization (flickerAdaptiveQuantization),
    -- Spatial adaptive quantization (spatialAdaptiveQuantization), and
    -- Temporal adaptive quantization (temporalAdaptiveQuantization).
    H265Settings -> Maybe H265AdaptiveQuantization
adaptiveQuantization :: Prelude.Maybe H265AdaptiveQuantization,
    -- | When you use the API for transcode jobs that use frame rate conversion,
    -- specify the frame rate as a fraction. For example, 24000 \/ 1001 =
    -- 23.976 fps. Use FramerateNumerator to specify the numerator of this
    -- fraction. In this example, use 24000 for the value of
    -- FramerateNumerator. When you use the console for transcode jobs that use
    -- frame rate conversion, provide the value as a decimal number for
    -- Framerate. In this example, specify 23.976.
    H265Settings -> Maybe Natural
framerateNumerator :: Prelude.Maybe Prelude.Natural,
    -- | If enable, use reference B frames for GOP structures that have B frames
    -- > 1.
    H265Settings -> Maybe H265GopBReference
gopBReference :: Prelude.Maybe H265GopBReference,
    -- | Maximum bitrate in bits\/second. For example, enter five megabits per
    -- second as 5000000. Required when Rate control mode is QVBR.
    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,
    -- | Required when you set Pixel aspect ratio (parControl) to SPECIFIED. On
    -- the console, this corresponds to any value other than Follow source.
    -- When you specify an output pixel aspect ratio (PAR) that is different
    -- from your input video PAR, provide your output PAR as a ratio. For
    -- example, for D1\/DV NTSC widescreen, you would specify the ratio 40:33.
    -- In this example, the value for parDenominator is 33.
    H265Settings -> Maybe Natural
parDenominator :: Prelude.Maybe Prelude.Natural,
    -- | Keep the default value, Enabled (ENABLED), to adjust quantization within
    -- each frame based on spatial variation of content complexity. When you
    -- enable this feature, the encoder uses fewer bits on areas that can
    -- sustain more distortion with no noticeable visual degradation and uses
    -- more bits on areas where any small distortion will be noticeable. For
    -- example, complex textured blocks are encoded with fewer bits and smooth
    -- textured blocks are encoded with more bits. Enabling this feature will
    -- almost always improve your video quality. Note, though, that this
    -- feature doesn\'t take into account where the viewer\'s attention is
    -- likely to be. If viewers are likely to be focusing their attention on a
    -- part of the screen with a lot of complex texture, you might choose to
    -- disable this feature. Related setting: When you enable spatial adaptive
    -- quantization, set the value for Adaptive quantization
    -- (adaptiveQuantization) depending on your content. For homogeneous
    -- content, such as cartoons and video games, set it to Low. For content
    -- with a wider variety of textures, set it to High or Higher.
    H265Settings -> Maybe H265SpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Prelude.Maybe H265SpatialAdaptiveQuantization
  }
  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:
--
-- 'unregisteredSeiTimecode', 'h265Settings_unregisteredSeiTimecode' - Inserts timecode for each frame as 4 bytes of an unregistered SEI
-- message.
--
-- 'qualityTuningLevel', 'h265Settings_qualityTuningLevel' - Optional. Use Quality tuning level (qualityTuningLevel) to choose how
-- you want to trade off encoding speed for output video quality. The
-- default behavior is faster, lower quality, single-pass encoding.
--
-- 'temporalAdaptiveQuantization', 'h265Settings_temporalAdaptiveQuantization' - Keep the default value, Enabled (ENABLED), to adjust quantization within
-- each frame based on temporal variation of content complexity. When you
-- enable this feature, the encoder uses fewer bits on areas of the frame
-- that aren\'t moving and uses more bits on complex objects with sharp
-- edges that move a lot. For example, this feature improves the
-- readability of text tickers on newscasts and scoreboards on sports
-- matches. Enabling this feature will almost always improve your video
-- quality. Note, though, that this feature doesn\'t take into account
-- where the viewer\'s attention is likely to be. If viewers are likely to
-- be focusing their attention on a part of the screen that doesn\'t have
-- moving objects with sharp edges, such as sports athletes\' faces, you
-- might choose to disable this feature. Related setting: When you enable
-- temporal quantization, adjust the strength of the filter with the
-- setting Adaptive quantization (adaptiveQuantization).
--
-- 'sceneChangeDetect', 'h265Settings_sceneChangeDetect' - Enable this setting to insert I-frames at scene changes that the service
-- automatically detects. This improves video quality and is enabled by
-- default. If this output uses QVBR, choose Transition detection
-- (TRANSITION_DETECTION) for further video quality improvement. For more
-- information about QVBR, see
-- https:\/\/docs.aws.amazon.com\/console\/mediaconvert\/cbr-vbr-qvbr.
--
-- 'hrdBufferInitialFillPercentage', 'h265Settings_hrdBufferInitialFillPercentage' - Percentage of the buffer that should initially be filled (HRD buffer
-- model).
--
-- 'tiles', 'h265Settings_tiles' - Enable use of tiles, allowing horizontal as well as vertical subdivision
-- of the encoded pictures.
--
-- 'slowPal', 'h265Settings_slowPal' - Ignore this setting unless your input frame rate is 23.976 or 24 frames
-- per second (fps). Enable slow PAL to create a 25 fps output. When you
-- enable slow PAL, MediaConvert relabels the video frames to 25 fps and
-- resamples your audio to keep it synchronized with the video. Note that
-- enabling this setting will slightly reduce the duration of your video.
-- Required settings: You must also set Framerate to 25. In your JSON job
-- specification, set (framerateControl) to (SPECIFIED),
-- (framerateNumerator) to 25 and (framerateDenominator) to 1.
--
-- 'temporalIds', 'h265Settings_temporalIds' - Enables temporal layer identifiers in the encoded bitstream. Up to 3
-- layers are supported depending on GOP structure: I- and P-frames form
-- one layer, reference B-frames can form a second layer and non-reference
-- b-frames can form a third layer. Decoders can optionally decode only the
-- lower temporal layers to generate a lower frame rate output. For
-- example, given a bitstream with temporal IDs and with b-frames = 1 (i.e.
-- IbPbPb display order), a decoder could decode all the frames for full
-- frame rate output or only the I and P frames (lowest temporal layer) for
-- a half frame rate output.
--
-- 'parNumerator', 'h265Settings_parNumerator' - Required when you set Pixel aspect ratio (parControl) to SPECIFIED. On
-- the console, this corresponds to any value other than Follow source.
-- When you specify an output pixel aspect ratio (PAR) that is different
-- from your input video PAR, provide your output PAR as a ratio. For
-- example, for D1\/DV NTSC widescreen, you would specify the ratio 40:33.
-- In this example, the value for parNumerator is 40.
--
-- 'gopSize', 'h265Settings_gopSize' - GOP Length (keyframe interval) in frames or seconds. Must be greater
-- than zero.
--
-- 'numberBFramesBetweenReferenceFrames', 'h265Settings_numberBFramesBetweenReferenceFrames' - Specify the number of B-frames that MediaConvert puts between reference
-- frames in this output. Valid values are whole numbers from 0 through 7.
-- When you don\'t specify a value, MediaConvert defaults to 2.
--
-- 'gopSizeUnits', 'h265Settings_gopSizeUnits' - Indicates if the GOP Size in H265 is specified in frames or seconds. If
-- seconds the system will convert the GOP Size into a frame count at run
-- time.
--
-- 'hrdBufferSize', 'h265Settings_hrdBufferSize' - Size of buffer (HRD buffer model) in bits. For example, enter five
-- megabits as 5000000.
--
-- '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.
--
-- 'alternateTransferFunctionSei', 'h265Settings_alternateTransferFunctionSei' - Enables Alternate Transfer Function SEI message for outputs using Hybrid
-- Log Gamma (HLG) Electro-Optical Transfer Function (EOTF).
--
-- 'rateControlMode', 'h265Settings_rateControlMode' - Use this setting to specify whether this output has a variable bitrate
-- (VBR), constant bitrate (CBR) or quality-defined variable bitrate
-- (QVBR).
--
-- 'numberReferenceFrames', 'h265Settings_numberReferenceFrames' - Number of reference frames to use. The encoder may use more than
-- requested if using B-frames and\/or interlaced encoding.
--
-- 'telecine', 'h265Settings_telecine' - This field applies only if the Streams > Advanced > Framerate
-- (framerate) field is set to 29.970. This field works with the Streams >
-- Advanced > Preprocessors > Deinterlacer field (deinterlace_mode) and the
-- Streams > Advanced > Interlaced Mode field (interlace_mode) to identify
-- the scan type for the output: Progressive, Interlaced, Hard Telecine or
-- Soft Telecine. - Hard: produces 29.97i output from 23.976 input. - Soft:
-- produces 23.976; the player converts this output to 29.97i.
--
-- 'dynamicSubGop', 'h265Settings_dynamicSubGop' - Choose Adaptive to improve subjective video quality for high-motion
-- content. This will cause the service to use fewer B-frames (which infer
-- information based on other frames) for high-motion portions of the video
-- and more B-frames for low-motion portions. The maximum number of
-- B-frames is limited by the value you provide for the setting B frames
-- between reference frames (numberBFramesBetweenReferenceFrames).
--
-- 'minIInterval', 'h265Settings_minIInterval' - Enforces separation between repeated (cadence) I-frames and I-frames
-- inserted by Scene Change Detection. If a scene change I-frame is within
-- I-interval frames of a cadence I-frame, the GOP is shrunk and\/or
-- stretched to the scene change I-frame. GOP stretch requires enabling
-- lookahead as well as setting I-interval. The normal cadence resumes for
-- the next GOP. This setting is only used when Scene Change Detect is
-- enabled. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
--
-- 'interlaceMode', 'h265Settings_interlaceMode' - Choose the scan line type for the output. Keep the default value,
-- Progressive (PROGRESSIVE) to create a progressive output, regardless of
-- the scan type of your input. Use Top field first (TOP_FIELD) or Bottom
-- field first (BOTTOM_FIELD) to create an output that\'s interlaced with
-- the same field polarity throughout. Use Follow, default top
-- (FOLLOW_TOP_FIELD) or Follow, default bottom (FOLLOW_BOTTOM_FIELD) to
-- produce outputs with the same field polarity as the source. For jobs
-- that have multiple inputs, the output field polarity might change over
-- the course of the output. Follow behavior depends on the input scan
-- type. If the source is interlaced, the output will be interlaced with
-- the same polarity as the source. If the source is progressive, the
-- output will be interlaced with top field bottom field first, depending
-- on which of the Follow options you choose.
--
-- 'parControl', 'h265Settings_parControl' - Optional. Specify how the service determines the pixel aspect ratio
-- (PAR) for this output. The default behavior, Follow source
-- (INITIALIZE_FROM_SOURCE), uses the PAR from your input video for your
-- output. To specify a different PAR in the console, choose any value
-- other than Follow source. To specify a different PAR by editing the JSON
-- job specification, choose SPECIFIED. When you choose SPECIFIED for this
-- setting, you must also specify values for the parNumerator and
-- parDenominator settings.
--
-- 'scanTypeConversionMode', 'h265Settings_scanTypeConversionMode' - Use this setting for interlaced outputs, when your output frame rate is
-- half of your input frame rate. In this situation, choose Optimized
-- interlacing (INTERLACED_OPTIMIZE) to create a better quality interlaced
-- output. In this case, each progressive frame from the input corresponds
-- to an interlaced field in the output. Keep the default value, Basic
-- interlacing (INTERLACED), for all other output frame rates. With basic
-- interlacing, MediaConvert performs any frame rate conversion first and
-- then interlaces the frames. When you choose Optimized interlacing and
-- you set your output frame rate to a value that isn\'t suitable for
-- optimized interlacing, MediaConvert automatically falls back to basic
-- interlacing. Required settings: To use optimized interlacing, you must
-- set Telecine (telecine) to None (NONE) or Soft (SOFT). You can\'t use
-- optimized interlacing for hard telecine outputs. You must also set
-- Interlace mode (interlaceMode) to a value other than Progressive
-- (PROGRESSIVE).
--
-- 'flickerAdaptiveQuantization', 'h265Settings_flickerAdaptiveQuantization' - Enable this setting to have the encoder reduce I-frame pop. I-frame pop
-- appears as a visual flicker that can arise when the encoder saves bits
-- by copying some macroblocks many times from frame to frame, and then
-- refreshes them at the I-frame. When you enable this setting, the encoder
-- updates these macroblocks slightly more often to smooth out the flicker.
-- This setting is disabled by default. Related setting: In addition to
-- enabling this setting, you must also set adaptiveQuantization to a value
-- other than Off (OFF).
--
-- 'qvbrSettings', 'h265Settings_qvbrSettings' - Settings for quality-defined variable bitrate encoding with the H.265
-- codec. Use these settings only when you set QVBR for Rate control mode
-- (RateControlMode).
--
-- 'sampleAdaptiveOffsetFilterMode', 'h265Settings_sampleAdaptiveOffsetFilterMode' - Specify Sample Adaptive Offset (SAO) filter strength. Adaptive mode
-- dynamically selects best strength based on content
--
-- 'codecProfile', 'h265Settings_codecProfile' - Represents the Profile and Tier, per the HEVC (H.265) specification.
-- Selections are grouped as [Profile] \/ [Tier], so \"Main\/High\"
-- represents Main Profile with High Tier. 4:2:2 profiles are only
-- available with the HEVC 4:2:2 License.
--
-- 'bitrate', 'h265Settings_bitrate' - Specify the average bitrate in bits per second. Required for VBR and
-- CBR. For MS Smooth outputs, bitrates must be unique when rounded down to
-- the nearest multiple of 1000.
--
-- 'framerateDenominator', 'h265Settings_framerateDenominator' - When you use the API for transcode jobs that use frame rate conversion,
-- specify the frame rate as a fraction. For example, 24000 \/ 1001 =
-- 23.976 fps. Use FramerateDenominator to specify the denominator of this
-- fraction. In this example, use 1001 for the value of
-- FramerateDenominator. When you use the console for transcode jobs that
-- use frame rate conversion, provide the value as a decimal number for
-- Framerate. In this example, specify 23.976.
--
-- 'framerateConversionAlgorithm', 'h265Settings_framerateConversionAlgorithm' - Choose the method that you want MediaConvert to use when increasing or
-- decreasing the frame rate. We recommend using drop duplicate
-- (DUPLICATE_DROP) for numerically simple conversions, such as 60 fps to
-- 30 fps. For numerically complex conversions, you can use interpolate
-- (INTERPOLATE) to avoid stutter. This results in a smooth picture, but
-- might introduce undesirable video artifacts. For complex frame rate
-- conversions, especially if your source video has already been converted
-- from its original cadence, use FrameFormer (FRAMEFORMER) to do
-- motion-compensated interpolation. FrameFormer chooses the best
-- conversion method frame by frame. Note that using FrameFormer increases
-- the transcoding time and incurs a significant add-on cost.
--
-- 'codecLevel', 'h265Settings_codecLevel' - H.265 Level.
--
-- 'framerateControl', 'h265Settings_framerateControl' - If you are using the console, use the Framerate setting to specify the
-- frame rate for this output. If you want to keep the same frame rate as
-- the input video, choose Follow source. If you want to do frame rate
-- conversion, choose a frame rate from the dropdown list or choose Custom.
-- The framerates shown in the dropdown list are decimal approximations of
-- fractions. If you choose Custom, specify your frame rate as a fraction.
-- If you are creating your transcoding job specification as a JSON file
-- without the console, use FramerateControl to specify which value the
-- service uses for the frame rate for this output. Choose
-- INITIALIZE_FROM_SOURCE if you want the service to use the frame rate
-- from the input. Choose SPECIFIED if you want the service to use the
-- frame rate you specify in the settings FramerateNumerator and
-- FramerateDenominator.
--
-- 'writeMp4PackagingType', 'h265Settings_writeMp4PackagingType' - If the location of parameter set NAL units doesn\'t matter in your
-- workflow, ignore this setting. Use this setting only with CMAF or DASH
-- outputs, or with standalone file outputs in an MPEG-4 container (MP4
-- outputs). Choose HVC1 to mark your output as HVC1. This makes your
-- output compliant with the following specification: ISO IECJTC1 SC29
-- N13798 Text ISO\/IEC FDIS 14496-15 3rd Edition. For these outputs, the
-- service stores parameter set NAL units in the sample headers but not in
-- the samples directly. For MP4 outputs, when you choose HVC1, your output
-- video might not work properly with some downstream systems and video
-- players. The service defaults to marking your output as HEV1. For these
-- outputs, the service writes parameter set NAL units directly into the
-- samples.
--
-- 'adaptiveQuantization', 'h265Settings_adaptiveQuantization' - Specify the strength of any adaptive quantization filters that you
-- enable. The value that you choose here applies to the following
-- settings: Flicker adaptive quantization (flickerAdaptiveQuantization),
-- Spatial adaptive quantization (spatialAdaptiveQuantization), and
-- Temporal adaptive quantization (temporalAdaptiveQuantization).
--
-- 'framerateNumerator', 'h265Settings_framerateNumerator' - When you use the API for transcode jobs that use frame rate conversion,
-- specify the frame rate as a fraction. For example, 24000 \/ 1001 =
-- 23.976 fps. Use FramerateNumerator to specify the numerator of this
-- fraction. In this example, use 24000 for the value of
-- FramerateNumerator. When you use the console for transcode jobs that use
-- frame rate conversion, provide the value as a decimal number for
-- Framerate. In this example, specify 23.976.
--
-- 'gopBReference', 'h265Settings_gopBReference' - If enable, use reference B frames for GOP structures that have B frames
-- > 1.
--
-- 'maxBitrate', 'h265Settings_maxBitrate' - Maximum bitrate in bits\/second. For example, enter five megabits per
-- second as 5000000. Required when Rate control mode is QVBR.
--
-- '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' - Required when you set Pixel aspect ratio (parControl) to SPECIFIED. On
-- the console, this corresponds to any value other than Follow source.
-- When you specify an output pixel aspect ratio (PAR) that is different
-- from your input video PAR, provide your output PAR as a ratio. For
-- example, for D1\/DV NTSC widescreen, you would specify the ratio 40:33.
-- In this example, the value for parDenominator is 33.
--
-- 'spatialAdaptiveQuantization', 'h265Settings_spatialAdaptiveQuantization' - Keep the default value, Enabled (ENABLED), to adjust quantization within
-- each frame based on spatial variation of content complexity. When you
-- enable this feature, the encoder uses fewer bits on areas that can
-- sustain more distortion with no noticeable visual degradation and uses
-- more bits on areas where any small distortion will be noticeable. For
-- example, complex textured blocks are encoded with fewer bits and smooth
-- textured blocks are encoded with more bits. Enabling this feature will
-- almost always improve your video quality. Note, though, that this
-- feature doesn\'t take into account where the viewer\'s attention is
-- likely to be. If viewers are likely to be focusing their attention on a
-- part of the screen with a lot of complex texture, you might choose to
-- disable this feature. Related setting: When you enable spatial adaptive
-- quantization, set the value for Adaptive quantization
-- (adaptiveQuantization) depending on your content. For homogeneous
-- content, such as cartoons and video games, set it to Low. For content
-- with a wider variety of textures, set it to High or Higher.
newH265Settings ::
  H265Settings
newH265Settings :: H265Settings
newH265Settings =
  H265Settings' :: Maybe H265UnregisteredSeiTimecode
-> Maybe H265QualityTuningLevel
-> Maybe H265TemporalAdaptiveQuantization
-> Maybe H265SceneChangeDetect
-> Maybe Natural
-> Maybe H265Tiles
-> Maybe H265SlowPal
-> Maybe H265TemporalIds
-> Maybe Natural
-> Maybe Double
-> Maybe Natural
-> Maybe H265GopSizeUnits
-> Maybe Natural
-> Maybe Natural
-> Maybe H265AlternateTransferFunctionSei
-> Maybe H265RateControlMode
-> Maybe Natural
-> Maybe H265Telecine
-> Maybe H265DynamicSubGop
-> Maybe Natural
-> Maybe H265InterlaceMode
-> Maybe H265ParControl
-> Maybe H265ScanTypeConversionMode
-> Maybe H265FlickerAdaptiveQuantization
-> Maybe H265QvbrSettings
-> Maybe H265SampleAdaptiveOffsetFilterMode
-> Maybe H265CodecProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe H265FramerateConversionAlgorithm
-> Maybe H265CodecLevel
-> Maybe H265FramerateControl
-> Maybe H265WriteMp4PackagingType
-> Maybe H265AdaptiveQuantization
-> Maybe Natural
-> Maybe H265GopBReference
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe H265SpatialAdaptiveQuantization
-> H265Settings
H265Settings'
    { $sel:unregisteredSeiTimecode:H265Settings' :: Maybe H265UnregisteredSeiTimecode
unregisteredSeiTimecode =
        Maybe H265UnregisteredSeiTimecode
forall a. Maybe a
Prelude.Nothing,
      $sel:qualityTuningLevel:H265Settings' :: Maybe H265QualityTuningLevel
qualityTuningLevel = Maybe H265QualityTuningLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:temporalAdaptiveQuantization:H265Settings' :: Maybe H265TemporalAdaptiveQuantization
temporalAdaptiveQuantization = Maybe H265TemporalAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:sceneChangeDetect:H265Settings' :: Maybe H265SceneChangeDetect
sceneChangeDetect = Maybe H265SceneChangeDetect
forall a. Maybe a
Prelude.Nothing,
      $sel:hrdBufferInitialFillPercentage:H265Settings' :: Maybe Natural
hrdBufferInitialFillPercentage = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:tiles:H265Settings' :: Maybe H265Tiles
tiles = Maybe H265Tiles
forall a. Maybe a
Prelude.Nothing,
      $sel:slowPal:H265Settings' :: Maybe H265SlowPal
slowPal = Maybe H265SlowPal
forall a. Maybe a
Prelude.Nothing,
      $sel:temporalIds:H265Settings' :: Maybe H265TemporalIds
temporalIds = Maybe H265TemporalIds
forall a. Maybe a
Prelude.Nothing,
      $sel:parNumerator:H265Settings' :: Maybe Natural
parNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopSize:H265Settings' :: Maybe Double
gopSize = Maybe Double
forall a. Maybe a
Prelude.Nothing,
      $sel:numberBFramesBetweenReferenceFrames:H265Settings' :: Maybe Natural
numberBFramesBetweenReferenceFrames =
        Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopSizeUnits:H265Settings' :: Maybe H265GopSizeUnits
gopSizeUnits = Maybe H265GopSizeUnits
forall a. Maybe a
Prelude.Nothing,
      $sel:hrdBufferSize:H265Settings' :: Maybe Natural
hrdBufferSize = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:slices:H265Settings' :: Maybe Natural
slices = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:alternateTransferFunctionSei:H265Settings' :: Maybe H265AlternateTransferFunctionSei
alternateTransferFunctionSei = Maybe H265AlternateTransferFunctionSei
forall a. Maybe a
Prelude.Nothing,
      $sel:rateControlMode:H265Settings' :: Maybe H265RateControlMode
rateControlMode = Maybe H265RateControlMode
forall a. Maybe a
Prelude.Nothing,
      $sel:numberReferenceFrames:H265Settings' :: Maybe Natural
numberReferenceFrames = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:telecine:H265Settings' :: Maybe H265Telecine
telecine = Maybe H265Telecine
forall a. Maybe a
Prelude.Nothing,
      $sel:dynamicSubGop:H265Settings' :: Maybe H265DynamicSubGop
dynamicSubGop = Maybe H265DynamicSubGop
forall a. Maybe a
Prelude.Nothing,
      $sel:minIInterval:H265Settings' :: Maybe Natural
minIInterval = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:interlaceMode:H265Settings' :: Maybe H265InterlaceMode
interlaceMode = Maybe H265InterlaceMode
forall a. Maybe a
Prelude.Nothing,
      $sel:parControl:H265Settings' :: Maybe H265ParControl
parControl = Maybe H265ParControl
forall a. Maybe a
Prelude.Nothing,
      $sel:scanTypeConversionMode:H265Settings' :: Maybe H265ScanTypeConversionMode
scanTypeConversionMode = Maybe H265ScanTypeConversionMode
forall a. Maybe a
Prelude.Nothing,
      $sel:flickerAdaptiveQuantization:H265Settings' :: Maybe H265FlickerAdaptiveQuantization
flickerAdaptiveQuantization = Maybe H265FlickerAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:qvbrSettings:H265Settings' :: Maybe H265QvbrSettings
qvbrSettings = Maybe H265QvbrSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:sampleAdaptiveOffsetFilterMode:H265Settings' :: Maybe H265SampleAdaptiveOffsetFilterMode
sampleAdaptiveOffsetFilterMode = Maybe H265SampleAdaptiveOffsetFilterMode
forall a. Maybe a
Prelude.Nothing,
      $sel:codecProfile:H265Settings' :: Maybe H265CodecProfile
codecProfile = Maybe H265CodecProfile
forall a. Maybe a
Prelude.Nothing,
      $sel:bitrate:H265Settings' :: Maybe Natural
bitrate = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateDenominator:H265Settings' :: Maybe Natural
framerateDenominator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateConversionAlgorithm:H265Settings' :: Maybe H265FramerateConversionAlgorithm
framerateConversionAlgorithm = Maybe H265FramerateConversionAlgorithm
forall a. Maybe a
Prelude.Nothing,
      $sel:codecLevel:H265Settings' :: Maybe H265CodecLevel
codecLevel = Maybe H265CodecLevel
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateControl:H265Settings' :: Maybe H265FramerateControl
framerateControl = Maybe H265FramerateControl
forall a. Maybe a
Prelude.Nothing,
      $sel:writeMp4PackagingType:H265Settings' :: Maybe H265WriteMp4PackagingType
writeMp4PackagingType = Maybe H265WriteMp4PackagingType
forall a. Maybe a
Prelude.Nothing,
      $sel:adaptiveQuantization:H265Settings' :: Maybe H265AdaptiveQuantization
adaptiveQuantization = Maybe H265AdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateNumerator:H265Settings' :: Maybe Natural
framerateNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:gopBReference:H265Settings' :: Maybe H265GopBReference
gopBReference = Maybe H265GopBReference
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:spatialAdaptiveQuantization:H265Settings' :: Maybe H265SpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe H265SpatialAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing
    }

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

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

-- | Keep the default value, Enabled (ENABLED), to adjust quantization within
-- each frame based on temporal variation of content complexity. When you
-- enable this feature, the encoder uses fewer bits on areas of the frame
-- that aren\'t moving and uses more bits on complex objects with sharp
-- edges that move a lot. For example, this feature improves the
-- readability of text tickers on newscasts and scoreboards on sports
-- matches. Enabling this feature will almost always improve your video
-- quality. Note, though, that this feature doesn\'t take into account
-- where the viewer\'s attention is likely to be. If viewers are likely to
-- be focusing their attention on a part of the screen that doesn\'t have
-- moving objects with sharp edges, such as sports athletes\' faces, you
-- might choose to disable this feature. Related setting: When you enable
-- temporal quantization, adjust the strength of the filter with the
-- setting Adaptive quantization (adaptiveQuantization).
h265Settings_temporalAdaptiveQuantization :: Lens.Lens' H265Settings (Prelude.Maybe H265TemporalAdaptiveQuantization)
h265Settings_temporalAdaptiveQuantization :: (Maybe H265TemporalAdaptiveQuantization
 -> f (Maybe H265TemporalAdaptiveQuantization))
-> H265Settings -> f H265Settings
h265Settings_temporalAdaptiveQuantization = (H265Settings -> Maybe H265TemporalAdaptiveQuantization)
-> (H265Settings
    -> Maybe H265TemporalAdaptiveQuantization -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265TemporalAdaptiveQuantization)
     (Maybe H265TemporalAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265TemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Maybe H265TemporalAdaptiveQuantization
$sel:temporalAdaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265TemporalAdaptiveQuantization
temporalAdaptiveQuantization} -> Maybe H265TemporalAdaptiveQuantization
temporalAdaptiveQuantization) (\s :: H265Settings
s@H265Settings' {} Maybe H265TemporalAdaptiveQuantization
a -> H265Settings
s {$sel:temporalAdaptiveQuantization:H265Settings' :: Maybe H265TemporalAdaptiveQuantization
temporalAdaptiveQuantization = Maybe H265TemporalAdaptiveQuantization
a} :: H265Settings)

-- | Enable this setting to insert I-frames at scene changes that the service
-- automatically detects. This improves video quality and is enabled by
-- default. If this output uses QVBR, choose Transition detection
-- (TRANSITION_DETECTION) for further video quality improvement. For more
-- information about QVBR, see
-- https:\/\/docs.aws.amazon.com\/console\/mediaconvert\/cbr-vbr-qvbr.
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)

-- | Percentage of the buffer that should initially be filled (HRD buffer
-- model).
h265Settings_hrdBufferInitialFillPercentage :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_hrdBufferInitialFillPercentage :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_hrdBufferInitialFillPercentage = (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
hrdBufferInitialFillPercentage :: Maybe Natural
$sel:hrdBufferInitialFillPercentage:H265Settings' :: H265Settings -> Maybe Natural
hrdBufferInitialFillPercentage} -> Maybe Natural
hrdBufferInitialFillPercentage) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:hrdBufferInitialFillPercentage:H265Settings' :: Maybe Natural
hrdBufferInitialFillPercentage = Maybe Natural
a} :: H265Settings)

-- | Enable use of tiles, allowing horizontal as well as vertical subdivision
-- of the encoded pictures.
h265Settings_tiles :: Lens.Lens' H265Settings (Prelude.Maybe H265Tiles)
h265Settings_tiles :: (Maybe H265Tiles -> f (Maybe H265Tiles))
-> H265Settings -> f H265Settings
h265Settings_tiles = (H265Settings -> Maybe H265Tiles)
-> (H265Settings -> Maybe H265Tiles -> H265Settings)
-> Lens
     H265Settings H265Settings (Maybe H265Tiles) (Maybe H265Tiles)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265Tiles
tiles :: Maybe H265Tiles
$sel:tiles:H265Settings' :: H265Settings -> Maybe H265Tiles
tiles} -> Maybe H265Tiles
tiles) (\s :: H265Settings
s@H265Settings' {} Maybe H265Tiles
a -> H265Settings
s {$sel:tiles:H265Settings' :: Maybe H265Tiles
tiles = Maybe H265Tiles
a} :: H265Settings)

-- | Ignore this setting unless your input frame rate is 23.976 or 24 frames
-- per second (fps). Enable slow PAL to create a 25 fps output. When you
-- enable slow PAL, MediaConvert relabels the video frames to 25 fps and
-- resamples your audio to keep it synchronized with the video. Note that
-- enabling this setting will slightly reduce the duration of your video.
-- Required settings: You must also set Framerate to 25. In your JSON job
-- specification, set (framerateControl) to (SPECIFIED),
-- (framerateNumerator) to 25 and (framerateDenominator) to 1.
h265Settings_slowPal :: Lens.Lens' H265Settings (Prelude.Maybe H265SlowPal)
h265Settings_slowPal :: (Maybe H265SlowPal -> f (Maybe H265SlowPal))
-> H265Settings -> f H265Settings
h265Settings_slowPal = (H265Settings -> Maybe H265SlowPal)
-> (H265Settings -> Maybe H265SlowPal -> H265Settings)
-> Lens
     H265Settings H265Settings (Maybe H265SlowPal) (Maybe H265SlowPal)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265SlowPal
slowPal :: Maybe H265SlowPal
$sel:slowPal:H265Settings' :: H265Settings -> Maybe H265SlowPal
slowPal} -> Maybe H265SlowPal
slowPal) (\s :: H265Settings
s@H265Settings' {} Maybe H265SlowPal
a -> H265Settings
s {$sel:slowPal:H265Settings' :: Maybe H265SlowPal
slowPal = Maybe H265SlowPal
a} :: H265Settings)

-- | Enables temporal layer identifiers in the encoded bitstream. Up to 3
-- layers are supported depending on GOP structure: I- and P-frames form
-- one layer, reference B-frames can form a second layer and non-reference
-- b-frames can form a third layer. Decoders can optionally decode only the
-- lower temporal layers to generate a lower frame rate output. For
-- example, given a bitstream with temporal IDs and with b-frames = 1 (i.e.
-- IbPbPb display order), a decoder could decode all the frames for full
-- frame rate output or only the I and P frames (lowest temporal layer) for
-- a half frame rate output.
h265Settings_temporalIds :: Lens.Lens' H265Settings (Prelude.Maybe H265TemporalIds)
h265Settings_temporalIds :: (Maybe H265TemporalIds -> f (Maybe H265TemporalIds))
-> H265Settings -> f H265Settings
h265Settings_temporalIds = (H265Settings -> Maybe H265TemporalIds)
-> (H265Settings -> Maybe H265TemporalIds -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265TemporalIds)
     (Maybe H265TemporalIds)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265TemporalIds
temporalIds :: Maybe H265TemporalIds
$sel:temporalIds:H265Settings' :: H265Settings -> Maybe H265TemporalIds
temporalIds} -> Maybe H265TemporalIds
temporalIds) (\s :: H265Settings
s@H265Settings' {} Maybe H265TemporalIds
a -> H265Settings
s {$sel:temporalIds:H265Settings' :: Maybe H265TemporalIds
temporalIds = Maybe H265TemporalIds
a} :: H265Settings)

-- | Required when you set Pixel aspect ratio (parControl) to SPECIFIED. On
-- the console, this corresponds to any value other than Follow source.
-- When you specify an output pixel aspect ratio (PAR) that is different
-- from your input video PAR, provide your output PAR as a ratio. For
-- example, for D1\/DV NTSC widescreen, you would specify the ratio 40:33.
-- In this example, the value for parNumerator is 40.
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)

-- | GOP Length (keyframe interval) in frames or seconds. Must be greater
-- than zero.
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)

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

-- | Indicates if the GOP Size in H265 is specified in frames or seconds. If
-- seconds the system will convert the GOP Size 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)

-- | Size of buffer (HRD buffer model) in bits. For example, enter five
-- megabits as 5000000.
h265Settings_hrdBufferSize :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_hrdBufferSize :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_hrdBufferSize = (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
hrdBufferSize :: Maybe Natural
$sel:hrdBufferSize:H265Settings' :: H265Settings -> Maybe Natural
hrdBufferSize} -> Maybe Natural
hrdBufferSize) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:hrdBufferSize:H265Settings' :: Maybe Natural
hrdBufferSize = Maybe Natural
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.
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)

-- | Enables Alternate Transfer Function SEI message for outputs using Hybrid
-- Log Gamma (HLG) Electro-Optical Transfer Function (EOTF).
h265Settings_alternateTransferFunctionSei :: Lens.Lens' H265Settings (Prelude.Maybe H265AlternateTransferFunctionSei)
h265Settings_alternateTransferFunctionSei :: (Maybe H265AlternateTransferFunctionSei
 -> f (Maybe H265AlternateTransferFunctionSei))
-> H265Settings -> f H265Settings
h265Settings_alternateTransferFunctionSei = (H265Settings -> Maybe H265AlternateTransferFunctionSei)
-> (H265Settings
    -> Maybe H265AlternateTransferFunctionSei -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265AlternateTransferFunctionSei)
     (Maybe H265AlternateTransferFunctionSei)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265AlternateTransferFunctionSei
alternateTransferFunctionSei :: Maybe H265AlternateTransferFunctionSei
$sel:alternateTransferFunctionSei:H265Settings' :: H265Settings -> Maybe H265AlternateTransferFunctionSei
alternateTransferFunctionSei} -> Maybe H265AlternateTransferFunctionSei
alternateTransferFunctionSei) (\s :: H265Settings
s@H265Settings' {} Maybe H265AlternateTransferFunctionSei
a -> H265Settings
s {$sel:alternateTransferFunctionSei:H265Settings' :: Maybe H265AlternateTransferFunctionSei
alternateTransferFunctionSei = Maybe H265AlternateTransferFunctionSei
a} :: H265Settings)

-- | Use this setting to specify whether this output has a variable bitrate
-- (VBR), constant bitrate (CBR) or quality-defined variable bitrate
-- (QVBR).
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)

-- | Number of reference frames to use. The encoder may use more than
-- requested if using B-frames and\/or interlaced encoding.
h265Settings_numberReferenceFrames :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_numberReferenceFrames :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_numberReferenceFrames = (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
numberReferenceFrames :: Maybe Natural
$sel:numberReferenceFrames:H265Settings' :: H265Settings -> Maybe Natural
numberReferenceFrames} -> Maybe Natural
numberReferenceFrames) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:numberReferenceFrames:H265Settings' :: Maybe Natural
numberReferenceFrames = Maybe Natural
a} :: H265Settings)

-- | This field applies only if the Streams > Advanced > Framerate
-- (framerate) field is set to 29.970. This field works with the Streams >
-- Advanced > Preprocessors > Deinterlacer field (deinterlace_mode) and the
-- Streams > Advanced > Interlaced Mode field (interlace_mode) to identify
-- the scan type for the output: Progressive, Interlaced, Hard Telecine or
-- Soft Telecine. - Hard: produces 29.97i output from 23.976 input. - Soft:
-- produces 23.976; the player converts this output to 29.97i.
h265Settings_telecine :: Lens.Lens' H265Settings (Prelude.Maybe H265Telecine)
h265Settings_telecine :: (Maybe H265Telecine -> f (Maybe H265Telecine))
-> H265Settings -> f H265Settings
h265Settings_telecine = (H265Settings -> Maybe H265Telecine)
-> (H265Settings -> Maybe H265Telecine -> H265Settings)
-> Lens
     H265Settings H265Settings (Maybe H265Telecine) (Maybe H265Telecine)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265Telecine
telecine :: Maybe H265Telecine
$sel:telecine:H265Settings' :: H265Settings -> Maybe H265Telecine
telecine} -> Maybe H265Telecine
telecine) (\s :: H265Settings
s@H265Settings' {} Maybe H265Telecine
a -> H265Settings
s {$sel:telecine:H265Settings' :: Maybe H265Telecine
telecine = Maybe H265Telecine
a} :: H265Settings)

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

-- | Enforces separation between repeated (cadence) I-frames and I-frames
-- inserted by Scene Change Detection. If a scene change I-frame is within
-- I-interval frames of a cadence I-frame, the GOP is shrunk and\/or
-- stretched to the scene change I-frame. GOP stretch requires enabling
-- lookahead as well as setting I-interval. The normal cadence resumes for
-- the next GOP. This setting is only used when Scene Change Detect is
-- enabled. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1
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)

-- | Choose the scan line type for the output. Keep the default value,
-- Progressive (PROGRESSIVE) to create a progressive output, regardless of
-- the scan type of your input. Use Top field first (TOP_FIELD) or Bottom
-- field first (BOTTOM_FIELD) to create an output that\'s interlaced with
-- the same field polarity throughout. Use Follow, default top
-- (FOLLOW_TOP_FIELD) or Follow, default bottom (FOLLOW_BOTTOM_FIELD) to
-- produce outputs with the same field polarity as the source. For jobs
-- that have multiple inputs, the output field polarity might change over
-- the course of the output. Follow behavior depends on the input scan
-- type. If the source is interlaced, the output will be interlaced with
-- the same polarity as the source. If the source is progressive, the
-- output will be interlaced with top field bottom field first, depending
-- on which of the Follow options you choose.
h265Settings_interlaceMode :: Lens.Lens' H265Settings (Prelude.Maybe H265InterlaceMode)
h265Settings_interlaceMode :: (Maybe H265InterlaceMode -> f (Maybe H265InterlaceMode))
-> H265Settings -> f H265Settings
h265Settings_interlaceMode = (H265Settings -> Maybe H265InterlaceMode)
-> (H265Settings -> Maybe H265InterlaceMode -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265InterlaceMode)
     (Maybe H265InterlaceMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265InterlaceMode
interlaceMode :: Maybe H265InterlaceMode
$sel:interlaceMode:H265Settings' :: H265Settings -> Maybe H265InterlaceMode
interlaceMode} -> Maybe H265InterlaceMode
interlaceMode) (\s :: H265Settings
s@H265Settings' {} Maybe H265InterlaceMode
a -> H265Settings
s {$sel:interlaceMode:H265Settings' :: Maybe H265InterlaceMode
interlaceMode = Maybe H265InterlaceMode
a} :: H265Settings)

-- | Optional. Specify how the service determines the pixel aspect ratio
-- (PAR) for this output. The default behavior, Follow source
-- (INITIALIZE_FROM_SOURCE), uses the PAR from your input video for your
-- output. To specify a different PAR in the console, choose any value
-- other than Follow source. To specify a different PAR by editing the JSON
-- job specification, choose SPECIFIED. When you choose SPECIFIED for this
-- setting, you must also specify values for the parNumerator and
-- parDenominator settings.
h265Settings_parControl :: Lens.Lens' H265Settings (Prelude.Maybe H265ParControl)
h265Settings_parControl :: (Maybe H265ParControl -> f (Maybe H265ParControl))
-> H265Settings -> f H265Settings
h265Settings_parControl = (H265Settings -> Maybe H265ParControl)
-> (H265Settings -> Maybe H265ParControl -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265ParControl)
     (Maybe H265ParControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265ParControl
parControl :: Maybe H265ParControl
$sel:parControl:H265Settings' :: H265Settings -> Maybe H265ParControl
parControl} -> Maybe H265ParControl
parControl) (\s :: H265Settings
s@H265Settings' {} Maybe H265ParControl
a -> H265Settings
s {$sel:parControl:H265Settings' :: Maybe H265ParControl
parControl = Maybe H265ParControl
a} :: H265Settings)

-- | Use this setting for interlaced outputs, when your output frame rate is
-- half of your input frame rate. In this situation, choose Optimized
-- interlacing (INTERLACED_OPTIMIZE) to create a better quality interlaced
-- output. In this case, each progressive frame from the input corresponds
-- to an interlaced field in the output. Keep the default value, Basic
-- interlacing (INTERLACED), for all other output frame rates. With basic
-- interlacing, MediaConvert performs any frame rate conversion first and
-- then interlaces the frames. When you choose Optimized interlacing and
-- you set your output frame rate to a value that isn\'t suitable for
-- optimized interlacing, MediaConvert automatically falls back to basic
-- interlacing. Required settings: To use optimized interlacing, you must
-- set Telecine (telecine) to None (NONE) or Soft (SOFT). You can\'t use
-- optimized interlacing for hard telecine outputs. You must also set
-- Interlace mode (interlaceMode) to a value other than Progressive
-- (PROGRESSIVE).
h265Settings_scanTypeConversionMode :: Lens.Lens' H265Settings (Prelude.Maybe H265ScanTypeConversionMode)
h265Settings_scanTypeConversionMode :: (Maybe H265ScanTypeConversionMode
 -> f (Maybe H265ScanTypeConversionMode))
-> H265Settings -> f H265Settings
h265Settings_scanTypeConversionMode = (H265Settings -> Maybe H265ScanTypeConversionMode)
-> (H265Settings
    -> Maybe H265ScanTypeConversionMode -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265ScanTypeConversionMode)
     (Maybe H265ScanTypeConversionMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265ScanTypeConversionMode
scanTypeConversionMode :: Maybe H265ScanTypeConversionMode
$sel:scanTypeConversionMode:H265Settings' :: H265Settings -> Maybe H265ScanTypeConversionMode
scanTypeConversionMode} -> Maybe H265ScanTypeConversionMode
scanTypeConversionMode) (\s :: H265Settings
s@H265Settings' {} Maybe H265ScanTypeConversionMode
a -> H265Settings
s {$sel:scanTypeConversionMode:H265Settings' :: Maybe H265ScanTypeConversionMode
scanTypeConversionMode = Maybe H265ScanTypeConversionMode
a} :: H265Settings)

-- | Enable this setting to have the encoder reduce I-frame pop. I-frame pop
-- appears as a visual flicker that can arise when the encoder saves bits
-- by copying some macroblocks many times from frame to frame, and then
-- refreshes them at the I-frame. When you enable this setting, the encoder
-- updates these macroblocks slightly more often to smooth out the flicker.
-- This setting is disabled by default. Related setting: In addition to
-- enabling this setting, you must also set adaptiveQuantization to a value
-- other than Off (OFF).
h265Settings_flickerAdaptiveQuantization :: Lens.Lens' H265Settings (Prelude.Maybe H265FlickerAdaptiveQuantization)
h265Settings_flickerAdaptiveQuantization :: (Maybe H265FlickerAdaptiveQuantization
 -> f (Maybe H265FlickerAdaptiveQuantization))
-> H265Settings -> f H265Settings
h265Settings_flickerAdaptiveQuantization = (H265Settings -> Maybe H265FlickerAdaptiveQuantization)
-> (H265Settings
    -> Maybe H265FlickerAdaptiveQuantization -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265FlickerAdaptiveQuantization)
     (Maybe H265FlickerAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265FlickerAdaptiveQuantization
flickerAdaptiveQuantization :: Maybe H265FlickerAdaptiveQuantization
$sel:flickerAdaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265FlickerAdaptiveQuantization
flickerAdaptiveQuantization} -> Maybe H265FlickerAdaptiveQuantization
flickerAdaptiveQuantization) (\s :: H265Settings
s@H265Settings' {} Maybe H265FlickerAdaptiveQuantization
a -> H265Settings
s {$sel:flickerAdaptiveQuantization:H265Settings' :: Maybe H265FlickerAdaptiveQuantization
flickerAdaptiveQuantization = Maybe H265FlickerAdaptiveQuantization
a} :: H265Settings)

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

-- | Specify Sample Adaptive Offset (SAO) filter strength. Adaptive mode
-- dynamically selects best strength based on content
h265Settings_sampleAdaptiveOffsetFilterMode :: Lens.Lens' H265Settings (Prelude.Maybe H265SampleAdaptiveOffsetFilterMode)
h265Settings_sampleAdaptiveOffsetFilterMode :: (Maybe H265SampleAdaptiveOffsetFilterMode
 -> f (Maybe H265SampleAdaptiveOffsetFilterMode))
-> H265Settings -> f H265Settings
h265Settings_sampleAdaptiveOffsetFilterMode = (H265Settings -> Maybe H265SampleAdaptiveOffsetFilterMode)
-> (H265Settings
    -> Maybe H265SampleAdaptiveOffsetFilterMode -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265SampleAdaptiveOffsetFilterMode)
     (Maybe H265SampleAdaptiveOffsetFilterMode)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265SampleAdaptiveOffsetFilterMode
sampleAdaptiveOffsetFilterMode :: Maybe H265SampleAdaptiveOffsetFilterMode
$sel:sampleAdaptiveOffsetFilterMode:H265Settings' :: H265Settings -> Maybe H265SampleAdaptiveOffsetFilterMode
sampleAdaptiveOffsetFilterMode} -> Maybe H265SampleAdaptiveOffsetFilterMode
sampleAdaptiveOffsetFilterMode) (\s :: H265Settings
s@H265Settings' {} Maybe H265SampleAdaptiveOffsetFilterMode
a -> H265Settings
s {$sel:sampleAdaptiveOffsetFilterMode:H265Settings' :: Maybe H265SampleAdaptiveOffsetFilterMode
sampleAdaptiveOffsetFilterMode = Maybe H265SampleAdaptiveOffsetFilterMode
a} :: H265Settings)

-- | Represents the Profile and Tier, per the HEVC (H.265) specification.
-- Selections are grouped as [Profile] \/ [Tier], so \"Main\/High\"
-- represents Main Profile with High Tier. 4:2:2 profiles are only
-- available with the HEVC 4:2:2 License.
h265Settings_codecProfile :: Lens.Lens' H265Settings (Prelude.Maybe H265CodecProfile)
h265Settings_codecProfile :: (Maybe H265CodecProfile -> f (Maybe H265CodecProfile))
-> H265Settings -> f H265Settings
h265Settings_codecProfile = (H265Settings -> Maybe H265CodecProfile)
-> (H265Settings -> Maybe H265CodecProfile -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265CodecProfile)
     (Maybe H265CodecProfile)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265CodecProfile
codecProfile :: Maybe H265CodecProfile
$sel:codecProfile:H265Settings' :: H265Settings -> Maybe H265CodecProfile
codecProfile} -> Maybe H265CodecProfile
codecProfile) (\s :: H265Settings
s@H265Settings' {} Maybe H265CodecProfile
a -> H265Settings
s {$sel:codecProfile:H265Settings' :: Maybe H265CodecProfile
codecProfile = Maybe H265CodecProfile
a} :: H265Settings)

-- | Specify the average bitrate in bits per second. Required for VBR and
-- CBR. For MS Smooth outputs, bitrates must be unique when rounded down to
-- the nearest multiple of 1000.
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)

-- | When you use the API for transcode jobs that use frame rate conversion,
-- specify the frame rate as a fraction. For example, 24000 \/ 1001 =
-- 23.976 fps. Use FramerateDenominator to specify the denominator of this
-- fraction. In this example, use 1001 for the value of
-- FramerateDenominator. When you use the console for transcode jobs that
-- use frame rate conversion, provide the value as a decimal number for
-- Framerate. In this example, specify 23.976.
h265Settings_framerateDenominator :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_framerateDenominator :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_framerateDenominator = (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
framerateDenominator :: Maybe Natural
$sel:framerateDenominator:H265Settings' :: H265Settings -> Maybe Natural
framerateDenominator} -> Maybe Natural
framerateDenominator) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:framerateDenominator:H265Settings' :: Maybe Natural
framerateDenominator = Maybe Natural
a} :: H265Settings)

-- | Choose the method that you want MediaConvert to use when increasing or
-- decreasing the frame rate. We recommend using drop duplicate
-- (DUPLICATE_DROP) for numerically simple conversions, such as 60 fps to
-- 30 fps. For numerically complex conversions, you can use interpolate
-- (INTERPOLATE) to avoid stutter. This results in a smooth picture, but
-- might introduce undesirable video artifacts. For complex frame rate
-- conversions, especially if your source video has already been converted
-- from its original cadence, use FrameFormer (FRAMEFORMER) to do
-- motion-compensated interpolation. FrameFormer chooses the best
-- conversion method frame by frame. Note that using FrameFormer increases
-- the transcoding time and incurs a significant add-on cost.
h265Settings_framerateConversionAlgorithm :: Lens.Lens' H265Settings (Prelude.Maybe H265FramerateConversionAlgorithm)
h265Settings_framerateConversionAlgorithm :: (Maybe H265FramerateConversionAlgorithm
 -> f (Maybe H265FramerateConversionAlgorithm))
-> H265Settings -> f H265Settings
h265Settings_framerateConversionAlgorithm = (H265Settings -> Maybe H265FramerateConversionAlgorithm)
-> (H265Settings
    -> Maybe H265FramerateConversionAlgorithm -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265FramerateConversionAlgorithm)
     (Maybe H265FramerateConversionAlgorithm)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265FramerateConversionAlgorithm
framerateConversionAlgorithm :: Maybe H265FramerateConversionAlgorithm
$sel:framerateConversionAlgorithm:H265Settings' :: H265Settings -> Maybe H265FramerateConversionAlgorithm
framerateConversionAlgorithm} -> Maybe H265FramerateConversionAlgorithm
framerateConversionAlgorithm) (\s :: H265Settings
s@H265Settings' {} Maybe H265FramerateConversionAlgorithm
a -> H265Settings
s {$sel:framerateConversionAlgorithm:H265Settings' :: Maybe H265FramerateConversionAlgorithm
framerateConversionAlgorithm = Maybe H265FramerateConversionAlgorithm
a} :: H265Settings)

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

-- | If you are using the console, use the Framerate setting to specify the
-- frame rate for this output. If you want to keep the same frame rate as
-- the input video, choose Follow source. If you want to do frame rate
-- conversion, choose a frame rate from the dropdown list or choose Custom.
-- The framerates shown in the dropdown list are decimal approximations of
-- fractions. If you choose Custom, specify your frame rate as a fraction.
-- If you are creating your transcoding job specification as a JSON file
-- without the console, use FramerateControl to specify which value the
-- service uses for the frame rate for this output. Choose
-- INITIALIZE_FROM_SOURCE if you want the service to use the frame rate
-- from the input. Choose SPECIFIED if you want the service to use the
-- frame rate you specify in the settings FramerateNumerator and
-- FramerateDenominator.
h265Settings_framerateControl :: Lens.Lens' H265Settings (Prelude.Maybe H265FramerateControl)
h265Settings_framerateControl :: (Maybe H265FramerateControl -> f (Maybe H265FramerateControl))
-> H265Settings -> f H265Settings
h265Settings_framerateControl = (H265Settings -> Maybe H265FramerateControl)
-> (H265Settings -> Maybe H265FramerateControl -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265FramerateControl)
     (Maybe H265FramerateControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265FramerateControl
framerateControl :: Maybe H265FramerateControl
$sel:framerateControl:H265Settings' :: H265Settings -> Maybe H265FramerateControl
framerateControl} -> Maybe H265FramerateControl
framerateControl) (\s :: H265Settings
s@H265Settings' {} Maybe H265FramerateControl
a -> H265Settings
s {$sel:framerateControl:H265Settings' :: Maybe H265FramerateControl
framerateControl = Maybe H265FramerateControl
a} :: H265Settings)

-- | If the location of parameter set NAL units doesn\'t matter in your
-- workflow, ignore this setting. Use this setting only with CMAF or DASH
-- outputs, or with standalone file outputs in an MPEG-4 container (MP4
-- outputs). Choose HVC1 to mark your output as HVC1. This makes your
-- output compliant with the following specification: ISO IECJTC1 SC29
-- N13798 Text ISO\/IEC FDIS 14496-15 3rd Edition. For these outputs, the
-- service stores parameter set NAL units in the sample headers but not in
-- the samples directly. For MP4 outputs, when you choose HVC1, your output
-- video might not work properly with some downstream systems and video
-- players. The service defaults to marking your output as HEV1. For these
-- outputs, the service writes parameter set NAL units directly into the
-- samples.
h265Settings_writeMp4PackagingType :: Lens.Lens' H265Settings (Prelude.Maybe H265WriteMp4PackagingType)
h265Settings_writeMp4PackagingType :: (Maybe H265WriteMp4PackagingType
 -> f (Maybe H265WriteMp4PackagingType))
-> H265Settings -> f H265Settings
h265Settings_writeMp4PackagingType = (H265Settings -> Maybe H265WriteMp4PackagingType)
-> (H265Settings
    -> Maybe H265WriteMp4PackagingType -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265WriteMp4PackagingType)
     (Maybe H265WriteMp4PackagingType)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265WriteMp4PackagingType
writeMp4PackagingType :: Maybe H265WriteMp4PackagingType
$sel:writeMp4PackagingType:H265Settings' :: H265Settings -> Maybe H265WriteMp4PackagingType
writeMp4PackagingType} -> Maybe H265WriteMp4PackagingType
writeMp4PackagingType) (\s :: H265Settings
s@H265Settings' {} Maybe H265WriteMp4PackagingType
a -> H265Settings
s {$sel:writeMp4PackagingType:H265Settings' :: Maybe H265WriteMp4PackagingType
writeMp4PackagingType = Maybe H265WriteMp4PackagingType
a} :: H265Settings)

-- | Specify the strength of any adaptive quantization filters that you
-- enable. The value that you choose here applies to the following
-- settings: Flicker adaptive quantization (flickerAdaptiveQuantization),
-- Spatial adaptive quantization (spatialAdaptiveQuantization), and
-- Temporal adaptive quantization (temporalAdaptiveQuantization).
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)

-- | When you use the API for transcode jobs that use frame rate conversion,
-- specify the frame rate as a fraction. For example, 24000 \/ 1001 =
-- 23.976 fps. Use FramerateNumerator to specify the numerator of this
-- fraction. In this example, use 24000 for the value of
-- FramerateNumerator. When you use the console for transcode jobs that use
-- frame rate conversion, provide the value as a decimal number for
-- Framerate. In this example, specify 23.976.
h265Settings_framerateNumerator :: Lens.Lens' H265Settings (Prelude.Maybe Prelude.Natural)
h265Settings_framerateNumerator :: (Maybe Natural -> f (Maybe Natural))
-> H265Settings -> f H265Settings
h265Settings_framerateNumerator = (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
framerateNumerator :: Maybe Natural
$sel:framerateNumerator:H265Settings' :: H265Settings -> Maybe Natural
framerateNumerator} -> Maybe Natural
framerateNumerator) (\s :: H265Settings
s@H265Settings' {} Maybe Natural
a -> H265Settings
s {$sel:framerateNumerator:H265Settings' :: Maybe Natural
framerateNumerator = Maybe Natural
a} :: H265Settings)

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

-- | Maximum bitrate in bits\/second. For example, enter five megabits per
-- second as 5000000. Required when Rate control mode is QVBR.
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)

-- | Required when you set Pixel aspect ratio (parControl) to SPECIFIED. On
-- the console, this corresponds to any value other than Follow source.
-- When you specify an output pixel aspect ratio (PAR) that is different
-- from your input video PAR, provide your output PAR as a ratio. For
-- example, for D1\/DV NTSC widescreen, you would specify the ratio 40:33.
-- In this example, the value for parDenominator is 33.
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)

-- | Keep the default value, Enabled (ENABLED), to adjust quantization within
-- each frame based on spatial variation of content complexity. When you
-- enable this feature, the encoder uses fewer bits on areas that can
-- sustain more distortion with no noticeable visual degradation and uses
-- more bits on areas where any small distortion will be noticeable. For
-- example, complex textured blocks are encoded with fewer bits and smooth
-- textured blocks are encoded with more bits. Enabling this feature will
-- almost always improve your video quality. Note, though, that this
-- feature doesn\'t take into account where the viewer\'s attention is
-- likely to be. If viewers are likely to be focusing their attention on a
-- part of the screen with a lot of complex texture, you might choose to
-- disable this feature. Related setting: When you enable spatial adaptive
-- quantization, set the value for Adaptive quantization
-- (adaptiveQuantization) depending on your content. For homogeneous
-- content, such as cartoons and video games, set it to Low. For content
-- with a wider variety of textures, set it to High or Higher.
h265Settings_spatialAdaptiveQuantization :: Lens.Lens' H265Settings (Prelude.Maybe H265SpatialAdaptiveQuantization)
h265Settings_spatialAdaptiveQuantization :: (Maybe H265SpatialAdaptiveQuantization
 -> f (Maybe H265SpatialAdaptiveQuantization))
-> H265Settings -> f H265Settings
h265Settings_spatialAdaptiveQuantization = (H265Settings -> Maybe H265SpatialAdaptiveQuantization)
-> (H265Settings
    -> Maybe H265SpatialAdaptiveQuantization -> H265Settings)
-> Lens
     H265Settings
     H265Settings
     (Maybe H265SpatialAdaptiveQuantization)
     (Maybe H265SpatialAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\H265Settings' {Maybe H265SpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe H265SpatialAdaptiveQuantization
$sel:spatialAdaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265SpatialAdaptiveQuantization
spatialAdaptiveQuantization} -> Maybe H265SpatialAdaptiveQuantization
spatialAdaptiveQuantization) (\s :: H265Settings
s@H265Settings' {} Maybe H265SpatialAdaptiveQuantization
a -> H265Settings
s {$sel:spatialAdaptiveQuantization:H265Settings' :: Maybe H265SpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe H265SpatialAdaptiveQuantization
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 H265UnregisteredSeiTimecode
-> Maybe H265QualityTuningLevel
-> Maybe H265TemporalAdaptiveQuantization
-> Maybe H265SceneChangeDetect
-> Maybe Natural
-> Maybe H265Tiles
-> Maybe H265SlowPal
-> Maybe H265TemporalIds
-> Maybe Natural
-> Maybe Double
-> Maybe Natural
-> Maybe H265GopSizeUnits
-> Maybe Natural
-> Maybe Natural
-> Maybe H265AlternateTransferFunctionSei
-> Maybe H265RateControlMode
-> Maybe Natural
-> Maybe H265Telecine
-> Maybe H265DynamicSubGop
-> Maybe Natural
-> Maybe H265InterlaceMode
-> Maybe H265ParControl
-> Maybe H265ScanTypeConversionMode
-> Maybe H265FlickerAdaptiveQuantization
-> Maybe H265QvbrSettings
-> Maybe H265SampleAdaptiveOffsetFilterMode
-> Maybe H265CodecProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe H265FramerateConversionAlgorithm
-> Maybe H265CodecLevel
-> Maybe H265FramerateControl
-> Maybe H265WriteMp4PackagingType
-> Maybe H265AdaptiveQuantization
-> Maybe Natural
-> Maybe H265GopBReference
-> Maybe Natural
-> Maybe Natural
-> Maybe Natural
-> Maybe H265SpatialAdaptiveQuantization
-> H265Settings
H265Settings'
            (Maybe H265UnregisteredSeiTimecode
 -> Maybe H265QualityTuningLevel
 -> Maybe H265TemporalAdaptiveQuantization
 -> Maybe H265SceneChangeDetect
 -> Maybe Natural
 -> Maybe H265Tiles
 -> Maybe H265SlowPal
 -> Maybe H265TemporalIds
 -> Maybe Natural
 -> Maybe Double
 -> Maybe Natural
 -> Maybe H265GopSizeUnits
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe H265AlternateTransferFunctionSei
 -> Maybe H265RateControlMode
 -> Maybe Natural
 -> Maybe H265Telecine
 -> Maybe H265DynamicSubGop
 -> Maybe Natural
 -> Maybe H265InterlaceMode
 -> Maybe H265ParControl
 -> Maybe H265ScanTypeConversionMode
 -> Maybe H265FlickerAdaptiveQuantization
 -> Maybe H265QvbrSettings
 -> Maybe H265SampleAdaptiveOffsetFilterMode
 -> Maybe H265CodecProfile
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe H265FramerateConversionAlgorithm
 -> Maybe H265CodecLevel
 -> Maybe H265FramerateControl
 -> Maybe H265WriteMp4PackagingType
 -> Maybe H265AdaptiveQuantization
 -> Maybe Natural
 -> Maybe H265GopBReference
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe H265SpatialAdaptiveQuantization
 -> H265Settings)
-> Parser (Maybe H265UnregisteredSeiTimecode)
-> Parser
     (Maybe H265QualityTuningLevel
      -> Maybe H265TemporalAdaptiveQuantization
      -> Maybe H265SceneChangeDetect
      -> Maybe Natural
      -> Maybe H265Tiles
      -> Maybe H265SlowPal
      -> Maybe H265TemporalIds
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe H265UnregisteredSeiTimecode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"unregisteredSeiTimecode")
            Parser
  (Maybe H265QualityTuningLevel
   -> Maybe H265TemporalAdaptiveQuantization
   -> Maybe H265SceneChangeDetect
   -> Maybe Natural
   -> Maybe H265Tiles
   -> Maybe H265SlowPal
   -> Maybe H265TemporalIds
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265QualityTuningLevel)
-> Parser
     (Maybe H265TemporalAdaptiveQuantization
      -> Maybe H265SceneChangeDetect
      -> Maybe Natural
      -> Maybe H265Tiles
      -> Maybe H265SlowPal
      -> Maybe H265TemporalIds
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265QualityTuningLevel)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"qualityTuningLevel")
            Parser
  (Maybe H265TemporalAdaptiveQuantization
   -> Maybe H265SceneChangeDetect
   -> Maybe Natural
   -> Maybe H265Tiles
   -> Maybe H265SlowPal
   -> Maybe H265TemporalIds
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265TemporalAdaptiveQuantization)
-> Parser
     (Maybe H265SceneChangeDetect
      -> Maybe Natural
      -> Maybe H265Tiles
      -> Maybe H265SlowPal
      -> Maybe H265TemporalIds
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265TemporalAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"temporalAdaptiveQuantization")
            Parser
  (Maybe H265SceneChangeDetect
   -> Maybe Natural
   -> Maybe H265Tiles
   -> Maybe H265SlowPal
   -> Maybe H265TemporalIds
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265SceneChangeDetect)
-> Parser
     (Maybe Natural
      -> Maybe H265Tiles
      -> Maybe H265SlowPal
      -> Maybe H265TemporalIds
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => 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 Natural
   -> Maybe H265Tiles
   -> Maybe H265SlowPal
   -> Maybe H265TemporalIds
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265Tiles
      -> Maybe H265SlowPal
      -> Maybe H265TemporalIds
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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
"hrdBufferInitialFillPercentage")
            Parser
  (Maybe H265Tiles
   -> Maybe H265SlowPal
   -> Maybe H265TemporalIds
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265Tiles)
-> Parser
     (Maybe H265SlowPal
      -> Maybe H265TemporalIds
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265Tiles)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"tiles")
            Parser
  (Maybe H265SlowPal
   -> Maybe H265TemporalIds
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265SlowPal)
-> Parser
     (Maybe H265TemporalIds
      -> Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265SlowPal)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"slowPal")
            Parser
  (Maybe H265TemporalIds
   -> Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265TemporalIds)
-> Parser
     (Maybe Natural
      -> Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265TemporalIds)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"temporalIds")
            Parser
  (Maybe Natural
   -> Maybe Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Double
      -> Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 Double
   -> Maybe Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Double)
-> Parser
     (Maybe Natural
      -> Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 Natural
   -> Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265GopSizeUnits
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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
"numberBFramesBetweenReferenceFrames")
            Parser
  (Maybe H265GopSizeUnits
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265GopSizeUnits)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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
"hrdBufferSize")
            Parser
  (Maybe Natural
   -> Maybe H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265AlternateTransferFunctionSei
      -> Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 H265AlternateTransferFunctionSei
   -> Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265AlternateTransferFunctionSei)
-> Parser
     (Maybe H265RateControlMode
      -> Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265AlternateTransferFunctionSei)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"alternateTransferFunctionSei")
            Parser
  (Maybe H265RateControlMode
   -> Maybe Natural
   -> Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265RateControlMode)
-> Parser
     (Maybe Natural
      -> Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265Telecine
      -> Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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
"numberReferenceFrames")
            Parser
  (Maybe H265Telecine
   -> Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265Telecine)
-> Parser
     (Maybe H265DynamicSubGop
      -> Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265Telecine)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"telecine")
            Parser
  (Maybe H265DynamicSubGop
   -> Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265DynamicSubGop)
-> Parser
     (Maybe Natural
      -> Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265DynamicSubGop)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"dynamicSubGop")
            Parser
  (Maybe Natural
   -> Maybe H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265InterlaceMode
      -> Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 H265InterlaceMode
   -> Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265InterlaceMode)
-> Parser
     (Maybe H265ParControl
      -> Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265InterlaceMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"interlaceMode")
            Parser
  (Maybe H265ParControl
   -> Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265ParControl)
-> Parser
     (Maybe H265ScanTypeConversionMode
      -> Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265ParControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"parControl")
            Parser
  (Maybe H265ScanTypeConversionMode
   -> Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265ScanTypeConversionMode)
-> Parser
     (Maybe H265FlickerAdaptiveQuantization
      -> Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265ScanTypeConversionMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"scanTypeConversionMode")
            Parser
  (Maybe H265FlickerAdaptiveQuantization
   -> Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265FlickerAdaptiveQuantization)
-> Parser
     (Maybe H265QvbrSettings
      -> Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265FlickerAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"flickerAdaptiveQuantization")
            Parser
  (Maybe H265QvbrSettings
   -> Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265QvbrSettings)
-> Parser
     (Maybe H265SampleAdaptiveOffsetFilterMode
      -> Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265QvbrSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"qvbrSettings")
            Parser
  (Maybe H265SampleAdaptiveOffsetFilterMode
   -> Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265SampleAdaptiveOffsetFilterMode)
-> Parser
     (Maybe H265CodecProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265SampleAdaptiveOffsetFilterMode)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"sampleAdaptiveOffsetFilterMode")
            Parser
  (Maybe H265CodecProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265CodecProfile)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265CodecProfile)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"codecProfile")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 Natural
   -> Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265FramerateConversionAlgorithm
      -> Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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
"framerateDenominator")
            Parser
  (Maybe H265FramerateConversionAlgorithm
   -> Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265FramerateConversionAlgorithm)
-> Parser
     (Maybe H265CodecLevel
      -> Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265FramerateConversionAlgorithm)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateConversionAlgorithm")
            Parser
  (Maybe H265CodecLevel
   -> Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265CodecLevel)
-> Parser
     (Maybe H265FramerateControl
      -> Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265CodecLevel)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"codecLevel")
            Parser
  (Maybe H265FramerateControl
   -> Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265FramerateControl)
-> Parser
     (Maybe H265WriteMp4PackagingType
      -> Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265FramerateControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateControl")
            Parser
  (Maybe H265WriteMp4PackagingType
   -> Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265WriteMp4PackagingType)
-> Parser
     (Maybe H265AdaptiveQuantization
      -> Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265WriteMp4PackagingType)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"writeMp4PackagingType")
            Parser
  (Maybe H265AdaptiveQuantization
   -> Maybe Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265AdaptiveQuantization)
-> Parser
     (Maybe Natural
      -> Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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 Natural
   -> Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe H265GopBReference
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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
"framerateNumerator")
            Parser
  (Maybe H265GopBReference
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe H265GopBReference)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> H265Settings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265GopBReference)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"gopBReference")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization
      -> 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
   -> Maybe H265SpatialAdaptiveQuantization
   -> H265Settings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe H265SpatialAdaptiveQuantization -> 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
   -> Maybe H265SpatialAdaptiveQuantization -> H265Settings)
-> Parser (Maybe Natural)
-> Parser (Maybe H265SpatialAdaptiveQuantization -> 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 (Maybe H265SpatialAdaptiveQuantization -> H265Settings)
-> Parser (Maybe H265SpatialAdaptiveQuantization)
-> Parser H265Settings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe H265SpatialAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"spatialAdaptiveQuantization")
      )

instance Prelude.Hashable H265Settings

instance Prelude.NFData H265Settings

instance Core.ToJSON H265Settings where
  toJSON :: H265Settings -> Value
toJSON H265Settings' {Maybe Double
Maybe Natural
Maybe H265AdaptiveQuantization
Maybe H265AlternateTransferFunctionSei
Maybe H265CodecLevel
Maybe H265CodecProfile
Maybe H265DynamicSubGop
Maybe H265FlickerAdaptiveQuantization
Maybe H265FramerateControl
Maybe H265FramerateConversionAlgorithm
Maybe H265GopBReference
Maybe H265GopSizeUnits
Maybe H265InterlaceMode
Maybe H265ParControl
Maybe H265QualityTuningLevel
Maybe H265QvbrSettings
Maybe H265RateControlMode
Maybe H265SampleAdaptiveOffsetFilterMode
Maybe H265ScanTypeConversionMode
Maybe H265SceneChangeDetect
Maybe H265SlowPal
Maybe H265SpatialAdaptiveQuantization
Maybe H265Telecine
Maybe H265TemporalAdaptiveQuantization
Maybe H265TemporalIds
Maybe H265Tiles
Maybe H265UnregisteredSeiTimecode
Maybe H265WriteMp4PackagingType
spatialAdaptiveQuantization :: Maybe H265SpatialAdaptiveQuantization
parDenominator :: Maybe Natural
gopClosedCadence :: Maybe Natural
maxBitrate :: Maybe Natural
gopBReference :: Maybe H265GopBReference
framerateNumerator :: Maybe Natural
adaptiveQuantization :: Maybe H265AdaptiveQuantization
writeMp4PackagingType :: Maybe H265WriteMp4PackagingType
framerateControl :: Maybe H265FramerateControl
codecLevel :: Maybe H265CodecLevel
framerateConversionAlgorithm :: Maybe H265FramerateConversionAlgorithm
framerateDenominator :: Maybe Natural
bitrate :: Maybe Natural
codecProfile :: Maybe H265CodecProfile
sampleAdaptiveOffsetFilterMode :: Maybe H265SampleAdaptiveOffsetFilterMode
qvbrSettings :: Maybe H265QvbrSettings
flickerAdaptiveQuantization :: Maybe H265FlickerAdaptiveQuantization
scanTypeConversionMode :: Maybe H265ScanTypeConversionMode
parControl :: Maybe H265ParControl
interlaceMode :: Maybe H265InterlaceMode
minIInterval :: Maybe Natural
dynamicSubGop :: Maybe H265DynamicSubGop
telecine :: Maybe H265Telecine
numberReferenceFrames :: Maybe Natural
rateControlMode :: Maybe H265RateControlMode
alternateTransferFunctionSei :: Maybe H265AlternateTransferFunctionSei
slices :: Maybe Natural
hrdBufferSize :: Maybe Natural
gopSizeUnits :: Maybe H265GopSizeUnits
numberBFramesBetweenReferenceFrames :: Maybe Natural
gopSize :: Maybe Double
parNumerator :: Maybe Natural
temporalIds :: Maybe H265TemporalIds
slowPal :: Maybe H265SlowPal
tiles :: Maybe H265Tiles
hrdBufferInitialFillPercentage :: Maybe Natural
sceneChangeDetect :: Maybe H265SceneChangeDetect
temporalAdaptiveQuantization :: Maybe H265TemporalAdaptiveQuantization
qualityTuningLevel :: Maybe H265QualityTuningLevel
unregisteredSeiTimecode :: Maybe H265UnregisteredSeiTimecode
$sel:spatialAdaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265SpatialAdaptiveQuantization
$sel:parDenominator:H265Settings' :: H265Settings -> Maybe Natural
$sel:gopClosedCadence:H265Settings' :: H265Settings -> Maybe Natural
$sel:maxBitrate:H265Settings' :: H265Settings -> Maybe Natural
$sel:gopBReference:H265Settings' :: H265Settings -> Maybe H265GopBReference
$sel:framerateNumerator:H265Settings' :: H265Settings -> Maybe Natural
$sel:adaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265AdaptiveQuantization
$sel:writeMp4PackagingType:H265Settings' :: H265Settings -> Maybe H265WriteMp4PackagingType
$sel:framerateControl:H265Settings' :: H265Settings -> Maybe H265FramerateControl
$sel:codecLevel:H265Settings' :: H265Settings -> Maybe H265CodecLevel
$sel:framerateConversionAlgorithm:H265Settings' :: H265Settings -> Maybe H265FramerateConversionAlgorithm
$sel:framerateDenominator:H265Settings' :: H265Settings -> Maybe Natural
$sel:bitrate:H265Settings' :: H265Settings -> Maybe Natural
$sel:codecProfile:H265Settings' :: H265Settings -> Maybe H265CodecProfile
$sel:sampleAdaptiveOffsetFilterMode:H265Settings' :: H265Settings -> Maybe H265SampleAdaptiveOffsetFilterMode
$sel:qvbrSettings:H265Settings' :: H265Settings -> Maybe H265QvbrSettings
$sel:flickerAdaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265FlickerAdaptiveQuantization
$sel:scanTypeConversionMode:H265Settings' :: H265Settings -> Maybe H265ScanTypeConversionMode
$sel:parControl:H265Settings' :: H265Settings -> Maybe H265ParControl
$sel:interlaceMode:H265Settings' :: H265Settings -> Maybe H265InterlaceMode
$sel:minIInterval:H265Settings' :: H265Settings -> Maybe Natural
$sel:dynamicSubGop:H265Settings' :: H265Settings -> Maybe H265DynamicSubGop
$sel:telecine:H265Settings' :: H265Settings -> Maybe H265Telecine
$sel:numberReferenceFrames:H265Settings' :: H265Settings -> Maybe Natural
$sel:rateControlMode:H265Settings' :: H265Settings -> Maybe H265RateControlMode
$sel:alternateTransferFunctionSei:H265Settings' :: H265Settings -> Maybe H265AlternateTransferFunctionSei
$sel:slices:H265Settings' :: H265Settings -> Maybe Natural
$sel:hrdBufferSize:H265Settings' :: H265Settings -> Maybe Natural
$sel:gopSizeUnits:H265Settings' :: H265Settings -> Maybe H265GopSizeUnits
$sel:numberBFramesBetweenReferenceFrames:H265Settings' :: H265Settings -> Maybe Natural
$sel:gopSize:H265Settings' :: H265Settings -> Maybe Double
$sel:parNumerator:H265Settings' :: H265Settings -> Maybe Natural
$sel:temporalIds:H265Settings' :: H265Settings -> Maybe H265TemporalIds
$sel:slowPal:H265Settings' :: H265Settings -> Maybe H265SlowPal
$sel:tiles:H265Settings' :: H265Settings -> Maybe H265Tiles
$sel:hrdBufferInitialFillPercentage:H265Settings' :: H265Settings -> Maybe Natural
$sel:sceneChangeDetect:H265Settings' :: H265Settings -> Maybe H265SceneChangeDetect
$sel:temporalAdaptiveQuantization:H265Settings' :: H265Settings -> Maybe H265TemporalAdaptiveQuantization
$sel:qualityTuningLevel:H265Settings' :: H265Settings -> Maybe H265QualityTuningLevel
$sel:unregisteredSeiTimecode:H265Settings' :: H265Settings -> Maybe H265UnregisteredSeiTimecode
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"unregisteredSeiTimecode" Text -> H265UnregisteredSeiTimecode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265UnregisteredSeiTimecode -> Pair)
-> Maybe H265UnregisteredSeiTimecode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265UnregisteredSeiTimecode
unregisteredSeiTimecode,
            (Text
"qualityTuningLevel" Text -> H265QualityTuningLevel -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265QualityTuningLevel -> Pair)
-> Maybe H265QualityTuningLevel -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265QualityTuningLevel
qualityTuningLevel,
            (Text
"temporalAdaptiveQuantization" Text -> H265TemporalAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265TemporalAdaptiveQuantization -> Pair)
-> Maybe H265TemporalAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265TemporalAdaptiveQuantization
temporalAdaptiveQuantization,
            (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
"hrdBufferInitialFillPercentage" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
hrdBufferInitialFillPercentage,
            (Text
"tiles" Text -> H265Tiles -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265Tiles -> Pair) -> Maybe H265Tiles -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265Tiles
tiles,
            (Text
"slowPal" Text -> H265SlowPal -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265SlowPal -> Pair) -> Maybe H265SlowPal -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265SlowPal
slowPal,
            (Text
"temporalIds" Text -> H265TemporalIds -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265TemporalIds -> Pair) -> Maybe H265TemporalIds -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265TemporalIds
temporalIds,
            (Text
"parNumerator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
parNumerator,
            (Text
"gopSize" Text -> Double -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Double -> Pair) -> Maybe Double -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Double
gopSize,
            (Text
"numberBFramesBetweenReferenceFrames" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
numberBFramesBetweenReferenceFrames,
            (Text
"gopSizeUnits" Text -> 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
"hrdBufferSize" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
hrdBufferSize,
            (Text
"slices" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
slices,
            (Text
"alternateTransferFunctionSei" Text -> H265AlternateTransferFunctionSei -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265AlternateTransferFunctionSei -> Pair)
-> Maybe H265AlternateTransferFunctionSei -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265AlternateTransferFunctionSei
alternateTransferFunctionSei,
            (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
"numberReferenceFrames" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
numberReferenceFrames,
            (Text
"telecine" Text -> H265Telecine -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265Telecine -> Pair) -> Maybe H265Telecine -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265Telecine
telecine,
            (Text
"dynamicSubGop" Text -> H265DynamicSubGop -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265DynamicSubGop -> Pair)
-> Maybe H265DynamicSubGop -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265DynamicSubGop
dynamicSubGop,
            (Text
"minIInterval" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
minIInterval,
            (Text
"interlaceMode" Text -> H265InterlaceMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265InterlaceMode -> Pair)
-> Maybe H265InterlaceMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265InterlaceMode
interlaceMode,
            (Text
"parControl" Text -> H265ParControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265ParControl -> Pair) -> Maybe H265ParControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265ParControl
parControl,
            (Text
"scanTypeConversionMode" Text -> H265ScanTypeConversionMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265ScanTypeConversionMode -> Pair)
-> Maybe H265ScanTypeConversionMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265ScanTypeConversionMode
scanTypeConversionMode,
            (Text
"flickerAdaptiveQuantization" Text -> H265FlickerAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265FlickerAdaptiveQuantization -> Pair)
-> Maybe H265FlickerAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265FlickerAdaptiveQuantization
flickerAdaptiveQuantization,
            (Text
"qvbrSettings" Text -> H265QvbrSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265QvbrSettings -> Pair) -> Maybe H265QvbrSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265QvbrSettings
qvbrSettings,
            (Text
"sampleAdaptiveOffsetFilterMode" Text -> H265SampleAdaptiveOffsetFilterMode -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265SampleAdaptiveOffsetFilterMode -> Pair)
-> Maybe H265SampleAdaptiveOffsetFilterMode -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265SampleAdaptiveOffsetFilterMode
sampleAdaptiveOffsetFilterMode,
            (Text
"codecProfile" Text -> H265CodecProfile -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265CodecProfile -> Pair) -> Maybe H265CodecProfile -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265CodecProfile
codecProfile,
            (Text
"bitrate" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
bitrate,
            (Text
"framerateDenominator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
framerateDenominator,
            (Text
"framerateConversionAlgorithm" Text -> H265FramerateConversionAlgorithm -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265FramerateConversionAlgorithm -> Pair)
-> Maybe H265FramerateConversionAlgorithm -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265FramerateConversionAlgorithm
framerateConversionAlgorithm,
            (Text
"codecLevel" Text -> H265CodecLevel -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265CodecLevel -> Pair) -> Maybe H265CodecLevel -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265CodecLevel
codecLevel,
            (Text
"framerateControl" Text -> H265FramerateControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265FramerateControl -> Pair)
-> Maybe H265FramerateControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265FramerateControl
framerateControl,
            (Text
"writeMp4PackagingType" Text -> H265WriteMp4PackagingType -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265WriteMp4PackagingType -> Pair)
-> Maybe H265WriteMp4PackagingType -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265WriteMp4PackagingType
writeMp4PackagingType,
            (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
"framerateNumerator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
framerateNumerator,
            (Text
"gopBReference" Text -> H265GopBReference -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (H265GopBReference -> Pair)
-> Maybe H265GopBReference -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265GopBReference
gopBReference,
            (Text
"maxBitrate" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
maxBitrate,
            (Text
"gopClosedCadence" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
gopClosedCadence,
            (Text
"parDenominator" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
parDenominator,
            (Text
"spatialAdaptiveQuantization" Text -> H265SpatialAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (H265SpatialAdaptiveQuantization -> Pair)
-> Maybe H265SpatialAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe H265SpatialAdaptiveQuantization
spatialAdaptiveQuantization
          ]
      )