shadergraph 0.1.0

Create evolving artistic images with hot-code-reloaded Lisp and GLSL.
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

use std::path::Path;

use ffmpeg_next::{
    format::{
        input,
        Pixel,
    },
    media::Type,
    software::scaling::{
        context::Context,
        flag::Flags,
    },
    util::frame::video::Video,
};
use glium::{
    backend::Facade,
    texture::RawImage2d,
    Texture2d,
};

pub struct FrameStream {
    frames: Vec<Texture2d>,
    index:  usize,
}

impl FrameStream {
    pub fn new<F: Facade>(
        filename: &Path,
        width: u32,
        height: u32,
        facade: &F,
    ) -> Result<Self, Box<dyn std::error::Error>> {
        ffmpeg_next::init().unwrap();
        let mut ictx = input(&filename)?;

        let input = ictx.streams().best(Type::Video).expect("no video stream");
        let video_stream_index = input.index();
        let mut decoder = input.codec().decoder().video()?;

        let mut scaler = Context::get(
            decoder.format(),
            decoder.width(),
            decoder.height(),
            Pixel::RGB24,
            width,
            height,
            Flags::BILINEAR,
        )?;

        let mut frames = vec![];
        for (stream, packet) in ictx.packets() {
            if stream.index() == video_stream_index {
                decoder.send_packet(&packet)?;
                let mut decoded = Video::empty();
                while decoder.receive_frame(&mut decoded).is_ok() {
                    let mut rgb_frame = Video::empty();
                    scaler
                        .run(&decoded, &mut rgb_frame)
                        .expect("scaler failed");
                    let data = rgb_frame.data(0);
                    let raw_image = RawImage2d::from_raw_rgb_reversed(
                        data,
                        (width, height),
                    );
                    frames.push(Texture2d::new(facade, raw_image).unwrap());
                }
            }
        }
        decoder.send_eof()?;
        Ok(Self { frames, index: 0 })
    }

    pub fn next_frame(&mut self) -> &Texture2d {
        let frame = &self.frames[self.index % self.frames.len()];
        self.index += 1;
        frame
    }
}