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
79
80
81
82
83
84
85
86
87
88

//! Helper functions to get metadata from the video files.
//!

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

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

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

/// Detects the video metadata for the given file.
pub fn get_metadata(_path: impl AsRef<Path>) -> Result<MetadataVideo, 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 video stream
    //         let stream = context
    //             .streams()
    //             .best(ffmpeg::media::Type::Video)
    //             .ok_or(OxenError::basic_str("Could not grab video stream"))?;

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

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

    //         Ok(MetadataVideo {
    //             width: video.width() as usize,
    //             height: video.height() as usize,
    //             color_space: ffmpg_to_colorspace(&video.format()), // RGB, RGBA, etc.
    //             num_seconds: duration,
    //             format: context.format().name().to_string(), // mp4, etc.
    //         })
    //     }
    //     Err(err) => {
    //         let err = format!("Could not get video metadata {:?}", err);
    //         Err(OxenError::basic_str(err))
    //     }
    // }
    Err(OxenError::basic_str("todo: implement"))
}

// fn ffmpg_to_colorspace(format: &ffmpeg::util::format::pixel::Pixel) -> ImgColorSpace {
//     println!("ffmpeg colorspace: {:?}", format);
//     match format {
//         ffmpeg::util::format::pixel::Pixel::RGBA => ImgColorSpace::RGBA,
//         ffmpeg::util::format::pixel::Pixel::GRAY8 => ImgColorSpace::Grayscale,
//         _ => ImgColorSpace::Unknown,
//     }
// }

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

//     use approx::assert_relative_eq;

//     #[test]
//     fn test_get_metadata_video_mp4() {
//         let file = test::test_video_file_with_name("basketball.mp4");
//         let metadata = api::local::metadata::get(file).unwrap();
//         println!("metadata: {:?}", metadata);

//         assert_eq!(metadata.size, 23599);
//         assert_eq!(metadata.data_type, EntryDataType::Video);
//         assert_eq!(metadata.mime_type, "video/mp4");

//         assert!(metadata.meta.video.is_some());
//         let meta = metadata.meta.video.unwrap();
//         assert_eq!(meta.width, 128);
//         assert_eq!(meta.height, 176);
//         assert_relative_eq!(meta.num_seconds, 1.6);
//     }
// }