audio_encoder_test_lib/
pcm_audio.rs

1// Copyright 2019 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use byteorder::{ByteOrder, NativeEndian};
6use fidl_fuchsia_media::*;
7use itertools::Itertools;
8use stream_processor_test::*;
9
10const PCM_SAMPLE_SIZE: usize = 2;
11const PCM_MIME_TYPE: &str = "audio/pcm";
12
13#[derive(Clone, Debug)]
14pub struct PcmAudio {
15    pcm_format: PcmFormat,
16    buffer: Vec<u8>,
17}
18
19impl PcmAudio {
20    pub fn create_saw_wave(pcm_format: PcmFormat, frame_count: usize) -> Self {
21        const FREQUENCY: f32 = 20.0;
22        const AMPLITUDE: f32 = 0.2;
23
24        let pcm_frame_size = PCM_SAMPLE_SIZE * pcm_format.channel_map.len();
25        let samples_per_frame = pcm_format.channel_map.len();
26        let sample_count = frame_count * samples_per_frame;
27
28        let mut buffer = vec![0; frame_count * pcm_frame_size];
29
30        for i in 0..sample_count {
31            let frame = (i / samples_per_frame) as f32;
32            let value =
33                ((frame * FREQUENCY / (pcm_format.frames_per_second as f32)) % 1.0) * AMPLITUDE;
34            let sample = (value * i16::max_value() as f32) as i16;
35
36            let mut sample_bytes = [0; std::mem::size_of::<i16>()];
37            NativeEndian::write_i16(&mut sample_bytes, sample);
38
39            let offset = i * PCM_SAMPLE_SIZE;
40            buffer[offset] = sample_bytes[0];
41            buffer[offset + 1] = sample_bytes[1];
42        }
43
44        Self { pcm_format, buffer }
45    }
46
47    pub fn create_from_data(pcm_format: PcmFormat, raw_data: &[i16]) -> Self {
48        Self {
49            pcm_format,
50            buffer: raw_data.iter().flat_map(|pcm_sample| pcm_sample.to_ne_bytes()).collect(),
51        }
52    }
53
54    pub fn frame_size(&self) -> usize {
55        self.pcm_format.channel_map.len() * PCM_SAMPLE_SIZE
56    }
57}
58
59/// Generates timestamps according to a timebase and rate of playback of uncompressed audio.
60///
61/// Since the rate is constant, this can also be used to extrapolate timestamps.
62pub struct TimestampGenerator {
63    bytes_per_second: usize,
64    timebase: u64,
65}
66
67impl TimestampGenerator {
68    pub fn timestamp_at(&self, input_index: usize) -> u64 {
69        let bps = self.bytes_per_second as u64;
70        (input_index as u64) * self.timebase / bps
71    }
72}
73
74pub struct PcmAudioStream<I> {
75    pub pcm_audio: PcmAudio,
76    pub encoder_settings: EncoderSettings,
77    pub frames_per_packet: I,
78    pub timebase: Option<u64>,
79}
80
81impl<I> PcmAudioStream<I>
82where
83    I: Iterator<Item = usize> + Clone,
84{
85    pub fn bytes_per_second(&self) -> usize {
86        self.pcm_audio.pcm_format.frames_per_second as usize
87            * std::mem::size_of::<i16>()
88            * self.pcm_audio.pcm_format.channel_map.len()
89    }
90
91    pub fn timestamp_generator(&self) -> Option<TimestampGenerator> {
92        self.timebase.map(|timebase| TimestampGenerator {
93            bytes_per_second: self.bytes_per_second(),
94            timebase,
95        })
96    }
97}
98
99impl<I> ElementaryStream for PcmAudioStream<I>
100where
101    I: Iterator<Item = usize> + Clone,
102{
103    fn format_details(&self, format_details_version_ordinal: u64) -> FormatDetails {
104        FormatDetails {
105            domain: Some(DomainFormat::Audio(AudioFormat::Uncompressed(
106                AudioUncompressedFormat::Pcm(self.pcm_audio.pcm_format.clone()),
107            ))),
108            encoder_settings: Some(self.encoder_settings.clone()),
109            format_details_version_ordinal: Some(format_details_version_ordinal),
110            mime_type: Some(String::from(PCM_MIME_TYPE)),
111            oob_bytes: None,
112            pass_through_parameters: None,
113            timebase: self.timebase,
114            ..Default::default()
115        }
116    }
117
118    fn is_access_units(&self) -> bool {
119        false
120    }
121
122    fn stream<'a>(&'a self) -> Box<dyn Iterator<Item = ElementaryStreamChunk> + 'a> {
123        let data = self.pcm_audio.buffer.as_slice();
124        let frame_size = self.pcm_audio.frame_size();
125        let mut offset = 0;
126        let mut frames_per_packet = self.frames_per_packet.clone();
127
128        let chunks = (0..)
129            .map(move |_| {
130                let number_of_frames_for_this_packet = frames_per_packet.next()?;
131                let payload_size = number_of_frames_for_this_packet * frame_size;
132                let payload_size = data
133                    .len()
134                    .checked_sub(offset)
135                    .map(|remaining_bytes| std::cmp::min(remaining_bytes, payload_size))
136                    .filter(|payload_size| *payload_size > 0)?;
137
138                let range = offset..(offset + payload_size);
139                let result = data.get(range).map(|range| (offset, range))?;
140                offset += payload_size;
141
142                Some(result)
143            })
144            .while_some();
145        Box::new(chunks.map(move |(input_index, data)| {
146            ElementaryStreamChunk {
147                start_access_unit: false,
148                known_end_access_unit: false,
149                data: data.to_vec(),
150                significance: Significance::Audio(AudioSignificance::PcmFrames),
151                timestamp: self
152                    .timestamp_generator()
153                    .as_ref()
154                    .map(|timestamp_generator| timestamp_generator.timestamp_at(input_index)),
155            }
156        }))
157    }
158}
159
160#[cfg(test)]
161mod test {
162    use super::*;
163
164    // Settings are arbitrary; we just need to construct an instance.
165    const DUMMY_ENCODER_SETTINGS: EncoderSettings = EncoderSettings::Sbc(SbcEncoderSettings {
166        sub_bands: SbcSubBands::SubBands8,
167        allocation: SbcAllocation::AllocLoudness,
168        block_count: SbcBlockCount::BlockCount16,
169        channel_mode: SbcChannelMode::JointStereo,
170        bit_pool: 59,
171    });
172
173    #[fuchsia::test]
174    fn elementary_chunk_data() {
175        let pcm_format = PcmFormat {
176            pcm_mode: AudioPcmMode::Linear,
177            bits_per_sample: 16,
178            frames_per_second: 44100,
179            channel_map: vec![AudioChannelId::Lf, AudioChannelId::Rf],
180        };
181        let pcm_audio = PcmAudio::create_saw_wave(pcm_format, /*frame_count=*/ 100);
182
183        let stream = PcmAudioStream {
184            pcm_audio: pcm_audio.clone(),
185            encoder_settings: DUMMY_ENCODER_SETTINGS,
186            frames_per_packet: (0..).map(|_| 40),
187            timebase: None,
188        };
189
190        let actual: Vec<u8> = stream.stream().flat_map(|chunk| chunk.data.clone()).collect();
191        assert_eq!(pcm_audio.buffer, actual);
192    }
193
194    #[fuchsia::test]
195    fn saw_wave_matches_hash() {
196        use hex;
197        use mundane::hash::*;
198
199        /// This was obtained by writing the buffer out to file and inspecting the wave on each channel.
200        const GOLDEN_DIGEST: &str =
201            "2bf4f233a179f0cb572b72570a28c07a334e406baa7fb4fc65f641b82d0ae64a";
202
203        let pcm_audio = PcmAudio::create_saw_wave(
204            PcmFormat {
205                pcm_mode: AudioPcmMode::Linear,
206                bits_per_sample: 16,
207                frames_per_second: 44100,
208                channel_map: vec![AudioChannelId::Lf, AudioChannelId::Rf],
209            },
210            /*frame_count=*/ 50000,
211        );
212
213        let actual_digest = hex::encode(Sha256::hash(&pcm_audio.buffer).bytes());
214        assert_eq!(&actual_digest, GOLDEN_DIGEST);
215    }
216
217    #[fuchsia::test]
218    fn stream_timestamps() {
219        let pcm_format = PcmFormat {
220            pcm_mode: AudioPcmMode::Linear,
221            bits_per_sample: 16,
222            frames_per_second: 50,
223            channel_map: vec![AudioChannelId::Lf, AudioChannelId::Rf],
224        };
225        let pcm_audio = PcmAudio::create_saw_wave(pcm_format, /*frame_count=*/ 100);
226
227        let stream = PcmAudioStream {
228            pcm_audio: pcm_audio.clone(),
229            encoder_settings: DUMMY_ENCODER_SETTINGS,
230            frames_per_packet: (0..).map(|_| 50),
231            timebase: Some(zx::MonotonicDuration::from_seconds(1).into_nanos() as u64),
232        };
233
234        let mut chunks = stream.stream();
235
236        assert_eq!(chunks.next().and_then(|chunk| chunk.timestamp), Some(0));
237        assert_eq!(
238            chunks.next().and_then(|chunk| chunk.timestamp),
239            Some(zx::MonotonicDuration::from_seconds(1).into_nanos() as u64)
240        );
241    }
242}
audio_encoder_test_lib/pcm_audio.rs

audio_encoder_test_lib/
pcm_audio.rs
