{-# 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.AudioNormalizationSettings
-- 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.AudioNormalizationSettings 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.AudioNormalizationAlgorithm
import Amazonka.MediaConvert.Types.AudioNormalizationAlgorithmControl
import Amazonka.MediaConvert.Types.AudioNormalizationLoudnessLogging
import Amazonka.MediaConvert.Types.AudioNormalizationPeakCalculation
import qualified Amazonka.Prelude as Prelude

-- | Advanced audio normalization settings. Ignore these settings unless you
-- need to comply with a loudness standard.
--
-- /See:/ 'newAudioNormalizationSettings' smart constructor.
data AudioNormalizationSettings = AudioNormalizationSettings'
  { -- | Choose one of the following audio normalization algorithms: ITU-R
    -- BS.1770-1: Ungated loudness. A measurement of ungated average loudness
    -- for an entire piece of content, suitable for measurement of short-form
    -- content under ATSC recommendation A\/85. Supports up to 5.1 audio
    -- channels. ITU-R BS.1770-2: Gated loudness. A measurement of gated
    -- average loudness compliant with the requirements of EBU-R128. Supports
    -- up to 5.1 audio channels. ITU-R BS.1770-3: Modified peak. The same
    -- loudness measurement algorithm as 1770-2, with an updated true peak
    -- measurement. ITU-R BS.1770-4: Higher channel count. Allows for more
    -- audio channels than the other algorithms, including configurations such
    -- as 7.1.
    AudioNormalizationSettings -> Maybe AudioNormalizationAlgorithm
algorithm :: Prelude.Maybe AudioNormalizationAlgorithm,
    -- | When enabled the output audio is corrected using the chosen algorithm.
    -- If disabled, the audio will be measured but not adjusted.
    AudioNormalizationSettings
-> Maybe AudioNormalizationAlgorithmControl
algorithmControl :: Prelude.Maybe AudioNormalizationAlgorithmControl,
    -- | Content measuring above this level will be corrected to the target
    -- level. Content measuring below this level will not be corrected.
    AudioNormalizationSettings -> Maybe Int
correctionGateLevel :: Prelude.Maybe Prelude.Int,
    -- | If set to LOG, log each output\'s audio track loudness to a CSV file.
    AudioNormalizationSettings
-> Maybe AudioNormalizationLoudnessLogging
loudnessLogging :: Prelude.Maybe AudioNormalizationLoudnessLogging,
    -- | If set to TRUE_PEAK, calculate and log the TruePeak for each output\'s
    -- audio track loudness.
    AudioNormalizationSettings
-> Maybe AudioNormalizationPeakCalculation
peakCalculation :: Prelude.Maybe AudioNormalizationPeakCalculation,
    -- | When you use Audio normalization (AudioNormalizationSettings),
    -- optionally use this setting to specify a target loudness. If you don\'t
    -- specify a value here, the encoder chooses a value for you, based on the
    -- algorithm that you choose for Algorithm (algorithm). If you choose
    -- algorithm 1770-1, the encoder will choose -24 LKFS; otherwise, the
    -- encoder will choose -23 LKFS.
    AudioNormalizationSettings -> Maybe Double
targetLkfs :: Prelude.Maybe Prelude.Double
  }
  deriving (AudioNormalizationSettings -> AudioNormalizationSettings -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AudioNormalizationSettings -> AudioNormalizationSettings -> Bool
$c/= :: AudioNormalizationSettings -> AudioNormalizationSettings -> Bool
== :: AudioNormalizationSettings -> AudioNormalizationSettings -> Bool
$c== :: AudioNormalizationSettings -> AudioNormalizationSettings -> Bool
Prelude.Eq, ReadPrec [AudioNormalizationSettings]
ReadPrec AudioNormalizationSettings
Int -> ReadS AudioNormalizationSettings
ReadS [AudioNormalizationSettings]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [AudioNormalizationSettings]
$creadListPrec :: ReadPrec [AudioNormalizationSettings]
readPrec :: ReadPrec AudioNormalizationSettings
$creadPrec :: ReadPrec AudioNormalizationSettings
readList :: ReadS [AudioNormalizationSettings]
$creadList :: ReadS [AudioNormalizationSettings]
readsPrec :: Int -> ReadS AudioNormalizationSettings
$creadsPrec :: Int -> ReadS AudioNormalizationSettings
Prelude.Read, Int -> AudioNormalizationSettings -> ShowS
[AudioNormalizationSettings] -> ShowS
AudioNormalizationSettings -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AudioNormalizationSettings] -> ShowS
$cshowList :: [AudioNormalizationSettings] -> ShowS
show :: AudioNormalizationSettings -> String
$cshow :: AudioNormalizationSettings -> String
showsPrec :: Int -> AudioNormalizationSettings -> ShowS
$cshowsPrec :: Int -> AudioNormalizationSettings -> ShowS
Prelude.Show, forall x.
Rep AudioNormalizationSettings x -> AudioNormalizationSettings
forall x.
AudioNormalizationSettings -> Rep AudioNormalizationSettings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep AudioNormalizationSettings x -> AudioNormalizationSettings
$cfrom :: forall x.
AudioNormalizationSettings -> Rep AudioNormalizationSettings x
Prelude.Generic)

-- |
-- Create a value of 'AudioNormalizationSettings' 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:
--
-- 'algorithm', 'audioNormalizationSettings_algorithm' - Choose one of the following audio normalization algorithms: ITU-R
-- BS.1770-1: Ungated loudness. A measurement of ungated average loudness
-- for an entire piece of content, suitable for measurement of short-form
-- content under ATSC recommendation A\/85. Supports up to 5.1 audio
-- channels. ITU-R BS.1770-2: Gated loudness. A measurement of gated
-- average loudness compliant with the requirements of EBU-R128. Supports
-- up to 5.1 audio channels. ITU-R BS.1770-3: Modified peak. The same
-- loudness measurement algorithm as 1770-2, with an updated true peak
-- measurement. ITU-R BS.1770-4: Higher channel count. Allows for more
-- audio channels than the other algorithms, including configurations such
-- as 7.1.
--
-- 'algorithmControl', 'audioNormalizationSettings_algorithmControl' - When enabled the output audio is corrected using the chosen algorithm.
-- If disabled, the audio will be measured but not adjusted.
--
-- 'correctionGateLevel', 'audioNormalizationSettings_correctionGateLevel' - Content measuring above this level will be corrected to the target
-- level. Content measuring below this level will not be corrected.
--
-- 'loudnessLogging', 'audioNormalizationSettings_loudnessLogging' - If set to LOG, log each output\'s audio track loudness to a CSV file.
--
-- 'peakCalculation', 'audioNormalizationSettings_peakCalculation' - If set to TRUE_PEAK, calculate and log the TruePeak for each output\'s
-- audio track loudness.
--
-- 'targetLkfs', 'audioNormalizationSettings_targetLkfs' - When you use Audio normalization (AudioNormalizationSettings),
-- optionally use this setting to specify a target loudness. If you don\'t
-- specify a value here, the encoder chooses a value for you, based on the
-- algorithm that you choose for Algorithm (algorithm). If you choose
-- algorithm 1770-1, the encoder will choose -24 LKFS; otherwise, the
-- encoder will choose -23 LKFS.
newAudioNormalizationSettings ::
  AudioNormalizationSettings
newAudioNormalizationSettings :: AudioNormalizationSettings
newAudioNormalizationSettings =
  AudioNormalizationSettings'
    { $sel:algorithm:AudioNormalizationSettings' :: Maybe AudioNormalizationAlgorithm
algorithm =
        forall a. Maybe a
Prelude.Nothing,
      $sel:algorithmControl:AudioNormalizationSettings' :: Maybe AudioNormalizationAlgorithmControl
algorithmControl = forall a. Maybe a
Prelude.Nothing,
      $sel:correctionGateLevel:AudioNormalizationSettings' :: Maybe Int
correctionGateLevel = forall a. Maybe a
Prelude.Nothing,
      $sel:loudnessLogging:AudioNormalizationSettings' :: Maybe AudioNormalizationLoudnessLogging
loudnessLogging = forall a. Maybe a
Prelude.Nothing,
      $sel:peakCalculation:AudioNormalizationSettings' :: Maybe AudioNormalizationPeakCalculation
peakCalculation = forall a. Maybe a
Prelude.Nothing,
      $sel:targetLkfs:AudioNormalizationSettings' :: Maybe Double
targetLkfs = forall a. Maybe a
Prelude.Nothing
    }

-- | Choose one of the following audio normalization algorithms: ITU-R
-- BS.1770-1: Ungated loudness. A measurement of ungated average loudness
-- for an entire piece of content, suitable for measurement of short-form
-- content under ATSC recommendation A\/85. Supports up to 5.1 audio
-- channels. ITU-R BS.1770-2: Gated loudness. A measurement of gated
-- average loudness compliant with the requirements of EBU-R128. Supports
-- up to 5.1 audio channels. ITU-R BS.1770-3: Modified peak. The same
-- loudness measurement algorithm as 1770-2, with an updated true peak
-- measurement. ITU-R BS.1770-4: Higher channel count. Allows for more
-- audio channels than the other algorithms, including configurations such
-- as 7.1.
audioNormalizationSettings_algorithm :: Lens.Lens' AudioNormalizationSettings (Prelude.Maybe AudioNormalizationAlgorithm)
audioNormalizationSettings_algorithm :: Lens'
  AudioNormalizationSettings (Maybe AudioNormalizationAlgorithm)
audioNormalizationSettings_algorithm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AudioNormalizationSettings' {Maybe AudioNormalizationAlgorithm
algorithm :: Maybe AudioNormalizationAlgorithm
$sel:algorithm:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe AudioNormalizationAlgorithm
algorithm} -> Maybe AudioNormalizationAlgorithm
algorithm) (\s :: AudioNormalizationSettings
s@AudioNormalizationSettings' {} Maybe AudioNormalizationAlgorithm
a -> AudioNormalizationSettings
s {$sel:algorithm:AudioNormalizationSettings' :: Maybe AudioNormalizationAlgorithm
algorithm = Maybe AudioNormalizationAlgorithm
a} :: AudioNormalizationSettings)

-- | When enabled the output audio is corrected using the chosen algorithm.
-- If disabled, the audio will be measured but not adjusted.
audioNormalizationSettings_algorithmControl :: Lens.Lens' AudioNormalizationSettings (Prelude.Maybe AudioNormalizationAlgorithmControl)
audioNormalizationSettings_algorithmControl :: Lens'
  AudioNormalizationSettings
  (Maybe AudioNormalizationAlgorithmControl)
audioNormalizationSettings_algorithmControl = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AudioNormalizationSettings' {Maybe AudioNormalizationAlgorithmControl
algorithmControl :: Maybe AudioNormalizationAlgorithmControl
$sel:algorithmControl:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationAlgorithmControl
algorithmControl} -> Maybe AudioNormalizationAlgorithmControl
algorithmControl) (\s :: AudioNormalizationSettings
s@AudioNormalizationSettings' {} Maybe AudioNormalizationAlgorithmControl
a -> AudioNormalizationSettings
s {$sel:algorithmControl:AudioNormalizationSettings' :: Maybe AudioNormalizationAlgorithmControl
algorithmControl = Maybe AudioNormalizationAlgorithmControl
a} :: AudioNormalizationSettings)

-- | Content measuring above this level will be corrected to the target
-- level. Content measuring below this level will not be corrected.
audioNormalizationSettings_correctionGateLevel :: Lens.Lens' AudioNormalizationSettings (Prelude.Maybe Prelude.Int)
audioNormalizationSettings_correctionGateLevel :: Lens' AudioNormalizationSettings (Maybe Int)
audioNormalizationSettings_correctionGateLevel = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AudioNormalizationSettings' {Maybe Int
correctionGateLevel :: Maybe Int
$sel:correctionGateLevel:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Int
correctionGateLevel} -> Maybe Int
correctionGateLevel) (\s :: AudioNormalizationSettings
s@AudioNormalizationSettings' {} Maybe Int
a -> AudioNormalizationSettings
s {$sel:correctionGateLevel:AudioNormalizationSettings' :: Maybe Int
correctionGateLevel = Maybe Int
a} :: AudioNormalizationSettings)

-- | If set to LOG, log each output\'s audio track loudness to a CSV file.
audioNormalizationSettings_loudnessLogging :: Lens.Lens' AudioNormalizationSettings (Prelude.Maybe AudioNormalizationLoudnessLogging)
audioNormalizationSettings_loudnessLogging :: Lens'
  AudioNormalizationSettings
  (Maybe AudioNormalizationLoudnessLogging)
audioNormalizationSettings_loudnessLogging = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AudioNormalizationSettings' {Maybe AudioNormalizationLoudnessLogging
loudnessLogging :: Maybe AudioNormalizationLoudnessLogging
$sel:loudnessLogging:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationLoudnessLogging
loudnessLogging} -> Maybe AudioNormalizationLoudnessLogging
loudnessLogging) (\s :: AudioNormalizationSettings
s@AudioNormalizationSettings' {} Maybe AudioNormalizationLoudnessLogging
a -> AudioNormalizationSettings
s {$sel:loudnessLogging:AudioNormalizationSettings' :: Maybe AudioNormalizationLoudnessLogging
loudnessLogging = Maybe AudioNormalizationLoudnessLogging
a} :: AudioNormalizationSettings)

-- | If set to TRUE_PEAK, calculate and log the TruePeak for each output\'s
-- audio track loudness.
audioNormalizationSettings_peakCalculation :: Lens.Lens' AudioNormalizationSettings (Prelude.Maybe AudioNormalizationPeakCalculation)
audioNormalizationSettings_peakCalculation :: Lens'
  AudioNormalizationSettings
  (Maybe AudioNormalizationPeakCalculation)
audioNormalizationSettings_peakCalculation = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AudioNormalizationSettings' {Maybe AudioNormalizationPeakCalculation
peakCalculation :: Maybe AudioNormalizationPeakCalculation
$sel:peakCalculation:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationPeakCalculation
peakCalculation} -> Maybe AudioNormalizationPeakCalculation
peakCalculation) (\s :: AudioNormalizationSettings
s@AudioNormalizationSettings' {} Maybe AudioNormalizationPeakCalculation
a -> AudioNormalizationSettings
s {$sel:peakCalculation:AudioNormalizationSettings' :: Maybe AudioNormalizationPeakCalculation
peakCalculation = Maybe AudioNormalizationPeakCalculation
a} :: AudioNormalizationSettings)

-- | When you use Audio normalization (AudioNormalizationSettings),
-- optionally use this setting to specify a target loudness. If you don\'t
-- specify a value here, the encoder chooses a value for you, based on the
-- algorithm that you choose for Algorithm (algorithm). If you choose
-- algorithm 1770-1, the encoder will choose -24 LKFS; otherwise, the
-- encoder will choose -23 LKFS.
audioNormalizationSettings_targetLkfs :: Lens.Lens' AudioNormalizationSettings (Prelude.Maybe Prelude.Double)
audioNormalizationSettings_targetLkfs :: Lens' AudioNormalizationSettings (Maybe Double)
audioNormalizationSettings_targetLkfs = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\AudioNormalizationSettings' {Maybe Double
targetLkfs :: Maybe Double
$sel:targetLkfs:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Double
targetLkfs} -> Maybe Double
targetLkfs) (\s :: AudioNormalizationSettings
s@AudioNormalizationSettings' {} Maybe Double
a -> AudioNormalizationSettings
s {$sel:targetLkfs:AudioNormalizationSettings' :: Maybe Double
targetLkfs = Maybe Double
a} :: AudioNormalizationSettings)

instance Data.FromJSON AudioNormalizationSettings where
  parseJSON :: Value -> Parser AudioNormalizationSettings
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"AudioNormalizationSettings"
      ( \Object
x ->
          Maybe AudioNormalizationAlgorithm
-> Maybe AudioNormalizationAlgorithmControl
-> Maybe Int
-> Maybe AudioNormalizationLoudnessLogging
-> Maybe AudioNormalizationPeakCalculation
-> Maybe Double
-> AudioNormalizationSettings
AudioNormalizationSettings'
            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
"algorithm")
            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
"algorithmControl")
            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
"correctionGateLevel")
            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
"loudnessLogging")
            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
"peakCalculation")
            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
"targetLkfs")
      )

instance Prelude.Hashable AudioNormalizationSettings where
  hashWithSalt :: Int -> AudioNormalizationSettings -> Int
hashWithSalt Int
_salt AudioNormalizationSettings' {Maybe Double
Maybe Int
Maybe AudioNormalizationAlgorithm
Maybe AudioNormalizationAlgorithmControl
Maybe AudioNormalizationLoudnessLogging
Maybe AudioNormalizationPeakCalculation
targetLkfs :: Maybe Double
peakCalculation :: Maybe AudioNormalizationPeakCalculation
loudnessLogging :: Maybe AudioNormalizationLoudnessLogging
correctionGateLevel :: Maybe Int
algorithmControl :: Maybe AudioNormalizationAlgorithmControl
algorithm :: Maybe AudioNormalizationAlgorithm
$sel:targetLkfs:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Double
$sel:peakCalculation:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationPeakCalculation
$sel:loudnessLogging:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationLoudnessLogging
$sel:correctionGateLevel:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Int
$sel:algorithmControl:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationAlgorithmControl
$sel:algorithm:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe AudioNormalizationAlgorithm
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AudioNormalizationAlgorithm
algorithm
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AudioNormalizationAlgorithmControl
algorithmControl
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
correctionGateLevel
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AudioNormalizationLoudnessLogging
loudnessLogging
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe AudioNormalizationPeakCalculation
peakCalculation
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Double
targetLkfs

instance Prelude.NFData AudioNormalizationSettings where
  rnf :: AudioNormalizationSettings -> ()
rnf AudioNormalizationSettings' {Maybe Double
Maybe Int
Maybe AudioNormalizationAlgorithm
Maybe AudioNormalizationAlgorithmControl
Maybe AudioNormalizationLoudnessLogging
Maybe AudioNormalizationPeakCalculation
targetLkfs :: Maybe Double
peakCalculation :: Maybe AudioNormalizationPeakCalculation
loudnessLogging :: Maybe AudioNormalizationLoudnessLogging
correctionGateLevel :: Maybe Int
algorithmControl :: Maybe AudioNormalizationAlgorithmControl
algorithm :: Maybe AudioNormalizationAlgorithm
$sel:targetLkfs:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Double
$sel:peakCalculation:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationPeakCalculation
$sel:loudnessLogging:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationLoudnessLogging
$sel:correctionGateLevel:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Int
$sel:algorithmControl:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationAlgorithmControl
$sel:algorithm:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe AudioNormalizationAlgorithm
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe AudioNormalizationAlgorithm
algorithm
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AudioNormalizationAlgorithmControl
algorithmControl
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
correctionGateLevel
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AudioNormalizationLoudnessLogging
loudnessLogging
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe AudioNormalizationPeakCalculation
peakCalculation
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Double
targetLkfs

instance Data.ToJSON AudioNormalizationSettings where
  toJSON :: AudioNormalizationSettings -> Value
toJSON AudioNormalizationSettings' {Maybe Double
Maybe Int
Maybe AudioNormalizationAlgorithm
Maybe AudioNormalizationAlgorithmControl
Maybe AudioNormalizationLoudnessLogging
Maybe AudioNormalizationPeakCalculation
targetLkfs :: Maybe Double
peakCalculation :: Maybe AudioNormalizationPeakCalculation
loudnessLogging :: Maybe AudioNormalizationLoudnessLogging
correctionGateLevel :: Maybe Int
algorithmControl :: Maybe AudioNormalizationAlgorithmControl
algorithm :: Maybe AudioNormalizationAlgorithm
$sel:targetLkfs:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Double
$sel:peakCalculation:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationPeakCalculation
$sel:loudnessLogging:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationLoudnessLogging
$sel:correctionGateLevel:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe Int
$sel:algorithmControl:AudioNormalizationSettings' :: AudioNormalizationSettings
-> Maybe AudioNormalizationAlgorithmControl
$sel:algorithm:AudioNormalizationSettings' :: AudioNormalizationSettings -> Maybe AudioNormalizationAlgorithm
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"algorithm" 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 AudioNormalizationAlgorithm
algorithm,
            (Key
"algorithmControl" 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 AudioNormalizationAlgorithmControl
algorithmControl,
            (Key
"correctionGateLevel" 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 Int
correctionGateLevel,
            (Key
"loudnessLogging" 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 AudioNormalizationLoudnessLogging
loudnessLogging,
            (Key
"peakCalculation" 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 AudioNormalizationPeakCalculation
peakCalculation,
            (Key
"targetLkfs" 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 Double
targetLkfs
          ]
      )