Skip to content

/ rust-png

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Upgrade Rust. #40

Merged
merged 1 commit into from Jul 31, 2014
+73 −85
Merged

Upgrade Rust. #40

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter...
Filter file types
Jump to…
Jump to file
Failed to load files.

Always

Just for now

12 Makefile.in
View file
Open in desktop
@@ -9,23 +9,23 @@ RUSTFLAGS := $(filter-out -O,$(RUSTFLAGS)) -L ../libpng --opt-level=3
EXT_DEPS ?=

.PHONY: all
all: librustpng.dummy
all: libpng-servo.dummy

%.o: %.c
$(CC) $< -o $@ -c $(CFLAGS)

librustpng.dummy: lib.rs libshim.a $(EXT_DEPS)
$(RUSTC) $(RUSTFLAGS) $< --out-dir .
libpng-servo.dummy: lib.rs libshim.a $(EXT_DEPS)
$(RUSTC) $(RUSTFLAGS) $< --out-dir . -C extra-filename=-servo
touch $@

rustpng-test: lib.rs libshim.a
png-test: lib.rs libshim.a
$(RUSTC) $(RUSTFLAGS) $< -o $@ --test

libshim.a: shim.o
$(AR) rcs libshim.a shim.o

check: rustpng-test
./rustpng-test
check: png-test
./png-test

.PHONY: clean
clean:
60 ffi.rs
View file
Open in desktop
@@ -33,48 +33,48 @@ pub static INFO_tRNS: c_int = 0x0010;
pub type png_struct = c_void;
pub type png_info = c_void;

#[link(name = "png")]
#[link(name = "png", kind = "static")]
#[link(name = "z")]
#[link(name = "shim")]
#[link(name = "shim", kind = "static")]
extern {
// libc routines needed
pub fn setjmp(env: *c_void) -> c_int;
pub fn setjmp(env: *mut c_void) -> c_int;

// shim routines
pub fn pngshim_jmpbuf(pnt_ptr: *mut png_struct) -> *c_void;
pub fn pngshim_jmpbuf(pnt_ptr: *mut png_struct) -> *mut c_void;

// libpng routines
pub fn png_get_header_ver(png_ptr: *png_struct) -> *c_char;
pub fn png_sig_cmp(sig: *u8, start: size_t, num_to_check: size_t) -> c_int;
pub fn png_get_header_ver(png_ptr: *mut png_struct) -> *mut c_char;
pub fn png_sig_cmp(sig: *const u8, start: size_t, num_to_check: size_t) -> c_int;

pub fn png_create_info_struct(png_ptr: *png_struct) -> *mut png_info;
pub fn png_get_io_ptr(png_ptr: *png_struct) -> *mut c_void;
pub fn png_create_info_struct(png_ptr: *mut png_struct) -> *mut png_info;
pub fn png_get_io_ptr(png_ptr: *mut png_struct) -> *mut c_void;
pub fn png_set_sig_bytes(png_ptr: *mut png_struct, num_bytes: c_int);

pub fn png_create_read_struct(user_png_ver: *c_char, error_ptr: *c_void, error_fn: *u8, warn_fn: *u8) -> *mut png_struct;
pub fn png_destroy_read_struct(png_ptr_ptr: **png_struct, info_ptr_ptr: **png_info, end_info_ptr_ptr: **png_info);
pub fn png_set_read_fn(png_ptr: *mut png_struct, io_ptr: *mut c_void, read_data_fn: extern "C" fn(*png_struct, *mut u8, size_t));
pub fn png_create_read_struct(user_png_ver: *const c_char, error_ptr: *mut c_void, error_fn: *mut u8, warn_fn: *mut u8) -> *mut png_struct;
pub fn png_destroy_read_struct(png_ptr_ptr: *mut *mut png_struct, info_ptr_ptr: *mut *mut png_info, end_info_ptr_ptr: *mut *mut png_info);
pub fn png_set_read_fn(png_ptr: *mut png_struct, io_ptr: *mut c_void, read_data_fn: extern "C" fn(*mut png_struct, *mut u8, size_t));
pub fn png_read_info(png_ptr: *mut png_struct, info_ptr: *mut png_info);
pub fn png_read_update_info(png_ptr: *mut png_struct, info_ptr: *mut png_info);
pub fn png_read_image(png_ptr: *mut png_struct, row_pointers: **mut u8);
pub fn png_read_png(png_ptr: *mut png_struct, info_ptr: *mut png_info, transforms: c_int, params: *c_void);

pub fn png_create_write_struct(user_png_ver: *c_char, error_ptr: *c_void, error_fn: *u8, warn_fn: *u8) -> *mut png_struct;
pub fn png_destroy_write_struct(png_ptr_ptr: **png_struct, info_ptr_ptr: **png_info);
pub fn png_set_write_fn(png_ptr: *mut png_struct, io_ptr: *mut c_void, write_data_fn: extern "C" fn(*png_struct, *u8, size_t), output_flush_ptr: extern "C" fn(*png_struct));
pub fn png_write_png(pnt_ptr: *mut png_struct, info_ptr: *mut png_info, transforms: c_int, params: *c_void); // ??

pub fn png_get_IHDR(png_ptr: *png_struct, info_ptr: *png_info, width: *mut u32, height: *mut u32, bit_depth: *mut c_int, color_type: *mut c_int, interlace_method: *mut c_int, compression_method: *mut c_int, filter_method: *mut c_int) -> u32;
pub fn png_get_pHYs(png_ptr: *png_struct, info_ptr: *png_info, res_x: *mut u32, res_y: *mut u32, unit_type: *mut c_int) -> u32;
pub fn png_get_image_width(png_ptr: *png_struct, info_ptr: *png_info) -> u32;
pub fn png_get_image_height(png_ptr: *png_struct, info_ptr: *png_info) -> u32;
pub fn png_get_bit_depth(png_ptr: *png_struct, info_ptr: *png_info) -> u8;
pub fn png_get_color_type(png_ptr: *png_struct, info_ptr: *png_info) -> u8;
pub fn png_get_rows(png_ptr: *png_struct, info_ptr: *png_info) -> **u8;

pub fn png_set_IHDR(png_ptr: *png_struct, info_ptr: *mut png_info, width: u32, height: u32, bit_depth: c_int, color_type: c_int, interlace_method: c_int, compression_method: c_int, filter_method: c_int);
pub fn png_set_pHYs(png_ptr: *png_struct, info_ptr: *mut png_info, res_x: u32, res_y: u32, unit_type: c_int);
pub fn png_set_rows(png_ptr: *png_struct, info_ptr: *mut png_info, row_pointers: **u8);
pub fn png_read_image(png_ptr: *mut png_struct, row_pointers: *mut *mut u8);
pub fn png_read_png(png_ptr: *mut png_struct, info_ptr: *mut png_info, transforms: c_int, params: *mut c_void);

pub fn png_create_write_struct(user_png_ver: *const c_char, error_ptr: *mut c_void, error_fn: *mut u8, warn_fn: *mut u8) -> *mut png_struct;
pub fn png_destroy_write_struct(png_ptr_ptr: *mut *mut png_struct, info_ptr_ptr: *mut *mut png_info);
pub fn png_set_write_fn(png_ptr: *mut png_struct, io_ptr: *mut c_void, write_data_fn: extern "C" fn(*mut png_struct, *mut u8, size_t), output_flush_ptr: extern "C" fn(*mut png_struct));
pub fn png_write_png(pnt_ptr: *mut png_struct, info_ptr: *mut png_info, transforms: c_int, params: *mut c_void); // ??

pub fn png_get_IHDR(png_ptr: *mut png_struct, info_ptr: *mut png_info, width: *mut u32, height: *mut u32, bit_depth: *mut c_int, color_type: *mut c_int, interlace_method: *mut c_int, compression_method: *mut c_int, filter_method: *mut c_int) -> u32;
pub fn png_get_pHYs(png_ptr: *mut png_struct, info_ptr: *mut png_info, res_x: *mut u32, res_y: *mut u32, unit_type: *mut c_int) -> u32;
pub fn png_get_image_width(png_ptr: *mut png_struct, info_ptr: *mut png_info) -> u32;
pub fn png_get_image_height(png_ptr: *mut png_struct, info_ptr: *mut png_info) -> u32;
pub fn png_get_bit_depth(png_ptr: *mut png_struct, info_ptr: *mut png_info) -> u8;
pub fn png_get_color_type(png_ptr: *mut png_struct, info_ptr: *mut png_info) -> u8;
pub fn png_get_rows(png_ptr: *mut png_struct, info_ptr: *mut png_info) -> *mut *mut u8;

pub fn png_set_IHDR(png_ptr: *mut png_struct, info_ptr: *mut png_info, width: u32, height: u32, bit_depth: c_int, color_type: c_int, interlace_method: c_int, compression_method: c_int, filter_method: c_int);
pub fn png_set_pHYs(png_ptr: *mut png_struct, info_ptr: *mut png_info, res_x: u32, res_y: u32, unit_type: c_int);
pub fn png_set_rows(png_ptr: *mut png_struct, info_ptr: *mut png_info, row_pointers: *mut *mut u8);

pub fn png_set_packing(png_ptr: *mut png_struct);
pub fn png_set_palette_to_rgb(png_ptr: *mut png_struct);
86 lib.rs
View file
Open in desktop
@@ -7,9 +7,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.

#![crate_id = "github.com/mozilla-servo/rust-png#png:0.1"]
#![crate_type = "lib"]
#![crate_type = "dylib"]
#![crate_name = "png"]
#![crate_type = "rlib"]

extern crate libc;
@@ -54,7 +52,7 @@ pub fn is_png(image: &[u8]) -> bool {
}
}

pub extern fn read_data(png_ptr: *ffi::png_struct, data: *mut u8, length: size_t) {
pub extern fn read_data(png_ptr: *mut ffi::png_struct, data: *mut u8, length: size_t) {
unsafe {
let io_ptr = ffi::png_get_io_ptr(png_ptr);
let image_data: &mut ImageData = mem::transmute(io_ptr);
@@ -81,24 +79,21 @@ pub fn load_png(path: &Path) -> Result<Image,String> {

pub fn load_png_from_memory(image: &[u8]) -> Result<Image,String> {
unsafe {
let png_ptr = ffi::png_create_read_struct(ffi::png_get_header_ver(ptr::null()),
ptr::null(),
ptr::null(),
ptr::null());
let mut png_ptr = ffi::png_create_read_struct(&*ffi::png_get_header_ver(ptr::mut_null()),
ptr::mut_null(),
ptr::mut_null(),
ptr::mut_null());
if png_ptr.is_null() {
return Err("could not create read struct".to_string());
}
let info_ptr = ffi::png_create_info_struct(&*png_ptr);
let mut info_ptr = ffi::png_create_info_struct(png_ptr);
if info_ptr.is_null() {
let png_ptr: *ffi::png_struct = &*png_ptr;
ffi::png_destroy_read_struct(&png_ptr, ptr::null(), ptr::null());
ffi::png_destroy_read_struct(&mut png_ptr, ptr::mut_null(), ptr::mut_null());
return Err("could not create info struct".to_string());
}
let res = ffi::setjmp(ffi::pngshim_jmpbuf(png_ptr));
if res != 0 {
let png_ptr: *ffi::png_struct = &*png_ptr;
let info_ptr: *ffi::png_info = &*info_ptr;
ffi::png_destroy_read_struct(&png_ptr, &info_ptr, ptr::null());
ffi::png_destroy_read_struct(&mut png_ptr, &mut info_ptr, ptr::mut_null());
return Err("error reading png".to_string());
}

@@ -110,10 +105,10 @@ pub fn load_png_from_memory(image: &[u8]) -> Result<Image,String> {
ffi::png_set_read_fn(png_ptr, mem::transmute(&mut image_data), read_data);
ffi::png_read_info(png_ptr, info_ptr);

let width = ffi::png_get_image_width(&*png_ptr, &*info_ptr);
let height = ffi::png_get_image_height(&*png_ptr, &*info_ptr);
let bit_depth = ffi::png_get_bit_depth(&*png_ptr, &*info_ptr);
let color_type = ffi::png_get_color_type(&*png_ptr, &*info_ptr);
let width = ffi::png_get_image_width(png_ptr, info_ptr);
let height = ffi::png_get_image_height(png_ptr, info_ptr);
let bit_depth = ffi::png_get_bit_depth(png_ptr, info_ptr);
let color_type = ffi::png_get_color_type(png_ptr, info_ptr);

// we convert palette to rgb
if color_type as c_int == ffi::COLOR_TYPE_PALETTE {
@@ -134,8 +129,8 @@ pub fn load_png_from_memory(image: &[u8]) -> Result<Image,String> {
ffi::png_set_interlace_handling(png_ptr);
ffi::png_read_update_info(png_ptr, info_ptr);

let updated_bit_depth = ffi::png_get_bit_depth(&*png_ptr, &*info_ptr);
let updated_color_type = ffi::png_get_color_type(&*png_ptr, &*info_ptr);
let updated_bit_depth = ffi::png_get_bit_depth(png_ptr, info_ptr);
let updated_color_type = ffi::png_get_color_type(png_ptr, info_ptr);

let (color_type, pixel_width) = match (updated_color_type as c_int, updated_bit_depth) {
(ffi::COLOR_TYPE_RGB, 8) |
@@ -148,15 +143,13 @@ pub fn load_png_from_memory(image: &[u8]) -> Result<Image,String> {

let mut image_data = Vec::from_elem((width * height * pixel_width) as uint, 0u8);
let image_buf = image_data.as_mut_ptr();
let row_pointers: Vec<*mut u8> = Vec::from_fn(height as uint, |idx| {
let mut row_pointers: Vec<*mut u8> = Vec::from_fn(height as uint, |idx| {
image_buf.offset((((width * pixel_width) as uint) * idx) as int)
});

ffi::png_read_image(png_ptr, row_pointers.as_ptr());
ffi::png_read_image(png_ptr, row_pointers.as_mut_ptr());

let png_ptr: *ffi::png_struct = &*png_ptr;
let info_ptr: *ffi::png_info = &*info_ptr;
ffi::png_destroy_read_struct(&png_ptr, &info_ptr, ptr::null());
ffi::png_destroy_read_struct(&mut png_ptr, &mut info_ptr, ptr::mut_null());

Ok(Image {
width: width,
@@ -167,11 +160,11 @@ pub fn load_png_from_memory(image: &[u8]) -> Result<Image,String> {
}
}

pub extern fn write_data(png_ptr: *ffi::png_struct, data: *u8, length: size_t) {
pub extern fn write_data(png_ptr: *mut ffi::png_struct, data: *mut u8, length: size_t) {
unsafe {
let io_ptr = ffi::png_get_io_ptr(png_ptr);
let writer: &mut &mut io::Writer = mem::transmute(io_ptr);
slice::raw::buf_as_slice(data, length as uint, |buf| {
slice::raw::buf_as_slice(&*data, length as uint, |buf| {
match writer.write(buf) {
Err(e) => fail!("{}", e.desc),
_ => {}
@@ -180,7 +173,7 @@ pub extern fn write_data(png_ptr: *ffi::png_struct, data: *u8, length: size_t) {
}
}

pub extern fn flush_data(png_ptr: *ffi::png_struct) {
pub extern fn flush_data(png_ptr: *mut ffi::png_struct) {
unsafe {
let io_ptr = ffi::png_get_io_ptr(png_ptr);
let writer: &mut &mut io::Writer = mem::transmute(io_ptr);
@@ -191,7 +184,7 @@ pub extern fn flush_data(png_ptr: *ffi::png_struct) {
}
}

pub fn store_png(img: &Image, path: &Path) -> Result<(),String> {
pub fn store_png(img: &mut Image, path: &Path) -> Result<(),String> {
let mut file = match File::create(path) {
Ok(f) => f,
Err(e) => return Err(format!("{}", e))
@@ -203,24 +196,21 @@ pub fn store_png(img: &Image, path: &Path) -> Result<(),String> {
let writer = &mut writer;

unsafe {
let png_ptr = ffi::png_create_write_struct(ffi::png_get_header_ver(ptr::null()),
ptr::null(),
ptr::null(),
ptr::null());
let mut png_ptr = ffi::png_create_write_struct(&*ffi::png_get_header_ver(ptr::mut_null()),
ptr::mut_null(),
ptr::mut_null(),
ptr::mut_null());
if png_ptr.is_null() {
return Err("could not create write struct".to_string());
}
let info_ptr = ffi::png_create_info_struct(&*png_ptr);
let mut info_ptr = ffi::png_create_info_struct(png_ptr);
if info_ptr.is_null() {
let png_ptr: *ffi::png_struct = &*png_ptr;
ffi::png_destroy_write_struct(&png_ptr, ptr::null());
ffi::png_destroy_write_struct(&mut png_ptr, ptr::mut_null());
return Err("could not create info struct".to_string());
}
let res = ffi::setjmp(ffi::pngshim_jmpbuf(png_ptr));
if res != 0 {
let png_ptr: *ffi::png_struct = &*png_ptr;
let info_ptr: *ffi::png_info = &*info_ptr;
ffi::png_destroy_write_struct(&png_ptr, &info_ptr);
ffi::png_destroy_write_struct(&mut png_ptr, &mut info_ptr);
return Err("error writing png".to_string());
}

@@ -234,20 +224,18 @@ pub fn store_png(img: &Image, path: &Path) -> Result<(),String> {
_ => fail!("bad color type"),
};

ffi::png_set_IHDR(&*png_ptr, info_ptr, img.width, img.height, bit_depth, color_type,
ffi::png_set_IHDR(png_ptr, info_ptr, img.width, img.height, bit_depth, color_type,
ffi::INTERLACE_NONE, ffi::COMPRESSION_TYPE_DEFAULT, ffi::FILTER_NONE);

let image_buf = img.pixels.as_ptr();
let row_pointers: Vec<*u8> = Vec::from_fn(img.height as uint, |idx| {
let image_buf = img.pixels.as_mut_ptr();
let mut row_pointers: Vec<*mut u8> = Vec::from_fn(img.height as uint, |idx| {
image_buf.offset((((img.width * pixel_width) as uint) * idx) as int)
});
ffi::png_set_rows(&*png_ptr, info_ptr, row_pointers.as_ptr());
ffi::png_set_rows(png_ptr, info_ptr, row_pointers.as_mut_ptr());

ffi::png_write_png(png_ptr, info_ptr, ffi::TRANSFORM_IDENTITY, ptr::null());
ffi::png_write_png(png_ptr, info_ptr, ffi::TRANSFORM_IDENTITY, ptr::mut_null());

let png_ptr: *ffi::png_struct = &*png_ptr;
let info_ptr: *ffi::png_info = &*info_ptr;
ffi::png_destroy_write_struct(&png_ptr, &info_ptr);
ffi::png_destroy_write_struct(&mut png_ptr, &mut info_ptr);
}
Ok(())
}
@@ -330,13 +318,13 @@ mod test {

#[test]
fn test_store() {
let img = Image {
let mut img = Image {
width: 10,
height: 10,
color_type: RGB8,
pixels: Vec::from_elem(10 * 10 * 3, 100u8),
};
let res = store_png(&img, &Path::new("test/store.png"));
let res = store_png(&mut img, &Path::new("test/store.png"));
assert!(res.is_ok());
}
}
ProTip! Use n and p to navigate between commits in a pull request.
You can’t perform that action at this time.