{-# 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.NoiseReducerTemporalFilterSettings
-- 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.NoiseReducerTemporalFilterSettings 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.NoiseFilterPostTemporalSharpening
import Amazonka.MediaConvert.Types.NoiseFilterPostTemporalSharpeningStrength
import qualified Amazonka.Prelude as Prelude

-- | Noise reducer filter settings for temporal filter.
--
-- /See:/ 'newNoiseReducerTemporalFilterSettings' smart constructor.
data NoiseReducerTemporalFilterSettings = NoiseReducerTemporalFilterSettings'
  { -- | Use Aggressive mode for content that has complex motion. Higher values
    -- produce stronger temporal filtering. This filters highly complex scenes
    -- more aggressively and creates better VQ for low bitrate outputs.
    NoiseReducerTemporalFilterSettings -> Maybe Natural
aggressiveMode :: Prelude.Maybe Prelude.Natural,
    -- | When you set Noise reducer (noiseReducer) to Temporal (TEMPORAL), the
    -- bandwidth and sharpness of your output is reduced. You can optionally
    -- use Post temporal sharpening (postTemporalSharpening) to apply
    -- sharpening to the edges of your output. Note that Post temporal
    -- sharpening will also make the bandwidth reduction from the Noise reducer
    -- smaller. The default behavior, Auto (AUTO), allows the transcoder to
    -- determine whether to apply sharpening, depending on your input type and
    -- quality. When you set Post temporal sharpening to Enabled (ENABLED),
    -- specify how much sharpening is applied using Post temporal sharpening
    -- strength (postTemporalSharpeningStrength). Set Post temporal sharpening
    -- to Disabled (DISABLED) to not apply sharpening.
    NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening :: Prelude.Maybe NoiseFilterPostTemporalSharpening,
    -- | Use Post temporal sharpening strength (postTemporalSharpeningStrength)
    -- to define the amount of sharpening the transcoder applies to your
    -- output. Set Post temporal sharpening strength to Low (LOW), Medium
    -- (MEDIUM), or High (HIGH) to indicate the amount of sharpening.
    NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength :: Prelude.Maybe NoiseFilterPostTemporalSharpeningStrength,
    -- | The speed of the filter (higher number is faster). Low setting reduces
    -- bit rate at the cost of transcode time, high setting improves transcode
    -- time at the cost of bit rate.
    NoiseReducerTemporalFilterSettings -> Maybe Int
speed :: Prelude.Maybe Prelude.Int,
    -- | Specify the strength of the noise reducing filter on this output. Higher
    -- values produce stronger filtering. We recommend the following value
    -- ranges, depending on the result that you want: * 0-2 for complexity
    -- reduction with minimal sharpness loss * 2-8 for complexity reduction
    -- with image preservation * 8-16 for a high level of complexity reduction
    NoiseReducerTemporalFilterSettings -> Maybe Natural
strength :: Prelude.Maybe Prelude.Natural
  }
  deriving (NoiseReducerTemporalFilterSettings
-> NoiseReducerTemporalFilterSettings -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NoiseReducerTemporalFilterSettings
-> NoiseReducerTemporalFilterSettings -> Bool
$c/= :: NoiseReducerTemporalFilterSettings
-> NoiseReducerTemporalFilterSettings -> Bool
== :: NoiseReducerTemporalFilterSettings
-> NoiseReducerTemporalFilterSettings -> Bool
$c== :: NoiseReducerTemporalFilterSettings
-> NoiseReducerTemporalFilterSettings -> Bool
Prelude.Eq, ReadPrec [NoiseReducerTemporalFilterSettings]
ReadPrec NoiseReducerTemporalFilterSettings
Int -> ReadS NoiseReducerTemporalFilterSettings
ReadS [NoiseReducerTemporalFilterSettings]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NoiseReducerTemporalFilterSettings]
$creadListPrec :: ReadPrec [NoiseReducerTemporalFilterSettings]
readPrec :: ReadPrec NoiseReducerTemporalFilterSettings
$creadPrec :: ReadPrec NoiseReducerTemporalFilterSettings
readList :: ReadS [NoiseReducerTemporalFilterSettings]
$creadList :: ReadS [NoiseReducerTemporalFilterSettings]
readsPrec :: Int -> ReadS NoiseReducerTemporalFilterSettings
$creadsPrec :: Int -> ReadS NoiseReducerTemporalFilterSettings
Prelude.Read, Int -> NoiseReducerTemporalFilterSettings -> ShowS
[NoiseReducerTemporalFilterSettings] -> ShowS
NoiseReducerTemporalFilterSettings -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NoiseReducerTemporalFilterSettings] -> ShowS
$cshowList :: [NoiseReducerTemporalFilterSettings] -> ShowS
show :: NoiseReducerTemporalFilterSettings -> String
$cshow :: NoiseReducerTemporalFilterSettings -> String
showsPrec :: Int -> NoiseReducerTemporalFilterSettings -> ShowS
$cshowsPrec :: Int -> NoiseReducerTemporalFilterSettings -> ShowS
Prelude.Show, forall x.
Rep NoiseReducerTemporalFilterSettings x
-> NoiseReducerTemporalFilterSettings
forall x.
NoiseReducerTemporalFilterSettings
-> Rep NoiseReducerTemporalFilterSettings x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x.
Rep NoiseReducerTemporalFilterSettings x
-> NoiseReducerTemporalFilterSettings
$cfrom :: forall x.
NoiseReducerTemporalFilterSettings
-> Rep NoiseReducerTemporalFilterSettings x
Prelude.Generic)

-- |
-- Create a value of 'NoiseReducerTemporalFilterSettings' 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:
--
-- 'aggressiveMode', 'noiseReducerTemporalFilterSettings_aggressiveMode' - Use Aggressive mode for content that has complex motion. Higher values
-- produce stronger temporal filtering. This filters highly complex scenes
-- more aggressively and creates better VQ for low bitrate outputs.
--
-- 'postTemporalSharpening', 'noiseReducerTemporalFilterSettings_postTemporalSharpening' - When you set Noise reducer (noiseReducer) to Temporal (TEMPORAL), the
-- bandwidth and sharpness of your output is reduced. You can optionally
-- use Post temporal sharpening (postTemporalSharpening) to apply
-- sharpening to the edges of your output. Note that Post temporal
-- sharpening will also make the bandwidth reduction from the Noise reducer
-- smaller. The default behavior, Auto (AUTO), allows the transcoder to
-- determine whether to apply sharpening, depending on your input type and
-- quality. When you set Post temporal sharpening to Enabled (ENABLED),
-- specify how much sharpening is applied using Post temporal sharpening
-- strength (postTemporalSharpeningStrength). Set Post temporal sharpening
-- to Disabled (DISABLED) to not apply sharpening.
--
-- 'postTemporalSharpeningStrength', 'noiseReducerTemporalFilterSettings_postTemporalSharpeningStrength' - Use Post temporal sharpening strength (postTemporalSharpeningStrength)
-- to define the amount of sharpening the transcoder applies to your
-- output. Set Post temporal sharpening strength to Low (LOW), Medium
-- (MEDIUM), or High (HIGH) to indicate the amount of sharpening.
--
-- 'speed', 'noiseReducerTemporalFilterSettings_speed' - The speed of the filter (higher number is faster). Low setting reduces
-- bit rate at the cost of transcode time, high setting improves transcode
-- time at the cost of bit rate.
--
-- 'strength', 'noiseReducerTemporalFilterSettings_strength' - Specify the strength of the noise reducing filter on this output. Higher
-- values produce stronger filtering. We recommend the following value
-- ranges, depending on the result that you want: * 0-2 for complexity
-- reduction with minimal sharpness loss * 2-8 for complexity reduction
-- with image preservation * 8-16 for a high level of complexity reduction
newNoiseReducerTemporalFilterSettings ::
  NoiseReducerTemporalFilterSettings
newNoiseReducerTemporalFilterSettings :: NoiseReducerTemporalFilterSettings
newNoiseReducerTemporalFilterSettings =
  NoiseReducerTemporalFilterSettings'
    { $sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: Maybe Natural
aggressiveMode =
        forall a. Maybe a
Prelude.Nothing,
      $sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening =
        forall a. Maybe a
Prelude.Nothing,
      $sel:postTemporalSharpeningStrength:NoiseReducerTemporalFilterSettings' :: Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength =
        forall a. Maybe a
Prelude.Nothing,
      $sel:speed:NoiseReducerTemporalFilterSettings' :: Maybe Int
speed = forall a. Maybe a
Prelude.Nothing,
      $sel:strength:NoiseReducerTemporalFilterSettings' :: Maybe Natural
strength = forall a. Maybe a
Prelude.Nothing
    }

-- | Use Aggressive mode for content that has complex motion. Higher values
-- produce stronger temporal filtering. This filters highly complex scenes
-- more aggressively and creates better VQ for low bitrate outputs.
noiseReducerTemporalFilterSettings_aggressiveMode :: Lens.Lens' NoiseReducerTemporalFilterSettings (Prelude.Maybe Prelude.Natural)
noiseReducerTemporalFilterSettings_aggressiveMode :: Lens' NoiseReducerTemporalFilterSettings (Maybe Natural)
noiseReducerTemporalFilterSettings_aggressiveMode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NoiseReducerTemporalFilterSettings' {Maybe Natural
aggressiveMode :: Maybe Natural
$sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
aggressiveMode} -> Maybe Natural
aggressiveMode) (\s :: NoiseReducerTemporalFilterSettings
s@NoiseReducerTemporalFilterSettings' {} Maybe Natural
a -> NoiseReducerTemporalFilterSettings
s {$sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: Maybe Natural
aggressiveMode = Maybe Natural
a} :: NoiseReducerTemporalFilterSettings)

-- | When you set Noise reducer (noiseReducer) to Temporal (TEMPORAL), the
-- bandwidth and sharpness of your output is reduced. You can optionally
-- use Post temporal sharpening (postTemporalSharpening) to apply
-- sharpening to the edges of your output. Note that Post temporal
-- sharpening will also make the bandwidth reduction from the Noise reducer
-- smaller. The default behavior, Auto (AUTO), allows the transcoder to
-- determine whether to apply sharpening, depending on your input type and
-- quality. When you set Post temporal sharpening to Enabled (ENABLED),
-- specify how much sharpening is applied using Post temporal sharpening
-- strength (postTemporalSharpeningStrength). Set Post temporal sharpening
-- to Disabled (DISABLED) to not apply sharpening.
noiseReducerTemporalFilterSettings_postTemporalSharpening :: Lens.Lens' NoiseReducerTemporalFilterSettings (Prelude.Maybe NoiseFilterPostTemporalSharpening)
noiseReducerTemporalFilterSettings_postTemporalSharpening :: Lens'
  NoiseReducerTemporalFilterSettings
  (Maybe NoiseFilterPostTemporalSharpening)
noiseReducerTemporalFilterSettings_postTemporalSharpening = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NoiseReducerTemporalFilterSettings' {Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening :: Maybe NoiseFilterPostTemporalSharpening
$sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening} -> Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening) (\s :: NoiseReducerTemporalFilterSettings
s@NoiseReducerTemporalFilterSettings' {} Maybe NoiseFilterPostTemporalSharpening
a -> NoiseReducerTemporalFilterSettings
s {$sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening = Maybe NoiseFilterPostTemporalSharpening
a} :: NoiseReducerTemporalFilterSettings)

-- | Use Post temporal sharpening strength (postTemporalSharpeningStrength)
-- to define the amount of sharpening the transcoder applies to your
-- output. Set Post temporal sharpening strength to Low (LOW), Medium
-- (MEDIUM), or High (HIGH) to indicate the amount of sharpening.
noiseReducerTemporalFilterSettings_postTemporalSharpeningStrength :: Lens.Lens' NoiseReducerTemporalFilterSettings (Prelude.Maybe NoiseFilterPostTemporalSharpeningStrength)
noiseReducerTemporalFilterSettings_postTemporalSharpeningStrength :: Lens'
  NoiseReducerTemporalFilterSettings
  (Maybe NoiseFilterPostTemporalSharpeningStrength)
noiseReducerTemporalFilterSettings_postTemporalSharpeningStrength = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NoiseReducerTemporalFilterSettings' {Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength :: Maybe NoiseFilterPostTemporalSharpeningStrength
$sel:postTemporalSharpeningStrength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength} -> Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength) (\s :: NoiseReducerTemporalFilterSettings
s@NoiseReducerTemporalFilterSettings' {} Maybe NoiseFilterPostTemporalSharpeningStrength
a -> NoiseReducerTemporalFilterSettings
s {$sel:postTemporalSharpeningStrength:NoiseReducerTemporalFilterSettings' :: Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength = Maybe NoiseFilterPostTemporalSharpeningStrength
a} :: NoiseReducerTemporalFilterSettings)

-- | The speed of the filter (higher number is faster). Low setting reduces
-- bit rate at the cost of transcode time, high setting improves transcode
-- time at the cost of bit rate.
noiseReducerTemporalFilterSettings_speed :: Lens.Lens' NoiseReducerTemporalFilterSettings (Prelude.Maybe Prelude.Int)
noiseReducerTemporalFilterSettings_speed :: Lens' NoiseReducerTemporalFilterSettings (Maybe Int)
noiseReducerTemporalFilterSettings_speed = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NoiseReducerTemporalFilterSettings' {Maybe Int
speed :: Maybe Int
$sel:speed:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Int
speed} -> Maybe Int
speed) (\s :: NoiseReducerTemporalFilterSettings
s@NoiseReducerTemporalFilterSettings' {} Maybe Int
a -> NoiseReducerTemporalFilterSettings
s {$sel:speed:NoiseReducerTemporalFilterSettings' :: Maybe Int
speed = Maybe Int
a} :: NoiseReducerTemporalFilterSettings)

-- | Specify the strength of the noise reducing filter on this output. Higher
-- values produce stronger filtering. We recommend the following value
-- ranges, depending on the result that you want: * 0-2 for complexity
-- reduction with minimal sharpness loss * 2-8 for complexity reduction
-- with image preservation * 8-16 for a high level of complexity reduction
noiseReducerTemporalFilterSettings_strength :: Lens.Lens' NoiseReducerTemporalFilterSettings (Prelude.Maybe Prelude.Natural)
noiseReducerTemporalFilterSettings_strength :: Lens' NoiseReducerTemporalFilterSettings (Maybe Natural)
noiseReducerTemporalFilterSettings_strength = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NoiseReducerTemporalFilterSettings' {Maybe Natural
strength :: Maybe Natural
$sel:strength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
strength} -> Maybe Natural
strength) (\s :: NoiseReducerTemporalFilterSettings
s@NoiseReducerTemporalFilterSettings' {} Maybe Natural
a -> NoiseReducerTemporalFilterSettings
s {$sel:strength:NoiseReducerTemporalFilterSettings' :: Maybe Natural
strength = Maybe Natural
a} :: NoiseReducerTemporalFilterSettings)

instance
  Data.FromJSON
    NoiseReducerTemporalFilterSettings
  where
  parseJSON :: Value -> Parser NoiseReducerTemporalFilterSettings
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"NoiseReducerTemporalFilterSettings"
      ( \Object
x ->
          Maybe Natural
-> Maybe NoiseFilterPostTemporalSharpening
-> Maybe NoiseFilterPostTemporalSharpeningStrength
-> Maybe Int
-> Maybe Natural
-> NoiseReducerTemporalFilterSettings
NoiseReducerTemporalFilterSettings'
            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
"aggressiveMode")
            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
"postTemporalSharpening")
            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
"postTemporalSharpeningStrength")
            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
"speed")
            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
"strength")
      )

instance
  Prelude.Hashable
    NoiseReducerTemporalFilterSettings
  where
  hashWithSalt :: Int -> NoiseReducerTemporalFilterSettings -> Int
hashWithSalt
    Int
_salt
    NoiseReducerTemporalFilterSettings' {Maybe Int
Maybe Natural
Maybe NoiseFilterPostTemporalSharpening
Maybe NoiseFilterPostTemporalSharpeningStrength
strength :: Maybe Natural
speed :: Maybe Int
postTemporalSharpeningStrength :: Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpening :: Maybe NoiseFilterPostTemporalSharpening
aggressiveMode :: Maybe Natural
$sel:strength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
$sel:speed:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Int
$sel:postTemporalSharpeningStrength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpeningStrength
$sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpening
$sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
..} =
      Int
_salt
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
aggressiveMode
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
speed
        forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Natural
strength

instance
  Prelude.NFData
    NoiseReducerTemporalFilterSettings
  where
  rnf :: NoiseReducerTemporalFilterSettings -> ()
rnf NoiseReducerTemporalFilterSettings' {Maybe Int
Maybe Natural
Maybe NoiseFilterPostTemporalSharpening
Maybe NoiseFilterPostTemporalSharpeningStrength
strength :: Maybe Natural
speed :: Maybe Int
postTemporalSharpeningStrength :: Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpening :: Maybe NoiseFilterPostTemporalSharpening
aggressiveMode :: Maybe Natural
$sel:strength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
$sel:speed:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Int
$sel:postTemporalSharpeningStrength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpeningStrength
$sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpening
$sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
aggressiveMode
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
speed
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Natural
strength

instance
  Data.ToJSON
    NoiseReducerTemporalFilterSettings
  where
  toJSON :: NoiseReducerTemporalFilterSettings -> Value
toJSON NoiseReducerTemporalFilterSettings' {Maybe Int
Maybe Natural
Maybe NoiseFilterPostTemporalSharpening
Maybe NoiseFilterPostTemporalSharpeningStrength
strength :: Maybe Natural
speed :: Maybe Int
postTemporalSharpeningStrength :: Maybe NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpening :: Maybe NoiseFilterPostTemporalSharpening
aggressiveMode :: Maybe Natural
$sel:strength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
$sel:speed:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Int
$sel:postTemporalSharpeningStrength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpeningStrength
$sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpening
$sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"aggressiveMode" 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
aggressiveMode,
            (Key
"postTemporalSharpening" 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 NoiseFilterPostTemporalSharpening
postTemporalSharpening,
            (Key
"postTemporalSharpeningStrength" 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 NoiseFilterPostTemporalSharpeningStrength
postTemporalSharpeningStrength,
            (Key
"speed" 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
speed,
            (Key
"strength" 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
strength
          ]
      )