julian/music-reader
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Tried implementing real async loading, using libpdfium instead of libpoppler

Browse Source 
pdfium does not find library yet.
Major clean up needed
This commit is contained in:
Julian Mutter 2023-11-21 00:45:03 +01:00
parent ca4d5fc899
commit d71a2dab66
6 changed files with 1275 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

926
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

12
Cargo.toml
View File

@ -5,9 +5,11 @@ edition = "2021"
[dependencies]
poppler-rs = "0.22"
cairo-rs = "0.18.2"
glib-macros = "0.18.2"
gio = "0.18.2"
glib = "0.18.2"
gtk4 = "0.7.3"
cairo-rs = "0.18.3"
glib-macros = "0.18.3"
gio = "0.18.3"
glib = "0.18.3"
clap = { version = "4.4.6", features = ["derive"] }
gtk = { version = "0.7.3", package = "gtk4", features = ["v4_8"] }
async-channel = "2.1.0"
pdfium-render = "0.8.15"

1
flake.nix
View File

@ -17,6 +17,7 @@
pkg-config
poppler
wrapGAppsHook
deepin.deepin-pdfium
];
in {
defaultPackage = naersk-lib.buildPackage {

159
src/cache.rs Normal file
View File

@ -0,0 +1,159 @@
use glib::Bytes;
use gtk::gdk::Texture;
use pdfium_render::{pdfium, prelude::*};
use std::{
collections::BTreeMap,
path::{Path, PathBuf},
sync::{Arc, Mutex},
};
use async_channel::{Receiver, Sender};
type PageNumber = usize;
pub struct PageCache<'a> {
document: PdfDocument<'a>,
render_config: PdfRenderConfig,
max_num_stored_pages: usize,
pages: BTreeMap<usize, Arc<Texture>>,
}
impl<'a> PageCache<'a> {
pub fn new(
document: PdfDocument<'a>,
render_config: PdfRenderConfig,
max_num_stored_pages: usize,
) -> Self {
PageCache {
document,
render_config,
max_num_stored_pages,
pages: BTreeMap::new(),
}
}
pub fn get_page(&self, page_number: usize) -> Option<Arc<Texture>> {
self.pages.get(&page_number).map(Arc::clone)
}
pub fn cache_pages(&mut self, page_numbers: Vec<usize>) {
for page_number in page_numbers {
if self.pages.contains_key(&page_number) {
continue;
}
let page = self.document.pages().get(page_number as u16).unwrap();
let image = page.render_with_config(&self.render_config).unwrap();
// TODO: does this clone?
let bytes = Bytes::from(image.as_bytes());
let page = Texture::from_bytes(&bytes).unwrap();
// let page = self.document.page(page_number as i32);
self.pages.insert(page_number, Arc::new(page));
if self.pages.len() > self.max_num_stored_pages && self.pages.len() > 2 {
let _result = self.remove_most_distant_page(page_number);
}
}
}
fn remove_most_distant_page(&mut self, current_page_number: usize) -> Result<(), ()> {
let (min_cached_page_number, min_cached_page) = self.pages.pop_first().ok_or(())?;
let (max_cached_page_number, max_cached_page) = self.pages.pop_last().ok_or(())?;
if current_page_number.abs_diff(min_cached_page_number)
> current_page_number.abs_diff(max_cached_page_number)
{
self.pages.insert(max_cached_page_number, max_cached_page);
} else {
self.pages.insert(min_cached_page_number, min_cached_page);
}
Ok(())
}
fn process_command(&mut self, command: CacheCommand) -> Option<CacheResponse> {
match command {
CacheCommand::CachePages { pages } => {
self.cache_pages(pages);
None
}
CacheCommand::GetCurrentTwoPages { page_left_number } => {
let page_left = self
.get_page(page_left_number)
.expect("Requested page was not cached!!!");
if let Some(page_right) = self.get_page(page_left_number + 1) {
Some(CacheResponse::TwoPagesLoaded {
page_left,
page_right,
})
} else {
Some(CacheResponse::SinglePageLoaded { page: page_left })
}
}
}
}
}
pub enum CacheCommand {
CachePages { pages: Vec<PageNumber> },
GetCurrentTwoPages { page_left_number: PageNumber },
}
pub enum CacheResponse {
DocumentLoaded {
num_pages: usize,
},
SinglePageLoaded {
page: Arc<Texture>,
},
TwoPagesLoaded {
page_left: Arc<Texture>,
page_right: Arc<Texture>,
},
}
pub fn spawn_async_cache(
file: impl AsRef<Path>,
) -> (Sender<CacheCommand>, Receiver<CacheResponse>) {
let (command_sender, command_receiver) = async_channel::unbounded();
let (response_sender, response_receiver) = async_channel::unbounded();
let path: PathBuf = file.as_ref().to_path_buf();
std::thread::spawn(move || {
// Load pdf document here since Document is not thread safe and cannot be passed from main thread
let pdfium = Pdfium::default();
let document = pdfium.load_pdf_from_file(&path, None).unwrap();
let render_config = PdfRenderConfig::new()
.set_target_width(2000)
.set_maximum_height(2000)
.rotate_if_landscape(PdfPageRenderRotation::Degrees90, true);
let num_pages = document.pages().iter().count();
// let document = poppler::Document::from_file(&uri, None).unwrap();
// let num_pages = document.n_pages() as usize;
response_sender.send(CacheResponse::DocumentLoaded { num_pages });
let mut cache = PageCache::new(document, render_config, 10);
loop {
if let Ok(command) = command_receiver.recv_blocking() {
// if !command_receiver.is_empty() {
// // ignore command if more up to date ones are available
// continue;
// }
if let Some(response) = cache.process_command(command) {
response_sender.send_blocking(response);
}
} else {
// Sender was closed, cache not needed anymore
break;
}
}
});
(command_sender, response_receiver)
}

5
src/main.rs
View File

@ -1,8 +1,9 @@
mod cache;
mod ui;
use clap::Parser;
use gtk4::prelude::*;
use gtk4::Application;
use gtk::prelude::*;
use gtk::Application;
use std::cell::RefCell;
use std::path::PathBuf;
use std::rc::Rc;

438
src/ui.rs
View File

@ -1,108 +1,46 @@
use std::{cell::RefCell, collections::BTreeMap, path::Path, rc::Rc, thread, time::Duration};
use async_channel::Sender;
use cairo::{Context, Format, ImageSurface};
use gtk4::{
prelude::*, Application, ApplicationWindow, Box, Button, DrawingArea, FileChooserAction,
FileChooserDialog, HeaderBar, Label, Orientation, ResponseType,
use gtk::{
gdk::Paintable, gio, glib, prelude::*, Application, ApplicationWindow, Box, Button,
DrawingArea, FileChooserAction, FileChooserDialog, HeaderBar, Label, Orientation, Picture,
ResponseType,
};
use poppler::{Document, Page};
use crate::cache::{self, CacheCommand, PageCache};
use glib::clone;
use gtk::prelude::*;
pub struct Ui {
window: ApplicationWindow,
bottom_bar: gtk4::Box,
header_bar: gtk4::HeaderBar,
page_indicator: gtk4::Label,
drawing_area: gtk4::DrawingArea,
bottom_bar: gtk::Box,
header_bar: gtk::HeaderBar,
page_indicator: gtk::Label,
drawing_area: gtk::DrawingArea,
picture: Picture,
drawing_context: cairo::Context,
document_canvas: Option<DocumentCanvas>,
}
pub struct PageCache {
max_num_pages: usize,
first_page_number: usize,
pages: BTreeMap<usize, Rc<Page>>,
}
impl PageCache {
pub fn new(max_num_pages: usize) -> Self {
PageCache {
max_num_pages,
first_page_number: 0,
pages: BTreeMap::new(),
}
}
pub fn get_page(&self, page_number: usize) -> Option<Rc<Page>> {
let index = page_number - self.first_page_number;
self.pages.get(&index).map(Rc::clone)
}
pub fn cache_pages(
&mut self,
current_page_number: usize,
page_numbers: Vec<usize>,
document: &Document,
) {
for page_number in page_numbers {
if self.pages.contains_key(&page_number) {
continue;
}
let page = document.page(page_number as i32);
if let Some(page) = page {
self.pages.insert(page_number, Rc::new(page));
if self.pages.len() > self.max_num_pages && self.pages.len() > 2 {
let _result = self.remove_most_distant_page(current_page_number);
}
}
}
}
fn remove_most_distant_page(&mut self, current_page_number: usize) -> Result<(), ()> {
let (min_cached_page_number, min_cached_page) = self.pages.pop_first().ok_or(())?;
let (max_cached_page_number, max_cached_page) = self.pages.pop_last().ok_or(())?;
if current_page_number.abs_diff(min_cached_page_number)
> current_page_number.abs_diff(max_cached_page_number)
{
self.pages.insert(max_cached_page_number, max_cached_page);
} else {
self.pages.insert(min_cached_page_number, min_cached_page);
}
Ok(())
}
}
pub struct DocumentCanvas {
document: Document,
current_page_number: usize,
num_pages: usize,
page_cache: PageCache,
num_pages: Option<usize>,
page_cache_sender: Sender<CacheCommand>,
}
impl DocumentCanvas {
pub fn new(document: poppler::Document, max_num_cached_pages: usize) -> Self {
let num_pages = document.n_pages() as usize;
pub fn new(page_cache_sender: Sender<CacheCommand>) -> Self {
DocumentCanvas {
document,
num_pages,
current_page_number: 0,
page_cache: PageCache::new(max_num_cached_pages),
num_pages: None,
page_cache_sender,
}
}
pub fn get_left_page(&self) -> Option<Rc<Page>> {
self.page_cache.get_page(self.current_page_number)
}
pub fn get_right_page(&self) -> Option<Rc<Page>> {
self.page_cache.get_page(self.current_page_number + 1)
}
pub fn increase_page_number(&mut self) {
if self.current_page_number >= self.num_pages - 2 {
if self.current_page_number >= self.num_pages.unwrap_or(0) - 2 {
return;
}
@ -117,33 +55,25 @@ impl DocumentCanvas {
self.current_page_number -= 1;
}
pub fn cache_current_two_pages(&mut self) {
self.page_cache.cache_pages(
self.current_page_number,
vec![self.current_page_number, self.current_page_number + 1],
&self.document,
);
pub fn cache_surrounding_pages(&self) {
self.page_cache_sender
.send_blocking(CacheCommand::CachePages {
pages: vec![
self.current_page_number.saturating_sub(2),
self.current_page_number.saturating_sub(1),
self.current_page_number,
self.current_page_number + 1,
self.current_page_number + 2,
self.current_page_number + 3,
],
});
}
pub fn cache_surrounding_pages(&mut self) {
self.page_cache.cache_pages(
self.current_page_number,
vec![
self.current_page_number.saturating_sub(2),
self.current_page_number.saturating_sub(1),
self.current_page_number + 2,
self.current_page_number + 3,
],
&self.document,
);
}
pub fn cache_all_pages(&mut self) {
self.page_cache.cache_pages(
self.current_page_number,
(0..self.document.n_pages() as usize).collect(),
&self.document,
);
pub fn request_to_draw_pages(&self) {
self.page_cache_sender
.send_blocking(CacheCommand::GetCurrentTwoPages {
page_left_number: self.current_page_number,
});
}
}
@ -165,14 +95,18 @@ pub fn toggle_fullscreen(ui: &Ui) {
fn update_page_status(ui: &Ui) {
let page_status = match &ui.document_canvas {
Some(doc) => {
if doc.num_pages == 1 {
format!("{} / {}", doc.current_page_number, doc.num_pages)
if doc.num_pages.unwrap_or(0) == 1 {
format!(
"{} / {}",
doc.current_page_number,
doc.num_pages.unwrap_or(0)
)
} else {
format!(
"{}-{} / {}",
doc.current_page_number + 1,
doc.current_page_number + 2,
doc.num_pages
doc.num_pages.unwrap_or(0)
)
}
}
@ -246,34 +180,43 @@ impl Ui {
.hexpand(true)
.vexpand(true)
.build(),
picture: Picture::builder()
.width_request(400)
.height_request(300)
.hexpand(true)
.vexpand(true)
.build(),
drawing_context: create_drawing_context(),
document_canvas: None,
};
let ui = Rc::new(RefCell::new(ui));
ui.borrow().header_bar.pack_start(&open_file_button);
app_wrapper.prepend(&ui.borrow().drawing_area);
// app_wrapper.prepend(&ui.borrow().drawing_area);
app_wrapper.prepend(&ui.borrow().picture);
app_wrapper.append(&ui.borrow().bottom_bar);
ui.borrow().bottom_bar.append(&ui.borrow().page_indicator);
let click_left = gtk4::GestureClick::new();
let click_left = gtk::GestureClick::new();
click_left.set_button(1);
click_left.connect_pressed(glib::clone!(@weak ui => @default-panic, move |_, _, x, y| {
process_left_click(&mut ui.borrow_mut(), x, y);
}));
let click_right = gtk4::GestureClick::new();
let click_right = gtk::GestureClick::new();
click_right.set_button(3);
click_right.connect_pressed(glib::clone!(@weak ui => @default-panic, move |_, _, x, y| {
process_right_click(&mut ui.borrow_mut(), x, y);
}));
ui.borrow().drawing_area.add_controller(click_left);
ui.borrow().drawing_area.add_controller(click_right);
// ui.borrow().drawing_area.add_controller(click_left);
// ui.borrow().drawing_area.add_controller(click_right);
ui.borrow().picture.add_controller(click_left);
ui.borrow().picture.add_controller(click_right);
ui.borrow().drawing_area.set_draw_func(
glib::clone!(@weak ui => move |area, context, _, _| {
draw(&mut ui.borrow_mut(), area, context);
// draw(&mut ui.borrow_mut(), area, context, sender.clone());
}),
);
@ -292,147 +235,148 @@ impl Ui {
}
}
fn draw(ui: &mut Ui, area: &DrawingArea, context: &Context) {
if ui.document_canvas.is_none() {
return;
}
let document_canvas = ui.document_canvas.as_ref().unwrap();
if document_canvas.num_pages > 1 {
draw_two_pages(ui, area, context);
} else {
draw_single_page(ui, area, context);
}
// fn draw(ui: &mut Ui, area: &DrawingArea, context: &Context, sender: Sender<String>) {
// if ui.document_canvas.is_none() {
// return;
// }
// let document_canvas = ui.document_canvas.as_ref().unwrap();
// if document_canvas.num_pages.unwrap_or(0) > 1 {
// draw_two_pages(ui, area, context);
// } else {
// draw_single_page(ui, area, context);
// }
// TODO: this makes the draw wait
// ui.document_canvas
// .as_mut()
// .unwrap()
// .cache_surrounding_pages();
}
// // gio::spawn_blocking(move || {
// // ui.document_canvas
// // .as_mut()
// // .unwrap()
// // .cache_surrounding_pages();
// // });
// }
fn draw_two_pages(ui: &Ui, area: &DrawingArea, context: &Context) {
if ui.document_canvas.is_none() {
return;
}
let document_canvas = ui.document_canvas.as_ref().unwrap();
// fn draw_two_pages(ui: &Ui, area: &DrawingArea, context: &Context) {
// if ui.document_canvas.is_none() {
// return;
// }
// let document_canvas = ui.document_canvas.as_ref().unwrap();
let page_left = document_canvas.get_left_page();
let page_right = document_canvas.get_right_page();
// let page_left = document_canvas.get_left_page();
// let page_right = document_canvas.get_right_page();
if page_left.is_none() || page_right.is_none() {
// TODO: show error message
return;
}
// if page_left.is_none() || page_right.is_none() {
// // TODO: show error message
// return;
// }
let page_left = page_left.unwrap();
let page_right = page_right.unwrap();
// let page_left = page_left.unwrap();
// let page_right = page_right.unwrap();
// Add white background
// context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// context.fill().unwrap();
// context.paint().unwrap();
// // Add white background
// // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// // context.fill().unwrap();
// // context.paint().unwrap();
let (w_left, h_left) = page_left.size();
let (w_right, h_right) = page_right.size();
// let (w_left, h_left) = page_left.size();
// let (w_right, h_right) = page_right.size();
let h_max = f64::max(h_left, h_right);
// Make sure both pages are rendered with the same height
let w_max = match h_left < h_right {
true => w_left * h_right / h_left + w_right,
false => w_left + w_right * h_left / h_right,
};
// let h_max = f64::max(h_left, h_right);
// // Make sure both pages are rendered with the same height
// let w_max = match h_left < h_right {
// true => w_left * h_right / h_left + w_right,
// false => w_left + w_right * h_left / h_right,
// };
let h_scale = area.height() as f64 / h_max;
let w_scale = area.width() as f64 / w_max;
let scale = f64::min(h_scale, w_scale);
let h_page = h_max * scale;
// let h_scale = area.height() as f64 / h_max;
// let w_scale = area.width() as f64 / w_max;
// let scale = f64::min(h_scale, w_scale);
// let h_page = h_max * scale;
let scale_left = h_page / h_left;
let scale_right = h_page / h_right;
// let scale_left = h_page / h_left;
// let scale_right = h_page / h_right;
context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
context.save().unwrap();
context.translate(
area.width() as f64 / 2.0 - w_left * scale_left,
area.height() as f64 / 2.0 - h_page / 2.0,
);
// Poppler sometimes crops white border, draw it manually
context.rectangle(0.0, 0.0, w_left * scale_left, h_page);
context.fill().unwrap();
context.scale(scale_left, scale_left);
page_left.render(context);
// context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// context.save().unwrap();
// context.translate(
// area.width() as f64 / 2.0 - w_left * scale_left,
// area.height() as f64 / 2.0 - h_page / 2.0,
// );
// // Poppler sometimes crops white border, draw it manually
// context.rectangle(0.0, 0.0, w_left * scale_left, h_page);
// context.fill().unwrap();
// context.scale(scale_left, scale_left);
// page_left.render(context);
context.restore().unwrap();
context.translate(
area.width() as f64 / 2.0,
area.height() as f64 / 2.0 - h_page / 2.0,
);
// Poppler sometimes crops white border, draw it manually
context.rectangle(0.0, 0.0, w_right * scale_right, h_page);
context.fill().unwrap();
context.scale(scale_right, scale_right);
page_right.render(context);
// context.restore().unwrap();
// context.translate(
// area.width() as f64 / 2.0,
// area.height() as f64 / 2.0 - h_page / 2.0,
// );
// // Poppler sometimes crops white border, draw it manually
// context.rectangle(0.0, 0.0, w_right * scale_right, h_page);
// context.fill().unwrap();
// context.scale(scale_right, scale_right);
// page_right.render(context);
let r = ui.drawing_context.paint();
match r {
Err(v) => println!("Error painting PDF: {v:?}"),
Ok(_v) => {}
}
// let r = ui.drawing_context.paint();
// match r {
// Err(v) => println!("Error painting PDF: {v:?}"),
// Ok(_v) => {}
// }
ui.drawing_context.show_page().unwrap();
}
fn draw_single_page(ui: &Ui, area: &DrawingArea, context: &Context) {
if ui.document_canvas.is_none() {
return;
}
let document_canvas = ui.document_canvas.as_ref().unwrap();
// ui.drawing_context.show_page().unwrap();
// }
// fn draw_single_page(ui: &Ui, area: &DrawingArea, context: &Context) {
// if ui.document_canvas.is_none() {
// return;
// }
// let document_canvas = ui.document_canvas.as_ref().unwrap();
if document_canvas.get_left_page().is_none() {
// TODO: show error message
return;
}
// if document_canvas.get_left_page().is_none() {
// // TODO: show error message
// return;
// }
let page = document_canvas.get_left_page().unwrap();
// let page = document_canvas.get_left_page().unwrap();
// Draw background
// context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// context.paint().unwrap();
// context.fill().expect("uh oh");
// context.paint().unwrap();
// // Draw background
// // context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// // context.paint().unwrap();
// // context.fill().expect("uh oh");
// // context.paint().unwrap();
let (w, h) = page.size();
// let (w, h) = page.size();
let width_diff = area.width() as f64 / w;
let height_diff = area.height() as f64 / h;
if width_diff > height_diff {
context.translate(
(area.width() as f64 - w * height_diff) / 2.0,
(area.height() as f64 - h * height_diff) / 2.0,
);
context.scale(height_diff, height_diff);
} else {
context.translate(
(area.width() as f64 - w * width_diff) / 2.0,
(area.height() as f64 - h * width_diff) / 2.0,
);
context.scale(width_diff, width_diff);
}
// let width_diff = area.width() as f64 / w;
// let height_diff = area.height() as f64 / h;
// if width_diff > height_diff {
// context.translate(
// (area.width() as f64 - w * height_diff) / 2.0,
// (area.height() as f64 - h * height_diff) / 2.0,
// );
// context.scale(height_diff, height_diff);
// } else {
// context.translate(
// (area.width() as f64 - w * width_diff) / 2.0,
// (area.height() as f64 - h * width_diff) / 2.0,
// );
// context.scale(width_diff, width_diff);
// }
// Poppler sometimes crops white border, draw it manually
context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
context.rectangle(0.0, 0.0, w, h);
context.fill().unwrap();
// // Poppler sometimes crops white border, draw it manually
// context.set_source_rgba(1.0, 1.0, 1.0, 1.0);
// context.rectangle(0.0, 0.0, w, h);
// context.fill().unwrap();
page.render(context);
// page.render(context);
let r = ui.drawing_context.paint();
match r {
Err(v) => println!("Error painting PDF: {v:?}"),
Ok(_v) => {}
}
// let r = ui.drawing_context.paint();
// match r {
// Err(v) => println!("Error painting PDF: {v:?}"),
// Ok(_v) => {}
// }
ui.drawing_context.show_page().unwrap();
}
// ui.drawing_context.show_page().unwrap();
// }
fn choose_file(ui: Rc<RefCell<Ui>>, window: &ApplicationWindow) {
let filechooser = FileChooserDialog::builder()
@ -456,13 +400,25 @@ fn choose_file(ui: Rc<RefCell<Ui>>, window: &ApplicationWindow) {
pub fn load_document(file: impl AsRef<Path>, ui: Rc<RefCell<Ui>>) {
println!("Loading file...");
// TODO: catch errors, maybe show error dialog
let uri = format!("file://{}", file.as_ref().to_str().unwrap());
let mut document_canvas =
DocumentCanvas::new(poppler::Document::from_file(&uri, None).unwrap(), 1000);
// document_canvas.cache_current_two_pages();
document_canvas.cache_all_pages();
// let uri = format!("file://{}", file.as_ref().to_str().unwrap());
let (sender, receiver) = cache::spawn_async_cache(file);
// gtk::spawn
glib::spawn_future_local(clone!(@weak ui => async move {
while let Ok(cache_response) = receiver.recv().await {
match cache_response{
cache::CacheResponse::DocumentLoaded { num_pages } => todo!(), //ui.borrow_mut().document_canvas.unwrap().num_pages = Some(num_pages),
cache::CacheResponse::SinglePageLoaded { page } => { ui.borrow_mut().picture.set_paintable(Some(page.as_ref()));},
cache::CacheResponse::TwoPagesLoaded { page_left, page_right } => todo!(),
}
}
}));
let document_canvas = DocumentCanvas::new(sender);
document_canvas.cache_surrounding_pages();
// document_canvas.cache_all_pages();
// update_page_status(&ui.borrow());
document_canvas.request_to_draw_pages();
ui.borrow_mut().document_canvas = Some(document_canvas);
update_page_status(&ui.borrow());
}