From d42ff7f0dd81c3f5cd2a415f0d3a4f1c43eee9b3 Mon Sep 17 00:00:00 2001 From: jp9000 Date: Tue, 1 Apr 2014 11:27:27 -0700 Subject: [PATCH] Improve serializer and add array serializer The serializer code is meant to be used as a means of reading/writing data from any arbitrary type of input/output. The array output serializer makes it so we can stream data to a dynamic array on the fly. --- libobs/util/array-serializer.c | 45 ++++++++++++++ libobs/util/array-serializer.h | 28 +++++++++ libobs/util/serializer.h | 110 +++++++++++++++++++++++---------- 3 files changed, 151 insertions(+), 32 deletions(-) create mode 100644 libobs/util/array-serializer.c create mode 100644 libobs/util/array-serializer.h diff --git a/libobs/util/array-serializer.c b/libobs/util/array-serializer.c new file mode 100644 index 000000000..f2dc0c259 --- /dev/null +++ b/libobs/util/array-serializer.c @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2014 Hugh Bailey + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "darray.h" +#include "array-serializer.h" + +static size_t array_output_write(void *param, const void *data, size_t size) +{ + struct array_output_data *output = param; + da_push_back_array(output->bytes, data, size); + return size; +} + +static uint64_t array_output_get_pos(void *param) +{ + struct array_output_data *data = param; + return data->bytes.num; +} + +void array_output_serializer_init(struct serializer *s, + struct array_output_data *data) +{ + memset(data, 0, sizeof(struct array_output_data)); + s->data = data; + s->write = array_output_write; + s->get_pos = array_output_get_pos; +} + +void array_output_serializer_free(struct array_output_data *data) +{ + da_free(data->bytes); +} diff --git a/libobs/util/array-serializer.h b/libobs/util/array-serializer.h new file mode 100644 index 000000000..64bcd9d99 --- /dev/null +++ b/libobs/util/array-serializer.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2014 Hugh Bailey + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#pragma once + +#include "serializer.h" +#include "darray.h" + +struct array_output_data { + DARRAY(uint8_t) bytes; +}; + +EXPORT void array_output_serializer_init(struct serializer *s, + struct array_output_data *data); +EXPORT void array_output_serializer_free(struct array_output_data *data); diff --git a/libobs/util/serializer.h b/libobs/util/serializer.h index 08f7c9707..4e812bcc7 100644 --- a/libobs/util/serializer.h +++ b/libobs/util/serializer.h @@ -16,11 +16,11 @@ #pragma once +#include "c99defs.h" + /* * General programmable serialization functions. (A shared interface to * various reading/writing to/from different inputs/outputs) - * - * TODO: Not currently implemented */ #ifdef __cplusplus @@ -34,16 +34,37 @@ enum serialize_seek_type { }; struct serializer { - void *param; - size_t (*serialize)(struct serializer, void *, size_t); - uint64_t (*seek)(struct serializer, int64_t, enum serialize_seek_type); - uint64_t (*getpos)(struct serializer); + void *data; + + size_t (*read)(void *, void *, size_t); + size_t (*write)(void *, const void *, size_t); + uint64_t (*seek)(void *, int64_t, enum serialize_seek_type); + uint64_t (*get_pos)(void *); }; +static inline size_t s_read(struct serializer *s, void *data, size_t size) +{ + if (s && s->read && data && size) + return s->read(s->data, (void*)data, size); + return 0; +} + +static inline size_t s_write(struct serializer *s, const void *data, + size_t size) +{ + if (s && s->write && data && size) + return s->write(s->data, (void*)data, size); + return 0; +} + static inline size_t serialize(struct serializer *s, void *data, size_t len) { - if (s->serialize) - return s->serialize(s, data, len); + if (s) { + if (s->write) + return s->write(s, data, len); + else if (s->read) + return s->read(s, data, len); + } return 0; } @@ -51,66 +72,91 @@ static inline size_t serialize(struct serializer *s, void *data, size_t len) static inline uint64_t serializer_seek(struct serializer *s, int64_t offset, enum serialize_seek_type seek_type) { - if (s->seek) + if (s && s->seek) return s->seek(s, offset, seek_type); return 0; } -static inline uint64_t serializer_getpos(struct serializer *s) +static inline uint64_t serializer_get_pos(struct serializer *s) { - if (s->getpos) - return s->getpos(s); + if (s && s->get_pos) + return s->get_pos(s); return 0; } -static inline void serializer_write_u8(struct serializer *s, uint8_t u8) +/* formatted this to be similar to the AVIO layout that ffmpeg uses */ + +static inline void s_w8(struct serializer *s, uint8_t u8) { - serialize(s, &u8, sizeof(uint8_t)); + s_write(s, &u8, sizeof(uint8_t)); } -static inline void serializer_write_i8(struct serializer *s, int8_t i8) +static inline void s_wl16(struct serializer *s, uint16_t u16) { - serialize(s, &i8, sizeof(int8_t)); + s_w8(s, (uint8_t)u16); + s_w8(s, u16 >> 8); } -static inline void serializer_write_u16(struct serializer *s, uint16_t u16) +static inline void s_wl24(struct serializer *s, uint32_t u24) { - serialize(s, &u16, sizeof(uint16_t)); + s_w8 (s, (uint8_t)u24); + s_wl16(s, (uint16_t)(u24 >> 8)); } -static inline void serializer_write_i16(struct serializer *s, int16_t i16) +static inline void s_wl32(struct serializer *s, uint32_t u32) { - serialize(s, &i16, sizeof(int16_t)); + s_wl16(s, (uint16_t)u32); + s_wl16(s, (uint16_t)(u32 >> 16)); } -static inline void serializer_write_u32(struct serializer *s, uint32_t u32) +static inline void s_wl64(struct serializer *s, uint64_t u64) { - serialize(s, &u32, sizeof(uint32_t)); + s_wl32(s, (uint32_t)u64); + s_wl32(s, (uint32_t)(u64 >> 32)); } -static inline void serializer_write_i32(struct serializer *s, int32_t i32) +static inline void s_wlf(struct serializer *s, float f) { - serialize(s, &i32, sizeof(int32_t)); + s_wl32(s, *(uint32_t*)&f); } -static inline void serializer_write_u64(struct serializer *s, uint32_t u64) +static inline void s_wld(struct serializer *s, double d) { - serialize(s, &u64, sizeof(uint64_t)); + s_wl64(s, *(uint64_t*)&d); } -static inline void serializer_write_i64(struct serializer *s, int32_t i64) +static inline void s_wb16(struct serializer *s, uint16_t u16) { - serialize(s, &i64, sizeof(int64_t)); + s_w8(s, u16 >> 8); + s_w8(s, (uint8_t)u16); } -static inline void serializer_write_float(struct serializer *s, float f) +static inline void s_wb24(struct serializer *s, uint32_t u24) { - serialize(s, &f, sizeof(float)); + s_wb16(s, (uint16_t)(u24 >> 8)); + s_w8 (s, (uint8_t)u24); } -static inline void serializer_write_double(struct serializer *s, double d) +static inline void s_wb32(struct serializer *s, uint32_t u32) { - serialize(s, &d, sizeof(double)); + s_wb16(s, (uint16_t)(u32 >> 16)); + s_wb16(s, (uint16_t)u32); +} + +static inline void s_wb64(struct serializer *s, uint64_t u64) +{ + s_wb32(s, (uint32_t)(u64 >> 32)); + s_wb32(s, (uint32_t)u64); +} + +static inline void s_wbf(struct serializer *s, float f) +{ + s_wb32(s, *(uint32_t*)&f); +} + +static inline void s_wbd(struct serializer *s, double d) +{ + s_wb64(s, *(uint64_t*)&d); } #ifdef __cplusplus