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

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaConvert.Types.Xavc4kIntraCbgProfileSettings
import Amazonka.MediaConvert.Types.Xavc4kIntraVbrProfileSettings
import Amazonka.MediaConvert.Types.Xavc4kProfileSettings
import Amazonka.MediaConvert.Types.XavcAdaptiveQuantization
import Amazonka.MediaConvert.Types.XavcEntropyEncoding
import Amazonka.MediaConvert.Types.XavcFramerateControl
import Amazonka.MediaConvert.Types.XavcFramerateConversionAlgorithm
import Amazonka.MediaConvert.Types.XavcHdIntraCbgProfileSettings
import Amazonka.MediaConvert.Types.XavcHdProfileSettings
import Amazonka.MediaConvert.Types.XavcProfile
import Amazonka.MediaConvert.Types.XavcSlowPal
import Amazonka.MediaConvert.Types.XavcSpatialAdaptiveQuantization
import Amazonka.MediaConvert.Types.XavcTemporalAdaptiveQuantization
import qualified Amazonka.Prelude as Prelude

-- | Required when you set (Codec) under (VideoDescription)>(CodecSettings)
-- to the value XAVC.
--
-- /See:/ 'newXavcSettings' smart constructor.
data XavcSettings = XavcSettings'
  { -- | The best way to set up adaptive quantization is to keep the default
    -- value, Auto (AUTO), for the setting Adaptive quantization
    -- (adaptiveQuantization). When you do so, MediaConvert automatically
    -- applies the best types of quantization for your video content. Include
    -- this setting in your JSON job specification only when you choose to
    -- change the default value for Adaptive quantization. For this setting,
    -- 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 adaptive quantization, adjust the strength of the filter with
    -- the setting Adaptive quantization (adaptiveQuantization).
    XavcSettings -> Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Prelude.Maybe XavcTemporalAdaptiveQuantization,
    -- | 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 by
    -- relabeling the video frames and resampling your audio. Note that
    -- enabling this setting will slightly reduce the duration of your video.
    -- Related settings: You must also set Frame rate to 25. In your JSON job
    -- specification, set (framerateControl) to (SPECIFIED),
    -- (framerateNumerator) to 25 and (framerateDenominator) to 1.
    XavcSettings -> Maybe XavcSlowPal
slowPal :: Prelude.Maybe XavcSlowPal,
    -- | Required when you set (Profile) under
    -- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_4K.
    XavcSettings -> Maybe Xavc4kProfileSettings
xavc4kProfileSettings :: Prelude.Maybe Xavc4kProfileSettings,
    -- | Required when you set (Profile) under
    -- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
    -- XAVC_HD_INTRA_CBG.
    XavcSettings -> Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings :: Prelude.Maybe XavcHdIntraCbgProfileSettings,
    -- | Required when you set (Profile) under
    -- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
    -- XAVC_4K_INTRA_VBR.
    XavcSettings -> Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings :: Prelude.Maybe Xavc4kIntraVbrProfileSettings,
    -- | Required when you set (Profile) under
    -- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
    -- XAVC_4K_INTRA_CBG.
    XavcSettings -> Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings :: Prelude.Maybe Xavc4kIntraCbgProfileSettings,
    -- | Specify the XAVC profile for this output. For more information, see the
    -- Sony documentation at https:\/\/www.xavc-info.org\/. Note that
    -- MediaConvert doesn\'t support the interlaced video XAVC operating points
    -- for XAVC_HD_INTRA_CBG. To create an interlaced XAVC output, choose the
    -- profile XAVC_HD.
    XavcSettings -> Maybe XavcProfile
profile :: Prelude.Maybe XavcProfile,
    -- | Ignore this setting unless your downstream workflow requires that you
    -- specify it explicitly. Otherwise, we recommend that you adjust the
    -- softness of your output by using a lower value for the setting Sharpness
    -- (sharpness) or by enabling a noise reducer filter (noiseReducerFilter).
    -- The Softness (softness) setting specifies the quantization matrices that
    -- the encoder uses. Keep the default value, 0, for flat quantization.
    -- Choose the value 1 or 16 to use the default JVT softening quantization
    -- matricies from the H.264 specification. Choose a value from 17 to 128 to
    -- use planar interpolation. Increasing values from 17 to 128 result in
    -- increasing reduction of high-frequency data. The value 128 results in
    -- the softest video.
    XavcSettings -> Maybe Natural
softness :: 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
    -- Frame rate. In this example, specify 23.976.
    XavcSettings -> 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.
    XavcSettings -> Maybe XavcFramerateConversionAlgorithm
framerateConversionAlgorithm :: Prelude.Maybe XavcFramerateConversionAlgorithm,
    -- | Optional. Choose a specific entropy encoding mode only when you want to
    -- override XAVC recommendations. If you choose the value auto,
    -- MediaConvert uses the mode that the XAVC file format specifies given
    -- this output\'s operating point.
    XavcSettings -> Maybe XavcEntropyEncoding
entropyEncoding :: Prelude.Maybe XavcEntropyEncoding,
    -- | If you are using the console, use the Frame rate 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. The framerates
    -- shown in the dropdown list are decimal approximations of fractions. 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 that you specify in the settings FramerateNumerator and
    -- FramerateDenominator.
    XavcSettings -> Maybe XavcFramerateControl
framerateControl :: Prelude.Maybe XavcFramerateControl,
    -- | Keep the default value, Auto (AUTO), for this setting to have
    -- MediaConvert automatically apply the best types of quantization for your
    -- video content. When you want to apply your quantization settings
    -- manually, you must set Adaptive quantization (adaptiveQuantization) to a
    -- value other than Auto (AUTO). Use this setting to specify the strength
    -- of any adaptive quantization filters that you enable. If you don\'t want
    -- MediaConvert to do any adaptive quantization in this transcode, set
    -- Adaptive quantization to Off (OFF). Related settings: The value that you
    -- choose here applies to the following settings: Flicker adaptive
    -- quantization (flickerAdaptiveQuantization), Spatial adaptive
    -- quantization (spatialAdaptiveQuantization), and Temporal adaptive
    -- quantization (temporalAdaptiveQuantization).
    XavcSettings -> Maybe XavcAdaptiveQuantization
adaptiveQuantization :: Prelude.Maybe XavcAdaptiveQuantization,
    -- | 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.
    XavcSettings -> Maybe Natural
framerateNumerator :: Prelude.Maybe Prelude.Natural,
    -- | Required when you set (Profile) under
    -- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_HD.
    XavcSettings -> Maybe XavcHdProfileSettings
xavcHdProfileSettings :: Prelude.Maybe XavcHdProfileSettings,
    -- | The best way to set up adaptive quantization is to keep the default
    -- value, Auto (AUTO), for the setting Adaptive quantization
    -- (adaptiveQuantization). When you do so, MediaConvert automatically
    -- applies the best types of quantization for your video content. Include
    -- this setting in your JSON job specification only when you choose to
    -- change the default value for Adaptive quantization. For this setting,
    -- 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.
    XavcSettings -> Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Prelude.Maybe XavcSpatialAdaptiveQuantization
  }
  deriving (XavcSettings -> XavcSettings -> Bool
(XavcSettings -> XavcSettings -> Bool)
-> (XavcSettings -> XavcSettings -> Bool) -> Eq XavcSettings
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: XavcSettings -> XavcSettings -> Bool
$c/= :: XavcSettings -> XavcSettings -> Bool
== :: XavcSettings -> XavcSettings -> Bool
$c== :: XavcSettings -> XavcSettings -> Bool
Prelude.Eq, ReadPrec [XavcSettings]
ReadPrec XavcSettings
Int -> ReadS XavcSettings
ReadS [XavcSettings]
(Int -> ReadS XavcSettings)
-> ReadS [XavcSettings]
-> ReadPrec XavcSettings
-> ReadPrec [XavcSettings]
-> Read XavcSettings
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [XavcSettings]
$creadListPrec :: ReadPrec [XavcSettings]
readPrec :: ReadPrec XavcSettings
$creadPrec :: ReadPrec XavcSettings
readList :: ReadS [XavcSettings]
$creadList :: ReadS [XavcSettings]
readsPrec :: Int -> ReadS XavcSettings
$creadsPrec :: Int -> ReadS XavcSettings
Prelude.Read, Int -> XavcSettings -> ShowS
[XavcSettings] -> ShowS
XavcSettings -> String
(Int -> XavcSettings -> ShowS)
-> (XavcSettings -> String)
-> ([XavcSettings] -> ShowS)
-> Show XavcSettings
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [XavcSettings] -> ShowS
$cshowList :: [XavcSettings] -> ShowS
show :: XavcSettings -> String
$cshow :: XavcSettings -> String
showsPrec :: Int -> XavcSettings -> ShowS
$cshowsPrec :: Int -> XavcSettings -> ShowS
Prelude.Show, (forall x. XavcSettings -> Rep XavcSettings x)
-> (forall x. Rep XavcSettings x -> XavcSettings)
-> Generic XavcSettings
forall x. Rep XavcSettings x -> XavcSettings
forall x. XavcSettings -> Rep XavcSettings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep XavcSettings x -> XavcSettings
$cfrom :: forall x. XavcSettings -> Rep XavcSettings x
Prelude.Generic)

-- |
-- Create a value of 'XavcSettings' 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:
--
-- 'temporalAdaptiveQuantization', 'xavcSettings_temporalAdaptiveQuantization' - The best way to set up adaptive quantization is to keep the default
-- value, Auto (AUTO), for the setting Adaptive quantization
-- (adaptiveQuantization). When you do so, MediaConvert automatically
-- applies the best types of quantization for your video content. Include
-- this setting in your JSON job specification only when you choose to
-- change the default value for Adaptive quantization. For this setting,
-- 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 adaptive quantization, adjust the strength of the filter with
-- the setting Adaptive quantization (adaptiveQuantization).
--
-- 'slowPal', 'xavcSettings_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 by
-- relabeling the video frames and resampling your audio. Note that
-- enabling this setting will slightly reduce the duration of your video.
-- Related settings: You must also set Frame rate to 25. In your JSON job
-- specification, set (framerateControl) to (SPECIFIED),
-- (framerateNumerator) to 25 and (framerateDenominator) to 1.
--
-- 'xavc4kProfileSettings', 'xavcSettings_xavc4kProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_4K.
--
-- 'xavcHdIntraCbgProfileSettings', 'xavcSettings_xavcHdIntraCbgProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_HD_INTRA_CBG.
--
-- 'xavc4kIntraVbrProfileSettings', 'xavcSettings_xavc4kIntraVbrProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_VBR.
--
-- 'xavc4kIntraCbgProfileSettings', 'xavcSettings_xavc4kIntraCbgProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_CBG.
--
-- 'profile', 'xavcSettings_profile' - Specify the XAVC profile for this output. For more information, see the
-- Sony documentation at https:\/\/www.xavc-info.org\/. Note that
-- MediaConvert doesn\'t support the interlaced video XAVC operating points
-- for XAVC_HD_INTRA_CBG. To create an interlaced XAVC output, choose the
-- profile XAVC_HD.
--
-- 'softness', 'xavcSettings_softness' - Ignore this setting unless your downstream workflow requires that you
-- specify it explicitly. Otherwise, we recommend that you adjust the
-- softness of your output by using a lower value for the setting Sharpness
-- (sharpness) or by enabling a noise reducer filter (noiseReducerFilter).
-- The Softness (softness) setting specifies the quantization matrices that
-- the encoder uses. Keep the default value, 0, for flat quantization.
-- Choose the value 1 or 16 to use the default JVT softening quantization
-- matricies from the H.264 specification. Choose a value from 17 to 128 to
-- use planar interpolation. Increasing values from 17 to 128 result in
-- increasing reduction of high-frequency data. The value 128 results in
-- the softest video.
--
-- 'framerateDenominator', 'xavcSettings_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
-- Frame rate. In this example, specify 23.976.
--
-- 'framerateConversionAlgorithm', 'xavcSettings_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.
--
-- 'entropyEncoding', 'xavcSettings_entropyEncoding' - Optional. Choose a specific entropy encoding mode only when you want to
-- override XAVC recommendations. If you choose the value auto,
-- MediaConvert uses the mode that the XAVC file format specifies given
-- this output\'s operating point.
--
-- 'framerateControl', 'xavcSettings_framerateControl' - If you are using the console, use the Frame rate 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. The framerates
-- shown in the dropdown list are decimal approximations of fractions. 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 that you specify in the settings FramerateNumerator and
-- FramerateDenominator.
--
-- 'adaptiveQuantization', 'xavcSettings_adaptiveQuantization' - Keep the default value, Auto (AUTO), for this setting to have
-- MediaConvert automatically apply the best types of quantization for your
-- video content. When you want to apply your quantization settings
-- manually, you must set Adaptive quantization (adaptiveQuantization) to a
-- value other than Auto (AUTO). Use this setting to specify the strength
-- of any adaptive quantization filters that you enable. If you don\'t want
-- MediaConvert to do any adaptive quantization in this transcode, set
-- Adaptive quantization to Off (OFF). Related settings: 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', 'xavcSettings_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.
--
-- 'xavcHdProfileSettings', 'xavcSettings_xavcHdProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_HD.
--
-- 'spatialAdaptiveQuantization', 'xavcSettings_spatialAdaptiveQuantization' - The best way to set up adaptive quantization is to keep the default
-- value, Auto (AUTO), for the setting Adaptive quantization
-- (adaptiveQuantization). When you do so, MediaConvert automatically
-- applies the best types of quantization for your video content. Include
-- this setting in your JSON job specification only when you choose to
-- change the default value for Adaptive quantization. For this setting,
-- 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.
newXavcSettings ::
  XavcSettings
newXavcSettings :: XavcSettings
newXavcSettings =
  XavcSettings' :: Maybe XavcTemporalAdaptiveQuantization
-> Maybe XavcSlowPal
-> Maybe Xavc4kProfileSettings
-> Maybe XavcHdIntraCbgProfileSettings
-> Maybe Xavc4kIntraVbrProfileSettings
-> Maybe Xavc4kIntraCbgProfileSettings
-> Maybe XavcProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe XavcFramerateConversionAlgorithm
-> Maybe XavcEntropyEncoding
-> Maybe XavcFramerateControl
-> Maybe XavcAdaptiveQuantization
-> Maybe Natural
-> Maybe XavcHdProfileSettings
-> Maybe XavcSpatialAdaptiveQuantization
-> XavcSettings
XavcSettings'
    { $sel:temporalAdaptiveQuantization:XavcSettings' :: Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization =
        Maybe XavcTemporalAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:slowPal:XavcSettings' :: Maybe XavcSlowPal
slowPal = Maybe XavcSlowPal
forall a. Maybe a
Prelude.Nothing,
      $sel:xavc4kProfileSettings:XavcSettings' :: Maybe Xavc4kProfileSettings
xavc4kProfileSettings = Maybe Xavc4kProfileSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:xavcHdIntraCbgProfileSettings:XavcSettings' :: Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings = Maybe XavcHdIntraCbgProfileSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:xavc4kIntraVbrProfileSettings:XavcSettings' :: Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings = Maybe Xavc4kIntraVbrProfileSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:xavc4kIntraCbgProfileSettings:XavcSettings' :: Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings = Maybe Xavc4kIntraCbgProfileSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:profile:XavcSettings' :: Maybe XavcProfile
profile = Maybe XavcProfile
forall a. Maybe a
Prelude.Nothing,
      $sel:softness:XavcSettings' :: Maybe Natural
softness = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateDenominator:XavcSettings' :: Maybe Natural
framerateDenominator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateConversionAlgorithm:XavcSettings' :: Maybe XavcFramerateConversionAlgorithm
framerateConversionAlgorithm = Maybe XavcFramerateConversionAlgorithm
forall a. Maybe a
Prelude.Nothing,
      $sel:entropyEncoding:XavcSettings' :: Maybe XavcEntropyEncoding
entropyEncoding = Maybe XavcEntropyEncoding
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateControl:XavcSettings' :: Maybe XavcFramerateControl
framerateControl = Maybe XavcFramerateControl
forall a. Maybe a
Prelude.Nothing,
      $sel:adaptiveQuantization:XavcSettings' :: Maybe XavcAdaptiveQuantization
adaptiveQuantization = Maybe XavcAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing,
      $sel:framerateNumerator:XavcSettings' :: Maybe Natural
framerateNumerator = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:xavcHdProfileSettings:XavcSettings' :: Maybe XavcHdProfileSettings
xavcHdProfileSettings = Maybe XavcHdProfileSettings
forall a. Maybe a
Prelude.Nothing,
      $sel:spatialAdaptiveQuantization:XavcSettings' :: Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe XavcSpatialAdaptiveQuantization
forall a. Maybe a
Prelude.Nothing
    }

-- | The best way to set up adaptive quantization is to keep the default
-- value, Auto (AUTO), for the setting Adaptive quantization
-- (adaptiveQuantization). When you do so, MediaConvert automatically
-- applies the best types of quantization for your video content. Include
-- this setting in your JSON job specification only when you choose to
-- change the default value for Adaptive quantization. For this setting,
-- 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 adaptive quantization, adjust the strength of the filter with
-- the setting Adaptive quantization (adaptiveQuantization).
xavcSettings_temporalAdaptiveQuantization :: Lens.Lens' XavcSettings (Prelude.Maybe XavcTemporalAdaptiveQuantization)
xavcSettings_temporalAdaptiveQuantization :: (Maybe XavcTemporalAdaptiveQuantization
 -> f (Maybe XavcTemporalAdaptiveQuantization))
-> XavcSettings -> f XavcSettings
xavcSettings_temporalAdaptiveQuantization = (XavcSettings -> Maybe XavcTemporalAdaptiveQuantization)
-> (XavcSettings
    -> Maybe XavcTemporalAdaptiveQuantization -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe XavcTemporalAdaptiveQuantization)
     (Maybe XavcTemporalAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization :: Maybe XavcTemporalAdaptiveQuantization
$sel:temporalAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization} -> Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcTemporalAdaptiveQuantization
a -> XavcSettings
s {$sel:temporalAdaptiveQuantization:XavcSettings' :: Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization = Maybe XavcTemporalAdaptiveQuantization
a} :: XavcSettings)

-- | 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 by
-- relabeling the video frames and resampling your audio. Note that
-- enabling this setting will slightly reduce the duration of your video.
-- Related settings: You must also set Frame rate to 25. In your JSON job
-- specification, set (framerateControl) to (SPECIFIED),
-- (framerateNumerator) to 25 and (framerateDenominator) to 1.
xavcSettings_slowPal :: Lens.Lens' XavcSettings (Prelude.Maybe XavcSlowPal)
xavcSettings_slowPal :: (Maybe XavcSlowPal -> f (Maybe XavcSlowPal))
-> XavcSettings -> f XavcSettings
xavcSettings_slowPal = (XavcSettings -> Maybe XavcSlowPal)
-> (XavcSettings -> Maybe XavcSlowPal -> XavcSettings)
-> Lens
     XavcSettings XavcSettings (Maybe XavcSlowPal) (Maybe XavcSlowPal)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcSlowPal
slowPal :: Maybe XavcSlowPal
$sel:slowPal:XavcSettings' :: XavcSettings -> Maybe XavcSlowPal
slowPal} -> Maybe XavcSlowPal
slowPal) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcSlowPal
a -> XavcSettings
s {$sel:slowPal:XavcSettings' :: Maybe XavcSlowPal
slowPal = Maybe XavcSlowPal
a} :: XavcSettings)

-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_4K.
xavcSettings_xavc4kProfileSettings :: Lens.Lens' XavcSettings (Prelude.Maybe Xavc4kProfileSettings)
xavcSettings_xavc4kProfileSettings :: (Maybe Xavc4kProfileSettings -> f (Maybe Xavc4kProfileSettings))
-> XavcSettings -> f XavcSettings
xavcSettings_xavc4kProfileSettings = (XavcSettings -> Maybe Xavc4kProfileSettings)
-> (XavcSettings -> Maybe Xavc4kProfileSettings -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe Xavc4kProfileSettings)
     (Maybe Xavc4kProfileSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe Xavc4kProfileSettings
xavc4kProfileSettings :: Maybe Xavc4kProfileSettings
$sel:xavc4kProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kProfileSettings
xavc4kProfileSettings} -> Maybe Xavc4kProfileSettings
xavc4kProfileSettings) (\s :: XavcSettings
s@XavcSettings' {} Maybe Xavc4kProfileSettings
a -> XavcSettings
s {$sel:xavc4kProfileSettings:XavcSettings' :: Maybe Xavc4kProfileSettings
xavc4kProfileSettings = Maybe Xavc4kProfileSettings
a} :: XavcSettings)

-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_HD_INTRA_CBG.
xavcSettings_xavcHdIntraCbgProfileSettings :: Lens.Lens' XavcSettings (Prelude.Maybe XavcHdIntraCbgProfileSettings)
xavcSettings_xavcHdIntraCbgProfileSettings :: (Maybe XavcHdIntraCbgProfileSettings
 -> f (Maybe XavcHdIntraCbgProfileSettings))
-> XavcSettings -> f XavcSettings
xavcSettings_xavcHdIntraCbgProfileSettings = (XavcSettings -> Maybe XavcHdIntraCbgProfileSettings)
-> (XavcSettings
    -> Maybe XavcHdIntraCbgProfileSettings -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe XavcHdIntraCbgProfileSettings)
     (Maybe XavcHdIntraCbgProfileSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings :: Maybe XavcHdIntraCbgProfileSettings
$sel:xavcHdIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings} -> Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcHdIntraCbgProfileSettings
a -> XavcSettings
s {$sel:xavcHdIntraCbgProfileSettings:XavcSettings' :: Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings = Maybe XavcHdIntraCbgProfileSettings
a} :: XavcSettings)

-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_VBR.
xavcSettings_xavc4kIntraVbrProfileSettings :: Lens.Lens' XavcSettings (Prelude.Maybe Xavc4kIntraVbrProfileSettings)
xavcSettings_xavc4kIntraVbrProfileSettings :: (Maybe Xavc4kIntraVbrProfileSettings
 -> f (Maybe Xavc4kIntraVbrProfileSettings))
-> XavcSettings -> f XavcSettings
xavcSettings_xavc4kIntraVbrProfileSettings = (XavcSettings -> Maybe Xavc4kIntraVbrProfileSettings)
-> (XavcSettings
    -> Maybe Xavc4kIntraVbrProfileSettings -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe Xavc4kIntraVbrProfileSettings)
     (Maybe Xavc4kIntraVbrProfileSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings :: Maybe Xavc4kIntraVbrProfileSettings
$sel:xavc4kIntraVbrProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings} -> Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings) (\s :: XavcSettings
s@XavcSettings' {} Maybe Xavc4kIntraVbrProfileSettings
a -> XavcSettings
s {$sel:xavc4kIntraVbrProfileSettings:XavcSettings' :: Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings = Maybe Xavc4kIntraVbrProfileSettings
a} :: XavcSettings)

-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_CBG.
xavcSettings_xavc4kIntraCbgProfileSettings :: Lens.Lens' XavcSettings (Prelude.Maybe Xavc4kIntraCbgProfileSettings)
xavcSettings_xavc4kIntraCbgProfileSettings :: (Maybe Xavc4kIntraCbgProfileSettings
 -> f (Maybe Xavc4kIntraCbgProfileSettings))
-> XavcSettings -> f XavcSettings
xavcSettings_xavc4kIntraCbgProfileSettings = (XavcSettings -> Maybe Xavc4kIntraCbgProfileSettings)
-> (XavcSettings
    -> Maybe Xavc4kIntraCbgProfileSettings -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe Xavc4kIntraCbgProfileSettings)
     (Maybe Xavc4kIntraCbgProfileSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings :: Maybe Xavc4kIntraCbgProfileSettings
$sel:xavc4kIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings} -> Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings) (\s :: XavcSettings
s@XavcSettings' {} Maybe Xavc4kIntraCbgProfileSettings
a -> XavcSettings
s {$sel:xavc4kIntraCbgProfileSettings:XavcSettings' :: Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings = Maybe Xavc4kIntraCbgProfileSettings
a} :: XavcSettings)

-- | Specify the XAVC profile for this output. For more information, see the
-- Sony documentation at https:\/\/www.xavc-info.org\/. Note that
-- MediaConvert doesn\'t support the interlaced video XAVC operating points
-- for XAVC_HD_INTRA_CBG. To create an interlaced XAVC output, choose the
-- profile XAVC_HD.
xavcSettings_profile :: Lens.Lens' XavcSettings (Prelude.Maybe XavcProfile)
xavcSettings_profile :: (Maybe XavcProfile -> f (Maybe XavcProfile))
-> XavcSettings -> f XavcSettings
xavcSettings_profile = (XavcSettings -> Maybe XavcProfile)
-> (XavcSettings -> Maybe XavcProfile -> XavcSettings)
-> Lens
     XavcSettings XavcSettings (Maybe XavcProfile) (Maybe XavcProfile)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcProfile
profile :: Maybe XavcProfile
$sel:profile:XavcSettings' :: XavcSettings -> Maybe XavcProfile
profile} -> Maybe XavcProfile
profile) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcProfile
a -> XavcSettings
s {$sel:profile:XavcSettings' :: Maybe XavcProfile
profile = Maybe XavcProfile
a} :: XavcSettings)

-- | Ignore this setting unless your downstream workflow requires that you
-- specify it explicitly. Otherwise, we recommend that you adjust the
-- softness of your output by using a lower value for the setting Sharpness
-- (sharpness) or by enabling a noise reducer filter (noiseReducerFilter).
-- The Softness (softness) setting specifies the quantization matrices that
-- the encoder uses. Keep the default value, 0, for flat quantization.
-- Choose the value 1 or 16 to use the default JVT softening quantization
-- matricies from the H.264 specification. Choose a value from 17 to 128 to
-- use planar interpolation. Increasing values from 17 to 128 result in
-- increasing reduction of high-frequency data. The value 128 results in
-- the softest video.
xavcSettings_softness :: Lens.Lens' XavcSettings (Prelude.Maybe Prelude.Natural)
xavcSettings_softness :: (Maybe Natural -> f (Maybe Natural))
-> XavcSettings -> f XavcSettings
xavcSettings_softness = (XavcSettings -> Maybe Natural)
-> (XavcSettings -> Maybe Natural -> XavcSettings)
-> Lens XavcSettings XavcSettings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe Natural
softness :: Maybe Natural
$sel:softness:XavcSettings' :: XavcSettings -> Maybe Natural
softness} -> Maybe Natural
softness) (\s :: XavcSettings
s@XavcSettings' {} Maybe Natural
a -> XavcSettings
s {$sel:softness:XavcSettings' :: Maybe Natural
softness = Maybe Natural
a} :: XavcSettings)

-- | 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
-- Frame rate. In this example, specify 23.976.
xavcSettings_framerateDenominator :: Lens.Lens' XavcSettings (Prelude.Maybe Prelude.Natural)
xavcSettings_framerateDenominator :: (Maybe Natural -> f (Maybe Natural))
-> XavcSettings -> f XavcSettings
xavcSettings_framerateDenominator = (XavcSettings -> Maybe Natural)
-> (XavcSettings -> Maybe Natural -> XavcSettings)
-> Lens XavcSettings XavcSettings (Maybe Natural) (Maybe Natural)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe Natural
framerateDenominator :: Maybe Natural
$sel:framerateDenominator:XavcSettings' :: XavcSettings -> Maybe Natural
framerateDenominator} -> Maybe Natural
framerateDenominator) (\s :: XavcSettings
s@XavcSettings' {} Maybe Natural
a -> XavcSettings
s {$sel:framerateDenominator:XavcSettings' :: Maybe Natural
framerateDenominator = Maybe Natural
a} :: XavcSettings)

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

-- | Optional. Choose a specific entropy encoding mode only when you want to
-- override XAVC recommendations. If you choose the value auto,
-- MediaConvert uses the mode that the XAVC file format specifies given
-- this output\'s operating point.
xavcSettings_entropyEncoding :: Lens.Lens' XavcSettings (Prelude.Maybe XavcEntropyEncoding)
xavcSettings_entropyEncoding :: (Maybe XavcEntropyEncoding -> f (Maybe XavcEntropyEncoding))
-> XavcSettings -> f XavcSettings
xavcSettings_entropyEncoding = (XavcSettings -> Maybe XavcEntropyEncoding)
-> (XavcSettings -> Maybe XavcEntropyEncoding -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe XavcEntropyEncoding)
     (Maybe XavcEntropyEncoding)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcEntropyEncoding
entropyEncoding :: Maybe XavcEntropyEncoding
$sel:entropyEncoding:XavcSettings' :: XavcSettings -> Maybe XavcEntropyEncoding
entropyEncoding} -> Maybe XavcEntropyEncoding
entropyEncoding) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcEntropyEncoding
a -> XavcSettings
s {$sel:entropyEncoding:XavcSettings' :: Maybe XavcEntropyEncoding
entropyEncoding = Maybe XavcEntropyEncoding
a} :: XavcSettings)

-- | If you are using the console, use the Frame rate 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. The framerates
-- shown in the dropdown list are decimal approximations of fractions. 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 that you specify in the settings FramerateNumerator and
-- FramerateDenominator.
xavcSettings_framerateControl :: Lens.Lens' XavcSettings (Prelude.Maybe XavcFramerateControl)
xavcSettings_framerateControl :: (Maybe XavcFramerateControl -> f (Maybe XavcFramerateControl))
-> XavcSettings -> f XavcSettings
xavcSettings_framerateControl = (XavcSettings -> Maybe XavcFramerateControl)
-> (XavcSettings -> Maybe XavcFramerateControl -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe XavcFramerateControl)
     (Maybe XavcFramerateControl)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcFramerateControl
framerateControl :: Maybe XavcFramerateControl
$sel:framerateControl:XavcSettings' :: XavcSettings -> Maybe XavcFramerateControl
framerateControl} -> Maybe XavcFramerateControl
framerateControl) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcFramerateControl
a -> XavcSettings
s {$sel:framerateControl:XavcSettings' :: Maybe XavcFramerateControl
framerateControl = Maybe XavcFramerateControl
a} :: XavcSettings)

-- | Keep the default value, Auto (AUTO), for this setting to have
-- MediaConvert automatically apply the best types of quantization for your
-- video content. When you want to apply your quantization settings
-- manually, you must set Adaptive quantization (adaptiveQuantization) to a
-- value other than Auto (AUTO). Use this setting to specify the strength
-- of any adaptive quantization filters that you enable. If you don\'t want
-- MediaConvert to do any adaptive quantization in this transcode, set
-- Adaptive quantization to Off (OFF). Related settings: The value that you
-- choose here applies to the following settings: Flicker adaptive
-- quantization (flickerAdaptiveQuantization), Spatial adaptive
-- quantization (spatialAdaptiveQuantization), and Temporal adaptive
-- quantization (temporalAdaptiveQuantization).
xavcSettings_adaptiveQuantization :: Lens.Lens' XavcSettings (Prelude.Maybe XavcAdaptiveQuantization)
xavcSettings_adaptiveQuantization :: (Maybe XavcAdaptiveQuantization
 -> f (Maybe XavcAdaptiveQuantization))
-> XavcSettings -> f XavcSettings
xavcSettings_adaptiveQuantization = (XavcSettings -> Maybe XavcAdaptiveQuantization)
-> (XavcSettings -> Maybe XavcAdaptiveQuantization -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe XavcAdaptiveQuantization)
     (Maybe XavcAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcAdaptiveQuantization
adaptiveQuantization :: Maybe XavcAdaptiveQuantization
$sel:adaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcAdaptiveQuantization
adaptiveQuantization} -> Maybe XavcAdaptiveQuantization
adaptiveQuantization) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcAdaptiveQuantization
a -> XavcSettings
s {$sel:adaptiveQuantization:XavcSettings' :: Maybe XavcAdaptiveQuantization
adaptiveQuantization = Maybe XavcAdaptiveQuantization
a} :: XavcSettings)

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

-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_HD.
xavcSettings_xavcHdProfileSettings :: Lens.Lens' XavcSettings (Prelude.Maybe XavcHdProfileSettings)
xavcSettings_xavcHdProfileSettings :: (Maybe XavcHdProfileSettings -> f (Maybe XavcHdProfileSettings))
-> XavcSettings -> f XavcSettings
xavcSettings_xavcHdProfileSettings = (XavcSettings -> Maybe XavcHdProfileSettings)
-> (XavcSettings -> Maybe XavcHdProfileSettings -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe XavcHdProfileSettings)
     (Maybe XavcHdProfileSettings)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcHdProfileSettings
xavcHdProfileSettings :: Maybe XavcHdProfileSettings
$sel:xavcHdProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdProfileSettings
xavcHdProfileSettings} -> Maybe XavcHdProfileSettings
xavcHdProfileSettings) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcHdProfileSettings
a -> XavcSettings
s {$sel:xavcHdProfileSettings:XavcSettings' :: Maybe XavcHdProfileSettings
xavcHdProfileSettings = Maybe XavcHdProfileSettings
a} :: XavcSettings)

-- | The best way to set up adaptive quantization is to keep the default
-- value, Auto (AUTO), for the setting Adaptive quantization
-- (adaptiveQuantization). When you do so, MediaConvert automatically
-- applies the best types of quantization for your video content. Include
-- this setting in your JSON job specification only when you choose to
-- change the default value for Adaptive quantization. For this setting,
-- 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.
xavcSettings_spatialAdaptiveQuantization :: Lens.Lens' XavcSettings (Prelude.Maybe XavcSpatialAdaptiveQuantization)
xavcSettings_spatialAdaptiveQuantization :: (Maybe XavcSpatialAdaptiveQuantization
 -> f (Maybe XavcSpatialAdaptiveQuantization))
-> XavcSettings -> f XavcSettings
xavcSettings_spatialAdaptiveQuantization = (XavcSettings -> Maybe XavcSpatialAdaptiveQuantization)
-> (XavcSettings
    -> Maybe XavcSpatialAdaptiveQuantization -> XavcSettings)
-> Lens
     XavcSettings
     XavcSettings
     (Maybe XavcSpatialAdaptiveQuantization)
     (Maybe XavcSpatialAdaptiveQuantization)
forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\XavcSettings' {Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe XavcSpatialAdaptiveQuantization
$sel:spatialAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization} -> Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization) (\s :: XavcSettings
s@XavcSettings' {} Maybe XavcSpatialAdaptiveQuantization
a -> XavcSettings
s {$sel:spatialAdaptiveQuantization:XavcSettings' :: Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization = Maybe XavcSpatialAdaptiveQuantization
a} :: XavcSettings)

instance Core.FromJSON XavcSettings where
  parseJSON :: Value -> Parser XavcSettings
parseJSON =
    String
-> (Object -> Parser XavcSettings) -> Value -> Parser XavcSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"XavcSettings"
      ( \Object
x ->
          Maybe XavcTemporalAdaptiveQuantization
-> Maybe XavcSlowPal
-> Maybe Xavc4kProfileSettings
-> Maybe XavcHdIntraCbgProfileSettings
-> Maybe Xavc4kIntraVbrProfileSettings
-> Maybe Xavc4kIntraCbgProfileSettings
-> Maybe XavcProfile
-> Maybe Natural
-> Maybe Natural
-> Maybe XavcFramerateConversionAlgorithm
-> Maybe XavcEntropyEncoding
-> Maybe XavcFramerateControl
-> Maybe XavcAdaptiveQuantization
-> Maybe Natural
-> Maybe XavcHdProfileSettings
-> Maybe XavcSpatialAdaptiveQuantization
-> XavcSettings
XavcSettings'
            (Maybe XavcTemporalAdaptiveQuantization
 -> Maybe XavcSlowPal
 -> Maybe Xavc4kProfileSettings
 -> Maybe XavcHdIntraCbgProfileSettings
 -> Maybe Xavc4kIntraVbrProfileSettings
 -> Maybe Xavc4kIntraCbgProfileSettings
 -> Maybe XavcProfile
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe XavcFramerateConversionAlgorithm
 -> Maybe XavcEntropyEncoding
 -> Maybe XavcFramerateControl
 -> Maybe XavcAdaptiveQuantization
 -> Maybe Natural
 -> Maybe XavcHdProfileSettings
 -> Maybe XavcSpatialAdaptiveQuantization
 -> XavcSettings)
-> Parser (Maybe XavcTemporalAdaptiveQuantization)
-> Parser
     (Maybe XavcSlowPal
      -> Maybe Xavc4kProfileSettings
      -> Maybe XavcHdIntraCbgProfileSettings
      -> Maybe Xavc4kIntraVbrProfileSettings
      -> Maybe Xavc4kIntraCbgProfileSettings
      -> Maybe XavcProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe XavcTemporalAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"temporalAdaptiveQuantization")
            Parser
  (Maybe XavcSlowPal
   -> Maybe Xavc4kProfileSettings
   -> Maybe XavcHdIntraCbgProfileSettings
   -> Maybe Xavc4kIntraVbrProfileSettings
   -> Maybe Xavc4kIntraCbgProfileSettings
   -> Maybe XavcProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe XavcSlowPal)
-> Parser
     (Maybe Xavc4kProfileSettings
      -> Maybe XavcHdIntraCbgProfileSettings
      -> Maybe Xavc4kIntraVbrProfileSettings
      -> Maybe Xavc4kIntraCbgProfileSettings
      -> Maybe XavcProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcSlowPal)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"slowPal")
            Parser
  (Maybe Xavc4kProfileSettings
   -> Maybe XavcHdIntraCbgProfileSettings
   -> Maybe Xavc4kIntraVbrProfileSettings
   -> Maybe Xavc4kIntraCbgProfileSettings
   -> Maybe XavcProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe Xavc4kProfileSettings)
-> Parser
     (Maybe XavcHdIntraCbgProfileSettings
      -> Maybe Xavc4kIntraVbrProfileSettings
      -> Maybe Xavc4kIntraCbgProfileSettings
      -> Maybe XavcProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Xavc4kProfileSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"xavc4kProfileSettings")
            Parser
  (Maybe XavcHdIntraCbgProfileSettings
   -> Maybe Xavc4kIntraVbrProfileSettings
   -> Maybe Xavc4kIntraCbgProfileSettings
   -> Maybe XavcProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe XavcHdIntraCbgProfileSettings)
-> Parser
     (Maybe Xavc4kIntraVbrProfileSettings
      -> Maybe Xavc4kIntraCbgProfileSettings
      -> Maybe XavcProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcHdIntraCbgProfileSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"xavcHdIntraCbgProfileSettings")
            Parser
  (Maybe Xavc4kIntraVbrProfileSettings
   -> Maybe Xavc4kIntraCbgProfileSettings
   -> Maybe XavcProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe Xavc4kIntraVbrProfileSettings)
-> Parser
     (Maybe Xavc4kIntraCbgProfileSettings
      -> Maybe XavcProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Xavc4kIntraVbrProfileSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"xavc4kIntraVbrProfileSettings")
            Parser
  (Maybe Xavc4kIntraCbgProfileSettings
   -> Maybe XavcProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe Xavc4kIntraCbgProfileSettings)
-> Parser
     (Maybe XavcProfile
      -> Maybe Natural
      -> Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Xavc4kIntraCbgProfileSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"xavc4kIntraCbgProfileSettings")
            Parser
  (Maybe XavcProfile
   -> Maybe Natural
   -> Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe XavcProfile)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcProfile)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"profile")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural
      -> Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"softness")
            Parser
  (Maybe Natural
   -> Maybe XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe XavcFramerateConversionAlgorithm
      -> Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
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 XavcFramerateConversionAlgorithm
   -> Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe XavcFramerateConversionAlgorithm)
-> Parser
     (Maybe XavcEntropyEncoding
      -> Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcFramerateConversionAlgorithm)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateConversionAlgorithm")
            Parser
  (Maybe XavcEntropyEncoding
   -> Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe XavcEntropyEncoding)
-> Parser
     (Maybe XavcFramerateControl
      -> Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcEntropyEncoding)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"entropyEncoding")
            Parser
  (Maybe XavcFramerateControl
   -> Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe XavcFramerateControl)
-> Parser
     (Maybe XavcAdaptiveQuantization
      -> Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcFramerateControl)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"framerateControl")
            Parser
  (Maybe XavcAdaptiveQuantization
   -> Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe XavcAdaptiveQuantization)
-> Parser
     (Maybe Natural
      -> Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization
      -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"adaptiveQuantization")
            Parser
  (Maybe Natural
   -> Maybe XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization
   -> XavcSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe XavcHdProfileSettings
      -> Maybe XavcSpatialAdaptiveQuantization -> XavcSettings)
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 XavcHdProfileSettings
   -> Maybe XavcSpatialAdaptiveQuantization -> XavcSettings)
-> Parser (Maybe XavcHdProfileSettings)
-> Parser (Maybe XavcSpatialAdaptiveQuantization -> XavcSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcHdProfileSettings)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"xavcHdProfileSettings")
            Parser (Maybe XavcSpatialAdaptiveQuantization -> XavcSettings)
-> Parser (Maybe XavcSpatialAdaptiveQuantization)
-> Parser XavcSettings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe XavcSpatialAdaptiveQuantization)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"spatialAdaptiveQuantization")
      )

instance Prelude.Hashable XavcSettings

instance Prelude.NFData XavcSettings

instance Core.ToJSON XavcSettings where
  toJSON :: XavcSettings -> Value
toJSON XavcSettings' {Maybe Natural
Maybe Xavc4kIntraCbgProfileSettings
Maybe Xavc4kIntraVbrProfileSettings
Maybe XavcAdaptiveQuantization
Maybe XavcEntropyEncoding
Maybe XavcFramerateControl
Maybe XavcFramerateConversionAlgorithm
Maybe Xavc4kProfileSettings
Maybe XavcHdIntraCbgProfileSettings
Maybe XavcHdProfileSettings
Maybe XavcProfile
Maybe XavcSlowPal
Maybe XavcSpatialAdaptiveQuantization
Maybe XavcTemporalAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe XavcSpatialAdaptiveQuantization
xavcHdProfileSettings :: Maybe XavcHdProfileSettings
framerateNumerator :: Maybe Natural
adaptiveQuantization :: Maybe XavcAdaptiveQuantization
framerateControl :: Maybe XavcFramerateControl
entropyEncoding :: Maybe XavcEntropyEncoding
framerateConversionAlgorithm :: Maybe XavcFramerateConversionAlgorithm
framerateDenominator :: Maybe Natural
softness :: Maybe Natural
profile :: Maybe XavcProfile
xavc4kIntraCbgProfileSettings :: Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraVbrProfileSettings :: Maybe Xavc4kIntraVbrProfileSettings
xavcHdIntraCbgProfileSettings :: Maybe XavcHdIntraCbgProfileSettings
xavc4kProfileSettings :: Maybe Xavc4kProfileSettings
slowPal :: Maybe XavcSlowPal
temporalAdaptiveQuantization :: Maybe XavcTemporalAdaptiveQuantization
$sel:spatialAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcSpatialAdaptiveQuantization
$sel:xavcHdProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdProfileSettings
$sel:framerateNumerator:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:adaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcAdaptiveQuantization
$sel:framerateControl:XavcSettings' :: XavcSettings -> Maybe XavcFramerateControl
$sel:entropyEncoding:XavcSettings' :: XavcSettings -> Maybe XavcEntropyEncoding
$sel:framerateConversionAlgorithm:XavcSettings' :: XavcSettings -> Maybe XavcFramerateConversionAlgorithm
$sel:framerateDenominator:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:softness:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:profile:XavcSettings' :: XavcSettings -> Maybe XavcProfile
$sel:xavc4kIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraCbgProfileSettings
$sel:xavc4kIntraVbrProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraVbrProfileSettings
$sel:xavcHdIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdIntraCbgProfileSettings
$sel:xavc4kProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kProfileSettings
$sel:slowPal:XavcSettings' :: XavcSettings -> Maybe XavcSlowPal
$sel:temporalAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcTemporalAdaptiveQuantization
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"temporalAdaptiveQuantization" Text -> XavcTemporalAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcTemporalAdaptiveQuantization -> Pair)
-> Maybe XavcTemporalAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization,
            (Text
"slowPal" Text -> XavcSlowPal -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (XavcSlowPal -> Pair) -> Maybe XavcSlowPal -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcSlowPal
slowPal,
            (Text
"xavc4kProfileSettings" Text -> Xavc4kProfileSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Xavc4kProfileSettings -> Pair)
-> Maybe Xavc4kProfileSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Xavc4kProfileSettings
xavc4kProfileSettings,
            (Text
"xavcHdIntraCbgProfileSettings" Text -> XavcHdIntraCbgProfileSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcHdIntraCbgProfileSettings -> Pair)
-> Maybe XavcHdIntraCbgProfileSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings,
            (Text
"xavc4kIntraVbrProfileSettings" Text -> Xavc4kIntraVbrProfileSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Xavc4kIntraVbrProfileSettings -> Pair)
-> Maybe Xavc4kIntraVbrProfileSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings,
            (Text
"xavc4kIntraCbgProfileSettings" Text -> Xavc4kIntraCbgProfileSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Xavc4kIntraCbgProfileSettings -> Pair)
-> Maybe Xavc4kIntraCbgProfileSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings,
            (Text
"profile" Text -> XavcProfile -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (XavcProfile -> Pair) -> Maybe XavcProfile -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcProfile
profile,
            (Text
"softness" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
softness,
            (Text
"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 -> XavcFramerateConversionAlgorithm -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcFramerateConversionAlgorithm -> Pair)
-> Maybe XavcFramerateConversionAlgorithm -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcFramerateConversionAlgorithm
framerateConversionAlgorithm,
            (Text
"entropyEncoding" Text -> XavcEntropyEncoding -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcEntropyEncoding -> Pair)
-> Maybe XavcEntropyEncoding -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcEntropyEncoding
entropyEncoding,
            (Text
"framerateControl" Text -> XavcFramerateControl -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcFramerateControl -> Pair)
-> Maybe XavcFramerateControl -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcFramerateControl
framerateControl,
            (Text
"adaptiveQuantization" Text -> XavcAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcAdaptiveQuantization -> Pair)
-> Maybe XavcAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcAdaptiveQuantization
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
"xavcHdProfileSettings" Text -> XavcHdProfileSettings -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcHdProfileSettings -> Pair)
-> Maybe XavcHdProfileSettings -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcHdProfileSettings
xavcHdProfileSettings,
            (Text
"spatialAdaptiveQuantization" Text -> XavcSpatialAdaptiveQuantization -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (XavcSpatialAdaptiveQuantization -> Pair)
-> Maybe XavcSpatialAdaptiveQuantization -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization
          ]
      )