Added early spritesheet generation

src/ffmpeg_api/api.rs

@@ -36,17 +36,30 @@ impl<'a> AVFormatContext {
     }
 
     pub fn streams(&self) -> Vec<AVStream> {
-        return unsafe {
+        Vec::from(
+            unsafe {
+                std::slice::from_raw_parts(
+                    (*self.base).streams,
+                    (*self.base).nb_streams as usize,
+                )
+            }
+        ).iter().map(|stream| {
+            AVStream::new(unsafe { (*stream).as_mut() }.expect("not null"), &self)
+        }).collect()
+    }
+
+    pub fn find_stream<P>(&self, predicate: P) -> Option<AVStream> where
+        P: FnMut(&AVStream) -> bool {
+        Vec::from(
+            unsafe {
                 std::slice::from_raw_parts(
                     (*self.base).streams,
                     (*self.base).nb_streams as usize,
                 )
             }
-            .iter()
-            .map(|stream| {
+        ).iter().map(|stream| {
             AVStream::new(unsafe { (*stream).as_mut() }.expect("not null"), &self)
-            })
-            .collect();
+        }).find(predicate)
     }
 
     pub fn read_frame(&/*TODO:mut*/ self, packet: &mut AVPacket) -> Result<(), failure::Error> {

src/main.rs

@@ -2,6 +2,7 @@ pub(crate) mod ffmpeg_api;
 
 use crate::ffmpeg_api::enums::*;
 use crate::ffmpeg_api::api::*;
+use image::{ImageBuffer, RgbImage};
 
 fn main() -> Result<(), std::io::Error> {
     let mut before = std::time::SystemTime::now();
@@ -15,7 +16,16 @@ fn main() -> Result<(), std::io::Error> {
         panic!("Could not open video input: {:?}", error)
     });
 
-    for mut stream in avformat_context.streams() {
+    let x = 5;
+    let y = 5;
+    let mut spritesheet: RgbImage = ImageBuffer::new(160 * x, 90 * x);
+
+    let mut stream: AVStream = avformat_context.find_stream(|stream| {
+        stream.codec_parameters().codec_type() == AVMediaType::Video
+    }).unwrap_or_else(|| {
+        panic!("Could not find video stream")
+    });
+
     stream.set_discard(AVDiscard::NonKey);
 
     let codec_parameters = stream.codec_parameters();
@@ -61,7 +71,7 @@ fn main() -> Result<(), std::io::Error> {
 
         let mut scale_context = SwsContext::new();
 
-            while avformat_context.read_frame(&mut packet).is_ok() && i < 16 {
+        while avformat_context.read_frame(&mut packet).is_ok() {
             if packet.stream_index() == stream.index() {
                 codec_context.in_packet(&mut packet).unwrap_or_else(|error| {
                     panic!("Could not load packet: {:?}", error)
@@ -84,22 +94,39 @@ fn main() -> Result<(), std::io::Error> {
                     println!("Processing Time: {:#?}", before.elapsed().unwrap());
                     before = std::time::SystemTime::now();
 
-                        image::save_buffer(
-                            format!("/home/janne/Workspace/justflix/data/test/image_{}.png", i),
-                            output_frame.data(0),
-                            output_frame.width() as u32,
-                            output_frame.height() as u32,
-                            image::ColorType::Rgb8,
-                        ).unwrap();
+                    let current: RgbImage = ImageBuffer::from_raw(160, 90, output_frame.data(0).to_vec()).unwrap();
+
+                    image::imageops::overlay(
+                        &mut spritesheet,
+                        &current,
+                        (i % x) * 160,
+                        ((i / x) % y) * 90,
+                    );
 
                     println!("Writing Time: {:#?}", before.elapsed().unwrap());
                     before = std::time::SystemTime::now();
 
                     i += 1;
+
+                    if i % (x * y) == 0 {
+                        spritesheet.save(format!("/home/janne/Workspace/justflix/data/spritesheets/spritesheet_{}.png", (i / (x*y)) - 1)).unwrap_or_else(|error| {
+                            panic!("Could not write spritesheet: {}", error)
+                        });
+                        spritesheet = ImageBuffer::new(160 * x, 90 * x);
+                        println!("Writing Time: {:#?}", before.elapsed().unwrap());
+                        before = std::time::SystemTime::now();
                     }
                 }
             }
         }
+
+        if i % (x * y) != 0 {
+            spritesheet.save(format!("/home/janne/Workspace/justflix/data/spritesheets/spritesheet_{}.png", i / (x*y))).unwrap_or_else(|error| {
+                panic!("Could not write spritesheet: {}", error)
+            });
+            println!("Writing Time: {:#?}", before.elapsed().unwrap());
+            before = std::time::SystemTime::now();
+        }
     }
 
     Ok(())