Struct MSEncoder 

pub struct MSEncoder { /* private fields */ }

Combine individual Opus streams in a single packet, up to 255 channels.

See Opus docs.

Implementations

impl MSEncoder

pub fn new( sample_rate: u32, streams: u8, coupled_streams: u8, mapping: &[u8], application: Application, ) -> Result<MSEncoder>

Create and initialize a multistream encoder.

pub fn new_surround( sample_rate: u32, channels: u8, mapping_family: i32, application: Application, ) -> Result<SurroundEncoder>

Create and initialize a multistream encoder for surround sound.

This is a convenience function that automatically determines the optimal stream configuration based on the number of channels and mapping family. It eliminates the need to manually calculate the number of streams, coupled streams, and channel mapping.

Arguments

• sample_rate - Sampling rate of input signal (Hz). Must be one of 8000, 12000, 16000, 24000, or 48000.
• channels - Number of channels in the input signal. This must be at most 255.
• mapping_family - Mapping family for the surround configuration:
  • 0: Mono or stereo (1 or 2 channels)
  • 1: Vorbis channel order for up to 8 channels
  • 255: No predefined channel ordering (up to 255 channels)
• application - The application type (Voip, Audio, or LowDelay)

Returns

Returns a SurroundEncoder containing the initialized encoder and its automatically determined stream configuration.

Examples found in repository

examples/surround.rs (line 5)

fn main() {
    // The new struct-based API is much more readable!
    let surround = MSEncoder::new_surround(48000, 6, 1, Application::Audio)
        .expect("Failed to create surround encoder");

    println!("=== Surround Encoder Configuration ===");
    println!("Streams: {}", surround.streams);
    println!("Coupled streams: {}", surround.coupled_streams);
    println!("Channel mapping: {:?}", surround.mapping);

    // You can destructure if you want specific fields
    let opus2::SurroundEncoder {
        encoder: _encoder,
        streams,
        coupled_streams,
        mapping,
    } = surround;

    println!("\n=== Destructured Values ===");
    println!("Streams: {}", streams);
    println!("Coupled streams: {}", coupled_streams);
    println!("Mapping: {:?}", mapping);

    // Now you can use the encoder for encoding
    // encoder.encode(...);
    
    println!("\nEncoder is ready for use!");
}

pub fn encode(&mut self, input: &[i16], output: &mut [u8]) -> Result<usize>

Encode an Opus frame.

pub fn encode_float( &mut self, input: &[f32], output: &mut [u8], ) -> Result<usize>

Encode an Opus frame from floating point input.

pub fn encode_vec(&mut self, input: &[i16], max_size: usize) -> Result<Vec<u8>>

Encode an Opus frame to a new buffer.

pub fn encode_vec_float( &mut self, input: &[f32], max_size: usize, ) -> Result<Vec<u8>>

Encode an Opus frame from floating point input to a new buffer.

impl MSEncoder

Generic CTLs. See Opus docs.

pub fn reset_state(&mut self) -> Result<()>

Reset the codec state to be equivalent to a freshly initialized state.

pub fn get_final_range(&mut self) -> Result<u32>

Get the final range of the codec’s entropy coder.

pub fn get_bandwidth(&mut self) -> Result<Bandwidth>

Get the encoder’s configured bandpass.

pub fn get_sample_rate(&mut self) -> Result<u32>

Get the samping rate the encoder was intialized with.

pub fn set_phase_inversion_disabled(&mut self, disabled: bool) -> Result<()>

If set to true, disables the use of phase inversion for intensity stereo.

pub fn get_phase_inversion_disabled(&mut self) -> Result<bool>

Get the encoder’s configured phase inversion status.

pub fn get_in_dtx(&mut self) -> Result<bool>

Get the DTX state of the encoder.

impl MSEncoder

Encoder CTLs. See Opus docs.

pub fn set_complexity(&mut self, value: i32) -> Result<()>

Configures the encoder’s computational complexity.

pub fn get_complexity(&mut self) -> Result<i32>

Gets the encoder’s complexity configuration.

pub fn set_bitrate(&mut self, value: Bitrate) -> Result<()>

Set the encoder’s bitrate.

pub fn get_bitrate(&mut self) -> Result<Bitrate>

Get the encoder’s bitrate.

pub fn set_vbr(&mut self, vbr: bool) -> Result<()>

Enable or disable variable bitrate.

pub fn get_vbr(&mut self) -> Result<bool>

Determine if variable bitrate is enabled.

pub fn set_vbr_constraint(&mut self, vbr: bool) -> Result<()>

Enable or disable constrained VBR.

pub fn get_vbr_constraint(&mut self) -> Result<bool>

Determine if constrained VBR is enabled.

pub fn set_force_channels(&mut self, value: Option<Channels>) -> Result<()>

Configures mono/stereo forcing in the encoder.

This can force the encoder to produce packets encoded as either mono or stereo, regardless of the format of the input audio. This is useful when the caller knows that the input signal is currently a mono source embedded in a stereo stream.

pub fn get_force_channels(&mut self) -> Result<Option<Channels>>

Gets the encoder’s forced channel configuration.

pub fn set_max_bandwidth(&mut self, bandwidth: Bandwidth) -> Result<()>

Configure the maximum bandpass that the encoder will select automatically.

pub fn get_max_bandwidth(&mut self) -> Result<Bandwidth>

Get the encoder’s configured maximum allowed bandpass.

pub fn set_bandwidth(&mut self, bandwidth: Bandwidth) -> Result<()>

Set the encoder’s bandpass to a specific value.

pub fn set_signal(&mut self, signal: Signal) -> Result<()>

Configure the type of signal being encoded.

pub fn get_signal(&mut self) -> Result<Signal>

Gets the encoder’s configured signal type.

pub fn set_application(&mut self, application: Application) -> Result<()>

Configure the encoder’s intended application.

pub fn get_application(&mut self) -> Result<Application>

Get the encoder’s configured application.

pub fn get_lookahead(&mut self) -> Result<i32>

Gets the total samples of delay added by the entire codec.

pub fn set_inband_fec(&mut self, value: bool) -> Result<()>

Configures the encoder’s use of inband forward error correction (FEC).

pub fn get_inband_fec(&mut self) -> Result<bool>

Gets encoder’s configured use of inband forward error correction.

pub fn set_packet_loss_perc(&mut self, value: i32) -> Result<()>

Sets the encoder’s expected packet loss percentage.

pub fn get_packet_loss_perc(&mut self) -> Result<i32>

Gets the encoder’s expected packet loss percentage.

pub fn set_dtx(&mut self, value: bool) -> Result<()>

Configures the encoder’s use of discontinuous transmission (DTX).

pub fn get_dtx(&mut self) -> Result<bool>

Gets encoder’s configured use of discontinuous transmission (DTX).

pub fn set_lsb_depth(&mut self, depth: i32) -> Result<()>

Configures the depth of signal being encoded.

Depth should be between 8 and 24 inclusive.

pub fn get_lsb_depth(&mut self) -> Result<i32>

Gets the encoder’s configured signal depth.

pub fn set_expert_frame_duration(&mut self, framesize: FrameSize) -> Result<()>

Configures the encoder’s use of variable duration frames.

Do not use this option unless you really know what you are doing.

pub fn get_expert_frame_duration(&mut self) -> Result<FrameSize>

Gets the encoder’s configured use of variable duration frames.

pub fn set_prediction_disabled(&mut self, disabled: bool) -> Result<()>

If set to true, disables almost all use of prediction, making frames almost completely independent.

pub fn get_prediction_disabled(&mut self) -> Result<bool>

Gets the encoder’s configured prediction status.

pub fn set_dred_duration(&mut self, duration_ms: i32) -> Result<()>

Set the DRED duration in milliseconds.

The duration must be between 0 and 20000 (20 seconds). DRED (Deep REDundancy) provides additional redundancy information that can be used for packet loss recovery. This feature is available since Opus 1.5.

pub fn get_dred_duration(&mut self) -> Result<i32>

Get the configured DRED duration in milliseconds.

DRED (Deep REDundancy) provides additional redundancy information that can be used for packet loss recovery. This feature is available since Opus 1.5.

pub fn set_dnn_blob(&mut self, blob: &[u8]) -> Result<()>

Set a DNN (Deep Neural Network) model blob for the encoder.

This allows loading custom neural network models for enhanced encoding. The blob should contain a trained DNN model in the format expected by libopus. This feature is available since Opus 1.5.

Trait Implementations

impl Debug for MSEncoder

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

Formats the value using the given formatter.

impl Drop for MSEncoder

fn drop(&mut self)

Executes the destructor for this type.

impl Send for MSEncoder