{-# 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-2021 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay <brendan.g.hay+amazonka@gmail.com>
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.MediaConvert.Types.NoiseReducerTemporalFilterSettings where

import qualified Amazonka.Core as Core
import qualified Amazonka.Lens as Lens
import Amazonka.MediaConvert.Types.NoiseFilterPostTemporalSharpening
import qualified Amazonka.Prelude as Prelude

-- | Noise reducer filter settings for temporal filter.
--
-- /See:/ 'newNoiseReducerTemporalFilterSettings' smart constructor.
data NoiseReducerTemporalFilterSettings = NoiseReducerTemporalFilterSettings'
  { -- | Optional. When you set Noise reducer (noiseReducer) to Temporal
    -- (TEMPORAL), you can use this setting to apply sharpening. The default
    -- behavior, Auto (AUTO), allows the transcoder to determine whether to
    -- apply filtering, depending on input type and quality. When you set Noise
    -- reducer to Temporal, your output bandwidth is reduced. When Post
    -- temporal sharpening is also enabled, that bandwidth reduction is
    -- smaller.
    NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening :: Prelude.Maybe NoiseFilterPostTemporalSharpening,
    -- | 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,
    -- | 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,
    -- | 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
  }
  deriving (NoiseReducerTemporalFilterSettings
-> NoiseReducerTemporalFilterSettings -> Bool
(NoiseReducerTemporalFilterSettings
 -> NoiseReducerTemporalFilterSettings -> Bool)
-> (NoiseReducerTemporalFilterSettings
    -> NoiseReducerTemporalFilterSettings -> Bool)
-> Eq NoiseReducerTemporalFilterSettings
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]
(Int -> ReadS NoiseReducerTemporalFilterSettings)
-> ReadS [NoiseReducerTemporalFilterSettings]
-> ReadPrec NoiseReducerTemporalFilterSettings
-> ReadPrec [NoiseReducerTemporalFilterSettings]
-> Read 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
(Int -> NoiseReducerTemporalFilterSettings -> ShowS)
-> (NoiseReducerTemporalFilterSettings -> String)
-> ([NoiseReducerTemporalFilterSettings] -> ShowS)
-> Show NoiseReducerTemporalFilterSettings
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.
 NoiseReducerTemporalFilterSettings
 -> Rep NoiseReducerTemporalFilterSettings x)
-> (forall x.
    Rep NoiseReducerTemporalFilterSettings x
    -> NoiseReducerTemporalFilterSettings)
-> Generic NoiseReducerTemporalFilterSettings
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:
--
-- 'postTemporalSharpening', 'noiseReducerTemporalFilterSettings_postTemporalSharpening' - Optional. When you set Noise reducer (noiseReducer) to Temporal
-- (TEMPORAL), you can use this setting to apply sharpening. The default
-- behavior, Auto (AUTO), allows the transcoder to determine whether to
-- apply filtering, depending on input type and quality. When you set Noise
-- reducer to Temporal, your output bandwidth is reduced. When Post
-- temporal sharpening is also enabled, that bandwidth reduction is
-- smaller.
--
-- '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.
--
-- '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
--
-- '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.
newNoiseReducerTemporalFilterSettings ::
  NoiseReducerTemporalFilterSettings
newNoiseReducerTemporalFilterSettings :: NoiseReducerTemporalFilterSettings
newNoiseReducerTemporalFilterSettings =
  NoiseReducerTemporalFilterSettings' :: Maybe NoiseFilterPostTemporalSharpening
-> Maybe Natural
-> Maybe Natural
-> Maybe Int
-> NoiseReducerTemporalFilterSettings
NoiseReducerTemporalFilterSettings'
    { $sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening =
        Maybe NoiseFilterPostTemporalSharpening
forall a. Maybe a
Prelude.Nothing,
      $sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: Maybe Natural
aggressiveMode = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:strength:NoiseReducerTemporalFilterSettings' :: Maybe Natural
strength = Maybe Natural
forall a. Maybe a
Prelude.Nothing,
      $sel:speed:NoiseReducerTemporalFilterSettings' :: Maybe Int
speed = Maybe Int
forall a. Maybe a
Prelude.Nothing
    }

-- | Optional. When you set Noise reducer (noiseReducer) to Temporal
-- (TEMPORAL), you can use this setting to apply sharpening. The default
-- behavior, Auto (AUTO), allows the transcoder to determine whether to
-- apply filtering, depending on input type and quality. When you set Noise
-- reducer to Temporal, your output bandwidth is reduced. When Post
-- temporal sharpening is also enabled, that bandwidth reduction is
-- smaller.
noiseReducerTemporalFilterSettings_postTemporalSharpening :: Lens.Lens' NoiseReducerTemporalFilterSettings (Prelude.Maybe NoiseFilterPostTemporalSharpening)
noiseReducerTemporalFilterSettings_postTemporalSharpening :: (Maybe NoiseFilterPostTemporalSharpening
 -> f (Maybe NoiseFilterPostTemporalSharpening))
-> NoiseReducerTemporalFilterSettings
-> f NoiseReducerTemporalFilterSettings
noiseReducerTemporalFilterSettings_postTemporalSharpening = (NoiseReducerTemporalFilterSettings
 -> Maybe NoiseFilterPostTemporalSharpening)
-> (NoiseReducerTemporalFilterSettings
    -> Maybe NoiseFilterPostTemporalSharpening
    -> NoiseReducerTemporalFilterSettings)
-> Lens
     NoiseReducerTemporalFilterSettings
     NoiseReducerTemporalFilterSettings
     (Maybe NoiseFilterPostTemporalSharpening)
     (Maybe NoiseFilterPostTemporalSharpening)
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 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 :: (Maybe Natural -> f (Maybe Natural))
-> NoiseReducerTemporalFilterSettings
-> f NoiseReducerTemporalFilterSettings
noiseReducerTemporalFilterSettings_aggressiveMode = (NoiseReducerTemporalFilterSettings -> Maybe Natural)
-> (NoiseReducerTemporalFilterSettings
    -> Maybe Natural -> NoiseReducerTemporalFilterSettings)
-> Lens
     NoiseReducerTemporalFilterSettings
     NoiseReducerTemporalFilterSettings
     (Maybe Natural)
     (Maybe Natural)
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)

-- | 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 :: (Maybe Natural -> f (Maybe Natural))
-> NoiseReducerTemporalFilterSettings
-> f NoiseReducerTemporalFilterSettings
noiseReducerTemporalFilterSettings_strength = (NoiseReducerTemporalFilterSettings -> Maybe Natural)
-> (NoiseReducerTemporalFilterSettings
    -> Maybe Natural -> NoiseReducerTemporalFilterSettings)
-> Lens
     NoiseReducerTemporalFilterSettings
     NoiseReducerTemporalFilterSettings
     (Maybe Natural)
     (Maybe Natural)
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)

-- | 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 :: (Maybe Int -> f (Maybe Int))
-> NoiseReducerTemporalFilterSettings
-> f NoiseReducerTemporalFilterSettings
noiseReducerTemporalFilterSettings_speed = (NoiseReducerTemporalFilterSettings -> Maybe Int)
-> (NoiseReducerTemporalFilterSettings
    -> Maybe Int -> NoiseReducerTemporalFilterSettings)
-> Lens
     NoiseReducerTemporalFilterSettings
     NoiseReducerTemporalFilterSettings
     (Maybe Int)
     (Maybe Int)
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)

instance
  Core.FromJSON
    NoiseReducerTemporalFilterSettings
  where
  parseJSON :: Value -> Parser NoiseReducerTemporalFilterSettings
parseJSON =
    String
-> (Object -> Parser NoiseReducerTemporalFilterSettings)
-> Value
-> Parser NoiseReducerTemporalFilterSettings
forall a. String -> (Object -> Parser a) -> Value -> Parser a
Core.withObject
      String
"NoiseReducerTemporalFilterSettings"
      ( \Object
x ->
          Maybe NoiseFilterPostTemporalSharpening
-> Maybe Natural
-> Maybe Natural
-> Maybe Int
-> NoiseReducerTemporalFilterSettings
NoiseReducerTemporalFilterSettings'
            (Maybe NoiseFilterPostTemporalSharpening
 -> Maybe Natural
 -> Maybe Natural
 -> Maybe Int
 -> NoiseReducerTemporalFilterSettings)
-> Parser (Maybe NoiseFilterPostTemporalSharpening)
-> Parser
     (Maybe Natural
      -> Maybe Natural
      -> Maybe Int
      -> NoiseReducerTemporalFilterSettings)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x Object -> Text -> Parser (Maybe NoiseFilterPostTemporalSharpening)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"postTemporalSharpening")
            Parser
  (Maybe Natural
   -> Maybe Natural
   -> Maybe Int
   -> NoiseReducerTemporalFilterSettings)
-> Parser (Maybe Natural)
-> Parser
     (Maybe Natural -> Maybe Int -> NoiseReducerTemporalFilterSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"aggressiveMode")
            Parser
  (Maybe Natural -> Maybe Int -> NoiseReducerTemporalFilterSettings)
-> Parser (Maybe Natural)
-> Parser (Maybe Int -> NoiseReducerTemporalFilterSettings)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Natural)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"strength")
            Parser (Maybe Int -> NoiseReducerTemporalFilterSettings)
-> Parser (Maybe Int) -> Parser NoiseReducerTemporalFilterSettings
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
Core..:? Text
"speed")
      )

instance
  Prelude.Hashable
    NoiseReducerTemporalFilterSettings

instance
  Prelude.NFData
    NoiseReducerTemporalFilterSettings

instance
  Core.ToJSON
    NoiseReducerTemporalFilterSettings
  where
  toJSON :: NoiseReducerTemporalFilterSettings -> Value
toJSON NoiseReducerTemporalFilterSettings' {Maybe Int
Maybe Natural
Maybe NoiseFilterPostTemporalSharpening
speed :: Maybe Int
strength :: Maybe Natural
aggressiveMode :: Maybe Natural
postTemporalSharpening :: Maybe NoiseFilterPostTemporalSharpening
$sel:speed:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Int
$sel:strength:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
$sel:aggressiveMode:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings -> Maybe Natural
$sel:postTemporalSharpening:NoiseReducerTemporalFilterSettings' :: NoiseReducerTemporalFilterSettings
-> Maybe NoiseFilterPostTemporalSharpening
..} =
    [Pair] -> Value
Core.object
      ( [Maybe Pair] -> [Pair]
forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Text
"postTemporalSharpening" Text -> NoiseFilterPostTemporalSharpening -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (NoiseFilterPostTemporalSharpening -> Pair)
-> Maybe NoiseFilterPostTemporalSharpening -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe NoiseFilterPostTemporalSharpening
postTemporalSharpening,
            (Text
"aggressiveMode" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=)
              (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
aggressiveMode,
            (Text
"strength" Text -> Natural -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Natural -> Pair) -> Maybe Natural -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Natural
strength,
            (Text
"speed" Text -> Int -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
Core..=) (Int -> Pair) -> Maybe Int -> Maybe Pair
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe Int
speed
          ]
      )