| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use super::freetype_ffi as freetype; |
| use failure::{format_err, Error}; |
| use fuchsia_zircon as zx; |
| use libc::{c_uchar, c_ulong, c_void}; |
| use std::cmp::Ordering; |
| |
| type BitmapElement = u64; |
| const BITMAP_ELEMENT_SIZE: usize = 64; |
| |
| const MAX_RANGE_GAP: u32 = 2048; |
| |
| struct CharSetRange { |
| start: u32, |
| bitmap: Vec<BitmapElement>, |
| } |
| |
| impl CharSetRange { |
| fn new() -> CharSetRange { |
| CharSetRange { |
| start: 0, |
| bitmap: vec![], |
| } |
| } |
| |
| fn start(&self) -> u32 { |
| self.start |
| } |
| |
| fn end(&self) -> u32 { |
| self.start + (self.bitmap.len() * BITMAP_ELEMENT_SIZE) as u32 |
| } |
| |
| fn is_empty(&self) -> bool { |
| self.bitmap.is_empty() |
| } |
| |
| fn add(&mut self, val: u32) { |
| assert!(val >= self.start); |
| |
| if self.bitmap.is_empty() { |
| self.start = val; |
| } |
| |
| let pos = (val - self.start) as usize; |
| let element_pos = pos / BITMAP_ELEMENT_SIZE; |
| |
| if element_pos >= self.bitmap.len() { |
| self.bitmap.resize(element_pos + 1, 0); |
| } |
| |
| self.bitmap[element_pos] |= 1 << (pos % BITMAP_ELEMENT_SIZE); |
| } |
| |
| fn contains(&self, c: u32) -> bool { |
| if c < self.start || c >= self.end() { |
| false |
| } else { |
| let index = c as usize - self.start as usize; |
| (self.bitmap[index / 64] & (1 << (index % 64))) > 0 |
| } |
| } |
| } |
| |
| pub struct CharSet { |
| ranges: Vec<CharSetRange>, |
| } |
| |
| impl CharSet { |
| pub fn new(mut codepoints: Vec<u32>) -> CharSet { |
| codepoints.sort_unstable(); |
| |
| let mut ranges = vec![]; |
| let mut range = CharSetRange::new(); |
| for c in codepoints { |
| if c != 0 && !range.is_empty() && c >= range.end() + MAX_RANGE_GAP { |
| ranges.push(range); |
| range = CharSetRange::new(); |
| } |
| range.add(c); |
| } |
| if !range.is_empty() { |
| ranges.push(range) |
| } |
| CharSet { ranges } |
| } |
| |
| pub fn contains(&self, c: u32) -> bool { |
| match self.ranges.binary_search_by(|r| { |
| if r.end() < c { |
| Ordering::Less |
| } else if r.start() > c { |
| Ordering::Greater |
| } else { |
| Ordering::Equal |
| } |
| }) { |
| Ok(r) => self.ranges[r].contains(c), |
| Err(_) => false, |
| } |
| } |
| } |
| |
| struct VmoStreamInternal { |
| vmo: zx::Vmo, |
| stream_rec: freetype::FT_StreamRec, |
| } |
| |
| impl VmoStreamInternal { |
| // Caller must ensure that the returned FT_Stream is not used after |
| // VmoStream is dropped. |
| unsafe fn ft_stream(&self) -> freetype::FT_Stream { |
| &self.stream_rec as freetype::FT_Stream |
| } |
| |
| fn read(&mut self, offset: u64, read_buffer: &mut [u8]) -> u64 { |
| if read_buffer.len() == 0 || offset >= self.stream_rec.size as u64 { |
| return 0; |
| } |
| let read_size = std::cmp::min(read_buffer.len(), (self.stream_rec.size - offset) as usize); |
| match self.vmo.read(&mut read_buffer[..read_size], offset) { |
| Ok(_) => read_size as u64, |
| Err(err) => { |
| println!("Error when reading from font VMO: {:?}", err); |
| 0 |
| } |
| } |
| } |
| |
| // Unsafe callback called by freetype to read from the stream. |
| unsafe extern "C" fn read_func( |
| stream: freetype::FT_Stream, offset: c_ulong, buffer: *mut c_uchar, count: c_ulong, |
| ) -> c_ulong { |
| let wrapper = &mut *((*stream).descriptor as *mut VmoStreamInternal); |
| let buffer_slice = std::slice::from_raw_parts_mut(buffer as *mut u8, count as usize); |
| wrapper.read(offset as u64, buffer_slice) as c_ulong |
| } |
| |
| extern "C" fn close_func(_stream: freetype::FT_Stream) { |
| // No-op. Stream will be closed when the VmoStream is dropped. |
| } |
| } |
| |
| // Implements FT_Stream for a VMO. |
| struct VmoStream { |
| // VmoStreamInternal needs to be boxed to ensure that it's not moved. This |
| // allows to set stream_rec.descriptor to point to the containing |
| // VmoStreamInternal instance. |
| internal: Box<VmoStreamInternal>, |
| } |
| |
| impl VmoStream { |
| fn new(vmo: zx::Vmo, vmo_size: usize) -> Result<VmoStream, Error> { |
| let mut internal = Box::new(VmoStreamInternal { |
| vmo, |
| stream_rec: freetype::FT_StreamRec { |
| base: std::ptr::null(), |
| size: vmo_size as c_ulong, |
| pos: 0, |
| |
| descriptor: std::ptr::null_mut(), |
| pathname: std::ptr::null_mut(), |
| read: VmoStreamInternal::read_func, |
| close: VmoStreamInternal::close_func, |
| |
| memory: std::ptr::null_mut(), |
| cursor: std::ptr::null_mut(), |
| limit: std::ptr::null_mut(), |
| }, |
| }); |
| |
| internal.stream_rec.descriptor = &mut *internal as *mut VmoStreamInternal as *mut c_void; |
| |
| Ok(VmoStream { internal }) |
| } |
| |
| // Caller must ensure that the returned FT_Stream is not used after |
| // VmoStream is dropped. |
| unsafe fn ft_stream(&self) -> freetype::FT_Stream { |
| self.internal.ft_stream() |
| } |
| } |
| |
| pub struct FontInfo { |
| pub charset: CharSet, |
| } |
| |
| pub struct FontInfoLoader { |
| ft_library: freetype::FT_Library, |
| } |
| |
| impl std::ops::Drop for FontInfoLoader { |
| fn drop(&mut self) { |
| unsafe { |
| freetype::FT_Done_Library(self.ft_library); |
| } |
| } |
| } |
| |
| impl FontInfoLoader { |
| pub fn new() -> Result<FontInfoLoader, Error> { |
| // Unsafe to call freetype FFI. On success stores the FT_Library pointer |
| // in FontInfoLoader, which calls FT_Done_Library in drop(). Must ensure |
| // that all allocated memory is freed on failure. |
| unsafe { |
| let mut ft_library = std::ptr::null_mut(); |
| if freetype::FT_New_Library(&freetype::FT_MEMORY, &mut ft_library) != 0 { |
| return Err(format_err!("Failed to initialize FreeType library.")); |
| } |
| freetype::FT_Add_Default_Modules(ft_library); |
| Ok(FontInfoLoader { ft_library }) |
| } |
| } |
| |
| pub fn load_font_info( |
| &self, vmo: zx::Vmo, vmo_size: usize, index: u32, |
| ) -> Result<FontInfo, Error> { |
| let mut codepoints: Vec<u32> = Vec::new(); |
| |
| // Unsafe to call freetype FFI. Call FT_Open_Face() to load a typeface. |
| // If it succeeds then enumerate character map with FT_Get_First_Char() |
| // and FT_Get_Next_Char(). FT_Done_Face() must be called if the typeface |
| // was initialized successfully. |
| unsafe { |
| let stream = VmoStream::new(vmo, vmo_size)?; |
| let open_args = freetype::FT_Open_Args { |
| flags: freetype::FT_OPEN_STREAM, |
| memory_base: std::ptr::null(), |
| memory_size: 0, |
| pathname: std::ptr::null(), |
| stream: stream.ft_stream(), |
| driver: std::ptr::null_mut(), |
| num_params: 0, |
| params: std::ptr::null_mut(), |
| }; |
| |
| let mut ft_face = std::ptr::null_mut(); |
| let err = freetype::FT_Open_Face( |
| self.ft_library, |
| &open_args, |
| index as libc::c_long, |
| &mut ft_face, |
| ); |
| |
| if err != 0 { |
| return Err(format_err!("Failed to parse font file: error={}", err)); |
| } |
| |
| let mut glyph_index = 0; |
| let mut codepoint = freetype::FT_Get_First_Char(ft_face, &mut glyph_index); |
| while glyph_index > 0 { |
| codepoints.push(codepoint as u32); |
| codepoint = freetype::FT_Get_Next_Char(ft_face, codepoint, &mut glyph_index); |
| } |
| |
| freetype::FT_Done_Face(ft_face); |
| } |
| |
| Ok(FontInfo { |
| charset: CharSet::new(codepoints), |
| }) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| |
| #[test] |
| fn test_charset() { |
| let charset = CharSet::new(vec![1, 2, 3, 10, 500, 5000, 5001, 10000]); |
| assert!(!charset.contains(0)); |
| assert!(charset.contains(1)); |
| assert!(charset.contains(2)); |
| assert!(charset.contains(3)); |
| assert!(!charset.contains(4)); |
| assert!(!charset.contains(9)); |
| assert!(charset.contains(10)); |
| assert!(charset.contains(500)); |
| assert!(!charset.contains(501)); |
| assert!(charset.contains(5000)); |
| assert!(charset.contains(5001)); |
| assert!(!charset.contains(5002)); |
| assert!(!charset.contains(9999)); |
| assert!(charset.contains(10000)); |
| assert!(!charset.contains(10001)); |
| } |
| } |
