lifegpc/pixiv_downloader
1
0
Fork 0
mirror of https://github.com/lifegpc/pixiv_downloader.git synced 2026-06-19 01:14:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update exif module

Browse Source
This commit is contained in:
lifegpc
2023-03-26 07:41:42 +00:00
committed by GitHub
parent 7867190b23
commit c9204f4d54
5 changed files with 215 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
build.rs
View File

@@ -154,6 +154,8 @@ fn main() {
// included header files changed.
.parse_callbacks(Box::new(bindgen::CargoCallbacks))
.no_copy("ExifDataRef")
.no_copy("ExifDatumRef")
.no_copy("ExifValueRef")
// Finish the builder and generate the bindings.
.generate()
// Unwrap the Result and panic on failure.

23
exif/exif.h
View File

@@ -21,6 +21,8 @@ typedef struct ExifDataRef ExifDataRef;
typedef struct ExifDataItor ExifDataItor;
/// <div rustbindgen opaque></div>
typedef struct ExifDatumRef ExifDatumRef;
/// <div rustbindgen opaque></div>
typedef struct ExifValueRef ExifValueRef;
#if defined _WIN32 && defined WIN32_DLL
#if BUILD_DLL
#define EXIF_API __declspec(dllexport)
@@ -51,15 +53,17 @@ EXIF_API int exif_get_key_default_type_id(ExifKey* key);
EXIF_API void exif_free(void* v);
EXIF_API void exif_free_key(ExifKey* key);
EXIF_API ExifValue* exif_create_value(int type_id);
EXIF_API int exif_get_value_type_id(ExifValue* value);
EXIF_API long exif_get_value_count(ExifValue* value);
EXIF_API long exif_get_value_size(ExifValue* value);
EXIF_API long exif_get_value_size_data_area(ExifValue *value);
EXIF_API int exif_value_read(ExifValue* value, const uint8_t* bytes, long len, int byte_order);
EXIF_API int exif_get_value_ok(ExifValue* value);
EXIF_API char* exif_value_to_string(ExifValue* value, size_t* len);
EXIF_API char* exif_value_to_string2(ExifValue* value, size_t* len, long i);
EXIF_API int64_t exif_value_to_int64(ExifValue* value, long i);
EXIF_API ExifValueRef* exif_value_get_ref(ExifValue* value);
EXIF_API int exif_get_value_type_id(ExifValueRef* value);
EXIF_API long exif_get_value_count(ExifValueRef* value);
EXIF_API long exif_get_value_size(ExifValueRef* value);
EXIF_API long exif_get_value_size_data_area(ExifValueRef *value);
EXIF_API int exif_value_read(ExifValueRef* value, const uint8_t* bytes, long len, int byte_order);
EXIF_API int exif_get_value_ok(ExifValueRef* value);
EXIF_API char* exif_value_to_string(ExifValueRef* value, size_t* len);
EXIF_API char* exif_value_to_string2(ExifValueRef* value, size_t* len, long i);
EXIF_API int64_t exif_value_to_int64(ExifValueRef* value, long i);
EXIF_API ExifValue* exif_value_ref_clone(ExifValueRef* value);
EXIF_API ExifData* exif_data_new();
EXIF_API int exif_data_ref_add(ExifDataRef* d, ExifKey* key, ExifValue* value);
EXIF_API int exif_data_ref_clear(ExifDataRef* d);
@@ -72,6 +76,7 @@ EXIF_API void exif_data_ref_sort_by_tag(ExifDataRef* d);
EXIF_API ExifDataItor* exif_data_ref_iter(ExifDataRef* d);
EXIF_API ExifDatumRef* exif_data_itor_next(ExifDataItor* itor);
EXIF_API char* exif_datum_key(ExifDatumRef* d);
EXIF_API ExifValueRef* exif_datum_value(ExifDatumRef *d);
EXIF_API void exif_free_value(ExifValue* value);
EXIF_API void exif_free_data(ExifData* d);
EXIF_API void exif_free_data_itor(ExifDataItor* itor);

71
exif/src/exif.cpp
View File

@@ -196,38 +196,44 @@ end:
return nullptr;
}
int exif_get_value_type_id(ExifValue* value) {
if (!value) return -1;
ExifValueRef* exif_value_get_ref(ExifValue* value) {
if (!value) return nullptr;
value->ref.value = value->value.get();
return &value->ref;
}
int exif_get_value_type_id(ExifValueRef* value) {
if (!value || !value->value) return -1;
return value->value->typeId();
}
long exif_get_value_count(ExifValue* value) {
if (!value) return -1;
long exif_get_value_count(ExifValueRef* value) {
if (!value || !value->value) return -1;
return value->value->count();
}
long exif_get_value_size(ExifValue* value) {
if (!value) return -1;
long exif_get_value_size(ExifValueRef* value) {
if (!value || !value->value) return -1;
return value->value->size();
}
long exif_get_value_size_data_area(ExifValue* value) {
if (!value) return -1;
long exif_get_value_size_data_area(ExifValueRef* value) {
if (!value || !value->value) return -1;
return value->value->sizeDataArea();
}
int exif_value_read(ExifValue* value, const uint8_t* bytes, long len, int byte_order) {
if (!value || !bytes) return -1;
int exif_value_read(ExifValueRef* value, const uint8_t* bytes, long len, int byte_order) {
if (!value || !bytes || !value->value) return -1;
return value->value->read(bytes, len, static_cast<Exiv2::ByteOrder>(byte_order));
}
int exif_get_value_ok(ExifValue* value) {
if (!value) return 0;
int exif_get_value_ok(ExifValueRef* value) {
if (!value || !value->value) return 0;
return value->value->ok() ? 1 : 0;
}
char* exif_value_to_string(ExifValue* value, size_t* len) {
if (!value || !len) return nullptr;
char* exif_value_to_string(ExifValueRef* value, size_t* len) {
if (!value || !len || !value->value) return nullptr;
auto s = value->value->toString();
*len = s.size();
char* tmp = nullptr;
@@ -235,8 +241,8 @@ char* exif_value_to_string(ExifValue* value, size_t* len) {
return tmp;
}
char* exif_value_to_string2(ExifValue* value, size_t* len, long i) {
if (!value || !len) return nullptr;
char* exif_value_to_string2(ExifValueRef* value, size_t* len, long i) {
if (!value || !len || !value->value) return nullptr;
auto s = value->value->toString(i);
*len = s.size();
char* tmp = nullptr;
@@ -244,11 +250,26 @@ char* exif_value_to_string2(ExifValue* value, size_t* len, long i) {
return tmp;
}
int64_t exif_value_to_int64(ExifValue* value, long i) {
if (!value) return -1;
int64_t exif_value_to_int64(ExifValueRef* value, long i) {
if (!value || !value->value) return -1;
return value->value->toInt64(i);
}
ExifValue* exif_value_ref_clone(ExifValueRef* value) {
if (!value || !value->value) return nullptr;
ExifValue* v = new ExifValue;
try {
v->value = value->value->clone();
} catch (std::exception& e) {
printf("%s\n", e.what());
goto end;
}
return v;
end:
if (v) delete v;
return nullptr;
}
ExifData* exif_data_new() {
return new ExifData;
}
@@ -299,6 +320,7 @@ long exif_data_ref_get_count(ExifDataRef* d) {
void exif_free_value(ExifValue* value) {
if (!value) return;
value->ref.value = nullptr;
delete value;
}
@@ -342,8 +364,19 @@ ExifDatumRef* exif_data_itor_next(ExifDataItor* itor) {
}
char* exif_datum_key(ExifDatumRef* d) {
if (!d->data) return nullptr;
if (!d || !d->data) return nullptr;
char* re = nullptr;
if (!string2char(d->data->key(), re)) return nullptr;
return re;
}
ExifValueRef* exif_datum_value(ExifDatumRef *d) {
if (!d || !d->data) return nullptr;
try {
d->ref.value = (Exiv2::Value*)&d->data->value();
} catch (std::exception& e) {
printf("%s\n", e.what());
return nullptr;
}
return &d->ref;
}

13
exif/src/exif_priv.h
View File

@@ -11,20 +11,25 @@ typedef struct ExifImage {
typedef struct ExifKey {
Exiv2::ExifKey* key = nullptr;
} ExifKey;
typedef struct ExifValueRef {
Exiv2::Value* value;
} ExifValueRef;
typedef struct ExifValue {
Exiv2::Value::UniquePtr value;
ExifValueRef ref;
} ExifValue;
typedef struct ExifData {
Exiv2::ExifData data;
ExifDataRef ref;
} ExifData;
typedef struct ExifDatum {
Exiv2::Exifdatum data;
ExifDataRef ref;
} ExifDatum;
typedef struct ExifDatumRef {
Exiv2::Exifdatum* data;
ExifValueRef ref;
} ExifDatumRef;
typedef struct ExifDatum {
Exiv2::Exifdatum data;
ExifDatumRef ref;
} ExifDatum;
typedef struct ExifDataItor {
ExifDataRef ref;
ExifDatumRef ref2;

177
src/exif.rs
View File

@@ -1,5 +1,5 @@
use crate::_exif;
use crate::_exif::{ExifDataRef, ExifDatumRef};
use crate::_exif::{ExifDataRef, ExifDatumRef, ExifValueRef};
use crate::ext::rawhandle::FromRawHandle;
use crate::ext::rawhandle::ToRawHandle;
use c_fixed_string::CFixedStr;
@@ -323,6 +323,12 @@ pub struct ExifValue {
value: *mut _exif::ExifValue,
}
impl ExifValue {
pub unsafe fn from_raw_pointer(value: *mut _exif::ExifValue) -> Self {
Self { value }
}
}
impl TryFrom<ExifTypeID> for ExifValue {
type Error = ();
fn try_from(value: ExifTypeID) -> Result<Self, Self::Error> {
@@ -346,10 +352,40 @@ impl TryFrom<i32> for ExifValue {
}
}
impl Borrow<ExifValueRef> for ExifValue {
fn borrow(&self) -> &ExifValueRef {
self.deref()
}
}
impl BorrowMut<ExifValueRef> for ExifValue {
fn borrow_mut(&mut self) -> &mut ExifValueRef {
self.deref_mut()
}
}
impl Deref for ExifValue {
type Target = ExifValueRef;
fn deref(&self) -> &Self::Target {
unsafe {
ExifValueRef::from_const_handle(
_exif::exif_value_get_ref(self.to_raw_handle()) as *const ExifValueRef
)
}
}
}
impl DerefMut for ExifValue {
fn deref_mut(&mut self) -> &mut Self::Target {
unsafe { ExifValueRef::from_raw_handle(_exif::exif_value_get_ref(self.to_raw_handle())) }
}
}
impl Drop for ExifValue {
fn drop(&mut self) {
if !self.value.is_null() {
unsafe { _exif::exif_free_value(self.value) };
self.value = std::ptr::null_mut();
}
}
}
@@ -361,13 +397,14 @@ impl ToRawHandle<_exif::ExifValue> for ExifValue {
}
#[allow(dead_code)]
impl ExifValue {
impl ExifValueRef {
/// Return the type identifier (Exif data format type).
pub fn type_id(&self) -> Option<ExifTypeID> {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return None;
}
let r = unsafe { _exif::exif_get_value_type_id(self.value) };
let r = unsafe { _exif::exif_get_value_type_id(value) };
if r == 0 {
return None;
}
@@ -380,10 +417,11 @@ impl ExifValue {
/// Return the number of components of the value.
pub fn count(&self) -> Option<usize> {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return None;
}
let r = unsafe { _exif::exif_get_value_count(self.value) };
let r = unsafe { _exif::exif_get_value_count(value) };
if r < 0 {
return None;
}
@@ -392,10 +430,11 @@ impl ExifValue {
/// Return the size of the value in bytes.
pub fn size(&self) -> Option<usize> {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return None;
}
let r = unsafe { _exif::exif_get_value_size(self.value) };
let r = unsafe { _exif::exif_get_value_size(value) };
if r < 0 {
return None;
}
@@ -404,10 +443,11 @@ impl ExifValue {
/// Return the size of the data area, 0 if there is none.
pub fn size_data_area(&self) -> Option<usize> {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return None;
}
let r = unsafe { _exif::exif_get_value_size_data_area(self.value) };
let r = unsafe { _exif::exif_get_value_size_data_area(value) };
if r < 0 {
return None;
}
@@ -418,7 +458,8 @@ impl ExifValue {
/// * `buf` - Buffer
/// * `byte_order` - Applicable byte order (little or big endian). Default: invaild.
pub fn read(&mut self, buf: &[u8], byte_order: Option<ExifByteOrder>) -> Result<(), ()> {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return Err(());
}
let buf_len = buf.len() as c_long;
@@ -428,7 +469,7 @@ impl ExifValue {
};
let order = order.int_value();
let ptr = buf.as_ptr();
let r = unsafe { _exif::exif_value_read(self.value, ptr, buf_len, order) };
let r = unsafe { _exif::exif_value_read(value, ptr, buf_len, order) };
if r == 0 {
Ok(())
} else {
@@ -439,7 +480,8 @@ impl ExifValue {
/// Return the value / n-th component of the value as a string
/// * `n` - specify the component, if None, return whole value
pub fn to_string(&self, n: Option<usize>) -> Option<CString> {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return None;
}
if n.is_some() {
@@ -457,9 +499,9 @@ impl ExifValue {
return None;
}
let r = if n.is_none() {
unsafe { _exif::exif_value_to_string(self.value, ptr) }
unsafe { _exif::exif_value_to_string(value, ptr) }
} else {
unsafe { _exif::exif_value_to_string2(self.value, ptr, n.unwrap() as c_long) }
unsafe { _exif::exif_value_to_string2(value, ptr, n.unwrap() as c_long) }
};
if r.is_null() {
return None;
@@ -476,16 +518,18 @@ impl ExifValue {
/// Check the ok status indicator.
/// After a `to<Type>` conversion, this indicator shows whether the conversion was successful.
pub fn ok(&self) -> bool {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return false;
}
let r = unsafe { _exif::exif_get_value_ok(self.value) };
let r = unsafe { _exif::exif_get_value_ok(value) };
r != 0
}
/// Convert the n-th component of the value to a int64
pub fn to_int64(&self, n: usize) -> Option<i64> {
if self.value.is_null() {
let value = unsafe { self.to_raw_handle() };
if value.is_null() {
return None;
}
let c = self.count();
@@ -496,7 +540,7 @@ impl ExifValue {
if n >= c {
return None;
}
let r = unsafe { _exif::exif_value_to_int64(self.value, n as c_long) };
let r = unsafe { _exif::exif_value_to_int64(value, n as c_long) };
if !self.ok() {
return None;
}
@@ -504,6 +548,30 @@ impl ExifValue {
}
}
impl ToRawHandle<ExifValueRef> for ExifValueRef {
unsafe fn to_raw_handle(&self) -> *mut ExifValueRef {
self.to_const_handle() as *mut ExifValueRef
}
unsafe fn to_const_handle(&self) -> *const ExifValueRef {
self
}
}
impl ToOwned for ExifValueRef {
type Owned = ExifValue;
fn to_owned(&self) -> Self::Owned {
let v = unsafe { self.to_raw_handle() };
if v.is_null() {
panic!("ExifValue reference is null.");
}
let r = unsafe { _exif::exif_value_ref_clone(v) };
if r.is_null() {
panic!("Failed to convert ExifValueRef to ExifValue");
}
unsafe { ExifValue::from_raw_pointer(r) }
}
}
#[allow(dead_code)]
impl ExifDatumRef {
/// Return the key of the Exifdatum.
@@ -526,6 +594,22 @@ impl ExifDatumRef {
let s = s.unwrap();
Some(s.to_owned())
}
/// Return a constant reference to the value.
///
/// This method is provided mostly for convenient and versatile output of the value which can (to some extent) be formatted through standard stream manipulators.
/// An Error is thrown if the value is not set; as an alternative to catching it, one can use count() to check if there is any data before calling this method.
pub fn value<'a>(&'a self) -> Option<&'a ExifValueRef> {
let data = unsafe { self.to_raw_handle() };
if data.is_null() {
return None;
}
let r = unsafe { _exif::exif_datum_value(data) };
if r.is_null() {
return None;
}
Some(unsafe { ExifValueRef::from_const_handle(r as *const ExifValueRef) })
}
}
impl ToRawHandle<ExifDatumRef> for ExifDatumRef {
@@ -731,20 +815,8 @@ impl<'a> Drop for ExifDataItor<'a> {
}
}
pub struct ExifDatumConstRef<'a> {
r: *mut ExifDatumRef,
phantom: PhantomData<&'a ExifDatumRef>,
}
impl<'a> Deref for ExifDatumConstRef<'a> {
type Target = ExifDatumRef;
fn deref(&self) -> &Self::Target {
unsafe { ExifDatumRef::from_const_handle(self.r as *const ExifDatumRef) }
}
}
impl<'a> Iterator for ExifDataItor<'a> {
type Item = ExifDatumConstRef<'a>;
type Item = &'a ExifDatumRef;
fn next(&mut self) -> Option<Self::Item> {
if self.itor.is_null() {
return None;
@@ -753,10 +825,7 @@ impl<'a> Iterator for ExifDataItor<'a> {
if r.is_null() {
return None;
}
Some(ExifDatumConstRef {
r,
phantom: PhantomData,
})
Some(unsafe { ExifDatumRef::from_const_handle(r as *const ExifDatumRef) })
}
}
@@ -793,7 +862,7 @@ impl ExifImage {
/// Returns a read only [ExifData] ([ExifDataRef]) instance containing currently buffered Exif data.
/// The Exif data in the returned instance will be written to the image when [Self::write_metadata()] is called.
pub fn exif_data(&self) -> Option<&ExifDataRef> {
pub fn exif_data<'a>(&'a self) -> Option<&'a ExifDataRef> {
if self.img.is_null() {
return None;
}
@@ -806,7 +875,7 @@ impl ExifImage {
/// Returns an ExifData instance containing currently buffered Exif data.
/// The Exif data in the returned instance will be written to the image when [Self::write_metadata()] is called.
pub fn exif_data_as_mut(&mut self) -> Option<&mut ExifDataRef> {
pub fn exif_data_as_mut<'a>(&'a mut self) -> Option<&'a mut ExifDataRef> {
if self.img.is_null() {
return None;
}
@@ -920,9 +989,25 @@ fn test_exif_value() {
assert_eq!(Some(4), v.size());
assert_eq!(Some(CString::new("116").unwrap()), v.to_string(Some(0)));
let mut v2 = ExifValue::try_from(ExifTypeID::SLongLong).unwrap();
v2.read(&(102345 as i64).to_le_bytes(), Some(ExifByteOrder::Little))
v2.read(&(102345i64).to_le_bytes(), Some(ExifByteOrder::Little))
.unwrap();
assert_eq!(Some(8), v2.count());
let v3: &ExifValueRef = &v2;
assert_eq!(
v3.to_string(None),
Some(CString::new("201 143 1 0 0 0 0 0").unwrap())
);
let mut v4 = v3.to_owned();
v4.read(&(102346i64).to_le_bytes(), Some(ExifByteOrder::Little))
.unwrap();
assert_eq!(
v3.to_string(None),
Some(CString::new("201 143 1 0 0 0 0 0").unwrap())
);
assert_eq!(
v4.to_string(None),
Some(CString::new("202 143 1 0 0 0 0 0").unwrap())
);
}
#[test]
@@ -953,6 +1038,20 @@ fn test_exif_data() {
Some(String::from("Exif.Image.PageName"))
);
assert!(i.next().is_none());
let mut i = 0;
for data in d.iter().unwrap() {
i += 1;
match data.key().unwrap().as_str() {
"Exif.Image.PageName" => {
assert_eq!(i, 2);
let v = data.value().unwrap();
assert_eq!(v.to_string(None), Some(CString::new("p1").unwrap()));
}
"Exif.Image.XPTitle" => assert_eq!(i, 1),
_ => {}
}
}
assert_eq!(i, 2);
}
#[test]