From 24495d66550dd17ee42e9858a7f1ad30187371d5 Mon Sep 17 00:00:00 2001 From: Hugues Delorme Date: Tue, 5 Feb 2013 12:24:13 +0100 Subject: [PATCH] c-libstl: add _set_cookie() functions and buffer parameter --- src/c/libstl/stlb_read.c | 26 +++++---- src/c/libstl/stlb_read.h | 20 ++++--- src/c/libstl/stlb_write.c | 114 +++++++++++++++++++++++++------------- src/c/libstl/stlb_write.h | 20 ++++--- src/c/stream.c | 6 ++ src/c/stream.h | 1 + src/c/task_control.c | 10 +++- src/c/task_control.h | 1 + 8 files changed, 133 insertions(+), 65 deletions(-) diff --git a/src/c/libstl/stlb_read.c b/src/c/libstl/stlb_read.c index 2864edb..0dac316 100644 --- a/src/c/libstl/stlb_read.c +++ b/src/c/libstl/stlb_read.c @@ -29,6 +29,12 @@ void* foug_stlb_geom_input_get_cookie(const foug_stlb_geom_input_t* geom) return geom != NULL ? geom->cookie : NULL; } +void foug_stlb_geom_input_set_cookie(foug_stlb_geom_input_t* geom, void* data) +{ + if (geom != NULL) + geom->cookie = data; +} + static foug_bool_t foug_stlb_no_error(int code) { return code == FOUG_STLB_READ_NO_ERROR; @@ -79,7 +85,6 @@ static void foug_stlb_read_facets(foug_stlb_geom_input_t* geom_input, int foug_stlb_read(foug_stlb_read_args_t args) { - uint8_t buffer[8192]; uint8_t header_data[FOUG_STLB_HEADER_SIZE]; uint32_t total_facet_count; size_t buffer_facet_count; @@ -91,8 +96,10 @@ int foug_stlb_read(foug_stlb_read_args_t args) return FOUG_STLB_READ_NULL_GEOM_INPUT_ERROR; if (args.stream == NULL) return FOUG_STLB_READ_NULL_STREAM_ERROR; -/* if (args.buffer_size == 0) - return FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR;*/ + if (args.buffer == NULL) + return FOUG_STLB_READ_NULL_BUFFER; + if (args.buffer_size < FOUG_STLB_MIN_CONTENTS_SIZE) + return FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR; /* Read header */ if (foug_stream_read(args.stream, header_data, 1, FOUG_STLB_HEADER_SIZE) != FOUG_STLB_HEADER_SIZE) @@ -102,10 +109,10 @@ int foug_stlb_read(foug_stlb_read_args_t args) (*(args.geom_input->manip.process_header_func))(args.geom_input, header_data); /* Read facet count */ - if (foug_stream_read(args.stream, buffer, sizeof(uint32_t), 1) != 1) + if (foug_stream_read(args.stream, args.buffer, sizeof(uint32_t), 1) != 1) return FOUG_STLB_READ_FACET_COUNT_ERROR; - total_facet_count = foug_decode_uint32_le(buffer); + total_facet_count = foug_decode_uint32_le(args.buffer); if (args.geom_input->manip.begin_triangles_func != NULL) (*(args.geom_input->manip.begin_triangles_func))(args.geom_input, total_facet_count); @@ -113,12 +120,12 @@ int foug_stlb_read(foug_stlb_read_args_t args) foug_task_control_set_range(args.task_control, 0., (foug_real32_t)total_facet_count); /* Read triangles */ - buffer_facet_count = 163; + buffer_facet_count = args.buffer_size / FOUG_STLB_TRIANGLE_SIZE; accum_facet_count_read = 0; error = FOUG_STLB_READ_NO_ERROR; while (foug_stlb_no_error(error) && accum_facet_count_read < total_facet_count) { facet_count_read = foug_stream_read(args.stream, - buffer, FOUG_STLB_TRIANGLE_SIZE, buffer_facet_count); + args.buffer, FOUG_STLB_TRIANGLE_SIZE, buffer_facet_count); if (foug_stream_error(args.stream) != 0) error = FOUG_STLB_READ_STREAM_ERROR; else if (facet_count_read > 0) @@ -127,15 +134,14 @@ int foug_stlb_read(foug_stlb_read_args_t args) break; /* Exit if no facet to read */ if (foug_stlb_no_error(error)) { - foug_stlb_read_facets(args.geom_input, buffer, facet_count_read); + foug_stlb_read_facets_one_go(args.geom_input, args.buffer, facet_count_read); accum_facet_count_read += facet_count_read; if (foug_task_control_is_stop_requested(args.task_control)) { error = FOUG_STLB_READ_TASK_STOPPED_ERROR; foug_task_control_handle_stop(args.task_control); } else { - foug_task_control_set_progress(args.task_control, - (foug_real32_t)accum_facet_count_read); + foug_task_control_set_progress(args.task_control, (foug_real32_t)accum_facet_count_read); } } } /* end while */ diff --git a/src/c/libstl/stlb_read.h b/src/c/libstl/stlb_read.h index e831c26..6f174ad 100644 --- a/src/c/libstl/stlb_read.h +++ b/src/c/libstl/stlb_read.h @@ -30,25 +30,29 @@ foug_stlb_geom_input_t* foug_stlb_geom_input_create(foug_malloc_func_t func, FOUG_DATAEX_LIBSTL_EXPORT void* foug_stlb_geom_input_get_cookie(const foug_stlb_geom_input_t* geom); +FOUG_DATAEX_LIBSTL_EXPORT +void foug_stlb_geom_input_set_cookie(foug_stlb_geom_input_t* geom, void* data); typedef struct { foug_stlb_geom_input_t* geom_input; foug_stream_t* stream; foug_task_control_t* task_control; + uint8_t* buffer; uint32_t buffer_size; } foug_stlb_read_args_t; FOUG_DATAEX_LIBSTL_EXPORT int foug_stlb_read(foug_stlb_read_args_t args); -#define FOUG_STLB_READ_NO_ERROR 0 -#define FOUG_STLB_READ_NULL_GEOM_INPUT_ERROR 1 -#define FOUG_STLB_READ_NULL_STREAM_ERROR 2 -#define FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR 3 -#define FOUG_STLB_READ_HEADER_WRONG_SIZE_ERROR 4 -#define FOUG_STLB_READ_FACET_COUNT_ERROR 5 -#define FOUG_STLB_READ_STREAM_ERROR 6 -#define FOUG_STLB_READ_TASK_STOPPED_ERROR 7 +#define FOUG_STLB_READ_NO_ERROR 0 +#define FOUG_STLB_READ_NULL_GEOM_INPUT_ERROR 1 +#define FOUG_STLB_READ_NULL_STREAM_ERROR 2 +#define FOUG_STLB_READ_NULL_BUFFER 3 +#define FOUG_STLB_READ_INVALID_BUFFER_SIZE_ERROR 4 +#define FOUG_STLB_READ_HEADER_WRONG_SIZE_ERROR 5 +#define FOUG_STLB_READ_FACET_COUNT_ERROR 6 +#define FOUG_STLB_READ_STREAM_ERROR 7 +#define FOUG_STLB_READ_TASK_STOPPED_ERROR 8 #endif /* FOUG_C_LIBSTL_STLB_READ_H */ diff --git a/src/c/libstl/stlb_write.c b/src/c/libstl/stlb_write.c index 4fc6994..0ae48cb 100644 --- a/src/c/libstl/stlb_write.c +++ b/src/c/libstl/stlb_write.c @@ -30,27 +30,79 @@ void* foug_stlb_geom_output_get_cookie(const foug_stlb_geom_output_t* geom) return geom != NULL ? geom->cookie : NULL; } +void foug_stlb_geom_output_set_cookie(foug_stlb_geom_output_t* geom, void* data) +{ + if (geom != NULL) + geom->cookie = data; +} + static foug_bool_t foug_stlb_no_error(int code) { return code == FOUG_STLB_WRITE_NO_ERROR; } -int foug_stlb_write(foug_stlb_write_args_t args) +static void foug_stlb_write_facets(const foug_stlb_geom_output_t* geom_output, + uint8_t* buffer, + uint32_t ifacet_start, + uint32_t facet_count) { - uint8_t buffer[128]; - uint8_t header_data[FOUG_STLB_HEADER_SIZE]; - uint32_t facet_count; foug_stl_triangle_t triangle; uint16_t attr_byte_count; + uint32_t buffer_offset; uint32_t i_facet; + + if (geom_output->manip.get_triangle_func == NULL) + return; + + attr_byte_count = 0; + buffer_offset = 0; + for (i_facet = ifacet_start; i_facet < (ifacet_start + facet_count); ++i_facet) { + (*(geom_output->manip.get_triangle_func))(geom_output, i_facet, &triangle, &attr_byte_count); + + /* Normal */ + foug_encode_real32_le(triangle.normal.x, buffer + buffer_offset); + foug_encode_real32_le(triangle.normal.y, buffer + 1*sizeof(foug_real32_t) + buffer_offset); + foug_encode_real32_le(triangle.normal.z, buffer + 2*sizeof(foug_real32_t) + buffer_offset); + + /* Vertex1 */ + foug_encode_real32_le(triangle.v1.x, buffer + 3*sizeof(foug_real32_t) + buffer_offset); + foug_encode_real32_le(triangle.v1.y, buffer + 4*sizeof(foug_real32_t) + buffer_offset); + foug_encode_real32_le(triangle.v1.z, buffer + 5*sizeof(foug_real32_t) + buffer_offset); + + /* Vertex2 */ + foug_encode_real32_le(triangle.v2.x, buffer + 6*sizeof(foug_real32_t) + buffer_offset); + foug_encode_real32_le(triangle.v2.y, buffer + 7*sizeof(foug_real32_t) + buffer_offset); + foug_encode_real32_le(triangle.v2.z, buffer + 8*sizeof(foug_real32_t) + buffer_offset); + + /* Vertex3 */ + foug_encode_real32_le(triangle.v3.x, buffer + 9*sizeof(foug_real32_t) + buffer_offset); + foug_encode_real32_le(triangle.v3.y, buffer + 10*sizeof(foug_real32_t) + buffer_offset); + foug_encode_real32_le(triangle.v3.z, buffer + 11*sizeof(foug_real32_t) + buffer_offset); + + /* Attribute byte count */ + foug_encode_uint16_le(attr_byte_count, buffer + 12*sizeof(foug_real32_t) + buffer_offset); + + buffer_offset += FOUG_STLB_TRIANGLE_SIZE; + } /* end for */ +} + +int foug_stlb_write(foug_stlb_write_args_t args) +{ + uint8_t header_data[FOUG_STLB_HEADER_SIZE]; + uint32_t facet_count; + uint32_t i_facet; + uint32_t buffer_facet_count; + uint32_t ifacet_start; int error; if (args.geom_output == NULL) return FOUG_STLB_WRITE_NULL_GEOM_OUTPUT_ERROR; if (args.stream == NULL) return FOUG_STLB_WRITE_NULL_STREAM_ERROR; -/* if (args.buffer_size == 0) - return FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR;*/ + if (args.buffer == NULL) + return FOUG_STLB_WRITE_NULL_BUFFER_ERROR; + if (args.buffer_size < FOUG_STLB_MIN_CONTENTS_SIZE) + return FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR; if (args.geom_output->manip.get_triangle_count_func == NULL) return FOUG_STLB_WRITE_NULL_GET_TRIANGLE_COUNT_FUNC; if (args.geom_output->manip.get_triangle_func == NULL) @@ -67,46 +119,34 @@ int foug_stlb_write(foug_stlb_write_args_t args) /* Write facet count */ facet_count = (*(args.geom_output->manip.get_triangle_count_func))(args.geom_output); - foug_encode_uint32_le(facet_count, buffer); - if (foug_stream_write(args.stream, buffer, sizeof(uint32_t), 1) != 1) + foug_encode_uint32_le(facet_count, args.buffer); + if (foug_stream_write(args.stream, args.buffer, sizeof(uint32_t), 1) != 1) return FOUG_STLB_WRITE_STREAM_ERROR; foug_task_control_reset(args.task_control); foug_task_control_set_range(args.task_control, 0., (foug_real32_t)facet_count); /* Write triangles */ - attr_byte_count = 0; error = FOUG_STLB_WRITE_NO_ERROR; - for (i_facet = 0; i_facet < facet_count && foug_stlb_no_error(error); ++i_facet) { - (*(args.geom_output->manip.get_triangle_func))(args.geom_output, i_facet, - &triangle, &attr_byte_count); - /* Normal */ - foug_encode_real32_le(triangle.normal.x, buffer); - foug_encode_real32_le(triangle.normal.y, buffer + 1*sizeof(foug_real32_t)); - foug_encode_real32_le(triangle.normal.z, buffer + 2*sizeof(foug_real32_t)); + buffer_facet_count = args.buffer_size / FOUG_STLB_TRIANGLE_SIZE; + ifacet_start = 0; + for (i_facet = 0; + i_facet < facet_count && foug_stlb_no_error(error); + i_facet += buffer_facet_count) + { + /* Write to buffer */ + if (buffer_facet_count > (facet_count - ifacet_start)) + buffer_facet_count = facet_count - ifacet_start; + foug_stlb_write_facets(args.geom_output, args.buffer, ifacet_start, buffer_facet_count); + ifacet_start += buffer_facet_count; - /* Vertex1 */ - foug_encode_real32_le(triangle.v1.x, buffer + 3*sizeof(foug_real32_t)); - foug_encode_real32_le(triangle.v1.y, buffer + 4*sizeof(foug_real32_t)); - foug_encode_real32_le(triangle.v1.z, buffer + 5*sizeof(foug_real32_t)); - - /* Vertex2 */ - foug_encode_real32_le(triangle.v2.x, buffer + 6*sizeof(foug_real32_t)); - foug_encode_real32_le(triangle.v2.y, buffer + 7*sizeof(foug_real32_t)); - foug_encode_real32_le(triangle.v2.z, buffer + 8*sizeof(foug_real32_t)); - - /* Vertex3 */ - foug_encode_real32_le(triangle.v3.x, buffer + 9*sizeof(foug_real32_t)); - foug_encode_real32_le(triangle.v3.y, buffer + 10*sizeof(foug_real32_t)); - foug_encode_real32_le(triangle.v3.z, buffer + 11*sizeof(foug_real32_t)); - - /* Attribute byte count */ - foug_encode_uint16_le(attr_byte_count, buffer + 12*sizeof(foug_real32_t)); - - /* Write to stream */ - if (foug_stream_write(args.stream, buffer, FOUG_STLB_TRIANGLE_SIZE, 1) != 1) + /* Write buffer to stream */ + if (foug_stream_write(args.stream, args.buffer, FOUG_STLB_TRIANGLE_SIZE, buffer_facet_count) + != buffer_facet_count) + { error = FOUG_STLB_WRITE_STREAM_ERROR; + } /* Task control */ if (foug_stlb_no_error(error)) { @@ -116,7 +156,7 @@ int foug_stlb_write(foug_stlb_write_args_t args) } else { foug_task_control_set_progress(args.task_control, - (foug_real32_t)(i_facet + 1)); + (foug_real32_t)(i_facet + 1)); } } } /* end for */ diff --git a/src/c/libstl/stlb_write.h b/src/c/libstl/stlb_write.h index 9a41f3e..8337746 100644 --- a/src/c/libstl/stlb_write.h +++ b/src/c/libstl/stlb_write.h @@ -29,25 +29,29 @@ foug_stlb_geom_output_t* foug_stlb_geom_output_create(foug_malloc_func_t func, FOUG_DATAEX_LIBSTL_EXPORT void* foug_stlb_geom_output_get_cookie(const foug_stlb_geom_output_t* geom); +FOUG_DATAEX_LIBSTL_EXPORT +void foug_stlb_geom_output_set_cookie(foug_stlb_geom_output_t* geom, void* data); typedef struct { foug_stlb_geom_output_t* geom_output; foug_stream_t* stream; foug_task_control_t* task_control; + uint8_t* buffer; uint32_t buffer_size; } foug_stlb_write_args_t; FOUG_DATAEX_LIBSTL_EXPORT int foug_stlb_write(foug_stlb_write_args_t args); -#define FOUG_STLB_WRITE_NO_ERROR 0 -#define FOUG_STLB_WRITE_NULL_GEOM_OUTPUT_ERROR 1 -#define FOUG_STLB_WRITE_NULL_STREAM_ERROR 2 -#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_COUNT_FUNC 3 -#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_FUNC 4 -#define FOUG_STLB_WRITE_STREAM_ERROR 5 -#define FOUG_STLB_WRITE_TASK_STOPPED_ERROR 6 -#define FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR 7 +#define FOUG_STLB_WRITE_NO_ERROR 0 +#define FOUG_STLB_WRITE_NULL_GEOM_OUTPUT_ERROR 1 +#define FOUG_STLB_WRITE_NULL_STREAM_ERROR 2 +#define FOUG_STLB_WRITE_NULL_BUFFER_ERROR 3 +#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_COUNT_FUNC 4 +#define FOUG_STLB_WRITE_NULL_GET_TRIANGLE_FUNC 5 +#define FOUG_STLB_WRITE_STREAM_ERROR 6 +#define FOUG_STLB_WRITE_TASK_STOPPED_ERROR 7 +#define FOUG_STLB_WRITE_INVALID_BUFFER_SIZE_ERROR 8 #endif /* FOUG_C_LIBSTL_STLB_WRITE_H */ diff --git a/src/c/stream.c b/src/c/stream.c index 5ac5e15..5ca637d 100644 --- a/src/c/stream.c +++ b/src/c/stream.c @@ -99,3 +99,9 @@ void* foug_stream_get_cookie(const foug_stream_t* stream) { return stream != NULL ? stream->cookie : NULL; } + +void foug_stream_set_cookie(foug_stream_t* stream, void* data) +{ + if (stream != NULL) + stream->cookie = data; +} diff --git a/src/c/stream.h b/src/c/stream.h index 41c2c0b..08a85a7 100644 --- a/src/c/stream.h +++ b/src/c/stream.h @@ -35,5 +35,6 @@ FOUG_LIB_EXPORT size_t foug_stream_read(foug_stream_t* stream, FOUG_LIB_EXPORT size_t foug_stream_write(foug_stream_t* stream, const void* ptr, size_t item_size, size_t item_count); FOUG_LIB_EXPORT void* foug_stream_get_cookie(const foug_stream_t* stream); +FOUG_LIB_EXPORT void foug_stream_set_cookie(foug_stream_t* stream, void* data); #endif /* FOUG_C_STREAM_H */ diff --git a/src/c/task_control.c b/src/c/task_control.c index b769aa9..4861efe 100644 --- a/src/c/task_control.c +++ b/src/c/task_control.c @@ -27,7 +27,7 @@ foug_task_control_t* foug_task_control_create(foug_malloc_func_t func, return NULL; ctrl = (*func)(sizeof(struct _internal_foug_task_control)); - if (ctrl != 0) { + if (ctrl != NULL) { ctrl->range_min = -1.f; ctrl->range_max = -2.f; ctrl->range_length = -0.f; @@ -88,7 +88,7 @@ foug_real32_t foug_task_control_get_progress_as_pc(const foug_task_control_t* ct { if (ctrl == NULL) return 0.f; - return fabsf((ctrl->progress_value - ctrl->range_min) / ctrl->range_length); + return fabs((ctrl->progress_value - ctrl->range_min) / ctrl->range_length); } foug_real32_t foug_task_control_get_progress(const foug_task_control_t* ctrl) @@ -160,3 +160,9 @@ void* foug_task_control_get_cookie(const foug_task_control_t* ctrl) { return ctrl != NULL ? ctrl->cookie : NULL; } + +void foug_task_control_set_cookie(foug_task_control_t* ctrl, void* data) +{ + if (ctrl != NULL) + ctrl->cookie = data; +} diff --git a/src/c/task_control.h b/src/c/task_control.h index 59c9dec..cce8fbd 100644 --- a/src/c/task_control.h +++ b/src/c/task_control.h @@ -52,5 +52,6 @@ FOUG_LIB_EXPORT foug_bool_t foug_task_control_is_stop_requested(const foug_task_ /* Cookie */ FOUG_LIB_EXPORT void* foug_task_control_get_cookie(const foug_task_control_t* ctrl); +FOUG_LIB_EXPORT void foug_task_control_set_cookie(foug_task_control_t* ctrl, void* data); #endif /* FOUG_C_TASK_CONTROL_H */