/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include #include #include #include namespace Aws { namespace Utils { namespace Json { class JsonValue; class JsonView; } // namespace Json } // namespace Utils namespace MediaConvert { namespace Model { /** * Required when you choose AVC-Intra for your output video codec. For more * information about the AVC-Intra settings, see the relevant specification. For * detailed information about SD and HD in AVC-Intra, see * https://ieeexplore.ieee.org/document/7290936. For information about 4K/2K in * AVC-Intra, see * https://pro-av.panasonic.net/en/avc-ultra/AVC-ULTRAoverview.pdf.

See * Also:

AWS * API Reference

*/ class AvcIntraSettings { public: AWS_MEDIACONVERT_API AvcIntraSettings(); AWS_MEDIACONVERT_API AvcIntraSettings(Aws::Utils::Json::JsonView jsonValue); AWS_MEDIACONVERT_API AvcIntraSettings& operator=(Aws::Utils::Json::JsonView jsonValue); AWS_MEDIACONVERT_API Aws::Utils::Json::JsonValue Jsonize() const; /** * Specify the AVC-Intra class of your output. The AVC-Intra class selection * determines the output video bit rate depending on the frame rate of the output. * Outputs with higher class values have higher bitrates and improved image * quality. Note that for Class 4K/2K, MediaConvert supports only 4:2:2 chroma * subsampling. */ inline const AvcIntraClass& GetAvcIntraClass() const{ return m_avcIntraClass; } /** * Specify the AVC-Intra class of your output. The AVC-Intra class selection * determines the output video bit rate depending on the frame rate of the output. * Outputs with higher class values have higher bitrates and improved image * quality. Note that for Class 4K/2K, MediaConvert supports only 4:2:2 chroma * subsampling. */ inline bool AvcIntraClassHasBeenSet() const { return m_avcIntraClassHasBeenSet; } /** * Specify the AVC-Intra class of your output. The AVC-Intra class selection * determines the output video bit rate depending on the frame rate of the output. * Outputs with higher class values have higher bitrates and improved image * quality. Note that for Class 4K/2K, MediaConvert supports only 4:2:2 chroma * subsampling. */ inline void SetAvcIntraClass(const AvcIntraClass& value) { m_avcIntraClassHasBeenSet = true; m_avcIntraClass = value; } /** * Specify the AVC-Intra class of your output. The AVC-Intra class selection * determines the output video bit rate depending on the frame rate of the output. * Outputs with higher class values have higher bitrates and improved image * quality. Note that for Class 4K/2K, MediaConvert supports only 4:2:2 chroma * subsampling. */ inline void SetAvcIntraClass(AvcIntraClass&& value) { m_avcIntraClassHasBeenSet = true; m_avcIntraClass = std::move(value); } /** * Specify the AVC-Intra class of your output. The AVC-Intra class selection * determines the output video bit rate depending on the frame rate of the output. * Outputs with higher class values have higher bitrates and improved image * quality. Note that for Class 4K/2K, MediaConvert supports only 4:2:2 chroma * subsampling. */ inline AvcIntraSettings& WithAvcIntraClass(const AvcIntraClass& value) { SetAvcIntraClass(value); return *this;} /** * Specify the AVC-Intra class of your output. The AVC-Intra class selection * determines the output video bit rate depending on the frame rate of the output. * Outputs with higher class values have higher bitrates and improved image * quality. Note that for Class 4K/2K, MediaConvert supports only 4:2:2 chroma * subsampling. */ inline AvcIntraSettings& WithAvcIntraClass(AvcIntraClass&& value) { SetAvcIntraClass(std::move(value)); return *this;} /** * Optional when you set AVC-Intra class to Class 4K/2K. When you set AVC-Intra * class to a different value, this object isn't allowed. */ inline const AvcIntraUhdSettings& GetAvcIntraUhdSettings() const{ return m_avcIntraUhdSettings; } /** * Optional when you set AVC-Intra class to Class 4K/2K. When you set AVC-Intra * class to a different value, this object isn't allowed. */ inline bool AvcIntraUhdSettingsHasBeenSet() const { return m_avcIntraUhdSettingsHasBeenSet; } /** * Optional when you set AVC-Intra class to Class 4K/2K. When you set AVC-Intra * class to a different value, this object isn't allowed. */ inline void SetAvcIntraUhdSettings(const AvcIntraUhdSettings& value) { m_avcIntraUhdSettingsHasBeenSet = true; m_avcIntraUhdSettings = value; } /** * Optional when you set AVC-Intra class to Class 4K/2K. When you set AVC-Intra * class to a different value, this object isn't allowed. */ inline void SetAvcIntraUhdSettings(AvcIntraUhdSettings&& value) { m_avcIntraUhdSettingsHasBeenSet = true; m_avcIntraUhdSettings = std::move(value); } /** * Optional when you set AVC-Intra class to Class 4K/2K. When you set AVC-Intra * class to a different value, this object isn't allowed. */ inline AvcIntraSettings& WithAvcIntraUhdSettings(const AvcIntraUhdSettings& value) { SetAvcIntraUhdSettings(value); return *this;} /** * Optional when you set AVC-Intra class to Class 4K/2K. When you set AVC-Intra * class to a different value, this object isn't allowed. */ inline AvcIntraSettings& WithAvcIntraUhdSettings(AvcIntraUhdSettings&& value) { SetAvcIntraUhdSettings(std::move(value)); return *this;} /** * If you are using the console, use the Framerate setting to specify the frame * rate for this output. If you want to keep the same frame rate as the input * video, choose Follow source. If you want to do frame rate conversion, choose a * frame rate from the dropdown list or choose Custom. The framerates shown in the * dropdown list are decimal approximations of fractions. If you choose Custom, * specify your frame rate as a fraction. */ inline const AvcIntraFramerateControl& GetFramerateControl() const{ return m_framerateControl; } /** * If you are using the console, use the Framerate setting to specify the frame * rate for this output. If you want to keep the same frame rate as the input * video, choose Follow source. If you want to do frame rate conversion, choose a * frame rate from the dropdown list or choose Custom. The framerates shown in the * dropdown list are decimal approximations of fractions. If you choose Custom, * specify your frame rate as a fraction. */ inline bool FramerateControlHasBeenSet() const { return m_framerateControlHasBeenSet; } /** * If you are using the console, use the Framerate setting to specify the frame * rate for this output. If you want to keep the same frame rate as the input * video, choose Follow source. If you want to do frame rate conversion, choose a * frame rate from the dropdown list or choose Custom. The framerates shown in the * dropdown list are decimal approximations of fractions. If you choose Custom, * specify your frame rate as a fraction. */ inline void SetFramerateControl(const AvcIntraFramerateControl& value) { m_framerateControlHasBeenSet = true; m_framerateControl = value; } /** * If you are using the console, use the Framerate setting to specify the frame * rate for this output. If you want to keep the same frame rate as the input * video, choose Follow source. If you want to do frame rate conversion, choose a * frame rate from the dropdown list or choose Custom. The framerates shown in the * dropdown list are decimal approximations of fractions. If you choose Custom, * specify your frame rate as a fraction. */ inline void SetFramerateControl(AvcIntraFramerateControl&& value) { m_framerateControlHasBeenSet = true; m_framerateControl = std::move(value); } /** * If you are using the console, use the Framerate setting to specify the frame * rate for this output. If you want to keep the same frame rate as the input * video, choose Follow source. If you want to do frame rate conversion, choose a * frame rate from the dropdown list or choose Custom. The framerates shown in the * dropdown list are decimal approximations of fractions. If you choose Custom, * specify your frame rate as a fraction. */ inline AvcIntraSettings& WithFramerateControl(const AvcIntraFramerateControl& value) { SetFramerateControl(value); return *this;} /** * If you are using the console, use the Framerate setting to specify the frame * rate for this output. If you want to keep the same frame rate as the input * video, choose Follow source. If you want to do frame rate conversion, choose a * frame rate from the dropdown list or choose Custom. The framerates shown in the * dropdown list are decimal approximations of fractions. If you choose Custom, * specify your frame rate as a fraction. */ inline AvcIntraSettings& WithFramerateControl(AvcIntraFramerateControl&& value) { SetFramerateControl(std::move(value)); return *this;} /** * Choose the method that you want MediaConvert to use when increasing or * decreasing the frame rate. For numerically simple conversions, such as 60 fps to * 30 fps: We recommend that you keep the default value, Drop duplicate. For * numerically complex conversions, to avoid stutter: Choose Interpolate. This * results in a smooth picture, but might introduce undesirable video artifacts. * For complex frame rate conversions, especially if your source video has already * been converted from its original cadence: Choose FrameFormer to do * motion-compensated interpolation. FrameFormer uses the best conversion method * frame by frame. Note that using FrameFormer increases the transcoding time and * incurs a significant add-on cost. When you choose FrameFormer, your input video * resolution must be at least 128x96. */ inline const AvcIntraFramerateConversionAlgorithm& GetFramerateConversionAlgorithm() const{ return m_framerateConversionAlgorithm; } /** * Choose the method that you want MediaConvert to use when increasing or * decreasing the frame rate. For numerically simple conversions, such as 60 fps to * 30 fps: We recommend that you keep the default value, Drop duplicate. For * numerically complex conversions, to avoid stutter: Choose Interpolate. This * results in a smooth picture, but might introduce undesirable video artifacts. * For complex frame rate conversions, especially if your source video has already * been converted from its original cadence: Choose FrameFormer to do * motion-compensated interpolation. FrameFormer uses the best conversion method * frame by frame. Note that using FrameFormer increases the transcoding time and * incurs a significant add-on cost. When you choose FrameFormer, your input video * resolution must be at least 128x96. */ inline bool FramerateConversionAlgorithmHasBeenSet() const { return m_framerateConversionAlgorithmHasBeenSet; } /** * Choose the method that you want MediaConvert to use when increasing or * decreasing the frame rate. For numerically simple conversions, such as 60 fps to * 30 fps: We recommend that you keep the default value, Drop duplicate. For * numerically complex conversions, to avoid stutter: Choose Interpolate. This * results in a smooth picture, but might introduce undesirable video artifacts. * For complex frame rate conversions, especially if your source video has already * been converted from its original cadence: Choose FrameFormer to do * motion-compensated interpolation. FrameFormer uses the best conversion method * frame by frame. Note that using FrameFormer increases the transcoding time and * incurs a significant add-on cost. When you choose FrameFormer, your input video * resolution must be at least 128x96. */ inline void SetFramerateConversionAlgorithm(const AvcIntraFramerateConversionAlgorithm& value) { m_framerateConversionAlgorithmHasBeenSet = true; m_framerateConversionAlgorithm = value; } /** * Choose the method that you want MediaConvert to use when increasing or * decreasing the frame rate. For numerically simple conversions, such as 60 fps to * 30 fps: We recommend that you keep the default value, Drop duplicate. For * numerically complex conversions, to avoid stutter: Choose Interpolate. This * results in a smooth picture, but might introduce undesirable video artifacts. * For complex frame rate conversions, especially if your source video has already * been converted from its original cadence: Choose FrameFormer to do * motion-compensated interpolation. FrameFormer uses the best conversion method * frame by frame. Note that using FrameFormer increases the transcoding time and * incurs a significant add-on cost. When you choose FrameFormer, your input video * resolution must be at least 128x96. */ inline void SetFramerateConversionAlgorithm(AvcIntraFramerateConversionAlgorithm&& value) { m_framerateConversionAlgorithmHasBeenSet = true; m_framerateConversionAlgorithm = std::move(value); } /** * Choose the method that you want MediaConvert to use when increasing or * decreasing the frame rate. For numerically simple conversions, such as 60 fps to * 30 fps: We recommend that you keep the default value, Drop duplicate. For * numerically complex conversions, to avoid stutter: Choose Interpolate. This * results in a smooth picture, but might introduce undesirable video artifacts. * For complex frame rate conversions, especially if your source video has already * been converted from its original cadence: Choose FrameFormer to do * motion-compensated interpolation. FrameFormer uses the best conversion method * frame by frame. Note that using FrameFormer increases the transcoding time and * incurs a significant add-on cost. When you choose FrameFormer, your input video * resolution must be at least 128x96. */ inline AvcIntraSettings& WithFramerateConversionAlgorithm(const AvcIntraFramerateConversionAlgorithm& value) { SetFramerateConversionAlgorithm(value); return *this;} /** * Choose the method that you want MediaConvert to use when increasing or * decreasing the frame rate. For numerically simple conversions, such as 60 fps to * 30 fps: We recommend that you keep the default value, Drop duplicate. For * numerically complex conversions, to avoid stutter: Choose Interpolate. This * results in a smooth picture, but might introduce undesirable video artifacts. * For complex frame rate conversions, especially if your source video has already * been converted from its original cadence: Choose FrameFormer to do * motion-compensated interpolation. FrameFormer uses the best conversion method * frame by frame. Note that using FrameFormer increases the transcoding time and * incurs a significant add-on cost. When you choose FrameFormer, your input video * resolution must be at least 128x96. */ inline AvcIntraSettings& WithFramerateConversionAlgorithm(AvcIntraFramerateConversionAlgorithm&& value) { SetFramerateConversionAlgorithm(std::move(value)); return *this;} /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateDenominator to specify the denominator of this fraction. In this * example, use 1001 for the value of FramerateDenominator. When you use the * console for transcode jobs that use frame rate conversion, provide the value as * a decimal number for Framerate. In this example, specify 23.976. */ inline int GetFramerateDenominator() const{ return m_framerateDenominator; } /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateDenominator to specify the denominator of this fraction. In this * example, use 1001 for the value of FramerateDenominator. When you use the * console for transcode jobs that use frame rate conversion, provide the value as * a decimal number for Framerate. In this example, specify 23.976. */ inline bool FramerateDenominatorHasBeenSet() const { return m_framerateDenominatorHasBeenSet; } /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateDenominator to specify the denominator of this fraction. In this * example, use 1001 for the value of FramerateDenominator. When you use the * console for transcode jobs that use frame rate conversion, provide the value as * a decimal number for Framerate. In this example, specify 23.976. */ inline void SetFramerateDenominator(int value) { m_framerateDenominatorHasBeenSet = true; m_framerateDenominator = value; } /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateDenominator to specify the denominator of this fraction. In this * example, use 1001 for the value of FramerateDenominator. When you use the * console for transcode jobs that use frame rate conversion, provide the value as * a decimal number for Framerate. In this example, specify 23.976. */ inline AvcIntraSettings& WithFramerateDenominator(int value) { SetFramerateDenominator(value); return *this;} /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateNumerator to specify the numerator of this fraction. In this example, * use 24000 for the value of FramerateNumerator. When you use the console for * transcode jobs that use frame rate conversion, provide the value as a decimal * number for Framerate. In this example, specify 23.976. */ inline int GetFramerateNumerator() const{ return m_framerateNumerator; } /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateNumerator to specify the numerator of this fraction. In this example, * use 24000 for the value of FramerateNumerator. When you use the console for * transcode jobs that use frame rate conversion, provide the value as a decimal * number for Framerate. In this example, specify 23.976. */ inline bool FramerateNumeratorHasBeenSet() const { return m_framerateNumeratorHasBeenSet; } /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateNumerator to specify the numerator of this fraction. In this example, * use 24000 for the value of FramerateNumerator. When you use the console for * transcode jobs that use frame rate conversion, provide the value as a decimal * number for Framerate. In this example, specify 23.976. */ inline void SetFramerateNumerator(int value) { m_framerateNumeratorHasBeenSet = true; m_framerateNumerator = value; } /** * When you use the API for transcode jobs that use frame rate conversion, specify * the frame rate as a fraction. For example, 24000 / 1001 = 23.976 fps. Use * FramerateNumerator to specify the numerator of this fraction. In this example, * use 24000 for the value of FramerateNumerator. When you use the console for * transcode jobs that use frame rate conversion, provide the value as a decimal * number for Framerate. In this example, specify 23.976. */ inline AvcIntraSettings& WithFramerateNumerator(int value) { SetFramerateNumerator(value); return *this;} /** * Choose the scan line type for the output. Keep the default value, Progressive to * create a progressive output, regardless of the scan type of your input. Use Top * field first or Bottom field first to create an output that's interlaced with the * same field polarity throughout. Use Follow, default top or Follow, default * bottom to produce outputs with the same field polarity as the source. For jobs * that have multiple inputs, the output field polarity might change over the * course of the output. Follow behavior depends on the input scan type. If the * source is interlaced, the output will be interlaced with the same polarity as * the source. If the source is progressive, the output will be interlaced with top * field bottom field first, depending on which of the Follow options you choose. */ inline const AvcIntraInterlaceMode& GetInterlaceMode() const{ return m_interlaceMode; } /** * Choose the scan line type for the output. Keep the default value, Progressive to * create a progressive output, regardless of the scan type of your input. Use Top * field first or Bottom field first to create an output that's interlaced with the * same field polarity throughout. Use Follow, default top or Follow, default * bottom to produce outputs with the same field polarity as the source. For jobs * that have multiple inputs, the output field polarity might change over the * course of the output. Follow behavior depends on the input scan type. If the * source is interlaced, the output will be interlaced with the same polarity as * the source. If the source is progressive, the output will be interlaced with top * field bottom field first, depending on which of the Follow options you choose. */ inline bool InterlaceModeHasBeenSet() const { return m_interlaceModeHasBeenSet; } /** * Choose the scan line type for the output. Keep the default value, Progressive to * create a progressive output, regardless of the scan type of your input. Use Top * field first or Bottom field first to create an output that's interlaced with the * same field polarity throughout. Use Follow, default top or Follow, default * bottom to produce outputs with the same field polarity as the source. For jobs * that have multiple inputs, the output field polarity might change over the * course of the output. Follow behavior depends on the input scan type. If the * source is interlaced, the output will be interlaced with the same polarity as * the source. If the source is progressive, the output will be interlaced with top * field bottom field first, depending on which of the Follow options you choose. */ inline void SetInterlaceMode(const AvcIntraInterlaceMode& value) { m_interlaceModeHasBeenSet = true; m_interlaceMode = value; } /** * Choose the scan line type for the output. Keep the default value, Progressive to * create a progressive output, regardless of the scan type of your input. Use Top * field first or Bottom field first to create an output that's interlaced with the * same field polarity throughout. Use Follow, default top or Follow, default * bottom to produce outputs with the same field polarity as the source. For jobs * that have multiple inputs, the output field polarity might change over the * course of the output. Follow behavior depends on the input scan type. If the * source is interlaced, the output will be interlaced with the same polarity as * the source. If the source is progressive, the output will be interlaced with top * field bottom field first, depending on which of the Follow options you choose. */ inline void SetInterlaceMode(AvcIntraInterlaceMode&& value) { m_interlaceModeHasBeenSet = true; m_interlaceMode = std::move(value); } /** * Choose the scan line type for the output. Keep the default value, Progressive to * create a progressive output, regardless of the scan type of your input. Use Top * field first or Bottom field first to create an output that's interlaced with the * same field polarity throughout. Use Follow, default top or Follow, default * bottom to produce outputs with the same field polarity as the source. For jobs * that have multiple inputs, the output field polarity might change over the * course of the output. Follow behavior depends on the input scan type. If the * source is interlaced, the output will be interlaced with the same polarity as * the source. If the source is progressive, the output will be interlaced with top * field bottom field first, depending on which of the Follow options you choose. */ inline AvcIntraSettings& WithInterlaceMode(const AvcIntraInterlaceMode& value) { SetInterlaceMode(value); return *this;} /** * Choose the scan line type for the output. Keep the default value, Progressive to * create a progressive output, regardless of the scan type of your input. Use Top * field first or Bottom field first to create an output that's interlaced with the * same field polarity throughout. Use Follow, default top or Follow, default * bottom to produce outputs with the same field polarity as the source. For jobs * that have multiple inputs, the output field polarity might change over the * course of the output. Follow behavior depends on the input scan type. If the * source is interlaced, the output will be interlaced with the same polarity as * the source. If the source is progressive, the output will be interlaced with top * field bottom field first, depending on which of the Follow options you choose. */ inline AvcIntraSettings& WithInterlaceMode(AvcIntraInterlaceMode&& value) { SetInterlaceMode(std::move(value)); return *this;} /** * Use this setting for interlaced outputs, when your output frame rate is half of * your input frame rate. In this situation, choose Optimized interlacing to create * a better quality interlaced output. In this case, each progressive frame from * the input corresponds to an interlaced field in the output. Keep the default * value, Basic interlacing, for all other output frame rates. With basic * interlacing, MediaConvert performs any frame rate conversion first and then * interlaces the frames. When you choose Optimized interlacing and you set your * output frame rate to a value that isn't suitable for optimized interlacing, * MediaConvert automatically falls back to basic interlacing. Required settings: * To use optimized interlacing, you must set Telecine to None or Soft. You can't * use optimized interlacing for hard telecine outputs. You must also set Interlace * mode to a value other than Progressive. */ inline const AvcIntraScanTypeConversionMode& GetScanTypeConversionMode() const{ return m_scanTypeConversionMode; } /** * Use this setting for interlaced outputs, when your output frame rate is half of * your input frame rate. In this situation, choose Optimized interlacing to create * a better quality interlaced output. In this case, each progressive frame from * the input corresponds to an interlaced field in the output. Keep the default * value, Basic interlacing, for all other output frame rates. With basic * interlacing, MediaConvert performs any frame rate conversion first and then * interlaces the frames. When you choose Optimized interlacing and you set your * output frame rate to a value that isn't suitable for optimized interlacing, * MediaConvert automatically falls back to basic interlacing. Required settings: * To use optimized interlacing, you must set Telecine to None or Soft. You can't * use optimized interlacing for hard telecine outputs. You must also set Interlace * mode to a value other than Progressive. */ inline bool ScanTypeConversionModeHasBeenSet() const { return m_scanTypeConversionModeHasBeenSet; } /** * Use this setting for interlaced outputs, when your output frame rate is half of * your input frame rate. In this situation, choose Optimized interlacing to create * a better quality interlaced output. In this case, each progressive frame from * the input corresponds to an interlaced field in the output. Keep the default * value, Basic interlacing, for all other output frame rates. With basic * interlacing, MediaConvert performs any frame rate conversion first and then * interlaces the frames. When you choose Optimized interlacing and you set your * output frame rate to a value that isn't suitable for optimized interlacing, * MediaConvert automatically falls back to basic interlacing. Required settings: * To use optimized interlacing, you must set Telecine to None or Soft. You can't * use optimized interlacing for hard telecine outputs. You must also set Interlace * mode to a value other than Progressive. */ inline void SetScanTypeConversionMode(const AvcIntraScanTypeConversionMode& value) { m_scanTypeConversionModeHasBeenSet = true; m_scanTypeConversionMode = value; } /** * Use this setting for interlaced outputs, when your output frame rate is half of * your input frame rate. In this situation, choose Optimized interlacing to create * a better quality interlaced output. In this case, each progressive frame from * the input corresponds to an interlaced field in the output. Keep the default * value, Basic interlacing, for all other output frame rates. With basic * interlacing, MediaConvert performs any frame rate conversion first and then * interlaces the frames. When you choose Optimized interlacing and you set your * output frame rate to a value that isn't suitable for optimized interlacing, * MediaConvert automatically falls back to basic interlacing. Required settings: * To use optimized interlacing, you must set Telecine to None or Soft. You can't * use optimized interlacing for hard telecine outputs. You must also set Interlace * mode to a value other than Progressive. */ inline void SetScanTypeConversionMode(AvcIntraScanTypeConversionMode&& value) { m_scanTypeConversionModeHasBeenSet = true; m_scanTypeConversionMode = std::move(value); } /** * Use this setting for interlaced outputs, when your output frame rate is half of * your input frame rate. In this situation, choose Optimized interlacing to create * a better quality interlaced output. In this case, each progressive frame from * the input corresponds to an interlaced field in the output. Keep the default * value, Basic interlacing, for all other output frame rates. With basic * interlacing, MediaConvert performs any frame rate conversion first and then * interlaces the frames. When you choose Optimized interlacing and you set your * output frame rate to a value that isn't suitable for optimized interlacing, * MediaConvert automatically falls back to basic interlacing. Required settings: * To use optimized interlacing, you must set Telecine to None or Soft. You can't * use optimized interlacing for hard telecine outputs. You must also set Interlace * mode to a value other than Progressive. */ inline AvcIntraSettings& WithScanTypeConversionMode(const AvcIntraScanTypeConversionMode& value) { SetScanTypeConversionMode(value); return *this;} /** * Use this setting for interlaced outputs, when your output frame rate is half of * your input frame rate. In this situation, choose Optimized interlacing to create * a better quality interlaced output. In this case, each progressive frame from * the input corresponds to an interlaced field in the output. Keep the default * value, Basic interlacing, for all other output frame rates. With basic * interlacing, MediaConvert performs any frame rate conversion first and then * interlaces the frames. When you choose Optimized interlacing and you set your * output frame rate to a value that isn't suitable for optimized interlacing, * MediaConvert automatically falls back to basic interlacing. Required settings: * To use optimized interlacing, you must set Telecine to None or Soft. You can't * use optimized interlacing for hard telecine outputs. You must also set Interlace * mode to a value other than Progressive. */ inline AvcIntraSettings& WithScanTypeConversionMode(AvcIntraScanTypeConversionMode&& value) { SetScanTypeConversionMode(std::move(value)); return *this;} /** * Ignore this setting unless your input frame rate is 23.976 or 24 frames per * second (fps). Enable slow PAL to create a 25 fps output. When you enable slow * PAL, MediaConvert relabels the video frames to 25 fps and resamples your audio * to keep it synchronized with the video. Note that enabling this setting will * slightly reduce the duration of your video. Required settings: You must also set * Framerate to 25. */ inline const AvcIntraSlowPal& GetSlowPal() const{ return m_slowPal; } /** * Ignore this setting unless your input frame rate is 23.976 or 24 frames per * second (fps). Enable slow PAL to create a 25 fps output. When you enable slow * PAL, MediaConvert relabels the video frames to 25 fps and resamples your audio * to keep it synchronized with the video. Note that enabling this setting will * slightly reduce the duration of your video. Required settings: You must also set * Framerate to 25. */ inline bool SlowPalHasBeenSet() const { return m_slowPalHasBeenSet; } /** * Ignore this setting unless your input frame rate is 23.976 or 24 frames per * second (fps). Enable slow PAL to create a 25 fps output. When you enable slow * PAL, MediaConvert relabels the video frames to 25 fps and resamples your audio * to keep it synchronized with the video. Note that enabling this setting will * slightly reduce the duration of your video. Required settings: You must also set * Framerate to 25. */ inline void SetSlowPal(const AvcIntraSlowPal& value) { m_slowPalHasBeenSet = true; m_slowPal = value; } /** * Ignore this setting unless your input frame rate is 23.976 or 24 frames per * second (fps). Enable slow PAL to create a 25 fps output. When you enable slow * PAL, MediaConvert relabels the video frames to 25 fps and resamples your audio * to keep it synchronized with the video. Note that enabling this setting will * slightly reduce the duration of your video. Required settings: You must also set * Framerate to 25. */ inline void SetSlowPal(AvcIntraSlowPal&& value) { m_slowPalHasBeenSet = true; m_slowPal = std::move(value); } /** * Ignore this setting unless your input frame rate is 23.976 or 24 frames per * second (fps). Enable slow PAL to create a 25 fps output. When you enable slow * PAL, MediaConvert relabels the video frames to 25 fps and resamples your audio * to keep it synchronized with the video. Note that enabling this setting will * slightly reduce the duration of your video. Required settings: You must also set * Framerate to 25. */ inline AvcIntraSettings& WithSlowPal(const AvcIntraSlowPal& value) { SetSlowPal(value); return *this;} /** * Ignore this setting unless your input frame rate is 23.976 or 24 frames per * second (fps). Enable slow PAL to create a 25 fps output. When you enable slow * PAL, MediaConvert relabels the video frames to 25 fps and resamples your audio * to keep it synchronized with the video. Note that enabling this setting will * slightly reduce the duration of your video. Required settings: You must also set * Framerate to 25. */ inline AvcIntraSettings& WithSlowPal(AvcIntraSlowPal&& value) { SetSlowPal(std::move(value)); return *this;} /** * When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 * fps, and your output scan type is interlaced, you can optionally enable hard * telecine to create a smoother picture. When you keep the default value, None, * MediaConvert does a standard frame rate conversion to 29.97 without doing * anything with the field polarity to create a smoother picture. */ inline const AvcIntraTelecine& GetTelecine() const{ return m_telecine; } /** * When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 * fps, and your output scan type is interlaced, you can optionally enable hard * telecine to create a smoother picture. When you keep the default value, None, * MediaConvert does a standard frame rate conversion to 29.97 without doing * anything with the field polarity to create a smoother picture. */ inline bool TelecineHasBeenSet() const { return m_telecineHasBeenSet; } /** * When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 * fps, and your output scan type is interlaced, you can optionally enable hard * telecine to create a smoother picture. When you keep the default value, None, * MediaConvert does a standard frame rate conversion to 29.97 without doing * anything with the field polarity to create a smoother picture. */ inline void SetTelecine(const AvcIntraTelecine& value) { m_telecineHasBeenSet = true; m_telecine = value; } /** * When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 * fps, and your output scan type is interlaced, you can optionally enable hard * telecine to create a smoother picture. When you keep the default value, None, * MediaConvert does a standard frame rate conversion to 29.97 without doing * anything with the field polarity to create a smoother picture. */ inline void SetTelecine(AvcIntraTelecine&& value) { m_telecineHasBeenSet = true; m_telecine = std::move(value); } /** * When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 * fps, and your output scan type is interlaced, you can optionally enable hard * telecine to create a smoother picture. When you keep the default value, None, * MediaConvert does a standard frame rate conversion to 29.97 without doing * anything with the field polarity to create a smoother picture. */ inline AvcIntraSettings& WithTelecine(const AvcIntraTelecine& value) { SetTelecine(value); return *this;} /** * When you do frame rate conversion from 23.976 frames per second (fps) to 29.97 * fps, and your output scan type is interlaced, you can optionally enable hard * telecine to create a smoother picture. When you keep the default value, None, * MediaConvert does a standard frame rate conversion to 29.97 without doing * anything with the field polarity to create a smoother picture. */ inline AvcIntraSettings& WithTelecine(AvcIntraTelecine&& value) { SetTelecine(std::move(value)); return *this;} private: AvcIntraClass m_avcIntraClass; bool m_avcIntraClassHasBeenSet = false; AvcIntraUhdSettings m_avcIntraUhdSettings; bool m_avcIntraUhdSettingsHasBeenSet = false; AvcIntraFramerateControl m_framerateControl; bool m_framerateControlHasBeenSet = false; AvcIntraFramerateConversionAlgorithm m_framerateConversionAlgorithm; bool m_framerateConversionAlgorithmHasBeenSet = false; int m_framerateDenominator; bool m_framerateDenominatorHasBeenSet = false; int m_framerateNumerator; bool m_framerateNumeratorHasBeenSet = false; AvcIntraInterlaceMode m_interlaceMode; bool m_interlaceModeHasBeenSet = false; AvcIntraScanTypeConversionMode m_scanTypeConversionMode; bool m_scanTypeConversionModeHasBeenSet = false; AvcIntraSlowPal m_slowPal; bool m_slowPalHasBeenSet = false; AvcIntraTelecine m_telecine; bool m_telecineHasBeenSet = false; }; } // namespace Model } // namespace MediaConvert } // namespace Aws