315 lines
10 KiB
Rust
315 lines
10 KiB
Rust
use crate::{color_mode::{self, ColorMode}, draw};
|
|
use anyhow::{anyhow, bail, Result};
|
|
use glib::timeout_future;
|
|
use gtk::{gdk::Texture, prelude::TextureExt};
|
|
use log::{debug, error};
|
|
use poppler::Document;
|
|
use std::{
|
|
cell::RefCell,
|
|
collections::{BTreeMap, VecDeque},
|
|
rc::Rc,
|
|
time::{Duration, Instant},
|
|
};
|
|
|
|
pub type PageNumber = usize;
|
|
pub type MyPageType = Texture;
|
|
|
|
pub struct PageCache {
|
|
document: Document,
|
|
max_num_stored_pages: usize,
|
|
pages: BTreeMap<usize, Rc<MyPageType>>,
|
|
last_requested_page_number: PageNumber,
|
|
color_mode: ColorMode,
|
|
}
|
|
|
|
impl PageCache {
|
|
pub fn new(document: Document, max_num_stored_pages: usize, color_mode : ColorMode) -> Self {
|
|
PageCache {
|
|
document,
|
|
max_num_stored_pages,
|
|
pages: BTreeMap::new(),
|
|
last_requested_page_number: 0,
|
|
color_mode,
|
|
}
|
|
}
|
|
|
|
pub fn get_page(&mut self, page_number: usize) -> Option<Rc<MyPageType>> {
|
|
self.last_requested_page_number = page_number;
|
|
self.pages.get(&page_number).map(Rc::clone)
|
|
}
|
|
|
|
pub fn get_page_or_cache(&mut self, page_number: usize) -> Result<Rc<MyPageType>> {
|
|
if let Some(page) = self.get_page(page_number) {
|
|
Ok(page)
|
|
} else {
|
|
let _ = self.cache_page(page_number, 100);
|
|
if let Some(page) = self.get_page(page_number) {
|
|
Ok(page)
|
|
} else {
|
|
bail!("Failed caching and retrieving page {}", page_number);
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn cache_page(&mut self, page_number: PageNumber, height: i32) -> Option<CacheResponse> {
|
|
debug!("Caching page {}", page_number);
|
|
if page_number.abs_diff(self.last_requested_page_number)
|
|
> self.max_num_stored_pages.div_ceil(2)
|
|
{
|
|
debug!("Page too far from reader, aborting caching call");
|
|
return None;
|
|
}
|
|
|
|
let begin_of_cashing = Instant::now();
|
|
if let Some(page) = self.pages.get(&page_number) {
|
|
if page.height() >= height {
|
|
debug!("Page already in cache");
|
|
return None;
|
|
}
|
|
}
|
|
|
|
let mut response = None;
|
|
|
|
if let Some(page) = self.document.page(page_number as i32) {
|
|
let pages = vec![Rc::new(page)];
|
|
let texture = draw::draw_pages_to_texture(&pages, height, &self.color_mode);
|
|
let page = Rc::new(texture);
|
|
|
|
// Overwrite page with lower resolution if exists
|
|
let previous_page = self.pages.insert(page_number, Rc::clone(&page));
|
|
let page_resolution_upgraded = previous_page.is_some();
|
|
if page_resolution_upgraded {
|
|
response = Some(CacheResponse::PageResolutionUpgraded { page_number, page });
|
|
}
|
|
|
|
if self.pages.len() > self.max_num_stored_pages && self.pages.len() > 2 {
|
|
let _result = self.remove_most_distant_page();
|
|
}
|
|
}
|
|
debug!(
|
|
"done caching of page {} in {}ms",
|
|
page_number,
|
|
begin_of_cashing.elapsed().as_millis()
|
|
);
|
|
response
|
|
}
|
|
|
|
fn remove_most_distant_page(&mut self) -> anyhow::Result<()> {
|
|
let (min_cached_page_number, min_cached_page) = self
|
|
.pages
|
|
.pop_first()
|
|
.ok_or(anyhow!("The cache is empty, cannot remove first page"))?;
|
|
let (max_cached_page_number, max_cached_page) = self
|
|
.pages
|
|
.pop_last()
|
|
.ok_or(anyhow!("The cache is empty, cannot remove last page"))?;
|
|
|
|
if self
|
|
.last_requested_page_number
|
|
.abs_diff(min_cached_page_number)
|
|
> self
|
|
.last_requested_page_number
|
|
.abs_diff(max_cached_page_number)
|
|
{
|
|
self.pages.insert(max_cached_page_number, max_cached_page);
|
|
debug!(
|
|
"Removed page {} from cache to keep size low...",
|
|
min_cached_page_number
|
|
);
|
|
} else {
|
|
self.pages.insert(min_cached_page_number, min_cached_page);
|
|
debug!(
|
|
"Removed page {} from cache to keep size low...",
|
|
max_cached_page_number
|
|
);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn process_command(&mut self, command: CacheCommand) -> Result<Option<CacheResponse>> {
|
|
debug!("Processing command: {:?}...", command);
|
|
match command {
|
|
CacheCommand::Cache(command) => Ok(self.cache_page(command.page, command.height)),
|
|
CacheCommand::Retrieve(command) => match command {
|
|
RetrievePagesCommand::GetCurrentTwoPages { page_left_number } => {
|
|
let page_left = self.get_page_or_cache(page_left_number)?;
|
|
if let Ok(page_right) = self.get_page_or_cache(page_left_number + 1) {
|
|
Ok(Some(CacheResponse::TwoPagesRetrieved {
|
|
page_left,
|
|
page_right,
|
|
}))
|
|
} else {
|
|
Ok(Some(CacheResponse::SinglePageRetrieved { page: page_left }))
|
|
}
|
|
}
|
|
RetrievePagesCommand::GetCurrentPage { page_number } => {
|
|
let page = self.get_page_or_cache(page_number)?;
|
|
Ok(Some(CacheResponse::SinglePageRetrieved { page }))
|
|
}
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum CacheCommand {
|
|
Cache(CachePageCommand),
|
|
Retrieve(RetrievePagesCommand),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct CachePageCommand {
|
|
page: PageNumber,
|
|
height: i32,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct CacheKillSignal;
|
|
|
|
#[derive(Debug)]
|
|
pub enum RetrievePagesCommand {
|
|
GetCurrentTwoPages { page_left_number: PageNumber },
|
|
GetCurrentPage { page_number: PageNumber },
|
|
}
|
|
|
|
pub enum CacheResponse {
|
|
SinglePageRetrieved {
|
|
page: Rc<MyPageType>,
|
|
},
|
|
TwoPagesRetrieved {
|
|
page_left: Rc<MyPageType>,
|
|
page_right: Rc<MyPageType>,
|
|
},
|
|
PageResolutionUpgraded {
|
|
page_number: PageNumber,
|
|
page: Rc<MyPageType>,
|
|
},
|
|
}
|
|
|
|
pub struct SyncCacheCommandChannel {
|
|
retrieve_commands: Vec<RetrievePagesCommand>,
|
|
cache_commands: VecDeque<CachePageCommand>,
|
|
priority_cache_commands: Vec<CachePageCommand>,
|
|
kill_signals : Vec<CacheKillSignal>
|
|
}
|
|
|
|
pub struct SyncCacheCommandSender {
|
|
channel: Rc<RefCell<SyncCacheCommandChannel>>,
|
|
}
|
|
|
|
pub struct SyncCacheCommandReceiver {
|
|
cache_closed : bool,
|
|
channel: Rc<RefCell<SyncCacheCommandChannel>>,
|
|
}
|
|
|
|
impl SyncCacheCommandChannel {
|
|
pub fn open() -> (SyncCacheCommandSender, SyncCacheCommandReceiver) {
|
|
let channel = SyncCacheCommandChannel {
|
|
retrieve_commands: Vec::new(),
|
|
cache_commands: VecDeque::new(),
|
|
priority_cache_commands: Vec::new(),
|
|
kill_signals: Vec::new(),
|
|
};
|
|
let channel = Rc::new(RefCell::new(channel));
|
|
|
|
let sender = SyncCacheCommandSender {
|
|
channel: Rc::clone(&channel),
|
|
};
|
|
let receiver = SyncCacheCommandReceiver { cache_closed: false, channel };
|
|
(sender, receiver)
|
|
}
|
|
}
|
|
|
|
impl SyncCacheCommandSender {
|
|
pub fn _is_channel_open(&self) -> bool {
|
|
Rc::strong_count(&self.channel) > 1
|
|
}
|
|
|
|
pub fn send_retrieve_command(&self, command: RetrievePagesCommand) {
|
|
// Make newest message the most important
|
|
self.channel.borrow_mut().retrieve_commands.push(command);
|
|
}
|
|
|
|
pub fn send_priority_cache_commands(&self, pages: &[PageNumber], height: i32) {
|
|
for &page in pages {
|
|
// Make message in front the most important
|
|
self.channel
|
|
.borrow_mut()
|
|
.priority_cache_commands
|
|
.push(CachePageCommand { page, height });
|
|
}
|
|
}
|
|
|
|
pub fn send_cache_commands(&self, pages: &[PageNumber], height: i32) {
|
|
for &page in pages {
|
|
// Make message in front the most important
|
|
self.channel
|
|
.borrow_mut()
|
|
.cache_commands
|
|
.push_front(CachePageCommand { page, height: 100 }); // Cache with lower resolution
|
|
self.channel
|
|
.borrow_mut()
|
|
.cache_commands
|
|
.push_back(CachePageCommand { page, height });
|
|
}
|
|
}
|
|
|
|
pub fn send_kill_signal(&self) {
|
|
self.channel.borrow_mut().kill_signals.push(CacheKillSignal);
|
|
}
|
|
}
|
|
|
|
impl SyncCacheCommandReceiver {
|
|
pub fn is_channel_open(&self) -> bool {
|
|
Rc::strong_count(&self.channel) > 1
|
|
}
|
|
|
|
pub fn receive_most_important_command(&self) -> Option<CacheCommand> {
|
|
let mut channel = self.channel.borrow_mut();
|
|
if let Some(command) = channel.kill_signals.pop() {
|
|
// self.cache_closed = true;
|
|
return None;
|
|
}
|
|
if let Some(command) = channel.priority_cache_commands.pop() {
|
|
return Some(CacheCommand::Cache(command));
|
|
} else if let Some(command) = channel.retrieve_commands.pop() {
|
|
return Some(CacheCommand::Retrieve(command));
|
|
} else if let Some(command) = channel.cache_commands.pop_front() {
|
|
return Some(CacheCommand::Cache(command));
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
pub fn spawn_sync_cache<F>(document: Document, color_mode:ColorMode,receiver: F) -> SyncCacheCommandSender
|
|
where
|
|
F: Fn(CacheResponse) + 'static,
|
|
{
|
|
let (command_sender, command_receiver) = SyncCacheCommandChannel::open();
|
|
|
|
let mut cache = PageCache::new(document, 30, color_mode);
|
|
|
|
// Besides the name, it is not in another thread
|
|
glib::spawn_future_local(async move {
|
|
while command_receiver.is_channel_open() && !command_receiver.cache_closed {
|
|
// Add delay to tell gtk to give rendering priority
|
|
timeout_future(Duration::from_millis(1)).await;
|
|
|
|
if let Some(command) = command_receiver.receive_most_important_command() {
|
|
if let Some(response) = cache.process_command(command).unwrap_or_else(|e| {
|
|
error!("Error processing command: {}", e);
|
|
None
|
|
}) {
|
|
// response_sender.send_blocking(response).unwrap();
|
|
debug!("Command processed, activating receiver....");
|
|
receiver(response);
|
|
debug!("receiver done");
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
command_sender
|
|
}
|