Struct aws_sdk_elastictranscoder::model::audio_parameters::Builder

pub struct Builder { /* private fields */ }

A builder for AudioParameters.

Implementations

impl Builder

pub fn codec(self, input: impl Into<String>) -> Self

The audio codec for the output file. Valid values include aac, flac, mp2, mp3, pcm, and vorbis.

pub fn set_codec(self, input: Option<String>) -> Self

The audio codec for the output file. Valid values include aac, flac, mp2, mp3, pcm, and vorbis.

Examples found in repository

src/json_deser.rs (lines 2501-2507)

pub(crate) fn deser_structure_crate_model_audio_parameters<'a, I>(
    tokens: &mut std::iter::Peekable<I>,
) -> Result<
    Option<crate::model::AudioParameters>,
    aws_smithy_json::deserialize::error::DeserializeError,
>
where
    I: Iterator<
        Item = Result<
            aws_smithy_json::deserialize::Token<'a>,
            aws_smithy_json::deserialize::error::DeserializeError,
        >,
    >,
{
    match tokens.next().transpose()? {
        Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
        Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
            #[allow(unused_mut)]
            let mut builder = crate::model::audio_parameters::Builder::default();
            loop {
                match tokens.next().transpose()? {
                    Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                    Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                        match key.to_unescaped()?.as_ref() {
                            "Codec" => {
                                builder = builder.set_codec(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "SampleRate" => {
                                builder = builder.set_sample_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "BitRate" => {
                                builder = builder.set_bit_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "Channels" => {
                                builder = builder.set_channels(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "AudioPackingMode" => {
                                builder = builder.set_audio_packing_mode(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "CodecOptions" => {
                                builder = builder.set_codec_options(
                                    crate::json_deser::deser_structure_crate_model_audio_codec_options(tokens)?
                                );
                            }
                            _ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
                        }
                    }
                    other => {
                        return Err(
                            aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                                "expected object key or end object, found: {:?}",
                                other
                            )),
                        )
                    }
                }
            }
            Ok(Some(builder.build()))
        }
        _ => Err(
            aws_smithy_json::deserialize::error::DeserializeError::custom(
                "expected start object or null",
            ),
        ),
    }
}

pub fn sample_rate(self, input: impl Into<String>) -> Self

The sample rate of the audio stream in the output file, in Hertz. Valid values include:

auto, 22050, 32000, 44100, 48000, 96000

If you specify auto, Elastic Transcoder automatically detects the sample rate.

pub fn set_sample_rate(self, input: Option<String>) -> Self

The sample rate of the audio stream in the output file, in Hertz. Valid values include:

auto, 22050, 32000, 44100, 48000, 96000

If you specify auto, Elastic Transcoder automatically detects the sample rate.

Examples found in repository

src/json_deser.rs (lines 2510-2516)

pub(crate) fn deser_structure_crate_model_audio_parameters<'a, I>(
    tokens: &mut std::iter::Peekable<I>,
) -> Result<
    Option<crate::model::AudioParameters>,
    aws_smithy_json::deserialize::error::DeserializeError,
>
where
    I: Iterator<
        Item = Result<
            aws_smithy_json::deserialize::Token<'a>,
            aws_smithy_json::deserialize::error::DeserializeError,
        >,
    >,
{
    match tokens.next().transpose()? {
        Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
        Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
            #[allow(unused_mut)]
            let mut builder = crate::model::audio_parameters::Builder::default();
            loop {
                match tokens.next().transpose()? {
                    Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                    Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                        match key.to_unescaped()?.as_ref() {
                            "Codec" => {
                                builder = builder.set_codec(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "SampleRate" => {
                                builder = builder.set_sample_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "BitRate" => {
                                builder = builder.set_bit_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "Channels" => {
                                builder = builder.set_channels(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "AudioPackingMode" => {
                                builder = builder.set_audio_packing_mode(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "CodecOptions" => {
                                builder = builder.set_codec_options(
                                    crate::json_deser::deser_structure_crate_model_audio_codec_options(tokens)?
                                );
                            }
                            _ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
                        }
                    }
                    other => {
                        return Err(
                            aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                                "expected object key or end object, found: {:?}",
                                other
                            )),
                        )
                    }
                }
            }
            Ok(Some(builder.build()))
        }
        _ => Err(
            aws_smithy_json::deserialize::error::DeserializeError::custom(
                "expected start object or null",
            ),
        ),
    }
}

pub fn bit_rate(self, input: impl Into<String>) -> Self

The bit rate of the audio stream in the output file, in kilobits/second. Enter an integer between 64 and 320, inclusive.

pub fn set_bit_rate(self, input: Option<String>) -> Self

The bit rate of the audio stream in the output file, in kilobits/second. Enter an integer between 64 and 320, inclusive.

Examples found in repository

src/json_deser.rs (lines 2519-2525)

pub(crate) fn deser_structure_crate_model_audio_parameters<'a, I>(
    tokens: &mut std::iter::Peekable<I>,
) -> Result<
    Option<crate::model::AudioParameters>,
    aws_smithy_json::deserialize::error::DeserializeError,
>
where
    I: Iterator<
        Item = Result<
            aws_smithy_json::deserialize::Token<'a>,
            aws_smithy_json::deserialize::error::DeserializeError,
        >,
    >,
{
    match tokens.next().transpose()? {
        Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
        Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
            #[allow(unused_mut)]
            let mut builder = crate::model::audio_parameters::Builder::default();
            loop {
                match tokens.next().transpose()? {
                    Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                    Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                        match key.to_unescaped()?.as_ref() {
                            "Codec" => {
                                builder = builder.set_codec(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "SampleRate" => {
                                builder = builder.set_sample_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "BitRate" => {
                                builder = builder.set_bit_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "Channels" => {
                                builder = builder.set_channels(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "AudioPackingMode" => {
                                builder = builder.set_audio_packing_mode(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "CodecOptions" => {
                                builder = builder.set_codec_options(
                                    crate::json_deser::deser_structure_crate_model_audio_codec_options(tokens)?
                                );
                            }
                            _ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
                        }
                    }
                    other => {
                        return Err(
                            aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                                "expected object key or end object, found: {:?}",
                                other
                            )),
                        )
                    }
                }
            }
            Ok(Some(builder.build()))
        }
        _ => Err(
            aws_smithy_json::deserialize::error::DeserializeError::custom(
                "expected start object or null",
            ),
        ),
    }
}

pub fn channels(self, input: impl Into<String>) -> Self

The number of audio channels in the output file. The following values are valid:

auto, 0, 1, 2

One channel carries the information played by a single speaker. For example, a stereo track with two channels sends one channel to the left speaker, and the other channel to the right speaker. The output channels are organized into tracks. If you want Elastic Transcoder to automatically detect the number of audio channels in the input file and use that value for the output file, select auto.

The output of a specific channel value and inputs are as follows:

• auto channel specified, with any input: Pass through up to eight input channels.

• 0 channels specified, with any input: Audio omitted from the output.

• 1 channel specified, with at least one input channel: Mono sound.

• 2 channels specified, with any input: Two identical mono channels or stereo. For more information about tracks, see Audio:AudioPackingMode.

For more information about how Elastic Transcoder organizes channels and tracks, see Audio:AudioPackingMode.

pub fn set_channels(self, input: Option<String>) -> Self

The number of audio channels in the output file. The following values are valid:

auto, 0, 1, 2

One channel carries the information played by a single speaker. For example, a stereo track with two channels sends one channel to the left speaker, and the other channel to the right speaker. The output channels are organized into tracks. If you want Elastic Transcoder to automatically detect the number of audio channels in the input file and use that value for the output file, select auto.

The output of a specific channel value and inputs are as follows:

• auto channel specified, with any input: Pass through up to eight input channels.

• 0 channels specified, with any input: Audio omitted from the output.

• 1 channel specified, with at least one input channel: Mono sound.

• 2 channels specified, with any input: Two identical mono channels or stereo. For more information about tracks, see Audio:AudioPackingMode.

For more information about how Elastic Transcoder organizes channels and tracks, see Audio:AudioPackingMode.

Examples found in repository

src/json_deser.rs (lines 2528-2534)

pub(crate) fn deser_structure_crate_model_audio_parameters<'a, I>(
    tokens: &mut std::iter::Peekable<I>,
) -> Result<
    Option<crate::model::AudioParameters>,
    aws_smithy_json::deserialize::error::DeserializeError,
>
where
    I: Iterator<
        Item = Result<
            aws_smithy_json::deserialize::Token<'a>,
            aws_smithy_json::deserialize::error::DeserializeError,
        >,
    >,
{
    match tokens.next().transpose()? {
        Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
        Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
            #[allow(unused_mut)]
            let mut builder = crate::model::audio_parameters::Builder::default();
            loop {
                match tokens.next().transpose()? {
                    Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                    Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                        match key.to_unescaped()?.as_ref() {
                            "Codec" => {
                                builder = builder.set_codec(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "SampleRate" => {
                                builder = builder.set_sample_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "BitRate" => {
                                builder = builder.set_bit_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "Channels" => {
                                builder = builder.set_channels(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "AudioPackingMode" => {
                                builder = builder.set_audio_packing_mode(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "CodecOptions" => {
                                builder = builder.set_codec_options(
                                    crate::json_deser::deser_structure_crate_model_audio_codec_options(tokens)?
                                );
                            }
                            _ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
                        }
                    }
                    other => {
                        return Err(
                            aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                                "expected object key or end object, found: {:?}",
                                other
                            )),
                        )
                    }
                }
            }
            Ok(Some(builder.build()))
        }
        _ => Err(
            aws_smithy_json::deserialize::error::DeserializeError::custom(
                "expected start object or null",
            ),
        ),
    }
}

pub fn audio_packing_mode(self, input: impl Into<String>) -> Self

The method of organizing audio channels and tracks. Use Audio:Channels to specify the number of channels in your output, and Audio:AudioPackingMode to specify the number of tracks and their relation to the channels. If you do not specify an Audio:AudioPackingMode, Elastic Transcoder uses SingleTrack.

The following values are valid:

SingleTrack, OneChannelPerTrack, and OneChannelPerTrackWithMosTo8Tracks

When you specify SingleTrack, Elastic Transcoder creates a single track for your output. The track can have up to eight channels. Use SingleTrack for all non-mxf containers.

The outputs of SingleTrack for a specific channel value and inputs are as follows:

• 0 channels with any input: Audio omitted from the output

• 1, 2, or auto channels with no audio input: Audio omitted from the output

• 1 channel with any input with audio: One track with one channel, downmixed if necessary

• 2 channels with one track with one channel: One track with two identical channels

• 2 or auto channels with two tracks with one channel each: One track with two channels

• 2 or auto channels with one track with two channels: One track with two channels

• 2 channels with one track with multiple channels: One track with two channels

• auto channels with one track with one channel: One track with one channel

• auto channels with one track with multiple channels: One track with multiple channels

When you specify OneChannelPerTrack, Elastic Transcoder creates a new track for every channel in your output. Your output can have up to eight single-channel tracks.

The outputs of OneChannelPerTrack for a specific channel value and inputs are as follows:

• 0 channels with any input: Audio omitted from the output

• 1, 2, or auto channels with no audio input: Audio omitted from the output

• 1 channel with any input with audio: One track with one channel, downmixed if necessary

• 2 channels with one track with one channel: Two tracks with one identical channel each

• 2 or auto channels with two tracks with one channel each: Two tracks with one channel each

• 2 or auto channels with one track with two channels: Two tracks with one channel each

• 2 channels with one track with multiple channels: Two tracks with one channel each

• auto channels with one track with one channel: One track with one channel

• auto channels with one track with multiple channels: Up to eight tracks with one channel each

When you specify OneChannelPerTrackWithMosTo8Tracks, Elastic Transcoder creates eight single-channel tracks for your output. All tracks that do not contain audio data from an input channel are MOS, or Mit Out Sound, tracks.

The outputs of OneChannelPerTrackWithMosTo8Tracks for a specific channel value and inputs are as follows:

• 0 channels with any input: Audio omitted from the output

• 1, 2, or auto channels with no audio input: Audio omitted from the output

• 1 channel with any input with audio: One track with one channel, downmixed if necessary, plus six MOS tracks

• 2 channels with one track with one channel: Two tracks with one identical channel each, plus six MOS tracks

• 2 or auto channels with two tracks with one channel each: Two tracks with one channel each, plus six MOS tracks

• 2 or auto channels with one track with two channels: Two tracks with one channel each, plus six MOS tracks

• 2 channels with one track with multiple channels: Two tracks with one channel each, plus six MOS tracks

• auto channels with one track with one channel: One track with one channel, plus seven MOS tracks

• auto channels with one track with multiple channels: Up to eight tracks with one channel each, plus MOS tracks until there are eight tracks in all

pub fn set_audio_packing_mode(self, input: Option<String>) -> Self

The method of organizing audio channels and tracks. Use Audio:Channels to specify the number of channels in your output, and Audio:AudioPackingMode to specify the number of tracks and their relation to the channels. If you do not specify an Audio:AudioPackingMode, Elastic Transcoder uses SingleTrack.

The following values are valid:

SingleTrack, OneChannelPerTrack, and OneChannelPerTrackWithMosTo8Tracks

When you specify SingleTrack, Elastic Transcoder creates a single track for your output. The track can have up to eight channels. Use SingleTrack for all non-mxf containers.

The outputs of SingleTrack for a specific channel value and inputs are as follows:

• 0 channels with any input: Audio omitted from the output

• 1, 2, or auto channels with no audio input: Audio omitted from the output

• 1 channel with any input with audio: One track with one channel, downmixed if necessary

• 2 channels with one track with one channel: One track with two identical channels

• 2 or auto channels with two tracks with one channel each: One track with two channels

• 2 or auto channels with one track with two channels: One track with two channels

• 2 channels with one track with multiple channels: One track with two channels

• auto channels with one track with one channel: One track with one channel

• auto channels with one track with multiple channels: One track with multiple channels

When you specify OneChannelPerTrack, Elastic Transcoder creates a new track for every channel in your output. Your output can have up to eight single-channel tracks.

The outputs of OneChannelPerTrack for a specific channel value and inputs are as follows:

• 0 channels with any input: Audio omitted from the output

• 1, 2, or auto channels with no audio input: Audio omitted from the output

• 1 channel with any input with audio: One track with one channel, downmixed if necessary

• 2 channels with one track with one channel: Two tracks with one identical channel each

• 2 or auto channels with two tracks with one channel each: Two tracks with one channel each

• 2 or auto channels with one track with two channels: Two tracks with one channel each

• 2 channels with one track with multiple channels: Two tracks with one channel each

• auto channels with one track with one channel: One track with one channel

• auto channels with one track with multiple channels: Up to eight tracks with one channel each

When you specify OneChannelPerTrackWithMosTo8Tracks, Elastic Transcoder creates eight single-channel tracks for your output. All tracks that do not contain audio data from an input channel are MOS, or Mit Out Sound, tracks.

The outputs of OneChannelPerTrackWithMosTo8Tracks for a specific channel value and inputs are as follows:

• 0 channels with any input: Audio omitted from the output

• 1, 2, or auto channels with no audio input: Audio omitted from the output

• 1 channel with any input with audio: One track with one channel, downmixed if necessary, plus six MOS tracks

• 2 channels with one track with one channel: Two tracks with one identical channel each, plus six MOS tracks

• 2 or auto channels with two tracks with one channel each: Two tracks with one channel each, plus six MOS tracks

• 2 or auto channels with one track with two channels: Two tracks with one channel each, plus six MOS tracks

• 2 channels with one track with multiple channels: Two tracks with one channel each, plus six MOS tracks

• auto channels with one track with one channel: One track with one channel, plus seven MOS tracks

• auto channels with one track with multiple channels: Up to eight tracks with one channel each, plus MOS tracks until there are eight tracks in all

Examples found in repository

src/json_deser.rs (lines 2537-2543)

pub(crate) fn deser_structure_crate_model_audio_parameters<'a, I>(
    tokens: &mut std::iter::Peekable<I>,
) -> Result<
    Option<crate::model::AudioParameters>,
    aws_smithy_json::deserialize::error::DeserializeError,
>
where
    I: Iterator<
        Item = Result<
            aws_smithy_json::deserialize::Token<'a>,
            aws_smithy_json::deserialize::error::DeserializeError,
        >,
    >,
{
    match tokens.next().transpose()? {
        Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
        Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
            #[allow(unused_mut)]
            let mut builder = crate::model::audio_parameters::Builder::default();
            loop {
                match tokens.next().transpose()? {
                    Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                    Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                        match key.to_unescaped()?.as_ref() {
                            "Codec" => {
                                builder = builder.set_codec(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "SampleRate" => {
                                builder = builder.set_sample_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "BitRate" => {
                                builder = builder.set_bit_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "Channels" => {
                                builder = builder.set_channels(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "AudioPackingMode" => {
                                builder = builder.set_audio_packing_mode(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "CodecOptions" => {
                                builder = builder.set_codec_options(
                                    crate::json_deser::deser_structure_crate_model_audio_codec_options(tokens)?
                                );
                            }
                            _ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
                        }
                    }
                    other => {
                        return Err(
                            aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                                "expected object key or end object, found: {:?}",
                                other
                            )),
                        )
                    }
                }
            }
            Ok(Some(builder.build()))
        }
        _ => Err(
            aws_smithy_json::deserialize::error::DeserializeError::custom(
                "expected start object or null",
            ),
        ),
    }
}

pub fn codec_options(self, input: AudioCodecOptions) -> Self

If you specified AAC for Audio:Codec, this is the AAC compression profile to use. Valid values include:

auto, AAC-LC, HE-AAC, HE-AACv2

If you specify auto, Elastic Transcoder chooses a profile based on the bit rate of the output file.

pub fn set_codec_options(self, input: Option<AudioCodecOptions>) -> Self

If you specified AAC for Audio:Codec, this is the AAC compression profile to use. Valid values include:

auto, AAC-LC, HE-AAC, HE-AACv2

If you specify auto, Elastic Transcoder chooses a profile based on the bit rate of the output file.

Examples found in repository

src/json_deser.rs (lines 2546-2548)

pub(crate) fn deser_structure_crate_model_audio_parameters<'a, I>(
    tokens: &mut std::iter::Peekable<I>,
) -> Result<
    Option<crate::model::AudioParameters>,
    aws_smithy_json::deserialize::error::DeserializeError,
>
where
    I: Iterator<
        Item = Result<
            aws_smithy_json::deserialize::Token<'a>,
            aws_smithy_json::deserialize::error::DeserializeError,
        >,
    >,
{
    match tokens.next().transpose()? {
        Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
        Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
            #[allow(unused_mut)]
            let mut builder = crate::model::audio_parameters::Builder::default();
            loop {
                match tokens.next().transpose()? {
                    Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                    Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                        match key.to_unescaped()?.as_ref() {
                            "Codec" => {
                                builder = builder.set_codec(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "SampleRate" => {
                                builder = builder.set_sample_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "BitRate" => {
                                builder = builder.set_bit_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "Channels" => {
                                builder = builder.set_channels(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "AudioPackingMode" => {
                                builder = builder.set_audio_packing_mode(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "CodecOptions" => {
                                builder = builder.set_codec_options(
                                    crate::json_deser::deser_structure_crate_model_audio_codec_options(tokens)?
                                );
                            }
                            _ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
                        }
                    }
                    other => {
                        return Err(
                            aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                                "expected object key or end object, found: {:?}",
                                other
                            )),
                        )
                    }
                }
            }
            Ok(Some(builder.build()))
        }
        _ => Err(
            aws_smithy_json::deserialize::error::DeserializeError::custom(
                "expected start object or null",
            ),
        ),
    }
}

pub fn build(self) -> AudioParameters

Consumes the builder and constructs a AudioParameters.

Examples found in repository

src/json_deser.rs (line 2563)

pub(crate) fn deser_structure_crate_model_audio_parameters<'a, I>(
    tokens: &mut std::iter::Peekable<I>,
) -> Result<
    Option<crate::model::AudioParameters>,
    aws_smithy_json::deserialize::error::DeserializeError,
>
where
    I: Iterator<
        Item = Result<
            aws_smithy_json::deserialize::Token<'a>,
            aws_smithy_json::deserialize::error::DeserializeError,
        >,
    >,
{
    match tokens.next().transpose()? {
        Some(aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
        Some(aws_smithy_json::deserialize::Token::StartObject { .. }) => {
            #[allow(unused_mut)]
            let mut builder = crate::model::audio_parameters::Builder::default();
            loop {
                match tokens.next().transpose()? {
                    Some(aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
                    Some(aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
                        match key.to_unescaped()?.as_ref() {
                            "Codec" => {
                                builder = builder.set_codec(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "SampleRate" => {
                                builder = builder.set_sample_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "BitRate" => {
                                builder = builder.set_bit_rate(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "Channels" => {
                                builder = builder.set_channels(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "AudioPackingMode" => {
                                builder = builder.set_audio_packing_mode(
                                    aws_smithy_json::deserialize::token::expect_string_or_null(
                                        tokens.next(),
                                    )?
                                    .map(|s| s.to_unescaped().map(|u| u.into_owned()))
                                    .transpose()?,
                                );
                            }
                            "CodecOptions" => {
                                builder = builder.set_codec_options(
                                    crate::json_deser::deser_structure_crate_model_audio_codec_options(tokens)?
                                );
                            }
                            _ => aws_smithy_json::deserialize::token::skip_value(tokens)?,
                        }
                    }
                    other => {
                        return Err(
                            aws_smithy_json::deserialize::error::DeserializeError::custom(format!(
                                "expected object key or end object, found: {:?}",
                                other
                            )),
                        )
                    }
                }
            }
            Ok(Some(builder.build()))
        }
        _ => Err(
            aws_smithy_json::deserialize::error::DeserializeError::custom(
                "expected start object or null",
            ),
        ),
    }
}

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Builder

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Builder

fn default() -> Builder

Returns the “default value” for a type.

impl PartialEq<Builder> for Builder

fn eq(&self, other: &Builder) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Builder