{-# 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.Deinterlacer
-- 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.Deinterlacer 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.DeinterlaceAlgorithm
import Amazonka.MediaConvert.Types.DeinterlacerControl
import Amazonka.MediaConvert.Types.DeinterlacerMode
import qualified Amazonka.Prelude as Prelude

-- | Settings for deinterlacer
--
-- /See:/ 'newDeinterlacer' smart constructor.
data Deinterlacer = Deinterlacer'
  { -- | Only applies when you set Deinterlacer (DeinterlaceMode) to Deinterlace
    -- (DEINTERLACE) or Adaptive (ADAPTIVE). Motion adaptive interpolate
    -- (INTERPOLATE) produces sharper pictures, while blend (BLEND) produces
    -- smoother motion. Use (INTERPOLATE_TICKER) OR (BLEND_TICKER) if your
    -- source file includes a ticker, such as a scrolling headline at the
    -- bottom of the frame.
    Deinterlacer -> Maybe DeinterlaceAlgorithm
algorithm :: Prelude.Maybe DeinterlaceAlgorithm,
    -- | - When set to NORMAL (default), the deinterlacer does not convert frames
    -- that are tagged in metadata as progressive. It will only convert those
    -- that are tagged as some other type. - When set to FORCE_ALL_FRAMES, the
    -- deinterlacer converts every frame to progressive - even those that are
    -- already tagged as progressive. Turn Force mode on only if there is a
    -- good chance that the metadata has tagged frames as progressive when they
    -- are not progressive. Do not turn on otherwise; processing frames that
    -- are already progressive into progressive will probably result in lower
    -- quality video.
    Deinterlacer -> Maybe DeinterlacerControl
control :: Prelude.Maybe DeinterlacerControl,
    -- | Use Deinterlacer (DeinterlaceMode) to choose how the service will do
    -- deinterlacing. Default is Deinterlace. - Deinterlace converts interlaced
    -- to progressive. - Inverse telecine converts Hard Telecine 29.97i to
    -- progressive 23.976p. - Adaptive auto-detects and converts to
    -- progressive.
    Deinterlacer -> Maybe DeinterlacerMode
mode :: Prelude.Maybe DeinterlacerMode
  }
  deriving (Deinterlacer -> Deinterlacer -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Deinterlacer -> Deinterlacer -> Bool
$c/= :: Deinterlacer -> Deinterlacer -> Bool
== :: Deinterlacer -> Deinterlacer -> Bool
$c== :: Deinterlacer -> Deinterlacer -> Bool
Prelude.Eq, ReadPrec [Deinterlacer]
ReadPrec Deinterlacer
Int -> ReadS Deinterlacer
ReadS [Deinterlacer]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Deinterlacer]
$creadListPrec :: ReadPrec [Deinterlacer]
readPrec :: ReadPrec Deinterlacer
$creadPrec :: ReadPrec Deinterlacer
readList :: ReadS [Deinterlacer]
$creadList :: ReadS [Deinterlacer]
readsPrec :: Int -> ReadS Deinterlacer
$creadsPrec :: Int -> ReadS Deinterlacer
Prelude.Read, Int -> Deinterlacer -> ShowS
[Deinterlacer] -> ShowS
Deinterlacer -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Deinterlacer] -> ShowS
$cshowList :: [Deinterlacer] -> ShowS
show :: Deinterlacer -> String
$cshow :: Deinterlacer -> String
showsPrec :: Int -> Deinterlacer -> ShowS
$cshowsPrec :: Int -> Deinterlacer -> ShowS
Prelude.Show, forall x. Rep Deinterlacer x -> Deinterlacer
forall x. Deinterlacer -> Rep Deinterlacer x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Deinterlacer x -> Deinterlacer
$cfrom :: forall x. Deinterlacer -> Rep Deinterlacer x
Prelude.Generic)

-- |
-- Create a value of 'Deinterlacer' 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', 'deinterlacer_algorithm' - Only applies when you set Deinterlacer (DeinterlaceMode) to Deinterlace
-- (DEINTERLACE) or Adaptive (ADAPTIVE). Motion adaptive interpolate
-- (INTERPOLATE) produces sharper pictures, while blend (BLEND) produces
-- smoother motion. Use (INTERPOLATE_TICKER) OR (BLEND_TICKER) if your
-- source file includes a ticker, such as a scrolling headline at the
-- bottom of the frame.
--
-- 'control', 'deinterlacer_control' - - When set to NORMAL (default), the deinterlacer does not convert frames
-- that are tagged in metadata as progressive. It will only convert those
-- that are tagged as some other type. - When set to FORCE_ALL_FRAMES, the
-- deinterlacer converts every frame to progressive - even those that are
-- already tagged as progressive. Turn Force mode on only if there is a
-- good chance that the metadata has tagged frames as progressive when they
-- are not progressive. Do not turn on otherwise; processing frames that
-- are already progressive into progressive will probably result in lower
-- quality video.
--
-- 'mode', 'deinterlacer_mode' - Use Deinterlacer (DeinterlaceMode) to choose how the service will do
-- deinterlacing. Default is Deinterlace. - Deinterlace converts interlaced
-- to progressive. - Inverse telecine converts Hard Telecine 29.97i to
-- progressive 23.976p. - Adaptive auto-detects and converts to
-- progressive.
newDeinterlacer ::
  Deinterlacer
newDeinterlacer :: Deinterlacer
newDeinterlacer =
  Deinterlacer'
    { $sel:algorithm:Deinterlacer' :: Maybe DeinterlaceAlgorithm
algorithm = forall a. Maybe a
Prelude.Nothing,
      $sel:control:Deinterlacer' :: Maybe DeinterlacerControl
control = forall a. Maybe a
Prelude.Nothing,
      $sel:mode:Deinterlacer' :: Maybe DeinterlacerMode
mode = forall a. Maybe a
Prelude.Nothing
    }

-- | Only applies when you set Deinterlacer (DeinterlaceMode) to Deinterlace
-- (DEINTERLACE) or Adaptive (ADAPTIVE). Motion adaptive interpolate
-- (INTERPOLATE) produces sharper pictures, while blend (BLEND) produces
-- smoother motion. Use (INTERPOLATE_TICKER) OR (BLEND_TICKER) if your
-- source file includes a ticker, such as a scrolling headline at the
-- bottom of the frame.
deinterlacer_algorithm :: Lens.Lens' Deinterlacer (Prelude.Maybe DeinterlaceAlgorithm)
deinterlacer_algorithm :: Lens' Deinterlacer (Maybe DeinterlaceAlgorithm)
deinterlacer_algorithm = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Deinterlacer' {Maybe DeinterlaceAlgorithm
algorithm :: Maybe DeinterlaceAlgorithm
$sel:algorithm:Deinterlacer' :: Deinterlacer -> Maybe DeinterlaceAlgorithm
algorithm} -> Maybe DeinterlaceAlgorithm
algorithm) (\s :: Deinterlacer
s@Deinterlacer' {} Maybe DeinterlaceAlgorithm
a -> Deinterlacer
s {$sel:algorithm:Deinterlacer' :: Maybe DeinterlaceAlgorithm
algorithm = Maybe DeinterlaceAlgorithm
a} :: Deinterlacer)

-- | - When set to NORMAL (default), the deinterlacer does not convert frames
-- that are tagged in metadata as progressive. It will only convert those
-- that are tagged as some other type. - When set to FORCE_ALL_FRAMES, the
-- deinterlacer converts every frame to progressive - even those that are
-- already tagged as progressive. Turn Force mode on only if there is a
-- good chance that the metadata has tagged frames as progressive when they
-- are not progressive. Do not turn on otherwise; processing frames that
-- are already progressive into progressive will probably result in lower
-- quality video.
deinterlacer_control :: Lens.Lens' Deinterlacer (Prelude.Maybe DeinterlacerControl)
deinterlacer_control :: Lens' Deinterlacer (Maybe DeinterlacerControl)
deinterlacer_control = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Deinterlacer' {Maybe DeinterlacerControl
control :: Maybe DeinterlacerControl
$sel:control:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerControl
control} -> Maybe DeinterlacerControl
control) (\s :: Deinterlacer
s@Deinterlacer' {} Maybe DeinterlacerControl
a -> Deinterlacer
s {$sel:control:Deinterlacer' :: Maybe DeinterlacerControl
control = Maybe DeinterlacerControl
a} :: Deinterlacer)

-- | Use Deinterlacer (DeinterlaceMode) to choose how the service will do
-- deinterlacing. Default is Deinterlace. - Deinterlace converts interlaced
-- to progressive. - Inverse telecine converts Hard Telecine 29.97i to
-- progressive 23.976p. - Adaptive auto-detects and converts to
-- progressive.
deinterlacer_mode :: Lens.Lens' Deinterlacer (Prelude.Maybe DeinterlacerMode)
deinterlacer_mode :: Lens' Deinterlacer (Maybe DeinterlacerMode)
deinterlacer_mode = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Deinterlacer' {Maybe DeinterlacerMode
mode :: Maybe DeinterlacerMode
$sel:mode:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerMode
mode} -> Maybe DeinterlacerMode
mode) (\s :: Deinterlacer
s@Deinterlacer' {} Maybe DeinterlacerMode
a -> Deinterlacer
s {$sel:mode:Deinterlacer' :: Maybe DeinterlacerMode
mode = Maybe DeinterlacerMode
a} :: Deinterlacer)

instance Data.FromJSON Deinterlacer where
  parseJSON :: Value -> Parser Deinterlacer
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Deinterlacer"
      ( \Object
x ->
          Maybe DeinterlaceAlgorithm
-> Maybe DeinterlacerControl
-> Maybe DeinterlacerMode
-> Deinterlacer
Deinterlacer'
            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
"control")
            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
"mode")
      )

instance Prelude.Hashable Deinterlacer where
  hashWithSalt :: Int -> Deinterlacer -> Int
hashWithSalt Int
_salt Deinterlacer' {Maybe DeinterlaceAlgorithm
Maybe DeinterlacerControl
Maybe DeinterlacerMode
mode :: Maybe DeinterlacerMode
control :: Maybe DeinterlacerControl
algorithm :: Maybe DeinterlaceAlgorithm
$sel:mode:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerMode
$sel:control:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerControl
$sel:algorithm:Deinterlacer' :: Deinterlacer -> Maybe DeinterlaceAlgorithm
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeinterlaceAlgorithm
algorithm
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeinterlacerControl
control
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe DeinterlacerMode
mode

instance Prelude.NFData Deinterlacer where
  rnf :: Deinterlacer -> ()
rnf Deinterlacer' {Maybe DeinterlaceAlgorithm
Maybe DeinterlacerControl
Maybe DeinterlacerMode
mode :: Maybe DeinterlacerMode
control :: Maybe DeinterlacerControl
algorithm :: Maybe DeinterlaceAlgorithm
$sel:mode:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerMode
$sel:control:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerControl
$sel:algorithm:Deinterlacer' :: Deinterlacer -> Maybe DeinterlaceAlgorithm
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe DeinterlaceAlgorithm
algorithm
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DeinterlacerControl
control
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe DeinterlacerMode
mode

instance Data.ToJSON Deinterlacer where
  toJSON :: Deinterlacer -> Value
toJSON Deinterlacer' {Maybe DeinterlaceAlgorithm
Maybe DeinterlacerControl
Maybe DeinterlacerMode
mode :: Maybe DeinterlacerMode
control :: Maybe DeinterlacerControl
algorithm :: Maybe DeinterlaceAlgorithm
$sel:mode:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerMode
$sel:control:Deinterlacer' :: Deinterlacer -> Maybe DeinterlacerControl
$sel:algorithm:Deinterlacer' :: Deinterlacer -> Maybe DeinterlaceAlgorithm
..} =
    [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 DeinterlaceAlgorithm
algorithm,
            (Key
"control" 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 DeinterlacerControl
control,
            (Key
"mode" 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 DeinterlacerMode
mode
          ]
      )