{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module Network.AWS.MediaConvert.Types.Product where
import Network.AWS.Lens
import Network.AWS.MediaConvert.Types.Sum
import Network.AWS.Prelude
data AacSettings = AacSettings'
{ _assAudioDescriptionBroadcasterMix :: !(Maybe AacAudioDescriptionBroadcasterMix)
, _assRawFormat :: !(Maybe AacRawFormat)
, _assCodingMode :: !(Maybe AacCodingMode)
, _assRateControlMode :: !(Maybe AacRateControlMode)
, _assSampleRate :: !(Maybe Int)
, _assSpecification :: !(Maybe AacSpecification)
, _assCodecProfile :: !(Maybe AacCodecProfile)
, _assBitrate :: !(Maybe Int)
, _assVbrQuality :: !(Maybe AacVbrQuality)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
aacSettings
:: AacSettings
aacSettings =
AacSettings'
{ _assAudioDescriptionBroadcasterMix = Nothing
, _assRawFormat = Nothing
, _assCodingMode = Nothing
, _assRateControlMode = Nothing
, _assSampleRate = Nothing
, _assSpecification = Nothing
, _assCodecProfile = Nothing
, _assBitrate = Nothing
, _assVbrQuality = Nothing
}
assAudioDescriptionBroadcasterMix :: Lens' AacSettings (Maybe AacAudioDescriptionBroadcasterMix)
assAudioDescriptionBroadcasterMix = lens _assAudioDescriptionBroadcasterMix (\ s a -> s{_assAudioDescriptionBroadcasterMix = a})
assRawFormat :: Lens' AacSettings (Maybe AacRawFormat)
assRawFormat = lens _assRawFormat (\ s a -> s{_assRawFormat = a})
assCodingMode :: Lens' AacSettings (Maybe AacCodingMode)
assCodingMode = lens _assCodingMode (\ s a -> s{_assCodingMode = a})
assRateControlMode :: Lens' AacSettings (Maybe AacRateControlMode)
assRateControlMode = lens _assRateControlMode (\ s a -> s{_assRateControlMode = a})
assSampleRate :: Lens' AacSettings (Maybe Int)
assSampleRate = lens _assSampleRate (\ s a -> s{_assSampleRate = a})
assSpecification :: Lens' AacSettings (Maybe AacSpecification)
assSpecification = lens _assSpecification (\ s a -> s{_assSpecification = a})
assCodecProfile :: Lens' AacSettings (Maybe AacCodecProfile)
assCodecProfile = lens _assCodecProfile (\ s a -> s{_assCodecProfile = a})
assBitrate :: Lens' AacSettings (Maybe Int)
assBitrate = lens _assBitrate (\ s a -> s{_assBitrate = a})
assVbrQuality :: Lens' AacSettings (Maybe AacVbrQuality)
assVbrQuality = lens _assVbrQuality (\ s a -> s{_assVbrQuality = a})
instance FromJSON AacSettings where
parseJSON
= withObject "AacSettings"
(\ x ->
AacSettings' <$>
(x .:? "audioDescriptionBroadcasterMix") <*>
(x .:? "rawFormat")
<*> (x .:? "codingMode")
<*> (x .:? "rateControlMode")
<*> (x .:? "sampleRate")
<*> (x .:? "specification")
<*> (x .:? "codecProfile")
<*> (x .:? "bitrate")
<*> (x .:? "vbrQuality"))
instance Hashable AacSettings where
instance NFData AacSettings where
instance ToJSON AacSettings where
toJSON AacSettings'{..}
= object
(catMaybes
[("audioDescriptionBroadcasterMix" .=) <$>
_assAudioDescriptionBroadcasterMix,
("rawFormat" .=) <$> _assRawFormat,
("codingMode" .=) <$> _assCodingMode,
("rateControlMode" .=) <$> _assRateControlMode,
("sampleRate" .=) <$> _assSampleRate,
("specification" .=) <$> _assSpecification,
("codecProfile" .=) <$> _assCodecProfile,
("bitrate" .=) <$> _assBitrate,
("vbrQuality" .=) <$> _assVbrQuality])
data Ac3Settings = Ac3Settings'
{ _aLfeFilter :: !(Maybe Ac3LfeFilter)
, _aMetadataControl :: !(Maybe Ac3MetadataControl)
, _aBitstreamMode :: !(Maybe Ac3BitstreamMode)
, _aCodingMode :: !(Maybe Ac3CodingMode)
, _aSampleRate :: !(Maybe Int)
, _aDynamicRangeCompressionProfile :: !(Maybe Ac3DynamicRangeCompressionProfile)
, _aBitrate :: !(Maybe Int)
, _aDialnorm :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
ac3Settings
:: Ac3Settings
ac3Settings =
Ac3Settings'
{ _aLfeFilter = Nothing
, _aMetadataControl = Nothing
, _aBitstreamMode = Nothing
, _aCodingMode = Nothing
, _aSampleRate = Nothing
, _aDynamicRangeCompressionProfile = Nothing
, _aBitrate = Nothing
, _aDialnorm = Nothing
}
aLfeFilter :: Lens' Ac3Settings (Maybe Ac3LfeFilter)
aLfeFilter = lens _aLfeFilter (\ s a -> s{_aLfeFilter = a})
aMetadataControl :: Lens' Ac3Settings (Maybe Ac3MetadataControl)
aMetadataControl = lens _aMetadataControl (\ s a -> s{_aMetadataControl = a})
aBitstreamMode :: Lens' Ac3Settings (Maybe Ac3BitstreamMode)
aBitstreamMode = lens _aBitstreamMode (\ s a -> s{_aBitstreamMode = a})
aCodingMode :: Lens' Ac3Settings (Maybe Ac3CodingMode)
aCodingMode = lens _aCodingMode (\ s a -> s{_aCodingMode = a})
aSampleRate :: Lens' Ac3Settings (Maybe Int)
aSampleRate = lens _aSampleRate (\ s a -> s{_aSampleRate = a})
aDynamicRangeCompressionProfile :: Lens' Ac3Settings (Maybe Ac3DynamicRangeCompressionProfile)
aDynamicRangeCompressionProfile = lens _aDynamicRangeCompressionProfile (\ s a -> s{_aDynamicRangeCompressionProfile = a})
aBitrate :: Lens' Ac3Settings (Maybe Int)
aBitrate = lens _aBitrate (\ s a -> s{_aBitrate = a})
aDialnorm :: Lens' Ac3Settings (Maybe Int)
aDialnorm = lens _aDialnorm (\ s a -> s{_aDialnorm = a})
instance FromJSON Ac3Settings where
parseJSON
= withObject "Ac3Settings"
(\ x ->
Ac3Settings' <$>
(x .:? "lfeFilter") <*> (x .:? "metadataControl") <*>
(x .:? "bitstreamMode")
<*> (x .:? "codingMode")
<*> (x .:? "sampleRate")
<*> (x .:? "dynamicRangeCompressionProfile")
<*> (x .:? "bitrate")
<*> (x .:? "dialnorm"))
instance Hashable Ac3Settings where
instance NFData Ac3Settings where
instance ToJSON Ac3Settings where
toJSON Ac3Settings'{..}
= object
(catMaybes
[("lfeFilter" .=) <$> _aLfeFilter,
("metadataControl" .=) <$> _aMetadataControl,
("bitstreamMode" .=) <$> _aBitstreamMode,
("codingMode" .=) <$> _aCodingMode,
("sampleRate" .=) <$> _aSampleRate,
("dynamicRangeCompressionProfile" .=) <$>
_aDynamicRangeCompressionProfile,
("bitrate" .=) <$> _aBitrate,
("dialnorm" .=) <$> _aDialnorm])
data AiffSettings = AiffSettings'
{ _asBitDepth :: !(Maybe Int)
, _asChannels :: !(Maybe Int)
, _asSampleRate :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
aiffSettings
:: AiffSettings
aiffSettings =
AiffSettings'
{_asBitDepth = Nothing, _asChannels = Nothing, _asSampleRate = Nothing}
asBitDepth :: Lens' AiffSettings (Maybe Int)
asBitDepth = lens _asBitDepth (\ s a -> s{_asBitDepth = a})
asChannels :: Lens' AiffSettings (Maybe Int)
asChannels = lens _asChannels (\ s a -> s{_asChannels = a})
asSampleRate :: Lens' AiffSettings (Maybe Int)
asSampleRate = lens _asSampleRate (\ s a -> s{_asSampleRate = a})
instance FromJSON AiffSettings where
parseJSON
= withObject "AiffSettings"
(\ x ->
AiffSettings' <$>
(x .:? "bitDepth") <*> (x .:? "channels") <*>
(x .:? "sampleRate"))
instance Hashable AiffSettings where
instance NFData AiffSettings where
instance ToJSON AiffSettings where
toJSON AiffSettings'{..}
= object
(catMaybes
[("bitDepth" .=) <$> _asBitDepth,
("channels" .=) <$> _asChannels,
("sampleRate" .=) <$> _asSampleRate])
newtype AncillarySourceSettings = AncillarySourceSettings'
{ _assSourceAncillaryChannelNumber :: Maybe Int
} deriving (Eq, Read, Show, Data, Typeable, Generic)
ancillarySourceSettings
:: AncillarySourceSettings
ancillarySourceSettings =
AncillarySourceSettings' {_assSourceAncillaryChannelNumber = Nothing}
assSourceAncillaryChannelNumber :: Lens' AncillarySourceSettings (Maybe Int)
assSourceAncillaryChannelNumber = lens _assSourceAncillaryChannelNumber (\ s a -> s{_assSourceAncillaryChannelNumber = a})
instance FromJSON AncillarySourceSettings where
parseJSON
= withObject "AncillarySourceSettings"
(\ x ->
AncillarySourceSettings' <$>
(x .:? "sourceAncillaryChannelNumber"))
instance Hashable AncillarySourceSettings where
instance NFData AncillarySourceSettings where
instance ToJSON AncillarySourceSettings where
toJSON AncillarySourceSettings'{..}
= object
(catMaybes
[("sourceAncillaryChannelNumber" .=) <$>
_assSourceAncillaryChannelNumber])
data AudioCodecSettings = AudioCodecSettings'
{ _acsAiffSettings :: !(Maybe AiffSettings)
, _acsCodec :: !(Maybe AudioCodec)
, _acsAc3Settings :: !(Maybe Ac3Settings)
, _acsMp2Settings :: !(Maybe Mp2Settings)
, _acsWavSettings :: !(Maybe WavSettings)
, _acsAacSettings :: !(Maybe AacSettings)
, _acsEac3Settings :: !(Maybe Eac3Settings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
audioCodecSettings
:: AudioCodecSettings
audioCodecSettings =
AudioCodecSettings'
{ _acsAiffSettings = Nothing
, _acsCodec = Nothing
, _acsAc3Settings = Nothing
, _acsMp2Settings = Nothing
, _acsWavSettings = Nothing
, _acsAacSettings = Nothing
, _acsEac3Settings = Nothing
}
acsAiffSettings :: Lens' AudioCodecSettings (Maybe AiffSettings)
acsAiffSettings = lens _acsAiffSettings (\ s a -> s{_acsAiffSettings = a})
acsCodec :: Lens' AudioCodecSettings (Maybe AudioCodec)
acsCodec = lens _acsCodec (\ s a -> s{_acsCodec = a})
acsAc3Settings :: Lens' AudioCodecSettings (Maybe Ac3Settings)
acsAc3Settings = lens _acsAc3Settings (\ s a -> s{_acsAc3Settings = a})
acsMp2Settings :: Lens' AudioCodecSettings (Maybe Mp2Settings)
acsMp2Settings = lens _acsMp2Settings (\ s a -> s{_acsMp2Settings = a})
acsWavSettings :: Lens' AudioCodecSettings (Maybe WavSettings)
acsWavSettings = lens _acsWavSettings (\ s a -> s{_acsWavSettings = a})
acsAacSettings :: Lens' AudioCodecSettings (Maybe AacSettings)
acsAacSettings = lens _acsAacSettings (\ s a -> s{_acsAacSettings = a})
acsEac3Settings :: Lens' AudioCodecSettings (Maybe Eac3Settings)
acsEac3Settings = lens _acsEac3Settings (\ s a -> s{_acsEac3Settings = a})
instance FromJSON AudioCodecSettings where
parseJSON
= withObject "AudioCodecSettings"
(\ x ->
AudioCodecSettings' <$>
(x .:? "aiffSettings") <*> (x .:? "codec") <*>
(x .:? "ac3Settings")
<*> (x .:? "mp2Settings")
<*> (x .:? "wavSettings")
<*> (x .:? "aacSettings")
<*> (x .:? "eac3Settings"))
instance Hashable AudioCodecSettings where
instance NFData AudioCodecSettings where
instance ToJSON AudioCodecSettings where
toJSON AudioCodecSettings'{..}
= object
(catMaybes
[("aiffSettings" .=) <$> _acsAiffSettings,
("codec" .=) <$> _acsCodec,
("ac3Settings" .=) <$> _acsAc3Settings,
("mp2Settings" .=) <$> _acsMp2Settings,
("wavSettings" .=) <$> _acsWavSettings,
("aacSettings" .=) <$> _acsAacSettings,
("eac3Settings" .=) <$> _acsEac3Settings])
data AudioDescription = AudioDescription'
{ _adAudioSourceName :: !(Maybe Text)
, _adLanguageCode :: !(Maybe LanguageCode)
, _adAudioType :: !(Maybe Int)
, _adAudioNormalizationSettings :: !(Maybe AudioNormalizationSettings)
, _adLanguageCodeControl :: !(Maybe AudioLanguageCodeControl)
, _adCodecSettings :: !(Maybe AudioCodecSettings)
, _adStreamName :: !(Maybe Text)
, _adRemixSettings :: !(Maybe RemixSettings)
, _adAudioTypeControl :: !(Maybe AudioTypeControl)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
audioDescription
:: AudioDescription
audioDescription =
AudioDescription'
{ _adAudioSourceName = Nothing
, _adLanguageCode = Nothing
, _adAudioType = Nothing
, _adAudioNormalizationSettings = Nothing
, _adLanguageCodeControl = Nothing
, _adCodecSettings = Nothing
, _adStreamName = Nothing
, _adRemixSettings = Nothing
, _adAudioTypeControl = Nothing
}
adAudioSourceName :: Lens' AudioDescription (Maybe Text)
adAudioSourceName = lens _adAudioSourceName (\ s a -> s{_adAudioSourceName = a})
adLanguageCode :: Lens' AudioDescription (Maybe LanguageCode)
adLanguageCode = lens _adLanguageCode (\ s a -> s{_adLanguageCode = a})
adAudioType :: Lens' AudioDescription (Maybe Int)
adAudioType = lens _adAudioType (\ s a -> s{_adAudioType = a})
adAudioNormalizationSettings :: Lens' AudioDescription (Maybe AudioNormalizationSettings)
adAudioNormalizationSettings = lens _adAudioNormalizationSettings (\ s a -> s{_adAudioNormalizationSettings = a})
adLanguageCodeControl :: Lens' AudioDescription (Maybe AudioLanguageCodeControl)
adLanguageCodeControl = lens _adLanguageCodeControl (\ s a -> s{_adLanguageCodeControl = a})
adCodecSettings :: Lens' AudioDescription (Maybe AudioCodecSettings)
adCodecSettings = lens _adCodecSettings (\ s a -> s{_adCodecSettings = a})
adStreamName :: Lens' AudioDescription (Maybe Text)
adStreamName = lens _adStreamName (\ s a -> s{_adStreamName = a})
adRemixSettings :: Lens' AudioDescription (Maybe RemixSettings)
adRemixSettings = lens _adRemixSettings (\ s a -> s{_adRemixSettings = a})
adAudioTypeControl :: Lens' AudioDescription (Maybe AudioTypeControl)
adAudioTypeControl = lens _adAudioTypeControl (\ s a -> s{_adAudioTypeControl = a})
instance FromJSON AudioDescription where
parseJSON
= withObject "AudioDescription"
(\ x ->
AudioDescription' <$>
(x .:? "audioSourceName") <*> (x .:? "languageCode")
<*> (x .:? "audioType")
<*> (x .:? "audioNormalizationSettings")
<*> (x .:? "languageCodeControl")
<*> (x .:? "codecSettings")
<*> (x .:? "streamName")
<*> (x .:? "remixSettings")
<*> (x .:? "audioTypeControl"))
instance Hashable AudioDescription where
instance NFData AudioDescription where
instance ToJSON AudioDescription where
toJSON AudioDescription'{..}
= object
(catMaybes
[("audioSourceName" .=) <$> _adAudioSourceName,
("languageCode" .=) <$> _adLanguageCode,
("audioType" .=) <$> _adAudioType,
("audioNormalizationSettings" .=) <$>
_adAudioNormalizationSettings,
("languageCodeControl" .=) <$>
_adLanguageCodeControl,
("codecSettings" .=) <$> _adCodecSettings,
("streamName" .=) <$> _adStreamName,
("remixSettings" .=) <$> _adRemixSettings,
("audioTypeControl" .=) <$> _adAudioTypeControl])
data AudioNormalizationSettings = AudioNormalizationSettings'
{ _ansAlgorithmControl :: !(Maybe AudioNormalizationAlgorithmControl)
, _ansTargetLkfs :: !(Maybe Double)
, _ansPeakCalculation :: !(Maybe AudioNormalizationPeakCalculation)
, _ansCorrectionGateLevel :: !(Maybe Int)
, _ansAlgorithm :: !(Maybe AudioNormalizationAlgorithm)
, _ansLoudnessLogging :: !(Maybe AudioNormalizationLoudnessLogging)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
audioNormalizationSettings
:: AudioNormalizationSettings
audioNormalizationSettings =
AudioNormalizationSettings'
{ _ansAlgorithmControl = Nothing
, _ansTargetLkfs = Nothing
, _ansPeakCalculation = Nothing
, _ansCorrectionGateLevel = Nothing
, _ansAlgorithm = Nothing
, _ansLoudnessLogging = Nothing
}
ansAlgorithmControl :: Lens' AudioNormalizationSettings (Maybe AudioNormalizationAlgorithmControl)
ansAlgorithmControl = lens _ansAlgorithmControl (\ s a -> s{_ansAlgorithmControl = a})
ansTargetLkfs :: Lens' AudioNormalizationSettings (Maybe Double)
ansTargetLkfs = lens _ansTargetLkfs (\ s a -> s{_ansTargetLkfs = a})
ansPeakCalculation :: Lens' AudioNormalizationSettings (Maybe AudioNormalizationPeakCalculation)
ansPeakCalculation = lens _ansPeakCalculation (\ s a -> s{_ansPeakCalculation = a})
ansCorrectionGateLevel :: Lens' AudioNormalizationSettings (Maybe Int)
ansCorrectionGateLevel = lens _ansCorrectionGateLevel (\ s a -> s{_ansCorrectionGateLevel = a})
ansAlgorithm :: Lens' AudioNormalizationSettings (Maybe AudioNormalizationAlgorithm)
ansAlgorithm = lens _ansAlgorithm (\ s a -> s{_ansAlgorithm = a})
ansLoudnessLogging :: Lens' AudioNormalizationSettings (Maybe AudioNormalizationLoudnessLogging)
ansLoudnessLogging = lens _ansLoudnessLogging (\ s a -> s{_ansLoudnessLogging = a})
instance FromJSON AudioNormalizationSettings where
parseJSON
= withObject "AudioNormalizationSettings"
(\ x ->
AudioNormalizationSettings' <$>
(x .:? "algorithmControl") <*> (x .:? "targetLkfs")
<*> (x .:? "peakCalculation")
<*> (x .:? "correctionGateLevel")
<*> (x .:? "algorithm")
<*> (x .:? "loudnessLogging"))
instance Hashable AudioNormalizationSettings where
instance NFData AudioNormalizationSettings where
instance ToJSON AudioNormalizationSettings where
toJSON AudioNormalizationSettings'{..}
= object
(catMaybes
[("algorithmControl" .=) <$> _ansAlgorithmControl,
("targetLkfs" .=) <$> _ansTargetLkfs,
("peakCalculation" .=) <$> _ansPeakCalculation,
("correctionGateLevel" .=) <$>
_ansCorrectionGateLevel,
("algorithm" .=) <$> _ansAlgorithm,
("loudnessLogging" .=) <$> _ansLoudnessLogging])
data AudioSelector = AudioSelector'
{ _asTracks :: !(Maybe [Int])
, _asProgramSelection :: !(Maybe Int)
, _asLanguageCode :: !(Maybe LanguageCode)
, _asOffset :: !(Maybe Int)
, _asDefaultSelection :: !(Maybe AudioDefaultSelection)
, _asPids :: !(Maybe [Int])
, _asSelectorType :: !(Maybe AudioSelectorType)
, _asExternalAudioFileInput :: !(Maybe Text)
, _asRemixSettings :: !(Maybe RemixSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
audioSelector
:: AudioSelector
audioSelector =
AudioSelector'
{ _asTracks = Nothing
, _asProgramSelection = Nothing
, _asLanguageCode = Nothing
, _asOffset = Nothing
, _asDefaultSelection = Nothing
, _asPids = Nothing
, _asSelectorType = Nothing
, _asExternalAudioFileInput = Nothing
, _asRemixSettings = Nothing
}
asTracks :: Lens' AudioSelector [Int]
asTracks = lens _asTracks (\ s a -> s{_asTracks = a}) . _Default . _Coerce
asProgramSelection :: Lens' AudioSelector (Maybe Int)
asProgramSelection = lens _asProgramSelection (\ s a -> s{_asProgramSelection = a})
asLanguageCode :: Lens' AudioSelector (Maybe LanguageCode)
asLanguageCode = lens _asLanguageCode (\ s a -> s{_asLanguageCode = a})
asOffset :: Lens' AudioSelector (Maybe Int)
asOffset = lens _asOffset (\ s a -> s{_asOffset = a})
asDefaultSelection :: Lens' AudioSelector (Maybe AudioDefaultSelection)
asDefaultSelection = lens _asDefaultSelection (\ s a -> s{_asDefaultSelection = a})
asPids :: Lens' AudioSelector [Int]
asPids = lens _asPids (\ s a -> s{_asPids = a}) . _Default . _Coerce
asSelectorType :: Lens' AudioSelector (Maybe AudioSelectorType)
asSelectorType = lens _asSelectorType (\ s a -> s{_asSelectorType = a})
asExternalAudioFileInput :: Lens' AudioSelector (Maybe Text)
asExternalAudioFileInput = lens _asExternalAudioFileInput (\ s a -> s{_asExternalAudioFileInput = a})
asRemixSettings :: Lens' AudioSelector (Maybe RemixSettings)
asRemixSettings = lens _asRemixSettings (\ s a -> s{_asRemixSettings = a})
instance FromJSON AudioSelector where
parseJSON
= withObject "AudioSelector"
(\ x ->
AudioSelector' <$>
(x .:? "tracks" .!= mempty) <*>
(x .:? "programSelection")
<*> (x .:? "languageCode")
<*> (x .:? "offset")
<*> (x .:? "defaultSelection")
<*> (x .:? "pids" .!= mempty)
<*> (x .:? "selectorType")
<*> (x .:? "externalAudioFileInput")
<*> (x .:? "remixSettings"))
instance Hashable AudioSelector where
instance NFData AudioSelector where
instance ToJSON AudioSelector where
toJSON AudioSelector'{..}
= object
(catMaybes
[("tracks" .=) <$> _asTracks,
("programSelection" .=) <$> _asProgramSelection,
("languageCode" .=) <$> _asLanguageCode,
("offset" .=) <$> _asOffset,
("defaultSelection" .=) <$> _asDefaultSelection,
("pids" .=) <$> _asPids,
("selectorType" .=) <$> _asSelectorType,
("externalAudioFileInput" .=) <$>
_asExternalAudioFileInput,
("remixSettings" .=) <$> _asRemixSettings])
newtype AudioSelectorGroup = AudioSelectorGroup'
{ _asgAudioSelectorNames :: Maybe [Text]
} deriving (Eq, Read, Show, Data, Typeable, Generic)
audioSelectorGroup
:: AudioSelectorGroup
audioSelectorGroup = AudioSelectorGroup' {_asgAudioSelectorNames = Nothing}
asgAudioSelectorNames :: Lens' AudioSelectorGroup [Text]
asgAudioSelectorNames = lens _asgAudioSelectorNames (\ s a -> s{_asgAudioSelectorNames = a}) . _Default . _Coerce
instance FromJSON AudioSelectorGroup where
parseJSON
= withObject "AudioSelectorGroup"
(\ x ->
AudioSelectorGroup' <$>
(x .:? "audioSelectorNames" .!= mempty))
instance Hashable AudioSelectorGroup where
instance NFData AudioSelectorGroup where
instance ToJSON AudioSelectorGroup where
toJSON AudioSelectorGroup'{..}
= object
(catMaybes
[("audioSelectorNames" .=) <$>
_asgAudioSelectorNames])
newtype AvailBlanking = AvailBlanking'
{ _abAvailBlankingImage :: Maybe Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
availBlanking
:: AvailBlanking
availBlanking = AvailBlanking' {_abAvailBlankingImage = Nothing}
abAvailBlankingImage :: Lens' AvailBlanking (Maybe Text)
abAvailBlankingImage = lens _abAvailBlankingImage (\ s a -> s{_abAvailBlankingImage = a})
instance FromJSON AvailBlanking where
parseJSON
= withObject "AvailBlanking"
(\ x ->
AvailBlanking' <$> (x .:? "availBlankingImage"))
instance Hashable AvailBlanking where
instance NFData AvailBlanking where
instance ToJSON AvailBlanking where
toJSON AvailBlanking'{..}
= object
(catMaybes
[("availBlankingImage" .=) <$>
_abAvailBlankingImage])
data BurninDestinationSettings = BurninDestinationSettings'
{ _bdsBackgroundOpacity :: !(Maybe Int)
, _bdsFontOpacity :: !(Maybe Int)
, _bdsShadowYOffset :: !(Maybe Int)
, _bdsFontResolution :: !(Maybe Int)
, _bdsYPosition :: !(Maybe Int)
, _bdsBackgroundColor :: !(Maybe BurninSubtitleBackgroundColor)
, _bdsShadowXOffset :: !(Maybe Int)
, _bdsFontSize :: !(Maybe Int)
, _bdsXPosition :: !(Maybe Int)
, _bdsTeletextSpacing :: !(Maybe BurninSubtitleTeletextSpacing)
, _bdsAlignment :: !(Maybe BurninSubtitleAlignment)
, _bdsShadowOpacity :: !(Maybe Int)
, _bdsOutlineColor :: !(Maybe BurninSubtitleOutlineColor)
, _bdsOutlineSize :: !(Maybe Int)
, _bdsShadowColor :: !(Maybe BurninSubtitleShadowColor)
, _bdsFontColor :: !(Maybe BurninSubtitleFontColor)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
burninDestinationSettings
:: BurninDestinationSettings
burninDestinationSettings =
BurninDestinationSettings'
{ _bdsBackgroundOpacity = Nothing
, _bdsFontOpacity = Nothing
, _bdsShadowYOffset = Nothing
, _bdsFontResolution = Nothing
, _bdsYPosition = Nothing
, _bdsBackgroundColor = Nothing
, _bdsShadowXOffset = Nothing
, _bdsFontSize = Nothing
, _bdsXPosition = Nothing
, _bdsTeletextSpacing = Nothing
, _bdsAlignment = Nothing
, _bdsShadowOpacity = Nothing
, _bdsOutlineColor = Nothing
, _bdsOutlineSize = Nothing
, _bdsShadowColor = Nothing
, _bdsFontColor = Nothing
}
bdsBackgroundOpacity :: Lens' BurninDestinationSettings (Maybe Int)
bdsBackgroundOpacity = lens _bdsBackgroundOpacity (\ s a -> s{_bdsBackgroundOpacity = a})
bdsFontOpacity :: Lens' BurninDestinationSettings (Maybe Int)
bdsFontOpacity = lens _bdsFontOpacity (\ s a -> s{_bdsFontOpacity = a})
bdsShadowYOffset :: Lens' BurninDestinationSettings (Maybe Int)
bdsShadowYOffset = lens _bdsShadowYOffset (\ s a -> s{_bdsShadowYOffset = a})
bdsFontResolution :: Lens' BurninDestinationSettings (Maybe Int)
bdsFontResolution = lens _bdsFontResolution (\ s a -> s{_bdsFontResolution = a})
bdsYPosition :: Lens' BurninDestinationSettings (Maybe Int)
bdsYPosition = lens _bdsYPosition (\ s a -> s{_bdsYPosition = a})
bdsBackgroundColor :: Lens' BurninDestinationSettings (Maybe BurninSubtitleBackgroundColor)
bdsBackgroundColor = lens _bdsBackgroundColor (\ s a -> s{_bdsBackgroundColor = a})
bdsShadowXOffset :: Lens' BurninDestinationSettings (Maybe Int)
bdsShadowXOffset = lens _bdsShadowXOffset (\ s a -> s{_bdsShadowXOffset = a})
bdsFontSize :: Lens' BurninDestinationSettings (Maybe Int)
bdsFontSize = lens _bdsFontSize (\ s a -> s{_bdsFontSize = a})
bdsXPosition :: Lens' BurninDestinationSettings (Maybe Int)
bdsXPosition = lens _bdsXPosition (\ s a -> s{_bdsXPosition = a})
bdsTeletextSpacing :: Lens' BurninDestinationSettings (Maybe BurninSubtitleTeletextSpacing)
bdsTeletextSpacing = lens _bdsTeletextSpacing (\ s a -> s{_bdsTeletextSpacing = a})
bdsAlignment :: Lens' BurninDestinationSettings (Maybe BurninSubtitleAlignment)
bdsAlignment = lens _bdsAlignment (\ s a -> s{_bdsAlignment = a})
bdsShadowOpacity :: Lens' BurninDestinationSettings (Maybe Int)
bdsShadowOpacity = lens _bdsShadowOpacity (\ s a -> s{_bdsShadowOpacity = a})
bdsOutlineColor :: Lens' BurninDestinationSettings (Maybe BurninSubtitleOutlineColor)
bdsOutlineColor = lens _bdsOutlineColor (\ s a -> s{_bdsOutlineColor = a})
bdsOutlineSize :: Lens' BurninDestinationSettings (Maybe Int)
bdsOutlineSize = lens _bdsOutlineSize (\ s a -> s{_bdsOutlineSize = a})
bdsShadowColor :: Lens' BurninDestinationSettings (Maybe BurninSubtitleShadowColor)
bdsShadowColor = lens _bdsShadowColor (\ s a -> s{_bdsShadowColor = a})
bdsFontColor :: Lens' BurninDestinationSettings (Maybe BurninSubtitleFontColor)
bdsFontColor = lens _bdsFontColor (\ s a -> s{_bdsFontColor = a})
instance FromJSON BurninDestinationSettings where
parseJSON
= withObject "BurninDestinationSettings"
(\ x ->
BurninDestinationSettings' <$>
(x .:? "backgroundOpacity") <*> (x .:? "fontOpacity")
<*> (x .:? "shadowYOffset")
<*> (x .:? "fontResolution")
<*> (x .:? "yPosition")
<*> (x .:? "backgroundColor")
<*> (x .:? "shadowXOffset")
<*> (x .:? "fontSize")
<*> (x .:? "xPosition")
<*> (x .:? "teletextSpacing")
<*> (x .:? "alignment")
<*> (x .:? "shadowOpacity")
<*> (x .:? "outlineColor")
<*> (x .:? "outlineSize")
<*> (x .:? "shadowColor")
<*> (x .:? "fontColor"))
instance Hashable BurninDestinationSettings where
instance NFData BurninDestinationSettings where
instance ToJSON BurninDestinationSettings where
toJSON BurninDestinationSettings'{..}
= object
(catMaybes
[("backgroundOpacity" .=) <$> _bdsBackgroundOpacity,
("fontOpacity" .=) <$> _bdsFontOpacity,
("shadowYOffset" .=) <$> _bdsShadowYOffset,
("fontResolution" .=) <$> _bdsFontResolution,
("yPosition" .=) <$> _bdsYPosition,
("backgroundColor" .=) <$> _bdsBackgroundColor,
("shadowXOffset" .=) <$> _bdsShadowXOffset,
("fontSize" .=) <$> _bdsFontSize,
("xPosition" .=) <$> _bdsXPosition,
("teletextSpacing" .=) <$> _bdsTeletextSpacing,
("alignment" .=) <$> _bdsAlignment,
("shadowOpacity" .=) <$> _bdsShadowOpacity,
("outlineColor" .=) <$> _bdsOutlineColor,
("outlineSize" .=) <$> _bdsOutlineSize,
("shadowColor" .=) <$> _bdsShadowColor,
("fontColor" .=) <$> _bdsFontColor])
data CaptionDescription = CaptionDescription'
{ _cdCaptionSelectorName :: !(Maybe Text)
, _cdLanguageCode :: !(Maybe LanguageCode)
, _cdDestinationSettings :: !(Maybe CaptionDestinationSettings)
, _cdLanguageDescription :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
captionDescription
:: CaptionDescription
captionDescription =
CaptionDescription'
{ _cdCaptionSelectorName = Nothing
, _cdLanguageCode = Nothing
, _cdDestinationSettings = Nothing
, _cdLanguageDescription = Nothing
}
cdCaptionSelectorName :: Lens' CaptionDescription (Maybe Text)
cdCaptionSelectorName = lens _cdCaptionSelectorName (\ s a -> s{_cdCaptionSelectorName = a})
cdLanguageCode :: Lens' CaptionDescription (Maybe LanguageCode)
cdLanguageCode = lens _cdLanguageCode (\ s a -> s{_cdLanguageCode = a})
cdDestinationSettings :: Lens' CaptionDescription (Maybe CaptionDestinationSettings)
cdDestinationSettings = lens _cdDestinationSettings (\ s a -> s{_cdDestinationSettings = a})
cdLanguageDescription :: Lens' CaptionDescription (Maybe Text)
cdLanguageDescription = lens _cdLanguageDescription (\ s a -> s{_cdLanguageDescription = a})
instance FromJSON CaptionDescription where
parseJSON
= withObject "CaptionDescription"
(\ x ->
CaptionDescription' <$>
(x .:? "captionSelectorName") <*>
(x .:? "languageCode")
<*> (x .:? "destinationSettings")
<*> (x .:? "languageDescription"))
instance Hashable CaptionDescription where
instance NFData CaptionDescription where
instance ToJSON CaptionDescription where
toJSON CaptionDescription'{..}
= object
(catMaybes
[("captionSelectorName" .=) <$>
_cdCaptionSelectorName,
("languageCode" .=) <$> _cdLanguageCode,
("destinationSettings" .=) <$>
_cdDestinationSettings,
("languageDescription" .=) <$>
_cdLanguageDescription])
data CaptionDescriptionPreset = CaptionDescriptionPreset'
{ _cdpLanguageCode :: !(Maybe LanguageCode)
, _cdpDestinationSettings :: !(Maybe CaptionDestinationSettings)
, _cdpLanguageDescription :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
captionDescriptionPreset
:: CaptionDescriptionPreset
captionDescriptionPreset =
CaptionDescriptionPreset'
{ _cdpLanguageCode = Nothing
, _cdpDestinationSettings = Nothing
, _cdpLanguageDescription = Nothing
}
cdpLanguageCode :: Lens' CaptionDescriptionPreset (Maybe LanguageCode)
cdpLanguageCode = lens _cdpLanguageCode (\ s a -> s{_cdpLanguageCode = a})
cdpDestinationSettings :: Lens' CaptionDescriptionPreset (Maybe CaptionDestinationSettings)
cdpDestinationSettings = lens _cdpDestinationSettings (\ s a -> s{_cdpDestinationSettings = a})
cdpLanguageDescription :: Lens' CaptionDescriptionPreset (Maybe Text)
cdpLanguageDescription = lens _cdpLanguageDescription (\ s a -> s{_cdpLanguageDescription = a})
instance FromJSON CaptionDescriptionPreset where
parseJSON
= withObject "CaptionDescriptionPreset"
(\ x ->
CaptionDescriptionPreset' <$>
(x .:? "languageCode") <*>
(x .:? "destinationSettings")
<*> (x .:? "languageDescription"))
instance Hashable CaptionDescriptionPreset where
instance NFData CaptionDescriptionPreset where
instance ToJSON CaptionDescriptionPreset where
toJSON CaptionDescriptionPreset'{..}
= object
(catMaybes
[("languageCode" .=) <$> _cdpLanguageCode,
("destinationSettings" .=) <$>
_cdpDestinationSettings,
("languageDescription" .=) <$>
_cdpLanguageDescription])
data CaptionDestinationSettings = CaptionDestinationSettings'
{ _cdsTeletextDestinationSettings :: !(Maybe TeletextDestinationSettings)
, _cdsDvbSubDestinationSettings :: !(Maybe DvbSubDestinationSettings)
, _cdsTtmlDestinationSettings :: !(Maybe TtmlDestinationSettings)
, _cdsDestinationType :: !(Maybe CaptionDestinationType)
, _cdsSccDestinationSettings :: !(Maybe SccDestinationSettings)
, _cdsBurninDestinationSettings :: !(Maybe BurninDestinationSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
captionDestinationSettings
:: CaptionDestinationSettings
captionDestinationSettings =
CaptionDestinationSettings'
{ _cdsTeletextDestinationSettings = Nothing
, _cdsDvbSubDestinationSettings = Nothing
, _cdsTtmlDestinationSettings = Nothing
, _cdsDestinationType = Nothing
, _cdsSccDestinationSettings = Nothing
, _cdsBurninDestinationSettings = Nothing
}
cdsTeletextDestinationSettings :: Lens' CaptionDestinationSettings (Maybe TeletextDestinationSettings)
cdsTeletextDestinationSettings = lens _cdsTeletextDestinationSettings (\ s a -> s{_cdsTeletextDestinationSettings = a})
cdsDvbSubDestinationSettings :: Lens' CaptionDestinationSettings (Maybe DvbSubDestinationSettings)
cdsDvbSubDestinationSettings = lens _cdsDvbSubDestinationSettings (\ s a -> s{_cdsDvbSubDestinationSettings = a})
cdsTtmlDestinationSettings :: Lens' CaptionDestinationSettings (Maybe TtmlDestinationSettings)
cdsTtmlDestinationSettings = lens _cdsTtmlDestinationSettings (\ s a -> s{_cdsTtmlDestinationSettings = a})
cdsDestinationType :: Lens' CaptionDestinationSettings (Maybe CaptionDestinationType)
cdsDestinationType = lens _cdsDestinationType (\ s a -> s{_cdsDestinationType = a})
cdsSccDestinationSettings :: Lens' CaptionDestinationSettings (Maybe SccDestinationSettings)
cdsSccDestinationSettings = lens _cdsSccDestinationSettings (\ s a -> s{_cdsSccDestinationSettings = a})
cdsBurninDestinationSettings :: Lens' CaptionDestinationSettings (Maybe BurninDestinationSettings)
cdsBurninDestinationSettings = lens _cdsBurninDestinationSettings (\ s a -> s{_cdsBurninDestinationSettings = a})
instance FromJSON CaptionDestinationSettings where
parseJSON
= withObject "CaptionDestinationSettings"
(\ x ->
CaptionDestinationSettings' <$>
(x .:? "teletextDestinationSettings") <*>
(x .:? "dvbSubDestinationSettings")
<*> (x .:? "ttmlDestinationSettings")
<*> (x .:? "destinationType")
<*> (x .:? "sccDestinationSettings")
<*> (x .:? "burninDestinationSettings"))
instance Hashable CaptionDestinationSettings where
instance NFData CaptionDestinationSettings where
instance ToJSON CaptionDestinationSettings where
toJSON CaptionDestinationSettings'{..}
= object
(catMaybes
[("teletextDestinationSettings" .=) <$>
_cdsTeletextDestinationSettings,
("dvbSubDestinationSettings" .=) <$>
_cdsDvbSubDestinationSettings,
("ttmlDestinationSettings" .=) <$>
_cdsTtmlDestinationSettings,
("destinationType" .=) <$> _cdsDestinationType,
("sccDestinationSettings" .=) <$>
_cdsSccDestinationSettings,
("burninDestinationSettings" .=) <$>
_cdsBurninDestinationSettings])
data CaptionSelector = CaptionSelector'
{ _csLanguageCode :: !(Maybe LanguageCode)
, _csSourceSettings :: !(Maybe CaptionSourceSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
captionSelector
:: CaptionSelector
captionSelector =
CaptionSelector' {_csLanguageCode = Nothing, _csSourceSettings = Nothing}
csLanguageCode :: Lens' CaptionSelector (Maybe LanguageCode)
csLanguageCode = lens _csLanguageCode (\ s a -> s{_csLanguageCode = a})
csSourceSettings :: Lens' CaptionSelector (Maybe CaptionSourceSettings)
csSourceSettings = lens _csSourceSettings (\ s a -> s{_csSourceSettings = a})
instance FromJSON CaptionSelector where
parseJSON
= withObject "CaptionSelector"
(\ x ->
CaptionSelector' <$>
(x .:? "languageCode") <*> (x .:? "sourceSettings"))
instance Hashable CaptionSelector where
instance NFData CaptionSelector where
instance ToJSON CaptionSelector where
toJSON CaptionSelector'{..}
= object
(catMaybes
[("languageCode" .=) <$> _csLanguageCode,
("sourceSettings" .=) <$> _csSourceSettings])
data CaptionSourceSettings = CaptionSourceSettings'
{ _cssTeletextSourceSettings :: !(Maybe TeletextSourceSettings)
, _cssSourceType :: !(Maybe CaptionSourceType)
, _cssFileSourceSettings :: !(Maybe FileSourceSettings)
, _cssDvbSubSourceSettings :: !(Maybe DvbSubSourceSettings)
, _cssAncillarySourceSettings :: !(Maybe AncillarySourceSettings)
, _cssEmbeddedSourceSettings :: !(Maybe EmbeddedSourceSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
captionSourceSettings
:: CaptionSourceSettings
captionSourceSettings =
CaptionSourceSettings'
{ _cssTeletextSourceSettings = Nothing
, _cssSourceType = Nothing
, _cssFileSourceSettings = Nothing
, _cssDvbSubSourceSettings = Nothing
, _cssAncillarySourceSettings = Nothing
, _cssEmbeddedSourceSettings = Nothing
}
cssTeletextSourceSettings :: Lens' CaptionSourceSettings (Maybe TeletextSourceSettings)
cssTeletextSourceSettings = lens _cssTeletextSourceSettings (\ s a -> s{_cssTeletextSourceSettings = a})
cssSourceType :: Lens' CaptionSourceSettings (Maybe CaptionSourceType)
cssSourceType = lens _cssSourceType (\ s a -> s{_cssSourceType = a})
cssFileSourceSettings :: Lens' CaptionSourceSettings (Maybe FileSourceSettings)
cssFileSourceSettings = lens _cssFileSourceSettings (\ s a -> s{_cssFileSourceSettings = a})
cssDvbSubSourceSettings :: Lens' CaptionSourceSettings (Maybe DvbSubSourceSettings)
cssDvbSubSourceSettings = lens _cssDvbSubSourceSettings (\ s a -> s{_cssDvbSubSourceSettings = a})
cssAncillarySourceSettings :: Lens' CaptionSourceSettings (Maybe AncillarySourceSettings)
cssAncillarySourceSettings = lens _cssAncillarySourceSettings (\ s a -> s{_cssAncillarySourceSettings = a})
cssEmbeddedSourceSettings :: Lens' CaptionSourceSettings (Maybe EmbeddedSourceSettings)
cssEmbeddedSourceSettings = lens _cssEmbeddedSourceSettings (\ s a -> s{_cssEmbeddedSourceSettings = a})
instance FromJSON CaptionSourceSettings where
parseJSON
= withObject "CaptionSourceSettings"
(\ x ->
CaptionSourceSettings' <$>
(x .:? "teletextSourceSettings") <*>
(x .:? "sourceType")
<*> (x .:? "fileSourceSettings")
<*> (x .:? "dvbSubSourceSettings")
<*> (x .:? "ancillarySourceSettings")
<*> (x .:? "embeddedSourceSettings"))
instance Hashable CaptionSourceSettings where
instance NFData CaptionSourceSettings where
instance ToJSON CaptionSourceSettings where
toJSON CaptionSourceSettings'{..}
= object
(catMaybes
[("teletextSourceSettings" .=) <$>
_cssTeletextSourceSettings,
("sourceType" .=) <$> _cssSourceType,
("fileSourceSettings" .=) <$> _cssFileSourceSettings,
("dvbSubSourceSettings" .=) <$>
_cssDvbSubSourceSettings,
("ancillarySourceSettings" .=) <$>
_cssAncillarySourceSettings,
("embeddedSourceSettings" .=) <$>
_cssEmbeddedSourceSettings])
newtype ChannelMapping = ChannelMapping'
{ _cmOutputChannels :: Maybe [OutputChannelMapping]
} deriving (Eq, Read, Show, Data, Typeable, Generic)
channelMapping
:: ChannelMapping
channelMapping = ChannelMapping' {_cmOutputChannels = Nothing}
cmOutputChannels :: Lens' ChannelMapping [OutputChannelMapping]
cmOutputChannels = lens _cmOutputChannels (\ s a -> s{_cmOutputChannels = a}) . _Default . _Coerce
instance FromJSON ChannelMapping where
parseJSON
= withObject "ChannelMapping"
(\ x ->
ChannelMapping' <$>
(x .:? "outputChannels" .!= mempty))
instance Hashable ChannelMapping where
instance NFData ChannelMapping where
instance ToJSON ChannelMapping where
toJSON ChannelMapping'{..}
= object
(catMaybes
[("outputChannels" .=) <$> _cmOutputChannels])
data ColorCorrector = ColorCorrector'
{ _ccSaturation :: !(Maybe Int)
, _ccHue :: !(Maybe Int)
, _ccColorSpaceConversion :: !(Maybe ColorSpaceConversion)
, _ccHdr10Metadata :: !(Maybe Hdr10Metadata)
, _ccContrast :: !(Maybe Int)
, _ccBrightness :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
colorCorrector
:: ColorCorrector
colorCorrector =
ColorCorrector'
{ _ccSaturation = Nothing
, _ccHue = Nothing
, _ccColorSpaceConversion = Nothing
, _ccHdr10Metadata = Nothing
, _ccContrast = Nothing
, _ccBrightness = Nothing
}
ccSaturation :: Lens' ColorCorrector (Maybe Int)
ccSaturation = lens _ccSaturation (\ s a -> s{_ccSaturation = a})
ccHue :: Lens' ColorCorrector (Maybe Int)
ccHue = lens _ccHue (\ s a -> s{_ccHue = a})
ccColorSpaceConversion :: Lens' ColorCorrector (Maybe ColorSpaceConversion)
ccColorSpaceConversion = lens _ccColorSpaceConversion (\ s a -> s{_ccColorSpaceConversion = a})
ccHdr10Metadata :: Lens' ColorCorrector (Maybe Hdr10Metadata)
ccHdr10Metadata = lens _ccHdr10Metadata (\ s a -> s{_ccHdr10Metadata = a})
ccContrast :: Lens' ColorCorrector (Maybe Int)
ccContrast = lens _ccContrast (\ s a -> s{_ccContrast = a})
ccBrightness :: Lens' ColorCorrector (Maybe Int)
ccBrightness = lens _ccBrightness (\ s a -> s{_ccBrightness = a})
instance FromJSON ColorCorrector where
parseJSON
= withObject "ColorCorrector"
(\ x ->
ColorCorrector' <$>
(x .:? "saturation") <*> (x .:? "hue") <*>
(x .:? "colorSpaceConversion")
<*> (x .:? "hdr10Metadata")
<*> (x .:? "contrast")
<*> (x .:? "brightness"))
instance Hashable ColorCorrector where
instance NFData ColorCorrector where
instance ToJSON ColorCorrector where
toJSON ColorCorrector'{..}
= object
(catMaybes
[("saturation" .=) <$> _ccSaturation,
("hue" .=) <$> _ccHue,
("colorSpaceConversion" .=) <$>
_ccColorSpaceConversion,
("hdr10Metadata" .=) <$> _ccHdr10Metadata,
("contrast" .=) <$> _ccContrast,
("brightness" .=) <$> _ccBrightness])
data ContainerSettings = ContainerSettings'
{ _csM2tsSettings :: !(Maybe M2tsSettings)
, _csM3u8Settings :: !(Maybe M3u8Settings)
, _csMovSettings :: !(Maybe MovSettings)
, _csMp4Settings :: !(Maybe Mp4Settings)
, _csContainer :: !(Maybe ContainerType)
, _csF4vSettings :: !(Maybe F4vSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
containerSettings
:: ContainerSettings
containerSettings =
ContainerSettings'
{ _csM2tsSettings = Nothing
, _csM3u8Settings = Nothing
, _csMovSettings = Nothing
, _csMp4Settings = Nothing
, _csContainer = Nothing
, _csF4vSettings = Nothing
}
csM2tsSettings :: Lens' ContainerSettings (Maybe M2tsSettings)
csM2tsSettings = lens _csM2tsSettings (\ s a -> s{_csM2tsSettings = a})
csM3u8Settings :: Lens' ContainerSettings (Maybe M3u8Settings)
csM3u8Settings = lens _csM3u8Settings (\ s a -> s{_csM3u8Settings = a})
csMovSettings :: Lens' ContainerSettings (Maybe MovSettings)
csMovSettings = lens _csMovSettings (\ s a -> s{_csMovSettings = a})
csMp4Settings :: Lens' ContainerSettings (Maybe Mp4Settings)
csMp4Settings = lens _csMp4Settings (\ s a -> s{_csMp4Settings = a})
csContainer :: Lens' ContainerSettings (Maybe ContainerType)
csContainer = lens _csContainer (\ s a -> s{_csContainer = a})
csF4vSettings :: Lens' ContainerSettings (Maybe F4vSettings)
csF4vSettings = lens _csF4vSettings (\ s a -> s{_csF4vSettings = a})
instance FromJSON ContainerSettings where
parseJSON
= withObject "ContainerSettings"
(\ x ->
ContainerSettings' <$>
(x .:? "m2tsSettings") <*> (x .:? "m3u8Settings") <*>
(x .:? "movSettings")
<*> (x .:? "mp4Settings")
<*> (x .:? "container")
<*> (x .:? "f4vSettings"))
instance Hashable ContainerSettings where
instance NFData ContainerSettings where
instance ToJSON ContainerSettings where
toJSON ContainerSettings'{..}
= object
(catMaybes
[("m2tsSettings" .=) <$> _csM2tsSettings,
("m3u8Settings" .=) <$> _csM3u8Settings,
("movSettings" .=) <$> _csMovSettings,
("mp4Settings" .=) <$> _csMp4Settings,
("container" .=) <$> _csContainer,
("f4vSettings" .=) <$> _csF4vSettings])
newtype DashIsoEncryptionSettings = DashIsoEncryptionSettings'
{ _diesSpekeKeyProvider :: Maybe SpekeKeyProvider
} deriving (Eq, Read, Show, Data, Typeable, Generic)
dashIsoEncryptionSettings
:: DashIsoEncryptionSettings
dashIsoEncryptionSettings =
DashIsoEncryptionSettings' {_diesSpekeKeyProvider = Nothing}
diesSpekeKeyProvider :: Lens' DashIsoEncryptionSettings (Maybe SpekeKeyProvider)
diesSpekeKeyProvider = lens _diesSpekeKeyProvider (\ s a -> s{_diesSpekeKeyProvider = a})
instance FromJSON DashIsoEncryptionSettings where
parseJSON
= withObject "DashIsoEncryptionSettings"
(\ x ->
DashIsoEncryptionSettings' <$>
(x .:? "spekeKeyProvider"))
instance Hashable DashIsoEncryptionSettings where
instance NFData DashIsoEncryptionSettings where
instance ToJSON DashIsoEncryptionSettings where
toJSON DashIsoEncryptionSettings'{..}
= object
(catMaybes
[("spekeKeyProvider" .=) <$> _diesSpekeKeyProvider])
data DashIsoGroupSettings = DashIsoGroupSettings'
{ _digsFragmentLength :: !(Maybe Int)
, _digsSegmentControl :: !(Maybe DashIsoSegmentControl)
, _digsDestination :: !(Maybe Text)
, _digsHbbtvCompliance :: !(Maybe DashIsoHbbtvCompliance)
, _digsMinBufferTime :: !(Maybe Int)
, _digsBaseURL :: !(Maybe Text)
, _digsEncryption :: !(Maybe DashIsoEncryptionSettings)
, _digsSegmentLength :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
dashIsoGroupSettings
:: DashIsoGroupSettings
dashIsoGroupSettings =
DashIsoGroupSettings'
{ _digsFragmentLength = Nothing
, _digsSegmentControl = Nothing
, _digsDestination = Nothing
, _digsHbbtvCompliance = Nothing
, _digsMinBufferTime = Nothing
, _digsBaseURL = Nothing
, _digsEncryption = Nothing
, _digsSegmentLength = Nothing
}
digsFragmentLength :: Lens' DashIsoGroupSettings (Maybe Int)
digsFragmentLength = lens _digsFragmentLength (\ s a -> s{_digsFragmentLength = a})
digsSegmentControl :: Lens' DashIsoGroupSettings (Maybe DashIsoSegmentControl)
digsSegmentControl = lens _digsSegmentControl (\ s a -> s{_digsSegmentControl = a})
digsDestination :: Lens' DashIsoGroupSettings (Maybe Text)
digsDestination = lens _digsDestination (\ s a -> s{_digsDestination = a})
digsHbbtvCompliance :: Lens' DashIsoGroupSettings (Maybe DashIsoHbbtvCompliance)
digsHbbtvCompliance = lens _digsHbbtvCompliance (\ s a -> s{_digsHbbtvCompliance = a})
digsMinBufferTime :: Lens' DashIsoGroupSettings (Maybe Int)
digsMinBufferTime = lens _digsMinBufferTime (\ s a -> s{_digsMinBufferTime = a})
digsBaseURL :: Lens' DashIsoGroupSettings (Maybe Text)
digsBaseURL = lens _digsBaseURL (\ s a -> s{_digsBaseURL = a})
digsEncryption :: Lens' DashIsoGroupSettings (Maybe DashIsoEncryptionSettings)
digsEncryption = lens _digsEncryption (\ s a -> s{_digsEncryption = a})
digsSegmentLength :: Lens' DashIsoGroupSettings (Maybe Int)
digsSegmentLength = lens _digsSegmentLength (\ s a -> s{_digsSegmentLength = a})
instance FromJSON DashIsoGroupSettings where
parseJSON
= withObject "DashIsoGroupSettings"
(\ x ->
DashIsoGroupSettings' <$>
(x .:? "fragmentLength") <*> (x .:? "segmentControl")
<*> (x .:? "destination")
<*> (x .:? "hbbtvCompliance")
<*> (x .:? "minBufferTime")
<*> (x .:? "baseUrl")
<*> (x .:? "encryption")
<*> (x .:? "segmentLength"))
instance Hashable DashIsoGroupSettings where
instance NFData DashIsoGroupSettings where
instance ToJSON DashIsoGroupSettings where
toJSON DashIsoGroupSettings'{..}
= object
(catMaybes
[("fragmentLength" .=) <$> _digsFragmentLength,
("segmentControl" .=) <$> _digsSegmentControl,
("destination" .=) <$> _digsDestination,
("hbbtvCompliance" .=) <$> _digsHbbtvCompliance,
("minBufferTime" .=) <$> _digsMinBufferTime,
("baseUrl" .=) <$> _digsBaseURL,
("encryption" .=) <$> _digsEncryption,
("segmentLength" .=) <$> _digsSegmentLength])
data Deinterlacer = Deinterlacer'
{ _dControl :: !(Maybe DeinterlacerControl)
, _dMode :: !(Maybe DeinterlacerMode)
, _dAlgorithm :: !(Maybe DeinterlaceAlgorithm)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
deinterlacer
:: Deinterlacer
deinterlacer =
Deinterlacer' {_dControl = Nothing, _dMode = Nothing, _dAlgorithm = Nothing}
dControl :: Lens' Deinterlacer (Maybe DeinterlacerControl)
dControl = lens _dControl (\ s a -> s{_dControl = a})
dMode :: Lens' Deinterlacer (Maybe DeinterlacerMode)
dMode = lens _dMode (\ s a -> s{_dMode = a})
dAlgorithm :: Lens' Deinterlacer (Maybe DeinterlaceAlgorithm)
dAlgorithm = lens _dAlgorithm (\ s a -> s{_dAlgorithm = a})
instance FromJSON Deinterlacer where
parseJSON
= withObject "Deinterlacer"
(\ x ->
Deinterlacer' <$>
(x .:? "control") <*> (x .:? "mode") <*>
(x .:? "algorithm"))
instance Hashable Deinterlacer where
instance NFData Deinterlacer where
instance ToJSON Deinterlacer where
toJSON Deinterlacer'{..}
= object
(catMaybes
[("control" .=) <$> _dControl,
("mode" .=) <$> _dMode,
("algorithm" .=) <$> _dAlgorithm])
data DvbNitSettings = DvbNitSettings'
{ _dnsNetworkId :: !(Maybe Int)
, _dnsNetworkName :: !(Maybe Text)
, _dnsNitInterval :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
dvbNitSettings
:: DvbNitSettings
dvbNitSettings =
DvbNitSettings'
{ _dnsNetworkId = Nothing
, _dnsNetworkName = Nothing
, _dnsNitInterval = Nothing
}
dnsNetworkId :: Lens' DvbNitSettings (Maybe Int)
dnsNetworkId = lens _dnsNetworkId (\ s a -> s{_dnsNetworkId = a})
dnsNetworkName :: Lens' DvbNitSettings (Maybe Text)
dnsNetworkName = lens _dnsNetworkName (\ s a -> s{_dnsNetworkName = a})
dnsNitInterval :: Lens' DvbNitSettings (Maybe Int)
dnsNitInterval = lens _dnsNitInterval (\ s a -> s{_dnsNitInterval = a})
instance FromJSON DvbNitSettings where
parseJSON
= withObject "DvbNitSettings"
(\ x ->
DvbNitSettings' <$>
(x .:? "networkId") <*> (x .:? "networkName") <*>
(x .:? "nitInterval"))
instance Hashable DvbNitSettings where
instance NFData DvbNitSettings where
instance ToJSON DvbNitSettings where
toJSON DvbNitSettings'{..}
= object
(catMaybes
[("networkId" .=) <$> _dnsNetworkId,
("networkName" .=) <$> _dnsNetworkName,
("nitInterval" .=) <$> _dnsNitInterval])
data DvbSdtSettings = DvbSdtSettings'
{ _dssSdtInterval :: !(Maybe Int)
, _dssServiceProviderName :: !(Maybe Text)
, _dssOutputSdt :: !(Maybe OutputSdt)
, _dssServiceName :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
dvbSdtSettings
:: DvbSdtSettings
dvbSdtSettings =
DvbSdtSettings'
{ _dssSdtInterval = Nothing
, _dssServiceProviderName = Nothing
, _dssOutputSdt = Nothing
, _dssServiceName = Nothing
}
dssSdtInterval :: Lens' DvbSdtSettings (Maybe Int)
dssSdtInterval = lens _dssSdtInterval (\ s a -> s{_dssSdtInterval = a})
dssServiceProviderName :: Lens' DvbSdtSettings (Maybe Text)
dssServiceProviderName = lens _dssServiceProviderName (\ s a -> s{_dssServiceProviderName = a})
dssOutputSdt :: Lens' DvbSdtSettings (Maybe OutputSdt)
dssOutputSdt = lens _dssOutputSdt (\ s a -> s{_dssOutputSdt = a})
dssServiceName :: Lens' DvbSdtSettings (Maybe Text)
dssServiceName = lens _dssServiceName (\ s a -> s{_dssServiceName = a})
instance FromJSON DvbSdtSettings where
parseJSON
= withObject "DvbSdtSettings"
(\ x ->
DvbSdtSettings' <$>
(x .:? "sdtInterval") <*>
(x .:? "serviceProviderName")
<*> (x .:? "outputSdt")
<*> (x .:? "serviceName"))
instance Hashable DvbSdtSettings where
instance NFData DvbSdtSettings where
instance ToJSON DvbSdtSettings where
toJSON DvbSdtSettings'{..}
= object
(catMaybes
[("sdtInterval" .=) <$> _dssSdtInterval,
("serviceProviderName" .=) <$>
_dssServiceProviderName,
("outputSdt" .=) <$> _dssOutputSdt,
("serviceName" .=) <$> _dssServiceName])
data DvbSubDestinationSettings = DvbSubDestinationSettings'
{ _dsdsBackgroundOpacity :: !(Maybe Int)
, _dsdsFontOpacity :: !(Maybe Int)
, _dsdsShadowYOffset :: !(Maybe Int)
, _dsdsFontResolution :: !(Maybe Int)
, _dsdsYPosition :: !(Maybe Int)
, _dsdsBackgroundColor :: !(Maybe DvbSubtitleBackgroundColor)
, _dsdsShadowXOffset :: !(Maybe Int)
, _dsdsFontSize :: !(Maybe Int)
, _dsdsXPosition :: !(Maybe Int)
, _dsdsTeletextSpacing :: !(Maybe DvbSubtitleTeletextSpacing)
, _dsdsAlignment :: !(Maybe DvbSubtitleAlignment)
, _dsdsShadowOpacity :: !(Maybe Int)
, _dsdsOutlineColor :: !(Maybe DvbSubtitleOutlineColor)
, _dsdsOutlineSize :: !(Maybe Int)
, _dsdsShadowColor :: !(Maybe DvbSubtitleShadowColor)
, _dsdsFontColor :: !(Maybe DvbSubtitleFontColor)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
dvbSubDestinationSettings
:: DvbSubDestinationSettings
dvbSubDestinationSettings =
DvbSubDestinationSettings'
{ _dsdsBackgroundOpacity = Nothing
, _dsdsFontOpacity = Nothing
, _dsdsShadowYOffset = Nothing
, _dsdsFontResolution = Nothing
, _dsdsYPosition = Nothing
, _dsdsBackgroundColor = Nothing
, _dsdsShadowXOffset = Nothing
, _dsdsFontSize = Nothing
, _dsdsXPosition = Nothing
, _dsdsTeletextSpacing = Nothing
, _dsdsAlignment = Nothing
, _dsdsShadowOpacity = Nothing
, _dsdsOutlineColor = Nothing
, _dsdsOutlineSize = Nothing
, _dsdsShadowColor = Nothing
, _dsdsFontColor = Nothing
}
dsdsBackgroundOpacity :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsBackgroundOpacity = lens _dsdsBackgroundOpacity (\ s a -> s{_dsdsBackgroundOpacity = a})
dsdsFontOpacity :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsFontOpacity = lens _dsdsFontOpacity (\ s a -> s{_dsdsFontOpacity = a})
dsdsShadowYOffset :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsShadowYOffset = lens _dsdsShadowYOffset (\ s a -> s{_dsdsShadowYOffset = a})
dsdsFontResolution :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsFontResolution = lens _dsdsFontResolution (\ s a -> s{_dsdsFontResolution = a})
dsdsYPosition :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsYPosition = lens _dsdsYPosition (\ s a -> s{_dsdsYPosition = a})
dsdsBackgroundColor :: Lens' DvbSubDestinationSettings (Maybe DvbSubtitleBackgroundColor)
dsdsBackgroundColor = lens _dsdsBackgroundColor (\ s a -> s{_dsdsBackgroundColor = a})
dsdsShadowXOffset :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsShadowXOffset = lens _dsdsShadowXOffset (\ s a -> s{_dsdsShadowXOffset = a})
dsdsFontSize :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsFontSize = lens _dsdsFontSize (\ s a -> s{_dsdsFontSize = a})
dsdsXPosition :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsXPosition = lens _dsdsXPosition (\ s a -> s{_dsdsXPosition = a})
dsdsTeletextSpacing :: Lens' DvbSubDestinationSettings (Maybe DvbSubtitleTeletextSpacing)
dsdsTeletextSpacing = lens _dsdsTeletextSpacing (\ s a -> s{_dsdsTeletextSpacing = a})
dsdsAlignment :: Lens' DvbSubDestinationSettings (Maybe DvbSubtitleAlignment)
dsdsAlignment = lens _dsdsAlignment (\ s a -> s{_dsdsAlignment = a})
dsdsShadowOpacity :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsShadowOpacity = lens _dsdsShadowOpacity (\ s a -> s{_dsdsShadowOpacity = a})
dsdsOutlineColor :: Lens' DvbSubDestinationSettings (Maybe DvbSubtitleOutlineColor)
dsdsOutlineColor = lens _dsdsOutlineColor (\ s a -> s{_dsdsOutlineColor = a})
dsdsOutlineSize :: Lens' DvbSubDestinationSettings (Maybe Int)
dsdsOutlineSize = lens _dsdsOutlineSize (\ s a -> s{_dsdsOutlineSize = a})
dsdsShadowColor :: Lens' DvbSubDestinationSettings (Maybe DvbSubtitleShadowColor)
dsdsShadowColor = lens _dsdsShadowColor (\ s a -> s{_dsdsShadowColor = a})
dsdsFontColor :: Lens' DvbSubDestinationSettings (Maybe DvbSubtitleFontColor)
dsdsFontColor = lens _dsdsFontColor (\ s a -> s{_dsdsFontColor = a})
instance FromJSON DvbSubDestinationSettings where
parseJSON
= withObject "DvbSubDestinationSettings"
(\ x ->
DvbSubDestinationSettings' <$>
(x .:? "backgroundOpacity") <*> (x .:? "fontOpacity")
<*> (x .:? "shadowYOffset")
<*> (x .:? "fontResolution")
<*> (x .:? "yPosition")
<*> (x .:? "backgroundColor")
<*> (x .:? "shadowXOffset")
<*> (x .:? "fontSize")
<*> (x .:? "xPosition")
<*> (x .:? "teletextSpacing")
<*> (x .:? "alignment")
<*> (x .:? "shadowOpacity")
<*> (x .:? "outlineColor")
<*> (x .:? "outlineSize")
<*> (x .:? "shadowColor")
<*> (x .:? "fontColor"))
instance Hashable DvbSubDestinationSettings where
instance NFData DvbSubDestinationSettings where
instance ToJSON DvbSubDestinationSettings where
toJSON DvbSubDestinationSettings'{..}
= object
(catMaybes
[("backgroundOpacity" .=) <$> _dsdsBackgroundOpacity,
("fontOpacity" .=) <$> _dsdsFontOpacity,
("shadowYOffset" .=) <$> _dsdsShadowYOffset,
("fontResolution" .=) <$> _dsdsFontResolution,
("yPosition" .=) <$> _dsdsYPosition,
("backgroundColor" .=) <$> _dsdsBackgroundColor,
("shadowXOffset" .=) <$> _dsdsShadowXOffset,
("fontSize" .=) <$> _dsdsFontSize,
("xPosition" .=) <$> _dsdsXPosition,
("teletextSpacing" .=) <$> _dsdsTeletextSpacing,
("alignment" .=) <$> _dsdsAlignment,
("shadowOpacity" .=) <$> _dsdsShadowOpacity,
("outlineColor" .=) <$> _dsdsOutlineColor,
("outlineSize" .=) <$> _dsdsOutlineSize,
("shadowColor" .=) <$> _dsdsShadowColor,
("fontColor" .=) <$> _dsdsFontColor])
newtype DvbSubSourceSettings = DvbSubSourceSettings'
{ _dsssPid :: Maybe Int
} deriving (Eq, Read, Show, Data, Typeable, Generic)
dvbSubSourceSettings
:: DvbSubSourceSettings
dvbSubSourceSettings = DvbSubSourceSettings' {_dsssPid = Nothing}
dsssPid :: Lens' DvbSubSourceSettings (Maybe Int)
dsssPid = lens _dsssPid (\ s a -> s{_dsssPid = a})
instance FromJSON DvbSubSourceSettings where
parseJSON
= withObject "DvbSubSourceSettings"
(\ x -> DvbSubSourceSettings' <$> (x .:? "pid"))
instance Hashable DvbSubSourceSettings where
instance NFData DvbSubSourceSettings where
instance ToJSON DvbSubSourceSettings where
toJSON DvbSubSourceSettings'{..}
= object (catMaybes [("pid" .=) <$> _dsssPid])
newtype DvbTdtSettings = DvbTdtSettings'
{ _dtsTdtInterval :: Maybe Int
} deriving (Eq, Read, Show, Data, Typeable, Generic)
dvbTdtSettings
:: DvbTdtSettings
dvbTdtSettings = DvbTdtSettings' {_dtsTdtInterval = Nothing}
dtsTdtInterval :: Lens' DvbTdtSettings (Maybe Int)
dtsTdtInterval = lens _dtsTdtInterval (\ s a -> s{_dtsTdtInterval = a})
instance FromJSON DvbTdtSettings where
parseJSON
= withObject "DvbTdtSettings"
(\ x -> DvbTdtSettings' <$> (x .:? "tdtInterval"))
instance Hashable DvbTdtSettings where
instance NFData DvbTdtSettings where
instance ToJSON DvbTdtSettings where
toJSON DvbTdtSettings'{..}
= object
(catMaybes [("tdtInterval" .=) <$> _dtsTdtInterval])
data Eac3Settings = Eac3Settings'
{ _esStereoDownmix :: !(Maybe Eac3StereoDownmix)
, _esLoRoCenterMixLevel :: !(Maybe Double)
, _esLtRtCenterMixLevel :: !(Maybe Double)
, _esLfeFilter :: !(Maybe Eac3LfeFilter)
, _esDynamicRangeCompressionLine :: !(Maybe Eac3DynamicRangeCompressionLine)
, _esLtRtSurroundMixLevel :: !(Maybe Double)
, _esMetadataControl :: !(Maybe Eac3MetadataControl)
, _esLoRoSurroundMixLevel :: !(Maybe Double)
, _esSurroundMode :: !(Maybe Eac3SurroundMode)
, _esAttenuationControl :: !(Maybe Eac3AttenuationControl)
, _esPassthroughControl :: !(Maybe Eac3PassthroughControl)
, _esBitstreamMode :: !(Maybe Eac3BitstreamMode)
, _esLfeControl :: !(Maybe Eac3LfeControl)
, _esDynamicRangeCompressionRf :: !(Maybe Eac3DynamicRangeCompressionRf)
, _esCodingMode :: !(Maybe Eac3CodingMode)
, _esSampleRate :: !(Maybe Int)
, _esDcFilter :: !(Maybe Eac3DcFilter)
, _esBitrate :: !(Maybe Int)
, _esPhaseControl :: !(Maybe Eac3PhaseControl)
, _esSurroundExMode :: !(Maybe Eac3SurroundExMode)
, _esDialnorm :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
eac3Settings
:: Eac3Settings
eac3Settings =
Eac3Settings'
{ _esStereoDownmix = Nothing
, _esLoRoCenterMixLevel = Nothing
, _esLtRtCenterMixLevel = Nothing
, _esLfeFilter = Nothing
, _esDynamicRangeCompressionLine = Nothing
, _esLtRtSurroundMixLevel = Nothing
, _esMetadataControl = Nothing
, _esLoRoSurroundMixLevel = Nothing
, _esSurroundMode = Nothing
, _esAttenuationControl = Nothing
, _esPassthroughControl = Nothing
, _esBitstreamMode = Nothing
, _esLfeControl = Nothing
, _esDynamicRangeCompressionRf = Nothing
, _esCodingMode = Nothing
, _esSampleRate = Nothing
, _esDcFilter = Nothing
, _esBitrate = Nothing
, _esPhaseControl = Nothing
, _esSurroundExMode = Nothing
, _esDialnorm = Nothing
}
esStereoDownmix :: Lens' Eac3Settings (Maybe Eac3StereoDownmix)
esStereoDownmix = lens _esStereoDownmix (\ s a -> s{_esStereoDownmix = a})
esLoRoCenterMixLevel :: Lens' Eac3Settings (Maybe Double)
esLoRoCenterMixLevel = lens _esLoRoCenterMixLevel (\ s a -> s{_esLoRoCenterMixLevel = a})
esLtRtCenterMixLevel :: Lens' Eac3Settings (Maybe Double)
esLtRtCenterMixLevel = lens _esLtRtCenterMixLevel (\ s a -> s{_esLtRtCenterMixLevel = a})
esLfeFilter :: Lens' Eac3Settings (Maybe Eac3LfeFilter)
esLfeFilter = lens _esLfeFilter (\ s a -> s{_esLfeFilter = a})
esDynamicRangeCompressionLine :: Lens' Eac3Settings (Maybe Eac3DynamicRangeCompressionLine)
esDynamicRangeCompressionLine = lens _esDynamicRangeCompressionLine (\ s a -> s{_esDynamicRangeCompressionLine = a})
esLtRtSurroundMixLevel :: Lens' Eac3Settings (Maybe Double)
esLtRtSurroundMixLevel = lens _esLtRtSurroundMixLevel (\ s a -> s{_esLtRtSurroundMixLevel = a})
esMetadataControl :: Lens' Eac3Settings (Maybe Eac3MetadataControl)
esMetadataControl = lens _esMetadataControl (\ s a -> s{_esMetadataControl = a})
esLoRoSurroundMixLevel :: Lens' Eac3Settings (Maybe Double)
esLoRoSurroundMixLevel = lens _esLoRoSurroundMixLevel (\ s a -> s{_esLoRoSurroundMixLevel = a})
esSurroundMode :: Lens' Eac3Settings (Maybe Eac3SurroundMode)
esSurroundMode = lens _esSurroundMode (\ s a -> s{_esSurroundMode = a})
esAttenuationControl :: Lens' Eac3Settings (Maybe Eac3AttenuationControl)
esAttenuationControl = lens _esAttenuationControl (\ s a -> s{_esAttenuationControl = a})
esPassthroughControl :: Lens' Eac3Settings (Maybe Eac3PassthroughControl)
esPassthroughControl = lens _esPassthroughControl (\ s a -> s{_esPassthroughControl = a})
esBitstreamMode :: Lens' Eac3Settings (Maybe Eac3BitstreamMode)
esBitstreamMode = lens _esBitstreamMode (\ s a -> s{_esBitstreamMode = a})
esLfeControl :: Lens' Eac3Settings (Maybe Eac3LfeControl)
esLfeControl = lens _esLfeControl (\ s a -> s{_esLfeControl = a})
esDynamicRangeCompressionRf :: Lens' Eac3Settings (Maybe Eac3DynamicRangeCompressionRf)
esDynamicRangeCompressionRf = lens _esDynamicRangeCompressionRf (\ s a -> s{_esDynamicRangeCompressionRf = a})
esCodingMode :: Lens' Eac3Settings (Maybe Eac3CodingMode)
esCodingMode = lens _esCodingMode (\ s a -> s{_esCodingMode = a})
esSampleRate :: Lens' Eac3Settings (Maybe Int)
esSampleRate = lens _esSampleRate (\ s a -> s{_esSampleRate = a})
esDcFilter :: Lens' Eac3Settings (Maybe Eac3DcFilter)
esDcFilter = lens _esDcFilter (\ s a -> s{_esDcFilter = a})
esBitrate :: Lens' Eac3Settings (Maybe Int)
esBitrate = lens _esBitrate (\ s a -> s{_esBitrate = a})
esPhaseControl :: Lens' Eac3Settings (Maybe Eac3PhaseControl)
esPhaseControl = lens _esPhaseControl (\ s a -> s{_esPhaseControl = a})
esSurroundExMode :: Lens' Eac3Settings (Maybe Eac3SurroundExMode)
esSurroundExMode = lens _esSurroundExMode (\ s a -> s{_esSurroundExMode = a})
esDialnorm :: Lens' Eac3Settings (Maybe Int)
esDialnorm = lens _esDialnorm (\ s a -> s{_esDialnorm = a})
instance FromJSON Eac3Settings where
parseJSON
= withObject "Eac3Settings"
(\ x ->
Eac3Settings' <$>
(x .:? "stereoDownmix") <*>
(x .:? "loRoCenterMixLevel")
<*> (x .:? "ltRtCenterMixLevel")
<*> (x .:? "lfeFilter")
<*> (x .:? "dynamicRangeCompressionLine")
<*> (x .:? "ltRtSurroundMixLevel")
<*> (x .:? "metadataControl")
<*> (x .:? "loRoSurroundMixLevel")
<*> (x .:? "surroundMode")
<*> (x .:? "attenuationControl")
<*> (x .:? "passthroughControl")
<*> (x .:? "bitstreamMode")
<*> (x .:? "lfeControl")
<*> (x .:? "dynamicRangeCompressionRf")
<*> (x .:? "codingMode")
<*> (x .:? "sampleRate")
<*> (x .:? "dcFilter")
<*> (x .:? "bitrate")
<*> (x .:? "phaseControl")
<*> (x .:? "surroundExMode")
<*> (x .:? "dialnorm"))
instance Hashable Eac3Settings where
instance NFData Eac3Settings where
instance ToJSON Eac3Settings where
toJSON Eac3Settings'{..}
= object
(catMaybes
[("stereoDownmix" .=) <$> _esStereoDownmix,
("loRoCenterMixLevel" .=) <$> _esLoRoCenterMixLevel,
("ltRtCenterMixLevel" .=) <$> _esLtRtCenterMixLevel,
("lfeFilter" .=) <$> _esLfeFilter,
("dynamicRangeCompressionLine" .=) <$>
_esDynamicRangeCompressionLine,
("ltRtSurroundMixLevel" .=) <$>
_esLtRtSurroundMixLevel,
("metadataControl" .=) <$> _esMetadataControl,
("loRoSurroundMixLevel" .=) <$>
_esLoRoSurroundMixLevel,
("surroundMode" .=) <$> _esSurroundMode,
("attenuationControl" .=) <$> _esAttenuationControl,
("passthroughControl" .=) <$> _esPassthroughControl,
("bitstreamMode" .=) <$> _esBitstreamMode,
("lfeControl" .=) <$> _esLfeControl,
("dynamicRangeCompressionRf" .=) <$>
_esDynamicRangeCompressionRf,
("codingMode" .=) <$> _esCodingMode,
("sampleRate" .=) <$> _esSampleRate,
("dcFilter" .=) <$> _esDcFilter,
("bitrate" .=) <$> _esBitrate,
("phaseControl" .=) <$> _esPhaseControl,
("surroundExMode" .=) <$> _esSurroundExMode,
("dialnorm" .=) <$> _esDialnorm])
data EmbeddedSourceSettings = EmbeddedSourceSettings'
{ _essConvert608To708 :: !(Maybe EmbeddedConvert608To708)
, _essSource608TrackNumber :: !(Maybe Int)
, _essSource608ChannelNumber :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
embeddedSourceSettings
:: EmbeddedSourceSettings
embeddedSourceSettings =
EmbeddedSourceSettings'
{ _essConvert608To708 = Nothing
, _essSource608TrackNumber = Nothing
, _essSource608ChannelNumber = Nothing
}
essConvert608To708 :: Lens' EmbeddedSourceSettings (Maybe EmbeddedConvert608To708)
essConvert608To708 = lens _essConvert608To708 (\ s a -> s{_essConvert608To708 = a})
essSource608TrackNumber :: Lens' EmbeddedSourceSettings (Maybe Int)
essSource608TrackNumber = lens _essSource608TrackNumber (\ s a -> s{_essSource608TrackNumber = a})
essSource608ChannelNumber :: Lens' EmbeddedSourceSettings (Maybe Int)
essSource608ChannelNumber = lens _essSource608ChannelNumber (\ s a -> s{_essSource608ChannelNumber = a})
instance FromJSON EmbeddedSourceSettings where
parseJSON
= withObject "EmbeddedSourceSettings"
(\ x ->
EmbeddedSourceSettings' <$>
(x .:? "convert608To708") <*>
(x .:? "source608TrackNumber")
<*> (x .:? "source608ChannelNumber"))
instance Hashable EmbeddedSourceSettings where
instance NFData EmbeddedSourceSettings where
instance ToJSON EmbeddedSourceSettings where
toJSON EmbeddedSourceSettings'{..}
= object
(catMaybes
[("convert608To708" .=) <$> _essConvert608To708,
("source608TrackNumber" .=) <$>
_essSource608TrackNumber,
("source608ChannelNumber" .=) <$>
_essSource608ChannelNumber])
newtype Endpoint = Endpoint'
{ _eURL :: Maybe Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
endpoint
:: Endpoint
endpoint = Endpoint' {_eURL = Nothing}
eURL :: Lens' Endpoint (Maybe Text)
eURL = lens _eURL (\ s a -> s{_eURL = a})
instance FromJSON Endpoint where
parseJSON
= withObject "Endpoint"
(\ x -> Endpoint' <$> (x .:? "url"))
instance Hashable Endpoint where
instance NFData Endpoint where
newtype F4vSettings = F4vSettings'
{ _fsMoovPlacement :: Maybe F4vMoovPlacement
} deriving (Eq, Read, Show, Data, Typeable, Generic)
f4vSettings
:: F4vSettings
f4vSettings = F4vSettings' {_fsMoovPlacement = Nothing}
fsMoovPlacement :: Lens' F4vSettings (Maybe F4vMoovPlacement)
fsMoovPlacement = lens _fsMoovPlacement (\ s a -> s{_fsMoovPlacement = a})
instance FromJSON F4vSettings where
parseJSON
= withObject "F4vSettings"
(\ x -> F4vSettings' <$> (x .:? "moovPlacement"))
instance Hashable F4vSettings where
instance NFData F4vSettings where
instance ToJSON F4vSettings where
toJSON F4vSettings'{..}
= object
(catMaybes
[("moovPlacement" .=) <$> _fsMoovPlacement])
newtype FileGroupSettings = FileGroupSettings'
{ _fgsDestination :: Maybe Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
fileGroupSettings
:: FileGroupSettings
fileGroupSettings = FileGroupSettings' {_fgsDestination = Nothing}
fgsDestination :: Lens' FileGroupSettings (Maybe Text)
fgsDestination = lens _fgsDestination (\ s a -> s{_fgsDestination = a})
instance FromJSON FileGroupSettings where
parseJSON
= withObject "FileGroupSettings"
(\ x -> FileGroupSettings' <$> (x .:? "destination"))
instance Hashable FileGroupSettings where
instance NFData FileGroupSettings where
instance ToJSON FileGroupSettings where
toJSON FileGroupSettings'{..}
= object
(catMaybes [("destination" .=) <$> _fgsDestination])
data FileSourceSettings = FileSourceSettings'
{ _fssConvert608To708 :: !(Maybe FileSourceConvert608To708)
, _fssTimeDelta :: !(Maybe Int)
, _fssSourceFile :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
fileSourceSettings
:: FileSourceSettings
fileSourceSettings =
FileSourceSettings'
{ _fssConvert608To708 = Nothing
, _fssTimeDelta = Nothing
, _fssSourceFile = Nothing
}
fssConvert608To708 :: Lens' FileSourceSettings (Maybe FileSourceConvert608To708)
fssConvert608To708 = lens _fssConvert608To708 (\ s a -> s{_fssConvert608To708 = a})
fssTimeDelta :: Lens' FileSourceSettings (Maybe Int)
fssTimeDelta = lens _fssTimeDelta (\ s a -> s{_fssTimeDelta = a})
fssSourceFile :: Lens' FileSourceSettings (Maybe Text)
fssSourceFile = lens _fssSourceFile (\ s a -> s{_fssSourceFile = a})
instance FromJSON FileSourceSettings where
parseJSON
= withObject "FileSourceSettings"
(\ x ->
FileSourceSettings' <$>
(x .:? "convert608To708") <*> (x .:? "timeDelta") <*>
(x .:? "sourceFile"))
instance Hashable FileSourceSettings where
instance NFData FileSourceSettings where
instance ToJSON FileSourceSettings where
toJSON FileSourceSettings'{..}
= object
(catMaybes
[("convert608To708" .=) <$> _fssConvert608To708,
("timeDelta" .=) <$> _fssTimeDelta,
("sourceFile" .=) <$> _fssSourceFile])
data FrameCaptureSettings = FrameCaptureSettings'
{ _fcsQuality :: !(Maybe Int)
, _fcsFramerateDenominator :: !(Maybe Int)
, _fcsMaxCaptures :: !(Maybe Int)
, _fcsFramerateNumerator :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
frameCaptureSettings
:: FrameCaptureSettings
frameCaptureSettings =
FrameCaptureSettings'
{ _fcsQuality = Nothing
, _fcsFramerateDenominator = Nothing
, _fcsMaxCaptures = Nothing
, _fcsFramerateNumerator = Nothing
}
fcsQuality :: Lens' FrameCaptureSettings (Maybe Int)
fcsQuality = lens _fcsQuality (\ s a -> s{_fcsQuality = a})
fcsFramerateDenominator :: Lens' FrameCaptureSettings (Maybe Int)
fcsFramerateDenominator = lens _fcsFramerateDenominator (\ s a -> s{_fcsFramerateDenominator = a})
fcsMaxCaptures :: Lens' FrameCaptureSettings (Maybe Int)
fcsMaxCaptures = lens _fcsMaxCaptures (\ s a -> s{_fcsMaxCaptures = a})
fcsFramerateNumerator :: Lens' FrameCaptureSettings (Maybe Int)
fcsFramerateNumerator = lens _fcsFramerateNumerator (\ s a -> s{_fcsFramerateNumerator = a})
instance FromJSON FrameCaptureSettings where
parseJSON
= withObject "FrameCaptureSettings"
(\ x ->
FrameCaptureSettings' <$>
(x .:? "quality") <*> (x .:? "framerateDenominator")
<*> (x .:? "maxCaptures")
<*> (x .:? "framerateNumerator"))
instance Hashable FrameCaptureSettings where
instance NFData FrameCaptureSettings where
instance ToJSON FrameCaptureSettings where
toJSON FrameCaptureSettings'{..}
= object
(catMaybes
[("quality" .=) <$> _fcsQuality,
("framerateDenominator" .=) <$>
_fcsFramerateDenominator,
("maxCaptures" .=) <$> _fcsMaxCaptures,
("framerateNumerator" .=) <$>
_fcsFramerateNumerator])
data H264Settings = H264Settings'
{ _hUnregisteredSeiTimecode :: !(Maybe H264UnregisteredSeiTimecode)
, _hQualityTuningLevel :: !(Maybe H264QualityTuningLevel)
, _hTemporalAdaptiveQuantization :: !(Maybe H264TemporalAdaptiveQuantization)
, _hSceneChangeDetect :: !(Maybe H264SceneChangeDetect)
, _hHrdBufferInitialFillPercentage :: !(Maybe Int)
, _hSlowPal :: !(Maybe H264SlowPal)
, _hParNumerator :: !(Maybe Int)
, _hGopSize :: !(Maybe Double)
, _hNumberBFramesBetweenReferenceFrames :: !(Maybe Int)
, _hGopSizeUnits :: !(Maybe H264GopSizeUnits)
, _hHrdBufferSize :: !(Maybe Int)
, _hSlices :: !(Maybe Int)
, _hRateControlMode :: !(Maybe H264RateControlMode)
, _hNumberReferenceFrames :: !(Maybe Int)
, _hTelecine :: !(Maybe H264Telecine)
, _hMinIInterval :: !(Maybe Int)
, _hInterlaceMode :: !(Maybe H264InterlaceMode)
, _hParControl :: !(Maybe H264ParControl)
, _hRepeatPps :: !(Maybe H264RepeatPps)
, _hFlickerAdaptiveQuantization :: !(Maybe H264FlickerAdaptiveQuantization)
, _hSoftness :: !(Maybe Int)
, _hCodecProfile :: !(Maybe H264CodecProfile)
, _hBitrate :: !(Maybe Int)
, _hFramerateDenominator :: !(Maybe Int)
, _hFramerateConversionAlgorithm :: !(Maybe H264FramerateConversionAlgorithm)
, _hCodecLevel :: !(Maybe H264CodecLevel)
, _hEntropyEncoding :: !(Maybe H264EntropyEncoding)
, _hFramerateControl :: !(Maybe H264FramerateControl)
, _hAdaptiveQuantization :: !(Maybe H264AdaptiveQuantization)
, _hFramerateNumerator :: !(Maybe Int)
, _hGopBReference :: !(Maybe H264GopBReference)
, _hMaxBitrate :: !(Maybe Int)
, _hSyntax :: !(Maybe H264Syntax)
, _hFieldEncoding :: !(Maybe H264FieldEncoding)
, _hGopClosedCadence :: !(Maybe Int)
, _hParDenominator :: !(Maybe Int)
, _hSpatialAdaptiveQuantization :: !(Maybe H264SpatialAdaptiveQuantization)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
h264Settings
:: H264Settings
h264Settings =
H264Settings'
{ _hUnregisteredSeiTimecode = Nothing
, _hQualityTuningLevel = Nothing
, _hTemporalAdaptiveQuantization = Nothing
, _hSceneChangeDetect = Nothing
, _hHrdBufferInitialFillPercentage = Nothing
, _hSlowPal = Nothing
, _hParNumerator = Nothing
, _hGopSize = Nothing
, _hNumberBFramesBetweenReferenceFrames = Nothing
, _hGopSizeUnits = Nothing
, _hHrdBufferSize = Nothing
, _hSlices = Nothing
, _hRateControlMode = Nothing
, _hNumberReferenceFrames = Nothing
, _hTelecine = Nothing
, _hMinIInterval = Nothing
, _hInterlaceMode = Nothing
, _hParControl = Nothing
, _hRepeatPps = Nothing
, _hFlickerAdaptiveQuantization = Nothing
, _hSoftness = Nothing
, _hCodecProfile = Nothing
, _hBitrate = Nothing
, _hFramerateDenominator = Nothing
, _hFramerateConversionAlgorithm = Nothing
, _hCodecLevel = Nothing
, _hEntropyEncoding = Nothing
, _hFramerateControl = Nothing
, _hAdaptiveQuantization = Nothing
, _hFramerateNumerator = Nothing
, _hGopBReference = Nothing
, _hMaxBitrate = Nothing
, _hSyntax = Nothing
, _hFieldEncoding = Nothing
, _hGopClosedCadence = Nothing
, _hParDenominator = Nothing
, _hSpatialAdaptiveQuantization = Nothing
}
hUnregisteredSeiTimecode :: Lens' H264Settings (Maybe H264UnregisteredSeiTimecode)
hUnregisteredSeiTimecode = lens _hUnregisteredSeiTimecode (\ s a -> s{_hUnregisteredSeiTimecode = a})
hQualityTuningLevel :: Lens' H264Settings (Maybe H264QualityTuningLevel)
hQualityTuningLevel = lens _hQualityTuningLevel (\ s a -> s{_hQualityTuningLevel = a})
hTemporalAdaptiveQuantization :: Lens' H264Settings (Maybe H264TemporalAdaptiveQuantization)
hTemporalAdaptiveQuantization = lens _hTemporalAdaptiveQuantization (\ s a -> s{_hTemporalAdaptiveQuantization = a})
hSceneChangeDetect :: Lens' H264Settings (Maybe H264SceneChangeDetect)
hSceneChangeDetect = lens _hSceneChangeDetect (\ s a -> s{_hSceneChangeDetect = a})
hHrdBufferInitialFillPercentage :: Lens' H264Settings (Maybe Int)
hHrdBufferInitialFillPercentage = lens _hHrdBufferInitialFillPercentage (\ s a -> s{_hHrdBufferInitialFillPercentage = a})
hSlowPal :: Lens' H264Settings (Maybe H264SlowPal)
hSlowPal = lens _hSlowPal (\ s a -> s{_hSlowPal = a})
hParNumerator :: Lens' H264Settings (Maybe Int)
hParNumerator = lens _hParNumerator (\ s a -> s{_hParNumerator = a})
hGopSize :: Lens' H264Settings (Maybe Double)
hGopSize = lens _hGopSize (\ s a -> s{_hGopSize = a})
hNumberBFramesBetweenReferenceFrames :: Lens' H264Settings (Maybe Int)
hNumberBFramesBetweenReferenceFrames = lens _hNumberBFramesBetweenReferenceFrames (\ s a -> s{_hNumberBFramesBetweenReferenceFrames = a})
hGopSizeUnits :: Lens' H264Settings (Maybe H264GopSizeUnits)
hGopSizeUnits = lens _hGopSizeUnits (\ s a -> s{_hGopSizeUnits = a})
hHrdBufferSize :: Lens' H264Settings (Maybe Int)
hHrdBufferSize = lens _hHrdBufferSize (\ s a -> s{_hHrdBufferSize = a})
hSlices :: Lens' H264Settings (Maybe Int)
hSlices = lens _hSlices (\ s a -> s{_hSlices = a})
hRateControlMode :: Lens' H264Settings (Maybe H264RateControlMode)
hRateControlMode = lens _hRateControlMode (\ s a -> s{_hRateControlMode = a})
hNumberReferenceFrames :: Lens' H264Settings (Maybe Int)
hNumberReferenceFrames = lens _hNumberReferenceFrames (\ s a -> s{_hNumberReferenceFrames = a})
hTelecine :: Lens' H264Settings (Maybe H264Telecine)
hTelecine = lens _hTelecine (\ s a -> s{_hTelecine = a})
hMinIInterval :: Lens' H264Settings (Maybe Int)
hMinIInterval = lens _hMinIInterval (\ s a -> s{_hMinIInterval = a})
hInterlaceMode :: Lens' H264Settings (Maybe H264InterlaceMode)
hInterlaceMode = lens _hInterlaceMode (\ s a -> s{_hInterlaceMode = a})
hParControl :: Lens' H264Settings (Maybe H264ParControl)
hParControl = lens _hParControl (\ s a -> s{_hParControl = a})
hRepeatPps :: Lens' H264Settings (Maybe H264RepeatPps)
hRepeatPps = lens _hRepeatPps (\ s a -> s{_hRepeatPps = a})
hFlickerAdaptiveQuantization :: Lens' H264Settings (Maybe H264FlickerAdaptiveQuantization)
hFlickerAdaptiveQuantization = lens _hFlickerAdaptiveQuantization (\ s a -> s{_hFlickerAdaptiveQuantization = a})
hSoftness :: Lens' H264Settings (Maybe Int)
hSoftness = lens _hSoftness (\ s a -> s{_hSoftness = a})
hCodecProfile :: Lens' H264Settings (Maybe H264CodecProfile)
hCodecProfile = lens _hCodecProfile (\ s a -> s{_hCodecProfile = a})
hBitrate :: Lens' H264Settings (Maybe Int)
hBitrate = lens _hBitrate (\ s a -> s{_hBitrate = a})
hFramerateDenominator :: Lens' H264Settings (Maybe Int)
hFramerateDenominator = lens _hFramerateDenominator (\ s a -> s{_hFramerateDenominator = a})
hFramerateConversionAlgorithm :: Lens' H264Settings (Maybe H264FramerateConversionAlgorithm)
hFramerateConversionAlgorithm = lens _hFramerateConversionAlgorithm (\ s a -> s{_hFramerateConversionAlgorithm = a})
hCodecLevel :: Lens' H264Settings (Maybe H264CodecLevel)
hCodecLevel = lens _hCodecLevel (\ s a -> s{_hCodecLevel = a})
hEntropyEncoding :: Lens' H264Settings (Maybe H264EntropyEncoding)
hEntropyEncoding = lens _hEntropyEncoding (\ s a -> s{_hEntropyEncoding = a})
hFramerateControl :: Lens' H264Settings (Maybe H264FramerateControl)
hFramerateControl = lens _hFramerateControl (\ s a -> s{_hFramerateControl = a})
hAdaptiveQuantization :: Lens' H264Settings (Maybe H264AdaptiveQuantization)
hAdaptiveQuantization = lens _hAdaptiveQuantization (\ s a -> s{_hAdaptiveQuantization = a})
hFramerateNumerator :: Lens' H264Settings (Maybe Int)
hFramerateNumerator = lens _hFramerateNumerator (\ s a -> s{_hFramerateNumerator = a})
hGopBReference :: Lens' H264Settings (Maybe H264GopBReference)
hGopBReference = lens _hGopBReference (\ s a -> s{_hGopBReference = a})
hMaxBitrate :: Lens' H264Settings (Maybe Int)
hMaxBitrate = lens _hMaxBitrate (\ s a -> s{_hMaxBitrate = a})
hSyntax :: Lens' H264Settings (Maybe H264Syntax)
hSyntax = lens _hSyntax (\ s a -> s{_hSyntax = a})
hFieldEncoding :: Lens' H264Settings (Maybe H264FieldEncoding)
hFieldEncoding = lens _hFieldEncoding (\ s a -> s{_hFieldEncoding = a})
hGopClosedCadence :: Lens' H264Settings (Maybe Int)
hGopClosedCadence = lens _hGopClosedCadence (\ s a -> s{_hGopClosedCadence = a})
hParDenominator :: Lens' H264Settings (Maybe Int)
hParDenominator = lens _hParDenominator (\ s a -> s{_hParDenominator = a})
hSpatialAdaptiveQuantization :: Lens' H264Settings (Maybe H264SpatialAdaptiveQuantization)
hSpatialAdaptiveQuantization = lens _hSpatialAdaptiveQuantization (\ s a -> s{_hSpatialAdaptiveQuantization = a})
instance FromJSON H264Settings where
parseJSON
= withObject "H264Settings"
(\ x ->
H264Settings' <$>
(x .:? "unregisteredSeiTimecode") <*>
(x .:? "qualityTuningLevel")
<*> (x .:? "temporalAdaptiveQuantization")
<*> (x .:? "sceneChangeDetect")
<*> (x .:? "hrdBufferInitialFillPercentage")
<*> (x .:? "slowPal")
<*> (x .:? "parNumerator")
<*> (x .:? "gopSize")
<*> (x .:? "numberBFramesBetweenReferenceFrames")
<*> (x .:? "gopSizeUnits")
<*> (x .:? "hrdBufferSize")
<*> (x .:? "slices")
<*> (x .:? "rateControlMode")
<*> (x .:? "numberReferenceFrames")
<*> (x .:? "telecine")
<*> (x .:? "minIInterval")
<*> (x .:? "interlaceMode")
<*> (x .:? "parControl")
<*> (x .:? "repeatPps")
<*> (x .:? "flickerAdaptiveQuantization")
<*> (x .:? "softness")
<*> (x .:? "codecProfile")
<*> (x .:? "bitrate")
<*> (x .:? "framerateDenominator")
<*> (x .:? "framerateConversionAlgorithm")
<*> (x .:? "codecLevel")
<*> (x .:? "entropyEncoding")
<*> (x .:? "framerateControl")
<*> (x .:? "adaptiveQuantization")
<*> (x .:? "framerateNumerator")
<*> (x .:? "gopBReference")
<*> (x .:? "maxBitrate")
<*> (x .:? "syntax")
<*> (x .:? "fieldEncoding")
<*> (x .:? "gopClosedCadence")
<*> (x .:? "parDenominator")
<*> (x .:? "spatialAdaptiveQuantization"))
instance Hashable H264Settings where
instance NFData H264Settings where
instance ToJSON H264Settings where
toJSON H264Settings'{..}
= object
(catMaybes
[("unregisteredSeiTimecode" .=) <$>
_hUnregisteredSeiTimecode,
("qualityTuningLevel" .=) <$> _hQualityTuningLevel,
("temporalAdaptiveQuantization" .=) <$>
_hTemporalAdaptiveQuantization,
("sceneChangeDetect" .=) <$> _hSceneChangeDetect,
("hrdBufferInitialFillPercentage" .=) <$>
_hHrdBufferInitialFillPercentage,
("slowPal" .=) <$> _hSlowPal,
("parNumerator" .=) <$> _hParNumerator,
("gopSize" .=) <$> _hGopSize,
("numberBFramesBetweenReferenceFrames" .=) <$>
_hNumberBFramesBetweenReferenceFrames,
("gopSizeUnits" .=) <$> _hGopSizeUnits,
("hrdBufferSize" .=) <$> _hHrdBufferSize,
("slices" .=) <$> _hSlices,
("rateControlMode" .=) <$> _hRateControlMode,
("numberReferenceFrames" .=) <$>
_hNumberReferenceFrames,
("telecine" .=) <$> _hTelecine,
("minIInterval" .=) <$> _hMinIInterval,
("interlaceMode" .=) <$> _hInterlaceMode,
("parControl" .=) <$> _hParControl,
("repeatPps" .=) <$> _hRepeatPps,
("flickerAdaptiveQuantization" .=) <$>
_hFlickerAdaptiveQuantization,
("softness" .=) <$> _hSoftness,
("codecProfile" .=) <$> _hCodecProfile,
("bitrate" .=) <$> _hBitrate,
("framerateDenominator" .=) <$>
_hFramerateDenominator,
("framerateConversionAlgorithm" .=) <$>
_hFramerateConversionAlgorithm,
("codecLevel" .=) <$> _hCodecLevel,
("entropyEncoding" .=) <$> _hEntropyEncoding,
("framerateControl" .=) <$> _hFramerateControl,
("adaptiveQuantization" .=) <$>
_hAdaptiveQuantization,
("framerateNumerator" .=) <$> _hFramerateNumerator,
("gopBReference" .=) <$> _hGopBReference,
("maxBitrate" .=) <$> _hMaxBitrate,
("syntax" .=) <$> _hSyntax,
("fieldEncoding" .=) <$> _hFieldEncoding,
("gopClosedCadence" .=) <$> _hGopClosedCadence,
("parDenominator" .=) <$> _hParDenominator,
("spatialAdaptiveQuantization" .=) <$>
_hSpatialAdaptiveQuantization])
data H265Settings = H265Settings'
{ _hsUnregisteredSeiTimecode :: !(Maybe H265UnregisteredSeiTimecode)
, _hsQualityTuningLevel :: !(Maybe H265QualityTuningLevel)
, _hsTemporalAdaptiveQuantization :: !(Maybe H265TemporalAdaptiveQuantization)
, _hsSceneChangeDetect :: !(Maybe H265SceneChangeDetect)
, _hsHrdBufferInitialFillPercentage :: !(Maybe Int)
, _hsTiles :: !(Maybe H265Tiles)
, _hsSlowPal :: !(Maybe H265SlowPal)
, _hsTemporalIds :: !(Maybe H265TemporalIds)
, _hsParNumerator :: !(Maybe Int)
, _hsGopSize :: !(Maybe Double)
, _hsNumberBFramesBetweenReferenceFrames :: !(Maybe Int)
, _hsGopSizeUnits :: !(Maybe H265GopSizeUnits)
, _hsHrdBufferSize :: !(Maybe Int)
, _hsSlices :: !(Maybe Int)
, _hsAlternateTransferFunctionSei :: !(Maybe H265AlternateTransferFunctionSei)
, _hsRateControlMode :: !(Maybe H265RateControlMode)
, _hsNumberReferenceFrames :: !(Maybe Int)
, _hsTelecine :: !(Maybe H265Telecine)
, _hsMinIInterval :: !(Maybe Int)
, _hsInterlaceMode :: !(Maybe H265InterlaceMode)
, _hsParControl :: !(Maybe H265ParControl)
, _hsFlickerAdaptiveQuantization :: !(Maybe H265FlickerAdaptiveQuantization)
, _hsSampleAdaptiveOffsetFilterMode :: !(Maybe H265SampleAdaptiveOffsetFilterMode)
, _hsCodecProfile :: !(Maybe H265CodecProfile)
, _hsBitrate :: !(Maybe Int)
, _hsFramerateDenominator :: !(Maybe Int)
, _hsFramerateConversionAlgorithm :: !(Maybe H265FramerateConversionAlgorithm)
, _hsCodecLevel :: !(Maybe H265CodecLevel)
, _hsFramerateControl :: !(Maybe H265FramerateControl)
, _hsAdaptiveQuantization :: !(Maybe H265AdaptiveQuantization)
, _hsFramerateNumerator :: !(Maybe Int)
, _hsGopBReference :: !(Maybe H265GopBReference)
, _hsMaxBitrate :: !(Maybe Int)
, _hsGopClosedCadence :: !(Maybe Int)
, _hsParDenominator :: !(Maybe Int)
, _hsSpatialAdaptiveQuantization :: !(Maybe H265SpatialAdaptiveQuantization)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
h265Settings
:: H265Settings
h265Settings =
H265Settings'
{ _hsUnregisteredSeiTimecode = Nothing
, _hsQualityTuningLevel = Nothing
, _hsTemporalAdaptiveQuantization = Nothing
, _hsSceneChangeDetect = Nothing
, _hsHrdBufferInitialFillPercentage = Nothing
, _hsTiles = Nothing
, _hsSlowPal = Nothing
, _hsTemporalIds = Nothing
, _hsParNumerator = Nothing
, _hsGopSize = Nothing
, _hsNumberBFramesBetweenReferenceFrames = Nothing
, _hsGopSizeUnits = Nothing
, _hsHrdBufferSize = Nothing
, _hsSlices = Nothing
, _hsAlternateTransferFunctionSei = Nothing
, _hsRateControlMode = Nothing
, _hsNumberReferenceFrames = Nothing
, _hsTelecine = Nothing
, _hsMinIInterval = Nothing
, _hsInterlaceMode = Nothing
, _hsParControl = Nothing
, _hsFlickerAdaptiveQuantization = Nothing
, _hsSampleAdaptiveOffsetFilterMode = Nothing
, _hsCodecProfile = Nothing
, _hsBitrate = Nothing
, _hsFramerateDenominator = Nothing
, _hsFramerateConversionAlgorithm = Nothing
, _hsCodecLevel = Nothing
, _hsFramerateControl = Nothing
, _hsAdaptiveQuantization = Nothing
, _hsFramerateNumerator = Nothing
, _hsGopBReference = Nothing
, _hsMaxBitrate = Nothing
, _hsGopClosedCadence = Nothing
, _hsParDenominator = Nothing
, _hsSpatialAdaptiveQuantization = Nothing
}
hsUnregisteredSeiTimecode :: Lens' H265Settings (Maybe H265UnregisteredSeiTimecode)
hsUnregisteredSeiTimecode = lens _hsUnregisteredSeiTimecode (\ s a -> s{_hsUnregisteredSeiTimecode = a})
hsQualityTuningLevel :: Lens' H265Settings (Maybe H265QualityTuningLevel)
hsQualityTuningLevel = lens _hsQualityTuningLevel (\ s a -> s{_hsQualityTuningLevel = a})
hsTemporalAdaptiveQuantization :: Lens' H265Settings (Maybe H265TemporalAdaptiveQuantization)
hsTemporalAdaptiveQuantization = lens _hsTemporalAdaptiveQuantization (\ s a -> s{_hsTemporalAdaptiveQuantization = a})
hsSceneChangeDetect :: Lens' H265Settings (Maybe H265SceneChangeDetect)
hsSceneChangeDetect = lens _hsSceneChangeDetect (\ s a -> s{_hsSceneChangeDetect = a})
hsHrdBufferInitialFillPercentage :: Lens' H265Settings (Maybe Int)
hsHrdBufferInitialFillPercentage = lens _hsHrdBufferInitialFillPercentage (\ s a -> s{_hsHrdBufferInitialFillPercentage = a})
hsTiles :: Lens' H265Settings (Maybe H265Tiles)
hsTiles = lens _hsTiles (\ s a -> s{_hsTiles = a})
hsSlowPal :: Lens' H265Settings (Maybe H265SlowPal)
hsSlowPal = lens _hsSlowPal (\ s a -> s{_hsSlowPal = a})
hsTemporalIds :: Lens' H265Settings (Maybe H265TemporalIds)
hsTemporalIds = lens _hsTemporalIds (\ s a -> s{_hsTemporalIds = a})
hsParNumerator :: Lens' H265Settings (Maybe Int)
hsParNumerator = lens _hsParNumerator (\ s a -> s{_hsParNumerator = a})
hsGopSize :: Lens' H265Settings (Maybe Double)
hsGopSize = lens _hsGopSize (\ s a -> s{_hsGopSize = a})
hsNumberBFramesBetweenReferenceFrames :: Lens' H265Settings (Maybe Int)
hsNumberBFramesBetweenReferenceFrames = lens _hsNumberBFramesBetweenReferenceFrames (\ s a -> s{_hsNumberBFramesBetweenReferenceFrames = a})
hsGopSizeUnits :: Lens' H265Settings (Maybe H265GopSizeUnits)
hsGopSizeUnits = lens _hsGopSizeUnits (\ s a -> s{_hsGopSizeUnits = a})
hsHrdBufferSize :: Lens' H265Settings (Maybe Int)
hsHrdBufferSize = lens _hsHrdBufferSize (\ s a -> s{_hsHrdBufferSize = a})
hsSlices :: Lens' H265Settings (Maybe Int)
hsSlices = lens _hsSlices (\ s a -> s{_hsSlices = a})
hsAlternateTransferFunctionSei :: Lens' H265Settings (Maybe H265AlternateTransferFunctionSei)
hsAlternateTransferFunctionSei = lens _hsAlternateTransferFunctionSei (\ s a -> s{_hsAlternateTransferFunctionSei = a})
hsRateControlMode :: Lens' H265Settings (Maybe H265RateControlMode)
hsRateControlMode = lens _hsRateControlMode (\ s a -> s{_hsRateControlMode = a})
hsNumberReferenceFrames :: Lens' H265Settings (Maybe Int)
hsNumberReferenceFrames = lens _hsNumberReferenceFrames (\ s a -> s{_hsNumberReferenceFrames = a})
hsTelecine :: Lens' H265Settings (Maybe H265Telecine)
hsTelecine = lens _hsTelecine (\ s a -> s{_hsTelecine = a})
hsMinIInterval :: Lens' H265Settings (Maybe Int)
hsMinIInterval = lens _hsMinIInterval (\ s a -> s{_hsMinIInterval = a})
hsInterlaceMode :: Lens' H265Settings (Maybe H265InterlaceMode)
hsInterlaceMode = lens _hsInterlaceMode (\ s a -> s{_hsInterlaceMode = a})
hsParControl :: Lens' H265Settings (Maybe H265ParControl)
hsParControl = lens _hsParControl (\ s a -> s{_hsParControl = a})
hsFlickerAdaptiveQuantization :: Lens' H265Settings (Maybe H265FlickerAdaptiveQuantization)
hsFlickerAdaptiveQuantization = lens _hsFlickerAdaptiveQuantization (\ s a -> s{_hsFlickerAdaptiveQuantization = a})
hsSampleAdaptiveOffsetFilterMode :: Lens' H265Settings (Maybe H265SampleAdaptiveOffsetFilterMode)
hsSampleAdaptiveOffsetFilterMode = lens _hsSampleAdaptiveOffsetFilterMode (\ s a -> s{_hsSampleAdaptiveOffsetFilterMode = a})
hsCodecProfile :: Lens' H265Settings (Maybe H265CodecProfile)
hsCodecProfile = lens _hsCodecProfile (\ s a -> s{_hsCodecProfile = a})
hsBitrate :: Lens' H265Settings (Maybe Int)
hsBitrate = lens _hsBitrate (\ s a -> s{_hsBitrate = a})
hsFramerateDenominator :: Lens' H265Settings (Maybe Int)
hsFramerateDenominator = lens _hsFramerateDenominator (\ s a -> s{_hsFramerateDenominator = a})
hsFramerateConversionAlgorithm :: Lens' H265Settings (Maybe H265FramerateConversionAlgorithm)
hsFramerateConversionAlgorithm = lens _hsFramerateConversionAlgorithm (\ s a -> s{_hsFramerateConversionAlgorithm = a})
hsCodecLevel :: Lens' H265Settings (Maybe H265CodecLevel)
hsCodecLevel = lens _hsCodecLevel (\ s a -> s{_hsCodecLevel = a})
hsFramerateControl :: Lens' H265Settings (Maybe H265FramerateControl)
hsFramerateControl = lens _hsFramerateControl (\ s a -> s{_hsFramerateControl = a})
hsAdaptiveQuantization :: Lens' H265Settings (Maybe H265AdaptiveQuantization)
hsAdaptiveQuantization = lens _hsAdaptiveQuantization (\ s a -> s{_hsAdaptiveQuantization = a})
hsFramerateNumerator :: Lens' H265Settings (Maybe Int)
hsFramerateNumerator = lens _hsFramerateNumerator (\ s a -> s{_hsFramerateNumerator = a})
hsGopBReference :: Lens' H265Settings (Maybe H265GopBReference)
hsGopBReference = lens _hsGopBReference (\ s a -> s{_hsGopBReference = a})
hsMaxBitrate :: Lens' H265Settings (Maybe Int)
hsMaxBitrate = lens _hsMaxBitrate (\ s a -> s{_hsMaxBitrate = a})
hsGopClosedCadence :: Lens' H265Settings (Maybe Int)
hsGopClosedCadence = lens _hsGopClosedCadence (\ s a -> s{_hsGopClosedCadence = a})
hsParDenominator :: Lens' H265Settings (Maybe Int)
hsParDenominator = lens _hsParDenominator (\ s a -> s{_hsParDenominator = a})
hsSpatialAdaptiveQuantization :: Lens' H265Settings (Maybe H265SpatialAdaptiveQuantization)
hsSpatialAdaptiveQuantization = lens _hsSpatialAdaptiveQuantization (\ s a -> s{_hsSpatialAdaptiveQuantization = a})
instance FromJSON H265Settings where
parseJSON
= withObject "H265Settings"
(\ x ->
H265Settings' <$>
(x .:? "unregisteredSeiTimecode") <*>
(x .:? "qualityTuningLevel")
<*> (x .:? "temporalAdaptiveQuantization")
<*> (x .:? "sceneChangeDetect")
<*> (x .:? "hrdBufferInitialFillPercentage")
<*> (x .:? "tiles")
<*> (x .:? "slowPal")
<*> (x .:? "temporalIds")
<*> (x .:? "parNumerator")
<*> (x .:? "gopSize")
<*> (x .:? "numberBFramesBetweenReferenceFrames")
<*> (x .:? "gopSizeUnits")
<*> (x .:? "hrdBufferSize")
<*> (x .:? "slices")
<*> (x .:? "alternateTransferFunctionSei")
<*> (x .:? "rateControlMode")
<*> (x .:? "numberReferenceFrames")
<*> (x .:? "telecine")
<*> (x .:? "minIInterval")
<*> (x .:? "interlaceMode")
<*> (x .:? "parControl")
<*> (x .:? "flickerAdaptiveQuantization")
<*> (x .:? "sampleAdaptiveOffsetFilterMode")
<*> (x .:? "codecProfile")
<*> (x .:? "bitrate")
<*> (x .:? "framerateDenominator")
<*> (x .:? "framerateConversionAlgorithm")
<*> (x .:? "codecLevel")
<*> (x .:? "framerateControl")
<*> (x .:? "adaptiveQuantization")
<*> (x .:? "framerateNumerator")
<*> (x .:? "gopBReference")
<*> (x .:? "maxBitrate")
<*> (x .:? "gopClosedCadence")
<*> (x .:? "parDenominator")
<*> (x .:? "spatialAdaptiveQuantization"))
instance Hashable H265Settings where
instance NFData H265Settings where
instance ToJSON H265Settings where
toJSON H265Settings'{..}
= object
(catMaybes
[("unregisteredSeiTimecode" .=) <$>
_hsUnregisteredSeiTimecode,
("qualityTuningLevel" .=) <$> _hsQualityTuningLevel,
("temporalAdaptiveQuantization" .=) <$>
_hsTemporalAdaptiveQuantization,
("sceneChangeDetect" .=) <$> _hsSceneChangeDetect,
("hrdBufferInitialFillPercentage" .=) <$>
_hsHrdBufferInitialFillPercentage,
("tiles" .=) <$> _hsTiles,
("slowPal" .=) <$> _hsSlowPal,
("temporalIds" .=) <$> _hsTemporalIds,
("parNumerator" .=) <$> _hsParNumerator,
("gopSize" .=) <$> _hsGopSize,
("numberBFramesBetweenReferenceFrames" .=) <$>
_hsNumberBFramesBetweenReferenceFrames,
("gopSizeUnits" .=) <$> _hsGopSizeUnits,
("hrdBufferSize" .=) <$> _hsHrdBufferSize,
("slices" .=) <$> _hsSlices,
("alternateTransferFunctionSei" .=) <$>
_hsAlternateTransferFunctionSei,
("rateControlMode" .=) <$> _hsRateControlMode,
("numberReferenceFrames" .=) <$>
_hsNumberReferenceFrames,
("telecine" .=) <$> _hsTelecine,
("minIInterval" .=) <$> _hsMinIInterval,
("interlaceMode" .=) <$> _hsInterlaceMode,
("parControl" .=) <$> _hsParControl,
("flickerAdaptiveQuantization" .=) <$>
_hsFlickerAdaptiveQuantization,
("sampleAdaptiveOffsetFilterMode" .=) <$>
_hsSampleAdaptiveOffsetFilterMode,
("codecProfile" .=) <$> _hsCodecProfile,
("bitrate" .=) <$> _hsBitrate,
("framerateDenominator" .=) <$>
_hsFramerateDenominator,
("framerateConversionAlgorithm" .=) <$>
_hsFramerateConversionAlgorithm,
("codecLevel" .=) <$> _hsCodecLevel,
("framerateControl" .=) <$> _hsFramerateControl,
("adaptiveQuantization" .=) <$>
_hsAdaptiveQuantization,
("framerateNumerator" .=) <$> _hsFramerateNumerator,
("gopBReference" .=) <$> _hsGopBReference,
("maxBitrate" .=) <$> _hsMaxBitrate,
("gopClosedCadence" .=) <$> _hsGopClosedCadence,
("parDenominator" .=) <$> _hsParDenominator,
("spatialAdaptiveQuantization" .=) <$>
_hsSpatialAdaptiveQuantization])
data Hdr10Metadata = Hdr10Metadata'
{ _hmRedPrimaryX :: !(Maybe Int)
, _hmBluePrimaryX :: !(Maybe Int)
, _hmMaxFrameAverageLightLevel :: !(Maybe Int)
, _hmWhitePointY :: !(Maybe Int)
, _hmMaxContentLightLevel :: !(Maybe Int)
, _hmWhitePointX :: !(Maybe Int)
, _hmBluePrimaryY :: !(Maybe Int)
, _hmGreenPrimaryY :: !(Maybe Int)
, _hmGreenPrimaryX :: !(Maybe Int)
, _hmMinLuminance :: !(Maybe Int)
, _hmRedPrimaryY :: !(Maybe Int)
, _hmMaxLuminance :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
hdr10Metadata
:: Hdr10Metadata
hdr10Metadata =
Hdr10Metadata'
{ _hmRedPrimaryX = Nothing
, _hmBluePrimaryX = Nothing
, _hmMaxFrameAverageLightLevel = Nothing
, _hmWhitePointY = Nothing
, _hmMaxContentLightLevel = Nothing
, _hmWhitePointX = Nothing
, _hmBluePrimaryY = Nothing
, _hmGreenPrimaryY = Nothing
, _hmGreenPrimaryX = Nothing
, _hmMinLuminance = Nothing
, _hmRedPrimaryY = Nothing
, _hmMaxLuminance = Nothing
}
hmRedPrimaryX :: Lens' Hdr10Metadata (Maybe Int)
hmRedPrimaryX = lens _hmRedPrimaryX (\ s a -> s{_hmRedPrimaryX = a})
hmBluePrimaryX :: Lens' Hdr10Metadata (Maybe Int)
hmBluePrimaryX = lens _hmBluePrimaryX (\ s a -> s{_hmBluePrimaryX = a})
hmMaxFrameAverageLightLevel :: Lens' Hdr10Metadata (Maybe Int)
hmMaxFrameAverageLightLevel = lens _hmMaxFrameAverageLightLevel (\ s a -> s{_hmMaxFrameAverageLightLevel = a})
hmWhitePointY :: Lens' Hdr10Metadata (Maybe Int)
hmWhitePointY = lens _hmWhitePointY (\ s a -> s{_hmWhitePointY = a})
hmMaxContentLightLevel :: Lens' Hdr10Metadata (Maybe Int)
hmMaxContentLightLevel = lens _hmMaxContentLightLevel (\ s a -> s{_hmMaxContentLightLevel = a})
hmWhitePointX :: Lens' Hdr10Metadata (Maybe Int)
hmWhitePointX = lens _hmWhitePointX (\ s a -> s{_hmWhitePointX = a})
hmBluePrimaryY :: Lens' Hdr10Metadata (Maybe Int)
hmBluePrimaryY = lens _hmBluePrimaryY (\ s a -> s{_hmBluePrimaryY = a})
hmGreenPrimaryY :: Lens' Hdr10Metadata (Maybe Int)
hmGreenPrimaryY = lens _hmGreenPrimaryY (\ s a -> s{_hmGreenPrimaryY = a})
hmGreenPrimaryX :: Lens' Hdr10Metadata (Maybe Int)
hmGreenPrimaryX = lens _hmGreenPrimaryX (\ s a -> s{_hmGreenPrimaryX = a})
hmMinLuminance :: Lens' Hdr10Metadata (Maybe Int)
hmMinLuminance = lens _hmMinLuminance (\ s a -> s{_hmMinLuminance = a})
hmRedPrimaryY :: Lens' Hdr10Metadata (Maybe Int)
hmRedPrimaryY = lens _hmRedPrimaryY (\ s a -> s{_hmRedPrimaryY = a})
hmMaxLuminance :: Lens' Hdr10Metadata (Maybe Int)
hmMaxLuminance = lens _hmMaxLuminance (\ s a -> s{_hmMaxLuminance = a})
instance FromJSON Hdr10Metadata where
parseJSON
= withObject "Hdr10Metadata"
(\ x ->
Hdr10Metadata' <$>
(x .:? "redPrimaryX") <*> (x .:? "bluePrimaryX") <*>
(x .:? "maxFrameAverageLightLevel")
<*> (x .:? "whitePointY")
<*> (x .:? "maxContentLightLevel")
<*> (x .:? "whitePointX")
<*> (x .:? "bluePrimaryY")
<*> (x .:? "greenPrimaryY")
<*> (x .:? "greenPrimaryX")
<*> (x .:? "minLuminance")
<*> (x .:? "redPrimaryY")
<*> (x .:? "maxLuminance"))
instance Hashable Hdr10Metadata where
instance NFData Hdr10Metadata where
instance ToJSON Hdr10Metadata where
toJSON Hdr10Metadata'{..}
= object
(catMaybes
[("redPrimaryX" .=) <$> _hmRedPrimaryX,
("bluePrimaryX" .=) <$> _hmBluePrimaryX,
("maxFrameAverageLightLevel" .=) <$>
_hmMaxFrameAverageLightLevel,
("whitePointY" .=) <$> _hmWhitePointY,
("maxContentLightLevel" .=) <$>
_hmMaxContentLightLevel,
("whitePointX" .=) <$> _hmWhitePointX,
("bluePrimaryY" .=) <$> _hmBluePrimaryY,
("greenPrimaryY" .=) <$> _hmGreenPrimaryY,
("greenPrimaryX" .=) <$> _hmGreenPrimaryX,
("minLuminance" .=) <$> _hmMinLuminance,
("redPrimaryY" .=) <$> _hmRedPrimaryY,
("maxLuminance" .=) <$> _hmMaxLuminance])
data HlsCaptionLanguageMapping = HlsCaptionLanguageMapping'
{ _hclmLanguageCode :: !(Maybe LanguageCode)
, _hclmLanguageDescription :: !(Maybe Text)
, _hclmCaptionChannel :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
hlsCaptionLanguageMapping
:: HlsCaptionLanguageMapping
hlsCaptionLanguageMapping =
HlsCaptionLanguageMapping'
{ _hclmLanguageCode = Nothing
, _hclmLanguageDescription = Nothing
, _hclmCaptionChannel = Nothing
}
hclmLanguageCode :: Lens' HlsCaptionLanguageMapping (Maybe LanguageCode)
hclmLanguageCode = lens _hclmLanguageCode (\ s a -> s{_hclmLanguageCode = a})
hclmLanguageDescription :: Lens' HlsCaptionLanguageMapping (Maybe Text)
hclmLanguageDescription = lens _hclmLanguageDescription (\ s a -> s{_hclmLanguageDescription = a})
hclmCaptionChannel :: Lens' HlsCaptionLanguageMapping (Maybe Int)
hclmCaptionChannel = lens _hclmCaptionChannel (\ s a -> s{_hclmCaptionChannel = a})
instance FromJSON HlsCaptionLanguageMapping where
parseJSON
= withObject "HlsCaptionLanguageMapping"
(\ x ->
HlsCaptionLanguageMapping' <$>
(x .:? "languageCode") <*>
(x .:? "languageDescription")
<*> (x .:? "captionChannel"))
instance Hashable HlsCaptionLanguageMapping where
instance NFData HlsCaptionLanguageMapping where
instance ToJSON HlsCaptionLanguageMapping where
toJSON HlsCaptionLanguageMapping'{..}
= object
(catMaybes
[("languageCode" .=) <$> _hclmLanguageCode,
("languageDescription" .=) <$>
_hclmLanguageDescription,
("captionChannel" .=) <$> _hclmCaptionChannel])
data HlsEncryptionSettings = HlsEncryptionSettings'
{ _hesEncryptionMethod :: !(Maybe HlsEncryptionType)
, _hesConstantInitializationVector :: !(Maybe Text)
, _hesType :: !(Maybe HlsKeyProviderType)
, _hesStaticKeyProvider :: !(Maybe StaticKeyProvider)
, _hesSpekeKeyProvider :: !(Maybe SpekeKeyProvider)
, _hesInitializationVectorInManifest :: !(Maybe HlsInitializationVectorInManifest)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
hlsEncryptionSettings
:: HlsEncryptionSettings
hlsEncryptionSettings =
HlsEncryptionSettings'
{ _hesEncryptionMethod = Nothing
, _hesConstantInitializationVector = Nothing
, _hesType = Nothing
, _hesStaticKeyProvider = Nothing
, _hesSpekeKeyProvider = Nothing
, _hesInitializationVectorInManifest = Nothing
}
hesEncryptionMethod :: Lens' HlsEncryptionSettings (Maybe HlsEncryptionType)
hesEncryptionMethod = lens _hesEncryptionMethod (\ s a -> s{_hesEncryptionMethod = a})
hesConstantInitializationVector :: Lens' HlsEncryptionSettings (Maybe Text)
hesConstantInitializationVector = lens _hesConstantInitializationVector (\ s a -> s{_hesConstantInitializationVector = a})
hesType :: Lens' HlsEncryptionSettings (Maybe HlsKeyProviderType)
hesType = lens _hesType (\ s a -> s{_hesType = a})
hesStaticKeyProvider :: Lens' HlsEncryptionSettings (Maybe StaticKeyProvider)
hesStaticKeyProvider = lens _hesStaticKeyProvider (\ s a -> s{_hesStaticKeyProvider = a})
hesSpekeKeyProvider :: Lens' HlsEncryptionSettings (Maybe SpekeKeyProvider)
hesSpekeKeyProvider = lens _hesSpekeKeyProvider (\ s a -> s{_hesSpekeKeyProvider = a})
hesInitializationVectorInManifest :: Lens' HlsEncryptionSettings (Maybe HlsInitializationVectorInManifest)
hesInitializationVectorInManifest = lens _hesInitializationVectorInManifest (\ s a -> s{_hesInitializationVectorInManifest = a})
instance FromJSON HlsEncryptionSettings where
parseJSON
= withObject "HlsEncryptionSettings"
(\ x ->
HlsEncryptionSettings' <$>
(x .:? "encryptionMethod") <*>
(x .:? "constantInitializationVector")
<*> (x .:? "type")
<*> (x .:? "staticKeyProvider")
<*> (x .:? "spekeKeyProvider")
<*> (x .:? "initializationVectorInManifest"))
instance Hashable HlsEncryptionSettings where
instance NFData HlsEncryptionSettings where
instance ToJSON HlsEncryptionSettings where
toJSON HlsEncryptionSettings'{..}
= object
(catMaybes
[("encryptionMethod" .=) <$> _hesEncryptionMethod,
("constantInitializationVector" .=) <$>
_hesConstantInitializationVector,
("type" .=) <$> _hesType,
("staticKeyProvider" .=) <$> _hesStaticKeyProvider,
("spekeKeyProvider" .=) <$> _hesSpekeKeyProvider,
("initializationVectorInManifest" .=) <$>
_hesInitializationVectorInManifest])
data HlsGroupSettings = HlsGroupSettings'
{ _hgsDirectoryStructure :: !(Maybe HlsDirectoryStructure)
, _hgsSegmentControl :: !(Maybe HlsSegmentControl)
, _hgsDestination :: !(Maybe Text)
, _hgsTimedMetadataId3Period :: !(Maybe Int)
, _hgsMinSegmentLength :: !(Maybe Int)
, _hgsProgramDateTime :: !(Maybe HlsProgramDateTime)
, _hgsProgramDateTimePeriod :: !(Maybe Int)
, _hgsCodecSpecification :: !(Maybe HlsCodecSpecification)
, _hgsCaptionLanguageMappings :: !(Maybe [HlsCaptionLanguageMapping])
, _hgsBaseURL :: !(Maybe Text)
, _hgsAdMarkers :: !(Maybe [HlsAdMarkers])
, _hgsEncryption :: !(Maybe HlsEncryptionSettings)
, _hgsSegmentLength :: !(Maybe Int)
, _hgsTimedMetadataId3Frame :: !(Maybe HlsTimedMetadataId3Frame)
, _hgsOutputSelection :: !(Maybe HlsOutputSelection)
, _hgsCaptionLanguageSetting :: !(Maybe HlsCaptionLanguageSetting)
, _hgsSegmentsPerSubdirectory :: !(Maybe Int)
, _hgsManifestDurationFormat :: !(Maybe HlsManifestDurationFormat)
, _hgsClientCache :: !(Maybe HlsClientCache)
, _hgsTimestampDeltaMilliseconds :: !(Maybe Int)
, _hgsStreamInfResolution :: !(Maybe HlsStreamInfResolution)
, _hgsManifestCompression :: !(Maybe HlsManifestCompression)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
hlsGroupSettings
:: HlsGroupSettings
hlsGroupSettings =
HlsGroupSettings'
{ _hgsDirectoryStructure = Nothing
, _hgsSegmentControl = Nothing
, _hgsDestination = Nothing
, _hgsTimedMetadataId3Period = Nothing
, _hgsMinSegmentLength = Nothing
, _hgsProgramDateTime = Nothing
, _hgsProgramDateTimePeriod = Nothing
, _hgsCodecSpecification = Nothing
, _hgsCaptionLanguageMappings = Nothing
, _hgsBaseURL = Nothing
, _hgsAdMarkers = Nothing
, _hgsEncryption = Nothing
, _hgsSegmentLength = Nothing
, _hgsTimedMetadataId3Frame = Nothing
, _hgsOutputSelection = Nothing
, _hgsCaptionLanguageSetting = Nothing
, _hgsSegmentsPerSubdirectory = Nothing
, _hgsManifestDurationFormat = Nothing
, _hgsClientCache = Nothing
, _hgsTimestampDeltaMilliseconds = Nothing
, _hgsStreamInfResolution = Nothing
, _hgsManifestCompression = Nothing
}
hgsDirectoryStructure :: Lens' HlsGroupSettings (Maybe HlsDirectoryStructure)
hgsDirectoryStructure = lens _hgsDirectoryStructure (\ s a -> s{_hgsDirectoryStructure = a})
hgsSegmentControl :: Lens' HlsGroupSettings (Maybe HlsSegmentControl)
hgsSegmentControl = lens _hgsSegmentControl (\ s a -> s{_hgsSegmentControl = a})
hgsDestination :: Lens' HlsGroupSettings (Maybe Text)
hgsDestination = lens _hgsDestination (\ s a -> s{_hgsDestination = a})
hgsTimedMetadataId3Period :: Lens' HlsGroupSettings (Maybe Int)
hgsTimedMetadataId3Period = lens _hgsTimedMetadataId3Period (\ s a -> s{_hgsTimedMetadataId3Period = a})
hgsMinSegmentLength :: Lens' HlsGroupSettings (Maybe Int)
hgsMinSegmentLength = lens _hgsMinSegmentLength (\ s a -> s{_hgsMinSegmentLength = a})
hgsProgramDateTime :: Lens' HlsGroupSettings (Maybe HlsProgramDateTime)
hgsProgramDateTime = lens _hgsProgramDateTime (\ s a -> s{_hgsProgramDateTime = a})
hgsProgramDateTimePeriod :: Lens' HlsGroupSettings (Maybe Int)
hgsProgramDateTimePeriod = lens _hgsProgramDateTimePeriod (\ s a -> s{_hgsProgramDateTimePeriod = a})
hgsCodecSpecification :: Lens' HlsGroupSettings (Maybe HlsCodecSpecification)
hgsCodecSpecification = lens _hgsCodecSpecification (\ s a -> s{_hgsCodecSpecification = a})
hgsCaptionLanguageMappings :: Lens' HlsGroupSettings [HlsCaptionLanguageMapping]
hgsCaptionLanguageMappings = lens _hgsCaptionLanguageMappings (\ s a -> s{_hgsCaptionLanguageMappings = a}) . _Default . _Coerce
hgsBaseURL :: Lens' HlsGroupSettings (Maybe Text)
hgsBaseURL = lens _hgsBaseURL (\ s a -> s{_hgsBaseURL = a})
hgsAdMarkers :: Lens' HlsGroupSettings [HlsAdMarkers]
hgsAdMarkers = lens _hgsAdMarkers (\ s a -> s{_hgsAdMarkers = a}) . _Default . _Coerce
hgsEncryption :: Lens' HlsGroupSettings (Maybe HlsEncryptionSettings)
hgsEncryption = lens _hgsEncryption (\ s a -> s{_hgsEncryption = a})
hgsSegmentLength :: Lens' HlsGroupSettings (Maybe Int)
hgsSegmentLength = lens _hgsSegmentLength (\ s a -> s{_hgsSegmentLength = a})
hgsTimedMetadataId3Frame :: Lens' HlsGroupSettings (Maybe HlsTimedMetadataId3Frame)
hgsTimedMetadataId3Frame = lens _hgsTimedMetadataId3Frame (\ s a -> s{_hgsTimedMetadataId3Frame = a})
hgsOutputSelection :: Lens' HlsGroupSettings (Maybe HlsOutputSelection)
hgsOutputSelection = lens _hgsOutputSelection (\ s a -> s{_hgsOutputSelection = a})
hgsCaptionLanguageSetting :: Lens' HlsGroupSettings (Maybe HlsCaptionLanguageSetting)
hgsCaptionLanguageSetting = lens _hgsCaptionLanguageSetting (\ s a -> s{_hgsCaptionLanguageSetting = a})
hgsSegmentsPerSubdirectory :: Lens' HlsGroupSettings (Maybe Int)
hgsSegmentsPerSubdirectory = lens _hgsSegmentsPerSubdirectory (\ s a -> s{_hgsSegmentsPerSubdirectory = a})
hgsManifestDurationFormat :: Lens' HlsGroupSettings (Maybe HlsManifestDurationFormat)
hgsManifestDurationFormat = lens _hgsManifestDurationFormat (\ s a -> s{_hgsManifestDurationFormat = a})
hgsClientCache :: Lens' HlsGroupSettings (Maybe HlsClientCache)
hgsClientCache = lens _hgsClientCache (\ s a -> s{_hgsClientCache = a})
hgsTimestampDeltaMilliseconds :: Lens' HlsGroupSettings (Maybe Int)
hgsTimestampDeltaMilliseconds = lens _hgsTimestampDeltaMilliseconds (\ s a -> s{_hgsTimestampDeltaMilliseconds = a})
hgsStreamInfResolution :: Lens' HlsGroupSettings (Maybe HlsStreamInfResolution)
hgsStreamInfResolution = lens _hgsStreamInfResolution (\ s a -> s{_hgsStreamInfResolution = a})
hgsManifestCompression :: Lens' HlsGroupSettings (Maybe HlsManifestCompression)
hgsManifestCompression = lens _hgsManifestCompression (\ s a -> s{_hgsManifestCompression = a})
instance FromJSON HlsGroupSettings where
parseJSON
= withObject "HlsGroupSettings"
(\ x ->
HlsGroupSettings' <$>
(x .:? "directoryStructure") <*>
(x .:? "segmentControl")
<*> (x .:? "destination")
<*> (x .:? "timedMetadataId3Period")
<*> (x .:? "minSegmentLength")
<*> (x .:? "programDateTime")
<*> (x .:? "programDateTimePeriod")
<*> (x .:? "codecSpecification")
<*> (x .:? "captionLanguageMappings" .!= mempty)
<*> (x .:? "baseUrl")
<*> (x .:? "adMarkers" .!= mempty)
<*> (x .:? "encryption")
<*> (x .:? "segmentLength")
<*> (x .:? "timedMetadataId3Frame")
<*> (x .:? "outputSelection")
<*> (x .:? "captionLanguageSetting")
<*> (x .:? "segmentsPerSubdirectory")
<*> (x .:? "manifestDurationFormat")
<*> (x .:? "clientCache")
<*> (x .:? "timestampDeltaMilliseconds")
<*> (x .:? "streamInfResolution")
<*> (x .:? "manifestCompression"))
instance Hashable HlsGroupSettings where
instance NFData HlsGroupSettings where
instance ToJSON HlsGroupSettings where
toJSON HlsGroupSettings'{..}
= object
(catMaybes
[("directoryStructure" .=) <$>
_hgsDirectoryStructure,
("segmentControl" .=) <$> _hgsSegmentControl,
("destination" .=) <$> _hgsDestination,
("timedMetadataId3Period" .=) <$>
_hgsTimedMetadataId3Period,
("minSegmentLength" .=) <$> _hgsMinSegmentLength,
("programDateTime" .=) <$> _hgsProgramDateTime,
("programDateTimePeriod" .=) <$>
_hgsProgramDateTimePeriod,
("codecSpecification" .=) <$> _hgsCodecSpecification,
("captionLanguageMappings" .=) <$>
_hgsCaptionLanguageMappings,
("baseUrl" .=) <$> _hgsBaseURL,
("adMarkers" .=) <$> _hgsAdMarkers,
("encryption" .=) <$> _hgsEncryption,
("segmentLength" .=) <$> _hgsSegmentLength,
("timedMetadataId3Frame" .=) <$>
_hgsTimedMetadataId3Frame,
("outputSelection" .=) <$> _hgsOutputSelection,
("captionLanguageSetting" .=) <$>
_hgsCaptionLanguageSetting,
("segmentsPerSubdirectory" .=) <$>
_hgsSegmentsPerSubdirectory,
("manifestDurationFormat" .=) <$>
_hgsManifestDurationFormat,
("clientCache" .=) <$> _hgsClientCache,
("timestampDeltaMilliseconds" .=) <$>
_hgsTimestampDeltaMilliseconds,
("streamInfResolution" .=) <$>
_hgsStreamInfResolution,
("manifestCompression" .=) <$>
_hgsManifestCompression])
data HlsSettings = HlsSettings'
{ _hsAudioRenditionSets :: !(Maybe Text)
, _hsIFrameOnlyManifest :: !(Maybe HlsIFrameOnlyManifest)
, _hsAudioGroupId :: !(Maybe Text)
, _hsSegmentModifier :: !(Maybe Text)
, _hsAudioTrackType :: !(Maybe HlsAudioTrackType)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
hlsSettings
:: HlsSettings
hlsSettings =
HlsSettings'
{ _hsAudioRenditionSets = Nothing
, _hsIFrameOnlyManifest = Nothing
, _hsAudioGroupId = Nothing
, _hsSegmentModifier = Nothing
, _hsAudioTrackType = Nothing
}
hsAudioRenditionSets :: Lens' HlsSettings (Maybe Text)
hsAudioRenditionSets = lens _hsAudioRenditionSets (\ s a -> s{_hsAudioRenditionSets = a})
hsIFrameOnlyManifest :: Lens' HlsSettings (Maybe HlsIFrameOnlyManifest)
hsIFrameOnlyManifest = lens _hsIFrameOnlyManifest (\ s a -> s{_hsIFrameOnlyManifest = a})
hsAudioGroupId :: Lens' HlsSettings (Maybe Text)
hsAudioGroupId = lens _hsAudioGroupId (\ s a -> s{_hsAudioGroupId = a})
hsSegmentModifier :: Lens' HlsSettings (Maybe Text)
hsSegmentModifier = lens _hsSegmentModifier (\ s a -> s{_hsSegmentModifier = a})
hsAudioTrackType :: Lens' HlsSettings (Maybe HlsAudioTrackType)
hsAudioTrackType = lens _hsAudioTrackType (\ s a -> s{_hsAudioTrackType = a})
instance FromJSON HlsSettings where
parseJSON
= withObject "HlsSettings"
(\ x ->
HlsSettings' <$>
(x .:? "audioRenditionSets") <*>
(x .:? "iFrameOnlyManifest")
<*> (x .:? "audioGroupId")
<*> (x .:? "segmentModifier")
<*> (x .:? "audioTrackType"))
instance Hashable HlsSettings where
instance NFData HlsSettings where
instance ToJSON HlsSettings where
toJSON HlsSettings'{..}
= object
(catMaybes
[("audioRenditionSets" .=) <$> _hsAudioRenditionSets,
("iFrameOnlyManifest" .=) <$> _hsIFrameOnlyManifest,
("audioGroupId" .=) <$> _hsAudioGroupId,
("segmentModifier" .=) <$> _hsSegmentModifier,
("audioTrackType" .=) <$> _hsAudioTrackType])
data Id3Insertion = Id3Insertion'
{ _iiId3 :: !(Maybe Text)
, _iiTimecode :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
id3Insertion
:: Id3Insertion
id3Insertion = Id3Insertion' {_iiId3 = Nothing, _iiTimecode = Nothing}
iiId3 :: Lens' Id3Insertion (Maybe Text)
iiId3 = lens _iiId3 (\ s a -> s{_iiId3 = a})
iiTimecode :: Lens' Id3Insertion (Maybe Text)
iiTimecode = lens _iiTimecode (\ s a -> s{_iiTimecode = a})
instance FromJSON Id3Insertion where
parseJSON
= withObject "Id3Insertion"
(\ x ->
Id3Insertion' <$>
(x .:? "id3") <*> (x .:? "timecode"))
instance Hashable Id3Insertion where
instance NFData Id3Insertion where
instance ToJSON Id3Insertion where
toJSON Id3Insertion'{..}
= object
(catMaybes
[("id3" .=) <$> _iiId3,
("timecode" .=) <$> _iiTimecode])
newtype ImageInserter = ImageInserter'
{ _iiInsertableImages :: Maybe [InsertableImage]
} deriving (Eq, Read, Show, Data, Typeable, Generic)
imageInserter
:: ImageInserter
imageInserter = ImageInserter' {_iiInsertableImages = Nothing}
iiInsertableImages :: Lens' ImageInserter [InsertableImage]
iiInsertableImages = lens _iiInsertableImages (\ s a -> s{_iiInsertableImages = a}) . _Default . _Coerce
instance FromJSON ImageInserter where
parseJSON
= withObject "ImageInserter"
(\ x ->
ImageInserter' <$>
(x .:? "insertableImages" .!= mempty))
instance Hashable ImageInserter where
instance NFData ImageInserter where
instance ToJSON ImageInserter where
toJSON ImageInserter'{..}
= object
(catMaybes
[("insertableImages" .=) <$> _iiInsertableImages])
data Input = Input'
{ _iVideoSelector :: !(Maybe VideoSelector)
, _iProgramNumber :: !(Maybe Int)
, _iAudioSelectorGroups :: !(Maybe (Map Text AudioSelectorGroup))
, _iTimecodeSource :: !(Maybe InputTimecodeSource)
, _iAudioSelectors :: !(Maybe (Map Text AudioSelector))
, _iDeblockFilter :: !(Maybe InputDeblockFilter)
, _iInputClippings :: !(Maybe [InputClipping])
, _iDenoiseFilter :: !(Maybe InputDenoiseFilter)
, _iFilterStrength :: !(Maybe Int)
, _iPsiControl :: !(Maybe InputPsiControl)
, _iCaptionSelectors :: !(Maybe (Map Text CaptionSelector))
, _iFileInput :: !(Maybe Text)
, _iFilterEnable :: !(Maybe InputFilterEnable)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
input
:: Input
input =
Input'
{ _iVideoSelector = Nothing
, _iProgramNumber = Nothing
, _iAudioSelectorGroups = Nothing
, _iTimecodeSource = Nothing
, _iAudioSelectors = Nothing
, _iDeblockFilter = Nothing
, _iInputClippings = Nothing
, _iDenoiseFilter = Nothing
, _iFilterStrength = Nothing
, _iPsiControl = Nothing
, _iCaptionSelectors = Nothing
, _iFileInput = Nothing
, _iFilterEnable = Nothing
}
iVideoSelector :: Lens' Input (Maybe VideoSelector)
iVideoSelector = lens _iVideoSelector (\ s a -> s{_iVideoSelector = a})
iProgramNumber :: Lens' Input (Maybe Int)
iProgramNumber = lens _iProgramNumber (\ s a -> s{_iProgramNumber = a})
iAudioSelectorGroups :: Lens' Input (HashMap Text AudioSelectorGroup)
iAudioSelectorGroups = lens _iAudioSelectorGroups (\ s a -> s{_iAudioSelectorGroups = a}) . _Default . _Map
iTimecodeSource :: Lens' Input (Maybe InputTimecodeSource)
iTimecodeSource = lens _iTimecodeSource (\ s a -> s{_iTimecodeSource = a})
iAudioSelectors :: Lens' Input (HashMap Text AudioSelector)
iAudioSelectors = lens _iAudioSelectors (\ s a -> s{_iAudioSelectors = a}) . _Default . _Map
iDeblockFilter :: Lens' Input (Maybe InputDeblockFilter)
iDeblockFilter = lens _iDeblockFilter (\ s a -> s{_iDeblockFilter = a})
iInputClippings :: Lens' Input [InputClipping]
iInputClippings = lens _iInputClippings (\ s a -> s{_iInputClippings = a}) . _Default . _Coerce
iDenoiseFilter :: Lens' Input (Maybe InputDenoiseFilter)
iDenoiseFilter = lens _iDenoiseFilter (\ s a -> s{_iDenoiseFilter = a})
iFilterStrength :: Lens' Input (Maybe Int)
iFilterStrength = lens _iFilterStrength (\ s a -> s{_iFilterStrength = a})
iPsiControl :: Lens' Input (Maybe InputPsiControl)
iPsiControl = lens _iPsiControl (\ s a -> s{_iPsiControl = a})
iCaptionSelectors :: Lens' Input (HashMap Text CaptionSelector)
iCaptionSelectors = lens _iCaptionSelectors (\ s a -> s{_iCaptionSelectors = a}) . _Default . _Map
iFileInput :: Lens' Input (Maybe Text)
iFileInput = lens _iFileInput (\ s a -> s{_iFileInput = a})
iFilterEnable :: Lens' Input (Maybe InputFilterEnable)
iFilterEnable = lens _iFilterEnable (\ s a -> s{_iFilterEnable = a})
instance FromJSON Input where
parseJSON
= withObject "Input"
(\ x ->
Input' <$>
(x .:? "videoSelector") <*> (x .:? "programNumber")
<*> (x .:? "audioSelectorGroups" .!= mempty)
<*> (x .:? "timecodeSource")
<*> (x .:? "audioSelectors" .!= mempty)
<*> (x .:? "deblockFilter")
<*> (x .:? "inputClippings" .!= mempty)
<*> (x .:? "denoiseFilter")
<*> (x .:? "filterStrength")
<*> (x .:? "psiControl")
<*> (x .:? "captionSelectors" .!= mempty)
<*> (x .:? "fileInput")
<*> (x .:? "filterEnable"))
instance Hashable Input where
instance NFData Input where
instance ToJSON Input where
toJSON Input'{..}
= object
(catMaybes
[("videoSelector" .=) <$> _iVideoSelector,
("programNumber" .=) <$> _iProgramNumber,
("audioSelectorGroups" .=) <$> _iAudioSelectorGroups,
("timecodeSource" .=) <$> _iTimecodeSource,
("audioSelectors" .=) <$> _iAudioSelectors,
("deblockFilter" .=) <$> _iDeblockFilter,
("inputClippings" .=) <$> _iInputClippings,
("denoiseFilter" .=) <$> _iDenoiseFilter,
("filterStrength" .=) <$> _iFilterStrength,
("psiControl" .=) <$> _iPsiControl,
("captionSelectors" .=) <$> _iCaptionSelectors,
("fileInput" .=) <$> _iFileInput,
("filterEnable" .=) <$> _iFilterEnable])
data InputClipping = InputClipping'
{ _icEndTimecode :: !(Maybe Text)
, _icStartTimecode :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputClipping
:: InputClipping
inputClipping =
InputClipping' {_icEndTimecode = Nothing, _icStartTimecode = Nothing}
icEndTimecode :: Lens' InputClipping (Maybe Text)
icEndTimecode = lens _icEndTimecode (\ s a -> s{_icEndTimecode = a})
icStartTimecode :: Lens' InputClipping (Maybe Text)
icStartTimecode = lens _icStartTimecode (\ s a -> s{_icStartTimecode = a})
instance FromJSON InputClipping where
parseJSON
= withObject "InputClipping"
(\ x ->
InputClipping' <$>
(x .:? "endTimecode") <*> (x .:? "startTimecode"))
instance Hashable InputClipping where
instance NFData InputClipping where
instance ToJSON InputClipping where
toJSON InputClipping'{..}
= object
(catMaybes
[("endTimecode" .=) <$> _icEndTimecode,
("startTimecode" .=) <$> _icStartTimecode])
data InputTemplate = InputTemplate'
{ _itVideoSelector :: !(Maybe VideoSelector)
, _itProgramNumber :: !(Maybe Int)
, _itAudioSelectorGroups :: !(Maybe (Map Text AudioSelectorGroup))
, _itTimecodeSource :: !(Maybe InputTimecodeSource)
, _itAudioSelectors :: !(Maybe (Map Text AudioSelector))
, _itDeblockFilter :: !(Maybe InputDeblockFilter)
, _itInputClippings :: !(Maybe [InputClipping])
, _itDenoiseFilter :: !(Maybe InputDenoiseFilter)
, _itFilterStrength :: !(Maybe Int)
, _itPsiControl :: !(Maybe InputPsiControl)
, _itCaptionSelectors :: !(Maybe (Map Text CaptionSelector))
, _itFilterEnable :: !(Maybe InputFilterEnable)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
inputTemplate
:: InputTemplate
inputTemplate =
InputTemplate'
{ _itVideoSelector = Nothing
, _itProgramNumber = Nothing
, _itAudioSelectorGroups = Nothing
, _itTimecodeSource = Nothing
, _itAudioSelectors = Nothing
, _itDeblockFilter = Nothing
, _itInputClippings = Nothing
, _itDenoiseFilter = Nothing
, _itFilterStrength = Nothing
, _itPsiControl = Nothing
, _itCaptionSelectors = Nothing
, _itFilterEnable = Nothing
}
itVideoSelector :: Lens' InputTemplate (Maybe VideoSelector)
itVideoSelector = lens _itVideoSelector (\ s a -> s{_itVideoSelector = a})
itProgramNumber :: Lens' InputTemplate (Maybe Int)
itProgramNumber = lens _itProgramNumber (\ s a -> s{_itProgramNumber = a})
itAudioSelectorGroups :: Lens' InputTemplate (HashMap Text AudioSelectorGroup)
itAudioSelectorGroups = lens _itAudioSelectorGroups (\ s a -> s{_itAudioSelectorGroups = a}) . _Default . _Map
itTimecodeSource :: Lens' InputTemplate (Maybe InputTimecodeSource)
itTimecodeSource = lens _itTimecodeSource (\ s a -> s{_itTimecodeSource = a})
itAudioSelectors :: Lens' InputTemplate (HashMap Text AudioSelector)
itAudioSelectors = lens _itAudioSelectors (\ s a -> s{_itAudioSelectors = a}) . _Default . _Map
itDeblockFilter :: Lens' InputTemplate (Maybe InputDeblockFilter)
itDeblockFilter = lens _itDeblockFilter (\ s a -> s{_itDeblockFilter = a})
itInputClippings :: Lens' InputTemplate [InputClipping]
itInputClippings = lens _itInputClippings (\ s a -> s{_itInputClippings = a}) . _Default . _Coerce
itDenoiseFilter :: Lens' InputTemplate (Maybe InputDenoiseFilter)
itDenoiseFilter = lens _itDenoiseFilter (\ s a -> s{_itDenoiseFilter = a})
itFilterStrength :: Lens' InputTemplate (Maybe Int)
itFilterStrength = lens _itFilterStrength (\ s a -> s{_itFilterStrength = a})
itPsiControl :: Lens' InputTemplate (Maybe InputPsiControl)
itPsiControl = lens _itPsiControl (\ s a -> s{_itPsiControl = a})
itCaptionSelectors :: Lens' InputTemplate (HashMap Text CaptionSelector)
itCaptionSelectors = lens _itCaptionSelectors (\ s a -> s{_itCaptionSelectors = a}) . _Default . _Map
itFilterEnable :: Lens' InputTemplate (Maybe InputFilterEnable)
itFilterEnable = lens _itFilterEnable (\ s a -> s{_itFilterEnable = a})
instance FromJSON InputTemplate where
parseJSON
= withObject "InputTemplate"
(\ x ->
InputTemplate' <$>
(x .:? "videoSelector") <*> (x .:? "programNumber")
<*> (x .:? "audioSelectorGroups" .!= mempty)
<*> (x .:? "timecodeSource")
<*> (x .:? "audioSelectors" .!= mempty)
<*> (x .:? "deblockFilter")
<*> (x .:? "inputClippings" .!= mempty)
<*> (x .:? "denoiseFilter")
<*> (x .:? "filterStrength")
<*> (x .:? "psiControl")
<*> (x .:? "captionSelectors" .!= mempty)
<*> (x .:? "filterEnable"))
instance Hashable InputTemplate where
instance NFData InputTemplate where
instance ToJSON InputTemplate where
toJSON InputTemplate'{..}
= object
(catMaybes
[("videoSelector" .=) <$> _itVideoSelector,
("programNumber" .=) <$> _itProgramNumber,
("audioSelectorGroups" .=) <$>
_itAudioSelectorGroups,
("timecodeSource" .=) <$> _itTimecodeSource,
("audioSelectors" .=) <$> _itAudioSelectors,
("deblockFilter" .=) <$> _itDeblockFilter,
("inputClippings" .=) <$> _itInputClippings,
("denoiseFilter" .=) <$> _itDenoiseFilter,
("filterStrength" .=) <$> _itFilterStrength,
("psiControl" .=) <$> _itPsiControl,
("captionSelectors" .=) <$> _itCaptionSelectors,
("filterEnable" .=) <$> _itFilterEnable])
data InsertableImage = InsertableImage'
{ _iiImageX :: !(Maybe Int)
, _iiHeight :: !(Maybe Int)
, _iiStartTime :: !(Maybe Text)
, _iiFadeOut :: !(Maybe Int)
, _iiWidth :: !(Maybe Int)
, _iiOpacity :: !(Maybe Int)
, _iiLayer :: !(Maybe Int)
, _iiDuration :: !(Maybe Int)
, _iiImageY :: !(Maybe Int)
, _iiImageInserterInput :: !(Maybe Text)
, _iiFadeIn :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
insertableImage
:: InsertableImage
insertableImage =
InsertableImage'
{ _iiImageX = Nothing
, _iiHeight = Nothing
, _iiStartTime = Nothing
, _iiFadeOut = Nothing
, _iiWidth = Nothing
, _iiOpacity = Nothing
, _iiLayer = Nothing
, _iiDuration = Nothing
, _iiImageY = Nothing
, _iiImageInserterInput = Nothing
, _iiFadeIn = Nothing
}
iiImageX :: Lens' InsertableImage (Maybe Int)
iiImageX = lens _iiImageX (\ s a -> s{_iiImageX = a})
iiHeight :: Lens' InsertableImage (Maybe Int)
iiHeight = lens _iiHeight (\ s a -> s{_iiHeight = a})
iiStartTime :: Lens' InsertableImage (Maybe Text)
iiStartTime = lens _iiStartTime (\ s a -> s{_iiStartTime = a})
iiFadeOut :: Lens' InsertableImage (Maybe Int)
iiFadeOut = lens _iiFadeOut (\ s a -> s{_iiFadeOut = a})
iiWidth :: Lens' InsertableImage (Maybe Int)
iiWidth = lens _iiWidth (\ s a -> s{_iiWidth = a})
iiOpacity :: Lens' InsertableImage (Maybe Int)
iiOpacity = lens _iiOpacity (\ s a -> s{_iiOpacity = a})
iiLayer :: Lens' InsertableImage (Maybe Int)
iiLayer = lens _iiLayer (\ s a -> s{_iiLayer = a})
iiDuration :: Lens' InsertableImage (Maybe Int)
iiDuration = lens _iiDuration (\ s a -> s{_iiDuration = a})
iiImageY :: Lens' InsertableImage (Maybe Int)
iiImageY = lens _iiImageY (\ s a -> s{_iiImageY = a})
iiImageInserterInput :: Lens' InsertableImage (Maybe Text)
iiImageInserterInput = lens _iiImageInserterInput (\ s a -> s{_iiImageInserterInput = a})
iiFadeIn :: Lens' InsertableImage (Maybe Int)
iiFadeIn = lens _iiFadeIn (\ s a -> s{_iiFadeIn = a})
instance FromJSON InsertableImage where
parseJSON
= withObject "InsertableImage"
(\ x ->
InsertableImage' <$>
(x .:? "imageX") <*> (x .:? "height") <*>
(x .:? "startTime")
<*> (x .:? "fadeOut")
<*> (x .:? "width")
<*> (x .:? "opacity")
<*> (x .:? "layer")
<*> (x .:? "duration")
<*> (x .:? "imageY")
<*> (x .:? "imageInserterInput")
<*> (x .:? "fadeIn"))
instance Hashable InsertableImage where
instance NFData InsertableImage where
instance ToJSON InsertableImage where
toJSON InsertableImage'{..}
= object
(catMaybes
[("imageX" .=) <$> _iiImageX,
("height" .=) <$> _iiHeight,
("startTime" .=) <$> _iiStartTime,
("fadeOut" .=) <$> _iiFadeOut,
("width" .=) <$> _iiWidth,
("opacity" .=) <$> _iiOpacity,
("layer" .=) <$> _iiLayer,
("duration" .=) <$> _iiDuration,
("imageY" .=) <$> _iiImageY,
("imageInserterInput" .=) <$> _iiImageInserterInput,
("fadeIn" .=) <$> _iiFadeIn])
data Job = Job'
{ _jStatus :: !(Maybe JobStatus)
, _jJobTemplate :: !(Maybe Text)
, _jSettings :: !(Maybe JobSettings)
, _jARN :: !(Maybe Text)
, _jCreatedAt :: !(Maybe POSIX)
, _jQueue :: !(Maybe Text)
, _jUserMetadata :: !(Maybe (Map Text Text))
, _jRole :: !(Maybe Text)
, _jOutputGroupDetails :: !(Maybe [OutputGroupDetail])
, _jErrorCode :: !(Maybe Int)
, _jId :: !(Maybe Text)
, _jTiming :: !(Maybe Timing)
, _jErrorMessage :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
job
:: Job
job =
Job'
{ _jStatus = Nothing
, _jJobTemplate = Nothing
, _jSettings = Nothing
, _jARN = Nothing
, _jCreatedAt = Nothing
, _jQueue = Nothing
, _jUserMetadata = Nothing
, _jRole = Nothing
, _jOutputGroupDetails = Nothing
, _jErrorCode = Nothing
, _jId = Nothing
, _jTiming = Nothing
, _jErrorMessage = Nothing
}
jStatus :: Lens' Job (Maybe JobStatus)
jStatus = lens _jStatus (\ s a -> s{_jStatus = a})
jJobTemplate :: Lens' Job (Maybe Text)
jJobTemplate = lens _jJobTemplate (\ s a -> s{_jJobTemplate = a})
jSettings :: Lens' Job (Maybe JobSettings)
jSettings = lens _jSettings (\ s a -> s{_jSettings = a})
jARN :: Lens' Job (Maybe Text)
jARN = lens _jARN (\ s a -> s{_jARN = a})
jCreatedAt :: Lens' Job (Maybe UTCTime)
jCreatedAt = lens _jCreatedAt (\ s a -> s{_jCreatedAt = a}) . mapping _Time
jQueue :: Lens' Job (Maybe Text)
jQueue = lens _jQueue (\ s a -> s{_jQueue = a})
jUserMetadata :: Lens' Job (HashMap Text Text)
jUserMetadata = lens _jUserMetadata (\ s a -> s{_jUserMetadata = a}) . _Default . _Map
jRole :: Lens' Job (Maybe Text)
jRole = lens _jRole (\ s a -> s{_jRole = a})
jOutputGroupDetails :: Lens' Job [OutputGroupDetail]
jOutputGroupDetails = lens _jOutputGroupDetails (\ s a -> s{_jOutputGroupDetails = a}) . _Default . _Coerce
jErrorCode :: Lens' Job (Maybe Int)
jErrorCode = lens _jErrorCode (\ s a -> s{_jErrorCode = a})
jId :: Lens' Job (Maybe Text)
jId = lens _jId (\ s a -> s{_jId = a})
jTiming :: Lens' Job (Maybe Timing)
jTiming = lens _jTiming (\ s a -> s{_jTiming = a})
jErrorMessage :: Lens' Job (Maybe Text)
jErrorMessage = lens _jErrorMessage (\ s a -> s{_jErrorMessage = a})
instance FromJSON Job where
parseJSON
= withObject "Job"
(\ x ->
Job' <$>
(x .:? "status") <*> (x .:? "jobTemplate") <*>
(x .:? "settings")
<*> (x .:? "arn")
<*> (x .:? "createdAt")
<*> (x .:? "queue")
<*> (x .:? "userMetadata" .!= mempty)
<*> (x .:? "role")
<*> (x .:? "outputGroupDetails" .!= mempty)
<*> (x .:? "errorCode")
<*> (x .:? "id")
<*> (x .:? "timing")
<*> (x .:? "errorMessage"))
instance Hashable Job where
instance NFData Job where
data JobSettings = JobSettings'
{ _jsInputs :: !(Maybe [Input])
, _jsTimedMetadataInsertion :: !(Maybe TimedMetadataInsertion)
, _jsNielsenConfiguration :: !(Maybe NielsenConfiguration)
, _jsAvailBlanking :: !(Maybe AvailBlanking)
, _jsTimecodeConfig :: !(Maybe TimecodeConfig)
, _jsOutputGroups :: !(Maybe [OutputGroup])
, _jsAdAvailOffset :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
jobSettings
:: JobSettings
jobSettings =
JobSettings'
{ _jsInputs = Nothing
, _jsTimedMetadataInsertion = Nothing
, _jsNielsenConfiguration = Nothing
, _jsAvailBlanking = Nothing
, _jsTimecodeConfig = Nothing
, _jsOutputGroups = Nothing
, _jsAdAvailOffset = Nothing
}
jsInputs :: Lens' JobSettings [Input]
jsInputs = lens _jsInputs (\ s a -> s{_jsInputs = a}) . _Default . _Coerce
jsTimedMetadataInsertion :: Lens' JobSettings (Maybe TimedMetadataInsertion)
jsTimedMetadataInsertion = lens _jsTimedMetadataInsertion (\ s a -> s{_jsTimedMetadataInsertion = a})
jsNielsenConfiguration :: Lens' JobSettings (Maybe NielsenConfiguration)
jsNielsenConfiguration = lens _jsNielsenConfiguration (\ s a -> s{_jsNielsenConfiguration = a})
jsAvailBlanking :: Lens' JobSettings (Maybe AvailBlanking)
jsAvailBlanking = lens _jsAvailBlanking (\ s a -> s{_jsAvailBlanking = a})
jsTimecodeConfig :: Lens' JobSettings (Maybe TimecodeConfig)
jsTimecodeConfig = lens _jsTimecodeConfig (\ s a -> s{_jsTimecodeConfig = a})
jsOutputGroups :: Lens' JobSettings [OutputGroup]
jsOutputGroups = lens _jsOutputGroups (\ s a -> s{_jsOutputGroups = a}) . _Default . _Coerce
jsAdAvailOffset :: Lens' JobSettings (Maybe Int)
jsAdAvailOffset = lens _jsAdAvailOffset (\ s a -> s{_jsAdAvailOffset = a})
instance FromJSON JobSettings where
parseJSON
= withObject "JobSettings"
(\ x ->
JobSettings' <$>
(x .:? "inputs" .!= mempty) <*>
(x .:? "timedMetadataInsertion")
<*> (x .:? "nielsenConfiguration")
<*> (x .:? "availBlanking")
<*> (x .:? "timecodeConfig")
<*> (x .:? "outputGroups" .!= mempty)
<*> (x .:? "adAvailOffset"))
instance Hashable JobSettings where
instance NFData JobSettings where
instance ToJSON JobSettings where
toJSON JobSettings'{..}
= object
(catMaybes
[("inputs" .=) <$> _jsInputs,
("timedMetadataInsertion" .=) <$>
_jsTimedMetadataInsertion,
("nielsenConfiguration" .=) <$>
_jsNielsenConfiguration,
("availBlanking" .=) <$> _jsAvailBlanking,
("timecodeConfig" .=) <$> _jsTimecodeConfig,
("outputGroups" .=) <$> _jsOutputGroups,
("adAvailOffset" .=) <$> _jsAdAvailOffset])
data JobTemplate = JobTemplate'
{ _jtLastUpdated :: !(Maybe POSIX)
, _jtSettings :: !(Maybe JobTemplateSettings)
, _jtARN :: !(Maybe Text)
, _jtCreatedAt :: !(Maybe POSIX)
, _jtCategory :: !(Maybe Text)
, _jtQueue :: !(Maybe Text)
, _jtName :: !(Maybe Text)
, _jtType :: !(Maybe Type)
, _jtDescription :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
jobTemplate
:: JobTemplate
jobTemplate =
JobTemplate'
{ _jtLastUpdated = Nothing
, _jtSettings = Nothing
, _jtARN = Nothing
, _jtCreatedAt = Nothing
, _jtCategory = Nothing
, _jtQueue = Nothing
, _jtName = Nothing
, _jtType = Nothing
, _jtDescription = Nothing
}
jtLastUpdated :: Lens' JobTemplate (Maybe UTCTime)
jtLastUpdated = lens _jtLastUpdated (\ s a -> s{_jtLastUpdated = a}) . mapping _Time
jtSettings :: Lens' JobTemplate (Maybe JobTemplateSettings)
jtSettings = lens _jtSettings (\ s a -> s{_jtSettings = a})
jtARN :: Lens' JobTemplate (Maybe Text)
jtARN = lens _jtARN (\ s a -> s{_jtARN = a})
jtCreatedAt :: Lens' JobTemplate (Maybe UTCTime)
jtCreatedAt = lens _jtCreatedAt (\ s a -> s{_jtCreatedAt = a}) . mapping _Time
jtCategory :: Lens' JobTemplate (Maybe Text)
jtCategory = lens _jtCategory (\ s a -> s{_jtCategory = a})
jtQueue :: Lens' JobTemplate (Maybe Text)
jtQueue = lens _jtQueue (\ s a -> s{_jtQueue = a})
jtName :: Lens' JobTemplate (Maybe Text)
jtName = lens _jtName (\ s a -> s{_jtName = a})
jtType :: Lens' JobTemplate (Maybe Type)
jtType = lens _jtType (\ s a -> s{_jtType = a})
jtDescription :: Lens' JobTemplate (Maybe Text)
jtDescription = lens _jtDescription (\ s a -> s{_jtDescription = a})
instance FromJSON JobTemplate where
parseJSON
= withObject "JobTemplate"
(\ x ->
JobTemplate' <$>
(x .:? "lastUpdated") <*> (x .:? "settings") <*>
(x .:? "arn")
<*> (x .:? "createdAt")
<*> (x .:? "category")
<*> (x .:? "queue")
<*> (x .:? "name")
<*> (x .:? "type")
<*> (x .:? "description"))
instance Hashable JobTemplate where
instance NFData JobTemplate where
data JobTemplateSettings = JobTemplateSettings'
{ _jtsInputs :: !(Maybe [InputTemplate])
, _jtsTimedMetadataInsertion :: !(Maybe TimedMetadataInsertion)
, _jtsNielsenConfiguration :: !(Maybe NielsenConfiguration)
, _jtsAvailBlanking :: !(Maybe AvailBlanking)
, _jtsTimecodeConfig :: !(Maybe TimecodeConfig)
, _jtsOutputGroups :: !(Maybe [OutputGroup])
, _jtsAdAvailOffset :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
jobTemplateSettings
:: JobTemplateSettings
jobTemplateSettings =
JobTemplateSettings'
{ _jtsInputs = Nothing
, _jtsTimedMetadataInsertion = Nothing
, _jtsNielsenConfiguration = Nothing
, _jtsAvailBlanking = Nothing
, _jtsTimecodeConfig = Nothing
, _jtsOutputGroups = Nothing
, _jtsAdAvailOffset = Nothing
}
jtsInputs :: Lens' JobTemplateSettings [InputTemplate]
jtsInputs = lens _jtsInputs (\ s a -> s{_jtsInputs = a}) . _Default . _Coerce
jtsTimedMetadataInsertion :: Lens' JobTemplateSettings (Maybe TimedMetadataInsertion)
jtsTimedMetadataInsertion = lens _jtsTimedMetadataInsertion (\ s a -> s{_jtsTimedMetadataInsertion = a})
jtsNielsenConfiguration :: Lens' JobTemplateSettings (Maybe NielsenConfiguration)
jtsNielsenConfiguration = lens _jtsNielsenConfiguration (\ s a -> s{_jtsNielsenConfiguration = a})
jtsAvailBlanking :: Lens' JobTemplateSettings (Maybe AvailBlanking)
jtsAvailBlanking = lens _jtsAvailBlanking (\ s a -> s{_jtsAvailBlanking = a})
jtsTimecodeConfig :: Lens' JobTemplateSettings (Maybe TimecodeConfig)
jtsTimecodeConfig = lens _jtsTimecodeConfig (\ s a -> s{_jtsTimecodeConfig = a})
jtsOutputGroups :: Lens' JobTemplateSettings [OutputGroup]
jtsOutputGroups = lens _jtsOutputGroups (\ s a -> s{_jtsOutputGroups = a}) . _Default . _Coerce
jtsAdAvailOffset :: Lens' JobTemplateSettings (Maybe Int)
jtsAdAvailOffset = lens _jtsAdAvailOffset (\ s a -> s{_jtsAdAvailOffset = a})
instance FromJSON JobTemplateSettings where
parseJSON
= withObject "JobTemplateSettings"
(\ x ->
JobTemplateSettings' <$>
(x .:? "inputs" .!= mempty) <*>
(x .:? "timedMetadataInsertion")
<*> (x .:? "nielsenConfiguration")
<*> (x .:? "availBlanking")
<*> (x .:? "timecodeConfig")
<*> (x .:? "outputGroups" .!= mempty)
<*> (x .:? "adAvailOffset"))
instance Hashable JobTemplateSettings where
instance NFData JobTemplateSettings where
instance ToJSON JobTemplateSettings where
toJSON JobTemplateSettings'{..}
= object
(catMaybes
[("inputs" .=) <$> _jtsInputs,
("timedMetadataInsertion" .=) <$>
_jtsTimedMetadataInsertion,
("nielsenConfiguration" .=) <$>
_jtsNielsenConfiguration,
("availBlanking" .=) <$> _jtsAvailBlanking,
("timecodeConfig" .=) <$> _jtsTimecodeConfig,
("outputGroups" .=) <$> _jtsOutputGroups,
("adAvailOffset" .=) <$> _jtsAdAvailOffset])
data M2tsSettings = M2tsSettings'
{ _mPmtPid :: !(Maybe Int)
, _mVideoPid :: !(Maybe Int)
, _mBufferModel :: !(Maybe M2tsBufferModel)
, _mProgramNumber :: !(Maybe Int)
, _mScte35Pid :: !(Maybe Int)
, _mMinEbpInterval :: !(Maybe Int)
, _mTransportStreamId :: !(Maybe Int)
, _mMaxPcrInterval :: !(Maybe Int)
, _mFragmentTime :: !(Maybe Double)
, _mPrivateMetadataPid :: !(Maybe Int)
, _mPmtInterval :: !(Maybe Int)
, _mDvbSdtSettings :: !(Maybe DvbSdtSettings)
, _mNullPacketBitrate :: !(Maybe Double)
, _mAudioBufferModel :: !(Maybe M2tsAudioBufferModel)
, _mTimedMetadataPid :: !(Maybe Int)
, _mAudioFramesPerPes :: !(Maybe Int)
, _mPcrPid :: !(Maybe Int)
, _mSegmentationMarkers :: !(Maybe M2tsSegmentationMarkers)
, _mDvbSubPids :: !(Maybe [Int])
, _mScte35Source :: !(Maybe M2tsScte35Source)
, _mPatInterval :: !(Maybe Int)
, _mEsRateInPes :: !(Maybe M2tsEsRateInPes)
, _mBitrate :: !(Maybe Int)
, _mAudioPids :: !(Maybe [Int])
, _mDvbTeletextPid :: !(Maybe Int)
, _mNielsenId3 :: !(Maybe M2tsNielsenId3)
, _mSegmentationTime :: !(Maybe Double)
, _mEbpAudioInterval :: !(Maybe M2tsEbpAudioInterval)
, _mDvbNitSettings :: !(Maybe DvbNitSettings)
, _mPcrControl :: !(Maybe M2tsPcrControl)
, _mEbpPlacement :: !(Maybe M2tsEbpPlacement)
, _mRateMode :: !(Maybe M2tsRateMode)
, _mSegmentationStyle :: !(Maybe M2tsSegmentationStyle)
, _mDvbTdtSettings :: !(Maybe DvbTdtSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
m2tsSettings
:: M2tsSettings
m2tsSettings =
M2tsSettings'
{ _mPmtPid = Nothing
, _mVideoPid = Nothing
, _mBufferModel = Nothing
, _mProgramNumber = Nothing
, _mScte35Pid = Nothing
, _mMinEbpInterval = Nothing
, _mTransportStreamId = Nothing
, _mMaxPcrInterval = Nothing
, _mFragmentTime = Nothing
, _mPrivateMetadataPid = Nothing
, _mPmtInterval = Nothing
, _mDvbSdtSettings = Nothing
, _mNullPacketBitrate = Nothing
, _mAudioBufferModel = Nothing
, _mTimedMetadataPid = Nothing
, _mAudioFramesPerPes = Nothing
, _mPcrPid = Nothing
, _mSegmentationMarkers = Nothing
, _mDvbSubPids = Nothing
, _mScte35Source = Nothing
, _mPatInterval = Nothing
, _mEsRateInPes = Nothing
, _mBitrate = Nothing
, _mAudioPids = Nothing
, _mDvbTeletextPid = Nothing
, _mNielsenId3 = Nothing
, _mSegmentationTime = Nothing
, _mEbpAudioInterval = Nothing
, _mDvbNitSettings = Nothing
, _mPcrControl = Nothing
, _mEbpPlacement = Nothing
, _mRateMode = Nothing
, _mSegmentationStyle = Nothing
, _mDvbTdtSettings = Nothing
}
mPmtPid :: Lens' M2tsSettings (Maybe Int)
mPmtPid = lens _mPmtPid (\ s a -> s{_mPmtPid = a})
mVideoPid :: Lens' M2tsSettings (Maybe Int)
mVideoPid = lens _mVideoPid (\ s a -> s{_mVideoPid = a})
mBufferModel :: Lens' M2tsSettings (Maybe M2tsBufferModel)
mBufferModel = lens _mBufferModel (\ s a -> s{_mBufferModel = a})
mProgramNumber :: Lens' M2tsSettings (Maybe Int)
mProgramNumber = lens _mProgramNumber (\ s a -> s{_mProgramNumber = a})
mScte35Pid :: Lens' M2tsSettings (Maybe Int)
mScte35Pid = lens _mScte35Pid (\ s a -> s{_mScte35Pid = a})
mMinEbpInterval :: Lens' M2tsSettings (Maybe Int)
mMinEbpInterval = lens _mMinEbpInterval (\ s a -> s{_mMinEbpInterval = a})
mTransportStreamId :: Lens' M2tsSettings (Maybe Int)
mTransportStreamId = lens _mTransportStreamId (\ s a -> s{_mTransportStreamId = a})
mMaxPcrInterval :: Lens' M2tsSettings (Maybe Int)
mMaxPcrInterval = lens _mMaxPcrInterval (\ s a -> s{_mMaxPcrInterval = a})
mFragmentTime :: Lens' M2tsSettings (Maybe Double)
mFragmentTime = lens _mFragmentTime (\ s a -> s{_mFragmentTime = a})
mPrivateMetadataPid :: Lens' M2tsSettings (Maybe Int)
mPrivateMetadataPid = lens _mPrivateMetadataPid (\ s a -> s{_mPrivateMetadataPid = a})
mPmtInterval :: Lens' M2tsSettings (Maybe Int)
mPmtInterval = lens _mPmtInterval (\ s a -> s{_mPmtInterval = a})
mDvbSdtSettings :: Lens' M2tsSettings (Maybe DvbSdtSettings)
mDvbSdtSettings = lens _mDvbSdtSettings (\ s a -> s{_mDvbSdtSettings = a})
mNullPacketBitrate :: Lens' M2tsSettings (Maybe Double)
mNullPacketBitrate = lens _mNullPacketBitrate (\ s a -> s{_mNullPacketBitrate = a})
mAudioBufferModel :: Lens' M2tsSettings (Maybe M2tsAudioBufferModel)
mAudioBufferModel = lens _mAudioBufferModel (\ s a -> s{_mAudioBufferModel = a})
mTimedMetadataPid :: Lens' M2tsSettings (Maybe Int)
mTimedMetadataPid = lens _mTimedMetadataPid (\ s a -> s{_mTimedMetadataPid = a})
mAudioFramesPerPes :: Lens' M2tsSettings (Maybe Int)
mAudioFramesPerPes = lens _mAudioFramesPerPes (\ s a -> s{_mAudioFramesPerPes = a})
mPcrPid :: Lens' M2tsSettings (Maybe Int)
mPcrPid = lens _mPcrPid (\ s a -> s{_mPcrPid = a})
mSegmentationMarkers :: Lens' M2tsSettings (Maybe M2tsSegmentationMarkers)
mSegmentationMarkers = lens _mSegmentationMarkers (\ s a -> s{_mSegmentationMarkers = a})
mDvbSubPids :: Lens' M2tsSettings [Int]
mDvbSubPids = lens _mDvbSubPids (\ s a -> s{_mDvbSubPids = a}) . _Default . _Coerce
mScte35Source :: Lens' M2tsSettings (Maybe M2tsScte35Source)
mScte35Source = lens _mScte35Source (\ s a -> s{_mScte35Source = a})
mPatInterval :: Lens' M2tsSettings (Maybe Int)
mPatInterval = lens _mPatInterval (\ s a -> s{_mPatInterval = a})
mEsRateInPes :: Lens' M2tsSettings (Maybe M2tsEsRateInPes)
mEsRateInPes = lens _mEsRateInPes (\ s a -> s{_mEsRateInPes = a})
mBitrate :: Lens' M2tsSettings (Maybe Int)
mBitrate = lens _mBitrate (\ s a -> s{_mBitrate = a})
mAudioPids :: Lens' M2tsSettings [Int]
mAudioPids = lens _mAudioPids (\ s a -> s{_mAudioPids = a}) . _Default . _Coerce
mDvbTeletextPid :: Lens' M2tsSettings (Maybe Int)
mDvbTeletextPid = lens _mDvbTeletextPid (\ s a -> s{_mDvbTeletextPid = a})
mNielsenId3 :: Lens' M2tsSettings (Maybe M2tsNielsenId3)
mNielsenId3 = lens _mNielsenId3 (\ s a -> s{_mNielsenId3 = a})
mSegmentationTime :: Lens' M2tsSettings (Maybe Double)
mSegmentationTime = lens _mSegmentationTime (\ s a -> s{_mSegmentationTime = a})
mEbpAudioInterval :: Lens' M2tsSettings (Maybe M2tsEbpAudioInterval)
mEbpAudioInterval = lens _mEbpAudioInterval (\ s a -> s{_mEbpAudioInterval = a})
mDvbNitSettings :: Lens' M2tsSettings (Maybe DvbNitSettings)
mDvbNitSettings = lens _mDvbNitSettings (\ s a -> s{_mDvbNitSettings = a})
mPcrControl :: Lens' M2tsSettings (Maybe M2tsPcrControl)
mPcrControl = lens _mPcrControl (\ s a -> s{_mPcrControl = a})
mEbpPlacement :: Lens' M2tsSettings (Maybe M2tsEbpPlacement)
mEbpPlacement = lens _mEbpPlacement (\ s a -> s{_mEbpPlacement = a})
mRateMode :: Lens' M2tsSettings (Maybe M2tsRateMode)
mRateMode = lens _mRateMode (\ s a -> s{_mRateMode = a})
mSegmentationStyle :: Lens' M2tsSettings (Maybe M2tsSegmentationStyle)
mSegmentationStyle = lens _mSegmentationStyle (\ s a -> s{_mSegmentationStyle = a})
mDvbTdtSettings :: Lens' M2tsSettings (Maybe DvbTdtSettings)
mDvbTdtSettings = lens _mDvbTdtSettings (\ s a -> s{_mDvbTdtSettings = a})
instance FromJSON M2tsSettings where
parseJSON
= withObject "M2tsSettings"
(\ x ->
M2tsSettings' <$>
(x .:? "pmtPid") <*> (x .:? "videoPid") <*>
(x .:? "bufferModel")
<*> (x .:? "programNumber")
<*> (x .:? "scte35Pid")
<*> (x .:? "minEbpInterval")
<*> (x .:? "transportStreamId")
<*> (x .:? "maxPcrInterval")
<*> (x .:? "fragmentTime")
<*> (x .:? "privateMetadataPid")
<*> (x .:? "pmtInterval")
<*> (x .:? "dvbSdtSettings")
<*> (x .:? "nullPacketBitrate")
<*> (x .:? "audioBufferModel")
<*> (x .:? "timedMetadataPid")
<*> (x .:? "audioFramesPerPes")
<*> (x .:? "pcrPid")
<*> (x .:? "segmentationMarkers")
<*> (x .:? "dvbSubPids" .!= mempty)
<*> (x .:? "scte35Source")
<*> (x .:? "patInterval")
<*> (x .:? "esRateInPes")
<*> (x .:? "bitrate")
<*> (x .:? "audioPids" .!= mempty)
<*> (x .:? "dvbTeletextPid")
<*> (x .:? "nielsenId3")
<*> (x .:? "segmentationTime")
<*> (x .:? "ebpAudioInterval")
<*> (x .:? "dvbNitSettings")
<*> (x .:? "pcrControl")
<*> (x .:? "ebpPlacement")
<*> (x .:? "rateMode")
<*> (x .:? "segmentationStyle")
<*> (x .:? "dvbTdtSettings"))
instance Hashable M2tsSettings where
instance NFData M2tsSettings where
instance ToJSON M2tsSettings where
toJSON M2tsSettings'{..}
= object
(catMaybes
[("pmtPid" .=) <$> _mPmtPid,
("videoPid" .=) <$> _mVideoPid,
("bufferModel" .=) <$> _mBufferModel,
("programNumber" .=) <$> _mProgramNumber,
("scte35Pid" .=) <$> _mScte35Pid,
("minEbpInterval" .=) <$> _mMinEbpInterval,
("transportStreamId" .=) <$> _mTransportStreamId,
("maxPcrInterval" .=) <$> _mMaxPcrInterval,
("fragmentTime" .=) <$> _mFragmentTime,
("privateMetadataPid" .=) <$> _mPrivateMetadataPid,
("pmtInterval" .=) <$> _mPmtInterval,
("dvbSdtSettings" .=) <$> _mDvbSdtSettings,
("nullPacketBitrate" .=) <$> _mNullPacketBitrate,
("audioBufferModel" .=) <$> _mAudioBufferModel,
("timedMetadataPid" .=) <$> _mTimedMetadataPid,
("audioFramesPerPes" .=) <$> _mAudioFramesPerPes,
("pcrPid" .=) <$> _mPcrPid,
("segmentationMarkers" .=) <$> _mSegmentationMarkers,
("dvbSubPids" .=) <$> _mDvbSubPids,
("scte35Source" .=) <$> _mScte35Source,
("patInterval" .=) <$> _mPatInterval,
("esRateInPes" .=) <$> _mEsRateInPes,
("bitrate" .=) <$> _mBitrate,
("audioPids" .=) <$> _mAudioPids,
("dvbTeletextPid" .=) <$> _mDvbTeletextPid,
("nielsenId3" .=) <$> _mNielsenId3,
("segmentationTime" .=) <$> _mSegmentationTime,
("ebpAudioInterval" .=) <$> _mEbpAudioInterval,
("dvbNitSettings" .=) <$> _mDvbNitSettings,
("pcrControl" .=) <$> _mPcrControl,
("ebpPlacement" .=) <$> _mEbpPlacement,
("rateMode" .=) <$> _mRateMode,
("segmentationStyle" .=) <$> _mSegmentationStyle,
("dvbTdtSettings" .=) <$> _mDvbTdtSettings])
data M3u8Settings = M3u8Settings'
{ _msPmtPid :: !(Maybe Int)
, _msVideoPid :: !(Maybe Int)
, _msProgramNumber :: !(Maybe Int)
, _msScte35Pid :: !(Maybe Int)
, _msTransportStreamId :: !(Maybe Int)
, _msPrivateMetadataPid :: !(Maybe Int)
, _msPmtInterval :: !(Maybe Int)
, _msTimedMetadataPid :: !(Maybe Int)
, _msAudioFramesPerPes :: !(Maybe Int)
, _msPcrPid :: !(Maybe Int)
, _msTimedMetadata :: !(Maybe TimedMetadata)
, _msScte35Source :: !(Maybe M3u8Scte35Source)
, _msPatInterval :: !(Maybe Int)
, _msAudioPids :: !(Maybe [Int])
, _msNielsenId3 :: !(Maybe M3u8NielsenId3)
, _msPcrControl :: !(Maybe M3u8PcrControl)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
m3u8Settings
:: M3u8Settings
m3u8Settings =
M3u8Settings'
{ _msPmtPid = Nothing
, _msVideoPid = Nothing
, _msProgramNumber = Nothing
, _msScte35Pid = Nothing
, _msTransportStreamId = Nothing
, _msPrivateMetadataPid = Nothing
, _msPmtInterval = Nothing
, _msTimedMetadataPid = Nothing
, _msAudioFramesPerPes = Nothing
, _msPcrPid = Nothing
, _msTimedMetadata = Nothing
, _msScte35Source = Nothing
, _msPatInterval = Nothing
, _msAudioPids = Nothing
, _msNielsenId3 = Nothing
, _msPcrControl = Nothing
}
msPmtPid :: Lens' M3u8Settings (Maybe Int)
msPmtPid = lens _msPmtPid (\ s a -> s{_msPmtPid = a})
msVideoPid :: Lens' M3u8Settings (Maybe Int)
msVideoPid = lens _msVideoPid (\ s a -> s{_msVideoPid = a})
msProgramNumber :: Lens' M3u8Settings (Maybe Int)
msProgramNumber = lens _msProgramNumber (\ s a -> s{_msProgramNumber = a})
msScte35Pid :: Lens' M3u8Settings (Maybe Int)
msScte35Pid = lens _msScte35Pid (\ s a -> s{_msScte35Pid = a})
msTransportStreamId :: Lens' M3u8Settings (Maybe Int)
msTransportStreamId = lens _msTransportStreamId (\ s a -> s{_msTransportStreamId = a})
msPrivateMetadataPid :: Lens' M3u8Settings (Maybe Int)
msPrivateMetadataPid = lens _msPrivateMetadataPid (\ s a -> s{_msPrivateMetadataPid = a})
msPmtInterval :: Lens' M3u8Settings (Maybe Int)
msPmtInterval = lens _msPmtInterval (\ s a -> s{_msPmtInterval = a})
msTimedMetadataPid :: Lens' M3u8Settings (Maybe Int)
msTimedMetadataPid = lens _msTimedMetadataPid (\ s a -> s{_msTimedMetadataPid = a})
msAudioFramesPerPes :: Lens' M3u8Settings (Maybe Int)
msAudioFramesPerPes = lens _msAudioFramesPerPes (\ s a -> s{_msAudioFramesPerPes = a})
msPcrPid :: Lens' M3u8Settings (Maybe Int)
msPcrPid = lens _msPcrPid (\ s a -> s{_msPcrPid = a})
msTimedMetadata :: Lens' M3u8Settings (Maybe TimedMetadata)
msTimedMetadata = lens _msTimedMetadata (\ s a -> s{_msTimedMetadata = a})
msScte35Source :: Lens' M3u8Settings (Maybe M3u8Scte35Source)
msScte35Source = lens _msScte35Source (\ s a -> s{_msScte35Source = a})
msPatInterval :: Lens' M3u8Settings (Maybe Int)
msPatInterval = lens _msPatInterval (\ s a -> s{_msPatInterval = a})
msAudioPids :: Lens' M3u8Settings [Int]
msAudioPids = lens _msAudioPids (\ s a -> s{_msAudioPids = a}) . _Default . _Coerce
msNielsenId3 :: Lens' M3u8Settings (Maybe M3u8NielsenId3)
msNielsenId3 = lens _msNielsenId3 (\ s a -> s{_msNielsenId3 = a})
msPcrControl :: Lens' M3u8Settings (Maybe M3u8PcrControl)
msPcrControl = lens _msPcrControl (\ s a -> s{_msPcrControl = a})
instance FromJSON M3u8Settings where
parseJSON
= withObject "M3u8Settings"
(\ x ->
M3u8Settings' <$>
(x .:? "pmtPid") <*> (x .:? "videoPid") <*>
(x .:? "programNumber")
<*> (x .:? "scte35Pid")
<*> (x .:? "transportStreamId")
<*> (x .:? "privateMetadataPid")
<*> (x .:? "pmtInterval")
<*> (x .:? "timedMetadataPid")
<*> (x .:? "audioFramesPerPes")
<*> (x .:? "pcrPid")
<*> (x .:? "timedMetadata")
<*> (x .:? "scte35Source")
<*> (x .:? "patInterval")
<*> (x .:? "audioPids" .!= mempty)
<*> (x .:? "nielsenId3")
<*> (x .:? "pcrControl"))
instance Hashable M3u8Settings where
instance NFData M3u8Settings where
instance ToJSON M3u8Settings where
toJSON M3u8Settings'{..}
= object
(catMaybes
[("pmtPid" .=) <$> _msPmtPid,
("videoPid" .=) <$> _msVideoPid,
("programNumber" .=) <$> _msProgramNumber,
("scte35Pid" .=) <$> _msScte35Pid,
("transportStreamId" .=) <$> _msTransportStreamId,
("privateMetadataPid" .=) <$> _msPrivateMetadataPid,
("pmtInterval" .=) <$> _msPmtInterval,
("timedMetadataPid" .=) <$> _msTimedMetadataPid,
("audioFramesPerPes" .=) <$> _msAudioFramesPerPes,
("pcrPid" .=) <$> _msPcrPid,
("timedMetadata" .=) <$> _msTimedMetadata,
("scte35Source" .=) <$> _msScte35Source,
("patInterval" .=) <$> _msPatInterval,
("audioPids" .=) <$> _msAudioPids,
("nielsenId3" .=) <$> _msNielsenId3,
("pcrControl" .=) <$> _msPcrControl])
data MovSettings = MovSettings'
{ _msReference :: !(Maybe MovReference)
, _msCslgAtom :: !(Maybe MovCslgAtom)
, _msMpeg2FourCCControl :: !(Maybe MovMpeg2FourCCControl)
, _msPaddingControl :: !(Maybe MovPaddingControl)
, _msClapAtom :: !(Maybe MovClapAtom)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
movSettings
:: MovSettings
movSettings =
MovSettings'
{ _msReference = Nothing
, _msCslgAtom = Nothing
, _msMpeg2FourCCControl = Nothing
, _msPaddingControl = Nothing
, _msClapAtom = Nothing
}
msReference :: Lens' MovSettings (Maybe MovReference)
msReference = lens _msReference (\ s a -> s{_msReference = a})
msCslgAtom :: Lens' MovSettings (Maybe MovCslgAtom)
msCslgAtom = lens _msCslgAtom (\ s a -> s{_msCslgAtom = a})
msMpeg2FourCCControl :: Lens' MovSettings (Maybe MovMpeg2FourCCControl)
msMpeg2FourCCControl = lens _msMpeg2FourCCControl (\ s a -> s{_msMpeg2FourCCControl = a})
msPaddingControl :: Lens' MovSettings (Maybe MovPaddingControl)
msPaddingControl = lens _msPaddingControl (\ s a -> s{_msPaddingControl = a})
msClapAtom :: Lens' MovSettings (Maybe MovClapAtom)
msClapAtom = lens _msClapAtom (\ s a -> s{_msClapAtom = a})
instance FromJSON MovSettings where
parseJSON
= withObject "MovSettings"
(\ x ->
MovSettings' <$>
(x .:? "reference") <*> (x .:? "cslgAtom") <*>
(x .:? "mpeg2FourCCControl")
<*> (x .:? "paddingControl")
<*> (x .:? "clapAtom"))
instance Hashable MovSettings where
instance NFData MovSettings where
instance ToJSON MovSettings where
toJSON MovSettings'{..}
= object
(catMaybes
[("reference" .=) <$> _msReference,
("cslgAtom" .=) <$> _msCslgAtom,
("mpeg2FourCCControl" .=) <$> _msMpeg2FourCCControl,
("paddingControl" .=) <$> _msPaddingControl,
("clapAtom" .=) <$> _msClapAtom])
data Mp2Settings = Mp2Settings'
{ _mssChannels :: !(Maybe Int)
, _mssSampleRate :: !(Maybe Int)
, _mssBitrate :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
mp2Settings
:: Mp2Settings
mp2Settings =
Mp2Settings'
{_mssChannels = Nothing, _mssSampleRate = Nothing, _mssBitrate = Nothing}
mssChannels :: Lens' Mp2Settings (Maybe Int)
mssChannels = lens _mssChannels (\ s a -> s{_mssChannels = a})
mssSampleRate :: Lens' Mp2Settings (Maybe Int)
mssSampleRate = lens _mssSampleRate (\ s a -> s{_mssSampleRate = a})
mssBitrate :: Lens' Mp2Settings (Maybe Int)
mssBitrate = lens _mssBitrate (\ s a -> s{_mssBitrate = a})
instance FromJSON Mp2Settings where
parseJSON
= withObject "Mp2Settings"
(\ x ->
Mp2Settings' <$>
(x .:? "channels") <*> (x .:? "sampleRate") <*>
(x .:? "bitrate"))
instance Hashable Mp2Settings where
instance NFData Mp2Settings where
instance ToJSON Mp2Settings where
toJSON Mp2Settings'{..}
= object
(catMaybes
[("channels" .=) <$> _mssChannels,
("sampleRate" .=) <$> _mssSampleRate,
("bitrate" .=) <$> _mssBitrate])
data Mp4Settings = Mp4Settings'
{ _mMoovPlacement :: !(Maybe Mp4MoovPlacement)
, _mFreeSpaceBox :: !(Maybe Mp4FreeSpaceBox)
, _mMp4MajorBrand :: !(Maybe Text)
, _mCslgAtom :: !(Maybe Mp4CslgAtom)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
mp4Settings
:: Mp4Settings
mp4Settings =
Mp4Settings'
{ _mMoovPlacement = Nothing
, _mFreeSpaceBox = Nothing
, _mMp4MajorBrand = Nothing
, _mCslgAtom = Nothing
}
mMoovPlacement :: Lens' Mp4Settings (Maybe Mp4MoovPlacement)
mMoovPlacement = lens _mMoovPlacement (\ s a -> s{_mMoovPlacement = a})
mFreeSpaceBox :: Lens' Mp4Settings (Maybe Mp4FreeSpaceBox)
mFreeSpaceBox = lens _mFreeSpaceBox (\ s a -> s{_mFreeSpaceBox = a})
mMp4MajorBrand :: Lens' Mp4Settings (Maybe Text)
mMp4MajorBrand = lens _mMp4MajorBrand (\ s a -> s{_mMp4MajorBrand = a})
mCslgAtom :: Lens' Mp4Settings (Maybe Mp4CslgAtom)
mCslgAtom = lens _mCslgAtom (\ s a -> s{_mCslgAtom = a})
instance FromJSON Mp4Settings where
parseJSON
= withObject "Mp4Settings"
(\ x ->
Mp4Settings' <$>
(x .:? "moovPlacement") <*> (x .:? "freeSpaceBox")
<*> (x .:? "mp4MajorBrand")
<*> (x .:? "cslgAtom"))
instance Hashable Mp4Settings where
instance NFData Mp4Settings where
instance ToJSON Mp4Settings where
toJSON Mp4Settings'{..}
= object
(catMaybes
[("moovPlacement" .=) <$> _mMoovPlacement,
("freeSpaceBox" .=) <$> _mFreeSpaceBox,
("mp4MajorBrand" .=) <$> _mMp4MajorBrand,
("cslgAtom" .=) <$> _mCslgAtom])
data Mpeg2Settings = Mpeg2Settings'
{ _msQualityTuningLevel :: !(Maybe Mpeg2QualityTuningLevel)
, _msTemporalAdaptiveQuantization :: !(Maybe Mpeg2TemporalAdaptiveQuantization)
, _msSceneChangeDetect :: !(Maybe Mpeg2SceneChangeDetect)
, _msHrdBufferInitialFillPercentage :: !(Maybe Int)
, _msSlowPal :: !(Maybe Mpeg2SlowPal)
, _msParNumerator :: !(Maybe Int)
, _msGopSize :: !(Maybe Double)
, _msNumberBFramesBetweenReferenceFrames :: !(Maybe Int)
, _msGopSizeUnits :: !(Maybe Mpeg2GopSizeUnits)
, _msHrdBufferSize :: !(Maybe Int)
, _msRateControlMode :: !(Maybe Mpeg2RateControlMode)
, _msTelecine :: !(Maybe Mpeg2Telecine)
, _msIntraDcPrecision :: !(Maybe Mpeg2IntraDcPrecision)
, _msMinIInterval :: !(Maybe Int)
, _msInterlaceMode :: !(Maybe Mpeg2InterlaceMode)
, _msParControl :: !(Maybe Mpeg2ParControl)
, _msSoftness :: !(Maybe Int)
, _msCodecProfile :: !(Maybe Mpeg2CodecProfile)
, _msBitrate :: !(Maybe Int)
, _msFramerateDenominator :: !(Maybe Int)
, _msFramerateConversionAlgorithm :: !(Maybe Mpeg2FramerateConversionAlgorithm)
, _msCodecLevel :: !(Maybe Mpeg2CodecLevel)
, _msFramerateControl :: !(Maybe Mpeg2FramerateControl)
, _msAdaptiveQuantization :: !(Maybe Mpeg2AdaptiveQuantization)
, _msFramerateNumerator :: !(Maybe Int)
, _msMaxBitrate :: !(Maybe Int)
, _msSyntax :: !(Maybe Mpeg2Syntax)
, _msGopClosedCadence :: !(Maybe Int)
, _msParDenominator :: !(Maybe Int)
, _msSpatialAdaptiveQuantization :: !(Maybe Mpeg2SpatialAdaptiveQuantization)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
mpeg2Settings
:: Mpeg2Settings
mpeg2Settings =
Mpeg2Settings'
{ _msQualityTuningLevel = Nothing
, _msTemporalAdaptiveQuantization = Nothing
, _msSceneChangeDetect = Nothing
, _msHrdBufferInitialFillPercentage = Nothing
, _msSlowPal = Nothing
, _msParNumerator = Nothing
, _msGopSize = Nothing
, _msNumberBFramesBetweenReferenceFrames = Nothing
, _msGopSizeUnits = Nothing
, _msHrdBufferSize = Nothing
, _msRateControlMode = Nothing
, _msTelecine = Nothing
, _msIntraDcPrecision = Nothing
, _msMinIInterval = Nothing
, _msInterlaceMode = Nothing
, _msParControl = Nothing
, _msSoftness = Nothing
, _msCodecProfile = Nothing
, _msBitrate = Nothing
, _msFramerateDenominator = Nothing
, _msFramerateConversionAlgorithm = Nothing
, _msCodecLevel = Nothing
, _msFramerateControl = Nothing
, _msAdaptiveQuantization = Nothing
, _msFramerateNumerator = Nothing
, _msMaxBitrate = Nothing
, _msSyntax = Nothing
, _msGopClosedCadence = Nothing
, _msParDenominator = Nothing
, _msSpatialAdaptiveQuantization = Nothing
}
msQualityTuningLevel :: Lens' Mpeg2Settings (Maybe Mpeg2QualityTuningLevel)
msQualityTuningLevel = lens _msQualityTuningLevel (\ s a -> s{_msQualityTuningLevel = a})
msTemporalAdaptiveQuantization :: Lens' Mpeg2Settings (Maybe Mpeg2TemporalAdaptiveQuantization)
msTemporalAdaptiveQuantization = lens _msTemporalAdaptiveQuantization (\ s a -> s{_msTemporalAdaptiveQuantization = a})
msSceneChangeDetect :: Lens' Mpeg2Settings (Maybe Mpeg2SceneChangeDetect)
msSceneChangeDetect = lens _msSceneChangeDetect (\ s a -> s{_msSceneChangeDetect = a})
msHrdBufferInitialFillPercentage :: Lens' Mpeg2Settings (Maybe Int)
msHrdBufferInitialFillPercentage = lens _msHrdBufferInitialFillPercentage (\ s a -> s{_msHrdBufferInitialFillPercentage = a})
msSlowPal :: Lens' Mpeg2Settings (Maybe Mpeg2SlowPal)
msSlowPal = lens _msSlowPal (\ s a -> s{_msSlowPal = a})
msParNumerator :: Lens' Mpeg2Settings (Maybe Int)
msParNumerator = lens _msParNumerator (\ s a -> s{_msParNumerator = a})
msGopSize :: Lens' Mpeg2Settings (Maybe Double)
msGopSize = lens _msGopSize (\ s a -> s{_msGopSize = a})
msNumberBFramesBetweenReferenceFrames :: Lens' Mpeg2Settings (Maybe Int)
msNumberBFramesBetweenReferenceFrames = lens _msNumberBFramesBetweenReferenceFrames (\ s a -> s{_msNumberBFramesBetweenReferenceFrames = a})
msGopSizeUnits :: Lens' Mpeg2Settings (Maybe Mpeg2GopSizeUnits)
msGopSizeUnits = lens _msGopSizeUnits (\ s a -> s{_msGopSizeUnits = a})
msHrdBufferSize :: Lens' Mpeg2Settings (Maybe Int)
msHrdBufferSize = lens _msHrdBufferSize (\ s a -> s{_msHrdBufferSize = a})
msRateControlMode :: Lens' Mpeg2Settings (Maybe Mpeg2RateControlMode)
msRateControlMode = lens _msRateControlMode (\ s a -> s{_msRateControlMode = a})
msTelecine :: Lens' Mpeg2Settings (Maybe Mpeg2Telecine)
msTelecine = lens _msTelecine (\ s a -> s{_msTelecine = a})
msIntraDcPrecision :: Lens' Mpeg2Settings (Maybe Mpeg2IntraDcPrecision)
msIntraDcPrecision = lens _msIntraDcPrecision (\ s a -> s{_msIntraDcPrecision = a})
msMinIInterval :: Lens' Mpeg2Settings (Maybe Int)
msMinIInterval = lens _msMinIInterval (\ s a -> s{_msMinIInterval = a})
msInterlaceMode :: Lens' Mpeg2Settings (Maybe Mpeg2InterlaceMode)
msInterlaceMode = lens _msInterlaceMode (\ s a -> s{_msInterlaceMode = a})
msParControl :: Lens' Mpeg2Settings (Maybe Mpeg2ParControl)
msParControl = lens _msParControl (\ s a -> s{_msParControl = a})
msSoftness :: Lens' Mpeg2Settings (Maybe Int)
msSoftness = lens _msSoftness (\ s a -> s{_msSoftness = a})
msCodecProfile :: Lens' Mpeg2Settings (Maybe Mpeg2CodecProfile)
msCodecProfile = lens _msCodecProfile (\ s a -> s{_msCodecProfile = a})
msBitrate :: Lens' Mpeg2Settings (Maybe Int)
msBitrate = lens _msBitrate (\ s a -> s{_msBitrate = a})
msFramerateDenominator :: Lens' Mpeg2Settings (Maybe Int)
msFramerateDenominator = lens _msFramerateDenominator (\ s a -> s{_msFramerateDenominator = a})
msFramerateConversionAlgorithm :: Lens' Mpeg2Settings (Maybe Mpeg2FramerateConversionAlgorithm)
msFramerateConversionAlgorithm = lens _msFramerateConversionAlgorithm (\ s a -> s{_msFramerateConversionAlgorithm = a})
msCodecLevel :: Lens' Mpeg2Settings (Maybe Mpeg2CodecLevel)
msCodecLevel = lens _msCodecLevel (\ s a -> s{_msCodecLevel = a})
msFramerateControl :: Lens' Mpeg2Settings (Maybe Mpeg2FramerateControl)
msFramerateControl = lens _msFramerateControl (\ s a -> s{_msFramerateControl = a})
msAdaptiveQuantization :: Lens' Mpeg2Settings (Maybe Mpeg2AdaptiveQuantization)
msAdaptiveQuantization = lens _msAdaptiveQuantization (\ s a -> s{_msAdaptiveQuantization = a})
msFramerateNumerator :: Lens' Mpeg2Settings (Maybe Int)
msFramerateNumerator = lens _msFramerateNumerator (\ s a -> s{_msFramerateNumerator = a})
msMaxBitrate :: Lens' Mpeg2Settings (Maybe Int)
msMaxBitrate = lens _msMaxBitrate (\ s a -> s{_msMaxBitrate = a})
msSyntax :: Lens' Mpeg2Settings (Maybe Mpeg2Syntax)
msSyntax = lens _msSyntax (\ s a -> s{_msSyntax = a})
msGopClosedCadence :: Lens' Mpeg2Settings (Maybe Int)
msGopClosedCadence = lens _msGopClosedCadence (\ s a -> s{_msGopClosedCadence = a})
msParDenominator :: Lens' Mpeg2Settings (Maybe Int)
msParDenominator = lens _msParDenominator (\ s a -> s{_msParDenominator = a})
msSpatialAdaptiveQuantization :: Lens' Mpeg2Settings (Maybe Mpeg2SpatialAdaptiveQuantization)
msSpatialAdaptiveQuantization = lens _msSpatialAdaptiveQuantization (\ s a -> s{_msSpatialAdaptiveQuantization = a})
instance FromJSON Mpeg2Settings where
parseJSON
= withObject "Mpeg2Settings"
(\ x ->
Mpeg2Settings' <$>
(x .:? "qualityTuningLevel") <*>
(x .:? "temporalAdaptiveQuantization")
<*> (x .:? "sceneChangeDetect")
<*> (x .:? "hrdBufferInitialFillPercentage")
<*> (x .:? "slowPal")
<*> (x .:? "parNumerator")
<*> (x .:? "gopSize")
<*> (x .:? "numberBFramesBetweenReferenceFrames")
<*> (x .:? "gopSizeUnits")
<*> (x .:? "hrdBufferSize")
<*> (x .:? "rateControlMode")
<*> (x .:? "telecine")
<*> (x .:? "intraDcPrecision")
<*> (x .:? "minIInterval")
<*> (x .:? "interlaceMode")
<*> (x .:? "parControl")
<*> (x .:? "softness")
<*> (x .:? "codecProfile")
<*> (x .:? "bitrate")
<*> (x .:? "framerateDenominator")
<*> (x .:? "framerateConversionAlgorithm")
<*> (x .:? "codecLevel")
<*> (x .:? "framerateControl")
<*> (x .:? "adaptiveQuantization")
<*> (x .:? "framerateNumerator")
<*> (x .:? "maxBitrate")
<*> (x .:? "syntax")
<*> (x .:? "gopClosedCadence")
<*> (x .:? "parDenominator")
<*> (x .:? "spatialAdaptiveQuantization"))
instance Hashable Mpeg2Settings where
instance NFData Mpeg2Settings where
instance ToJSON Mpeg2Settings where
toJSON Mpeg2Settings'{..}
= object
(catMaybes
[("qualityTuningLevel" .=) <$> _msQualityTuningLevel,
("temporalAdaptiveQuantization" .=) <$>
_msTemporalAdaptiveQuantization,
("sceneChangeDetect" .=) <$> _msSceneChangeDetect,
("hrdBufferInitialFillPercentage" .=) <$>
_msHrdBufferInitialFillPercentage,
("slowPal" .=) <$> _msSlowPal,
("parNumerator" .=) <$> _msParNumerator,
("gopSize" .=) <$> _msGopSize,
("numberBFramesBetweenReferenceFrames" .=) <$>
_msNumberBFramesBetweenReferenceFrames,
("gopSizeUnits" .=) <$> _msGopSizeUnits,
("hrdBufferSize" .=) <$> _msHrdBufferSize,
("rateControlMode" .=) <$> _msRateControlMode,
("telecine" .=) <$> _msTelecine,
("intraDcPrecision" .=) <$> _msIntraDcPrecision,
("minIInterval" .=) <$> _msMinIInterval,
("interlaceMode" .=) <$> _msInterlaceMode,
("parControl" .=) <$> _msParControl,
("softness" .=) <$> _msSoftness,
("codecProfile" .=) <$> _msCodecProfile,
("bitrate" .=) <$> _msBitrate,
("framerateDenominator" .=) <$>
_msFramerateDenominator,
("framerateConversionAlgorithm" .=) <$>
_msFramerateConversionAlgorithm,
("codecLevel" .=) <$> _msCodecLevel,
("framerateControl" .=) <$> _msFramerateControl,
("adaptiveQuantization" .=) <$>
_msAdaptiveQuantization,
("framerateNumerator" .=) <$> _msFramerateNumerator,
("maxBitrate" .=) <$> _msMaxBitrate,
("syntax" .=) <$> _msSyntax,
("gopClosedCadence" .=) <$> _msGopClosedCadence,
("parDenominator" .=) <$> _msParDenominator,
("spatialAdaptiveQuantization" .=) <$>
_msSpatialAdaptiveQuantization])
newtype MsSmoothEncryptionSettings = MsSmoothEncryptionSettings'
{ _msesSpekeKeyProvider :: Maybe SpekeKeyProvider
} deriving (Eq, Read, Show, Data, Typeable, Generic)
msSmoothEncryptionSettings
:: MsSmoothEncryptionSettings
msSmoothEncryptionSettings =
MsSmoothEncryptionSettings' {_msesSpekeKeyProvider = Nothing}
msesSpekeKeyProvider :: Lens' MsSmoothEncryptionSettings (Maybe SpekeKeyProvider)
msesSpekeKeyProvider = lens _msesSpekeKeyProvider (\ s a -> s{_msesSpekeKeyProvider = a})
instance FromJSON MsSmoothEncryptionSettings where
parseJSON
= withObject "MsSmoothEncryptionSettings"
(\ x ->
MsSmoothEncryptionSettings' <$>
(x .:? "spekeKeyProvider"))
instance Hashable MsSmoothEncryptionSettings where
instance NFData MsSmoothEncryptionSettings where
instance ToJSON MsSmoothEncryptionSettings where
toJSON MsSmoothEncryptionSettings'{..}
= object
(catMaybes
[("spekeKeyProvider" .=) <$> _msesSpekeKeyProvider])
data MsSmoothGroupSettings = MsSmoothGroupSettings'
{ _msgsFragmentLength :: !(Maybe Int)
, _msgsManifestEncoding :: !(Maybe MsSmoothManifestEncoding)
, _msgsDestination :: !(Maybe Text)
, _msgsAudioDeduplication :: !(Maybe MsSmoothAudioDeduplication)
, _msgsEncryption :: !(Maybe MsSmoothEncryptionSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
msSmoothGroupSettings
:: MsSmoothGroupSettings
msSmoothGroupSettings =
MsSmoothGroupSettings'
{ _msgsFragmentLength = Nothing
, _msgsManifestEncoding = Nothing
, _msgsDestination = Nothing
, _msgsAudioDeduplication = Nothing
, _msgsEncryption = Nothing
}
msgsFragmentLength :: Lens' MsSmoothGroupSettings (Maybe Int)
msgsFragmentLength = lens _msgsFragmentLength (\ s a -> s{_msgsFragmentLength = a})
msgsManifestEncoding :: Lens' MsSmoothGroupSettings (Maybe MsSmoothManifestEncoding)
msgsManifestEncoding = lens _msgsManifestEncoding (\ s a -> s{_msgsManifestEncoding = a})
msgsDestination :: Lens' MsSmoothGroupSettings (Maybe Text)
msgsDestination = lens _msgsDestination (\ s a -> s{_msgsDestination = a})
msgsAudioDeduplication :: Lens' MsSmoothGroupSettings (Maybe MsSmoothAudioDeduplication)
msgsAudioDeduplication = lens _msgsAudioDeduplication (\ s a -> s{_msgsAudioDeduplication = a})
msgsEncryption :: Lens' MsSmoothGroupSettings (Maybe MsSmoothEncryptionSettings)
msgsEncryption = lens _msgsEncryption (\ s a -> s{_msgsEncryption = a})
instance FromJSON MsSmoothGroupSettings where
parseJSON
= withObject "MsSmoothGroupSettings"
(\ x ->
MsSmoothGroupSettings' <$>
(x .:? "fragmentLength") <*>
(x .:? "manifestEncoding")
<*> (x .:? "destination")
<*> (x .:? "audioDeduplication")
<*> (x .:? "encryption"))
instance Hashable MsSmoothGroupSettings where
instance NFData MsSmoothGroupSettings where
instance ToJSON MsSmoothGroupSettings where
toJSON MsSmoothGroupSettings'{..}
= object
(catMaybes
[("fragmentLength" .=) <$> _msgsFragmentLength,
("manifestEncoding" .=) <$> _msgsManifestEncoding,
("destination" .=) <$> _msgsDestination,
("audioDeduplication" .=) <$>
_msgsAudioDeduplication,
("encryption" .=) <$> _msgsEncryption])
data NielsenConfiguration = NielsenConfiguration'
{ _ncBreakoutCode :: !(Maybe Int)
, _ncDistributorId :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
nielsenConfiguration
:: NielsenConfiguration
nielsenConfiguration =
NielsenConfiguration' {_ncBreakoutCode = Nothing, _ncDistributorId = Nothing}
ncBreakoutCode :: Lens' NielsenConfiguration (Maybe Int)
ncBreakoutCode = lens _ncBreakoutCode (\ s a -> s{_ncBreakoutCode = a})
ncDistributorId :: Lens' NielsenConfiguration (Maybe Text)
ncDistributorId = lens _ncDistributorId (\ s a -> s{_ncDistributorId = a})
instance FromJSON NielsenConfiguration where
parseJSON
= withObject "NielsenConfiguration"
(\ x ->
NielsenConfiguration' <$>
(x .:? "breakoutCode") <*> (x .:? "distributorId"))
instance Hashable NielsenConfiguration where
instance NFData NielsenConfiguration where
instance ToJSON NielsenConfiguration where
toJSON NielsenConfiguration'{..}
= object
(catMaybes
[("breakoutCode" .=) <$> _ncBreakoutCode,
("distributorId" .=) <$> _ncDistributorId])
data NoiseReducer = NoiseReducer'
{ _nrSpatialFilterSettings :: !(Maybe NoiseReducerSpatialFilterSettings)
, _nrFilterSettings :: !(Maybe NoiseReducerFilterSettings)
, _nrFilter :: !(Maybe NoiseReducerFilter)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
noiseReducer
:: NoiseReducer
noiseReducer =
NoiseReducer'
{ _nrSpatialFilterSettings = Nothing
, _nrFilterSettings = Nothing
, _nrFilter = Nothing
}
nrSpatialFilterSettings :: Lens' NoiseReducer (Maybe NoiseReducerSpatialFilterSettings)
nrSpatialFilterSettings = lens _nrSpatialFilterSettings (\ s a -> s{_nrSpatialFilterSettings = a})
nrFilterSettings :: Lens' NoiseReducer (Maybe NoiseReducerFilterSettings)
nrFilterSettings = lens _nrFilterSettings (\ s a -> s{_nrFilterSettings = a})
nrFilter :: Lens' NoiseReducer (Maybe NoiseReducerFilter)
nrFilter = lens _nrFilter (\ s a -> s{_nrFilter = a})
instance FromJSON NoiseReducer where
parseJSON
= withObject "NoiseReducer"
(\ x ->
NoiseReducer' <$>
(x .:? "spatialFilterSettings") <*>
(x .:? "filterSettings")
<*> (x .:? "filter"))
instance Hashable NoiseReducer where
instance NFData NoiseReducer where
instance ToJSON NoiseReducer where
toJSON NoiseReducer'{..}
= object
(catMaybes
[("spatialFilterSettings" .=) <$>
_nrSpatialFilterSettings,
("filterSettings" .=) <$> _nrFilterSettings,
("filter" .=) <$> _nrFilter])
newtype NoiseReducerFilterSettings = NoiseReducerFilterSettings'
{ _nrfsStrength :: Maybe Int
} deriving (Eq, Read, Show, Data, Typeable, Generic)
noiseReducerFilterSettings
:: NoiseReducerFilterSettings
noiseReducerFilterSettings =
NoiseReducerFilterSettings' {_nrfsStrength = Nothing}
nrfsStrength :: Lens' NoiseReducerFilterSettings (Maybe Int)
nrfsStrength = lens _nrfsStrength (\ s a -> s{_nrfsStrength = a})
instance FromJSON NoiseReducerFilterSettings where
parseJSON
= withObject "NoiseReducerFilterSettings"
(\ x ->
NoiseReducerFilterSettings' <$> (x .:? "strength"))
instance Hashable NoiseReducerFilterSettings where
instance NFData NoiseReducerFilterSettings where
instance ToJSON NoiseReducerFilterSettings where
toJSON NoiseReducerFilterSettings'{..}
= object
(catMaybes [("strength" .=) <$> _nrfsStrength])
data NoiseReducerSpatialFilterSettings = NoiseReducerSpatialFilterSettings'
{ _nrsfsStrength :: !(Maybe Int)
, _nrsfsPostFilterSharpenStrength :: !(Maybe Int)
, _nrsfsSpeed :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
noiseReducerSpatialFilterSettings
:: NoiseReducerSpatialFilterSettings
noiseReducerSpatialFilterSettings =
NoiseReducerSpatialFilterSettings'
{ _nrsfsStrength = Nothing
, _nrsfsPostFilterSharpenStrength = Nothing
, _nrsfsSpeed = Nothing
}
nrsfsStrength :: Lens' NoiseReducerSpatialFilterSettings (Maybe Int)
nrsfsStrength = lens _nrsfsStrength (\ s a -> s{_nrsfsStrength = a})
nrsfsPostFilterSharpenStrength :: Lens' NoiseReducerSpatialFilterSettings (Maybe Int)
nrsfsPostFilterSharpenStrength = lens _nrsfsPostFilterSharpenStrength (\ s a -> s{_nrsfsPostFilterSharpenStrength = a})
nrsfsSpeed :: Lens' NoiseReducerSpatialFilterSettings (Maybe Int)
nrsfsSpeed = lens _nrsfsSpeed (\ s a -> s{_nrsfsSpeed = a})
instance FromJSON NoiseReducerSpatialFilterSettings
where
parseJSON
= withObject "NoiseReducerSpatialFilterSettings"
(\ x ->
NoiseReducerSpatialFilterSettings' <$>
(x .:? "strength") <*>
(x .:? "postFilterSharpenStrength")
<*> (x .:? "speed"))
instance Hashable NoiseReducerSpatialFilterSettings
where
instance NFData NoiseReducerSpatialFilterSettings
where
instance ToJSON NoiseReducerSpatialFilterSettings
where
toJSON NoiseReducerSpatialFilterSettings'{..}
= object
(catMaybes
[("strength" .=) <$> _nrsfsStrength,
("postFilterSharpenStrength" .=) <$>
_nrsfsPostFilterSharpenStrength,
("speed" .=) <$> _nrsfsSpeed])
data Output = Output'
{ _oCaptionDescriptions :: !(Maybe [CaptionDescription])
, _oExtension :: !(Maybe Text)
, _oVideoDescription :: !(Maybe VideoDescription)
, _oContainerSettings :: !(Maybe ContainerSettings)
, _oOutputSettings :: !(Maybe OutputSettings)
, _oPreset :: !(Maybe Text)
, _oNameModifier :: !(Maybe Text)
, _oAudioDescriptions :: !(Maybe [AudioDescription])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
output
:: Output
output =
Output'
{ _oCaptionDescriptions = Nothing
, _oExtension = Nothing
, _oVideoDescription = Nothing
, _oContainerSettings = Nothing
, _oOutputSettings = Nothing
, _oPreset = Nothing
, _oNameModifier = Nothing
, _oAudioDescriptions = Nothing
}
oCaptionDescriptions :: Lens' Output [CaptionDescription]
oCaptionDescriptions = lens _oCaptionDescriptions (\ s a -> s{_oCaptionDescriptions = a}) . _Default . _Coerce
oExtension :: Lens' Output (Maybe Text)
oExtension = lens _oExtension (\ s a -> s{_oExtension = a})
oVideoDescription :: Lens' Output (Maybe VideoDescription)
oVideoDescription = lens _oVideoDescription (\ s a -> s{_oVideoDescription = a})
oContainerSettings :: Lens' Output (Maybe ContainerSettings)
oContainerSettings = lens _oContainerSettings (\ s a -> s{_oContainerSettings = a})
oOutputSettings :: Lens' Output (Maybe OutputSettings)
oOutputSettings = lens _oOutputSettings (\ s a -> s{_oOutputSettings = a})
oPreset :: Lens' Output (Maybe Text)
oPreset = lens _oPreset (\ s a -> s{_oPreset = a})
oNameModifier :: Lens' Output (Maybe Text)
oNameModifier = lens _oNameModifier (\ s a -> s{_oNameModifier = a})
oAudioDescriptions :: Lens' Output [AudioDescription]
oAudioDescriptions = lens _oAudioDescriptions (\ s a -> s{_oAudioDescriptions = a}) . _Default . _Coerce
instance FromJSON Output where
parseJSON
= withObject "Output"
(\ x ->
Output' <$>
(x .:? "captionDescriptions" .!= mempty) <*>
(x .:? "extension")
<*> (x .:? "videoDescription")
<*> (x .:? "containerSettings")
<*> (x .:? "outputSettings")
<*> (x .:? "preset")
<*> (x .:? "nameModifier")
<*> (x .:? "audioDescriptions" .!= mempty))
instance Hashable Output where
instance NFData Output where
instance ToJSON Output where
toJSON Output'{..}
= object
(catMaybes
[("captionDescriptions" .=) <$>
_oCaptionDescriptions,
("extension" .=) <$> _oExtension,
("videoDescription" .=) <$> _oVideoDescription,
("containerSettings" .=) <$> _oContainerSettings,
("outputSettings" .=) <$> _oOutputSettings,
("preset" .=) <$> _oPreset,
("nameModifier" .=) <$> _oNameModifier,
("audioDescriptions" .=) <$> _oAudioDescriptions])
newtype OutputChannelMapping = OutputChannelMapping'
{ _ocmInputChannels :: Maybe [Int]
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputChannelMapping
:: OutputChannelMapping
outputChannelMapping = OutputChannelMapping' {_ocmInputChannels = Nothing}
ocmInputChannels :: Lens' OutputChannelMapping [Int]
ocmInputChannels = lens _ocmInputChannels (\ s a -> s{_ocmInputChannels = a}) . _Default . _Coerce
instance FromJSON OutputChannelMapping where
parseJSON
= withObject "OutputChannelMapping"
(\ x ->
OutputChannelMapping' <$>
(x .:? "inputChannels" .!= mempty))
instance Hashable OutputChannelMapping where
instance NFData OutputChannelMapping where
instance ToJSON OutputChannelMapping where
toJSON OutputChannelMapping'{..}
= object
(catMaybes
[("inputChannels" .=) <$> _ocmInputChannels])
data OutputDetail = OutputDetail'
{ _odVideoDetails :: !(Maybe VideoDetail)
, _odDurationInMs :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputDetail
:: OutputDetail
outputDetail =
OutputDetail' {_odVideoDetails = Nothing, _odDurationInMs = Nothing}
odVideoDetails :: Lens' OutputDetail (Maybe VideoDetail)
odVideoDetails = lens _odVideoDetails (\ s a -> s{_odVideoDetails = a})
odDurationInMs :: Lens' OutputDetail (Maybe Int)
odDurationInMs = lens _odDurationInMs (\ s a -> s{_odDurationInMs = a})
instance FromJSON OutputDetail where
parseJSON
= withObject "OutputDetail"
(\ x ->
OutputDetail' <$>
(x .:? "videoDetails") <*> (x .:? "durationInMs"))
instance Hashable OutputDetail where
instance NFData OutputDetail where
data OutputGroup = OutputGroup'
{ _ogOutputGroupSettings :: !(Maybe OutputGroupSettings)
, _ogOutputs :: !(Maybe [Output])
, _ogCustomName :: !(Maybe Text)
, _ogName :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputGroup
:: OutputGroup
outputGroup =
OutputGroup'
{ _ogOutputGroupSettings = Nothing
, _ogOutputs = Nothing
, _ogCustomName = Nothing
, _ogName = Nothing
}
ogOutputGroupSettings :: Lens' OutputGroup (Maybe OutputGroupSettings)
ogOutputGroupSettings = lens _ogOutputGroupSettings (\ s a -> s{_ogOutputGroupSettings = a})
ogOutputs :: Lens' OutputGroup [Output]
ogOutputs = lens _ogOutputs (\ s a -> s{_ogOutputs = a}) . _Default . _Coerce
ogCustomName :: Lens' OutputGroup (Maybe Text)
ogCustomName = lens _ogCustomName (\ s a -> s{_ogCustomName = a})
ogName :: Lens' OutputGroup (Maybe Text)
ogName = lens _ogName (\ s a -> s{_ogName = a})
instance FromJSON OutputGroup where
parseJSON
= withObject "OutputGroup"
(\ x ->
OutputGroup' <$>
(x .:? "outputGroupSettings") <*>
(x .:? "outputs" .!= mempty)
<*> (x .:? "customName")
<*> (x .:? "name"))
instance Hashable OutputGroup where
instance NFData OutputGroup where
instance ToJSON OutputGroup where
toJSON OutputGroup'{..}
= object
(catMaybes
[("outputGroupSettings" .=) <$>
_ogOutputGroupSettings,
("outputs" .=) <$> _ogOutputs,
("customName" .=) <$> _ogCustomName,
("name" .=) <$> _ogName])
newtype OutputGroupDetail = OutputGroupDetail'
{ _ogdOutputDetails :: Maybe [OutputDetail]
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputGroupDetail
:: OutputGroupDetail
outputGroupDetail = OutputGroupDetail' {_ogdOutputDetails = Nothing}
ogdOutputDetails :: Lens' OutputGroupDetail [OutputDetail]
ogdOutputDetails = lens _ogdOutputDetails (\ s a -> s{_ogdOutputDetails = a}) . _Default . _Coerce
instance FromJSON OutputGroupDetail where
parseJSON
= withObject "OutputGroupDetail"
(\ x ->
OutputGroupDetail' <$>
(x .:? "outputDetails" .!= mempty))
instance Hashable OutputGroupDetail where
instance NFData OutputGroupDetail where
data OutputGroupSettings = OutputGroupSettings'
{ _ogsFileGroupSettings :: !(Maybe FileGroupSettings)
, _ogsMsSmoothGroupSettings :: !(Maybe MsSmoothGroupSettings)
, _ogsHlsGroupSettings :: !(Maybe HlsGroupSettings)
, _ogsType :: !(Maybe OutputGroupType)
, _ogsDashIsoGroupSettings :: !(Maybe DashIsoGroupSettings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputGroupSettings
:: OutputGroupSettings
outputGroupSettings =
OutputGroupSettings'
{ _ogsFileGroupSettings = Nothing
, _ogsMsSmoothGroupSettings = Nothing
, _ogsHlsGroupSettings = Nothing
, _ogsType = Nothing
, _ogsDashIsoGroupSettings = Nothing
}
ogsFileGroupSettings :: Lens' OutputGroupSettings (Maybe FileGroupSettings)
ogsFileGroupSettings = lens _ogsFileGroupSettings (\ s a -> s{_ogsFileGroupSettings = a})
ogsMsSmoothGroupSettings :: Lens' OutputGroupSettings (Maybe MsSmoothGroupSettings)
ogsMsSmoothGroupSettings = lens _ogsMsSmoothGroupSettings (\ s a -> s{_ogsMsSmoothGroupSettings = a})
ogsHlsGroupSettings :: Lens' OutputGroupSettings (Maybe HlsGroupSettings)
ogsHlsGroupSettings = lens _ogsHlsGroupSettings (\ s a -> s{_ogsHlsGroupSettings = a})
ogsType :: Lens' OutputGroupSettings (Maybe OutputGroupType)
ogsType = lens _ogsType (\ s a -> s{_ogsType = a})
ogsDashIsoGroupSettings :: Lens' OutputGroupSettings (Maybe DashIsoGroupSettings)
ogsDashIsoGroupSettings = lens _ogsDashIsoGroupSettings (\ s a -> s{_ogsDashIsoGroupSettings = a})
instance FromJSON OutputGroupSettings where
parseJSON
= withObject "OutputGroupSettings"
(\ x ->
OutputGroupSettings' <$>
(x .:? "fileGroupSettings") <*>
(x .:? "msSmoothGroupSettings")
<*> (x .:? "hlsGroupSettings")
<*> (x .:? "type")
<*> (x .:? "dashIsoGroupSettings"))
instance Hashable OutputGroupSettings where
instance NFData OutputGroupSettings where
instance ToJSON OutputGroupSettings where
toJSON OutputGroupSettings'{..}
= object
(catMaybes
[("fileGroupSettings" .=) <$> _ogsFileGroupSettings,
("msSmoothGroupSettings" .=) <$>
_ogsMsSmoothGroupSettings,
("hlsGroupSettings" .=) <$> _ogsHlsGroupSettings,
("type" .=) <$> _ogsType,
("dashIsoGroupSettings" .=) <$>
_ogsDashIsoGroupSettings])
newtype OutputSettings = OutputSettings'
{ _osHlsSettings :: Maybe HlsSettings
} deriving (Eq, Read, Show, Data, Typeable, Generic)
outputSettings
:: OutputSettings
outputSettings = OutputSettings' {_osHlsSettings = Nothing}
osHlsSettings :: Lens' OutputSettings (Maybe HlsSettings)
osHlsSettings = lens _osHlsSettings (\ s a -> s{_osHlsSettings = a})
instance FromJSON OutputSettings where
parseJSON
= withObject "OutputSettings"
(\ x -> OutputSettings' <$> (x .:? "hlsSettings"))
instance Hashable OutputSettings where
instance NFData OutputSettings where
instance ToJSON OutputSettings where
toJSON OutputSettings'{..}
= object
(catMaybes [("hlsSettings" .=) <$> _osHlsSettings])
data Preset = Preset'
{ _pLastUpdated :: !(Maybe POSIX)
, _pSettings :: !(Maybe PresetSettings)
, _pARN :: !(Maybe Text)
, _pCreatedAt :: !(Maybe POSIX)
, _pCategory :: !(Maybe Text)
, _pName :: !(Maybe Text)
, _pType :: !(Maybe Type)
, _pDescription :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
preset
:: Preset
preset =
Preset'
{ _pLastUpdated = Nothing
, _pSettings = Nothing
, _pARN = Nothing
, _pCreatedAt = Nothing
, _pCategory = Nothing
, _pName = Nothing
, _pType = Nothing
, _pDescription = Nothing
}
pLastUpdated :: Lens' Preset (Maybe UTCTime)
pLastUpdated = lens _pLastUpdated (\ s a -> s{_pLastUpdated = a}) . mapping _Time
pSettings :: Lens' Preset (Maybe PresetSettings)
pSettings = lens _pSettings (\ s a -> s{_pSettings = a})
pARN :: Lens' Preset (Maybe Text)
pARN = lens _pARN (\ s a -> s{_pARN = a})
pCreatedAt :: Lens' Preset (Maybe UTCTime)
pCreatedAt = lens _pCreatedAt (\ s a -> s{_pCreatedAt = a}) . mapping _Time
pCategory :: Lens' Preset (Maybe Text)
pCategory = lens _pCategory (\ s a -> s{_pCategory = a})
pName :: Lens' Preset (Maybe Text)
pName = lens _pName (\ s a -> s{_pName = a})
pType :: Lens' Preset (Maybe Type)
pType = lens _pType (\ s a -> s{_pType = a})
pDescription :: Lens' Preset (Maybe Text)
pDescription = lens _pDescription (\ s a -> s{_pDescription = a})
instance FromJSON Preset where
parseJSON
= withObject "Preset"
(\ x ->
Preset' <$>
(x .:? "lastUpdated") <*> (x .:? "settings") <*>
(x .:? "arn")
<*> (x .:? "createdAt")
<*> (x .:? "category")
<*> (x .:? "name")
<*> (x .:? "type")
<*> (x .:? "description"))
instance Hashable Preset where
instance NFData Preset where
data PresetSettings = PresetSettings'
{ _psCaptionDescriptions :: !(Maybe [CaptionDescriptionPreset])
, _psVideoDescription :: !(Maybe VideoDescription)
, _psContainerSettings :: !(Maybe ContainerSettings)
, _psAudioDescriptions :: !(Maybe [AudioDescription])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
presetSettings
:: PresetSettings
presetSettings =
PresetSettings'
{ _psCaptionDescriptions = Nothing
, _psVideoDescription = Nothing
, _psContainerSettings = Nothing
, _psAudioDescriptions = Nothing
}
psCaptionDescriptions :: Lens' PresetSettings [CaptionDescriptionPreset]
psCaptionDescriptions = lens _psCaptionDescriptions (\ s a -> s{_psCaptionDescriptions = a}) . _Default . _Coerce
psVideoDescription :: Lens' PresetSettings (Maybe VideoDescription)
psVideoDescription = lens _psVideoDescription (\ s a -> s{_psVideoDescription = a})
psContainerSettings :: Lens' PresetSettings (Maybe ContainerSettings)
psContainerSettings = lens _psContainerSettings (\ s a -> s{_psContainerSettings = a})
psAudioDescriptions :: Lens' PresetSettings [AudioDescription]
psAudioDescriptions = lens _psAudioDescriptions (\ s a -> s{_psAudioDescriptions = a}) . _Default . _Coerce
instance FromJSON PresetSettings where
parseJSON
= withObject "PresetSettings"
(\ x ->
PresetSettings' <$>
(x .:? "captionDescriptions" .!= mempty) <*>
(x .:? "videoDescription")
<*> (x .:? "containerSettings")
<*> (x .:? "audioDescriptions" .!= mempty))
instance Hashable PresetSettings where
instance NFData PresetSettings where
instance ToJSON PresetSettings where
toJSON PresetSettings'{..}
= object
(catMaybes
[("captionDescriptions" .=) <$>
_psCaptionDescriptions,
("videoDescription" .=) <$> _psVideoDescription,
("containerSettings" .=) <$> _psContainerSettings,
("audioDescriptions" .=) <$> _psAudioDescriptions])
data ProresSettings = ProresSettings'
{ _psSlowPal :: !(Maybe ProresSlowPal)
, _psParNumerator :: !(Maybe Int)
, _psTelecine :: !(Maybe ProresTelecine)
, _psInterlaceMode :: !(Maybe ProresInterlaceMode)
, _psParControl :: !(Maybe ProresParControl)
, _psCodecProfile :: !(Maybe ProresCodecProfile)
, _psFramerateDenominator :: !(Maybe Int)
, _psFramerateConversionAlgorithm :: !(Maybe ProresFramerateConversionAlgorithm)
, _psFramerateControl :: !(Maybe ProresFramerateControl)
, _psFramerateNumerator :: !(Maybe Int)
, _psParDenominator :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
proresSettings
:: ProresSettings
proresSettings =
ProresSettings'
{ _psSlowPal = Nothing
, _psParNumerator = Nothing
, _psTelecine = Nothing
, _psInterlaceMode = Nothing
, _psParControl = Nothing
, _psCodecProfile = Nothing
, _psFramerateDenominator = Nothing
, _psFramerateConversionAlgorithm = Nothing
, _psFramerateControl = Nothing
, _psFramerateNumerator = Nothing
, _psParDenominator = Nothing
}
psSlowPal :: Lens' ProresSettings (Maybe ProresSlowPal)
psSlowPal = lens _psSlowPal (\ s a -> s{_psSlowPal = a})
psParNumerator :: Lens' ProresSettings (Maybe Int)
psParNumerator = lens _psParNumerator (\ s a -> s{_psParNumerator = a})
psTelecine :: Lens' ProresSettings (Maybe ProresTelecine)
psTelecine = lens _psTelecine (\ s a -> s{_psTelecine = a})
psInterlaceMode :: Lens' ProresSettings (Maybe ProresInterlaceMode)
psInterlaceMode = lens _psInterlaceMode (\ s a -> s{_psInterlaceMode = a})
psParControl :: Lens' ProresSettings (Maybe ProresParControl)
psParControl = lens _psParControl (\ s a -> s{_psParControl = a})
psCodecProfile :: Lens' ProresSettings (Maybe ProresCodecProfile)
psCodecProfile = lens _psCodecProfile (\ s a -> s{_psCodecProfile = a})
psFramerateDenominator :: Lens' ProresSettings (Maybe Int)
psFramerateDenominator = lens _psFramerateDenominator (\ s a -> s{_psFramerateDenominator = a})
psFramerateConversionAlgorithm :: Lens' ProresSettings (Maybe ProresFramerateConversionAlgorithm)
psFramerateConversionAlgorithm = lens _psFramerateConversionAlgorithm (\ s a -> s{_psFramerateConversionAlgorithm = a})
psFramerateControl :: Lens' ProresSettings (Maybe ProresFramerateControl)
psFramerateControl = lens _psFramerateControl (\ s a -> s{_psFramerateControl = a})
psFramerateNumerator :: Lens' ProresSettings (Maybe Int)
psFramerateNumerator = lens _psFramerateNumerator (\ s a -> s{_psFramerateNumerator = a})
psParDenominator :: Lens' ProresSettings (Maybe Int)
psParDenominator = lens _psParDenominator (\ s a -> s{_psParDenominator = a})
instance FromJSON ProresSettings where
parseJSON
= withObject "ProresSettings"
(\ x ->
ProresSettings' <$>
(x .:? "slowPal") <*> (x .:? "parNumerator") <*>
(x .:? "telecine")
<*> (x .:? "interlaceMode")
<*> (x .:? "parControl")
<*> (x .:? "codecProfile")
<*> (x .:? "framerateDenominator")
<*> (x .:? "framerateConversionAlgorithm")
<*> (x .:? "framerateControl")
<*> (x .:? "framerateNumerator")
<*> (x .:? "parDenominator"))
instance Hashable ProresSettings where
instance NFData ProresSettings where
instance ToJSON ProresSettings where
toJSON ProresSettings'{..}
= object
(catMaybes
[("slowPal" .=) <$> _psSlowPal,
("parNumerator" .=) <$> _psParNumerator,
("telecine" .=) <$> _psTelecine,
("interlaceMode" .=) <$> _psInterlaceMode,
("parControl" .=) <$> _psParControl,
("codecProfile" .=) <$> _psCodecProfile,
("framerateDenominator" .=) <$>
_psFramerateDenominator,
("framerateConversionAlgorithm" .=) <$>
_psFramerateConversionAlgorithm,
("framerateControl" .=) <$> _psFramerateControl,
("framerateNumerator" .=) <$> _psFramerateNumerator,
("parDenominator" .=) <$> _psParDenominator])
data Queue = Queue'
{ _qStatus :: !(Maybe QueueStatus)
, _qLastUpdated :: !(Maybe POSIX)
, _qARN :: !(Maybe Text)
, _qCreatedAt :: !(Maybe POSIX)
, _qName :: !(Maybe Text)
, _qType :: !(Maybe Type)
, _qDescription :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
queue
:: Queue
queue =
Queue'
{ _qStatus = Nothing
, _qLastUpdated = Nothing
, _qARN = Nothing
, _qCreatedAt = Nothing
, _qName = Nothing
, _qType = Nothing
, _qDescription = Nothing
}
qStatus :: Lens' Queue (Maybe QueueStatus)
qStatus = lens _qStatus (\ s a -> s{_qStatus = a})
qLastUpdated :: Lens' Queue (Maybe UTCTime)
qLastUpdated = lens _qLastUpdated (\ s a -> s{_qLastUpdated = a}) . mapping _Time
qARN :: Lens' Queue (Maybe Text)
qARN = lens _qARN (\ s a -> s{_qARN = a})
qCreatedAt :: Lens' Queue (Maybe UTCTime)
qCreatedAt = lens _qCreatedAt (\ s a -> s{_qCreatedAt = a}) . mapping _Time
qName :: Lens' Queue (Maybe Text)
qName = lens _qName (\ s a -> s{_qName = a})
qType :: Lens' Queue (Maybe Type)
qType = lens _qType (\ s a -> s{_qType = a})
qDescription :: Lens' Queue (Maybe Text)
qDescription = lens _qDescription (\ s a -> s{_qDescription = a})
instance FromJSON Queue where
parseJSON
= withObject "Queue"
(\ x ->
Queue' <$>
(x .:? "status") <*> (x .:? "lastUpdated") <*>
(x .:? "arn")
<*> (x .:? "createdAt")
<*> (x .:? "name")
<*> (x .:? "type")
<*> (x .:? "description"))
instance Hashable Queue where
instance NFData Queue where
data Rectangle = Rectangle'
{ _rHeight :: !(Maybe Int)
, _rWidth :: !(Maybe Int)
, _rX :: !(Maybe Int)
, _rY :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
rectangle
:: Rectangle
rectangle =
Rectangle'
{_rHeight = Nothing, _rWidth = Nothing, _rX = Nothing, _rY = Nothing}
rHeight :: Lens' Rectangle (Maybe Int)
rHeight = lens _rHeight (\ s a -> s{_rHeight = a})
rWidth :: Lens' Rectangle (Maybe Int)
rWidth = lens _rWidth (\ s a -> s{_rWidth = a})
rX :: Lens' Rectangle (Maybe Int)
rX = lens _rX (\ s a -> s{_rX = a})
rY :: Lens' Rectangle (Maybe Int)
rY = lens _rY (\ s a -> s{_rY = a})
instance FromJSON Rectangle where
parseJSON
= withObject "Rectangle"
(\ x ->
Rectangle' <$>
(x .:? "height") <*> (x .:? "width") <*> (x .:? "x")
<*> (x .:? "y"))
instance Hashable Rectangle where
instance NFData Rectangle where
instance ToJSON Rectangle where
toJSON Rectangle'{..}
= object
(catMaybes
[("height" .=) <$> _rHeight,
("width" .=) <$> _rWidth, ("x" .=) <$> _rX,
("y" .=) <$> _rY])
data RemixSettings = RemixSettings'
{ _rsChannelMapping :: !(Maybe ChannelMapping)
, _rsChannelsIn :: !(Maybe Int)
, _rsChannelsOut :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
remixSettings
:: RemixSettings
remixSettings =
RemixSettings'
{ _rsChannelMapping = Nothing
, _rsChannelsIn = Nothing
, _rsChannelsOut = Nothing
}
rsChannelMapping :: Lens' RemixSettings (Maybe ChannelMapping)
rsChannelMapping = lens _rsChannelMapping (\ s a -> s{_rsChannelMapping = a})
rsChannelsIn :: Lens' RemixSettings (Maybe Int)
rsChannelsIn = lens _rsChannelsIn (\ s a -> s{_rsChannelsIn = a})
rsChannelsOut :: Lens' RemixSettings (Maybe Int)
rsChannelsOut = lens _rsChannelsOut (\ s a -> s{_rsChannelsOut = a})
instance FromJSON RemixSettings where
parseJSON
= withObject "RemixSettings"
(\ x ->
RemixSettings' <$>
(x .:? "channelMapping") <*> (x .:? "channelsIn") <*>
(x .:? "channelsOut"))
instance Hashable RemixSettings where
instance NFData RemixSettings where
instance ToJSON RemixSettings where
toJSON RemixSettings'{..}
= object
(catMaybes
[("channelMapping" .=) <$> _rsChannelMapping,
("channelsIn" .=) <$> _rsChannelsIn,
("channelsOut" .=) <$> _rsChannelsOut])
newtype SccDestinationSettings = SccDestinationSettings'
{ _sdsFramerate :: Maybe SccDestinationFramerate
} deriving (Eq, Read, Show, Data, Typeable, Generic)
sccDestinationSettings
:: SccDestinationSettings
sccDestinationSettings = SccDestinationSettings' {_sdsFramerate = Nothing}
sdsFramerate :: Lens' SccDestinationSettings (Maybe SccDestinationFramerate)
sdsFramerate = lens _sdsFramerate (\ s a -> s{_sdsFramerate = a})
instance FromJSON SccDestinationSettings where
parseJSON
= withObject "SccDestinationSettings"
(\ x ->
SccDestinationSettings' <$> (x .:? "framerate"))
instance Hashable SccDestinationSettings where
instance NFData SccDestinationSettings where
instance ToJSON SccDestinationSettings where
toJSON SccDestinationSettings'{..}
= object
(catMaybes [("framerate" .=) <$> _sdsFramerate])
data SpekeKeyProvider = SpekeKeyProvider'
{ _skpResourceId :: !(Maybe Text)
, _skpURL :: !(Maybe Text)
, _skpSystemIds :: !(Maybe [Text])
} deriving (Eq, Read, Show, Data, Typeable, Generic)
spekeKeyProvider
:: SpekeKeyProvider
spekeKeyProvider =
SpekeKeyProvider'
{_skpResourceId = Nothing, _skpURL = Nothing, _skpSystemIds = Nothing}
skpResourceId :: Lens' SpekeKeyProvider (Maybe Text)
skpResourceId = lens _skpResourceId (\ s a -> s{_skpResourceId = a})
skpURL :: Lens' SpekeKeyProvider (Maybe Text)
skpURL = lens _skpURL (\ s a -> s{_skpURL = a})
skpSystemIds :: Lens' SpekeKeyProvider [Text]
skpSystemIds = lens _skpSystemIds (\ s a -> s{_skpSystemIds = a}) . _Default . _Coerce
instance FromJSON SpekeKeyProvider where
parseJSON
= withObject "SpekeKeyProvider"
(\ x ->
SpekeKeyProvider' <$>
(x .:? "resourceId") <*> (x .:? "url") <*>
(x .:? "systemIds" .!= mempty))
instance Hashable SpekeKeyProvider where
instance NFData SpekeKeyProvider where
instance ToJSON SpekeKeyProvider where
toJSON SpekeKeyProvider'{..}
= object
(catMaybes
[("resourceId" .=) <$> _skpResourceId,
("url" .=) <$> _skpURL,
("systemIds" .=) <$> _skpSystemIds])
data StaticKeyProvider = StaticKeyProvider'
{ _sStaticKeyValue :: !(Maybe Text)
, _sURL :: !(Maybe Text)
, _sKeyFormat :: !(Maybe Text)
, _sKeyFormatVersions :: !(Maybe Text)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
staticKeyProvider
:: StaticKeyProvider
staticKeyProvider =
StaticKeyProvider'
{ _sStaticKeyValue = Nothing
, _sURL = Nothing
, _sKeyFormat = Nothing
, _sKeyFormatVersions = Nothing
}
sStaticKeyValue :: Lens' StaticKeyProvider (Maybe Text)
sStaticKeyValue = lens _sStaticKeyValue (\ s a -> s{_sStaticKeyValue = a})
sURL :: Lens' StaticKeyProvider (Maybe Text)
sURL = lens _sURL (\ s a -> s{_sURL = a})
sKeyFormat :: Lens' StaticKeyProvider (Maybe Text)
sKeyFormat = lens _sKeyFormat (\ s a -> s{_sKeyFormat = a})
sKeyFormatVersions :: Lens' StaticKeyProvider (Maybe Text)
sKeyFormatVersions = lens _sKeyFormatVersions (\ s a -> s{_sKeyFormatVersions = a})
instance FromJSON StaticKeyProvider where
parseJSON
= withObject "StaticKeyProvider"
(\ x ->
StaticKeyProvider' <$>
(x .:? "staticKeyValue") <*> (x .:? "url") <*>
(x .:? "keyFormat")
<*> (x .:? "keyFormatVersions"))
instance Hashable StaticKeyProvider where
instance NFData StaticKeyProvider where
instance ToJSON StaticKeyProvider where
toJSON StaticKeyProvider'{..}
= object
(catMaybes
[("staticKeyValue" .=) <$> _sStaticKeyValue,
("url" .=) <$> _sURL,
("keyFormat" .=) <$> _sKeyFormat,
("keyFormatVersions" .=) <$> _sKeyFormatVersions])
newtype TeletextDestinationSettings = TeletextDestinationSettings'
{ _tdsPageNumber :: Maybe Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
teletextDestinationSettings
:: TeletextDestinationSettings
teletextDestinationSettings =
TeletextDestinationSettings' {_tdsPageNumber = Nothing}
tdsPageNumber :: Lens' TeletextDestinationSettings (Maybe Text)
tdsPageNumber = lens _tdsPageNumber (\ s a -> s{_tdsPageNumber = a})
instance FromJSON TeletextDestinationSettings where
parseJSON
= withObject "TeletextDestinationSettings"
(\ x ->
TeletextDestinationSettings' <$>
(x .:? "pageNumber"))
instance Hashable TeletextDestinationSettings where
instance NFData TeletextDestinationSettings where
instance ToJSON TeletextDestinationSettings where
toJSON TeletextDestinationSettings'{..}
= object
(catMaybes [("pageNumber" .=) <$> _tdsPageNumber])
newtype TeletextSourceSettings = TeletextSourceSettings'
{ _tssPageNumber :: Maybe Text
} deriving (Eq, Read, Show, Data, Typeable, Generic)
teletextSourceSettings
:: TeletextSourceSettings
teletextSourceSettings = TeletextSourceSettings' {_tssPageNumber = Nothing}
tssPageNumber :: Lens' TeletextSourceSettings (Maybe Text)
tssPageNumber = lens _tssPageNumber (\ s a -> s{_tssPageNumber = a})
instance FromJSON TeletextSourceSettings where
parseJSON
= withObject "TeletextSourceSettings"
(\ x ->
TeletextSourceSettings' <$> (x .:? "pageNumber"))
instance Hashable TeletextSourceSettings where
instance NFData TeletextSourceSettings where
instance ToJSON TeletextSourceSettings where
toJSON TeletextSourceSettings'{..}
= object
(catMaybes [("pageNumber" .=) <$> _tssPageNumber])
data TimecodeBurnin = TimecodeBurnin'
{ _tbPrefix :: !(Maybe Text)
, _tbFontSize :: !(Maybe Int)
, _tbPosition :: !(Maybe TimecodeBurninPosition)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
timecodeBurnin
:: TimecodeBurnin
timecodeBurnin =
TimecodeBurnin'
{_tbPrefix = Nothing, _tbFontSize = Nothing, _tbPosition = Nothing}
tbPrefix :: Lens' TimecodeBurnin (Maybe Text)
tbPrefix = lens _tbPrefix (\ s a -> s{_tbPrefix = a})
tbFontSize :: Lens' TimecodeBurnin (Maybe Int)
tbFontSize = lens _tbFontSize (\ s a -> s{_tbFontSize = a})
tbPosition :: Lens' TimecodeBurnin (Maybe TimecodeBurninPosition)
tbPosition = lens _tbPosition (\ s a -> s{_tbPosition = a})
instance FromJSON TimecodeBurnin where
parseJSON
= withObject "TimecodeBurnin"
(\ x ->
TimecodeBurnin' <$>
(x .:? "prefix") <*> (x .:? "fontSize") <*>
(x .:? "position"))
instance Hashable TimecodeBurnin where
instance NFData TimecodeBurnin where
instance ToJSON TimecodeBurnin where
toJSON TimecodeBurnin'{..}
= object
(catMaybes
[("prefix" .=) <$> _tbPrefix,
("fontSize" .=) <$> _tbFontSize,
("position" .=) <$> _tbPosition])
data TimecodeConfig = TimecodeConfig'
{ _tcStart :: !(Maybe Text)
, _tcTimestampOffset :: !(Maybe Text)
, _tcAnchor :: !(Maybe Text)
, _tcSource :: !(Maybe TimecodeSource)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
timecodeConfig
:: TimecodeConfig
timecodeConfig =
TimecodeConfig'
{ _tcStart = Nothing
, _tcTimestampOffset = Nothing
, _tcAnchor = Nothing
, _tcSource = Nothing
}
tcStart :: Lens' TimecodeConfig (Maybe Text)
tcStart = lens _tcStart (\ s a -> s{_tcStart = a})
tcTimestampOffset :: Lens' TimecodeConfig (Maybe Text)
tcTimestampOffset = lens _tcTimestampOffset (\ s a -> s{_tcTimestampOffset = a})
tcAnchor :: Lens' TimecodeConfig (Maybe Text)
tcAnchor = lens _tcAnchor (\ s a -> s{_tcAnchor = a})
tcSource :: Lens' TimecodeConfig (Maybe TimecodeSource)
tcSource = lens _tcSource (\ s a -> s{_tcSource = a})
instance FromJSON TimecodeConfig where
parseJSON
= withObject "TimecodeConfig"
(\ x ->
TimecodeConfig' <$>
(x .:? "start") <*> (x .:? "timestampOffset") <*>
(x .:? "anchor")
<*> (x .:? "source"))
instance Hashable TimecodeConfig where
instance NFData TimecodeConfig where
instance ToJSON TimecodeConfig where
toJSON TimecodeConfig'{..}
= object
(catMaybes
[("start" .=) <$> _tcStart,
("timestampOffset" .=) <$> _tcTimestampOffset,
("anchor" .=) <$> _tcAnchor,
("source" .=) <$> _tcSource])
newtype TimedMetadataInsertion = TimedMetadataInsertion'
{ _tmiId3Insertions :: Maybe [Id3Insertion]
} deriving (Eq, Read, Show, Data, Typeable, Generic)
timedMetadataInsertion
:: TimedMetadataInsertion
timedMetadataInsertion = TimedMetadataInsertion' {_tmiId3Insertions = Nothing}
tmiId3Insertions :: Lens' TimedMetadataInsertion [Id3Insertion]
tmiId3Insertions = lens _tmiId3Insertions (\ s a -> s{_tmiId3Insertions = a}) . _Default . _Coerce
instance FromJSON TimedMetadataInsertion where
parseJSON
= withObject "TimedMetadataInsertion"
(\ x ->
TimedMetadataInsertion' <$>
(x .:? "id3Insertions" .!= mempty))
instance Hashable TimedMetadataInsertion where
instance NFData TimedMetadataInsertion where
instance ToJSON TimedMetadataInsertion where
toJSON TimedMetadataInsertion'{..}
= object
(catMaybes
[("id3Insertions" .=) <$> _tmiId3Insertions])
data Timing = Timing'
{ _tStartTime :: !(Maybe POSIX)
, _tFinishTime :: !(Maybe POSIX)
, _tSubmitTime :: !(Maybe POSIX)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
timing
:: Timing
timing =
Timing'
{_tStartTime = Nothing, _tFinishTime = Nothing, _tSubmitTime = Nothing}
tStartTime :: Lens' Timing (Maybe UTCTime)
tStartTime = lens _tStartTime (\ s a -> s{_tStartTime = a}) . mapping _Time
tFinishTime :: Lens' Timing (Maybe UTCTime)
tFinishTime = lens _tFinishTime (\ s a -> s{_tFinishTime = a}) . mapping _Time
tSubmitTime :: Lens' Timing (Maybe UTCTime)
tSubmitTime = lens _tSubmitTime (\ s a -> s{_tSubmitTime = a}) . mapping _Time
instance FromJSON Timing where
parseJSON
= withObject "Timing"
(\ x ->
Timing' <$>
(x .:? "startTime") <*> (x .:? "finishTime") <*>
(x .:? "submitTime"))
instance Hashable Timing where
instance NFData Timing where
newtype TtmlDestinationSettings = TtmlDestinationSettings'
{ _tdsStylePassthrough :: Maybe TtmlStylePassthrough
} deriving (Eq, Read, Show, Data, Typeable, Generic)
ttmlDestinationSettings
:: TtmlDestinationSettings
ttmlDestinationSettings =
TtmlDestinationSettings' {_tdsStylePassthrough = Nothing}
tdsStylePassthrough :: Lens' TtmlDestinationSettings (Maybe TtmlStylePassthrough)
tdsStylePassthrough = lens _tdsStylePassthrough (\ s a -> s{_tdsStylePassthrough = a})
instance FromJSON TtmlDestinationSettings where
parseJSON
= withObject "TtmlDestinationSettings"
(\ x ->
TtmlDestinationSettings' <$>
(x .:? "stylePassthrough"))
instance Hashable TtmlDestinationSettings where
instance NFData TtmlDestinationSettings where
instance ToJSON TtmlDestinationSettings where
toJSON TtmlDestinationSettings'{..}
= object
(catMaybes
[("stylePassthrough" .=) <$> _tdsStylePassthrough])
data VideoCodecSettings = VideoCodecSettings'
{ _vcsFrameCaptureSettings :: !(Maybe FrameCaptureSettings)
, _vcsCodec :: !(Maybe VideoCodec)
, _vcsH265Settings :: !(Maybe H265Settings)
, _vcsProresSettings :: !(Maybe ProresSettings)
, _vcsH264Settings :: !(Maybe H264Settings)
, _vcsMpeg2Settings :: !(Maybe Mpeg2Settings)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
videoCodecSettings
:: VideoCodecSettings
videoCodecSettings =
VideoCodecSettings'
{ _vcsFrameCaptureSettings = Nothing
, _vcsCodec = Nothing
, _vcsH265Settings = Nothing
, _vcsProresSettings = Nothing
, _vcsH264Settings = Nothing
, _vcsMpeg2Settings = Nothing
}
vcsFrameCaptureSettings :: Lens' VideoCodecSettings (Maybe FrameCaptureSettings)
vcsFrameCaptureSettings = lens _vcsFrameCaptureSettings (\ s a -> s{_vcsFrameCaptureSettings = a})
vcsCodec :: Lens' VideoCodecSettings (Maybe VideoCodec)
vcsCodec = lens _vcsCodec (\ s a -> s{_vcsCodec = a})
vcsH265Settings :: Lens' VideoCodecSettings (Maybe H265Settings)
vcsH265Settings = lens _vcsH265Settings (\ s a -> s{_vcsH265Settings = a})
vcsProresSettings :: Lens' VideoCodecSettings (Maybe ProresSettings)
vcsProresSettings = lens _vcsProresSettings (\ s a -> s{_vcsProresSettings = a})
vcsH264Settings :: Lens' VideoCodecSettings (Maybe H264Settings)
vcsH264Settings = lens _vcsH264Settings (\ s a -> s{_vcsH264Settings = a})
vcsMpeg2Settings :: Lens' VideoCodecSettings (Maybe Mpeg2Settings)
vcsMpeg2Settings = lens _vcsMpeg2Settings (\ s a -> s{_vcsMpeg2Settings = a})
instance FromJSON VideoCodecSettings where
parseJSON
= withObject "VideoCodecSettings"
(\ x ->
VideoCodecSettings' <$>
(x .:? "frameCaptureSettings") <*> (x .:? "codec")
<*> (x .:? "h265Settings")
<*> (x .:? "proresSettings")
<*> (x .:? "h264Settings")
<*> (x .:? "mpeg2Settings"))
instance Hashable VideoCodecSettings where
instance NFData VideoCodecSettings where
instance ToJSON VideoCodecSettings where
toJSON VideoCodecSettings'{..}
= object
(catMaybes
[("frameCaptureSettings" .=) <$>
_vcsFrameCaptureSettings,
("codec" .=) <$> _vcsCodec,
("h265Settings" .=) <$> _vcsH265Settings,
("proresSettings" .=) <$> _vcsProresSettings,
("h264Settings" .=) <$> _vcsH264Settings,
("mpeg2Settings" .=) <$> _vcsMpeg2Settings])
data VideoDescription = VideoDescription'
{ _vdTimecodeInsertion :: !(Maybe VideoTimecodeInsertion)
, _vdHeight :: !(Maybe Int)
, _vdAfdSignaling :: !(Maybe AfdSignaling)
, _vdSharpness :: !(Maybe Int)
, _vdCrop :: !(Maybe Rectangle)
, _vdWidth :: !(Maybe Int)
, _vdScalingBehavior :: !(Maybe ScalingBehavior)
, _vdRespondToAfd :: !(Maybe RespondToAfd)
, _vdDropFrameTimecode :: !(Maybe DropFrameTimecode)
, _vdAntiAlias :: !(Maybe AntiAlias)
, _vdFixedAfd :: !(Maybe Int)
, _vdColorMetadata :: !(Maybe ColorMetadata)
, _vdCodecSettings :: !(Maybe VideoCodecSettings)
, _vdVideoPreprocessors :: !(Maybe VideoPreprocessor)
, _vdPosition :: !(Maybe Rectangle)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
videoDescription
:: VideoDescription
videoDescription =
VideoDescription'
{ _vdTimecodeInsertion = Nothing
, _vdHeight = Nothing
, _vdAfdSignaling = Nothing
, _vdSharpness = Nothing
, _vdCrop = Nothing
, _vdWidth = Nothing
, _vdScalingBehavior = Nothing
, _vdRespondToAfd = Nothing
, _vdDropFrameTimecode = Nothing
, _vdAntiAlias = Nothing
, _vdFixedAfd = Nothing
, _vdColorMetadata = Nothing
, _vdCodecSettings = Nothing
, _vdVideoPreprocessors = Nothing
, _vdPosition = Nothing
}
vdTimecodeInsertion :: Lens' VideoDescription (Maybe VideoTimecodeInsertion)
vdTimecodeInsertion = lens _vdTimecodeInsertion (\ s a -> s{_vdTimecodeInsertion = a})
vdHeight :: Lens' VideoDescription (Maybe Int)
vdHeight = lens _vdHeight (\ s a -> s{_vdHeight = a})
vdAfdSignaling :: Lens' VideoDescription (Maybe AfdSignaling)
vdAfdSignaling = lens _vdAfdSignaling (\ s a -> s{_vdAfdSignaling = a})
vdSharpness :: Lens' VideoDescription (Maybe Int)
vdSharpness = lens _vdSharpness (\ s a -> s{_vdSharpness = a})
vdCrop :: Lens' VideoDescription (Maybe Rectangle)
vdCrop = lens _vdCrop (\ s a -> s{_vdCrop = a})
vdWidth :: Lens' VideoDescription (Maybe Int)
vdWidth = lens _vdWidth (\ s a -> s{_vdWidth = a})
vdScalingBehavior :: Lens' VideoDescription (Maybe ScalingBehavior)
vdScalingBehavior = lens _vdScalingBehavior (\ s a -> s{_vdScalingBehavior = a})
vdRespondToAfd :: Lens' VideoDescription (Maybe RespondToAfd)
vdRespondToAfd = lens _vdRespondToAfd (\ s a -> s{_vdRespondToAfd = a})
vdDropFrameTimecode :: Lens' VideoDescription (Maybe DropFrameTimecode)
vdDropFrameTimecode = lens _vdDropFrameTimecode (\ s a -> s{_vdDropFrameTimecode = a})
vdAntiAlias :: Lens' VideoDescription (Maybe AntiAlias)
vdAntiAlias = lens _vdAntiAlias (\ s a -> s{_vdAntiAlias = a})
vdFixedAfd :: Lens' VideoDescription (Maybe Int)
vdFixedAfd = lens _vdFixedAfd (\ s a -> s{_vdFixedAfd = a})
vdColorMetadata :: Lens' VideoDescription (Maybe ColorMetadata)
vdColorMetadata = lens _vdColorMetadata (\ s a -> s{_vdColorMetadata = a})
vdCodecSettings :: Lens' VideoDescription (Maybe VideoCodecSettings)
vdCodecSettings = lens _vdCodecSettings (\ s a -> s{_vdCodecSettings = a})
vdVideoPreprocessors :: Lens' VideoDescription (Maybe VideoPreprocessor)
vdVideoPreprocessors = lens _vdVideoPreprocessors (\ s a -> s{_vdVideoPreprocessors = a})
vdPosition :: Lens' VideoDescription (Maybe Rectangle)
vdPosition = lens _vdPosition (\ s a -> s{_vdPosition = a})
instance FromJSON VideoDescription where
parseJSON
= withObject "VideoDescription"
(\ x ->
VideoDescription' <$>
(x .:? "timecodeInsertion") <*> (x .:? "height") <*>
(x .:? "afdSignaling")
<*> (x .:? "sharpness")
<*> (x .:? "crop")
<*> (x .:? "width")
<*> (x .:? "scalingBehavior")
<*> (x .:? "respondToAfd")
<*> (x .:? "dropFrameTimecode")
<*> (x .:? "antiAlias")
<*> (x .:? "fixedAfd")
<*> (x .:? "colorMetadata")
<*> (x .:? "codecSettings")
<*> (x .:? "videoPreprocessors")
<*> (x .:? "position"))
instance Hashable VideoDescription where
instance NFData VideoDescription where
instance ToJSON VideoDescription where
toJSON VideoDescription'{..}
= object
(catMaybes
[("timecodeInsertion" .=) <$> _vdTimecodeInsertion,
("height" .=) <$> _vdHeight,
("afdSignaling" .=) <$> _vdAfdSignaling,
("sharpness" .=) <$> _vdSharpness,
("crop" .=) <$> _vdCrop, ("width" .=) <$> _vdWidth,
("scalingBehavior" .=) <$> _vdScalingBehavior,
("respondToAfd" .=) <$> _vdRespondToAfd,
("dropFrameTimecode" .=) <$> _vdDropFrameTimecode,
("antiAlias" .=) <$> _vdAntiAlias,
("fixedAfd" .=) <$> _vdFixedAfd,
("colorMetadata" .=) <$> _vdColorMetadata,
("codecSettings" .=) <$> _vdCodecSettings,
("videoPreprocessors" .=) <$> _vdVideoPreprocessors,
("position" .=) <$> _vdPosition])
data VideoDetail = VideoDetail'
{ _vdHeightInPx :: !(Maybe Int)
, _vdWidthInPx :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
videoDetail
:: VideoDetail
videoDetail = VideoDetail' {_vdHeightInPx = Nothing, _vdWidthInPx = Nothing}
vdHeightInPx :: Lens' VideoDetail (Maybe Int)
vdHeightInPx = lens _vdHeightInPx (\ s a -> s{_vdHeightInPx = a})
vdWidthInPx :: Lens' VideoDetail (Maybe Int)
vdWidthInPx = lens _vdWidthInPx (\ s a -> s{_vdWidthInPx = a})
instance FromJSON VideoDetail where
parseJSON
= withObject "VideoDetail"
(\ x ->
VideoDetail' <$>
(x .:? "heightInPx") <*> (x .:? "widthInPx"))
instance Hashable VideoDetail where
instance NFData VideoDetail where
data VideoPreprocessor = VideoPreprocessor'
{ _vpTimecodeBurnin :: !(Maybe TimecodeBurnin)
, _vpColorCorrector :: !(Maybe ColorCorrector)
, _vpDeinterlacer :: !(Maybe Deinterlacer)
, _vpNoiseReducer :: !(Maybe NoiseReducer)
, _vpImageInserter :: !(Maybe ImageInserter)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
videoPreprocessor
:: VideoPreprocessor
videoPreprocessor =
VideoPreprocessor'
{ _vpTimecodeBurnin = Nothing
, _vpColorCorrector = Nothing
, _vpDeinterlacer = Nothing
, _vpNoiseReducer = Nothing
, _vpImageInserter = Nothing
}
vpTimecodeBurnin :: Lens' VideoPreprocessor (Maybe TimecodeBurnin)
vpTimecodeBurnin = lens _vpTimecodeBurnin (\ s a -> s{_vpTimecodeBurnin = a})
vpColorCorrector :: Lens' VideoPreprocessor (Maybe ColorCorrector)
vpColorCorrector = lens _vpColorCorrector (\ s a -> s{_vpColorCorrector = a})
vpDeinterlacer :: Lens' VideoPreprocessor (Maybe Deinterlacer)
vpDeinterlacer = lens _vpDeinterlacer (\ s a -> s{_vpDeinterlacer = a})
vpNoiseReducer :: Lens' VideoPreprocessor (Maybe NoiseReducer)
vpNoiseReducer = lens _vpNoiseReducer (\ s a -> s{_vpNoiseReducer = a})
vpImageInserter :: Lens' VideoPreprocessor (Maybe ImageInserter)
vpImageInserter = lens _vpImageInserter (\ s a -> s{_vpImageInserter = a})
instance FromJSON VideoPreprocessor where
parseJSON
= withObject "VideoPreprocessor"
(\ x ->
VideoPreprocessor' <$>
(x .:? "timecodeBurnin") <*> (x .:? "colorCorrector")
<*> (x .:? "deinterlacer")
<*> (x .:? "noiseReducer")
<*> (x .:? "imageInserter"))
instance Hashable VideoPreprocessor where
instance NFData VideoPreprocessor where
instance ToJSON VideoPreprocessor where
toJSON VideoPreprocessor'{..}
= object
(catMaybes
[("timecodeBurnin" .=) <$> _vpTimecodeBurnin,
("colorCorrector" .=) <$> _vpColorCorrector,
("deinterlacer" .=) <$> _vpDeinterlacer,
("noiseReducer" .=) <$> _vpNoiseReducer,
("imageInserter" .=) <$> _vpImageInserter])
data VideoSelector = VideoSelector'
{ _vsProgramNumber :: !(Maybe Int)
, _vsColorSpaceUsage :: !(Maybe ColorSpaceUsage)
, _vsHdr10Metadata :: !(Maybe Hdr10Metadata)
, _vsPid :: !(Maybe Int)
, _vsColorSpace :: !(Maybe ColorSpace)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
videoSelector
:: VideoSelector
videoSelector =
VideoSelector'
{ _vsProgramNumber = Nothing
, _vsColorSpaceUsage = Nothing
, _vsHdr10Metadata = Nothing
, _vsPid = Nothing
, _vsColorSpace = Nothing
}
vsProgramNumber :: Lens' VideoSelector (Maybe Int)
vsProgramNumber = lens _vsProgramNumber (\ s a -> s{_vsProgramNumber = a})
vsColorSpaceUsage :: Lens' VideoSelector (Maybe ColorSpaceUsage)
vsColorSpaceUsage = lens _vsColorSpaceUsage (\ s a -> s{_vsColorSpaceUsage = a})
vsHdr10Metadata :: Lens' VideoSelector (Maybe Hdr10Metadata)
vsHdr10Metadata = lens _vsHdr10Metadata (\ s a -> s{_vsHdr10Metadata = a})
vsPid :: Lens' VideoSelector (Maybe Int)
vsPid = lens _vsPid (\ s a -> s{_vsPid = a})
vsColorSpace :: Lens' VideoSelector (Maybe ColorSpace)
vsColorSpace = lens _vsColorSpace (\ s a -> s{_vsColorSpace = a})
instance FromJSON VideoSelector where
parseJSON
= withObject "VideoSelector"
(\ x ->
VideoSelector' <$>
(x .:? "programNumber") <*> (x .:? "colorSpaceUsage")
<*> (x .:? "hdr10Metadata")
<*> (x .:? "pid")
<*> (x .:? "colorSpace"))
instance Hashable VideoSelector where
instance NFData VideoSelector where
instance ToJSON VideoSelector where
toJSON VideoSelector'{..}
= object
(catMaybes
[("programNumber" .=) <$> _vsProgramNumber,
("colorSpaceUsage" .=) <$> _vsColorSpaceUsage,
("hdr10Metadata" .=) <$> _vsHdr10Metadata,
("pid" .=) <$> _vsPid,
("colorSpace" .=) <$> _vsColorSpace])
data WavSettings = WavSettings'
{ _wsBitDepth :: !(Maybe Int)
, _wsChannels :: !(Maybe Int)
, _wsSampleRate :: !(Maybe Int)
} deriving (Eq, Read, Show, Data, Typeable, Generic)
wavSettings
:: WavSettings
wavSettings =
WavSettings'
{_wsBitDepth = Nothing, _wsChannels = Nothing, _wsSampleRate = Nothing}
wsBitDepth :: Lens' WavSettings (Maybe Int)
wsBitDepth = lens _wsBitDepth (\ s a -> s{_wsBitDepth = a})
wsChannels :: Lens' WavSettings (Maybe Int)
wsChannels = lens _wsChannels (\ s a -> s{_wsChannels = a})
wsSampleRate :: Lens' WavSettings (Maybe Int)
wsSampleRate = lens _wsSampleRate (\ s a -> s{_wsSampleRate = a})
instance FromJSON WavSettings where
parseJSON
= withObject "WavSettings"
(\ x ->
WavSettings' <$>
(x .:? "bitDepth") <*> (x .:? "channels") <*>
(x .:? "sampleRate"))
instance Hashable WavSettings where
instance NFData WavSettings where
instance ToJSON WavSettings where
toJSON WavSettings'{..}
= object
(catMaybes
[("bitDepth" .=) <$> _wsBitDepth,
("channels" .=) <$> _wsChannels,
("sampleRate" .=) <$> _wsSampleRate])