ff-decode 0.13.0

Video and audio decoding - the Rust way
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

//! Integration tests for `Iterator` and `FusedIterator` on `VideoDecoder` and
//! `AudioDecoder`.

mod fixtures;
use fixtures::*;

// ============================================================================
// Compile-time trait-bound checks
// ============================================================================

fn _assert_video_fused(_: impl std::iter::FusedIterator) {}
fn _assert_audio_fused(_: impl std::iter::FusedIterator) {}

// ============================================================================
// VideoDecoder Iterator tests
// ============================================================================

#[test]
fn video_iterator_should_yield_frames_until_eof() {
    let mut decoder = match create_decoder() {
        Ok(d) => d,
        Err(e) => {
            println!("Skipping: {e}");
            return;
        }
    };

    let mut count = 0u64;
    for result in &mut decoder {
        match result {
            Ok(_) => count += 1,
            Err(e) => panic!("Unexpected decode error: {e}"),
        }
    }

    assert!(count > 0, "Expected at least one video frame");
}

#[test]
fn video_iterator_should_support_take_adapter() {
    let mut decoder = match create_decoder() {
        Ok(d) => d,
        Err(e) => {
            println!("Skipping: {e}");
            return;
        }
    };

    let frames: Vec<_> = decoder
        .by_ref()
        .take(5)
        .collect::<Result<Vec<_>, _>>()
        .expect("Failed to decode frames");

    assert_eq!(frames.len(), 5, "take(5) should yield exactly 5 frames");
}

#[test]
fn video_iterator_should_return_none_after_eof() {
    let mut decoder = match create_decoder() {
        Ok(d) => d,
        Err(e) => {
            println!("Skipping: {e}");
            return;
        }
    };

    // Drain all frames
    for result in &mut decoder {
        result.expect("Unexpected decode error while draining");
    }

    assert!(decoder.is_eof(), "Decoder should report EOF");

    // FusedIterator: subsequent next() calls must return None
    assert!(
        decoder.next().is_none(),
        "next() after EOF should return None (first call)"
    );
    assert!(
        decoder.next().is_none(),
        "next() after EOF should return None (second call)"
    );
}

// ============================================================================
// AudioDecoder Iterator tests
// ============================================================================

#[test]
fn audio_iterator_should_yield_frames_until_eof() {
    let mut decoder = match create_audio_decoder() {
        Ok(d) => d,
        Err(e) => {
            println!("Skipping: {e}");
            return;
        }
    };

    let mut count = 0u64;
    for result in &mut decoder {
        match result {
            Ok(_) => count += 1,
            Err(e) => panic!("Unexpected decode error: {e}"),
        }
    }

    assert!(count > 0, "Expected at least one audio frame");
}

#[test]
fn audio_iterator_should_support_take_adapter() {
    let mut decoder = match create_audio_decoder() {
        Ok(d) => d,
        Err(e) => {
            println!("Skipping: {e}");
            return;
        }
    };

    let frames: Vec<_> = decoder
        .by_ref()
        .take(10)
        .collect::<Result<Vec<_>, _>>()
        .expect("Failed to decode audio frames");

    assert_eq!(frames.len(), 10, "take(10) should yield exactly 10 frames");
}

#[test]
fn audio_iterator_collect_should_return_all_frames() {
    let mut decoder = match create_audio_decoder() {
        Ok(d) => d,
        Err(e) => {
            println!("Skipping: {e}");
            return;
        }
    };

    let frames: Vec<_> = decoder
        .by_ref()
        .collect::<Result<Vec<_>, _>>()
        .expect("Failed to collect audio frames");

    assert!(!frames.is_empty(), "Expected at least one audio frame");

    // FusedIterator: next() after collection must return None
    assert!(
        decoder.next().is_none(),
        "next() after collect should return None"
    );
}