vp9-parser 0.3.2

Provides tools to parse VP9 bitstreams and IVF containers.
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

use std::fs::File;

use vp9_parser::{
    ivf::{Frame, Ivf},
    ColorDepth, ColorRange, ColorSpace, FrameType, Profile, Subsampling, Vp9Parser,
};

#[test]
pub fn parse_ivf() {
    let file = File::open("tests/data/320-24-crf.ivf").unwrap();
    let mut ivf = Ivf::new(file).unwrap();

    assert_eq!(ivf.width(), 320);
    assert_eq!(ivf.height(), 180);
    assert_eq!(ivf.frame_rate_rate(), 24);
    assert_eq!(ivf.frame_rate_scale(), 1);
    assert_eq!(ivf.frame_count(), 24);

    let mut first = true;

    let mut count = 0;
    while let Some(frame) = ivf.read_frame().unwrap() {
        if first {
            assert_eq!(frame.timestamp, 0);
            first = false;
        } else {
            assert_ne!(frame.timestamp, 0);
        }

        assert_ne!(frame.packet.len(), 0);
        count += 1;
    }

    assert_eq!(count, 24);
}

#[test]
pub fn parse_vp9_frames_and_super_frames() {
    // 320-24-cq.ivf contains super frames with reference frames.
    let file = File::open("tests/data/320-24-cq.ivf").unwrap();
    let mut ivf = Ivf::new(file).unwrap();
    let mut parser = Vp9Parser::default();

    let mut intra_frames = 0;
    let mut key_frames = 0;

    let mut last_frame_type = FrameType::NonKeyFrame;
    while let Some(ivf_frame) = ivf.read_frame().unwrap() {
        let Frame {
            timestamp: _timestamp,
            packet,
        } = ivf_frame;

        let frames = parser.parse_packet(packet).unwrap();
        for frame in frames.iter() {
            assert_ne!(frame.compressed_header_data().len(), 0);
            assert_ne!(frame.compressed_header_and_tile_data().len(), 0);
            assert_ne!(frame.tile_data().len(), 0);
            assert_eq!(frame.profile(), Profile::Profile0);
            assert_eq!(frame.color_depth(), ColorDepth::Depth8);
            assert_eq!(frame.color_range(), ColorRange::StudioSwing);
            assert_eq!(frame.color_space(), ColorSpace::Bt709);
            assert_eq!(frame.subsampling(), Subsampling::Yuv420);
            assert!(!frame.show_existing_frame());
            assert!(frame.frame_to_show_map_idx().is_none());
            assert_eq!(frame.last_frame_type(), last_frame_type);
            last_frame_type = frame.frame_type();

            if frame.frame_type() == FrameType::KeyFrame {
                key_frames += 1;
            }

            assert!(!frame.error_resilient_mode());
            if frame.intra_only() {
                intra_frames += 1;
            }
        }

        assert_eq!(key_frames, 1);
        assert_eq!(intra_frames, 0);
    }
}

#[test]
pub fn parse_vp9_10bit() {
    let file = File::open("tests/data/320-444-10bit.ivf").unwrap();
    let mut ivf = Ivf::new(file).unwrap();
    let mut parser = Vp9Parser::default();

    let mut last_frame_type = FrameType::NonKeyFrame;
    while let Some(ivf_frame) = ivf.read_frame().unwrap() {
        let Frame {
            timestamp: _timestamp,
            packet,
        } = ivf_frame;

        let frames = parser.parse_packet(packet).unwrap();
        for frame in frames.iter() {
            assert_ne!(frame.compressed_header_data().len(), 0);
            assert_ne!(frame.compressed_header_and_tile_data().len(), 0);
            assert_ne!(frame.tile_data().len(), 0);
            assert_eq!(frame.profile(), Profile::Profile3);
            assert_eq!(frame.color_depth(), ColorDepth::Depth10);
            assert_eq!(frame.color_range(), ColorRange::StudioSwing);
            assert_eq!(frame.color_space(), ColorSpace::Bt709);
            assert_eq!(frame.subsampling(), Subsampling::Yuv444);
            assert!(!frame.show_existing_frame());
            assert!(frame.frame_to_show_map_idx().is_none());
            assert_eq!(frame.last_frame_type(), last_frame_type);
            last_frame_type = frame.frame_type();
        }
    }
}

#[test]
pub fn parse_vp9_12bit() {
    let file = File::open("tests/data/320-444-12bit.ivf").unwrap();
    let mut ivf = Ivf::new(file).unwrap();
    let mut parser = Vp9Parser::default();

    let mut last_frame_type = FrameType::NonKeyFrame;
    while let Some(ivf_frame) = ivf.read_frame().unwrap() {
        let Frame {
            timestamp: _timestamp,
            packet,
        } = ivf_frame;

        let frames = parser.parse_packet(packet).unwrap();
        for frame in frames.iter() {
            assert_ne!(frame.compressed_header_data().len(), 0);
            assert_ne!(frame.compressed_header_and_tile_data().len(), 0);
            assert_ne!(frame.tile_data().len(), 0);
            assert_eq!(frame.profile(), Profile::Profile3);
            assert_eq!(frame.color_depth(), ColorDepth::Depth12);
            assert_eq!(frame.color_range(), ColorRange::StudioSwing);
            assert_eq!(frame.color_space(), ColorSpace::Bt709);
            assert_eq!(frame.subsampling(), Subsampling::Yuv444);
            assert!(!frame.show_existing_frame());
            assert!(frame.frame_to_show_map_idx().is_none());
            assert_eq!(frame.last_frame_type(), last_frame_type);
            last_frame_type = frame.frame_type();
        }
    }
}