amazonka-mediaconvert-2.0: gen/Amazonka/MediaConvert/Types/XavcSettings.hs
{-# 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).
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.
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.
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.
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.
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.
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.
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.
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.
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.
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).
temporalAdaptiveQuantization :: Prelude.Maybe XavcTemporalAdaptiveQuantization,
-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_CBG.
xavc4kIntraCbgProfileSettings :: Prelude.Maybe Xavc4kIntraCbgProfileSettings,
-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_4K_INTRA_VBR.
xavc4kIntraVbrProfileSettings :: Prelude.Maybe Xavc4kIntraVbrProfileSettings,
-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_4K.
xavc4kProfileSettings :: Prelude.Maybe Xavc4kProfileSettings,
-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value
-- XAVC_HD_INTRA_CBG.
xavcHdIntraCbgProfileSettings :: Prelude.Maybe XavcHdIntraCbgProfileSettings,
-- | Required when you set (Profile) under
-- (VideoDescription)>(CodecSettings)>(XavcSettings) to the value XAVC_HD.
xavcHdProfileSettings :: Prelude.Maybe XavcHdProfileSettings
}
deriving (Prelude.Eq, Prelude.Read, Prelude.Show, 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'
{ adaptiveQuantization =
Prelude.Nothing,
entropyEncoding = Prelude.Nothing,
framerateControl = Prelude.Nothing,
framerateConversionAlgorithm = Prelude.Nothing,
framerateDenominator = Prelude.Nothing,
framerateNumerator = Prelude.Nothing,
profile = Prelude.Nothing,
slowPal = Prelude.Nothing,
softness = Prelude.Nothing,
spatialAdaptiveQuantization = Prelude.Nothing,
temporalAdaptiveQuantization = Prelude.Nothing,
xavc4kIntraCbgProfileSettings = Prelude.Nothing,
xavc4kIntraVbrProfileSettings = Prelude.Nothing,
xavc4kProfileSettings = Prelude.Nothing,
xavcHdIntraCbgProfileSettings = Prelude.Nothing,
xavcHdProfileSettings = 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.lens (\XavcSettings' {adaptiveQuantization} -> adaptiveQuantization) (\s@XavcSettings' {} a -> s {adaptiveQuantization = 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.lens (\XavcSettings' {entropyEncoding} -> entropyEncoding) (\s@XavcSettings' {} a -> s {entropyEncoding = 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.lens (\XavcSettings' {framerateControl} -> framerateControl) (\s@XavcSettings' {} a -> s {framerateControl = 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.lens (\XavcSettings' {framerateConversionAlgorithm} -> framerateConversionAlgorithm) (\s@XavcSettings' {} a -> s {framerateConversionAlgorithm = 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.lens (\XavcSettings' {framerateDenominator} -> framerateDenominator) (\s@XavcSettings' {} a -> s {framerateDenominator = 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.lens (\XavcSettings' {framerateNumerator} -> framerateNumerator) (\s@XavcSettings' {} a -> s {framerateNumerator = 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.lens (\XavcSettings' {profile} -> profile) (\s@XavcSettings' {} a -> s {profile = 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.lens (\XavcSettings' {slowPal} -> slowPal) (\s@XavcSettings' {} a -> s {slowPal = 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.lens (\XavcSettings' {softness} -> softness) (\s@XavcSettings' {} a -> s {softness = 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.lens (\XavcSettings' {spatialAdaptiveQuantization} -> spatialAdaptiveQuantization) (\s@XavcSettings' {} a -> s {spatialAdaptiveQuantization = 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.lens (\XavcSettings' {temporalAdaptiveQuantization} -> temporalAdaptiveQuantization) (\s@XavcSettings' {} a -> s {temporalAdaptiveQuantization = 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.lens (\XavcSettings' {xavc4kIntraCbgProfileSettings} -> xavc4kIntraCbgProfileSettings) (\s@XavcSettings' {} a -> s {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.lens (\XavcSettings' {xavc4kIntraVbrProfileSettings} -> xavc4kIntraVbrProfileSettings) (\s@XavcSettings' {} a -> s {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.lens (\XavcSettings' {xavc4kProfileSettings} -> xavc4kProfileSettings) (\s@XavcSettings' {} a -> s {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.lens (\XavcSettings' {xavcHdIntraCbgProfileSettings} -> xavcHdIntraCbgProfileSettings) (\s@XavcSettings' {} a -> s {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.lens (\XavcSettings' {xavcHdProfileSettings} -> xavcHdProfileSettings) (\s@XavcSettings' {} a -> s {xavcHdProfileSettings = a} :: XavcSettings)
instance Data.FromJSON XavcSettings where
parseJSON =
Data.withObject
"XavcSettings"
( \x ->
XavcSettings'
Prelude.<$> (x Data..:? "adaptiveQuantization")
Prelude.<*> (x Data..:? "entropyEncoding")
Prelude.<*> (x Data..:? "framerateControl")
Prelude.<*> (x Data..:? "framerateConversionAlgorithm")
Prelude.<*> (x Data..:? "framerateDenominator")
Prelude.<*> (x Data..:? "framerateNumerator")
Prelude.<*> (x Data..:? "profile")
Prelude.<*> (x Data..:? "slowPal")
Prelude.<*> (x Data..:? "softness")
Prelude.<*> (x Data..:? "spatialAdaptiveQuantization")
Prelude.<*> (x Data..:? "temporalAdaptiveQuantization")
Prelude.<*> (x Data..:? "xavc4kIntraCbgProfileSettings")
Prelude.<*> (x Data..:? "xavc4kIntraVbrProfileSettings")
Prelude.<*> (x Data..:? "xavc4kProfileSettings")
Prelude.<*> (x Data..:? "xavcHdIntraCbgProfileSettings")
Prelude.<*> (x Data..:? "xavcHdProfileSettings")
)
instance Prelude.Hashable XavcSettings where
hashWithSalt _salt XavcSettings' {..} =
_salt
`Prelude.hashWithSalt` adaptiveQuantization
`Prelude.hashWithSalt` entropyEncoding
`Prelude.hashWithSalt` framerateControl
`Prelude.hashWithSalt` framerateConversionAlgorithm
`Prelude.hashWithSalt` framerateDenominator
`Prelude.hashWithSalt` framerateNumerator
`Prelude.hashWithSalt` profile
`Prelude.hashWithSalt` slowPal
`Prelude.hashWithSalt` softness
`Prelude.hashWithSalt` spatialAdaptiveQuantization
`Prelude.hashWithSalt` temporalAdaptiveQuantization
`Prelude.hashWithSalt` xavc4kIntraCbgProfileSettings
`Prelude.hashWithSalt` xavc4kIntraVbrProfileSettings
`Prelude.hashWithSalt` xavc4kProfileSettings
`Prelude.hashWithSalt` xavcHdIntraCbgProfileSettings
`Prelude.hashWithSalt` xavcHdProfileSettings
instance Prelude.NFData XavcSettings where
rnf XavcSettings' {..} =
Prelude.rnf adaptiveQuantization
`Prelude.seq` Prelude.rnf entropyEncoding
`Prelude.seq` Prelude.rnf framerateControl
`Prelude.seq` Prelude.rnf framerateConversionAlgorithm
`Prelude.seq` Prelude.rnf framerateDenominator
`Prelude.seq` Prelude.rnf framerateNumerator
`Prelude.seq` Prelude.rnf profile
`Prelude.seq` Prelude.rnf slowPal
`Prelude.seq` Prelude.rnf softness
`Prelude.seq` Prelude.rnf spatialAdaptiveQuantization
`Prelude.seq` Prelude.rnf temporalAdaptiveQuantization
`Prelude.seq` Prelude.rnf xavc4kIntraCbgProfileSettings
`Prelude.seq` Prelude.rnf xavc4kIntraVbrProfileSettings
`Prelude.seq` Prelude.rnf xavc4kProfileSettings
`Prelude.seq` Prelude.rnf
xavcHdIntraCbgProfileSettings
`Prelude.seq` Prelude.rnf xavcHdProfileSettings
instance Data.ToJSON XavcSettings where
toJSON XavcSettings' {..} =
Data.object
( Prelude.catMaybes
[ ("adaptiveQuantization" Data..=)
Prelude.<$> adaptiveQuantization,
("entropyEncoding" Data..=)
Prelude.<$> entropyEncoding,
("framerateControl" Data..=)
Prelude.<$> framerateControl,
("framerateConversionAlgorithm" Data..=)
Prelude.<$> framerateConversionAlgorithm,
("framerateDenominator" Data..=)
Prelude.<$> framerateDenominator,
("framerateNumerator" Data..=)
Prelude.<$> framerateNumerator,
("profile" Data..=) Prelude.<$> profile,
("slowPal" Data..=) Prelude.<$> slowPal,
("softness" Data..=) Prelude.<$> softness,
("spatialAdaptiveQuantization" Data..=)
Prelude.<$> spatialAdaptiveQuantization,
("temporalAdaptiveQuantization" Data..=)
Prelude.<$> temporalAdaptiveQuantization,
("xavc4kIntraCbgProfileSettings" Data..=)
Prelude.<$> xavc4kIntraCbgProfileSettings,
("xavc4kIntraVbrProfileSettings" Data..=)
Prelude.<$> xavc4kIntraVbrProfileSettings,
("xavc4kProfileSettings" Data..=)
Prelude.<$> xavc4kProfileSettings,
("xavcHdIntraCbgProfileSettings" Data..=)
Prelude.<$> xavcHdIntraCbgProfileSettings,
("xavcHdProfileSettings" Data..=)
Prelude.<$> xavcHdProfileSettings
]
)