1 /** 2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 * SPDX-License-Identifier: Apache-2.0. 4 */ 5 6 #pragma once 7 #include <aws/medialive/MediaLive_EXPORTS.h> 8 #include <aws/medialive/model/H265AdaptiveQuantization.h> 9 #include <aws/medialive/model/AfdSignaling.h> 10 #include <aws/medialive/model/H265AlternativeTransferFunction.h> 11 #include <aws/medialive/model/H265ColorMetadata.h> 12 #include <aws/medialive/model/H265ColorSpaceSettings.h> 13 #include <aws/medialive/model/H265FilterSettings.h> 14 #include <aws/medialive/model/FixedAfd.h> 15 #include <aws/medialive/model/H265FlickerAq.h> 16 #include <aws/medialive/model/H265GopSizeUnits.h> 17 #include <aws/medialive/model/H265Level.h> 18 #include <aws/medialive/model/H265LookAheadRateControl.h> 19 #include <aws/medialive/model/H265Profile.h> 20 #include <aws/medialive/model/H265RateControlMode.h> 21 #include <aws/medialive/model/H265ScanType.h> 22 #include <aws/medialive/model/H265SceneChangeDetect.h> 23 #include <aws/medialive/model/H265Tier.h> 24 #include <aws/medialive/model/H265TimecodeInsertionBehavior.h> 25 #include <utility> 26 27 namespace Aws 28 { 29 namespace Utils 30 { 31 namespace Json 32 { 33 class JsonValue; 34 class JsonView; 35 } // namespace Json 36 } // namespace Utils 37 namespace MediaLive 38 { 39 namespace Model 40 { 41 42 /** 43 * H265 Settings<p><h3>See Also:</h3> <a 44 * href="http://docs.aws.amazon.com/goto/WebAPI/medialive-2017-10-14/H265Settings">AWS 45 * API Reference</a></p> 46 */ 47 class AWS_MEDIALIVE_API H265Settings 48 { 49 public: 50 H265Settings(); 51 H265Settings(Aws::Utils::Json::JsonView jsonValue); 52 H265Settings& operator=(Aws::Utils::Json::JsonView jsonValue); 53 Aws::Utils::Json::JsonValue Jsonize() const; 54 55 56 /** 57 * Adaptive quantization. Allows intra-frame quantizers to vary to improve visual 58 * quality. 59 */ GetAdaptiveQuantization()60 inline const H265AdaptiveQuantization& GetAdaptiveQuantization() const{ return m_adaptiveQuantization; } 61 62 /** 63 * Adaptive quantization. Allows intra-frame quantizers to vary to improve visual 64 * quality. 65 */ AdaptiveQuantizationHasBeenSet()66 inline bool AdaptiveQuantizationHasBeenSet() const { return m_adaptiveQuantizationHasBeenSet; } 67 68 /** 69 * Adaptive quantization. Allows intra-frame quantizers to vary to improve visual 70 * quality. 71 */ SetAdaptiveQuantization(const H265AdaptiveQuantization & value)72 inline void SetAdaptiveQuantization(const H265AdaptiveQuantization& value) { m_adaptiveQuantizationHasBeenSet = true; m_adaptiveQuantization = value; } 73 74 /** 75 * Adaptive quantization. Allows intra-frame quantizers to vary to improve visual 76 * quality. 77 */ SetAdaptiveQuantization(H265AdaptiveQuantization && value)78 inline void SetAdaptiveQuantization(H265AdaptiveQuantization&& value) { m_adaptiveQuantizationHasBeenSet = true; m_adaptiveQuantization = std::move(value); } 79 80 /** 81 * Adaptive quantization. Allows intra-frame quantizers to vary to improve visual 82 * quality. 83 */ WithAdaptiveQuantization(const H265AdaptiveQuantization & value)84 inline H265Settings& WithAdaptiveQuantization(const H265AdaptiveQuantization& value) { SetAdaptiveQuantization(value); return *this;} 85 86 /** 87 * Adaptive quantization. Allows intra-frame quantizers to vary to improve visual 88 * quality. 89 */ WithAdaptiveQuantization(H265AdaptiveQuantization && value)90 inline H265Settings& WithAdaptiveQuantization(H265AdaptiveQuantization&& value) { SetAdaptiveQuantization(std::move(value)); return *this;} 91 92 93 /** 94 * Indicates that AFD values will be written into the output stream. If 95 * afdSignaling is "auto", the system will try to preserve the input AFD value (in 96 * cases where multiple AFD values are valid). If set to "fixed", the AFD value 97 * will be the value configured in the fixedAfd parameter. 98 */ GetAfdSignaling()99 inline const AfdSignaling& GetAfdSignaling() const{ return m_afdSignaling; } 100 101 /** 102 * Indicates that AFD values will be written into the output stream. If 103 * afdSignaling is "auto", the system will try to preserve the input AFD value (in 104 * cases where multiple AFD values are valid). If set to "fixed", the AFD value 105 * will be the value configured in the fixedAfd parameter. 106 */ AfdSignalingHasBeenSet()107 inline bool AfdSignalingHasBeenSet() const { return m_afdSignalingHasBeenSet; } 108 109 /** 110 * Indicates that AFD values will be written into the output stream. If 111 * afdSignaling is "auto", the system will try to preserve the input AFD value (in 112 * cases where multiple AFD values are valid). If set to "fixed", the AFD value 113 * will be the value configured in the fixedAfd parameter. 114 */ SetAfdSignaling(const AfdSignaling & value)115 inline void SetAfdSignaling(const AfdSignaling& value) { m_afdSignalingHasBeenSet = true; m_afdSignaling = value; } 116 117 /** 118 * Indicates that AFD values will be written into the output stream. If 119 * afdSignaling is "auto", the system will try to preserve the input AFD value (in 120 * cases where multiple AFD values are valid). If set to "fixed", the AFD value 121 * will be the value configured in the fixedAfd parameter. 122 */ SetAfdSignaling(AfdSignaling && value)123 inline void SetAfdSignaling(AfdSignaling&& value) { m_afdSignalingHasBeenSet = true; m_afdSignaling = std::move(value); } 124 125 /** 126 * Indicates that AFD values will be written into the output stream. If 127 * afdSignaling is "auto", the system will try to preserve the input AFD value (in 128 * cases where multiple AFD values are valid). If set to "fixed", the AFD value 129 * will be the value configured in the fixedAfd parameter. 130 */ WithAfdSignaling(const AfdSignaling & value)131 inline H265Settings& WithAfdSignaling(const AfdSignaling& value) { SetAfdSignaling(value); return *this;} 132 133 /** 134 * Indicates that AFD values will be written into the output stream. If 135 * afdSignaling is "auto", the system will try to preserve the input AFD value (in 136 * cases where multiple AFD values are valid). If set to "fixed", the AFD value 137 * will be the value configured in the fixedAfd parameter. 138 */ WithAfdSignaling(AfdSignaling && value)139 inline H265Settings& WithAfdSignaling(AfdSignaling&& value) { SetAfdSignaling(std::move(value)); return *this;} 140 141 142 /** 143 * Whether or not EML should insert an Alternative Transfer Function SEI message to 144 * support backwards compatibility with non-HDR decoders and displays. 145 */ GetAlternativeTransferFunction()146 inline const H265AlternativeTransferFunction& GetAlternativeTransferFunction() const{ return m_alternativeTransferFunction; } 147 148 /** 149 * Whether or not EML should insert an Alternative Transfer Function SEI message to 150 * support backwards compatibility with non-HDR decoders and displays. 151 */ AlternativeTransferFunctionHasBeenSet()152 inline bool AlternativeTransferFunctionHasBeenSet() const { return m_alternativeTransferFunctionHasBeenSet; } 153 154 /** 155 * Whether or not EML should insert an Alternative Transfer Function SEI message to 156 * support backwards compatibility with non-HDR decoders and displays. 157 */ SetAlternativeTransferFunction(const H265AlternativeTransferFunction & value)158 inline void SetAlternativeTransferFunction(const H265AlternativeTransferFunction& value) { m_alternativeTransferFunctionHasBeenSet = true; m_alternativeTransferFunction = value; } 159 160 /** 161 * Whether or not EML should insert an Alternative Transfer Function SEI message to 162 * support backwards compatibility with non-HDR decoders and displays. 163 */ SetAlternativeTransferFunction(H265AlternativeTransferFunction && value)164 inline void SetAlternativeTransferFunction(H265AlternativeTransferFunction&& value) { m_alternativeTransferFunctionHasBeenSet = true; m_alternativeTransferFunction = std::move(value); } 165 166 /** 167 * Whether or not EML should insert an Alternative Transfer Function SEI message to 168 * support backwards compatibility with non-HDR decoders and displays. 169 */ WithAlternativeTransferFunction(const H265AlternativeTransferFunction & value)170 inline H265Settings& WithAlternativeTransferFunction(const H265AlternativeTransferFunction& value) { SetAlternativeTransferFunction(value); return *this;} 171 172 /** 173 * Whether or not EML should insert an Alternative Transfer Function SEI message to 174 * support backwards compatibility with non-HDR decoders and displays. 175 */ WithAlternativeTransferFunction(H265AlternativeTransferFunction && value)176 inline H265Settings& WithAlternativeTransferFunction(H265AlternativeTransferFunction&& value) { SetAlternativeTransferFunction(std::move(value)); return *this;} 177 178 179 /** 180 * Average bitrate in bits/second. Required when the rate control mode is VBR or 181 * CBR. Not used for QVBR. In an MS Smooth output group, each output must have a 182 * unique value when its bitrate is rounded down to the nearest multiple of 1000. 183 */ GetBitrate()184 inline int GetBitrate() const{ return m_bitrate; } 185 186 /** 187 * Average bitrate in bits/second. Required when the rate control mode is VBR or 188 * CBR. Not used for QVBR. In an MS Smooth output group, each output must have a 189 * unique value when its bitrate is rounded down to the nearest multiple of 1000. 190 */ BitrateHasBeenSet()191 inline bool BitrateHasBeenSet() const { return m_bitrateHasBeenSet; } 192 193 /** 194 * Average bitrate in bits/second. Required when the rate control mode is VBR or 195 * CBR. Not used for QVBR. In an MS Smooth output group, each output must have a 196 * unique value when its bitrate is rounded down to the nearest multiple of 1000. 197 */ SetBitrate(int value)198 inline void SetBitrate(int value) { m_bitrateHasBeenSet = true; m_bitrate = value; } 199 200 /** 201 * Average bitrate in bits/second. Required when the rate control mode is VBR or 202 * CBR. Not used for QVBR. In an MS Smooth output group, each output must have a 203 * unique value when its bitrate is rounded down to the nearest multiple of 1000. 204 */ WithBitrate(int value)205 inline H265Settings& WithBitrate(int value) { SetBitrate(value); return *this;} 206 207 208 /** 209 * Size of buffer (HRD buffer model) in bits. 210 */ GetBufSize()211 inline int GetBufSize() const{ return m_bufSize; } 212 213 /** 214 * Size of buffer (HRD buffer model) in bits. 215 */ BufSizeHasBeenSet()216 inline bool BufSizeHasBeenSet() const { return m_bufSizeHasBeenSet; } 217 218 /** 219 * Size of buffer (HRD buffer model) in bits. 220 */ SetBufSize(int value)221 inline void SetBufSize(int value) { m_bufSizeHasBeenSet = true; m_bufSize = value; } 222 223 /** 224 * Size of buffer (HRD buffer model) in bits. 225 */ WithBufSize(int value)226 inline H265Settings& WithBufSize(int value) { SetBufSize(value); return *this;} 227 228 229 /** 230 * Includes colorspace metadata in the output. 231 */ GetColorMetadata()232 inline const H265ColorMetadata& GetColorMetadata() const{ return m_colorMetadata; } 233 234 /** 235 * Includes colorspace metadata in the output. 236 */ ColorMetadataHasBeenSet()237 inline bool ColorMetadataHasBeenSet() const { return m_colorMetadataHasBeenSet; } 238 239 /** 240 * Includes colorspace metadata in the output. 241 */ SetColorMetadata(const H265ColorMetadata & value)242 inline void SetColorMetadata(const H265ColorMetadata& value) { m_colorMetadataHasBeenSet = true; m_colorMetadata = value; } 243 244 /** 245 * Includes colorspace metadata in the output. 246 */ SetColorMetadata(H265ColorMetadata && value)247 inline void SetColorMetadata(H265ColorMetadata&& value) { m_colorMetadataHasBeenSet = true; m_colorMetadata = std::move(value); } 248 249 /** 250 * Includes colorspace metadata in the output. 251 */ WithColorMetadata(const H265ColorMetadata & value)252 inline H265Settings& WithColorMetadata(const H265ColorMetadata& value) { SetColorMetadata(value); return *this;} 253 254 /** 255 * Includes colorspace metadata in the output. 256 */ WithColorMetadata(H265ColorMetadata && value)257 inline H265Settings& WithColorMetadata(H265ColorMetadata&& value) { SetColorMetadata(std::move(value)); return *this;} 258 259 260 /** 261 * Color Space settings 262 */ GetColorSpaceSettings()263 inline const H265ColorSpaceSettings& GetColorSpaceSettings() const{ return m_colorSpaceSettings; } 264 265 /** 266 * Color Space settings 267 */ ColorSpaceSettingsHasBeenSet()268 inline bool ColorSpaceSettingsHasBeenSet() const { return m_colorSpaceSettingsHasBeenSet; } 269 270 /** 271 * Color Space settings 272 */ SetColorSpaceSettings(const H265ColorSpaceSettings & value)273 inline void SetColorSpaceSettings(const H265ColorSpaceSettings& value) { m_colorSpaceSettingsHasBeenSet = true; m_colorSpaceSettings = value; } 274 275 /** 276 * Color Space settings 277 */ SetColorSpaceSettings(H265ColorSpaceSettings && value)278 inline void SetColorSpaceSettings(H265ColorSpaceSettings&& value) { m_colorSpaceSettingsHasBeenSet = true; m_colorSpaceSettings = std::move(value); } 279 280 /** 281 * Color Space settings 282 */ WithColorSpaceSettings(const H265ColorSpaceSettings & value)283 inline H265Settings& WithColorSpaceSettings(const H265ColorSpaceSettings& value) { SetColorSpaceSettings(value); return *this;} 284 285 /** 286 * Color Space settings 287 */ WithColorSpaceSettings(H265ColorSpaceSettings && value)288 inline H265Settings& WithColorSpaceSettings(H265ColorSpaceSettings&& value) { SetColorSpaceSettings(std::move(value)); return *this;} 289 290 291 /** 292 * Optional filters that you can apply to an encode. 293 */ GetFilterSettings()294 inline const H265FilterSettings& GetFilterSettings() const{ return m_filterSettings; } 295 296 /** 297 * Optional filters that you can apply to an encode. 298 */ FilterSettingsHasBeenSet()299 inline bool FilterSettingsHasBeenSet() const { return m_filterSettingsHasBeenSet; } 300 301 /** 302 * Optional filters that you can apply to an encode. 303 */ SetFilterSettings(const H265FilterSettings & value)304 inline void SetFilterSettings(const H265FilterSettings& value) { m_filterSettingsHasBeenSet = true; m_filterSettings = value; } 305 306 /** 307 * Optional filters that you can apply to an encode. 308 */ SetFilterSettings(H265FilterSettings && value)309 inline void SetFilterSettings(H265FilterSettings&& value) { m_filterSettingsHasBeenSet = true; m_filterSettings = std::move(value); } 310 311 /** 312 * Optional filters that you can apply to an encode. 313 */ WithFilterSettings(const H265FilterSettings & value)314 inline H265Settings& WithFilterSettings(const H265FilterSettings& value) { SetFilterSettings(value); return *this;} 315 316 /** 317 * Optional filters that you can apply to an encode. 318 */ WithFilterSettings(H265FilterSettings && value)319 inline H265Settings& WithFilterSettings(H265FilterSettings&& value) { SetFilterSettings(std::move(value)); return *this;} 320 321 322 /** 323 * Four bit AFD value to write on all frames of video in the output stream. Only 324 * valid when afdSignaling is set to 'Fixed'. 325 */ GetFixedAfd()326 inline const FixedAfd& GetFixedAfd() const{ return m_fixedAfd; } 327 328 /** 329 * Four bit AFD value to write on all frames of video in the output stream. Only 330 * valid when afdSignaling is set to 'Fixed'. 331 */ FixedAfdHasBeenSet()332 inline bool FixedAfdHasBeenSet() const { return m_fixedAfdHasBeenSet; } 333 334 /** 335 * Four bit AFD value to write on all frames of video in the output stream. Only 336 * valid when afdSignaling is set to 'Fixed'. 337 */ SetFixedAfd(const FixedAfd & value)338 inline void SetFixedAfd(const FixedAfd& value) { m_fixedAfdHasBeenSet = true; m_fixedAfd = value; } 339 340 /** 341 * Four bit AFD value to write on all frames of video in the output stream. Only 342 * valid when afdSignaling is set to 'Fixed'. 343 */ SetFixedAfd(FixedAfd && value)344 inline void SetFixedAfd(FixedAfd&& value) { m_fixedAfdHasBeenSet = true; m_fixedAfd = std::move(value); } 345 346 /** 347 * Four bit AFD value to write on all frames of video in the output stream. Only 348 * valid when afdSignaling is set to 'Fixed'. 349 */ WithFixedAfd(const FixedAfd & value)350 inline H265Settings& WithFixedAfd(const FixedAfd& value) { SetFixedAfd(value); return *this;} 351 352 /** 353 * Four bit AFD value to write on all frames of video in the output stream. Only 354 * valid when afdSignaling is set to 'Fixed'. 355 */ WithFixedAfd(FixedAfd && value)356 inline H265Settings& WithFixedAfd(FixedAfd&& value) { SetFixedAfd(std::move(value)); return *this;} 357 358 359 /** 360 * If set to enabled, adjust quantization within each frame to reduce flicker or 361 * 'pop' on I-frames. 362 */ GetFlickerAq()363 inline const H265FlickerAq& GetFlickerAq() const{ return m_flickerAq; } 364 365 /** 366 * If set to enabled, adjust quantization within each frame to reduce flicker or 367 * 'pop' on I-frames. 368 */ FlickerAqHasBeenSet()369 inline bool FlickerAqHasBeenSet() const { return m_flickerAqHasBeenSet; } 370 371 /** 372 * If set to enabled, adjust quantization within each frame to reduce flicker or 373 * 'pop' on I-frames. 374 */ SetFlickerAq(const H265FlickerAq & value)375 inline void SetFlickerAq(const H265FlickerAq& value) { m_flickerAqHasBeenSet = true; m_flickerAq = value; } 376 377 /** 378 * If set to enabled, adjust quantization within each frame to reduce flicker or 379 * 'pop' on I-frames. 380 */ SetFlickerAq(H265FlickerAq && value)381 inline void SetFlickerAq(H265FlickerAq&& value) { m_flickerAqHasBeenSet = true; m_flickerAq = std::move(value); } 382 383 /** 384 * If set to enabled, adjust quantization within each frame to reduce flicker or 385 * 'pop' on I-frames. 386 */ WithFlickerAq(const H265FlickerAq & value)387 inline H265Settings& WithFlickerAq(const H265FlickerAq& value) { SetFlickerAq(value); return *this;} 388 389 /** 390 * If set to enabled, adjust quantization within each frame to reduce flicker or 391 * 'pop' on I-frames. 392 */ WithFlickerAq(H265FlickerAq && value)393 inline H265Settings& WithFlickerAq(H265FlickerAq&& value) { SetFlickerAq(std::move(value)); return *this;} 394 395 396 /** 397 * Framerate denominator. 398 */ GetFramerateDenominator()399 inline int GetFramerateDenominator() const{ return m_framerateDenominator; } 400 401 /** 402 * Framerate denominator. 403 */ FramerateDenominatorHasBeenSet()404 inline bool FramerateDenominatorHasBeenSet() const { return m_framerateDenominatorHasBeenSet; } 405 406 /** 407 * Framerate denominator. 408 */ SetFramerateDenominator(int value)409 inline void SetFramerateDenominator(int value) { m_framerateDenominatorHasBeenSet = true; m_framerateDenominator = value; } 410 411 /** 412 * Framerate denominator. 413 */ WithFramerateDenominator(int value)414 inline H265Settings& WithFramerateDenominator(int value) { SetFramerateDenominator(value); return *this;} 415 416 417 /** 418 * Framerate numerator - framerate is a fraction, e.g. 24000 / 1001 = 23.976 fps. 419 */ GetFramerateNumerator()420 inline int GetFramerateNumerator() const{ return m_framerateNumerator; } 421 422 /** 423 * Framerate numerator - framerate is a fraction, e.g. 24000 / 1001 = 23.976 fps. 424 */ FramerateNumeratorHasBeenSet()425 inline bool FramerateNumeratorHasBeenSet() const { return m_framerateNumeratorHasBeenSet; } 426 427 /** 428 * Framerate numerator - framerate is a fraction, e.g. 24000 / 1001 = 23.976 fps. 429 */ SetFramerateNumerator(int value)430 inline void SetFramerateNumerator(int value) { m_framerateNumeratorHasBeenSet = true; m_framerateNumerator = value; } 431 432 /** 433 * Framerate numerator - framerate is a fraction, e.g. 24000 / 1001 = 23.976 fps. 434 */ WithFramerateNumerator(int value)435 inline H265Settings& WithFramerateNumerator(int value) { SetFramerateNumerator(value); return *this;} 436 437 438 /** 439 * Frequency of closed GOPs. In streaming applications, it is recommended that this 440 * be set to 1 so a decoder joining mid-stream will receive an IDR frame as quickly 441 * as possible. Setting this value to 0 will break output segmenting. 442 */ GetGopClosedCadence()443 inline int GetGopClosedCadence() const{ return m_gopClosedCadence; } 444 445 /** 446 * Frequency of closed GOPs. In streaming applications, it is recommended that this 447 * be set to 1 so a decoder joining mid-stream will receive an IDR frame as quickly 448 * as possible. Setting this value to 0 will break output segmenting. 449 */ GopClosedCadenceHasBeenSet()450 inline bool GopClosedCadenceHasBeenSet() const { return m_gopClosedCadenceHasBeenSet; } 451 452 /** 453 * Frequency of closed GOPs. In streaming applications, it is recommended that this 454 * be set to 1 so a decoder joining mid-stream will receive an IDR frame as quickly 455 * as possible. Setting this value to 0 will break output segmenting. 456 */ SetGopClosedCadence(int value)457 inline void SetGopClosedCadence(int value) { m_gopClosedCadenceHasBeenSet = true; m_gopClosedCadence = value; } 458 459 /** 460 * Frequency of closed GOPs. In streaming applications, it is recommended that this 461 * be set to 1 so a decoder joining mid-stream will receive an IDR frame as quickly 462 * as possible. Setting this value to 0 will break output segmenting. 463 */ WithGopClosedCadence(int value)464 inline H265Settings& WithGopClosedCadence(int value) { SetGopClosedCadence(value); return *this;} 465 466 467 /** 468 * GOP size (keyframe interval) in units of either frames or seconds per 469 * gopSizeUnits. 470 If gopSizeUnits is frames, gopSize must be an integer and must be 471 * greater than or equal to 1. 472 If gopSizeUnits is seconds, gopSize must be greater 473 * than 0, but need not be an integer. 474 */ GetGopSize()475 inline double GetGopSize() const{ return m_gopSize; } 476 477 /** 478 * GOP size (keyframe interval) in units of either frames or seconds per 479 * gopSizeUnits. 480 If gopSizeUnits is frames, gopSize must be an integer and must be 481 * greater than or equal to 1. 482 If gopSizeUnits is seconds, gopSize must be greater 483 * than 0, but need not be an integer. 484 */ GopSizeHasBeenSet()485 inline bool GopSizeHasBeenSet() const { return m_gopSizeHasBeenSet; } 486 487 /** 488 * GOP size (keyframe interval) in units of either frames or seconds per 489 * gopSizeUnits. 490 If gopSizeUnits is frames, gopSize must be an integer and must be 491 * greater than or equal to 1. 492 If gopSizeUnits is seconds, gopSize must be greater 493 * than 0, but need not be an integer. 494 */ SetGopSize(double value)495 inline void SetGopSize(double value) { m_gopSizeHasBeenSet = true; m_gopSize = value; } 496 497 /** 498 * GOP size (keyframe interval) in units of either frames or seconds per 499 * gopSizeUnits. 500 If gopSizeUnits is frames, gopSize must be an integer and must be 501 * greater than or equal to 1. 502 If gopSizeUnits is seconds, gopSize must be greater 503 * than 0, but need not be an integer. 504 */ WithGopSize(double value)505 inline H265Settings& WithGopSize(double value) { SetGopSize(value); return *this;} 506 507 508 /** 509 * Indicates if the gopSize is specified in frames or seconds. If seconds the 510 * system will convert the gopSize into a frame count at run time. 511 */ GetGopSizeUnits()512 inline const H265GopSizeUnits& GetGopSizeUnits() const{ return m_gopSizeUnits; } 513 514 /** 515 * Indicates if the gopSize is specified in frames or seconds. If seconds the 516 * system will convert the gopSize into a frame count at run time. 517 */ GopSizeUnitsHasBeenSet()518 inline bool GopSizeUnitsHasBeenSet() const { return m_gopSizeUnitsHasBeenSet; } 519 520 /** 521 * Indicates if the gopSize is specified in frames or seconds. If seconds the 522 * system will convert the gopSize into a frame count at run time. 523 */ SetGopSizeUnits(const H265GopSizeUnits & value)524 inline void SetGopSizeUnits(const H265GopSizeUnits& value) { m_gopSizeUnitsHasBeenSet = true; m_gopSizeUnits = value; } 525 526 /** 527 * Indicates if the gopSize is specified in frames or seconds. If seconds the 528 * system will convert the gopSize into a frame count at run time. 529 */ SetGopSizeUnits(H265GopSizeUnits && value)530 inline void SetGopSizeUnits(H265GopSizeUnits&& value) { m_gopSizeUnitsHasBeenSet = true; m_gopSizeUnits = std::move(value); } 531 532 /** 533 * Indicates if the gopSize is specified in frames or seconds. If seconds the 534 * system will convert the gopSize into a frame count at run time. 535 */ WithGopSizeUnits(const H265GopSizeUnits & value)536 inline H265Settings& WithGopSizeUnits(const H265GopSizeUnits& value) { SetGopSizeUnits(value); return *this;} 537 538 /** 539 * Indicates if the gopSize is specified in frames or seconds. If seconds the 540 * system will convert the gopSize into a frame count at run time. 541 */ WithGopSizeUnits(H265GopSizeUnits && value)542 inline H265Settings& WithGopSizeUnits(H265GopSizeUnits&& value) { SetGopSizeUnits(std::move(value)); return *this;} 543 544 545 /** 546 * H.265 Level. 547 */ GetLevel()548 inline const H265Level& GetLevel() const{ return m_level; } 549 550 /** 551 * H.265 Level. 552 */ LevelHasBeenSet()553 inline bool LevelHasBeenSet() const { return m_levelHasBeenSet; } 554 555 /** 556 * H.265 Level. 557 */ SetLevel(const H265Level & value)558 inline void SetLevel(const H265Level& value) { m_levelHasBeenSet = true; m_level = value; } 559 560 /** 561 * H.265 Level. 562 */ SetLevel(H265Level && value)563 inline void SetLevel(H265Level&& value) { m_levelHasBeenSet = true; m_level = std::move(value); } 564 565 /** 566 * H.265 Level. 567 */ WithLevel(const H265Level & value)568 inline H265Settings& WithLevel(const H265Level& value) { SetLevel(value); return *this;} 569 570 /** 571 * H.265 Level. 572 */ WithLevel(H265Level && value)573 inline H265Settings& WithLevel(H265Level&& value) { SetLevel(std::move(value)); return *this;} 574 575 576 /** 577 * Amount of lookahead. A value of low can decrease latency and memory usage, while 578 * high can produce better quality for certain content. 579 */ GetLookAheadRateControl()580 inline const H265LookAheadRateControl& GetLookAheadRateControl() const{ return m_lookAheadRateControl; } 581 582 /** 583 * Amount of lookahead. A value of low can decrease latency and memory usage, while 584 * high can produce better quality for certain content. 585 */ LookAheadRateControlHasBeenSet()586 inline bool LookAheadRateControlHasBeenSet() const { return m_lookAheadRateControlHasBeenSet; } 587 588 /** 589 * Amount of lookahead. A value of low can decrease latency and memory usage, while 590 * high can produce better quality for certain content. 591 */ SetLookAheadRateControl(const H265LookAheadRateControl & value)592 inline void SetLookAheadRateControl(const H265LookAheadRateControl& value) { m_lookAheadRateControlHasBeenSet = true; m_lookAheadRateControl = value; } 593 594 /** 595 * Amount of lookahead. A value of low can decrease latency and memory usage, while 596 * high can produce better quality for certain content. 597 */ SetLookAheadRateControl(H265LookAheadRateControl && value)598 inline void SetLookAheadRateControl(H265LookAheadRateControl&& value) { m_lookAheadRateControlHasBeenSet = true; m_lookAheadRateControl = std::move(value); } 599 600 /** 601 * Amount of lookahead. A value of low can decrease latency and memory usage, while 602 * high can produce better quality for certain content. 603 */ WithLookAheadRateControl(const H265LookAheadRateControl & value)604 inline H265Settings& WithLookAheadRateControl(const H265LookAheadRateControl& value) { SetLookAheadRateControl(value); return *this;} 605 606 /** 607 * Amount of lookahead. A value of low can decrease latency and memory usage, while 608 * high can produce better quality for certain content. 609 */ WithLookAheadRateControl(H265LookAheadRateControl && value)610 inline H265Settings& WithLookAheadRateControl(H265LookAheadRateControl&& value) { SetLookAheadRateControl(std::move(value)); return *this;} 611 612 613 /** 614 * For QVBR: See the tooltip for Quality level 615 */ GetMaxBitrate()616 inline int GetMaxBitrate() const{ return m_maxBitrate; } 617 618 /** 619 * For QVBR: See the tooltip for Quality level 620 */ MaxBitrateHasBeenSet()621 inline bool MaxBitrateHasBeenSet() const { return m_maxBitrateHasBeenSet; } 622 623 /** 624 * For QVBR: See the tooltip for Quality level 625 */ SetMaxBitrate(int value)626 inline void SetMaxBitrate(int value) { m_maxBitrateHasBeenSet = true; m_maxBitrate = value; } 627 628 /** 629 * For QVBR: See the tooltip for Quality level 630 */ WithMaxBitrate(int value)631 inline H265Settings& WithMaxBitrate(int value) { SetMaxBitrate(value); return *this;} 632 633 634 /** 635 * Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if 636 * multiplex rate control is used. Enforces separation between repeated (cadence) 637 * I-frames and I-frames inserted by Scene Change Detection. If a scene change 638 * I-frame is within I-interval frames of a cadence I-frame, the GOP is shrunk 639 * and/or stretched to the scene change I-frame. GOP stretch requires enabling 640 * lookahead as well as setting I-interval. The normal cadence resumes for the next 641 * GOP. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1 642 */ GetMinIInterval()643 inline int GetMinIInterval() const{ return m_minIInterval; } 644 645 /** 646 * Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if 647 * multiplex rate control is used. Enforces separation between repeated (cadence) 648 * I-frames and I-frames inserted by Scene Change Detection. If a scene change 649 * I-frame is within I-interval frames of a cadence I-frame, the GOP is shrunk 650 * and/or stretched to the scene change I-frame. GOP stretch requires enabling 651 * lookahead as well as setting I-interval. The normal cadence resumes for the next 652 * GOP. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1 653 */ MinIIntervalHasBeenSet()654 inline bool MinIIntervalHasBeenSet() const { return m_minIIntervalHasBeenSet; } 655 656 /** 657 * Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if 658 * multiplex rate control is used. Enforces separation between repeated (cadence) 659 * I-frames and I-frames inserted by Scene Change Detection. If a scene change 660 * I-frame is within I-interval frames of a cadence I-frame, the GOP is shrunk 661 * and/or stretched to the scene change I-frame. GOP stretch requires enabling 662 * lookahead as well as setting I-interval. The normal cadence resumes for the next 663 * GOP. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1 664 */ SetMinIInterval(int value)665 inline void SetMinIInterval(int value) { m_minIIntervalHasBeenSet = true; m_minIInterval = value; } 666 667 /** 668 * Only meaningful if sceneChangeDetect is set to enabled. Defaults to 5 if 669 * multiplex rate control is used. Enforces separation between repeated (cadence) 670 * I-frames and I-frames inserted by Scene Change Detection. If a scene change 671 * I-frame is within I-interval frames of a cadence I-frame, the GOP is shrunk 672 * and/or stretched to the scene change I-frame. GOP stretch requires enabling 673 * lookahead as well as setting I-interval. The normal cadence resumes for the next 674 * GOP. Note: Maximum GOP stretch = GOP size + Min-I-interval - 1 675 */ WithMinIInterval(int value)676 inline H265Settings& WithMinIInterval(int value) { SetMinIInterval(value); return *this;} 677 678 679 /** 680 * Pixel Aspect Ratio denominator. 681 */ GetParDenominator()682 inline int GetParDenominator() const{ return m_parDenominator; } 683 684 /** 685 * Pixel Aspect Ratio denominator. 686 */ ParDenominatorHasBeenSet()687 inline bool ParDenominatorHasBeenSet() const { return m_parDenominatorHasBeenSet; } 688 689 /** 690 * Pixel Aspect Ratio denominator. 691 */ SetParDenominator(int value)692 inline void SetParDenominator(int value) { m_parDenominatorHasBeenSet = true; m_parDenominator = value; } 693 694 /** 695 * Pixel Aspect Ratio denominator. 696 */ WithParDenominator(int value)697 inline H265Settings& WithParDenominator(int value) { SetParDenominator(value); return *this;} 698 699 700 /** 701 * Pixel Aspect Ratio numerator. 702 */ GetParNumerator()703 inline int GetParNumerator() const{ return m_parNumerator; } 704 705 /** 706 * Pixel Aspect Ratio numerator. 707 */ ParNumeratorHasBeenSet()708 inline bool ParNumeratorHasBeenSet() const { return m_parNumeratorHasBeenSet; } 709 710 /** 711 * Pixel Aspect Ratio numerator. 712 */ SetParNumerator(int value)713 inline void SetParNumerator(int value) { m_parNumeratorHasBeenSet = true; m_parNumerator = value; } 714 715 /** 716 * Pixel Aspect Ratio numerator. 717 */ WithParNumerator(int value)718 inline H265Settings& WithParNumerator(int value) { SetParNumerator(value); return *this;} 719 720 721 /** 722 * H.265 Profile. 723 */ GetProfile()724 inline const H265Profile& GetProfile() const{ return m_profile; } 725 726 /** 727 * H.265 Profile. 728 */ ProfileHasBeenSet()729 inline bool ProfileHasBeenSet() const { return m_profileHasBeenSet; } 730 731 /** 732 * H.265 Profile. 733 */ SetProfile(const H265Profile & value)734 inline void SetProfile(const H265Profile& value) { m_profileHasBeenSet = true; m_profile = value; } 735 736 /** 737 * H.265 Profile. 738 */ SetProfile(H265Profile && value)739 inline void SetProfile(H265Profile&& value) { m_profileHasBeenSet = true; m_profile = std::move(value); } 740 741 /** 742 * H.265 Profile. 743 */ WithProfile(const H265Profile & value)744 inline H265Settings& WithProfile(const H265Profile& value) { SetProfile(value); return *this;} 745 746 /** 747 * H.265 Profile. 748 */ WithProfile(H265Profile && value)749 inline H265Settings& WithProfile(H265Profile&& value) { SetProfile(std::move(value)); return *this;} 750 751 752 /** 753 * Controls the target quality for the video encode. Applies only when the rate 754 * control mode is QVBR. Set values for the QVBR quality level field and Max 755 * bitrate field that suit your most important viewing devices. Recommended values 756 * are: 757 - Primary screen: Quality level: 8 to 10. Max bitrate: 4M 758 - PC or tablet: 759 * Quality level: 7. Max bitrate: 1.5M to 3M 760 - Smartphone: Quality level: 6. Max 761 * bitrate: 1M to 1.5M 762 */ GetQvbrQualityLevel()763 inline int GetQvbrQualityLevel() const{ return m_qvbrQualityLevel; } 764 765 /** 766 * Controls the target quality for the video encode. Applies only when the rate 767 * control mode is QVBR. Set values for the QVBR quality level field and Max 768 * bitrate field that suit your most important viewing devices. Recommended values 769 * are: 770 - Primary screen: Quality level: 8 to 10. Max bitrate: 4M 771 - PC or tablet: 772 * Quality level: 7. Max bitrate: 1.5M to 3M 773 - Smartphone: Quality level: 6. Max 774 * bitrate: 1M to 1.5M 775 */ QvbrQualityLevelHasBeenSet()776 inline bool QvbrQualityLevelHasBeenSet() const { return m_qvbrQualityLevelHasBeenSet; } 777 778 /** 779 * Controls the target quality for the video encode. Applies only when the rate 780 * control mode is QVBR. Set values for the QVBR quality level field and Max 781 * bitrate field that suit your most important viewing devices. Recommended values 782 * are: 783 - Primary screen: Quality level: 8 to 10. Max bitrate: 4M 784 - PC or tablet: 785 * Quality level: 7. Max bitrate: 1.5M to 3M 786 - Smartphone: Quality level: 6. Max 787 * bitrate: 1M to 1.5M 788 */ SetQvbrQualityLevel(int value)789 inline void SetQvbrQualityLevel(int value) { m_qvbrQualityLevelHasBeenSet = true; m_qvbrQualityLevel = value; } 790 791 /** 792 * Controls the target quality for the video encode. Applies only when the rate 793 * control mode is QVBR. Set values for the QVBR quality level field and Max 794 * bitrate field that suit your most important viewing devices. Recommended values 795 * are: 796 - Primary screen: Quality level: 8 to 10. Max bitrate: 4M 797 - PC or tablet: 798 * Quality level: 7. Max bitrate: 1.5M to 3M 799 - Smartphone: Quality level: 6. Max 800 * bitrate: 1M to 1.5M 801 */ WithQvbrQualityLevel(int value)802 inline H265Settings& WithQvbrQualityLevel(int value) { SetQvbrQualityLevel(value); return *this;} 803 804 805 /** 806 * Rate control mode. 807 808 QVBR: Quality will match the specified quality level except 809 * when it is constrained by the 810 maximum bitrate. Recommended if you or your 811 * viewers pay for bandwidth. 812 813 CBR: Quality varies, depending on the video 814 * complexity. Recommended only if you distribute 815 your assets to devices that 816 * cannot handle variable bitrates. 817 818 Multiplex: This rate control mode is only 819 * supported (and is required) when the video is being 820 delivered to a MediaLive 821 * Multiplex in which case the rate control configuration is controlled 822 by the 823 * properties within the Multiplex Program. 824 */ GetRateControlMode()825 inline const H265RateControlMode& GetRateControlMode() const{ return m_rateControlMode; } 826 827 /** 828 * Rate control mode. 829 830 QVBR: Quality will match the specified quality level except 831 * when it is constrained by the 832 maximum bitrate. Recommended if you or your 833 * viewers pay for bandwidth. 834 835 CBR: Quality varies, depending on the video 836 * complexity. Recommended only if you distribute 837 your assets to devices that 838 * cannot handle variable bitrates. 839 840 Multiplex: This rate control mode is only 841 * supported (and is required) when the video is being 842 delivered to a MediaLive 843 * Multiplex in which case the rate control configuration is controlled 844 by the 845 * properties within the Multiplex Program. 846 */ RateControlModeHasBeenSet()847 inline bool RateControlModeHasBeenSet() const { return m_rateControlModeHasBeenSet; } 848 849 /** 850 * Rate control mode. 851 852 QVBR: Quality will match the specified quality level except 853 * when it is constrained by the 854 maximum bitrate. Recommended if you or your 855 * viewers pay for bandwidth. 856 857 CBR: Quality varies, depending on the video 858 * complexity. Recommended only if you distribute 859 your assets to devices that 860 * cannot handle variable bitrates. 861 862 Multiplex: This rate control mode is only 863 * supported (and is required) when the video is being 864 delivered to a MediaLive 865 * Multiplex in which case the rate control configuration is controlled 866 by the 867 * properties within the Multiplex Program. 868 */ SetRateControlMode(const H265RateControlMode & value)869 inline void SetRateControlMode(const H265RateControlMode& value) { m_rateControlModeHasBeenSet = true; m_rateControlMode = value; } 870 871 /** 872 * Rate control mode. 873 874 QVBR: Quality will match the specified quality level except 875 * when it is constrained by the 876 maximum bitrate. Recommended if you or your 877 * viewers pay for bandwidth. 878 879 CBR: Quality varies, depending on the video 880 * complexity. Recommended only if you distribute 881 your assets to devices that 882 * cannot handle variable bitrates. 883 884 Multiplex: This rate control mode is only 885 * supported (and is required) when the video is being 886 delivered to a MediaLive 887 * Multiplex in which case the rate control configuration is controlled 888 by the 889 * properties within the Multiplex Program. 890 */ SetRateControlMode(H265RateControlMode && value)891 inline void SetRateControlMode(H265RateControlMode&& value) { m_rateControlModeHasBeenSet = true; m_rateControlMode = std::move(value); } 892 893 /** 894 * Rate control mode. 895 896 QVBR: Quality will match the specified quality level except 897 * when it is constrained by the 898 maximum bitrate. Recommended if you or your 899 * viewers pay for bandwidth. 900 901 CBR: Quality varies, depending on the video 902 * complexity. Recommended only if you distribute 903 your assets to devices that 904 * cannot handle variable bitrates. 905 906 Multiplex: This rate control mode is only 907 * supported (and is required) when the video is being 908 delivered to a MediaLive 909 * Multiplex in which case the rate control configuration is controlled 910 by the 911 * properties within the Multiplex Program. 912 */ WithRateControlMode(const H265RateControlMode & value)913 inline H265Settings& WithRateControlMode(const H265RateControlMode& value) { SetRateControlMode(value); return *this;} 914 915 /** 916 * Rate control mode. 917 918 QVBR: Quality will match the specified quality level except 919 * when it is constrained by the 920 maximum bitrate. Recommended if you or your 921 * viewers pay for bandwidth. 922 923 CBR: Quality varies, depending on the video 924 * complexity. Recommended only if you distribute 925 your assets to devices that 926 * cannot handle variable bitrates. 927 928 Multiplex: This rate control mode is only 929 * supported (and is required) when the video is being 930 delivered to a MediaLive 931 * Multiplex in which case the rate control configuration is controlled 932 by the 933 * properties within the Multiplex Program. 934 */ WithRateControlMode(H265RateControlMode && value)935 inline H265Settings& WithRateControlMode(H265RateControlMode&& value) { SetRateControlMode(std::move(value)); return *this;} 936 937 938 /** 939 * Sets the scan type of the output to progressive or top-field-first interlaced. 940 */ GetScanType()941 inline const H265ScanType& GetScanType() const{ return m_scanType; } 942 943 /** 944 * Sets the scan type of the output to progressive or top-field-first interlaced. 945 */ ScanTypeHasBeenSet()946 inline bool ScanTypeHasBeenSet() const { return m_scanTypeHasBeenSet; } 947 948 /** 949 * Sets the scan type of the output to progressive or top-field-first interlaced. 950 */ SetScanType(const H265ScanType & value)951 inline void SetScanType(const H265ScanType& value) { m_scanTypeHasBeenSet = true; m_scanType = value; } 952 953 /** 954 * Sets the scan type of the output to progressive or top-field-first interlaced. 955 */ SetScanType(H265ScanType && value)956 inline void SetScanType(H265ScanType&& value) { m_scanTypeHasBeenSet = true; m_scanType = std::move(value); } 957 958 /** 959 * Sets the scan type of the output to progressive or top-field-first interlaced. 960 */ WithScanType(const H265ScanType & value)961 inline H265Settings& WithScanType(const H265ScanType& value) { SetScanType(value); return *this;} 962 963 /** 964 * Sets the scan type of the output to progressive or top-field-first interlaced. 965 */ WithScanType(H265ScanType && value)966 inline H265Settings& WithScanType(H265ScanType&& value) { SetScanType(std::move(value)); return *this;} 967 968 969 /** 970 * Scene change detection. 971 */ GetSceneChangeDetect()972 inline const H265SceneChangeDetect& GetSceneChangeDetect() const{ return m_sceneChangeDetect; } 973 974 /** 975 * Scene change detection. 976 */ SceneChangeDetectHasBeenSet()977 inline bool SceneChangeDetectHasBeenSet() const { return m_sceneChangeDetectHasBeenSet; } 978 979 /** 980 * Scene change detection. 981 */ SetSceneChangeDetect(const H265SceneChangeDetect & value)982 inline void SetSceneChangeDetect(const H265SceneChangeDetect& value) { m_sceneChangeDetectHasBeenSet = true; m_sceneChangeDetect = value; } 983 984 /** 985 * Scene change detection. 986 */ SetSceneChangeDetect(H265SceneChangeDetect && value)987 inline void SetSceneChangeDetect(H265SceneChangeDetect&& value) { m_sceneChangeDetectHasBeenSet = true; m_sceneChangeDetect = std::move(value); } 988 989 /** 990 * Scene change detection. 991 */ WithSceneChangeDetect(const H265SceneChangeDetect & value)992 inline H265Settings& WithSceneChangeDetect(const H265SceneChangeDetect& value) { SetSceneChangeDetect(value); return *this;} 993 994 /** 995 * Scene change detection. 996 */ WithSceneChangeDetect(H265SceneChangeDetect && value)997 inline H265Settings& WithSceneChangeDetect(H265SceneChangeDetect&& value) { SetSceneChangeDetect(std::move(value)); return *this;} 998 999 1000 /** 1001 * Number of slices per picture. Must be less than or equal to the number of 1002 * macroblock rows for progressive pictures, and less than or equal to half the 1003 * number of macroblock rows for interlaced pictures. 1004 This field is optional; when 1005 * no value is specified the encoder will choose the number of slices based on 1006 * encode resolution. 1007 */ GetSlices()1008 inline int GetSlices() const{ return m_slices; } 1009 1010 /** 1011 * Number of slices per picture. Must be less than or equal to the number of 1012 * macroblock rows for progressive pictures, and less than or equal to half the 1013 * number of macroblock rows for interlaced pictures. 1014 This field is optional; when 1015 * no value is specified the encoder will choose the number of slices based on 1016 * encode resolution. 1017 */ SlicesHasBeenSet()1018 inline bool SlicesHasBeenSet() const { return m_slicesHasBeenSet; } 1019 1020 /** 1021 * Number of slices per picture. Must be less than or equal to the number of 1022 * macroblock rows for progressive pictures, and less than or equal to half the 1023 * number of macroblock rows for interlaced pictures. 1024 This field is optional; when 1025 * no value is specified the encoder will choose the number of slices based on 1026 * encode resolution. 1027 */ SetSlices(int value)1028 inline void SetSlices(int value) { m_slicesHasBeenSet = true; m_slices = value; } 1029 1030 /** 1031 * Number of slices per picture. Must be less than or equal to the number of 1032 * macroblock rows for progressive pictures, and less than or equal to half the 1033 * number of macroblock rows for interlaced pictures. 1034 This field is optional; when 1035 * no value is specified the encoder will choose the number of slices based on 1036 * encode resolution. 1037 */ WithSlices(int value)1038 inline H265Settings& WithSlices(int value) { SetSlices(value); return *this;} 1039 1040 1041 /** 1042 * H.265 Tier. 1043 */ GetTier()1044 inline const H265Tier& GetTier() const{ return m_tier; } 1045 1046 /** 1047 * H.265 Tier. 1048 */ TierHasBeenSet()1049 inline bool TierHasBeenSet() const { return m_tierHasBeenSet; } 1050 1051 /** 1052 * H.265 Tier. 1053 */ SetTier(const H265Tier & value)1054 inline void SetTier(const H265Tier& value) { m_tierHasBeenSet = true; m_tier = value; } 1055 1056 /** 1057 * H.265 Tier. 1058 */ SetTier(H265Tier && value)1059 inline void SetTier(H265Tier&& value) { m_tierHasBeenSet = true; m_tier = std::move(value); } 1060 1061 /** 1062 * H.265 Tier. 1063 */ WithTier(const H265Tier & value)1064 inline H265Settings& WithTier(const H265Tier& value) { SetTier(value); return *this;} 1065 1066 /** 1067 * H.265 Tier. 1068 */ WithTier(H265Tier && value)1069 inline H265Settings& WithTier(H265Tier&& value) { SetTier(std::move(value)); return *this;} 1070 1071 1072 /** 1073 * Determines how timecodes should be inserted into the video elementary stream. 1074 - 1075 * 'disabled': Do not include timecodes 1076 - 'picTimingSei': Pass through picture 1077 * timing SEI messages from the source specified in Timecode Config 1078 */ GetTimecodeInsertion()1079 inline const H265TimecodeInsertionBehavior& GetTimecodeInsertion() const{ return m_timecodeInsertion; } 1080 1081 /** 1082 * Determines how timecodes should be inserted into the video elementary stream. 1083 - 1084 * 'disabled': Do not include timecodes 1085 - 'picTimingSei': Pass through picture 1086 * timing SEI messages from the source specified in Timecode Config 1087 */ TimecodeInsertionHasBeenSet()1088 inline bool TimecodeInsertionHasBeenSet() const { return m_timecodeInsertionHasBeenSet; } 1089 1090 /** 1091 * Determines how timecodes should be inserted into the video elementary stream. 1092 - 1093 * 'disabled': Do not include timecodes 1094 - 'picTimingSei': Pass through picture 1095 * timing SEI messages from the source specified in Timecode Config 1096 */ SetTimecodeInsertion(const H265TimecodeInsertionBehavior & value)1097 inline void SetTimecodeInsertion(const H265TimecodeInsertionBehavior& value) { m_timecodeInsertionHasBeenSet = true; m_timecodeInsertion = value; } 1098 1099 /** 1100 * Determines how timecodes should be inserted into the video elementary stream. 1101 - 1102 * 'disabled': Do not include timecodes 1103 - 'picTimingSei': Pass through picture 1104 * timing SEI messages from the source specified in Timecode Config 1105 */ SetTimecodeInsertion(H265TimecodeInsertionBehavior && value)1106 inline void SetTimecodeInsertion(H265TimecodeInsertionBehavior&& value) { m_timecodeInsertionHasBeenSet = true; m_timecodeInsertion = std::move(value); } 1107 1108 /** 1109 * Determines how timecodes should be inserted into the video elementary stream. 1110 - 1111 * 'disabled': Do not include timecodes 1112 - 'picTimingSei': Pass through picture 1113 * timing SEI messages from the source specified in Timecode Config 1114 */ WithTimecodeInsertion(const H265TimecodeInsertionBehavior & value)1115 inline H265Settings& WithTimecodeInsertion(const H265TimecodeInsertionBehavior& value) { SetTimecodeInsertion(value); return *this;} 1116 1117 /** 1118 * Determines how timecodes should be inserted into the video elementary stream. 1119 - 1120 * 'disabled': Do not include timecodes 1121 - 'picTimingSei': Pass through picture 1122 * timing SEI messages from the source specified in Timecode Config 1123 */ WithTimecodeInsertion(H265TimecodeInsertionBehavior && value)1124 inline H265Settings& WithTimecodeInsertion(H265TimecodeInsertionBehavior&& value) { SetTimecodeInsertion(std::move(value)); return *this;} 1125 1126 private: 1127 1128 H265AdaptiveQuantization m_adaptiveQuantization; 1129 bool m_adaptiveQuantizationHasBeenSet; 1130 1131 AfdSignaling m_afdSignaling; 1132 bool m_afdSignalingHasBeenSet; 1133 1134 H265AlternativeTransferFunction m_alternativeTransferFunction; 1135 bool m_alternativeTransferFunctionHasBeenSet; 1136 1137 int m_bitrate; 1138 bool m_bitrateHasBeenSet; 1139 1140 int m_bufSize; 1141 bool m_bufSizeHasBeenSet; 1142 1143 H265ColorMetadata m_colorMetadata; 1144 bool m_colorMetadataHasBeenSet; 1145 1146 H265ColorSpaceSettings m_colorSpaceSettings; 1147 bool m_colorSpaceSettingsHasBeenSet; 1148 1149 H265FilterSettings m_filterSettings; 1150 bool m_filterSettingsHasBeenSet; 1151 1152 FixedAfd m_fixedAfd; 1153 bool m_fixedAfdHasBeenSet; 1154 1155 H265FlickerAq m_flickerAq; 1156 bool m_flickerAqHasBeenSet; 1157 1158 int m_framerateDenominator; 1159 bool m_framerateDenominatorHasBeenSet; 1160 1161 int m_framerateNumerator; 1162 bool m_framerateNumeratorHasBeenSet; 1163 1164 int m_gopClosedCadence; 1165 bool m_gopClosedCadenceHasBeenSet; 1166 1167 double m_gopSize; 1168 bool m_gopSizeHasBeenSet; 1169 1170 H265GopSizeUnits m_gopSizeUnits; 1171 bool m_gopSizeUnitsHasBeenSet; 1172 1173 H265Level m_level; 1174 bool m_levelHasBeenSet; 1175 1176 H265LookAheadRateControl m_lookAheadRateControl; 1177 bool m_lookAheadRateControlHasBeenSet; 1178 1179 int m_maxBitrate; 1180 bool m_maxBitrateHasBeenSet; 1181 1182 int m_minIInterval; 1183 bool m_minIIntervalHasBeenSet; 1184 1185 int m_parDenominator; 1186 bool m_parDenominatorHasBeenSet; 1187 1188 int m_parNumerator; 1189 bool m_parNumeratorHasBeenSet; 1190 1191 H265Profile m_profile; 1192 bool m_profileHasBeenSet; 1193 1194 int m_qvbrQualityLevel; 1195 bool m_qvbrQualityLevelHasBeenSet; 1196 1197 H265RateControlMode m_rateControlMode; 1198 bool m_rateControlModeHasBeenSet; 1199 1200 H265ScanType m_scanType; 1201 bool m_scanTypeHasBeenSet; 1202 1203 H265SceneChangeDetect m_sceneChangeDetect; 1204 bool m_sceneChangeDetectHasBeenSet; 1205 1206 int m_slices; 1207 bool m_slicesHasBeenSet; 1208 1209 H265Tier m_tier; 1210 bool m_tierHasBeenSet; 1211 1212 H265TimecodeInsertionBehavior m_timecodeInsertion; 1213 bool m_timecodeInsertionHasBeenSet; 1214 }; 1215 1216 } // namespace Model 1217 } // namespace MediaLive 1218 } // namespace Aws 1219