{-# 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.MediaPackage.Types.CmafPackage
-- 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.MediaPackage.Types.CmafPackage where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.MediaPackage.Types.CmafEncryption
import Amazonka.MediaPackage.Types.HlsManifest
import Amazonka.MediaPackage.Types.StreamSelection
import qualified Amazonka.Prelude as Prelude

-- | A Common Media Application Format (CMAF) packaging configuration.
--
-- /See:/ 'newCmafPackage' smart constructor.
data CmafPackage = CmafPackage'
  { CmafPackage -> Maybe CmafEncryption
encryption :: Prelude.Maybe CmafEncryption,
    -- | A list of HLS manifest configurations
    CmafPackage -> Maybe [HlsManifest]
hlsManifests :: Prelude.Maybe [HlsManifest],
    -- | Duration (in seconds) of each segment. Actual segments will be rounded
    -- to the nearest multiple of the source segment duration.
    CmafPackage -> Maybe Int
segmentDurationSeconds :: Prelude.Maybe Prelude.Int,
    -- | An optional custom string that is prepended to the name of each segment.
    -- If not specified, it defaults to the ChannelId.
    CmafPackage -> Maybe Text
segmentPrefix :: Prelude.Maybe Prelude.Text,
    CmafPackage -> Maybe StreamSelection
streamSelection :: Prelude.Maybe StreamSelection
  }
  deriving (CmafPackage -> CmafPackage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CmafPackage -> CmafPackage -> Bool
$c/= :: CmafPackage -> CmafPackage -> Bool
== :: CmafPackage -> CmafPackage -> Bool
$c== :: CmafPackage -> CmafPackage -> Bool
Prelude.Eq, ReadPrec [CmafPackage]
ReadPrec CmafPackage
Int -> ReadS CmafPackage
ReadS [CmafPackage]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CmafPackage]
$creadListPrec :: ReadPrec [CmafPackage]
readPrec :: ReadPrec CmafPackage
$creadPrec :: ReadPrec CmafPackage
readList :: ReadS [CmafPackage]
$creadList :: ReadS [CmafPackage]
readsPrec :: Int -> ReadS CmafPackage
$creadsPrec :: Int -> ReadS CmafPackage
Prelude.Read, Int -> CmafPackage -> ShowS
[CmafPackage] -> ShowS
CmafPackage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CmafPackage] -> ShowS
$cshowList :: [CmafPackage] -> ShowS
show :: CmafPackage -> String
$cshow :: CmafPackage -> String
showsPrec :: Int -> CmafPackage -> ShowS
$cshowsPrec :: Int -> CmafPackage -> ShowS
Prelude.Show, forall x. Rep CmafPackage x -> CmafPackage
forall x. CmafPackage -> Rep CmafPackage x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CmafPackage x -> CmafPackage
$cfrom :: forall x. CmafPackage -> Rep CmafPackage x
Prelude.Generic)

-- |
-- Create a value of 'CmafPackage' 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:
--
-- 'encryption', 'cmafPackage_encryption' - Undocumented member.
--
-- 'hlsManifests', 'cmafPackage_hlsManifests' - A list of HLS manifest configurations
--
-- 'segmentDurationSeconds', 'cmafPackage_segmentDurationSeconds' - Duration (in seconds) of each segment. Actual segments will be rounded
-- to the nearest multiple of the source segment duration.
--
-- 'segmentPrefix', 'cmafPackage_segmentPrefix' - An optional custom string that is prepended to the name of each segment.
-- If not specified, it defaults to the ChannelId.
--
-- 'streamSelection', 'cmafPackage_streamSelection' - Undocumented member.
newCmafPackage ::
  CmafPackage
newCmafPackage :: CmafPackage
newCmafPackage =
  CmafPackage'
    { $sel:encryption:CmafPackage' :: Maybe CmafEncryption
encryption = forall a. Maybe a
Prelude.Nothing,
      $sel:hlsManifests:CmafPackage' :: Maybe [HlsManifest]
hlsManifests = forall a. Maybe a
Prelude.Nothing,
      $sel:segmentDurationSeconds:CmafPackage' :: Maybe Int
segmentDurationSeconds = forall a. Maybe a
Prelude.Nothing,
      $sel:segmentPrefix:CmafPackage' :: Maybe Text
segmentPrefix = forall a. Maybe a
Prelude.Nothing,
      $sel:streamSelection:CmafPackage' :: Maybe StreamSelection
streamSelection = forall a. Maybe a
Prelude.Nothing
    }

-- | Undocumented member.
cmafPackage_encryption :: Lens.Lens' CmafPackage (Prelude.Maybe CmafEncryption)
cmafPackage_encryption :: Lens' CmafPackage (Maybe CmafEncryption)
cmafPackage_encryption = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CmafPackage' {Maybe CmafEncryption
encryption :: Maybe CmafEncryption
$sel:encryption:CmafPackage' :: CmafPackage -> Maybe CmafEncryption
encryption} -> Maybe CmafEncryption
encryption) (\s :: CmafPackage
s@CmafPackage' {} Maybe CmafEncryption
a -> CmafPackage
s {$sel:encryption:CmafPackage' :: Maybe CmafEncryption
encryption = Maybe CmafEncryption
a} :: CmafPackage)

-- | A list of HLS manifest configurations
cmafPackage_hlsManifests :: Lens.Lens' CmafPackage (Prelude.Maybe [HlsManifest])
cmafPackage_hlsManifests :: Lens' CmafPackage (Maybe [HlsManifest])
cmafPackage_hlsManifests = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CmafPackage' {Maybe [HlsManifest]
hlsManifests :: Maybe [HlsManifest]
$sel:hlsManifests:CmafPackage' :: CmafPackage -> Maybe [HlsManifest]
hlsManifests} -> Maybe [HlsManifest]
hlsManifests) (\s :: CmafPackage
s@CmafPackage' {} Maybe [HlsManifest]
a -> CmafPackage
s {$sel:hlsManifests:CmafPackage' :: Maybe [HlsManifest]
hlsManifests = Maybe [HlsManifest]
a} :: CmafPackage) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | Duration (in seconds) of each segment. Actual segments will be rounded
-- to the nearest multiple of the source segment duration.
cmafPackage_segmentDurationSeconds :: Lens.Lens' CmafPackage (Prelude.Maybe Prelude.Int)
cmafPackage_segmentDurationSeconds :: Lens' CmafPackage (Maybe Int)
cmafPackage_segmentDurationSeconds = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CmafPackage' {Maybe Int
segmentDurationSeconds :: Maybe Int
$sel:segmentDurationSeconds:CmafPackage' :: CmafPackage -> Maybe Int
segmentDurationSeconds} -> Maybe Int
segmentDurationSeconds) (\s :: CmafPackage
s@CmafPackage' {} Maybe Int
a -> CmafPackage
s {$sel:segmentDurationSeconds:CmafPackage' :: Maybe Int
segmentDurationSeconds = Maybe Int
a} :: CmafPackage)

-- | An optional custom string that is prepended to the name of each segment.
-- If not specified, it defaults to the ChannelId.
cmafPackage_segmentPrefix :: Lens.Lens' CmafPackage (Prelude.Maybe Prelude.Text)
cmafPackage_segmentPrefix :: Lens' CmafPackage (Maybe Text)
cmafPackage_segmentPrefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CmafPackage' {Maybe Text
segmentPrefix :: Maybe Text
$sel:segmentPrefix:CmafPackage' :: CmafPackage -> Maybe Text
segmentPrefix} -> Maybe Text
segmentPrefix) (\s :: CmafPackage
s@CmafPackage' {} Maybe Text
a -> CmafPackage
s {$sel:segmentPrefix:CmafPackage' :: Maybe Text
segmentPrefix = Maybe Text
a} :: CmafPackage)

-- | Undocumented member.
cmafPackage_streamSelection :: Lens.Lens' CmafPackage (Prelude.Maybe StreamSelection)
cmafPackage_streamSelection :: Lens' CmafPackage (Maybe StreamSelection)
cmafPackage_streamSelection = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\CmafPackage' {Maybe StreamSelection
streamSelection :: Maybe StreamSelection
$sel:streamSelection:CmafPackage' :: CmafPackage -> Maybe StreamSelection
streamSelection} -> Maybe StreamSelection
streamSelection) (\s :: CmafPackage
s@CmafPackage' {} Maybe StreamSelection
a -> CmafPackage
s {$sel:streamSelection:CmafPackage' :: Maybe StreamSelection
streamSelection = Maybe StreamSelection
a} :: CmafPackage)

instance Data.FromJSON CmafPackage where
  parseJSON :: Value -> Parser CmafPackage
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"CmafPackage"
      ( \Object
x ->
          Maybe CmafEncryption
-> Maybe [HlsManifest]
-> Maybe Int
-> Maybe Text
-> Maybe StreamSelection
-> CmafPackage
CmafPackage'
            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
"encryption")
            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
"hlsManifests" forall a. Parser (Maybe a) -> a -> Parser a
Data..!= forall a. Monoid a => a
Prelude.mempty)
            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
"segmentDurationSeconds")
            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
"segmentPrefix")
            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
"streamSelection")
      )

instance Prelude.Hashable CmafPackage where
  hashWithSalt :: Int -> CmafPackage -> Int
hashWithSalt Int
_salt CmafPackage' {Maybe Int
Maybe [HlsManifest]
Maybe Text
Maybe CmafEncryption
Maybe StreamSelection
streamSelection :: Maybe StreamSelection
segmentPrefix :: Maybe Text
segmentDurationSeconds :: Maybe Int
hlsManifests :: Maybe [HlsManifest]
encryption :: Maybe CmafEncryption
$sel:streamSelection:CmafPackage' :: CmafPackage -> Maybe StreamSelection
$sel:segmentPrefix:CmafPackage' :: CmafPackage -> Maybe Text
$sel:segmentDurationSeconds:CmafPackage' :: CmafPackage -> Maybe Int
$sel:hlsManifests:CmafPackage' :: CmafPackage -> Maybe [HlsManifest]
$sel:encryption:CmafPackage' :: CmafPackage -> Maybe CmafEncryption
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CmafEncryption
encryption
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [HlsManifest]
hlsManifests
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
segmentDurationSeconds
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
segmentPrefix
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe StreamSelection
streamSelection

instance Prelude.NFData CmafPackage where
  rnf :: CmafPackage -> ()
rnf CmafPackage' {Maybe Int
Maybe [HlsManifest]
Maybe Text
Maybe CmafEncryption
Maybe StreamSelection
streamSelection :: Maybe StreamSelection
segmentPrefix :: Maybe Text
segmentDurationSeconds :: Maybe Int
hlsManifests :: Maybe [HlsManifest]
encryption :: Maybe CmafEncryption
$sel:streamSelection:CmafPackage' :: CmafPackage -> Maybe StreamSelection
$sel:segmentPrefix:CmafPackage' :: CmafPackage -> Maybe Text
$sel:segmentDurationSeconds:CmafPackage' :: CmafPackage -> Maybe Int
$sel:hlsManifests:CmafPackage' :: CmafPackage -> Maybe [HlsManifest]
$sel:encryption:CmafPackage' :: CmafPackage -> Maybe CmafEncryption
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CmafEncryption
encryption
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [HlsManifest]
hlsManifests
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
segmentDurationSeconds
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
segmentPrefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe StreamSelection
streamSelection