liboxen 0.7.2

Oxen is a fast, unstructured data version control, to help version large machine learning datasets written in Rust.
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
77
78

//! Helper functions to get metadata from audio files.
//!

use crate::error::OxenError;
use crate::model::entry::metadata_entry::MetadataAudio;

use std::path::Path;
// use std::sync::Once;

// static START: Once = Once::new();

/// Detects the audio metadata for the given file.
pub fn get_metadata(_path: impl AsRef<Path>) -> Result<MetadataAudio, OxenError> {
    // START.call_once(|| match ffmpeg::init() {
    //     Ok(_) => {}
    //     Err(err) => {
    //         log::error!("Could not initialize ffmpeg {:?}", err);
    //     }
    // });

    // match ffmpeg::format::input(&path) {
    //     Ok(context) => {
    //         let duration = context.duration() as f64 / f64::from(ffmpeg::ffi::AV_TIME_BASE);

    //         // for now just grab the best audio stream
    //         let stream = context
    //             .streams()
    //             .best(ffmpeg::media::Type::Audio)
    //             .ok_or(OxenError::basic_str("Could not grab audio stream"))?;

    //         let codec = ffmpeg::codec::context::Context::from_parameters(stream.parameters())
    //             .map_err(|_| OxenError::basic_str("Could not grab audio codec"))?;

    //         let audio = codec
    //             .decoder()
    //             .audio()
    //             .map_err(|_| OxenError::basic_str("Could not grab audio decoder"))?;

    //         Ok(MetadataAudio {
    //             num_seconds: duration,
    //             format: "mp3".to_string(), // mp3, etc.
    //             num_channels: audio.channels() as usize,
    //             sample_rate: audio.rate() as usize,
    //         })
    //     }
    //     Err(err) => {
    //         let err = format!("Could not get audio metadata {:?}", err);
    //         Err(OxenError::basic_str(err))
    //     }
    // }
    Err(OxenError::basic_str("todo: implement"))
}

// #[cfg(test)]
// mod tests {
//     use crate::api;
//     use crate::model::EntryDataType;
//     use crate::test;
//     use approx::assert_relative_eq;

//     #[test]
//     fn test_get_metadata_audio_flac() {
//         let file = test::test_audio_file_with_name("121-121726-0005.flac");
//         let metadata = api::local::metadata::get(file).unwrap();

//         println!("metadata: {:?}", metadata);

//         assert_eq!(metadata.size, 37096);
//         assert_eq!(metadata.data_type, EntryDataType::Audio);
//         assert_eq!(metadata.mime_type, "audio/x-flac");

//         assert!(metadata.meta.audio.is_some());
//         let meta = metadata.meta.audio.unwrap();
//         assert_eq!(meta.num_channels, 1);
//         assert_eq!(meta.sample_rate, 16000);
//         assert_relative_eq!(meta.num_seconds, 3.10);
//     }
// }