1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76
// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
/*!
Provides an asynchronous wrapper around the StreamProcessor API to encode/decode audio packets.
The main object to use is the StreamProcessor with either the `create_encoder` or `create_decoder` methods which are passed the input audio parameters and the
encoder settings to provide to the StreamProcessor for the encoder case. The `input_domain`
can be found as `fidl_fuchsia_media::DomainFormat` and it must be one of the Audio formats. The
`encoder_settings` is found as `fidl_fuchsia_media::EncoderSettings`.
After creating the encoder/decoder, audio input data can be provided either by using the StreamProcessor as an
`AsyncWrite` provider. The resulting audio is provided via the output stream which can
be acquired via the `StreamProcessor::take_output_stream` call.
# Example
```rust
let pcm_format = PcmFormat {
pcm_mode: AudioPcmMode::Linear,
bits_per_sample: 16,
frames_per_second: 44100,
channel_map: vec![AudioChannelId::Cf],
};
// Some sample SBC encoder settings.
let sbc_encoder_settings = EncoderSettings::Sbc(SbcEncoderSettings {
sub_bands,
block_count,
allocation: SbcAllocation::AllocLoudness,
channel_mode: SbcChannelMode::Mono,
bit_pool: 59,
});
// Read a WAV file into memory.
let mut raw_audio = Vec::new();
File::open("sample.wav")?.read_to_end(&mut raw_audio)?;
let encoder = StreamProcessor::create_encoder(pcm_format, sbc_encoder_settings);
// 44 bytes offset skips the RIFF header in the wav file.
// Delivering 16 audio frames at once that are 2 bytes each
for audio_frames in raw_audio[44..].chunks(2 * 16) {
encoder.write(&audio_frames).await?;
}
encoder.close()?;
let mut encoded_stream = encoder.take_encoded_stream();
let mut output_file = File::create("sample.sbc")?;
while let Some(data) = encoded_stream.try_next().await? {
output_file.write(&data)?;
}
output_file.close()?;
```
The output stream will begin producing data as soon as the StreamProcessor starts providing it -
the writing of the uncompressed data and the reading of the output stream can happen on separate
tasks.
*/
/// Interface to CodecFactory
pub mod stream_processor;
pub use stream_processor::{StreamProcessor, StreamProcessorOutputStream};
mod buffer_collection_constraints;
pub mod sysmem_allocator;