{-# 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-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.MediaConvert.Types.XavcSettings where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
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'
  { -- | 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,
    -- | 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,
    -- | 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,
    -- | 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,
    -- | 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,
    -- | 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 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,
    -- | 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,
    -- | 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,
    -- | 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,
    -- | Required when you set (Profile) under
    -- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
    -- XAVC_4K_INTRA_CBG.
    XavcSettings -> Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings :: Prelude.Maybe Xavc4kIntraCbgProfileSettings,
    -- | 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.
    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_HD.
    XavcSettings -> Maybe XavcHdProfileSettings
xavcHdProfileSettings :: Prelude.Maybe XavcHdProfileSettings
  }
  deriving (XavcSettings -> XavcSettings -> Bool
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]
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
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. 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:
--
-- '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).
--
-- '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.
--
-- '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.
--
-- '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.
--
-- '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.
--
-- '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.
--
-- '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.
--
-- '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.
--
-- '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.
--
-- '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).
--
-- 'xavc4kIntraCbgProfileSettings', 'xavcSettings_xavc4kIntraCbgProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_CBG.
--
-- 'xavc4kIntraVbrProfileSettings', 'xavcSettings_xavc4kIntraVbrProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_VBR.
--
-- '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.
--
-- 'xavcHdProfileSettings', 'xavcSettings_xavcHdProfileSettings' - Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_HD.
newXavcSettings ::
  XavcSettings
newXavcSettings :: XavcSettings
newXavcSettings =
  XavcSettings'
    { $sel:adaptiveQuantization:XavcSettings' :: Maybe XavcAdaptiveQuantization
adaptiveQuantization =
        forall a. Maybe a
Prelude.Nothing,
      $sel:entropyEncoding:XavcSettings' :: Maybe XavcEntropyEncoding
entropyEncoding = forall a. Maybe a
Prelude.Nothing,
      $sel:framerateControl:XavcSettings' :: Maybe XavcFramerateControl
framerateControl = forall a. Maybe a
Prelude.Nothing,
      $sel:framerateConversionAlgorithm:XavcSettings' :: Maybe XavcFramerateConversionAlgorithm
framerateConversionAlgorithm = forall a. Maybe a
Prelude.Nothing,
      $sel:framerateDenominator:XavcSettings' :: Maybe Natural
framerateDenominator = forall a. Maybe a
Prelude.Nothing,
      $sel:framerateNumerator:XavcSettings' :: Maybe Natural
framerateNumerator = forall a. Maybe a
Prelude.Nothing,
      $sel:profile:XavcSettings' :: Maybe XavcProfile
profile = forall a. Maybe a
Prelude.Nothing,
      $sel:slowPal:XavcSettings' :: Maybe XavcSlowPal
slowPal = forall a. Maybe a
Prelude.Nothing,
      $sel:softness:XavcSettings' :: Maybe Natural
softness = forall a. Maybe a
Prelude.Nothing,
      $sel:spatialAdaptiveQuantization:XavcSettings' :: Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization = forall a. Maybe a
Prelude.Nothing,
      $sel:temporalAdaptiveQuantization:XavcSettings' :: Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization = forall a. Maybe a
Prelude.Nothing,
      $sel:xavc4kIntraCbgProfileSettings:XavcSettings' :: Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:xavc4kIntraVbrProfileSettings:XavcSettings' :: Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:xavc4kProfileSettings:XavcSettings' :: Maybe Xavc4kProfileSettings
xavc4kProfileSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:xavcHdIntraCbgProfileSettings:XavcSettings' :: Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings = forall a. Maybe a
Prelude.Nothing,
      $sel:xavcHdProfileSettings:XavcSettings' :: Maybe XavcHdProfileSettings
xavcHdProfileSettings = forall a. Maybe a
Prelude.Nothing
    }

-- | 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 :: Lens' XavcSettings (Maybe XavcAdaptiveQuantization)
xavcSettings_adaptiveQuantization = 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)

-- | 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 :: Lens' XavcSettings (Maybe XavcEntropyEncoding)
xavcSettings_entropyEncoding = 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 :: Lens' XavcSettings (Maybe XavcFramerateControl)
xavcSettings_framerateControl = 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)

-- | 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 :: Lens' XavcSettings (Maybe XavcFramerateConversionAlgorithm)
xavcSettings_framerateConversionAlgorithm = 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)

-- | 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 :: Lens' XavcSettings (Maybe Natural)
xavcSettings_framerateDenominator = 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)

-- | 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 :: Lens' XavcSettings (Maybe Natural)
xavcSettings_framerateNumerator = 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)

-- | 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 :: Lens' XavcSettings (Maybe XavcProfile)
xavcSettings_profile = 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 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 :: Lens' XavcSettings (Maybe XavcSlowPal)
xavcSettings_slowPal = 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)

-- | 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 :: Lens' XavcSettings (Maybe Natural)
xavcSettings_softness = 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)

-- | 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 :: Lens' XavcSettings (Maybe XavcSpatialAdaptiveQuantization)
xavcSettings_spatialAdaptiveQuantization = 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)

-- | 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 :: Lens' XavcSettings (Maybe XavcTemporalAdaptiveQuantization)
xavcSettings_temporalAdaptiveQuantization = 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)

-- | 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 :: Lens' XavcSettings (Maybe Xavc4kIntraCbgProfileSettings)
xavcSettings_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)

-- | 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 :: Lens' XavcSettings (Maybe Xavc4kIntraVbrProfileSettings)
xavcSettings_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.
xavcSettings_xavc4kProfileSettings :: Lens.Lens' XavcSettings (Prelude.Maybe Xavc4kProfileSettings)
xavcSettings_xavc4kProfileSettings :: Lens' XavcSettings (Maybe Xavc4kProfileSettings)
xavcSettings_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 :: Lens' XavcSettings (Maybe XavcHdIntraCbgProfileSettings)
xavcSettings_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_HD.
xavcSettings_xavcHdProfileSettings :: Lens.Lens' XavcSettings (Prelude.Maybe XavcHdProfileSettings)
xavcSettings_xavcHdProfileSettings :: Lens' XavcSettings (Maybe XavcHdProfileSettings)
xavcSettings_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)

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

instance Prelude.Hashable XavcSettings where
  hashWithSalt :: Int -> XavcSettings -> Int
hashWithSalt Int
_salt 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
xavcHdProfileSettings :: Maybe XavcHdProfileSettings
xavcHdIntraCbgProfileSettings :: Maybe XavcHdIntraCbgProfileSettings
xavc4kProfileSettings :: Maybe Xavc4kProfileSettings
xavc4kIntraVbrProfileSettings :: Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraCbgProfileSettings :: Maybe Xavc4kIntraCbgProfileSettings
temporalAdaptiveQuantization :: Maybe XavcTemporalAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe XavcSpatialAdaptiveQuantization
softness :: Maybe Natural
slowPal :: Maybe XavcSlowPal
profile :: Maybe XavcProfile
framerateNumerator :: Maybe Natural
framerateDenominator :: Maybe Natural
framerateConversionAlgorithm :: Maybe XavcFramerateConversionAlgorithm
framerateControl :: Maybe XavcFramerateControl
entropyEncoding :: Maybe XavcEntropyEncoding
adaptiveQuantization :: Maybe XavcAdaptiveQuantization
$sel:xavcHdProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdProfileSettings
$sel:xavcHdIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdIntraCbgProfileSettings
$sel:xavc4kProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kProfileSettings
$sel:xavc4kIntraVbrProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraVbrProfileSettings
$sel:xavc4kIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraCbgProfileSettings
$sel:temporalAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcTemporalAdaptiveQuantization
$sel:spatialAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcSpatialAdaptiveQuantization
$sel:softness:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:slowPal:XavcSettings' :: XavcSettings -> Maybe XavcSlowPal
$sel:profile:XavcSettings' :: XavcSettings -> Maybe XavcProfile
$sel:framerateNumerator:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:framerateDenominator:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:framerateConversionAlgorithm:XavcSettings' :: XavcSettings -> Maybe XavcFramerateConversionAlgorithm
$sel:framerateControl:XavcSettings' :: XavcSettings -> Maybe XavcFramerateControl
$sel:entropyEncoding:XavcSettings' :: XavcSettings -> Maybe XavcEntropyEncoding
$sel:adaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcAdaptiveQuantization
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcAdaptiveQuantization
adaptiveQuantization
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcEntropyEncoding
entropyEncoding
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcFramerateControl
framerateControl
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcFramerateConversionAlgorithm
framerateConversionAlgorithm
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
framerateDenominator
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
framerateNumerator
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcProfile
profile
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcSlowPal
slowPal
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
softness
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Xavc4kProfileSettings
xavc4kProfileSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XavcHdProfileSettings
xavcHdProfileSettings

instance Prelude.NFData XavcSettings where
  rnf :: XavcSettings -> ()
rnf 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
xavcHdProfileSettings :: Maybe XavcHdProfileSettings
xavcHdIntraCbgProfileSettings :: Maybe XavcHdIntraCbgProfileSettings
xavc4kProfileSettings :: Maybe Xavc4kProfileSettings
xavc4kIntraVbrProfileSettings :: Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraCbgProfileSettings :: Maybe Xavc4kIntraCbgProfileSettings
temporalAdaptiveQuantization :: Maybe XavcTemporalAdaptiveQuantization
spatialAdaptiveQuantization :: Maybe XavcSpatialAdaptiveQuantization
softness :: Maybe Natural
slowPal :: Maybe XavcSlowPal
profile :: Maybe XavcProfile
framerateNumerator :: Maybe Natural
framerateDenominator :: Maybe Natural
framerateConversionAlgorithm :: Maybe XavcFramerateConversionAlgorithm
framerateControl :: Maybe XavcFramerateControl
entropyEncoding :: Maybe XavcEntropyEncoding
adaptiveQuantization :: Maybe XavcAdaptiveQuantization
$sel:xavcHdProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdProfileSettings
$sel:xavcHdIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe XavcHdIntraCbgProfileSettings
$sel:xavc4kProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kProfileSettings
$sel:xavc4kIntraVbrProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraVbrProfileSettings
$sel:xavc4kIntraCbgProfileSettings:XavcSettings' :: XavcSettings -> Maybe Xavc4kIntraCbgProfileSettings
$sel:temporalAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcTemporalAdaptiveQuantization
$sel:spatialAdaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcSpatialAdaptiveQuantization
$sel:softness:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:slowPal:XavcSettings' :: XavcSettings -> Maybe XavcSlowPal
$sel:profile:XavcSettings' :: XavcSettings -> Maybe XavcProfile
$sel:framerateNumerator:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:framerateDenominator:XavcSettings' :: XavcSettings -> Maybe Natural
$sel:framerateConversionAlgorithm:XavcSettings' :: XavcSettings -> Maybe XavcFramerateConversionAlgorithm
$sel:framerateControl:XavcSettings' :: XavcSettings -> Maybe XavcFramerateControl
$sel:entropyEncoding:XavcSettings' :: XavcSettings -> Maybe XavcEntropyEncoding
$sel:adaptiveQuantization:XavcSettings' :: XavcSettings -> Maybe XavcAdaptiveQuantization
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcAdaptiveQuantization
adaptiveQuantization
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcEntropyEncoding
entropyEncoding
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcFramerateControl
framerateControl
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcFramerateConversionAlgorithm
framerateConversionAlgorithm
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
framerateDenominator
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
framerateNumerator
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcProfile
profile
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcSlowPal
slowPal
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
softness
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcSpatialAdaptiveQuantization
spatialAdaptiveQuantization
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcTemporalAdaptiveQuantization
temporalAdaptiveQuantization
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Xavc4kIntraCbgProfileSettings
xavc4kIntraCbgProfileSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Xavc4kIntraVbrProfileSettings
xavc4kIntraVbrProfileSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Xavc4kProfileSettings
xavc4kProfileSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf
        Maybe XavcHdIntraCbgProfileSettings
xavcHdIntraCbgProfileSettings
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XavcHdProfileSettings
xavcHdProfileSettings

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