Fastest way to read in audio file

[obsoleszenz]

I have a function that takes a path and loads the whole audio file into a Vec<Vec; 2>. I hope to be able to make it faster, as currently it takes couple of seconds to load a file.

1. To avoid resizing of the Vec<> I'm trying to allocate it with the correct size
2. I simply loop over the packets and decode it into SampleBuffer, the copy it to the right point in the Vec<>.

Currently it looks like this:

#[derive(Clone)]
pub struct Samples {
    pub samples: Arc<Vec<Vec<f32>>>,
    pub rate: usize,
    pub count_samples: usize,
}

/// Load a whole audio file into memory
pub fn load_samples_from_audio_file(path: &str) -> Result<Samples, symphonia::core::errors::Error> {
    // Open the media source.
    let path = Path::new(&path);
    let src = File::open(path).expect("failed to open media");

    // Create the media source stream.
    let mss = MediaSourceStream::new(Box::new(src), Default::default());

    // Create a probe hint using the file's extension. [Optional]
    let mut hint = Hint::new();
    if let Some(extension) = path.extension() {
        hint.with_extension(&extension.to_string_lossy());
    };

    // Probe the media source.
    let probed = symphonia::default::get_probe()
        .format(&hint, mss, &Default::default(), &Default::default())
        .expect("unsupported format");

    // Get the instantiated format reader.
    let mut format = probed.format;

    // Find the first audio track with a known (decodeable) codec.
    let track = format
        .tracks()
        .iter()
        .find(|t| t.codec_params.codec != CODEC_TYPE_NULL)
        .expect("no supported audio tracks");

    // Use the default options for the decoder.
    let dec_opts: DecoderOptions = Default::default();

    // Calculate the needed size for our sample vector
    // We do this now as we will borrow track in the decoder
    let samples_capacity: usize = if let Some(n_frames) = track.codec_params.n_frames {
        n_frames as usize
    } else {
        0
    };

    // Create a decoder for the track.
    let mut decoder = symphonia::default::get_codecs()
        .make(&track.codec_params, &dec_opts)
        .expect("unsupported codec");

    // Create sample buffer and retrieve sample rate
    let (mut read_buffer, rate) = {
        // Read first packet and determine sample buffer size
        let packet = format.next_packet()?;
        let decoded_packet = decoder.decode(&packet)?;
        let spec = *decoded_packet.spec();
        let rate = spec.rate as usize;

        // Get the capacity of the decoded buffer. Note: This is capacity, not length!
        let duration = decoded_packet.capacity() as u64;

        let mut read_buffer = SampleBuffer::<f32>::new(duration, spec);

        // As we loaded the first packet, let's also put it into the sample buffer
        read_buffer.copy_planar_ref(decoded_packet);
        (read_buffer, rate)
    };

    // Create vector that will hold all samples
    let mut samples: Vec<Vec<f32>> = vec![Vec::with_capacity(samples_capacity); 2];

    loop {
        // extract left & right channel
        let (left, right) = read_buffer.samples().split_at(read_buffer.len() / 2);
        samples[0].extend_from_slice(left);
        samples[1].extend_from_slice(right);

        // Decode next packet
        let packet = match format.next_packet() {
            Ok(packet) => packet,
            Err(_err) => {
                error!("Err loading next packet: {}", _err);
                break;
            }
        };
        let decoded_packet = match decoder.decode(&packet) {
            Ok(decoded_packet) => decoded_packet,
            Err(_err) => {
                error!("Err decoding next packet: {}", _err);
                break;
            }
        };

        // Copy decoded packet into read buffer
        read_buffer.copy_planar_ref(decoded_packet);
    }

    debug!("Precalculated sample count: {}", samples_capacity);
    debug!("Sample count: {}", samples[0].len());
    let count_samples = samples[0].len();
    Ok(Samples {
        samples: Arc::new(samples),
        rate,
        count_samples,
    })
}