use image::{Pixel, FilterType, DynamicImage, GenericImageView};
use termion::color::{Bg, Fg, Rgb};
#[cfg(feature = "video")]
use termion::input::TermRead;
#[cfg(feature = "video")]
use gstreamer::{self, prelude::*};
#[cfg(feature = "video")]
use gstreamer_app;
use failure::Error;
#[cfg(feature = "video")]
use failure::format_err;
use rayon::prelude::*;
use std::io::Write;
#[cfg(feature = "video")]
use std::sync::{Arc, RwLock};
pub type MResult<T> = Result<T, Error>;
fn main() -> MResult<()> {
let args = std::env::args().collect::<Vec<String>>();
let xsize: usize = args.get(1)
.expect("Provide xsize")
.parse::<usize>()
.unwrap();
let ysize = args.get(2)
.expect("provide ysize")
.parse()
.unwrap();
#[cfg(feature = "video")]
let preview_type = args.get(3)
.expect("Provide preview type")
.parse::<String>()
.unwrap();
#[cfg(feature = "video")]
let autoplay = args.get(4)
.expect("Autoplay?")
.parse::<bool>()
.unwrap();
#[cfg(feature = "video")]
let mute = args.get(5)
.expect("Muted?")
.parse::<bool>()
.unwrap();
let path = args.get(6).expect("Provide path");
#[cfg(feature = "video")]
let result =
match preview_type.as_ref() {
"video" => video_preview(path, xsize, ysize, autoplay, mute),
"image" => image_preview(path, xsize, ysize),
"audio" => audio_preview(path, autoplay, mute),
_ => { panic!("Available types: video/image/audio") }
};
#[cfg(not(feature = "video"))]
let result = image_preview(path, xsize, ysize);
if result.is_err() {
println!("{:?}", &result);
result
} else {
Ok(())
}
}
fn image_preview(path: &str,
xsize: usize,
ysize: usize) -> MResult<()> {
let img = image::open(&path)?;
let renderer = Renderer::new(xsize, ysize);
renderer.send_image(&img)?;
Ok(())
}
#[cfg(feature = "video")]
fn video_preview(path: &String,
xsize: usize,
ysize: usize,
autoplay: bool,
mute: bool)
-> MResult<()> {
let (player, appsink) = make_gstreamer()?;
let uri = format!("file://{}", &path);
player.set_property("uri", &uri)?;
let renderer = Renderer::new(xsize, ysize);
let renderer = Arc::new(RwLock::new(renderer));
let crenderer = renderer.clone();
let p = player.clone();
appsink.set_callbacks(
gstreamer_app::AppSinkCallbacks::new()
.new_sample({
move |sink| {
let sample = match sink.pull_sample() {
Some(sample) => sample,
None => return gstreamer::FlowReturn::Eos,
};
let position = p.query_position::<gstreamer::ClockTime>()
.map(|p| p.seconds().unwrap_or(0))
.unwrap_or(0);
let duration = p.query_duration::<gstreamer::ClockTime>()
.map(|d| d.seconds().unwrap_or(0))
.unwrap_or(0);
if let Ok(mut renderer) = crenderer.write() {
match renderer.send_frame(&*sample,
position,
duration) {
Ok(()) => {
if autoplay == false {
match p.set_state(gstreamer::State::Paused)
.into_result() {
Ok(_) => gstreamer::FlowReturn::Eos,
Err(_) => gstreamer::FlowReturn::Error
}
} else {
gstreamer::FlowReturn::Ok
}
}
Err(err) => {
println!("{:?}", err);
gstreamer::FlowReturn::Error
}
}
} else { gstreamer::FlowReturn::Error }
}
})
.eos({
move |_| {
std::process::exit(0);
}
})
.build()
);
if mute == true || autoplay == false {
player.set_property("volume", &0.0)?;
}
player.set_state(gstreamer::State::Playing).into_result()?;
read_keys(player, Some(renderer))?;
Ok(())
}
#[cfg(feature = "video")]
fn read_keys(player: gstreamer::Element,
renderer: Option<Arc<RwLock<Renderer>>>) -> MResult<()> {
let seek_time = gstreamer::ClockTime::from_seconds(5);
let stdin = std::io::stdin();
let mut stdin = stdin.lock();
loop {
let input = stdin
.read_line()?
.unwrap_or_else(|| String::from("q"));
match input.as_str() {
"q" => std::process::exit(0),
">" => {
if let Some(mut time) = player
.query_position::<gstreamer::ClockTime>() {
time += seek_time;
player.seek_simple(
gstreamer::SeekFlags::FLUSH,
gstreamer::format::GenericFormattedValue::from_time(time)
)?;
}
},
"<" => {
if let Some(mut time) = player
.query_position::<gstreamer::ClockTime>() {
if time >= seek_time {
time -= seek_time;
} else {
time = gstreamer::ClockTime(Some(0));
}
player.seek_simple(
gstreamer::SeekFlags::FLUSH,
gstreamer::format::GenericFormattedValue::from_time(time)
)?;
}
}
"p" => {
player.set_state(gstreamer::State::Playing).into_result()?;
if let Some(time) = player
.query_position::<gstreamer::ClockTime>() {
player.seek_simple(
gstreamer::SeekFlags::FLUSH,
gstreamer::format::GenericFormattedValue::from_time(time)
)?;
}
}
"a" => {
player.set_state(gstreamer::State::Paused).into_result()?;
}
"m" => {
player.set_property("volume", &0.0)?;
}
"u" => {
player.set_property("volume", &1.0)?;
}
"xy" => {
if let Some(ref renderer) = renderer {
let xsize = stdin.read_line()?;
let ysize = stdin.read_line()?;
let xsize = xsize.unwrap_or(String::from("0")).parse::<usize>()?;
let ysize = ysize.unwrap_or(String::from("0")).parse::<usize>()?;
let mut renderer = renderer
.write()
.map_err(|_| format_err!("Renderer RwLock failed!"))?;
renderer.set_size(xsize, ysize)?;
}
}
_ => {}
}
}
}
#[cfg(feature = "video")]
pub fn audio_preview(path: &String,
autoplay: bool,
mute: bool)
-> MResult<()> {
let (player, _) = make_gstreamer()?;
let uri = format!("file://{}", &path);
player.set_property("uri", &uri)?;
let p = player.clone();
std::thread::spawn(move || -> MResult<()> {
let mut last_pos = None;
let sleep_duration = std::time::Duration::from_millis(50);
let mut stdout = std::io::stdout();
loop {
std::thread::sleep(sleep_duration);
let position = p.query_position::<gstreamer::ClockTime>()
.map(|p| p.seconds().unwrap_or(0))
.unwrap_or(0);
let duration = p.query_duration::<gstreamer::ClockTime>()
.map(|d| d.seconds().unwrap_or(0))
.unwrap_or(0);
if last_pos == Some(position) {
continue
}
last_pos = Some(position);
writeln!(stdout, "")?;
writeln!(stdout, "{}", position)?;
writeln!(stdout, "{}", duration)?;
stdout.flush()?;
}
});
if mute == true || autoplay == false{
player.set_property("volume", &0.0)?;
} else {
player.set_state(gstreamer::State::Playing).into_result()?;
}
read_keys(player, None)?;
Ok(())
}
#[cfg(feature = "video")]
pub fn make_gstreamer() -> MResult<(gstreamer::Element,
gstreamer_app::AppSink)> {
gstreamer::init()?;
let player = gstreamer::ElementFactory::make("playbin", None)
.ok_or(format_err!("Can't create playbin"))?;
let videorate = gstreamer::ElementFactory::make("videorate", None)
.ok_or(format_err!("Can't create videorate element"))?;
let pnmenc = gstreamer::ElementFactory::make("pnmenc", None)
.ok_or(format_err!("Can't create PNM-encoder"))?;
let sink = gstreamer::ElementFactory::make("appsink", None)
.ok_or(format_err!("Can't create appsink"))?;
let appsink = sink.clone()
.downcast::<gstreamer_app::AppSink>()
.unwrap();
videorate.set_property("max-rate", &60)?;
let elems = &[&videorate, &pnmenc, &sink];
let bin = gstreamer::Bin::new(None);
bin.add_many(elems)?;
gstreamer::Element::link_many(elems)?;
let sink = elems[0].get_static_pad("sink").unwrap();
let ghost = gstreamer::GhostPad::new("sink", &sink)
.ok_or(format_err!("Can't create GhostPad"))?;
ghost.set_active(true)?;
bin.add_pad(&ghost)?;
player.set_property("video-sink", &bin.upcast::<gstreamer::Element>())?;
Ok((player, appsink))
}
struct Renderer {
xsize: usize,
ysize: usize,
#[cfg(feature = "video")]
last_frame: Option<DynamicImage>,
#[cfg(feature = "video")]
position: Option<usize>,
#[cfg(feature = "video")]
duration: Option<usize>
}
impl Renderer {
fn new(xsize: usize, ysize: usize) -> Renderer {
Renderer {
xsize,
ysize,
#[cfg(feature = "video")]
last_frame: None,
#[cfg(feature = "video")]
position: None,
#[cfg(feature = "video")]
duration: None
}
}
#[cfg(feature = "video")]
fn set_size(&mut self, xsize: usize, ysize: usize) -> MResult<()> {
self.xsize = xsize;
self.ysize = ysize;
if let Some(ref frame) = self.last_frame {
let pos = self.position.unwrap_or(0);
let dur = self.duration.unwrap_or(0);
self.send_image(frame)?;
let stdout = std::io::stdout();
let mut stdout = stdout.lock();
writeln!(stdout, "")?;
writeln!(stdout, "{}", pos)?;
writeln!(stdout, "{}", dur)?;
}
Ok(())
}
fn send_image(&self, image: &DynamicImage) -> MResult<()> {
let rendered_img = self.render_image(image);
let stdout = std::io::stdout();
let mut stdout = stdout.lock();
for line in rendered_img {
writeln!(stdout, "{}", line)?;
}
Ok(())
}
#[cfg(feature = "video")]
fn send_frame(&mut self,
frame: &gstreamer::sample::SampleRef,
position: u64,
duration: u64)
-> MResult<()> {
let buffer = frame.get_buffer()
.ok_or(format_err!("Couldn't get buffer from frame!"))?;
let map = buffer.map_readable()
.ok_or(format_err!("Couldn't get buffer from frame!"))?;
let img = image::load_from_memory_with_format(&map,
image::ImageFormat::PNM)?;
let rendered_img = self.render_image(&img);
self.last_frame = Some(img);
self.position = Some(position as usize);
self.duration = Some(duration as usize);
let stdout = std::io::stdout();
let mut stdout = stdout.lock();
for line in rendered_img {
writeln!(stdout, "{}", line)?;
}
writeln!(stdout, "")?;
writeln!(stdout, "{}", position)?;
writeln!(stdout, "{}", duration)?;
Ok(())
}
pub fn render_image(&self, image: &DynamicImage) -> Vec<String> {
let (xsize, ysize) = self.max_size(&image);
let img = image.resize_exact(xsize as u32,
ysize as u32,
FilterType::Nearest).to_rgba();
let rows = img.pixels()
.collect::<Vec<_>>()
.chunks(xsize as usize)
.map(|line| line.to_vec())
.collect::<Vec<Vec<_>>>();
rows.par_chunks(2)
.map(|rows| {
rows[0]
.par_iter()
.zip(rows[1].par_iter())
.map(|(upper, lower)| {
let upper_color = upper.to_rgb();
let lower_color = lower.to_rgb();
format!("{}{}▀{}",
Fg(Rgb(upper_color[0], upper_color[1], upper_color[2])),
Bg(Rgb(lower_color[0], lower_color[1], lower_color[2])),
termion::style::Reset
)
}).collect()
}).collect()
}
pub fn max_size(&self, image: &DynamicImage) -> (usize, usize)
{
let xsize = self.xsize;
let ysize = self.ysize;
let img_xsize = image.width();
let img_ysize = image.height();
let img_ratio = img_xsize as f32 / img_ysize as f32;
let mut new_x = xsize;
let mut new_y;
new_y = if img_ratio < 1 as f32 {
(xsize as f32 * img_ratio) as usize
} else {
(xsize as f32 / img_ratio) as usize
};
if new_y > ysize*2 {
new_y = self.ysize * 2;
new_x = if img_ratio < 1 as f32 {
(ysize as f32 / img_ratio) as usize * 2
} else {
(ysize as f32 * img_ratio) as usize * 2
};
}
if new_y as u32 % 2 == 1 {
new_y += 1;
}
(new_x as usize, new_y as usize)
}
}