unbundle 5.2.0

Unbundle media files - extract still frames, audio tracks, and subtitles from video files
Documentation 
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Parallel frame extraction integration tests (feature = "rayon").
//!
//! These tests require the `rayon` feature and test fixtures
//! generated by `tests/fixtures/generate_fixtures.sh`.

#![cfg(feature = "rayon")]

use std::path::Path;

use image::DynamicImage;
use unbundle::{ExtractOptions, FrameRange, MediaFile};

const SAMPLE_VIDEO: &str = "tests/fixtures/sample_video.mp4";

fn skip_unless(path: &str) -> bool {
    if !Path::new(path).exists() {
        eprintln!("Skipping: fixture {path} not found");
        return true;
    }
    false
}

#[test]
fn parallel_basic_consecutive() {
    if skip_unless(SAMPLE_VIDEO) {
        return;
    }

    let mut unbundler = MediaFile::open(SAMPLE_VIDEO).unwrap();
    let config = ExtractOptions::new();
    let frames = unbundler
        .video()
        .frames_parallel(FrameRange::Range(0, 9), &config)
        .unwrap();

    assert_eq!(frames.len(), 10);

    for frame in &frames {
        let frame: &DynamicImage = frame;
        assert!(frame.width() > 0);
        assert!(frame.height() > 0);
    }
}

#[test]
fn parallel_with_large_gaps() {
    if skip_unless(SAMPLE_VIDEO) {
        return;
    }

    let mut unbundler = MediaFile::open(SAMPLE_VIDEO).unwrap();
    let config = ExtractOptions::new();
    let frames = unbundler
        .video()
        .frames_parallel(FrameRange::Specific(vec![0, 1, 50, 51, 100, 101]), &config)
        .unwrap();

    assert_eq!(frames.len(), 6, "should extract all 6 requested frames");
}

#[test]
fn parallel_matches_sequential() {
    if skip_unless(SAMPLE_VIDEO) {
        return;
    }

    let target = vec![10u64, 11, 12];

    let mut unbundler = MediaFile::open(SAMPLE_VIDEO).unwrap();
    let parallel = unbundler
        .video()
        .frames_parallel(FrameRange::Specific(target.clone()), &ExtractOptions::new())
        .unwrap();

    let mut unbundler2 = MediaFile::open(SAMPLE_VIDEO).unwrap();
    let sequential = unbundler2
        .video()
        .frames(FrameRange::Specific(target))
        .unwrap();

    assert_eq!(parallel.len(), sequential.len());

    // Pixel-level comparison of the first frame.
    let p_img = parallel[0].to_rgb8();
    let s_img = sequential[0].to_rgb8();
    assert_eq!(p_img.dimensions(), s_img.dimensions());
    assert_eq!(
        p_img.as_raw(),
        s_img.as_raw(),
        "parallel and sequential output should be pixel-identical",
    );
}

#[test]
fn parallel_interval() {
    if skip_unless(SAMPLE_VIDEO) {
        return;
    }

    let mut unbundler = MediaFile::open(SAMPLE_VIDEO).unwrap();
    let config = ExtractOptions::new();
    let frames = unbundler
        .video()
        .frames_parallel(FrameRange::Interval(30), &config)
        .unwrap();

    // With a 30-fps, 5-second fixture we expect ~5 frames at interval=30.
    assert!(
        !frames.is_empty(),
        "interval extraction should return at least one frame",
    );
}

#[test]
fn parallel_from_open_url_source_input() {
    if skip_unless(SAMPLE_VIDEO) {
        return;
    }

    let mut unbundler = MediaFile::open_url(SAMPLE_VIDEO).unwrap();
    let frames = unbundler
        .video()
        .frames_parallel(
            FrameRange::Specific(vec![0, 15, 30]),
            &ExtractOptions::new(),
        )
        .unwrap();

    assert_eq!(frames.len(), 3);
    for frame in &frames {
        assert!(frame.width() > 0);
        assert!(frame.height() > 0);
    }
}