caiyu/gmio
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Several changes

Browse Source 
* Remove typedefs on struct and enums
* First working version of gmio_stla_stats_get()
This commit is contained in:
Hugues Delorme 2015-12-03 18:00:25 +01:00
parent 3850f0f278
commit fb81b25407
63 changed files with 918 additions and 734 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
benchmarks/benchmark_gmio/main.c
View File

@ -14,23 +14,29 @@
****************************************************************************/ ****************************************************************************/
#include <gmio_core/error.h> #include <gmio_core/error.h>
#include <gmio_core/rwargs.h>
#include <gmio_stl/stl_io.h> #include <gmio_stl/stl_io.h>
#include <gmio_stl/stl_io_options.h>
#include <gmio_stl/stl_mesh.h>
#include <gmio_stl/stl_mesh_creator.h>
#include "../commons/benchmark_tools.h" #include "../commons/benchmark_tools.h"
#include <string.h> #include <string.h>
typedef struct my_igeom struct gmio_stl_triangle;
struct my_igeom
{ {
uint32_t facet_count; uint32_t facet_count;
} my_igeom_t; };
static void dummy_process_triangle( static void dummy_process_triangle(
void* cookie, void* cookie,
uint32_t triangle_id, uint32_t triangle_id,
const gmio_stl_triangle_t* triangle) const struct gmio_stl_triangle* triangle)
{ {
my_igeom_t* my_igeom = (my_igeom_t*)(cookie); struct my_igeom* my_igeom = (struct my_igeom*)(cookie);
GMIO_UNUSED(triangle_id); GMIO_UNUSED(triangle_id);
GMIO_UNUSED(triangle); GMIO_UNUSED(triangle);
if (my_igeom != NULL) if (my_igeom != NULL)
@ -39,18 +45,18 @@ static void dummy_process_triangle(
static void bmk_gmio_stl_read(const char* filepath) static void bmk_gmio_stl_read(const char* filepath)
{ {
my_igeom_t cookie = {0}; struct my_igeom cookie = {0};
gmio_stl_mesh_creator_t mesh_creator = {0}; struct gmio_stl_mesh_creator mesh_creator = {0};
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
mesh_creator.cookie = &cookie; mesh_creator.cookie = &cookie;
mesh_creator.func_add_triangle = dummy_process_triangle; mesh_creator.func_add_triangle = dummy_process_triangle;
error = gmio_stl_read_file(filepath, &mesh_creator, NULL); error = gmio_stl_read_file(filepath, NULL, &mesh_creator);
if (error != GMIO_ERROR_OK) if (error != GMIO_ERROR_OK)
printf("gmio error: 0x%X\n", error); printf("gmio error: 0x%X\n", error);
} }
static gmio_endianness_t to_byte_order(gmio_stl_format_t format) static enum gmio_endianness to_byte_order(enum gmio_stl_format format)
{ {
switch (format) { switch (format) {
case GMIO_STL_FORMAT_BINARY_LE: case GMIO_STL_FORMAT_BINARY_LE:
@ -65,22 +71,22 @@ static gmio_endianness_t to_byte_order(gmio_stl_format_t format)
} }
enum { STL_TRIANGLE_ARRAY_SIZE = 512 }; enum { STL_TRIANGLE_ARRAY_SIZE = 512 };
typedef struct stl_readwrite_conv struct stl_readwrite_conv
{ {
gmio_transfer_t trsf; struct gmio_rwargs rwargs;
gmio_stream_pos_t out_stream_pos_begin; struct gmio_stream_pos out_stream_pos_begin;
gmio_stl_format_t in_format; enum gmio_stl_format in_format;
gmio_stl_format_t out_format; enum gmio_stl_format out_format;
gmio_stl_triangle_t triangle_array[STL_TRIANGLE_ARRAY_SIZE]; struct gmio_stl_triangle triangle_array[STL_TRIANGLE_ARRAY_SIZE];
unsigned triangle_pos; unsigned triangle_pos;
uint32_t total_triangle_count; uint32_t total_triangle_count;
} stl_readwrite_conv_t; };
static void readwrite_ascii_begin_solid( static void readwrite_ascii_begin_solid(
void* cookie, gmio_streamsize_t stream_size, const char* solid_name) void* cookie, gmio_streamsize_t stream_size, const char* solid_name)
{ {
stl_readwrite_conv_t* rw_conv = (stl_readwrite_conv_t*)cookie; struct stl_readwrite_conv* rw_conv = (struct stl_readwrite_conv*)cookie;
gmio_stream_t* stream = &rw_conv->trsf.stream; struct gmio_stream* stream = &rw_conv->rwargs.stream;
GMIO_UNUSED(stream_size); GMIO_UNUSED(stream_size);
if (rw_conv->out_format == GMIO_STL_FORMAT_ASCII) { if (rw_conv->out_format == GMIO_STL_FORMAT_ASCII) {
stream->func_write(stream->cookie, "solid ", 1, 6); stream->func_write(stream->cookie, "solid ", 1, 6);
@ -92,50 +98,50 @@ static void readwrite_ascii_begin_solid(
* point. Header will be correctly rewritten at the end of the read * point. Header will be correctly rewritten at the end of the read
* procedure (in gmio_stl_mesh_creator::func_end_solid() callback) * procedure (in gmio_stl_mesh_creator::func_end_solid() callback)
*/ */
const gmio_endianness_t byte_order = to_byte_order(rw_conv->out_format); const enum gmio_endianness byte_order = to_byte_order(rw_conv->out_format);
gmio_stlb_write_header(stream, byte_order, NULL, 0); gmio_stlb_write_header(stream, byte_order, NULL, 0);
} }
} }
static void readwrite_binary_begin_solid( static void readwrite_binary_begin_solid(
void* cookie, uint32_t tri_count, const gmio_stlb_header_t* header) void* cookie, uint32_t tri_count, const struct gmio_stlb_header* header)
{ {
stl_readwrite_conv_t* rw_conv = (stl_readwrite_conv_t*)cookie; struct stl_readwrite_conv* rw_conv = (struct stl_readwrite_conv*)cookie;
gmio_stream_t* stream = &rw_conv->trsf.stream; struct gmio_stream* stream = &rw_conv->rwargs.stream;
if (rw_conv->out_format == GMIO_STL_FORMAT_ASCII) { if (rw_conv->out_format == GMIO_STL_FORMAT_ASCII) {
stream->func_write(stream->cookie, "solid\n", 1, 6); stream->func_write(stream->cookie, "solid\n", 1, 6);
} }
else { else {
const gmio_endianness_t byte_order = to_byte_order(rw_conv->out_format); const enum gmio_endianness byte_order = to_byte_order(rw_conv->out_format);
gmio_stlb_write_header(stream, byte_order, header, tri_count); gmio_stlb_write_header(stream, byte_order, header, tri_count);
} }
} }
static void readwrite_get_triangle( static void readwrite_get_triangle(
const void* cookie, uint32_t tri_id, gmio_stl_triangle_t* triangle) const void* cookie, uint32_t tri_id, struct gmio_stl_triangle* triangle)
{ {
const gmio_stl_triangle_t* tri_array = (const gmio_stl_triangle_t*)cookie; const struct gmio_stl_triangle* tri_array = (const struct gmio_stl_triangle*)cookie;
*triangle = tri_array[tri_id]; *triangle = tri_array[tri_id];
} }
static void stl_readwrite_flush_triangles(stl_readwrite_conv_t* rw_conv) static void stl_readwrite_flush_triangles(struct stl_readwrite_conv* rw_conv)
{ {
gmio_stl_mesh_t mesh = {0}; struct gmio_stl_mesh mesh = {0};
gmio_stl_write_options_t options = {0}; struct gmio_stl_write_options options = {0};
mesh.cookie = &rw_conv->triangle_array[0]; mesh.cookie = &rw_conv->triangle_array[0];
mesh.triangle_count = rw_conv->triangle_pos; mesh.triangle_count = rw_conv->triangle_pos;
mesh.func_get_triangle = &readwrite_get_triangle; mesh.func_get_triangle = &readwrite_get_triangle;
options.stl_write_triangles_only = GMIO_TRUE; options.stl_write_triangles_only = GMIO_TRUE;
options.stla_float32_format = GMIO_FLOAT_TEXT_FORMAT_SCIENTIFIC_LOWERCASE; options.stla_float32_format = GMIO_FLOAT_TEXT_FORMAT_SCIENTIFIC_LOWERCASE;
options.stla_float32_prec = 6; options.stla_float32_prec = 6;
gmio_stl_write(rw_conv->out_format, &rw_conv->trsf, &mesh, &options); gmio_stl_write(&rw_conv->rwargs, &mesh, rw_conv->out_format, &options);
rw_conv->triangle_pos = 0; rw_conv->triangle_pos = 0;
} }
static void readwrite_add_triangle( static void readwrite_add_triangle(
void* cookie, uint32_t tri_id, const gmio_stl_triangle_t* triangle) void* cookie, uint32_t tri_id, const struct gmio_stl_triangle* triangle)
{ {
stl_readwrite_conv_t* rw_conv = (stl_readwrite_conv_t*)cookie; struct stl_readwrite_conv* rw_conv = (struct stl_readwrite_conv*)cookie;
if (rw_conv->triangle_pos >= STL_TRIANGLE_ARRAY_SIZE) if (rw_conv->triangle_pos >= STL_TRIANGLE_ARRAY_SIZE)
stl_readwrite_flush_triangles(rw_conv); stl_readwrite_flush_triangles(rw_conv);
rw_conv->triangle_array[rw_conv->triangle_pos] = *triangle; rw_conv->triangle_array[rw_conv->triangle_pos] = *triangle;
@ -145,15 +151,15 @@ static void readwrite_add_triangle(
static void readwrite_end_solid(void* cookie) static void readwrite_end_solid(void* cookie)
{ {
stl_readwrite_conv_t* rw_conv = (stl_readwrite_conv_t*)cookie; struct stl_readwrite_conv* rw_conv = (struct stl_readwrite_conv*)cookie;
gmio_stream_t* stream = &rw_conv->trsf.stream; struct gmio_stream* stream = &rw_conv->rwargs.stream;
if (rw_conv->triangle_pos != 0) if (rw_conv->triangle_pos != 0)
stl_readwrite_flush_triangles(rw_conv); stl_readwrite_flush_triangles(rw_conv);
if (rw_conv->out_format == GMIO_STL_FORMAT_ASCII) { if (rw_conv->out_format == GMIO_STL_FORMAT_ASCII) {
stream->func_write(stream->cookie, "endsolid", 1, 8); stream->func_write(stream->cookie, "endsolid", 1, 8);
} }
else if (rw_conv->in_format == GMIO_STL_FORMAT_ASCII) { else if (rw_conv->in_format == GMIO_STL_FORMAT_ASCII) {
const gmio_endianness_t byte_order = to_byte_order(rw_conv->out_format); const enum gmio_endianness byte_order = to_byte_order(rw_conv->out_format);
/* The total facet count has to be written because it wasn't known at /* The total facet count has to be written because it wasn't known at
* the beginning of the read procedure */ * the beginning of the read procedure */
stream->func_set_pos(stream->cookie, &rw_conv->out_stream_pos_begin); stream->func_set_pos(stream->cookie, &rw_conv->out_stream_pos_begin);
@ -166,24 +172,24 @@ static void bmk_gmio_stl_readwrite_conv(const char* filepath)
{ {
FILE* infile = fopen(filepath, "rb"); FILE* infile = fopen(filepath, "rb");
FILE* outfile = fopen("_readwrite_conv.stl", "wb"); FILE* outfile = fopen("_readwrite_conv.stl", "wb");
gmio_transfer_t in_trsf = {0}; struct gmio_rwargs in_rwargs = {0};
stl_readwrite_conv_t rw_conv = {0}; struct stl_readwrite_conv rw_conv = {0};
gmio_stl_mesh_creator_t mesh_creator = {0}; struct gmio_stl_mesh_creator mesh_creator = {0};
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
/* rw_conv.out_format = GMIO_STL_FORMAT_BINARY_LE; */ /* rw_conv.out_format = GMIO_STL_FORMAT_BINARY_LE; */
rw_conv.out_format = GMIO_STL_FORMAT_ASCII; rw_conv.out_format = GMIO_STL_FORMAT_ASCII;
if (infile != NULL) { if (infile != NULL) {
in_trsf.memblock = gmio_memblock_malloc(512 * 1024); in_rwargs.memblock = gmio_memblock_malloc(512 * 1024);
in_trsf.stream = gmio_stream_stdio(infile); in_rwargs.stream = gmio_stream_stdio(infile);
rw_conv.in_format = gmio_stl_get_format(&in_trsf.stream); rw_conv.in_format = gmio_stl_get_format(&in_rwargs.stream);
} }
if (outfile != NULL) { if (outfile != NULL) {
rw_conv.trsf.memblock = gmio_memblock_malloc(512 * 1024); rw_conv.rwargs.memblock = gmio_memblock_malloc(512 * 1024);
rw_conv.trsf.stream = gmio_stream_stdio(outfile); rw_conv.rwargs.stream = gmio_stream_stdio(outfile);
rw_conv.trsf.stream.func_get_pos( rw_conv.rwargs.stream.func_get_pos(
rw_conv.trsf.stream.cookie, rw_conv.rwargs.stream.cookie,
&rw_conv.out_stream_pos_begin); &rw_conv.out_stream_pos_begin);
} }
@ -193,10 +199,10 @@ static void bmk_gmio_stl_readwrite_conv(const char* filepath)
mesh_creator.func_add_triangle = &readwrite_add_triangle; mesh_creator.func_add_triangle = &readwrite_add_triangle;
mesh_creator.func_end_solid = &readwrite_end_solid; mesh_creator.func_end_solid = &readwrite_end_solid;
error = gmio_stl_read(&in_trsf, &mesh_creator); error = gmio_stl_read(&in_rwargs, &mesh_creator);
gmio_memblock_deallocate(&in_trsf.memblock); gmio_memblock_deallocate(&in_rwargs.memblock);
gmio_memblock_deallocate(&rw_conv.trsf.memblock); gmio_memblock_deallocate(&rw_conv.rwargs.memblock);
if (error != GMIO_ERROR_OK) if (error != GMIO_ERROR_OK)
printf("gmio error: 0x%X\n", error); printf("gmio error: 0x%X\n", error);
@ -208,7 +214,7 @@ int main(int argc, char** argv)
const char* filepath = argv[1]; const char* filepath = argv[1];
/* Declare benchmarks */ /* Declare benchmarks */
benchmark_cmp_arg_t cmp_args[] = { struct benchmark_cmp_arg cmp_args[] = {
{ "read_file()", { "read_file()",
bmk_gmio_stl_read, NULL, bmk_gmio_stl_read, NULL,
NULL, NULL }, NULL, NULL },
@ -218,10 +224,10 @@ int main(int argc, char** argv)
{0} {0}
}; };
const size_t cmp_count = const size_t cmp_count =
sizeof(cmp_args) / sizeof(benchmark_cmp_arg_t) - 1; sizeof(cmp_args) / sizeof(struct benchmark_cmp_arg) - 1;
benchmark_cmp_result_t cmp_res[2] = {0}; struct benchmark_cmp_result cmp_res[2] = {0};
benchmark_cmp_result_array_t res_array = {0}; struct benchmark_cmp_result_array res_array = {0};
const benchmark_cmp_result_header_t header = { "gmio", NULL }; const struct benchmark_cmp_result_header header = { "gmio", NULL };
cmp_args[0].func1_filepath = filepath; cmp_args[0].func1_filepath = filepath;
cmp_args[1].func1_filepath = filepath; cmp_args[1].func1_filepath = filepath;

43
benchmarks/commons/benchmark_tools.c
View File

@ -39,9 +39,8 @@ struct benchmark_timer
clock_t start_tick; clock_t start_tick;
#endif #endif
}; };
typedef struct benchmark_timer benchmark_timer_t;
static void benchmark_timer_start(benchmark_timer_t* timer) static void benchmark_timer_start(struct benchmark_timer* timer)
{ {
#ifdef BENCHMARK_TIMER_WINDOWS #ifdef BENCHMARK_TIMER_WINDOWS
QueryPerformanceFrequency(&timer->frequency); QueryPerformanceFrequency(&timer->frequency);
@ -51,7 +50,7 @@ static void benchmark_timer_start(benchmark_timer_t* timer)
#endif #endif
} }
static gmio_time_ms_t benchmark_timer_elapsed_ms(const benchmark_timer_t* timer) static gmio_time_ms_t benchmark_timer_elapsed_ms(const struct benchmark_timer* timer)
{ {
#ifdef BENCHMARK_TIMER_WINDOWS #ifdef BENCHMARK_TIMER_WINDOWS
LARGE_INTEGER end_time = {0}; LARGE_INTEGER end_time = {0};
@ -194,7 +193,7 @@ static void printf_func_exec_time(
} }
/*! Returns the strlen of the longest tag string */ /*! Returns the strlen of the longest tag string */
static size_t find_maxlen_cmp_result_tag(benchmark_cmp_result_array_t res_array) static size_t find_maxlen_cmp_result_tag(struct benchmark_cmp_result_array res_array)
{ {
size_t max_len = 0; size_t max_len = 0;
size_t i; size_t i;
@ -207,7 +206,7 @@ static size_t find_maxlen_cmp_result_tag(benchmark_cmp_result_array_t res_array)
/*! Writes in output args the func1 execution informations */ /*! Writes in output args the func1 execution informations */
static void select_cmp_result_func1_exec_infos( static void select_cmp_result_func1_exec_infos(
const benchmark_cmp_result_t* cmp, const struct benchmark_cmp_result* cmp,
gmio_time_ms_t* time, gmio_time_ms_t* time,
gmio_bool_t* has_time) gmio_bool_t* has_time)
{ {
@ -217,7 +216,7 @@ static void select_cmp_result_func1_exec_infos(
/*! Writes in output args the func2 execution informations */ /*! Writes in output args the func2 execution informations */
static void select_cmp_result_func2_exec_infos( static void select_cmp_result_func2_exec_infos(
const benchmark_cmp_result_t* cmp, const struct benchmark_cmp_result* cmp,
gmio_time_ms_t* time, gmio_time_ms_t* time,
gmio_bool_t* has_time) gmio_bool_t* has_time)
{ {
@ -227,11 +226,11 @@ static void select_cmp_result_func2_exec_infos(
/*! Typedef on pointer to functions like select_cmp_result_funcX_exec_infos() */ /*! Typedef on pointer to functions like select_cmp_result_funcX_exec_infos() */
typedef void (*func_select_cmp_result_func_exec_infos_t)( typedef void (*func_select_cmp_result_func_exec_infos_t)(
const benchmark_cmp_result_t*, gmio_time_ms_t*, gmio_bool_t*); const struct benchmark_cmp_result*, gmio_time_ms_t*, gmio_bool_t*);
/*! Returns the strlen of the longest execution time string */ /*! Returns the strlen of the longest execution time string */
static size_t find_maxlen_cmp_result_func_exec_time( static size_t find_maxlen_cmp_result_func_exec_time(
benchmark_cmp_result_array_t res_array, struct benchmark_cmp_result_array res_array,
func_select_cmp_result_func_exec_infos_t func_select_exec_infos) func_select_cmp_result_func_exec_infos_t func_select_exec_infos)
{ {
char strbuff[1024] = {0}; char strbuff[1024] = {0};
@ -249,7 +248,7 @@ static size_t find_maxlen_cmp_result_func_exec_time(
/*! Returns the strlen of the longest func2/func1 ratio string */ /*! Returns the strlen of the longest func2/func1 ratio string */
static size_t find_maxlen_cmp_result_ratio( static size_t find_maxlen_cmp_result_ratio(
benchmark_cmp_result_array_t res_array) struct benchmark_cmp_result_array res_array)
{ {
char strbuff[1024] = {0}; char strbuff[1024] = {0};
size_t max_len = 0; size_t max_len = 0;
@ -262,7 +261,7 @@ static size_t find_maxlen_cmp_result_ratio(
return max_len; return max_len;
} }
static void update_benchmark_cmp_result_ratio(benchmark_cmp_result_t* result) static void update_benchmark_cmp_result_ratio(struct benchmark_cmp_result* result)
{ {
if (result->has_func1_exec_time && result->has_func2_exec_time) { if (result->has_func1_exec_time && result->has_func2_exec_time) {
if (result->func2_exec_time_ms > 0) { if (result->func2_exec_time_ms > 0) {
@ -281,20 +280,20 @@ static void update_benchmark_cmp_result_ratio(benchmark_cmp_result_t* result)
/* Implementation */ /* Implementation */
benchmark_cmp_result_t benchmark_cmp(benchmark_cmp_arg_t arg) struct benchmark_cmp_result benchmark_cmp(struct benchmark_cmp_arg arg)
{ {
benchmark_cmp_result_t result = {0}; struct benchmark_cmp_result result = {0};
result.tag = arg.tag; result.tag = arg.tag;
if (arg.func1 != NULL) { if (arg.func1 != NULL) {
benchmark_timer_t timer = {0}; struct benchmark_timer timer = {0};
benchmark_timer_start(&timer); benchmark_timer_start(&timer);
(*arg.func1)(arg.func1_filepath); (*arg.func1)(arg.func1_filepath);
result.func1_exec_time_ms = benchmark_timer_elapsed_ms(&timer); result.func1_exec_time_ms = benchmark_timer_elapsed_ms(&timer);
result.has_func1_exec_time = GMIO_TRUE; result.has_func1_exec_time = GMIO_TRUE;
} }
if (arg.func2 != NULL) { if (arg.func2 != NULL) {
benchmark_timer_t timer = {0}; struct benchmark_timer timer = {0};
benchmark_timer_start(&timer); benchmark_timer_start(&timer);
(*arg.func2)(arg.func2_filepath); (*arg.func2)(arg.func2_filepath);
result.func2_exec_time_ms = benchmark_timer_elapsed_ms(&timer); result.func2_exec_time_ms = benchmark_timer_elapsed_ms(&timer);
@ -307,8 +306,8 @@ benchmark_cmp_result_t benchmark_cmp(benchmark_cmp_arg_t arg)
void benchmark_cmp_batch( void benchmark_cmp_batch(
size_t run_count, size_t run_count,
const benchmark_cmp_arg_t *arg_array, const struct benchmark_cmp_arg *arg_array,
benchmark_cmp_result_t *result_array, struct benchmark_cmp_result *result_array,
void (*func_init)(), void (*func_init)(),
void (*func_cleanup)()) void (*func_cleanup)())
{ {
@ -324,8 +323,8 @@ void benchmark_cmp_batch(
(*func_init)(); (*func_init)();
for (i = 0; i < array_size; ++i) { for (i = 0; i < array_size; ++i) {
const benchmark_cmp_result_t ires = benchmark_cmp(arg_array[i]); const struct benchmark_cmp_result ires = benchmark_cmp(arg_array[i]);
benchmark_cmp_result_t* fres = &result_array[i]; struct benchmark_cmp_result* fres = &result_array[i];
if (run != 0) { if (run != 0) {
if (fres->func1_exec_time_ms > ires.func1_exec_time_ms) if (fres->func1_exec_time_ms > ires.func1_exec_time_ms)
fres->func1_exec_time_ms = ires.func1_exec_time_ms; fres->func1_exec_time_ms = ires.func1_exec_time_ms;
@ -345,9 +344,9 @@ void benchmark_cmp_batch(
} }
void benchmark_print_results( void benchmark_print_results(
benchmark_print_format_t format, enum benchmark_print_format format,
benchmark_cmp_result_header_t header, struct benchmark_cmp_result_header header,
benchmark_cmp_result_array_t result_array) struct benchmark_cmp_result_array result_array)
{ {
if (format == BENCHMARK_PRINT_FORMAT_MARKDOWN) { if (format == BENCHMARK_PRINT_FORMAT_MARKDOWN) {
const char* header_comp1 = const char* header_comp1 =
@ -391,7 +390,7 @@ void benchmark_print_results(
/* Print benchmark result lines */ /* Print benchmark result lines */
for (i = 0; i < result_array.count; ++i) { for (i = 0; i < result_array.count; ++i) {
const benchmark_cmp_result_t result = result_array.ptr[i]; const struct benchmark_cmp_result result = result_array.ptr[i];
printf("%-*s | ", (int)width_tag_col, result.tag); printf("%-*s | ", (int)width_tag_col, result.tag);
printf_func_exec_time( printf_func_exec_time(
width_func1_col, width_func1_col,

19
benchmarks/commons/benchmark_tools.h
View File

@ -46,7 +46,6 @@ struct benchmark_cmp_arg
/*! Argument passed to the 2nd function on exec */ /*! Argument passed to the 2nd function on exec */
const char* func2_filepath; const char* func2_filepath;
}; };
typedef struct benchmark_cmp_arg benchmark_cmp_arg_t;
/*! Holds the result of the exec time comparison between two functions */ /*! Holds the result of the exec time comparison between two functions */
struct benchmark_cmp_result struct benchmark_cmp_result
@ -63,16 +62,15 @@ struct benchmark_cmp_result
gmio_bool_t has_func2_exec_time; gmio_bool_t has_func2_exec_time;
float func2_func1_ratio; float func2_func1_ratio;
}; };
typedef struct benchmark_cmp_result benchmark_cmp_result_t;
/*! Runs func1 then func2 and measures the respective execution time */ /*! Runs func1 then func2 and measures the respective execution time */
benchmark_cmp_result_t benchmark_cmp(benchmark_cmp_arg_t arg); struct benchmark_cmp_result benchmark_cmp(struct benchmark_cmp_arg arg);
/*! Runs a batch(array) of comparison benchmarks */ /*! Runs a batch(array) of comparison benchmarks */
void benchmark_cmp_batch( void benchmark_cmp_batch(
size_t run_count, size_t run_count,
const benchmark_cmp_arg_t* arg_array, const struct benchmark_cmp_arg* arg_array,
benchmark_cmp_result_t* result_array, struct benchmark_cmp_result* result_array,
void (*func_init)(), void (*func_init)(),
void (*func_cleanup)()); void (*func_cleanup)());
@ -83,15 +81,13 @@ enum benchmark_print_format
{ {
BENCHMARK_PRINT_FORMAT_MARKDOWN = 0 BENCHMARK_PRINT_FORMAT_MARKDOWN = 0
}; };
typedef enum benchmark_print_format benchmark_print_format_t;
/*! Array of benchmark_cmp_result */ /*! Array of benchmark_cmp_result */
struct benchmark_cmp_result_array struct benchmark_cmp_result_array
{ {
const benchmark_cmp_result_t* ptr; const struct benchmark_cmp_result* ptr;
size_t count; size_t count;
}; };
typedef struct benchmark_cmp_result_array benchmark_cmp_result_array_t;
/*! Horizontal header labels for benchmark results(by column) */ /*! Horizontal header labels for benchmark results(by column) */
struct benchmark_cmp_result_header struct benchmark_cmp_result_header
@ -99,13 +95,12 @@ struct benchmark_cmp_result_header
const char* component_1; const char* component_1;
const char* component_2; const char* component_2;
}; };
typedef struct benchmark_cmp_result_header benchmark_cmp_result_header_t;
/*! Prints formatted benchmark results */ /*! Prints formatted benchmark results */
void benchmark_print_results( void benchmark_print_results(
benchmark_print_format_t format, enum benchmark_print_format format,
benchmark_cmp_result_header_t header, struct benchmark_cmp_result_header header,
benchmark_cmp_result_array_t result_array); struct benchmark_cmp_result_array result_array);
GMIO_C_LINKAGE_END GMIO_C_LINKAGE_END

8
src/gmio_core/endian.c
View File

@ -19,15 +19,15 @@
#include <string.h> #include <string.h>
typedef union union gmio_int_bytes_32_convert
{ {
uint32_t integer; uint32_t integer;
uint8_t bytes[4]; uint8_t bytes[4];
} gmio_int_bytes_32_convert_t; };
gmio_endianness_t gmio_host_endianness() enum gmio_endianness gmio_host_endianness()
{ {
gmio_int_bytes_32_convert_t conv; union gmio_int_bytes_32_convert conv;
conv.integer = 0x01020408; conv.integer = 0x01020408;
if (conv.bytes[0] == 0x08 && conv.bytes[3] == 0x01) if (conv.bytes[0] == 0x08 && conv.bytes[3] == 0x01)

4
src/gmio_core/endian.h
View File

@ -52,12 +52,10 @@ enum gmio_endianness
#endif #endif
}; };
typedef enum gmio_endianness gmio_endianness_t;
GMIO_C_LINKAGE_BEGIN GMIO_C_LINKAGE_BEGIN
/*! Returns endianness (byte order) of the host's CPU architecture */ /*! Returns endianness (byte order) of the host's CPU architecture */
GMIO_LIB_EXPORT gmio_endianness_t gmio_host_endianness(); GMIO_LIB_EXPORT enum gmio_endianness gmio_host_endianness();
GMIO_C_LINKAGE_END GMIO_C_LINKAGE_END

6
src/gmio_core/error.h
View File

@ -31,8 +31,8 @@ enum gmio_error
/*! No error occurred, success */ /*! No error occurred, success */
GMIO_ERROR_OK = 0, GMIO_ERROR_OK = 0,
/*! Pointer on argument gmio_transfer_t is NULL */ /*! Pointer on argument gmio_rwargs is NULL */
GMIO_ERROR_NULL_TRANSFER, GMIO_ERROR_NULL_RWARGS,
/*! Pointer on argument memory block is NULL */ /*! Pointer on argument memory block is NULL */
GMIO_ERROR_NULL_MEMBLOCK, GMIO_ERROR_NULL_MEMBLOCK,
@ -57,8 +57,6 @@ enum gmio_error
GMIO_ERROR_UNKNOWN GMIO_ERROR_UNKNOWN
}; };
typedef enum gmio_error gmio_error_t;
/*! Returns true if <tt>code == GMIO_NO_ERROR</tt> */ /*! Returns true if <tt>code == GMIO_NO_ERROR</tt> */
GMIO_INLINE gmio_bool_t gmio_no_error(int code) GMIO_INLINE gmio_bool_t gmio_no_error(int code)
{ return code == GMIO_ERROR_OK ? GMIO_TRUE : GMIO_FALSE; } { return code == GMIO_ERROR_OK ? GMIO_TRUE : GMIO_FALSE; }

24
src/gmio_core/internal/helper_transfer.h → src/gmio_core/internal/helper_rwargs.h
View File

@ -13,31 +13,31 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html". ** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/ ****************************************************************************/
#ifndef GMIO_INTERNAL_HELPER_TRANSFER_H #ifndef GMIO_INTERNAL_HELPER_RWARGS_H
#define GMIO_INTERNAL_HELPER_TRANSFER_H #define GMIO_INTERNAL_HELPER_RWARGS_H
#include "../transfer.h" #include "../rwargs.h"
#include "helper_task_iface.h" #include "helper_task_iface.h"
/*! Safe and convenient function for gmio_task_iface::func_is_stop_requested() /*! Safe and convenient function for gmio_task_iface::func_is_stop_requested()
* through gmio_transfer::task_iface * through gmio_transfer::task_iface
*/ */
GMIO_INLINE gmio_bool_t gmio_transfer_is_stop_requested( GMIO_INLINE gmio_bool_t gmio_rwargs_is_stop_requested(
const gmio_transfer_t* trsf) const struct gmio_rwargs* args)
{ {
if (trsf != NULL) if (args != NULL)
return gmio_task_iface_is_stop_requested(&trsf->task_iface); return gmio_task_iface_is_stop_requested(&args->task_iface);
return GMIO_FALSE; return GMIO_FALSE;
} }
/*! Safe and convenient function for gmio_task_iface::func_handle_progress() /*! Safe and convenient function for gmio_task_iface::func_handle_progress()
* through gmio_transfer::task_iface * through gmio_transfer::task_iface
*/ */
GMIO_INLINE void gmio_transfer_handle_progress( GMIO_INLINE void gmio_rwargs_handle_progress(
const gmio_transfer_t* trsf, size_t value, size_t max_value) const struct gmio_rwargs* args, size_t value, size_t max_value)
{ {
if (trsf != NULL) if (args != NULL)
gmio_task_iface_handle_progress(&trsf->task_iface, value, max_value); gmio_task_iface_handle_progress(&args->task_iface, value, max_value);
} }
#endif /* GMIO_INTERNAL_HELPER_TRANSFER_H */ #endif /* GMIO_INTERNAL_HELPER_RWARGS_H */

14
src/gmio_core/internal/helper_stream.h
View File

@ -19,7 +19,7 @@
#include "../stream.h" #include "../stream.h"
/*! Safe and convenient function for gmio_stream::func_at_end() */ /*! Safe and convenient function for gmio_stream::func_at_end() */
GMIO_INLINE gmio_bool_t gmio_stream_at_end(gmio_stream_t* stream) GMIO_INLINE gmio_bool_t gmio_stream_at_end(struct gmio_stream* stream)
{ {
if (stream != NULL && stream->func_at_end != NULL) if (stream != NULL && stream->func_at_end != NULL)
return stream->func_at_end(stream->cookie); return stream->func_at_end(stream->cookie);
@ -27,7 +27,7 @@ GMIO_INLINE gmio_bool_t gmio_stream_at_end(gmio_stream_t* stream)
} }
/*! Safe and convenient function for gmio_stream::func_error() */ /*! Safe and convenient function for gmio_stream::func_error() */
GMIO_INLINE int gmio_stream_error(gmio_stream_t* stream) GMIO_INLINE int gmio_stream_error(struct gmio_stream* stream)
{ {
if (stream != NULL && stream->func_error != NULL) if (stream != NULL && stream->func_error != NULL)
return stream->func_error(stream->cookie); return stream->func_error(stream->cookie);
@ -36,7 +36,7 @@ GMIO_INLINE int gmio_stream_error(gmio_stream_t* stream)
/*! Safe and convenient function for gmio_stream::func_read() */ /*! Safe and convenient function for gmio_stream::func_read() */
GMIO_INLINE size_t gmio_stream_read( GMIO_INLINE size_t gmio_stream_read(
gmio_stream_t* stream, void *ptr, size_t size, size_t count) struct gmio_stream* stream, void *ptr, size_t size, size_t count)
{ {
if (stream != NULL && stream->func_read != NULL) if (stream != NULL && stream->func_read != NULL)
return stream->func_read(stream->cookie, ptr, size, count); return stream->func_read(stream->cookie, ptr, size, count);
@ -45,7 +45,7 @@ GMIO_INLINE size_t gmio_stream_read(
/*! Safe and convenient function for gmio_stream::func_write() */ /*! Safe and convenient function for gmio_stream::func_write() */
GMIO_INLINE size_t gmio_stream_write( GMIO_INLINE size_t gmio_stream_write(
gmio_stream_t* stream, const void *ptr, size_t size, size_t count) struct gmio_stream* stream, const void *ptr, size_t size, size_t count)
{ {
if (stream != NULL && stream->func_write != NULL) if (stream != NULL && stream->func_write != NULL)
return stream->func_write(stream->cookie, ptr, size, count); return stream->func_write(stream->cookie, ptr, size, count);
@ -53,7 +53,7 @@ GMIO_INLINE size_t gmio_stream_write(
} }
/*! Safe and convenient function for gmio_stream::func_size() */ /*! Safe and convenient function for gmio_stream::func_size() */
GMIO_INLINE gmio_streamsize_t gmio_stream_size(gmio_stream_t* stream) GMIO_INLINE gmio_streamsize_t gmio_stream_size(struct gmio_stream* stream)
{ {
if (stream != NULL && stream->func_size != NULL) if (stream != NULL && stream->func_size != NULL)
return stream->func_size(stream->cookie); return stream->func_size(stream->cookie);
@ -62,7 +62,7 @@ GMIO_INLINE gmio_streamsize_t gmio_stream_size(gmio_stream_t* stream)
/*! Safe and convenient function for gmio_stream::func_get_pos() */ /*! Safe and convenient function for gmio_stream::func_get_pos() */
GMIO_INLINE int gmio_stream_get_pos( GMIO_INLINE int gmio_stream_get_pos(
gmio_stream_t* stream, gmio_stream_pos_t* pos) struct gmio_stream* stream, struct gmio_stream_pos* pos)
{ {
if (stream != NULL && stream->func_get_pos != NULL) if (stream != NULL && stream->func_get_pos != NULL)
return stream->func_get_pos(stream->cookie, pos); return stream->func_get_pos(stream->cookie, pos);
@ -71,7 +71,7 @@ GMIO_INLINE int gmio_stream_get_pos(
/*! Safe and convenient function for gmio_stream::func_set_pos() */ /*! Safe and convenient function for gmio_stream::func_set_pos() */
GMIO_INLINE int gmio_stream_set_pos( GMIO_INLINE int gmio_stream_set_pos(
gmio_stream_t* stream, const gmio_stream_pos_t* pos) struct gmio_stream* stream, const struct gmio_stream_pos* pos)
{ {
if (stream != NULL && stream->func_set_pos != NULL) if (stream != NULL && stream->func_set_pos != NULL)
return stream->func_set_pos(stream->cookie, pos); return stream->func_set_pos(stream->cookie, pos);

4
src/gmio_core/internal/helper_task_iface.h
View File

@ -22,7 +22,7 @@
/*! Safe and convenient function for gmio_task_iface::func_is_stop_requested() */ /*! Safe and convenient function for gmio_task_iface::func_is_stop_requested() */
GMIO_INLINE gmio_bool_t gmio_task_iface_is_stop_requested( GMIO_INLINE gmio_bool_t gmio_task_iface_is_stop_requested(
const gmio_task_iface_t* itask) const struct gmio_task_iface* itask)
{ {
if (itask != NULL && itask->func_is_stop_requested != NULL) if (itask != NULL && itask->func_is_stop_requested != NULL)
return itask->func_is_stop_requested(itask->cookie); return itask->func_is_stop_requested(itask->cookie);
@ -31,7 +31,7 @@ GMIO_INLINE gmio_bool_t gmio_task_iface_is_stop_requested(
/*! Safe and convenient function for gmio_task_iface::func_handle_progress() */ /*! Safe and convenient function for gmio_task_iface::func_handle_progress() */
GMIO_INLINE void gmio_task_iface_handle_progress( GMIO_INLINE void gmio_task_iface_handle_progress(
const gmio_task_iface_t* itask, size_t value, size_t max_value) const struct gmio_task_iface* itask, size_t value, size_t max_value)
{ {
if (itask != NULL && itask->func_handle_progress != NULL) if (itask != NULL && itask->func_handle_progress != NULL)
itask->func_handle_progress(itask->cookie, value, max_value); itask->func_handle_progress(itask->cookie, value, max_value);

35
src/gmio_core/internal/string.h
View File

@ -29,7 +29,6 @@ struct gmio_const_string
const char* ptr; /*!< Contents */ const char* ptr; /*!< Contents */
size_t len; /*!< Size(length) of current contents */ size_t len; /*!< Size(length) of current contents */
}; };
typedef struct gmio_const_string gmio_const_string_t;
/*! Stores a mutable string of 8-bit chars /*! Stores a mutable string of 8-bit chars
* *
@ -42,42 +41,60 @@ struct gmio_string
size_t len; /*!< Size(length) of current contents */ size_t len; /*!< Size(length) of current contents */
size_t max_len; /*!< Maximum contents size(capacity) */ size_t max_len; /*!< Maximum contents size(capacity) */
}; };
typedef struct gmio_string gmio_string_t;
/*! Expands to bracket initialization of a gmio_const_string from const char[] /*! Expands to bracket initialization of a gmio_const_string from const char[]
* *
* Example: * Example:
* \code * \code
* static const char token[] = "woops"; * static const char token[] = "woops";
* gmio_const_string_t token_s = GMIO_CONST_STRING_FROM_ARRAY(token); * struct gmio_const_string token_s = GMIO_CONST_STRING_FROM_ARRAY(token);
* \endcode * \endcode
*/ */
#define GMIO_CONST_STRING_FROM_ARRAY(array) { &(array)[0], sizeof(array) - 1 } #define GMIO_CONST_STRING_FROM_ARRAY(array) { &(array)[0], sizeof(array) - 1 }
/*! Returns an initialized gmio_const_string_t object */ /*! Returns an initialized struct gmio_const_string object */
GMIO_INLINE gmio_const_string_t gmio_const_string(const char* ptr, size_t len); GMIO_INLINE struct gmio_const_string gmio_const_string(const char* ptr, size_t len);
/*! Returns an initialized struct gmio_string object */
GMIO_INLINE struct gmio_string gmio_string(char* ptr, size_t len, size_t max_len);
/*! Clears the contents of the string \p str and makes it null */ /*! Clears the contents of the string \p str and makes it null */
GMIO_INLINE void gmio_string_clear(gmio_string_t* str); GMIO_INLINE void gmio_string_clear(struct gmio_string* str);
/*! Clears the contents of the string \p str and makes it null */
GMIO_INLINE const char* gmio_string_end(const struct gmio_string* str);
/* /*
* -- Implementation * -- Implementation
*/ */
gmio_const_string_t gmio_const_string(const char* ptr, size_t len) struct gmio_const_string gmio_const_string(const char* ptr, size_t len)
{ {
gmio_const_string_t cstr; struct gmio_const_string cstr;
cstr.ptr = ptr; cstr.ptr = ptr;
cstr.len = len; cstr.len = len;
return cstr; return cstr;
} }
void gmio_string_clear(gmio_string_t* str) struct gmio_string gmio_string(char* ptr, size_t len, size_t max_len)
{
struct gmio_string str;
str.ptr = ptr;
str.len = len;
str.max_len = max_len;
return str;
}
void gmio_string_clear(struct gmio_string* str)
{ {
str->ptr[0] = 0; str->ptr[0] = 0;
str->len = 0; str->len = 0;
} }
const char* gmio_string_end(const struct gmio_string* str)
{
return &str->ptr[str->len];
}
#endif /* GMIO_INTERNAL_STRING_H */ #endif /* GMIO_INTERNAL_STRING_H */

8
src/gmio_core/internal/stringstream.c
View File

@ -17,7 +17,7 @@
#include "helper_stream.h" #include "helper_stream.h"
void gmio_stringstream_init(gmio_stringstream_t *it) void gmio_stringstream_init(struct gmio_stringstream *it)
{ {
/* Trick: declaring the buffer exhausted will actually trigger the first /* Trick: declaring the buffer exhausted will actually trigger the first
* call to gmio_stream_read() inside gmio_next_char() * call to gmio_stream_read() inside gmio_next_char()
@ -28,8 +28,8 @@ void gmio_stringstream_init(gmio_stringstream_t *it)
gmio_stringstream_next_char(it); gmio_stringstream_next_char(it);
} }
gmio_eat_word_error_t gmio_stringstream_eat_word( enum gmio_eat_word_error gmio_stringstream_eat_word(
gmio_stringstream_t *it, gmio_string_t *str) struct gmio_stringstream *it, struct gmio_string *str)
{ {
char* str_ptr_at = str->ptr + str->len; char* str_ptr_at = str->ptr + str->len;
const char* str_ptr_end = str->ptr + str->max_len; const char* str_ptr_end = str->ptr + str->max_len;
@ -61,7 +61,7 @@ gmio_eat_word_error_t gmio_stringstream_eat_word(
#if 0 #if 0
gmio_bool_t gmio_stringstream_checked_next_chars( gmio_bool_t gmio_stringstream_checked_next_chars(
gmio_stringstream_t *it, const char *str) struct gmio_stringstream *it, const char *str)
{ {
size_t pos = 0; size_t pos = 0;
const char* curr_char = gmio_stringstream_current_char(it); const char* curr_char = gmio_stringstream_current_char(it);

45
src/gmio_core/internal/stringstream.h
View File

@ -28,39 +28,39 @@
*/ */
struct gmio_stringstream struct gmio_stringstream
{ {
gmio_stream_t stream; struct gmio_stream stream;
gmio_string_t strbuff; struct gmio_string strbuff;
const char* strbuff_end; /*!< Position after last char in strbuff */ const char* strbuff_end; /*!< Position after last char in strbuff */
const char* strbuff_at; /*!< Position indicator in buffer */ const char* strbuff_at; /*!< Position indicator in buffer */
void* cookie; void* cookie;
void (*func_stream_read_hook)(void* cookie, const gmio_string_t* strbuff); void (*func_stream_read_hook)(
void* cookie, const struct gmio_string* strbuff);
}; };
typedef struct gmio_stringstream gmio_stringstream_t;
/*! Initializes iterator */ /*! Initializes iterator */
void gmio_stringstream_init(gmio_stringstream_t* it); void gmio_stringstream_init(struct gmio_stringstream* it);
/*! Returns the char where the iterator is currently pointing at */ /*! Returns the char where the iterator is currently pointing at */
GMIO_INLINE const char* gmio_stringstream_current_char( GMIO_INLINE const char* gmio_stringstream_current_char(
const gmio_stringstream_t* it); const struct gmio_stringstream* it);
/*! Moves on next char in stream */ /*! Moves on next char in stream */
GMIO_INLINE const char* gmio_stringstream_next_char( GMIO_INLINE const char* gmio_stringstream_next_char(
gmio_stringstream_t *it); struct gmio_stringstream *it);
/*! Moves on next char in stream */ /*! Moves on next char in stream */
GMIO_INLINE gmio_stringstream_t* gmio_stringstream_move_next_char( GMIO_INLINE struct gmio_stringstream* gmio_stringstream_move_next_char(
gmio_stringstream_t *it); struct gmio_stringstream *it);
/*! Advances iterator until the first non-space char */ /*! Advances iterator until the first non-space char */
GMIO_INLINE const char* gmio_stringstream_skip_ascii_spaces( GMIO_INLINE const char* gmio_stringstream_skip_ascii_spaces(
gmio_stringstream_t* it); struct gmio_stringstream* it);
/*! Advances iterator until the first non-space char and copies in \p str any /*! Advances iterator until the first non-space char and copies in \p str any
* space found */ * space found */
GMIO_INLINE void gmio_stringstream_copy_ascii_spaces( GMIO_INLINE void gmio_stringstream_copy_ascii_spaces(
gmio_stringstream_t* it, gmio_string_t* str); struct gmio_stringstream* it, struct gmio_string* str);
/*! Error codes returned by gmio_eat_word() */ /*! Error codes returned by gmio_eat_word() */
enum gmio_eat_word_error enum gmio_eat_word_error
@ -69,11 +69,10 @@ enum gmio_eat_word_error
GMIO_EAT_WORD_ERROR_EMPTY, GMIO_EAT_WORD_ERROR_EMPTY,
GMIO_EAT_WORD_ERROR_CAPACITY_OVERFLOW GMIO_EAT_WORD_ERROR_CAPACITY_OVERFLOW
}; };
typedef enum gmio_eat_word_error gmio_eat_word_error_t;
/*! Advances iterator so that next word is extracted into \p str */ /*! Advances iterator so that next word is extracted into \p str */
gmio_eat_word_error_t gmio_stringstream_eat_word( enum gmio_eat_word_error gmio_stringstream_eat_word(
gmio_stringstream_t* it, gmio_string_t* str); struct gmio_stringstream* it, struct gmio_string* str);
#if 0 #if 0
/*! Iterate over stream while it matches input string \p str /*! Iterate over stream while it matches input string \p str
@ -81,12 +80,12 @@ gmio_eat_word_error_t gmio_stringstream_eat_word(
* Returns GMIO_TRUE if \p str was fully matched * Returns GMIO_TRUE if \p str was fully matched
*/ */
gmio_bool_t gmio_stringstream_checked_next_chars( gmio_bool_t gmio_stringstream_checked_next_chars(
gmio_stringstream_t* it, const char* str); struct gmio_stringstream* it, const char* str);
#endif #endif
/*! Parses float from string iterator \p it */ /*! Parses float from string iterator \p it */
GMIO_INLINE gmio_float32_t gmio_stringstream_parse_float32( GMIO_INLINE gmio_float32_t gmio_stringstream_parse_float32(
gmio_stringstream_t* it); struct gmio_stringstream* it);
/*! Converts C string \p str to float /*! Converts C string \p str to float
* *
@ -119,14 +118,14 @@ GMIO_INLINE gmio_float32_t gmio_to_float32(const char* str);
#include <errno.h> #include <errno.h>
#include <stdlib.h> #include <stdlib.h>
const char* gmio_stringstream_current_char(const gmio_stringstream_t* it) const char* gmio_stringstream_current_char(const struct gmio_stringstream* it)
{ {
return it->strbuff_at < it->strbuff_end ? return it->strbuff_at < it->strbuff_end ?
it->strbuff_at : it->strbuff_at :
NULL; NULL;
} }
const char *gmio_stringstream_next_char(gmio_stringstream_t *it) const char *gmio_stringstream_next_char(struct gmio_stringstream *it)
{ {
++(it->strbuff_at); ++(it->strbuff_at);
if (it->strbuff_at < it->strbuff_end) if (it->strbuff_at < it->strbuff_end)
@ -146,13 +145,13 @@ const char *gmio_stringstream_next_char(gmio_stringstream_t *it)
return NULL; return NULL;
} }
gmio_stringstream_t* gmio_stringstream_move_next_char(gmio_stringstream_t *it) struct gmio_stringstream* gmio_stringstream_move_next_char(struct gmio_stringstream *it)
{ {
gmio_stringstream_next_char(it); gmio_stringstream_next_char(it);
return it; return it;
} }
const char* gmio_stringstream_skip_ascii_spaces(gmio_stringstream_t* it) const char* gmio_stringstream_skip_ascii_spaces(struct gmio_stringstream* it)
{ {
const char* curr_char = gmio_stringstream_current_char(it); const char* curr_char = gmio_stringstream_current_char(it);
while (curr_char != NULL && gmio_ascii_isspace(*curr_char)) while (curr_char != NULL && gmio_ascii_isspace(*curr_char))
@ -161,7 +160,7 @@ const char* gmio_stringstream_skip_ascii_spaces(gmio_stringstream_t* it)
} }
void gmio_stringstream_copy_ascii_spaces( void gmio_stringstream_copy_ascii_spaces(
gmio_stringstream_t* it, gmio_string_t* str) struct gmio_stringstream* it, struct gmio_string* str)
{ {
const char* curr_char = gmio_stringstream_current_char(it); const char* curr_char = gmio_stringstream_current_char(it);
while (curr_char != NULL while (curr_char != NULL
@ -200,13 +199,13 @@ gmio_float32_t gmio_to_float32(const char* str)
#endif #endif
} }
gmio_float32_t gmio_stringstream_parse_float32(gmio_stringstream_t* it) gmio_float32_t gmio_stringstream_parse_float32(struct gmio_stringstream* it)
{ {
#if defined(GMIO_STRINGSTREAM_USE_FAST_ATOF) #if defined(GMIO_STRINGSTREAM_USE_FAST_ATOF)
return gmio_stringstream_fast_atof(it); return gmio_stringstream_fast_atof(it);
#else #else
char strbuff_ptr[64]; char strbuff_ptr[64];
gmio_string_t strbuff = { &strbuff_ptr[0], 0, sizeof(strbuff_ptr) }; struct gmio_string strbuff = { &strbuff_ptr[0], 0, sizeof(strbuff_ptr) };
gmio_stringstream_eat_word(it, &strbuff); gmio_stringstream_eat_word(it, &strbuff);
return (gmio_float32_t)atof(strbuff_ptr); return (gmio_float32_t)atof(strbuff_ptr);
#endif #endif

18
src/gmio_core/internal/stringstream_fast_atof.h
View File

@ -12,7 +12,7 @@
#include "fast_atof.h" #include "fast_atof.h"
#include "stringstream.h" #include "stringstream.h"
GMIO_INLINE uint32_t gmio_stringstream_strtoul10(gmio_stringstream_t* it) GMIO_INLINE uint32_t gmio_stringstream_strtoul10(struct gmio_stringstream* it)
{ {
unsigned int value = 0; unsigned int value = 0;
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(it);
@ -25,7 +25,7 @@ GMIO_INLINE uint32_t gmio_stringstream_strtoul10(gmio_stringstream_t* it)
return value; return value;
} }
GMIO_INLINE int32_t gmio_stringstream_strtol10(gmio_stringstream_t* it) GMIO_INLINE int32_t gmio_stringstream_strtol10(struct gmio_stringstream* it)
{ {
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(it);
const gmio_bool_t inv = (*in == '-'); const gmio_bool_t inv = (*in == '-');
@ -39,21 +39,21 @@ GMIO_INLINE int32_t gmio_stringstream_strtol10(gmio_stringstream_t* it)
return value; return value;
} }
typedef struct struct gmio_stringstream_strtof10_result
{ {
float val; float val;
unsigned char_diff; unsigned char_diff;
} gmio_stringstream_strtof10_result_t; };
GMIO_INLINE gmio_stringstream_strtof10_result_t gmio_stringstream_strtof10( GMIO_INLINE struct gmio_stringstream_strtof10_result
gmio_stringstream_t* it) gmio_stringstream_strtof10(struct gmio_stringstream* it)
{ {
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(it);
const uint32_t MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10; const uint32_t MAX_SAFE_U32_VALUE = UINT_MAX / 10 - 10;
uint32_t int_val = 0; uint32_t int_val = 0;
float float_val = 0.f; float float_val = 0.f;
unsigned char_diff = 0; unsigned char_diff = 0;
gmio_stringstream_strtof10_result_t result; struct gmio_stringstream_strtof10_result result;
/* Use integer arithmetic for as long as possible, for speed and /* Use integer arithmetic for as long as possible, for speed and
* precision */ * precision */
@ -79,7 +79,7 @@ GMIO_INLINE gmio_stringstream_strtof10_result_t gmio_stringstream_strtof10(
return result; return result;
} }
GMIO_INLINE float gmio_stringstream_fast_atof(gmio_stringstream_t* it) GMIO_INLINE float gmio_stringstream_fast_atof(struct gmio_stringstream* it)
{ {
const char* in = gmio_stringstream_current_char(it); const char* in = gmio_stringstream_current_char(it);
const gmio_bool_t negative = ('-' == *in); const gmio_bool_t negative = ('-' == *in);
@ -92,7 +92,7 @@ GMIO_INLINE float gmio_stringstream_fast_atof(gmio_stringstream_t* it)
value = gmio_stringstream_strtof10(it).val; value = gmio_stringstream_strtof10(it).val;
in = gmio_stringstream_current_char(it); in = gmio_stringstream_current_char(it);
if (is_local_decimal_point(*in)) { if (is_local_decimal_point(*in)) {
const gmio_stringstream_strtof10_result_t decimal = const struct gmio_stringstream_strtof10_result decimal =
gmio_stringstream_strtof10( gmio_stringstream_strtof10(
gmio_stringstream_move_next_char(it)); gmio_stringstream_move_next_char(it));
value += decimal.val * fast_atof_table[decimal.char_diff]; value += decimal.val * fast_atof_table[decimal.char_diff];

22
src/gmio_core/memblock.c
View File

@ -17,44 +17,38 @@
#include <stdlib.h> #include <stdlib.h>
GMIO_INLINE gmio_memblock_t gmio_memblock_null() struct gmio_memblock gmio_memblock(
{
gmio_memblock_t buff = {0};
return buff;
}
gmio_memblock_t gmio_memblock(
void* ptr, size_t size, void (*func_deallocate)(void*)) void* ptr, size_t size, void (*func_deallocate)(void*))
{ {
gmio_memblock_t buff; struct gmio_memblock buff;
buff.ptr = ptr; buff.ptr = ptr;
buff.size = ptr != NULL ? size : 0; buff.size = ptr != NULL ? size : 0;
buff.func_deallocate = func_deallocate; buff.func_deallocate = func_deallocate;
return buff; return buff;
} }
gmio_memblock_t gmio_memblock_malloc(size_t size) struct gmio_memblock gmio_memblock_malloc(size_t size)
{ {
return gmio_memblock(malloc(size), size, &free); return gmio_memblock(malloc(size), size, &free);
} }
gmio_memblock_t gmio_memblock_calloc(size_t num, size_t size) struct gmio_memblock gmio_memblock_calloc(size_t num, size_t size)
{ {
return gmio_memblock(calloc(num, size), num * size, &free); return gmio_memblock(calloc(num, size), num * size, &free);
} }
gmio_memblock_t gmio_memblock_realloc(void* ptr, size_t size) struct gmio_memblock gmio_memblock_realloc(void* ptr, size_t size)
{ {
return gmio_memblock(realloc(ptr, size), size, &free); return gmio_memblock(realloc(ptr, size), size, &free);
} }
void gmio_memblock_deallocate(gmio_memblock_t *mblock) void gmio_memblock_deallocate(struct gmio_memblock *mblock)
{ {
if (mblock != NULL && mblock->func_deallocate != NULL) if (mblock != NULL && mblock->func_deallocate != NULL)
mblock->func_deallocate(mblock->ptr); mblock->func_deallocate(mblock->ptr);
} }
static gmio_memblock_t gmio_memblock_default_internal_ctor() static struct gmio_memblock gmio_memblock_default_internal_ctor()
{ {
return gmio_memblock_malloc(128 * 1024); /* 128 KB */ return gmio_memblock_malloc(128 * 1024); /* 128 KB */
} }
@ -74,7 +68,7 @@ gmio_memblock_constructor_func_t gmio_memblock_default_constructor()
return gmio_global_mblock_ctor; return gmio_global_mblock_ctor;
} }
gmio_memblock_t gmio_memblock_default() struct gmio_memblock gmio_memblock_default()
{ {
return gmio_global_mblock_ctor(); return gmio_global_mblock_ctor();
} }

17
src/gmio_core/memblock.h
View File

@ -40,7 +40,6 @@ struct gmio_memblock
* beginning at \p ptr */ * beginning at \p ptr */
void (*func_deallocate)(void* ptr); void (*func_deallocate)(void* ptr);
}; };
typedef struct gmio_memblock gmio_memblock_t;
GMIO_C_LINKAGE_BEGIN GMIO_C_LINKAGE_BEGIN
@ -48,27 +47,27 @@ GMIO_C_LINKAGE_BEGIN
* *
* If \p ptr is NULL then gmio_memblock::size is forced to \c 0 * If \p ptr is NULL then gmio_memblock::size is forced to \c 0
*/ */
GMIO_LIB_EXPORT gmio_memblock_t gmio_memblock( GMIO_LIB_EXPORT struct gmio_memblock gmio_memblock(
void* ptr, size_t size, void (*func_deallocate)(void*)); void* ptr, size_t size, void (*func_deallocate)(void*));
/*! Returns a gmio_memblock object allocated with standard \c malloc() */ /*! Returns a gmio_memblock object allocated with standard \c malloc() */
GMIO_LIB_EXPORT gmio_memblock_t gmio_memblock_malloc(size_t size); GMIO_LIB_EXPORT struct gmio_memblock gmio_memblock_malloc(size_t size);
/*! Returns a gmio_memblock object allocated with standard \c calloc() */ /*! Returns a gmio_memblock object allocated with standard \c calloc() */
GMIO_LIB_EXPORT gmio_memblock_t gmio_memblock_calloc(size_t num, size_t size); GMIO_LIB_EXPORT struct gmio_memblock gmio_memblock_calloc(size_t num, size_t size);
/*! Returns a gmio_memblock object allocated with standard \c realloc() */ /*! Returns a gmio_memblock object allocated with standard \c realloc() */
GMIO_LIB_EXPORT gmio_memblock_t gmio_memblock_realloc(void* ptr, size_t size); GMIO_LIB_EXPORT struct gmio_memblock gmio_memblock_realloc(void* ptr, size_t size);
/*! Safe and convenient call to gmio_memblock::func_deallocate() */ /*! Safe and convenient call to gmio_memblock::func_deallocate() */
GMIO_LIB_EXPORT void gmio_memblock_deallocate(gmio_memblock_t* mblock); GMIO_LIB_EXPORT void gmio_memblock_deallocate(struct gmio_memblock* mblock);
/*! Typedef for a pointer to a function that creates an allocated mblock /*! Typedef for a pointer to a function that creates an allocated mblock
* *
* Signature: * Signature:
* \code gmio_memblock_t mblock_ctor(); \endcode * \code struct gmio_memblock mblock_ctor(); \endcode
*/ */
typedef gmio_memblock_t (*gmio_memblock_constructor_func_t)(); typedef struct gmio_memblock (*gmio_memblock_constructor_func_t)();
/*! Installs a global function to construct gmio_memblock objects /*! Installs a global function to construct gmio_memblock objects
* *
@ -88,7 +87,7 @@ GMIO_LIB_EXPORT gmio_memblock_constructor_func_t gmio_memblock_default_construct
/*! Returns a gmio_memblock object created using the function /*! Returns a gmio_memblock object created using the function
* gmio_memblock_default_constructor() */ * gmio_memblock_default_constructor() */
GMIO_LIB_EXPORT gmio_memblock_t gmio_memblock_default(); GMIO_LIB_EXPORT struct gmio_memblock gmio_memblock_default();
GMIO_C_LINKAGE_END GMIO_C_LINKAGE_END

62
src/gmio_core/rwargs.h Normal file
View File

@ -0,0 +1,62 @@
/****************************************************************************
** gmio
** Copyright Fougue (2 Mar. 2015)
** contact@fougue.pro
**
** This software is a reusable library whose purpose is to provide complete
** I/O support for various CAD file formats (eg. STL)
**
** This software is governed by the CeCILL-B license under French law and
** abiding by the rules of distribution of free software. You can use,
** modify and/ or redistribute the software under the terms of the CeCILL-B
** license as circulated by CEA, CNRS and INRIA at the following URL
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/
/*! \file rwargs.h
* Declares structures for the common arguments of read/write operations
*
* \addtogroup gmio_core
* @{
*/
#ifndef GMIO_RWARGS_H
#define GMIO_RWARGS_H
#include "stream.h"
#include "memblock.h"
#include "task_iface.h"
/*! Common arguments for read or write functions */
struct gmio_rwargs
{
/*! The stream object to be used for I/O */
struct gmio_stream stream;
/*! Optional memory block used by the stream to bufferize I/O device
* operations
*
* If passed null to a read/write function, then a temporary memblock
* is created with the global default constructor function (see
* gmio_memblock_default())
*/
struct gmio_memblock memblock;
/*! Optional interface by which the I/O operation can be controlled */
struct gmio_task_iface task_iface;
};
GMIO_INLINE struct gmio_rwargs gmio_rwargs_null();
/*
* Implementation
*/
struct gmio_rwargs gmio_rwargs_null()
{
static const struct gmio_rwargs null = {0};
return null;
}
#endif /* GMIO_RWARGS_H */

12
src/gmio_core/stream.c
View File

@ -45,9 +45,9 @@ GMIO_INLINE int gmio_fstat(int fd, gmio_stat_t* buf)
#endif /* GMIO_HAVE_SYS_TYPES_H && GMIO_HAVE_SYS_STAT_H */ #endif /* GMIO_HAVE_SYS_TYPES_H && GMIO_HAVE_SYS_STAT_H */
gmio_stream_t gmio_stream_null() struct gmio_stream gmio_stream_null()
{ {
gmio_stream_t null_stream = {0}; struct gmio_stream null_stream = {0};
return null_stream; return null_stream;
} }
@ -129,7 +129,7 @@ static gmio_streamsize_t gmio_stream_stdio_size(void* cookie)
#endif #endif
} }
static int gmio_stream_stdio_get_pos(void* cookie, gmio_stream_pos_t* pos) static int gmio_stream_stdio_get_pos(void* cookie, struct gmio_stream_pos* pos)
{ {
fpos_t fpos; fpos_t fpos;
int res = fgetpos((FILE*)cookie, &fpos); int res = fgetpos((FILE*)cookie, &fpos);
@ -137,16 +137,16 @@ static int gmio_stream_stdio_get_pos(void* cookie, gmio_stream_pos_t* pos)
return res; return res;
} }
static int gmio_stream_stdio_set_pos(void* cookie, const gmio_stream_pos_t* pos) static int gmio_stream_stdio_set_pos(void* cookie, const struct gmio_stream_pos* pos)
{ {
fpos_t fpos; fpos_t fpos;
memcpy(&fpos, &pos->cookie[0], sizeof(fpos_t)); memcpy(&fpos, &pos->cookie[0], sizeof(fpos_t));
return fsetpos((FILE*)cookie, &fpos); return fsetpos((FILE*)cookie, &fpos);
} }
gmio_stream_t gmio_stream_stdio(FILE* file) struct gmio_stream gmio_stream_stdio(FILE* file)
{ {
gmio_stream_t stream = gmio_stream_null(); struct gmio_stream stream = gmio_stream_null();
stream.cookie = file; stream.cookie = file;
stream.func_at_end = gmio_stream_stdio_at_end; stream.func_at_end = gmio_stream_stdio_at_end;
stream.func_error = gmio_stream_stdio_error; stream.func_error = gmio_stream_stdio_error;

10
src/gmio_core/stream.h
View File

@ -108,7 +108,7 @@ struct gmio_stream
* \retval 0 on success * \retval 0 on success
* \retval !=0 on error * \retval !=0 on error
*/ */
int (*func_get_pos)(void* cookie, gmio_stream_pos_t* pos); int (*func_get_pos)(void* cookie, struct gmio_stream_pos* pos);
/*! Pointer on a function that restores the current position in the stream /*! Pointer on a function that restores the current position in the stream
* to \p pos * to \p pos
@ -116,21 +116,19 @@ struct gmio_stream
* \retval 0 on success * \retval 0 on success
* \retval !=0 on error * \retval !=0 on error
*/ */
int (*func_set_pos)(void* cookie, const gmio_stream_pos_t* pos); int (*func_set_pos)(void* cookie, const struct gmio_stream_pos* pos);
}; };
typedef struct gmio_stream gmio_stream_t;
GMIO_C_LINKAGE_BEGIN GMIO_C_LINKAGE_BEGIN
/* Initialization */ /* Initialization */
/*! Returns a null stream */ /*! Returns a null stream */
GMIO_LIB_EXPORT gmio_stream_t gmio_stream_null(); GMIO_LIB_EXPORT struct gmio_stream gmio_stream_null();
/*! Returns a stream for standard FILE* (cookie will hold \p file) */ /*! Returns a stream for standard FILE* (cookie will hold \p file) */
GMIO_LIB_EXPORT gmio_stream_t gmio_stream_stdio(FILE* file); GMIO_LIB_EXPORT struct gmio_stream gmio_stream_stdio(FILE* file);
GMIO_C_LINKAGE_END GMIO_C_LINKAGE_END

4
src/gmio_core/stream_pos.c
View File

@ -18,8 +18,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
gmio_stream_pos_t gmio_stream_pos_null() struct gmio_stream_pos gmio_stream_pos_null()
{ {
gmio_stream_pos_t pos = {0}; struct gmio_stream_pos pos = {0};
return pos; return pos;
} }

3
src/gmio_core/stream_pos.h
View File

@ -42,12 +42,11 @@ struct gmio_stream_pos
/*! Stores the actual(concrete) stream position object */ /*! Stores the actual(concrete) stream position object */
uint8_t cookie[GMIO_STREAM_POS_COOKIE_SIZE]; uint8_t cookie[GMIO_STREAM_POS_COOKIE_SIZE];
}; };
typedef struct gmio_stream_pos gmio_stream_pos_t;
GMIO_C_LINKAGE_BEGIN GMIO_C_LINKAGE_BEGIN
/*! Returns a null stream position */ /*! Returns a null stream position */
GMIO_LIB_EXPORT gmio_stream_pos_t gmio_stream_pos_null(); GMIO_LIB_EXPORT struct gmio_stream_pos gmio_stream_pos_null();
GMIO_C_LINKAGE_END GMIO_C_LINKAGE_END

2
src/gmio_core/task_iface.h
View File

@ -50,7 +50,5 @@ struct gmio_task_iface
void (*func_handle_progress)(void* cookie, size_t value, size_t max_value); void (*func_handle_progress)(void* cookie, size_t value, size_t max_value);
}; };
typedef struct gmio_task_iface gmio_task_iface_t;
#endif /* GMIO_TASK_IFACE_H */ #endif /* GMIO_TASK_IFACE_H */
/*! @} */ /*! @} */

1
src/gmio_core/text_format.h
View File

@ -41,7 +41,6 @@ enum gmio_float_text_format
/*! Use the shortest representation: decimal or scientific uppercase */ /*! Use the shortest representation: decimal or scientific uppercase */
GMIO_FLOAT_TEXT_FORMAT_SHORTEST_UPPERCASE GMIO_FLOAT_TEXT_FORMAT_SHORTEST_UPPERCASE
}; };
typedef enum gmio_float_text_format gmio_float_text_format_t;
#endif /* GMIO_TEXT_FORMAT_H */ #endif /* GMIO_TEXT_FORMAT_H */
/*! @} */ /*! @} */

12
src/gmio_stl/internal/helper_stl_mesh_creator.h
View File

@ -21,7 +21,7 @@
/*! Safe and convenient function for /*! Safe and convenient function for
* gmio_stl_mesh_creator::func_ascii_begin_solid() */ * gmio_stl_mesh_creator::func_ascii_begin_solid() */
GMIO_INLINE void gmio_stl_mesh_creator_ascii_begin_solid( GMIO_INLINE void gmio_stl_mesh_creator_ascii_begin_solid(
gmio_stl_mesh_creator_t* creator, struct gmio_stl_mesh_creator* creator,
gmio_streamsize_t stream_size, gmio_streamsize_t stream_size,
const char* solid_name) const char* solid_name)
{ {
@ -34,9 +34,9 @@ GMIO_INLINE void gmio_stl_mesh_creator_ascii_begin_solid(
/*! Safe and convenient function for /*! Safe and convenient function for
* gmio_stl_mesh_creator::func_binary_begin_solid() */ * gmio_stl_mesh_creator::func_binary_begin_solid() */
GMIO_INLINE void gmio_stl_mesh_creator_binary_begin_solid( GMIO_INLINE void gmio_stl_mesh_creator_binary_begin_solid(
gmio_stl_mesh_creator_t* creator, struct gmio_stl_mesh_creator* creator,
uint32_t tri_count, uint32_t tri_count,
const gmio_stlb_header_t* header) const struct gmio_stlb_header* header)
{ {
if (creator != NULL && creator->func_binary_begin_solid != NULL) if (creator != NULL && creator->func_binary_begin_solid != NULL)
creator->func_binary_begin_solid(creator->cookie, tri_count, header); creator->func_binary_begin_solid(creator->cookie, tri_count, header);
@ -45,9 +45,9 @@ GMIO_INLINE void gmio_stl_mesh_creator_binary_begin_solid(
/*! Safe and convenient function for /*! Safe and convenient function for
* gmio_stl_mesh_creator::func_add_triangle() */ * gmio_stl_mesh_creator::func_add_triangle() */
GMIO_INLINE void gmio_stl_mesh_creator_add_triangle( GMIO_INLINE void gmio_stl_mesh_creator_add_triangle(
gmio_stl_mesh_creator_t* creator, struct gmio_stl_mesh_creator* creator,
uint32_t tri_id, uint32_t tri_id,
const gmio_stl_triangle_t* triangle) const struct gmio_stl_triangle* triangle)
{ {
if (creator != NULL && creator->func_add_triangle != NULL) if (creator != NULL && creator->func_add_triangle != NULL)
creator->func_add_triangle(creator->cookie, tri_id, triangle); creator->func_add_triangle(creator->cookie, tri_id, triangle);
@ -56,7 +56,7 @@ GMIO_INLINE void gmio_stl_mesh_creator_add_triangle(
/*! Safe and convenient function for /*! Safe and convenient function for
* gmio_stl_mesh_creator::func_end_solid() */ * gmio_stl_mesh_creator::func_end_solid() */
GMIO_INLINE void gmio_stl_mesh_creator_end_solid( GMIO_INLINE void gmio_stl_mesh_creator_end_solid(
gmio_stl_mesh_creator_t* creator) struct gmio_stl_mesh_creator* creator)
{ {
if (creator != NULL && creator->func_end_solid != NULL) if (creator != NULL && creator->func_end_solid != NULL)
creator->func_end_solid(creator->cookie); creator->func_end_solid(creator->cookie);

8
src/gmio_stl/internal/stl_funptr_typedefs.h
View File

@ -22,19 +22,19 @@
#include "../stl_mesh_creator.h" #include "../stl_mesh_creator.h"
/* gmio_stl_triangle */ /* gmio_stl_triangle */
typedef void (*gmio_stl_triangle_func_fix_endian_t)(gmio_stl_triangle_t*); typedef void (*gmio_stl_triangle_func_fix_endian_t)(struct gmio_stl_triangle*);
/* gmio_stl_mesh */ /* gmio_stl_mesh */
typedef void (*gmio_stl_mesh_func_get_triangle_t)( typedef void (*gmio_stl_mesh_func_get_triangle_t)(
const void*, uint32_t, gmio_stl_triangle_t*); const void*, uint32_t, struct gmio_stl_triangle*);
/* gmio_stl_mesh_creator */ /* gmio_stl_mesh_creator */
typedef void (*gmio_stl_mesh_creator_func_ascii_begin_solid_t)( typedef void (*gmio_stl_mesh_creator_func_ascii_begin_solid_t)(
void*, gmio_streamsize_t, const char*); void*, gmio_streamsize_t, const char*);
typedef void (*gmio_stl_mesh_creator_func_binary_begin_solid_t)( typedef void (*gmio_stl_mesh_creator_func_binary_begin_solid_t)(
void*, uint32_t, const gmio_stlb_header_t*); void*, uint32_t, const struct gmio_stlb_header*);
typedef void (*gmio_stl_mesh_creator_func_add_triangle_t)( typedef void (*gmio_stl_mesh_creator_func_add_triangle_t)(
void*, uint32_t, const gmio_stl_triangle_t*); void*, uint32_t, const struct gmio_stl_triangle*);
typedef void (*gmio_stl_mesh_creator_func_end_solid_t)(void*); typedef void (*gmio_stl_mesh_creator_func_end_solid_t)(void*);
#endif /* GMIO_INTERNAL_STL_FUNPTR_TYPEDEFS_H */ #endif /* GMIO_INTERNAL_STL_FUNPTR_TYPEDEFS_H */

23
src/gmio_stl/internal/stl_rw_common.c
View File

@ -16,30 +16,31 @@
#include "stl_rw_common.h" #include "stl_rw_common.h"
#include "../../gmio_core/error.h" #include "../../gmio_core/error.h"
#include "../../gmio_core/rwargs.h"
#include "../stl_error.h" #include "../stl_error.h"
#include "../stl_io.h" #include "../stl_io.h"
gmio_bool_t gmio_check_transfer(int *error, const gmio_transfer_t* trsf) gmio_bool_t gmio_check_rwargs(int *error, const struct gmio_rwargs* args)
{ {
if (trsf == NULL) { if (args == NULL) {
*error = GMIO_ERROR_NULL_TRANSFER; *error = GMIO_ERROR_NULL_RWARGS;
} }
else { else {
if (trsf->memblock.ptr == NULL) if (args->memblock.ptr == NULL)
*error = GMIO_ERROR_NULL_MEMBLOCK; *error = GMIO_ERROR_NULL_MEMBLOCK;
else if (trsf->memblock.size == 0) else if (args->memblock.size == 0)
*error = GMIO_ERROR_INVALID_MEMBLOCK_SIZE; *error = GMIO_ERROR_INVALID_MEMBLOCK_SIZE;
} }
return gmio_no_error(*error); return gmio_no_error(*error);
} }
gmio_bool_t gmio_stl_check_mesh(int *error, const gmio_stl_mesh_t* mesh) gmio_bool_t gmio_stl_check_mesh(int *error, const struct gmio_stl_mesh* mesh)
{ {
if (mesh == NULL if (mesh == NULL
|| (mesh->triangle_count > 0 && mesh->func_get_triangle == NULL)) || (mesh->triangle_count > 0 && mesh->func_get_triangle == NULL))
{ {
*error = GMIO_STL_ERROR_NULL_GET_TRIANGLE_FUNC; *error = GMIO_STL_ERROR_NULL_FUNC_GET_TRIANGLE;
} }
return gmio_no_error(*error); return gmio_no_error(*error);
@ -47,13 +48,13 @@ gmio_bool_t gmio_stl_check_mesh(int *error, const gmio_stl_mesh_t* mesh)
gmio_bool_t gmio_stlb_check_params( gmio_bool_t gmio_stlb_check_params(
int *error, int *error,
const gmio_transfer_t *trsf, const struct gmio_rwargs* args,
gmio_endianness_t byte_order) enum gmio_endianness byte_order)
{ {
if (!gmio_check_transfer(error, trsf)) if (!gmio_check_rwargs(error, args))
return GMIO_FALSE; return GMIO_FALSE;
if (trsf->memblock.size < GMIO_STLB_MIN_CONTENTS_SIZE) if (args->memblock.size < GMIO_STLB_MIN_CONTENTS_SIZE)
*error = GMIO_ERROR_INVALID_MEMBLOCK_SIZE; *error = GMIO_ERROR_INVALID_MEMBLOCK_SIZE;
if (byte_order != GMIO_ENDIANNESS_LITTLE if (byte_order != GMIO_ENDIANNESS_LITTLE
&& byte_order != GMIO_ENDIANNESS_BIG) && byte_order != GMIO_ENDIANNESS_BIG)

15
src/gmio_stl/internal/stl_rw_common.h
View File

@ -22,9 +22,9 @@
#include "../../gmio_core/global.h" #include "../../gmio_core/global.h"
#include "../../gmio_core/endian.h" #include "../../gmio_core/endian.h"
#include "../../gmio_core/transfer.h"
#include "../stl_mesh.h" struct gmio_rwargs;
#include "../stl_triangle.h" struct gmio_stl_mesh;
struct gmio_stlb_readwrite_helper struct gmio_stlb_readwrite_helper
{ {
@ -32,15 +32,14 @@ struct gmio_stlb_readwrite_helper
uint32_t i_facet_offset; uint32_t i_facet_offset;
gmio_stl_triangle_func_fix_endian_t func_fix_endian; gmio_stl_triangle_func_fix_endian_t func_fix_endian;
}; };
typedef struct gmio_stlb_readwrite_helper gmio_stlb_readwrite_helper_t;
gmio_bool_t gmio_check_transfer(int* error, const gmio_transfer_t* trsf); gmio_bool_t gmio_check_rwargs(int* error, const struct gmio_rwargs* args);
gmio_bool_t gmio_stl_check_mesh(int* error, const gmio_stl_mesh_t *mesh); gmio_bool_t gmio_stl_check_mesh(int* error, const struct gmio_stl_mesh* mesh);
gmio_bool_t gmio_stlb_check_params( gmio_bool_t gmio_stlb_check_params(
int* error, int* error,
const gmio_transfer_t* trsf, const struct gmio_rwargs* args,
gmio_endianness_t byte_order); enum gmio_endianness byte_order);
#endif /* GMIO_INTERNAL_STLB_RW_COMMON_H */ #endif /* GMIO_INTERNAL_STLB_RW_COMMON_H */

49
src/gmio_stl/internal/stla_write.c
View File

@ -18,10 +18,14 @@
#include "stl_funptr_typedefs.h" #include "stl_funptr_typedefs.h"
#include "stl_rw_common.h" #include "stl_rw_common.h"
#include "../stl_error.h" #include "../stl_error.h"
#include "../stl_io_options.h"
#include "../stl_mesh.h"
#include "../../gmio_core/error.h" #include "../../gmio_core/error.h"
#include "../../gmio_core/rwargs.h"
#include "../../gmio_core/text_format.h"
#include "../../gmio_core/internal/helper_rwargs.h"
#include "../../gmio_core/internal/helper_stream.h" #include "../../gmio_core/internal/helper_stream.h"
#include "../../gmio_core/internal/helper_transfer.h"
#include "../../gmio_core/internal/min_max.h" #include "../../gmio_core/internal/min_max.h"
#include "../../gmio_core/internal/safe_cast.h" #include "../../gmio_core/internal/safe_cast.h"
@ -85,7 +89,7 @@ GMIO_INLINE char* gmio_write_rawstr_eol(char* buffer, const char* str)
} }
GMIO_INLINE char gmio_float_text_format_to_specifier( GMIO_INLINE char gmio_float_text_format_to_specifier(
gmio_float_text_format_t format) enum gmio_float_text_format format)
{ {
switch (format) { switch (format) {
case GMIO_FLOAT_TEXT_FORMAT_DECIMAL_LOWERCASE: return 'f'; case GMIO_FLOAT_TEXT_FORMAT_DECIMAL_LOWERCASE: return 'f';
@ -114,36 +118,37 @@ GMIO_INLINE char* gmio_write_stdio_format(
GMIO_INLINE char* gmio_write_coords( GMIO_INLINE char* gmio_write_coords(
char* buffer, char* buffer,
const char* coords_format, const char* coords_format,
const gmio_stl_coords_t* coords) const struct gmio_stl_coords* coords)
{ {
return buffer + sprintf(buffer, return buffer + sprintf(buffer,
coords_format, coords->x, coords->y, coords->z); coords_format, coords->x, coords->y, coords->z);
} }
GMIO_INLINE gmio_bool_t gmio_transfer_flush_buffer( GMIO_INLINE gmio_bool_t gmio_rwargs_flush_buffer(
gmio_transfer_t* trsf, size_t n) struct gmio_rwargs* args, size_t n)
{ {
const size_t write_count = const size_t write_count =
gmio_stream_write(&trsf->stream, trsf->memblock.ptr, sizeof(char), n); gmio_stream_write(
&args->stream, args->memblock.ptr, sizeof(char), n);
return write_count == n; return write_count == n;
} }
int gmio_stla_write( int gmio_stla_write(
gmio_transfer_t* trsf, struct gmio_rwargs* args,
const gmio_stl_mesh_t* mesh, const struct gmio_stl_mesh* mesh,
const gmio_stl_write_options_t* options) const struct gmio_stl_write_options* options)
{ {
/* Constants */ /* Constants */
const uint32_t total_facet_count = mesh != NULL ? mesh->triangle_count : 0; const uint32_t total_facet_count = mesh != NULL ? mesh->triangle_count : 0;
const uint32_t buffer_facet_count = const uint32_t buffer_facet_count =
trsf != NULL ? args != NULL ?
gmio_size_to_uint32(trsf->memblock.size / GMIO_STLA_FACET_SIZE_P2) gmio_size_to_uint32(args->memblock.size / GMIO_STLA_FACET_SIZE_P2)
: 0; : 0;
const char* opt_solid_name = const char* opt_solid_name =
options != NULL ? options->stla_solid_name : NULL; options != NULL ? options->stla_solid_name : NULL;
const char* solid_name = const char* solid_name =
opt_solid_name != NULL ? opt_solid_name : ""; opt_solid_name != NULL ? opt_solid_name : "";
const gmio_float_text_format_t float32_format = const enum gmio_float_text_format float32_format =
options != NULL ? options != NULL ?
options->stla_float32_format : options->stla_float32_format :
GMIO_FLOAT_TEXT_FORMAT_DECIMAL_LOWERCASE; GMIO_FLOAT_TEXT_FORMAT_DECIMAL_LOWERCASE;
@ -153,19 +158,19 @@ int gmio_stla_write(
options != NULL ? options->stl_write_triangles_only : GMIO_FALSE; options != NULL ? options->stl_write_triangles_only : GMIO_FALSE;
/* Variables */ /* Variables */
uint32_t ifacet = 0; uint32_t ifacet = 0;
void* mblock_ptr = trsf != NULL ? trsf->memblock.ptr : NULL; void* mblock_ptr = args != NULL ? args->memblock.ptr : NULL;
char* buffc = mblock_ptr; char* buffc = mblock_ptr;
char coords_format[64]; char coords_format[64];
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
/* Check validity of input parameters */ /* Check validity of input parameters */
if (!gmio_check_transfer(&error, trsf)) if (!gmio_check_rwargs(&error, args))
return error; return error;
if (!gmio_stl_check_mesh(&error, mesh)) if (!gmio_stl_check_mesh(&error, mesh))
return error; return error;
if (float32_prec == 0 || float32_prec > 9) if (float32_prec == 0 || float32_prec > 9)
return GMIO_STL_ERROR_INVALID_FLOAT32_PREC; return GMIO_STL_ERROR_INVALID_FLOAT32_PREC;
if (trsf->memblock.size < GMIO_STLA_FACET_SIZE_P2) if (args->memblock.size < GMIO_STLA_FACET_SIZE_P2)
return GMIO_ERROR_INVALID_MEMBLOCK_SIZE; return GMIO_ERROR_INVALID_MEMBLOCK_SIZE;
{ /* Create XYZ coords format string (for normal and vertex coords) */ { /* Create XYZ coords format string (for normal and vertex coords) */
@ -185,7 +190,7 @@ int gmio_stla_write(
if (!write_triangles_only) { if (!write_triangles_only) {
buffc = gmio_write_rawstr(buffc, "solid "); buffc = gmio_write_rawstr(buffc, "solid ");
buffc = gmio_write_rawstr_eol(buffc, solid_name); buffc = gmio_write_rawstr_eol(buffc, solid_name);
if (!gmio_transfer_flush_buffer(trsf, buffc - (char*)mblock_ptr)) if (!gmio_rwargs_flush_buffer(args, buffc - (char*)mblock_ptr))
return GMIO_ERROR_STREAM; return GMIO_ERROR_STREAM;
} }
@ -199,10 +204,10 @@ int gmio_stla_write(
const void* mesh_cookie = mesh->cookie; const void* mesh_cookie = mesh->cookie;
const uint32_t clamped_facet_count = const uint32_t clamped_facet_count =
GMIO_MIN(ifacet + buffer_facet_count, total_facet_count); GMIO_MIN(ifacet + buffer_facet_count, total_facet_count);
gmio_stl_triangle_t tri; struct gmio_stl_triangle tri;
uint32_t ibuffer_facet; uint32_t ibuffer_facet;
gmio_transfer_handle_progress(trsf, ifacet, total_facet_count); gmio_rwargs_handle_progress(args, ifacet, total_facet_count);
/* Writing of facets is buffered */ /* Writing of facets is buffered */
buffc = mblock_ptr; buffc = mblock_ptr;
@ -226,19 +231,19 @@ int gmio_stla_write(
buffc = gmio_write_rawstr(buffc, "\nendfacet\n"); buffc = gmio_write_rawstr(buffc, "\nendfacet\n");
} /* end for (ibuffer_facet) */ } /* end for (ibuffer_facet) */
if (!gmio_transfer_flush_buffer(trsf, buffc - (char*)mblock_ptr)) if (!gmio_rwargs_flush_buffer(args, buffc - (char*)mblock_ptr))
error = GMIO_ERROR_STREAM; error = GMIO_ERROR_STREAM;
/* Task control */ /* Task control */
if (gmio_no_error(error) && gmio_transfer_is_stop_requested(trsf)) if (gmio_no_error(error) && gmio_rwargs_is_stop_requested(args))
error = GMIO_ERROR_TRANSFER_STOPPED; error = GMIO_ERROR_TRANSFER_STOPPED;
} /* end for (ifacet) */ } /* end for (ifacet) */
/* Write end of solid */ /* Write end of solid */
if (gmio_no_error(error) && !write_triangles_only) { if (gmio_no_error(error) && !write_triangles_only) {
buffc = gmio_write_rawstr(trsf->memblock.ptr, "endsolid "); buffc = gmio_write_rawstr(args->memblock.ptr, "endsolid ");
buffc = gmio_write_rawstr_eol(buffc, solid_name); buffc = gmio_write_rawstr_eol(buffc, solid_name);
if (!gmio_transfer_flush_buffer(trsf, buffc - (char*)mblock_ptr)) if (!gmio_rwargs_flush_buffer(args, buffc - (char*)mblock_ptr))
error = GMIO_ERROR_STREAM; error = GMIO_ERROR_STREAM;
} }

15
src/gmio_stl/internal/stla_write.h
View File

@ -16,20 +16,19 @@
#ifndef GMIO_INTERNAL_STLA_WRITE_H #ifndef GMIO_INTERNAL_STLA_WRITE_H
#define GMIO_INTERNAL_STLA_WRITE_H #define GMIO_INTERNAL_STLA_WRITE_H
#include "../stl_mesh.h" struct gmio_rwargs;
#include "../stl_io_options.h" struct gmio_stl_mesh;
#include "../../gmio_core/text_format.h" struct gmio_stl_write_options;
#include "../../gmio_core/transfer.h"
/*! Writes geometry in the STL ascii format /*! Writes geometry in the STL ascii format
* *
* \return Error code (see error.h and stl_error.h) * \return Error code (see error.h and stl_error.h)
* \retval GMIO_ERROR_INVALID_MEMBLOCK_SIZE * \retval GMIO_ERROR_INVALID_MEMBLOCK_SIZE
* if <tt>trsf->memblock.size < 512</tt> * if <tt>args->memblock.size < 512</tt>
*/ */
int gmio_stla_write( int gmio_stla_write(
gmio_transfer_t* trsf, struct gmio_rwargs* args,
const gmio_stl_mesh_t* mesh, const struct gmio_stl_mesh* mesh,
const gmio_stl_write_options_t* options); const struct gmio_stl_write_options* options);
#endif /* GMIO_INTERNAL_STLA_WRITE_H */ #endif /* GMIO_INTERNAL_STLA_WRITE_H */

2
src/gmio_stl/internal/stlb_byte_swap.c
View File

@ -17,7 +17,7 @@
#include "../../gmio_core/internal/byte_swap.h" #include "../../gmio_core/internal/byte_swap.h"
void gmio_stl_triangle_bswap(gmio_stl_triangle_t* triangle) void gmio_stl_triangle_bswap(struct gmio_stl_triangle* triangle)
{ {
int i; int i;
uint32_t* uintcoord_ptr = (uint32_t*)&(triangle->normal.x); uint32_t* uintcoord_ptr = (uint32_t*)&(triangle->normal.x);

2
src/gmio_stl/internal/stlb_byte_swap.h
View File

@ -24,6 +24,6 @@
* Each XYZ coord (float32) is individually reversed (byte-swap) as well as * Each XYZ coord (float32) is individually reversed (byte-swap) as well as
* the "attribute byte count" member. * the "attribute byte count" member.
*/ */
void gmio_stl_triangle_bswap(gmio_stl_triangle_t* triangle); void gmio_stl_triangle_bswap(struct gmio_stl_triangle* triangle);
#endif /* GMIO_INTERNAL_STLB_BYTE_SWAP_H */ #endif /* GMIO_INTERNAL_STLB_BYTE_SWAP_H */

35
src/gmio_stl/internal/stlb_write.c
View File

@ -20,26 +20,27 @@
#include "stlb_byte_swap.h" #include "stlb_byte_swap.h"
#include "../stl_error.h" #include "../stl_error.h"
#include "../stl_io.h" #include "../stl_io.h"
#include "../stl_io_options.h"
#include "../../gmio_core/error.h" #include "../../gmio_core/error.h"
#include "../../gmio_core/internal/byte_codec.h" #include "../../gmio_core/internal/byte_codec.h"
#include "../../gmio_core/internal/min_max.h" #include "../../gmio_core/internal/min_max.h"
#include "../../gmio_core/internal/helper_rwargs.h"
#include "../../gmio_core/internal/helper_stream.h" #include "../../gmio_core/internal/helper_stream.h"
#include "../../gmio_core/internal/helper_transfer.h"
#include "../../gmio_core/internal/safe_cast.h" #include "../../gmio_core/internal/safe_cast.h"
#include <string.h> #include <string.h>
GMIO_INLINE void write_triangle_memcpy( GMIO_INLINE void write_triangle_memcpy(
const gmio_stl_triangle_t* triangle, uint8_t* mblock) const struct gmio_stl_triangle* triangle, uint8_t* mblock)
{ {
memcpy(mblock, triangle, GMIO_STLB_TRIANGLE_RAWSIZE); memcpy(mblock, triangle, GMIO_STLB_TRIANGLE_RAWSIZE);
} }
static void gmio_stlb_write_facets( static void gmio_stlb_write_facets(
const gmio_stl_mesh_t* mesh, const struct gmio_stl_mesh* mesh,
uint8_t* mblock, uint8_t* mblock,
const gmio_stlb_readwrite_helper_t* wparams) const struct gmio_stlb_readwrite_helper* wparams)
{ {
const uint32_t facet_count = wparams->facet_count; const uint32_t facet_count = wparams->facet_count;
const uint32_t i_facet_offset = wparams->i_facet_offset; const uint32_t i_facet_offset = wparams->i_facet_offset;
@ -48,7 +49,7 @@ static void gmio_stlb_write_facets(
const gmio_stl_mesh_func_get_triangle_t func_get_triangle = const gmio_stl_mesh_func_get_triangle_t func_get_triangle =
mesh->func_get_triangle; mesh->func_get_triangle;
const void* cookie = mesh->cookie; const void* cookie = mesh->cookie;
gmio_stl_triangle_t triangle; struct gmio_stl_triangle triangle;
uint32_t mblock_offset = 0; uint32_t mblock_offset = 0;
uint32_t i_facet = 0; uint32_t i_facet = 0;
@ -65,10 +66,10 @@ static void gmio_stlb_write_facets(
} }
int gmio_stlb_write( int gmio_stlb_write(
gmio_transfer_t* trsf, struct gmio_rwargs* args,
const gmio_stl_mesh_t* mesh, const struct gmio_stl_mesh* mesh,
const gmio_stl_write_options_t* options, const struct gmio_stl_write_options* options,
gmio_endianness_t byte_order) enum gmio_endianness byte_order)
{ {
/* Constants */ /* Constants */
const uint32_t facet_count = const uint32_t facet_count =
@ -76,14 +77,14 @@ int gmio_stlb_write(
const gmio_bool_t write_triangles_only = const gmio_bool_t write_triangles_only =
options != NULL ? options->stl_write_triangles_only : GMIO_FALSE; options != NULL ? options->stl_write_triangles_only : GMIO_FALSE;
/* Variables */ /* Variables */
void* mblock_ptr = trsf != NULL ? trsf->memblock.ptr : NULL; void* mblock_ptr = args != NULL ? args->memblock.ptr : NULL;
gmio_stlb_readwrite_helper_t wparams = {0}; struct gmio_stlb_readwrite_helper wparams = {0};
uint32_t i_facet = 0; uint32_t i_facet = 0;
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
/* Check validity of input parameters */ /* Check validity of input parameters */
if (!gmio_stl_check_mesh(&error, mesh) if (!gmio_stl_check_mesh(&error, mesh)
|| !gmio_stlb_check_params(&error, trsf, byte_order)) || !gmio_stlb_check_params(&error, args, byte_order))
{ {
return error; return error;
} }
@ -94,11 +95,11 @@ int gmio_stlb_write(
/* Note: trsf != NULL certified by gmio_stlb_check_params() */ /* Note: trsf != NULL certified by gmio_stlb_check_params() */
/* coverity[var_deref_op : FALSE] */ /* coverity[var_deref_op : FALSE] */
wparams.facet_count = gmio_size_to_uint32( wparams.facet_count = gmio_size_to_uint32(
trsf->memblock.size / GMIO_STLB_TRIANGLE_RAWSIZE); args->memblock.size / GMIO_STLB_TRIANGLE_RAWSIZE);
if (!write_triangles_only) { if (!write_triangles_only) {
error = gmio_stlb_write_header( error = gmio_stlb_write_header(
&trsf->stream, &args->stream,
byte_order, byte_order,
options != NULL ? options->stlb_header_data : NULL, options != NULL ? options->stlb_header_data : NULL,
facet_count); facet_count);
@ -111,7 +112,7 @@ int gmio_stlb_write(
i_facet < facet_count && gmio_no_error(error); i_facet < facet_count && gmio_no_error(error);
i_facet += wparams.facet_count) i_facet += wparams.facet_count)
{ {
gmio_transfer_handle_progress(trsf, i_facet, facet_count); gmio_rwargs_handle_progress(args, i_facet, facet_count);
/* Write to memory block */ /* Write to memory block */
wparams.facet_count = GMIO_MIN(wparams.facet_count, wparams.facet_count = GMIO_MIN(wparams.facet_count,
@ -122,7 +123,7 @@ int gmio_stlb_write(
/* Write memory block to stream */ /* Write memory block to stream */
if (gmio_stream_write( if (gmio_stream_write(
&trsf->stream, &args->stream,
mblock_ptr, mblock_ptr,
GMIO_STLB_TRIANGLE_RAWSIZE, GMIO_STLB_TRIANGLE_RAWSIZE,
wparams.facet_count) wparams.facet_count)
@ -132,7 +133,7 @@ int gmio_stlb_write(
} }
/* Handle stop request */ /* Handle stop request */
if (gmio_no_error(error) && gmio_transfer_is_stop_requested(trsf)) if (gmio_no_error(error) && gmio_rwargs_is_stop_requested(args))
error = GMIO_ERROR_TRANSFER_STOPPED; error = GMIO_ERROR_TRANSFER_STOPPED;
} /* end for */ } /* end for */

16
src/gmio_stl/internal/stlb_write.h
View File

@ -16,10 +16,10 @@
#ifndef GMIO_INTERNAL_STLB_WRITE_H #ifndef GMIO_INTERNAL_STLB_WRITE_H
#define GMIO_INTERNAL_STLB_WRITE_H #define GMIO_INTERNAL_STLB_WRITE_H
#include "../stl_mesh.h" struct gmio_rwargs;
#include "../stl_io_options.h" struct gmio_stl_mesh;
#include "../../gmio_core/endian.h" struct gmio_stl_write_options;
#include "../../gmio_core/transfer.h" enum gmio_endianness;
/*! Writes geometry in the STL binary format /*! Writes geometry in the STL binary format
* *
@ -28,9 +28,9 @@
* if <tt>trsf->memblock.size < GMIO_STLB_MIN_CONTENTS_SIZE</tt> * if <tt>trsf->memblock.size < GMIO_STLB_MIN_CONTENTS_SIZE</tt>
*/ */
int gmio_stlb_write( int gmio_stlb_write(
gmio_transfer_t* trsf, struct gmio_rwargs* args,
const gmio_stl_mesh_t* mesh, const struct gmio_stl_mesh* mesh,
const gmio_stl_write_options_t* options, const struct gmio_stl_write_options* options,
gmio_endianness_t byte_order); enum gmio_endianness byte_order);
#endif /* GMIO_INTERNAL_STLB_WRITE_H */ #endif /* GMIO_INTERNAL_STLB_WRITE_H */

4
src/gmio_stl/stl_error.h
View File

@ -35,7 +35,7 @@ enum gmio_stl_error
/*! Common STL write error indicating gmio_stl_mesh::func_get_triangle() /*! Common STL write error indicating gmio_stl_mesh::func_get_triangle()
* pointer is NULL */ * pointer is NULL */
GMIO_STL_ERROR_NULL_GET_TRIANGLE_FUNC = GMIO_STL_ERROR_TAG + 0x02, GMIO_STL_ERROR_NULL_FUNC_GET_TRIANGLE = GMIO_STL_ERROR_TAG + 0x02,
/* Specific error codes returned by STL_ascii read function */ /* Specific error codes returned by STL_ascii read function */
@ -58,7 +58,5 @@ enum gmio_stl_error
GMIO_STL_ERROR_FACET_COUNT = GMIO_STL_ERROR_TAG + 0x1002 GMIO_STL_ERROR_FACET_COUNT = GMIO_STL_ERROR_TAG + 0x1002
}; };
typedef enum gmio_stl_error gmio_stl_error_t;
#endif /* GMIO_STL_ERROR_H */ #endif /* GMIO_STL_ERROR_H */
/*! @} */ /*! @} */

10
src/gmio_stl/stl_format.c
View File

@ -34,11 +34,11 @@ GMIO_INLINE gmio_streamsize_t gmio_stlb_streamsize(uint32_t facet_count)
return GMIO_STLB_HEADER_SIZE + 4 + facet_count*GMIO_STLB_TRIANGLE_RAWSIZE; return GMIO_STLB_HEADER_SIZE + 4 + facet_count*GMIO_STLB_TRIANGLE_RAWSIZE;
} }
gmio_stl_format_t gmio_stl_get_format(gmio_stream_t *stream) enum gmio_stl_format gmio_stl_get_format(struct gmio_stream *stream)
{ {
char fixed_buffer[GMIO_FIXED_BUFFER_SIZE] = {0}; char fixed_buffer[GMIO_FIXED_BUFFER_SIZE] = {0};
size_t read_size = 0; size_t read_size = 0;
gmio_stream_pos_t stream_start_pos = gmio_stream_pos_null(); struct gmio_stream_pos stream_start_pos = gmio_stream_pos_null();
if (stream == NULL) if (stream == NULL)
return GMIO_STL_FORMAT_UNKNOWN; return GMIO_STL_FORMAT_UNKNOWN;
@ -89,13 +89,13 @@ gmio_stl_format_t gmio_stl_get_format(gmio_stream_t *stream)
return GMIO_STL_FORMAT_UNKNOWN; return GMIO_STL_FORMAT_UNKNOWN;
} }
gmio_stl_format_t gmio_stl_get_format_file(const char* filepath) enum gmio_stl_format gmio_stl_get_format_file(const char* filepath)
{ {
gmio_stl_format_t format = GMIO_STL_FORMAT_UNKNOWN; enum gmio_stl_format format = GMIO_STL_FORMAT_UNKNOWN;
FILE* file = fopen(filepath, "rb"); FILE* file = fopen(filepath, "rb");
if (file != NULL) { if (file != NULL) {
gmio_stream_t stream = gmio_stream_stdio(file); struct gmio_stream stream = gmio_stream_stdio(file);
format = gmio_stl_get_format(&stream); format = gmio_stl_get_format(&stream);
fclose(file); fclose(file);
} }

6
src/gmio_stl/stl_format.h
View File

@ -35,8 +35,6 @@ enum gmio_stl_format
GMIO_STL_FORMAT_BINARY_BE /*!< STL binary (big-endian) */ GMIO_STL_FORMAT_BINARY_BE /*!< STL binary (big-endian) */
}; };
typedef enum gmio_stl_format gmio_stl_format_t;
GMIO_C_LINKAGE_BEGIN GMIO_C_LINKAGE_BEGIN
/*! Returns the format of the STL data in \p stream /*! Returns the format of the STL data in \p stream
@ -47,7 +45,7 @@ GMIO_C_LINKAGE_BEGIN
* \retval GMIO_STL_FORMAT_UNKNOWN in case of error. * \retval GMIO_STL_FORMAT_UNKNOWN in case of error.
*/ */
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
gmio_stl_format_t gmio_stl_get_format(gmio_stream_t* stream); enum gmio_stl_format gmio_stl_get_format(struct gmio_stream* stream);
/*! Returns the format of the STL data in file at location \p filepath /*! Returns the format of the STL data in file at location \p filepath
* *
@ -58,7 +56,7 @@ gmio_stl_format_t gmio_stl_get_format(gmio_stream_t* stream);
* environment * environment
*/ */
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
gmio_stl_format_t gmio_stl_get_format_file(const char* filepath); enum gmio_stl_format gmio_stl_get_format_file(const char* filepath);
GMIO_C_LINKAGE_END GMIO_C_LINKAGE_END

112
src/gmio_stl/stl_io.c
View File

@ -17,33 +17,37 @@
#include "stl_error.h" #include "stl_error.h"
#include "stl_format.h" #include "stl_format.h"
#include "stlb_header.h"
#include "internal/stla_write.h" #include "internal/stla_write.h"
#include "internal/stlb_write.h" #include "internal/stlb_write.h"
#include "../gmio_core/error.h" #include "../gmio_core/error.h"
#include "../gmio_core/rwargs.h"
#include "../gmio_core/stream.h" #include "../gmio_core/stream.h"
#include "../gmio_core/transfer.h"
#include "../gmio_core/internal/byte_codec.h" #include "../gmio_core/internal/byte_codec.h"
#include "../gmio_core/internal/helper_stream.h" #include "../gmio_core/internal/helper_stream.h"
int gmio_stl_read_file( int gmio_stl_read_file(
const char* filepath, const char* filepath,
gmio_stl_mesh_creator_t* creator, struct gmio_rwargs* args,
gmio_task_iface_t* task_iface) struct gmio_stl_mesh_creator* creator)
{ {
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
FILE* file = NULL; FILE* file = NULL;
file = fopen(filepath, "rb"); file = fopen(filepath, "rb");
if (file != NULL) { if (file != NULL) {
gmio_transfer_t trsf = {0}; struct gmio_rwargs local_args =
trsf.stream = gmio_stream_stdio(file); args != NULL ? *args : gmio_rwargs_null();
trsf.memblock = gmio_memblock_default(); const gmio_bool_t memblock_allocated =
if (task_iface != NULL) local_args.memblock.ptr == NULL;
trsf.task_iface = *task_iface;
error = gmio_stl_read(&trsf, creator); if (memblock_allocated)
local_args.memblock = gmio_memblock_default();
local_args.stream = gmio_stream_stdio(file);
error = gmio_stl_read(&local_args, creator);
fclose(file); fclose(file);
gmio_memblock_deallocate(&trsf.memblock); if (memblock_allocated)
gmio_memblock_deallocate(&local_args.memblock);
} }
else { else {
error = GMIO_ERROR_STDIO; error = GMIO_ERROR_STDIO;
@ -52,24 +56,27 @@ int gmio_stl_read_file(
return error; return error;
} }
int gmio_stl_read(gmio_transfer_t *trsf, gmio_stl_mesh_creator_t *creator) int gmio_stl_read(
struct gmio_rwargs* args,
struct gmio_stl_mesh_creator* creator)
{ {
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
if (trsf != NULL) { if (args != NULL) {
const gmio_stl_format_t stl_format = gmio_stl_get_format(&trsf->stream); const enum gmio_stl_format stl_format =
gmio_stl_get_format(&args->stream);
switch (stl_format) { switch (stl_format) {
case GMIO_STL_FORMAT_ASCII: { case GMIO_STL_FORMAT_ASCII: {
error = gmio_stla_read(trsf, creator); error = gmio_stla_read(args, creator);
break; break;
} }
case GMIO_STL_FORMAT_BINARY_BE: { case GMIO_STL_FORMAT_BINARY_BE: {
error = gmio_stlb_read(trsf, creator, GMIO_ENDIANNESS_BIG); error = gmio_stlb_read(args, creator, GMIO_ENDIANNESS_BIG);
break; break;
} }
case GMIO_STL_FORMAT_BINARY_LE: { case GMIO_STL_FORMAT_BINARY_LE: {
error = gmio_stlb_read(trsf, creator, GMIO_ENDIANNESS_LITTLE); error = gmio_stlb_read(args, creator, GMIO_ENDIANNESS_LITTLE);
break; break;
} }
case GMIO_STL_FORMAT_UNKNOWN: { case GMIO_STL_FORMAT_UNKNOWN: {
@ -78,33 +85,36 @@ int gmio_stl_read(gmio_transfer_t *trsf, gmio_stl_mesh_creator_t *creator)
} /* end switch() */ } /* end switch() */
} }
else { else {
error = GMIO_ERROR_NULL_TRANSFER; error = GMIO_ERROR_NULL_RWARGS;
} }
return error; return error;
} }
int gmio_stl_write_file( int gmio_stl_write_file(
gmio_stl_format_t format, const char* filepath,
const char *filepath, struct gmio_rwargs* args,
const gmio_stl_mesh_t *mesh, const struct gmio_stl_mesh* mesh,
gmio_task_iface_t *task_iface, enum gmio_stl_format format,
const gmio_stl_write_options_t *options) const struct gmio_stl_write_options* options)
{ {
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
FILE* file = NULL; FILE* file = NULL;
file = fopen(filepath, "wb"); file = fopen(filepath, "wb");
if (file != NULL) { if (file != NULL) {
gmio_transfer_t trsf = {0}; struct gmio_rwargs local_args =
trsf.stream = gmio_stream_stdio(file); args != NULL ? *args : gmio_rwargs_null();
trsf.memblock = gmio_memblock_default(); const gmio_bool_t memblock_allocated =
if (task_iface != NULL) local_args.memblock.ptr == NULL;
trsf.task_iface = *task_iface;
error = gmio_stl_write(format, &trsf, mesh, options); if (memblock_allocated)
local_args.memblock = gmio_memblock_default();
local_args.stream = gmio_stream_stdio(file);
error = gmio_stl_write(&local_args, mesh, format, options);
fclose(file); fclose(file);
gmio_memblock_deallocate(&trsf.memblock); if (memblock_allocated)
gmio_memblock_deallocate(&local_args.memblock);
} }
else { else {
error = GMIO_ERROR_STDIO; error = GMIO_ERROR_STDIO;
@ -114,49 +124,56 @@ int gmio_stl_write_file(
} }
int gmio_stl_write( int gmio_stl_write(
gmio_stl_format_t format, struct gmio_rwargs* args,
gmio_transfer_t *trsf, const struct gmio_stl_mesh* mesh,
const gmio_stl_mesh_t *mesh, enum gmio_stl_format format,
const gmio_stl_write_options_t *options) const struct gmio_stl_write_options* options)
{ {
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
if (trsf != NULL) { if (args != NULL) {
const gmio_bool_t memblock_allocated = args->memblock.ptr == NULL;
if (memblock_allocated)
args->memblock = gmio_memblock_default();
switch (format) { switch (format) {
case GMIO_STL_FORMAT_ASCII: { case GMIO_STL_FORMAT_ASCII: {
error = gmio_stla_write(trsf, mesh, options); error = gmio_stla_write(args, mesh, options);
break; break;
} }
case GMIO_STL_FORMAT_BINARY_BE: { case GMIO_STL_FORMAT_BINARY_BE: {
error = gmio_stlb_write(trsf, mesh, options, GMIO_ENDIANNESS_BIG); error = gmio_stlb_write(args, mesh, options, GMIO_ENDIANNESS_BIG);
break; break;
} }
case GMIO_STL_FORMAT_BINARY_LE: { case GMIO_STL_FORMAT_BINARY_LE: {
error = gmio_stlb_write(trsf, mesh, options, GMIO_ENDIANNESS_LITTLE); error = gmio_stlb_write(args, mesh, options, GMIO_ENDIANNESS_LITTLE);
break; break;
} }
case GMIO_STL_FORMAT_UNKNOWN: { case GMIO_STL_FORMAT_UNKNOWN: {
error = GMIO_STL_ERROR_UNKNOWN_FORMAT; error = GMIO_STL_ERROR_UNKNOWN_FORMAT;
} }
} /* end switch() */ } /* end switch() */
if (memblock_allocated)
gmio_memblock_deallocate(&args->memblock);
} }
else { else {
error = GMIO_ERROR_NULL_TRANSFER; error = GMIO_ERROR_NULL_RWARGS;
} }
return error; return error;
} }
static const gmio_stlb_header_t internal_stlb_zero_header = {0}; static const struct gmio_stlb_header internal_stlb_zero_header = {0};
int gmio_stlb_write_header( int gmio_stlb_write_header(
gmio_stream_t *stream, struct gmio_stream *stream,
gmio_endianness_t byte_order, enum gmio_endianness byte_order,
const gmio_stlb_header_t *header, const struct gmio_stlb_header *header,
uint32_t facet_count) uint32_t facet_count)
{ {
uint8_t facet_count_bytes[sizeof(uint32_t)]; uint8_t facet_count_bytes[sizeof(uint32_t)];
const gmio_stlb_header_t* non_null_header = const struct gmio_stlb_header* non_null_header =
header != NULL ? header : &internal_stlb_zero_header; header != NULL ? header : &internal_stlb_zero_header;
/* Write 80-byte header */ /* Write 80-byte header */
@ -168,14 +185,11 @@ int gmio_stlb_write_header(
/* Write facet count */ /* Write facet count */
if (byte_order == GMIO_ENDIANNESS_LITTLE) if (byte_order == GMIO_ENDIANNESS_LITTLE)
gmio_encode_uint32_le(facet_count, &facet_count_bytes[0]); gmio_encode_uint32_le(facet_count, facet_count_bytes);
else else
gmio_encode_uint32_be(facet_count, &facet_count_bytes[0]); gmio_encode_uint32_be(facet_count, facet_count_bytes);
if (gmio_stream_write(stream, &facet_count_bytes[0], sizeof(uint32_t), 1) if (gmio_stream_write(stream, facet_count_bytes, sizeof(uint32_t), 1) != 1)
!= 1)
{
return GMIO_ERROR_STREAM; return GMIO_ERROR_STREAM;
}
return GMIO_ERROR_OK; return GMIO_ERROR_OK;
} }

89
src/gmio_stl/stl_io.h
View File

@ -25,20 +25,21 @@
#include "stl_global.h" #include "stl_global.h"
#include "stl_format.h" #include "stl_format.h"
#include "stl_mesh.h"
#include "stl_mesh_creator.h"
#include "stl_io_options.h"
#include "../gmio_core/endian.h" #include "../gmio_core/endian.h"
#include "../gmio_core/transfer.h"
struct gmio_rwargs;
struct gmio_stream;
struct gmio_stl_mesh;
struct gmio_stl_mesh_creator;
struct gmio_stl_write_options;
struct gmio_stlb_header;
enum gmio_endianness;
enum gmio_stl_format;
GMIO_C_LINKAGE_BEGIN GMIO_C_LINKAGE_BEGIN
/*! Reads STL mesh from file, format is automatically guessed /*! Reads STL mesh from file, format is automatically guessed
*
* Internally, it uses:
* \li the builtin stream wrapper around FILE* (see gmio_stream_stdio())
* \li the global default function to construct a temporary gmio_memblock
* object (see gmio_memblock_default())
* *
* \return Error code (see error.h and stl_error.h) * \return Error code (see error.h and stl_error.h)
*/ */
@ -49,12 +50,13 @@ int gmio_stl_read_file(
* name specifications of the running environment */ * name specifications of the running environment */
const char* filepath, const char* filepath,
/*! Defines the callbacks for the mesh creation */ /*! Common objects needed for the read operation
gmio_stl_mesh_creator_t* creator, * gmio_read_args::stream is internally initialized with the
* builtin stream wrapper around \c FILE* (see gmio_stream_stdio()) */
struct gmio_rwargs* args,
/*! The interface object by which the read operation can be controlled. /*! Defines the callbacks for the mesh creation */
* Optional, can be safely set to NULL */ struct gmio_stl_mesh_creator* creator
gmio_task_iface_t* task_iface
); );
/*! Reads STL mesh from stream, format is automatically guessed /*! Reads STL mesh from stream, format is automatically guessed
@ -63,11 +65,11 @@ int gmio_stl_read_file(
*/ */
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
int gmio_stl_read( int gmio_stl_read(
/*! Defines needed objects for the read operation */ /*! Common objects needed for the read operation */
gmio_transfer_t* trsf, struct gmio_rwargs* args,
/*! Defines the callbacks for the mesh creation */ /*! Defines the callbacks for the mesh creation */
gmio_stl_mesh_creator_t* creator struct gmio_stl_mesh_creator* creator
); );
/*! Writes STL mesh to file /*! Writes STL mesh to file
@ -81,24 +83,25 @@ int gmio_stl_read(
*/ */
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
int gmio_stl_write_file( int gmio_stl_write_file(
/*! STL format of the output file */
gmio_stl_format_t format,
/*! Path to the STL file. A stream is opened with fopen() so the string /*! Path to the STL file. A stream is opened with fopen() so the string
* shall follow the file name specifications of the running * shall follow the file name specifications of the running
* environment */ * environment */
const char* filepath, const char* filepath,
/*! Defines the mesh to output */ /*! Common objects needed for the write operation
const gmio_stl_mesh_t* mesh, * gmio_read_args::stream is internally initialized with the
* builtin stream wrapper around \c FILE* (see gmio_stream_stdio()) */
struct gmio_rwargs* args,
/*! The interface object by which the write operation can be controlled. /*! Defines the mesh to output */
* Optional, can be safely set to NULL */ const struct gmio_stl_mesh* mesh,
gmio_task_iface_t* task_iface,
/*! STL format of the output file */
enum gmio_stl_format format,
/*! Options for the write operation, can be safely set to NULL to use /*! Options for the write operation, can be safely set to NULL to use
* default values */ * default values */
const gmio_stl_write_options_t* options const struct gmio_stl_write_options* options
); );
/*! Writes STL mesh to stream /*! Writes STL mesh to stream
@ -107,18 +110,18 @@ int gmio_stl_write_file(
*/ */
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
int gmio_stl_write( int gmio_stl_write(
/*! STL format of the output */ /*! Common objects needed for the write operation */
gmio_stl_format_t format, struct gmio_rwargs* args,
/*! Defines needed objects for the write operation */
gmio_transfer_t* trsf,
/*! Defines the mesh to output */ /*! Defines the mesh to output */
const gmio_stl_mesh_t* mesh, const struct gmio_stl_mesh* mesh,
/*! STL format of the output */
enum gmio_stl_format format,
/*! Options for the write operation, can be safely set to NULL to use /*! Options for the write operation, can be safely set to NULL to use
* default values */ * default values */
const gmio_stl_write_options_t* options const struct gmio_stl_write_options* options
); );
/*! Reads geometry from STL ascii stream /*! Reads geometry from STL ascii stream
@ -134,11 +137,11 @@ int gmio_stl_write(
*/ */
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
int gmio_stla_read( int gmio_stla_read(
/*! Defines needed objects for the read operation */ /*! Common objects needed for the read operation */
gmio_transfer_t* trsf, struct gmio_rwargs* args,
/*! Defines the callbacks for the mesh creation */ /*! Defines the callbacks for the mesh creation */
gmio_stl_mesh_creator_t* creator struct gmio_stl_mesh_creator* creator
); );
/*! Size(in bytes) of the minimum contents possible with the STL binary format */ /*! Size(in bytes) of the minimum contents possible with the STL binary format */
@ -152,14 +155,14 @@ enum { GMIO_STLB_MIN_CONTENTS_SIZE = 284 };
*/ */
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
int gmio_stlb_read( int gmio_stlb_read(
/*! Defines needed objects for the read operation */ /*! Common objects needed for the read operation */
gmio_transfer_t* trsf, struct gmio_rwargs* args,
/*! Defines the callbacks for the mesh creation */ /*! Defines the callbacks for the mesh creation */
gmio_stl_mesh_creator_t* creator, struct gmio_stl_mesh_creator* creator,
/*! Byte order of the input STL binary data */ /*! Byte order of the input STL binary data */
gmio_endianness_t byte_order enum gmio_endianness byte_order
); );
/*! Writes STL binary header data to stream /*! Writes STL binary header data to stream
@ -172,14 +175,14 @@ int gmio_stlb_read(
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
int gmio_stlb_write_header( int gmio_stlb_write_header(
/*! Output stream where is written the header data */ /*! Output stream where is written the header data */
gmio_stream_t* stream, struct gmio_stream* stream,
/*! Byte order of the output STL data */ /*! Byte order of the output STL data */
gmio_endianness_t byte_order, enum gmio_endianness byte_order,
/*! 80-bytes array of header data, can be safely set to NULL to generate /*! 80-bytes array of header data, can be safely set to NULL to generate
* an array of zeroes */ * an array of zeroes */
const gmio_stlb_header_t* header, const struct gmio_stlb_header* header,
/*! Total count of facets (triangles) in the mesh to be written */ /*! Total count of facets (triangles) in the mesh to be written */
uint32_t facet_count uint32_t facet_count

5
src/gmio_stl/stl_io_options.h
View File

@ -59,7 +59,7 @@ struct gmio_stl_write_options
* Defaulted to \c GMIO_FLOAT_TEXT_FORMAT_DECIMAL_LOWERCASE when calling * Defaulted to \c GMIO_FLOAT_TEXT_FORMAT_DECIMAL_LOWERCASE when calling
* gmio_stl_write() with \c options==NULL * gmio_stl_write() with \c options==NULL
*/ */
gmio_float_text_format_t stla_float32_format; enum gmio_float_text_format stla_float32_format;
/*! The maximum number of significant digits when writting float values /*! The maximum number of significant digits when writting float values
* *
@ -78,9 +78,8 @@ struct gmio_stl_write_options
* \li calling gmio_stl_write() with <tt>options == NULL</tt> * \li calling gmio_stl_write() with <tt>options == NULL</tt>
* \li OR <tt>stlb_header_data == NULL</tt> * \li OR <tt>stlb_header_data == NULL</tt>
*/ */
const gmio_stlb_header_t* stlb_header_data; const struct gmio_stlb_header* stlb_header_data;
}; };
typedef struct gmio_stl_write_options gmio_stl_write_options_t;
#endif /* GMIO_STL_IO_OPTIONS_H */ #endif /* GMIO_STL_IO_OPTIONS_H */
/*! @} */ /*! @} */

4
src/gmio_stl/stl_mesh.h
View File

@ -39,10 +39,8 @@ struct gmio_stl_mesh
/*! Pointer on a function that stores the mesh triangle of index \p tri_id /*! Pointer on a function that stores the mesh triangle of index \p tri_id
* into \p triangle */ * into \p triangle */
void (*func_get_triangle)( void (*func_get_triangle)(
const void* cookie, uint32_t tri_id, gmio_stl_triangle_t* triangle); const void* cookie, uint32_t tri_id, struct gmio_stl_triangle* triangle);
}; };
typedef struct gmio_stl_mesh gmio_stl_mesh_t;
#endif /* GMIO_STL_MESH_H */ #endif /* GMIO_STL_MESH_H */
/*! @} */ /*! @} */

12
src/gmio_stl/stl_mesh_creator.h
View File

@ -59,17 +59,21 @@ struct gmio_stl_mesh_creator
* The argument \p header contains the header data(80 bytes) * The argument \p header contains the header data(80 bytes)
*/ */
void (*func_binary_begin_solid)( void (*func_binary_begin_solid)(
void* cookie, uint32_t tri_count, const gmio_stlb_header_t* header); void* cookie,
uint32_t tri_count,
const struct gmio_stlb_header* header);
/*! Pointer on a function that adds a triangle to the user mesh /*! Pointer on a function that adds a triangle to the user mesh
* *
* The argument \p triangle is the triangle to be added, note that * The argument \p triangle is the triangle to be added, note that
* gmio_stl_triangle_t::attribute_byte_count is meaningless for STL ascii. * struct gmio_stl_triangle::attribute_byte_count is meaningless for STL ascii.
* *
* The argument \p tri_id is the index of the mesh triangle * The argument \p tri_id is the index of the mesh triangle
*/ */
void (*func_add_triangle)( void (*func_add_triangle)(
void* cookie, uint32_t tri_id, const gmio_stl_triangle_t* triangle); void* cookie,
uint32_t tri_id,
const struct gmio_stl_triangle* triangle);
/*! Pointer on a function that finalizes creation of the user mesh /*! Pointer on a function that finalizes creation of the user mesh
* *
@ -79,7 +83,5 @@ struct gmio_stl_mesh_creator
void (*func_end_solid)(void* cookie); void (*func_end_solid)(void* cookie);
}; };
typedef struct gmio_stl_mesh_creator gmio_stl_mesh_creator_t;
#endif /* GMIO_STL_MESH_CREATOR_H */ #endif /* GMIO_STL_MESH_CREATOR_H */
/*! @} */ /*! @} */

18
src/gmio_stl/stl_triangle.h
View File

@ -34,30 +34,26 @@ struct gmio_stl_coords
gmio_float32_t z; gmio_float32_t z;
}; };
typedef struct gmio_stl_coords gmio_stl_coords_t;
/*! STL mesh triangle defined three geometric vertices and an /*! STL mesh triangle defined three geometric vertices and an
* orientation(normal) */ * orientation(normal) */
struct gmio_stl_triangle struct gmio_stl_triangle
{ {
gmio_stl_coords_t normal; /*!< Normal vector */ struct gmio_stl_coords normal; /*!< Normal vector */
gmio_stl_coords_t v1; /*!< Vertex 1 */ struct gmio_stl_coords v1; /*!< Vertex 1 */
gmio_stl_coords_t v2; /*!< Vertex 2 */ struct gmio_stl_coords v2; /*!< Vertex 2 */
gmio_stl_coords_t v3; /*!< Vertex 3 */ struct gmio_stl_coords v3; /*!< Vertex 3 */
uint16_t attribute_byte_count; /*!< Useful only for STL binary format */ uint16_t attribute_byte_count; /*!< Useful only for STL binary format */
}; };
typedef struct gmio_stl_triangle gmio_stl_triangle_t;
/*! Constants for STL triangles */ /*! Constants for STL triangles */
enum { enum {
/*! Compact size of a gmio_stl_coords_t object */ /*! Compact size of a struct gmio_stl_coords object */
GMIO_STL_COORDS_RAWSIZE = (3 * sizeof(gmio_float32_t)), GMIO_STL_COORDS_RAWSIZE = (3 * sizeof(gmio_float32_t)),
/*! Compact size of a gmio_stl_triangle_t object for STL ascii format */ /*! Compact size of a struct gmio_stl_triangle object for STL ascii format */
GMIO_STLA_TRIANGLE_RAWSIZE = (4 * GMIO_STL_COORDS_RAWSIZE), GMIO_STLA_TRIANGLE_RAWSIZE = (4 * GMIO_STL_COORDS_RAWSIZE),
/*! Compact size of a gmio_stl_triangle_t object for STL binary format */ /*! Compact size of a struct gmio_stl_triangle object for STL binary format */
GMIO_STLB_TRIANGLE_RAWSIZE = (GMIO_STLA_TRIANGLE_RAWSIZE + sizeof(uint16_t)) GMIO_STLB_TRIANGLE_RAWSIZE = (GMIO_STLA_TRIANGLE_RAWSIZE + sizeof(uint16_t))
}; };

164
src/gmio_stl/stla_read.c
View File

@ -21,8 +21,9 @@
#include "internal/stl_rw_common.h" #include "internal/stl_rw_common.h"
#include "../gmio_core/error.h" #include "../gmio_core/error.h"
#include "../gmio_core/rwargs.h"
#include "../gmio_core/internal/helper_rwargs.h"
#include "../gmio_core/internal/helper_stream.h" #include "../gmio_core/internal/helper_stream.h"
#include "../gmio_core/internal/helper_transfer.h"
#include "../gmio_core/internal/min_max.h" #include "../gmio_core/internal/min_max.h"
#include "../gmio_core/internal/stringstream.h" #include "../gmio_core/internal/stringstream.h"
#include "../gmio_core/internal/string_utils.h" #include "../gmio_core/internal/string_utils.h"
@ -80,7 +81,7 @@
*/ */
/* gmio_stla_token */ /* gmio_stla_token */
typedef enum enum gmio_stla_token
{ {
null_token = 0, null_token = 0,
ENDFACET_token, ENDFACET_token,
@ -96,76 +97,79 @@ typedef enum
FLOAT_token = ID_token, FLOAT_token = ID_token,
empty_token, empty_token,
unknown_token unknown_token
} gmio_stla_token_t; };
/* gmio_stringstream_stla_cookie_t */ /* struct gmio_stringstream_stla_cookie */
typedef struct struct gmio_stringstream_stla_cookie
{ {
/* Copy of gmio_stla_read() corresponding argument */ /* Copy of gmio_stla_read() corresponding argument */
gmio_transfer_t* transfer; struct gmio_rwargs* rwargs;
/* Cache for gmio_stream_size(&transfer->stream) */ /* Cache for gmio_stream_size(&transfer->stream) */
gmio_streamsize_t stream_size; gmio_streamsize_t stream_size;
/* Offset (in bytes) from beginning of stream : current position */ /* Offset (in bytes) from beginning of stream : current position */
gmio_streamoffset_t stream_offset; gmio_streamoffset_t stream_offset;
/* Cache for gmio_transfer::func_is_stop_requested() */ /* Cache for gmio_transfer::func_is_stop_requested() */
gmio_bool_t is_stop_requested; gmio_bool_t is_stop_requested;
} gmio_stringstream_stla_cookie_t; };
/* gmio_stla_parse_data */ /* gmio_stla_parse_data */
typedef struct struct gmio_stla_parse_data
{ {
gmio_stla_token_t token; enum gmio_stla_token token;
gmio_bool_t error; gmio_bool_t error;
gmio_stringstream_t stream_iterator; struct gmio_stringstream stream_iterator;
gmio_stringstream_stla_cookie_t stream_iterator_cookie; struct gmio_stringstream_stla_cookie stream_iterator_cookie;
gmio_string_t string_buffer; struct gmio_string string_buffer;
gmio_stl_mesh_creator_t* creator; struct gmio_stl_mesh_creator* creator;
} gmio_stla_parse_data_t; };
/* Fixed maximum length of any gmio_string in this source file */ /* Fixed maximum length of any gmio_string in this source file */
enum { GMIO_STLA_READ_STRING_MAX_LEN = 1024 }; enum { GMIO_STLA_READ_STRING_MAX_LEN = 1024 };
/* Callback used for gmio_string_stream_fwd_iterator::func_stream_read_hook */ /* Callback used for gmio_string_stream_fwd_iterator::func_stream_read_hook */
static void gmio_stringstream_stla_read_hook( static void gmio_stringstream_stla_read_hook(
void* cookie, const gmio_string_t* strbuff) void* cookie, const struct gmio_string* strbuff)
{ {
gmio_stringstream_stla_cookie_t* tcookie = struct gmio_stringstream_stla_cookie* tcookie =
(gmio_stringstream_stla_cookie_t*)(cookie); (struct gmio_stringstream_stla_cookie*)(cookie);
const gmio_transfer_t* trsf = tcookie != NULL ? tcookie->transfer : NULL; const struct gmio_rwargs* rwargs =
tcookie != NULL ? tcookie->rwargs : NULL;
if (tcookie != NULL) { if (tcookie != NULL) {
tcookie->stream_offset += strbuff->len; tcookie->stream_offset += strbuff->len;
tcookie->is_stop_requested = gmio_transfer_is_stop_requested(trsf); tcookie->is_stop_requested = gmio_rwargs_is_stop_requested(rwargs);
gmio_transfer_handle_progress( gmio_rwargs_handle_progress(
trsf, tcookie->stream_offset, tcookie->stream_size); rwargs, tcookie->stream_offset, tcookie->stream_size);
} }
} }
/* Root function, parses a whole solid */ /* Root function, parses a whole solid */
static void parse_solid(gmio_stla_parse_data_t* data); static void parse_solid(struct gmio_stla_parse_data* data);
int gmio_stla_read(gmio_transfer_t* trsf, gmio_stl_mesh_creator_t* creator) int gmio_stla_read(
struct gmio_rwargs* args,
struct gmio_stl_mesh_creator* creator)
{ {
char fixed_buffer[GMIO_STLA_READ_STRING_MAX_LEN]; char fixed_buffer[GMIO_STLA_READ_STRING_MAX_LEN];
gmio_stla_parse_data_t parse_data; struct gmio_stla_parse_data parse_data;
{ /* Check validity of input parameters */ { /* Check validity of input parameters */
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
if (!gmio_check_transfer(&error, trsf)) if (!gmio_check_rwargs(&error, args))
return error; return error;
} }
parse_data.token = unknown_token; parse_data.token = unknown_token;
parse_data.error = GMIO_FALSE; parse_data.error = GMIO_FALSE;
parse_data.stream_iterator_cookie.transfer = trsf; parse_data.stream_iterator_cookie.rwargs = args;
parse_data.stream_iterator_cookie.stream_offset = 0; parse_data.stream_iterator_cookie.stream_offset = 0;
parse_data.stream_iterator_cookie.stream_size = parse_data.stream_iterator_cookie.stream_size =
gmio_stream_size(&trsf->stream); gmio_stream_size(&args->stream);
parse_data.stream_iterator_cookie.is_stop_requested = GMIO_FALSE; parse_data.stream_iterator_cookie.is_stop_requested = GMIO_FALSE;
parse_data.stream_iterator.stream = trsf->stream; parse_data.stream_iterator.stream = args->stream;
parse_data.stream_iterator.strbuff.ptr = trsf->memblock.ptr; parse_data.stream_iterator.strbuff.ptr = args->memblock.ptr;
parse_data.stream_iterator.strbuff.max_len = trsf->memblock.size; parse_data.stream_iterator.strbuff.max_len = args->memblock.size;
parse_data.stream_iterator.cookie = &parse_data.stream_iterator_cookie; parse_data.stream_iterator.cookie = &parse_data.stream_iterator_cookie;
parse_data.stream_iterator.func_stream_read_hook = parse_data.stream_iterator.func_stream_read_hook =
gmio_stringstream_stla_read_hook; gmio_stringstream_stla_read_hook;
@ -207,7 +211,7 @@ static const char stla_tokstr_OUTER[] = "outer";
static const char stla_tokstr_SOLID[] = "solid"; static const char stla_tokstr_SOLID[] = "solid";
static const char stla_tokstr_VERTEX[] = "vertex"; static const char stla_tokstr_VERTEX[] = "vertex";
static const gmio_const_string_t stla_tokcstr[] = { static const struct gmio_const_string stla_tokcstr[] = {
{0}, /* null_token */ {0}, /* null_token */
GMIO_CONST_STRING_FROM_ARRAY(stla_tokstr_ENDFACET), GMIO_CONST_STRING_FROM_ARRAY(stla_tokstr_ENDFACET),
GMIO_CONST_STRING_FROM_ARRAY(stla_tokstr_ENDLOOP), GMIO_CONST_STRING_FROM_ARRAY(stla_tokstr_ENDLOOP),
@ -224,20 +228,20 @@ static const gmio_const_string_t stla_tokcstr[] = {
}; };
/* Returns the string corresponding to token */ /* Returns the string corresponding to token */
GMIO_INLINE const char* stla_token_to_string(gmio_stla_token_t token); GMIO_INLINE const char* stla_token_to_string(enum gmio_stla_token token);
/* Qualifies input string as a token */ /* Qualifies input string as a token */
static gmio_stla_token_t stla_find_token(const char* word, size_t word_len); static enum gmio_stla_token stla_find_token(const char* word, size_t word_len);
/* Same as parsing_find_token() but takes a gmio_string_t object as input */ /* Same as parsing_find_token() but takes a struct gmio_string object as input */
GMIO_INLINE gmio_stla_token_t stla_find_token_from_string(const gmio_string_t* str); GMIO_INLINE enum gmio_stla_token stla_find_token_from_string(const struct gmio_string* str);
/* Returns true if \p token matches one of the candidate tokens /* Returns true if \p token matches one of the candidate tokens
* *
* Array \p candidates must end with a "null_token" item * Array \p candidates must end with a "null_token" item
*/ */
GMIO_INLINE gmio_bool_t stla_token_match_candidate( GMIO_INLINE gmio_bool_t stla_token_match_candidate(
gmio_stla_token_t token, const gmio_stla_token_t* candidates); enum gmio_stla_token token, const enum gmio_stla_token* candidates);
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
* Error message functions * Error message functions
@ -245,11 +249,11 @@ GMIO_INLINE gmio_bool_t stla_token_match_candidate(
/* Makes the parsing fails and print error message */ /* Makes the parsing fails and print error message */
static void stla_error_msg( static void stla_error_msg(
gmio_stla_parse_data_t* data, const char* msg); struct gmio_stla_parse_data* data, const char* msg);
/* Makes the parsing fails with message showing token mismatch */ /* Makes the parsing fails with message showing token mismatch */
static void stla_error_token_expected( static void stla_error_token_expected(
gmio_stla_parse_data_t* data, gmio_stla_token_t token); struct gmio_stla_parse_data* data, enum gmio_stla_token token);
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
* Parsing helper functions * Parsing helper functions
@ -258,10 +262,10 @@ static void stla_error_token_expected(
/* Eats next token string and checks it against an expected token /* Eats next token string and checks it against an expected token
* *
* This procedure copies the token string into internal * This procedure copies the token string into internal
* gmio_stla_parse_data_t::string_buffer * struct gmio_stla_parse_data::string_buffer
*/ */
static int stla_eat_next_token( static int stla_eat_next_token(
gmio_stla_parse_data_t* data, gmio_stla_token_t expected_token); struct gmio_stla_parse_data* data, enum gmio_stla_token expected_token);
/* Eats next token string and checks it against an expected token /* Eats next token string and checks it against an expected token
* *
@ -271,18 +275,18 @@ static int stla_eat_next_token(
* token string against expected * token string against expected
*/ */
static int stla_eat_next_token_inplace( static int stla_eat_next_token_inplace(
gmio_stla_parse_data_t* data, gmio_stla_token_t expected_token); struct gmio_stla_parse_data* data, enum gmio_stla_token expected_token);
/* Eats contents until some expected "end" token is matched /* Eats contents until some expected "end" token is matched
* *
* Array \p end_tokens must end with a "null_token" item * Array \p end_tokens must end with a "null_token" item
*/ */
static int stla_eat_until_token( static int stla_eat_until_token(
gmio_stla_parse_data_t* data, const gmio_stla_token_t* end_tokens); struct gmio_stla_parse_data* data, const enum gmio_stla_token* end_tokens);
/* Returns true if parsing can continue */ /* Returns true if parsing can continue */
GMIO_INLINE gmio_bool_t stla_parsing_can_continue( GMIO_INLINE gmio_bool_t stla_parsing_can_continue(
const gmio_stla_parse_data_t* data); const struct gmio_stla_parse_data* data);
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
* STLA parsing functions * STLA parsing functions
@ -292,30 +296,30 @@ GMIO_INLINE gmio_bool_t stla_parsing_can_continue(
enum { GMIO_STLA_PARSE_ERROR = 1 }; enum { GMIO_STLA_PARSE_ERROR = 1 };
/* Parses the (optional) solid name that appears after token "solid" */ /* Parses the (optional) solid name that appears after token "solid" */
static int parse_solidname_beg(gmio_stla_parse_data_t* data); static int parse_solidname_beg(struct gmio_stla_parse_data* data);
/* Parses the (optional) solid name that appears after token "endsolid" /* Parses the (optional) solid name that appears after token "endsolid"
* *
* It should be the same name as the one parsed with parse_solidname_beg() * It should be the same name as the one parsed with parse_solidname_beg()
*/ */
static int parse_solidname_end(gmio_stla_parse_data_t* data); static int parse_solidname_end(struct gmio_stla_parse_data* data);
/* Parses "solid <name>" */ /* Parses "solid <name>" */
static int parse_beginsolid(gmio_stla_parse_data_t* data); static int parse_beginsolid(struct gmio_stla_parse_data* data);
/* Parses "endsolid <name>" */ /* Parses "endsolid <name>" */
static gmio_bool_t parse_endsolid(gmio_stla_parse_data_t* data); static gmio_bool_t parse_endsolid(struct gmio_stla_parse_data* data);
/* Parses STL (x,y,z) coords, each coord being separated by whitespaces */ /* Parses STL (x,y,z) coords, each coord being separated by whitespaces */
GMIO_INLINE int parse_xyz_coords( GMIO_INLINE int parse_xyz_coords(
gmio_stla_parse_data_t* data, gmio_stl_coords_t* coords); struct gmio_stla_parse_data* data, struct gmio_stl_coords* coords);
/* Parses a STL facet, ie. facet ... endfacet */ /* Parses a STL facet, ie. facet ... endfacet */
static int parse_facet( static int parse_facet(
gmio_stla_parse_data_t* data, gmio_stl_triangle_t* facet); struct gmio_stla_parse_data* data, struct gmio_stl_triangle* facet);
/* Parses a list of facets */ /* Parses a list of facets */
static void parse_facets(gmio_stla_parse_data_t* data); static void parse_facets(struct gmio_stla_parse_data* data);
/* __________________________________________________________________________ /* __________________________________________________________________________
* *
@ -326,12 +330,12 @@ static void parse_facets(gmio_stla_parse_data_t* data);
* STLA token utils * STLA token utils
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
const char* stla_token_to_string(gmio_stla_token_t token) const char* stla_token_to_string(enum gmio_stla_token token)
{ {
return stla_tokcstr[token].ptr; return stla_tokcstr[token].ptr;
} }
gmio_stla_token_t stla_find_token(const char* word, size_t word_len) enum gmio_stla_token stla_find_token(const char* word, size_t word_len)
{ {
/* Get rid of ill-formed token */ /* Get rid of ill-formed token */
if (word_len == 0) if (word_len == 0)
@ -401,13 +405,13 @@ gmio_stla_token_t stla_find_token(const char* word, size_t word_len)
return ID_token; return ID_token;
} }
gmio_stla_token_t stla_find_token_from_string(const gmio_string_t* str) enum gmio_stla_token stla_find_token_from_string(const struct gmio_string* str)
{ {
return stla_find_token(str->ptr, str->len); return stla_find_token(str->ptr, str->len);
} }
gmio_bool_t stla_token_match_candidate( gmio_bool_t stla_token_match_candidate(
gmio_stla_token_t token, const gmio_stla_token_t* candidates) enum gmio_stla_token token, const enum gmio_stla_token* candidates)
{ {
gmio_bool_t found = GMIO_FALSE; gmio_bool_t found = GMIO_FALSE;
size_t i; size_t i;
@ -420,7 +424,7 @@ gmio_bool_t stla_token_match_candidate(
* Error message functions * Error message functions
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
void stla_error_msg(gmio_stla_parse_data_t* data, const char* msg) void stla_error_msg(struct gmio_stla_parse_data* data, const char* msg)
{ {
fprintf(stderr, fprintf(stderr,
"\n" "\n"
@ -435,7 +439,7 @@ void stla_error_msg(gmio_stla_parse_data_t* data, const char* msg)
} }
void stla_error_token_expected( void stla_error_token_expected(
gmio_stla_parse_data_t* data, gmio_stla_token_t token) struct gmio_stla_parse_data* data, enum gmio_stla_token token)
{ {
char msg[256] = {0}; char msg[256] = {0};
sprintf(msg, sprintf(msg,
@ -450,11 +454,11 @@ void stla_error_token_expected(
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
int stla_eat_next_token( int stla_eat_next_token(
gmio_stla_parse_data_t* data, struct gmio_stla_parse_data* data,
gmio_stla_token_t expected_token) enum gmio_stla_token expected_token)
{ {
gmio_string_t* strbuff = &data->string_buffer; struct gmio_string* strbuff = &data->string_buffer;
gmio_eat_word_error_t eat_error; enum gmio_eat_word_error eat_error;
strbuff->len = 0; strbuff->len = 0;
eat_error = gmio_stringstream_eat_word(&data->stream_iterator, strbuff); eat_error = gmio_stringstream_eat_word(&data->stream_iterator, strbuff);
@ -477,10 +481,10 @@ int stla_eat_next_token(
} }
int stla_eat_next_token_inplace( int stla_eat_next_token_inplace(
gmio_stla_parse_data_t* data, struct gmio_stla_parse_data* data,
gmio_stla_token_t expected_token) enum gmio_stla_token expected_token)
{ {
gmio_stringstream_t* it = &data->stream_iterator; struct gmio_stringstream* it = &data->stream_iterator;
const char* stream_char = NULL; const char* stream_char = NULL;
const char* expected_token_str = stla_token_to_string(expected_token); const char* expected_token_str = stla_token_to_string(expected_token);
gmio_bool_t error = GMIO_FALSE; gmio_bool_t error = GMIO_FALSE;
@ -512,16 +516,16 @@ int stla_eat_next_token_inplace(
} }
int stla_eat_until_token( int stla_eat_until_token(
gmio_stla_parse_data_t* data, const gmio_stla_token_t* end_tokens) struct gmio_stla_parse_data* data, const enum gmio_stla_token* end_tokens)
{ {
if (!stla_token_match_candidate(data->token, end_tokens)) { if (!stla_token_match_candidate(data->token, end_tokens)) {
gmio_stringstream_t* stream_it = &data->stream_iterator; struct gmio_stringstream* stream_it = &data->stream_iterator;
gmio_string_t* strbuff = &data->string_buffer; struct gmio_string* strbuff = &data->string_buffer;
gmio_bool_t end_token_found = GMIO_FALSE; gmio_bool_t end_token_found = GMIO_FALSE;
do { do {
const size_t previous_buff_len = strbuff->len; const size_t previous_buff_len = strbuff->len;
gmio_eat_word_error_t eat_word_err = 0; enum gmio_eat_word_error eat_word_err = 0;
const char* next_word = NULL; /* Pointer on next word string */ const char* next_word = NULL; /* Pointer on next word string */
size_t next_word_len = 0; /* Length of next word string */ size_t next_word_len = 0; /* Length of next word string */
@ -554,7 +558,7 @@ int stla_eat_until_token(
return 0; return 0;
} }
gmio_bool_t stla_parsing_can_continue(const gmio_stla_parse_data_t* data) gmio_bool_t stla_parsing_can_continue(const struct gmio_stla_parse_data* data)
{ {
return !data->error && !data->stream_iterator_cookie.is_stop_requested; return !data->error && !data->stream_iterator_cookie.is_stop_requested;
} }
@ -563,7 +567,7 @@ gmio_bool_t stla_parsing_can_continue(const gmio_stla_parse_data_t* data)
* STLA parsing functions * STLA parsing functions
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
int parse_solidname_beg(gmio_stla_parse_data_t* data) int parse_solidname_beg(struct gmio_stla_parse_data* data)
{ {
if (stla_eat_next_token(data, unknown_token) == 0) { if (stla_eat_next_token(data, unknown_token) == 0) {
data->token = stla_find_token_from_string(&data->string_buffer); data->token = stla_find_token_from_string(&data->string_buffer);
@ -573,7 +577,7 @@ int parse_solidname_beg(gmio_stla_parse_data_t* data)
} }
else { else {
/* Solid name can be made of multiple words */ /* Solid name can be made of multiple words */
const gmio_stla_token_t end_tokens[] = { const enum gmio_stla_token end_tokens[] = {
FACET_token, ENDSOLID_token, null_token }; FACET_token, ENDSOLID_token, null_token };
return stla_eat_until_token(data, end_tokens); return stla_eat_until_token(data, end_tokens);
} }
@ -581,14 +585,14 @@ int parse_solidname_beg(gmio_stla_parse_data_t* data)
return GMIO_STLA_PARSE_ERROR; return GMIO_STLA_PARSE_ERROR;
} }
int parse_solidname_end(gmio_stla_parse_data_t* data) int parse_solidname_end(struct gmio_stla_parse_data* data)
{ {
GMIO_UNUSED(data); GMIO_UNUSED(data);
/* TODO: parse according to retrieved solid name */ /* TODO: parse according to retrieved solid name */
return 0; return 0;
} }
int parse_beginsolid(gmio_stla_parse_data_t* data) int parse_beginsolid(struct gmio_stla_parse_data* data)
{ {
if (stla_eat_next_token(data, SOLID_token) == 0) { if (stla_eat_next_token(data, SOLID_token) == 0) {
if (parse_solidname_beg(data) == 0) { if (parse_solidname_beg(data) == 0) {
@ -602,7 +606,7 @@ int parse_beginsolid(gmio_stla_parse_data_t* data)
return GMIO_STLA_PARSE_ERROR; return GMIO_STLA_PARSE_ERROR;
} }
gmio_bool_t parse_endsolid(gmio_stla_parse_data_t* data) gmio_bool_t parse_endsolid(struct gmio_stla_parse_data* data)
{ {
if (data->token == ENDSOLID_token if (data->token == ENDSOLID_token
|| stla_eat_next_token(data, ENDSOLID_token) == 0) || stla_eat_next_token(data, ENDSOLID_token) == 0)
@ -626,10 +630,10 @@ GMIO_INLINE int is_float_char(const char* str)
|| c == '+'; || c == '+';
} }
int parse_xyz_coords(gmio_stla_parse_data_t* data, gmio_stl_coords_t* coords) int parse_xyz_coords(struct gmio_stla_parse_data* data, struct gmio_stl_coords* coords)
{ {
int errc = 0; int errc = 0;
gmio_stringstream_t* it = &data->stream_iterator; struct gmio_stringstream* it = &data->stream_iterator;
const char* strbuff = NULL; const char* strbuff = NULL;
strbuff = gmio_stringstream_skip_ascii_spaces(it); strbuff = gmio_stringstream_skip_ascii_spaces(it);
@ -650,7 +654,7 @@ int parse_xyz_coords(gmio_stla_parse_data_t* data, gmio_stl_coords_t* coords)
return errc; return errc;
} }
int parse_facet(gmio_stla_parse_data_t* data, gmio_stl_triangle_t* facet) int parse_facet(struct gmio_stla_parse_data* data, struct gmio_stl_triangle* facet)
{ {
int errc = 0; int errc = 0;
if (data->token != FACET_token) if (data->token != FACET_token)
@ -675,14 +679,14 @@ int parse_facet(gmio_stla_parse_data_t* data, gmio_stl_triangle_t* facet)
return errc; return errc;
} }
void parse_facets(gmio_stla_parse_data_t* data) void parse_facets(struct gmio_stla_parse_data* data)
{ {
const gmio_stl_mesh_creator_func_add_triangle_t func_add_triangle = const gmio_stl_mesh_creator_func_add_triangle_t func_add_triangle =
data->creator->func_add_triangle; data->creator->func_add_triangle;
void* creator_cookie = data->creator->cookie; void* creator_cookie = data->creator->cookie;
gmio_string_t* strbuff = &data->string_buffer; struct gmio_string* strbuff = &data->string_buffer;
uint32_t i_facet = 0; uint32_t i_facet = 0;
gmio_stl_triangle_t facet; struct gmio_stl_triangle facet;
facet.attribute_byte_count = 0; facet.attribute_byte_count = 0;
while (data->token == FACET_token && stla_parsing_can_continue(data)) { while (data->token == FACET_token && stla_parsing_can_continue(data)) {
@ -702,7 +706,7 @@ void parse_facets(gmio_stla_parse_data_t* data)
} }
} }
void parse_solid(gmio_stla_parse_data_t* data) void parse_solid(struct gmio_stla_parse_data* data)
{ {
parse_beginsolid(data); parse_beginsolid(data);
parse_facets(data); parse_facets(data);

135
src/gmio_stl/stla_stats.c
View File

@ -16,31 +16,142 @@
#include "stla_stats.h" #include "stla_stats.h"
#include "../gmio_core/error.h" #include "../gmio_core/error.h"
#include "../gmio_core/internal/string.h"
#include "../gmio_core/internal/helper_rwargs.h"
#include "../gmio_core/internal/helper_stream.h" #include "../gmio_core/internal/helper_stream.h"
#include "../gmio_core/internal/helper_transfer.h" #include "../gmio_core/internal/min_max.h"
#include "../gmio_stl/internal/stl_rw_common.h" #include "../gmio_stl/internal/stl_rw_common.h"
gmio_stla_stats_t gmio_stla_stats_get( #include <string.h>
gmio_transfer_t* trsf, unsigned stat_flags, size_t size_limit)
GMIO_INLINE const char* find_substr(
const struct gmio_string* str, size_t str_offset, const char* substr)
{ {
gmio_stla_stats_t stats = {0}; return strstr(str->ptr + str_offset, substr);
void* mblock_ptr = trsf != NULL ? trsf->memblock.ptr : NULL; }
const size_t mblock_size = trsf != NULL ? trsf->memblock.size : 0;
static uint32_t stla_facet_count(
const struct gmio_string* strbuff, const char* end_ptr)
{
const char* substr_at = NULL;
size_t strbuff_pos = 0;
uint32_t facet_count = 0;
do {
substr_at = find_substr(strbuff, strbuff_pos, "endfacet");
if (substr_at != NULL && substr_at < end_ptr) {
++facet_count;
/* Note: strlen("endfacet") == 8 */
strbuff_pos = (substr_at - strbuff->ptr) + 8;
}
else {
substr_at = NULL;
}
} while (substr_at != NULL);
return facet_count;
}
enum {
BUFF_OVERLAP_SIZE = 14,
BUFF_OVERLAP_SIZE_DIV2 = BUFF_OVERLAP_SIZE / 2
};
struct gmio_stla_stats gmio_stla_stats_get(
struct gmio_rwargs* args, unsigned stat_flags)
{
struct gmio_stla_stats stats = {0};
struct gmio_stream* stream = args ? &args->stream : NULL;
void* mblock_ptr = args != NULL ? args->memblock.ptr : NULL;
/* Leave one byte to end the string buffer with 0 */
const size_t mblock_size = args != NULL ? args->memblock.size - 1: 0;
struct gmio_string strbuff = gmio_string(mblock_ptr, 0, mblock_size);
const gmio_bool_t flag_size =
(stat_flags & GMIO_STLA_STAT_FLAG_SIZE) != 0;
const gmio_bool_t flag_avg_facet_size =
(stat_flags & GMIO_STLA_STAT_FLAG_AVERAGE_FACET_SIZE) != 0;
const gmio_bool_t flag_facet_count =
(stat_flags & GMIO_STLA_STAT_FLAG_FACET_COUNT) != 0;
int err = GMIO_ERROR_OK; int err = GMIO_ERROR_OK;
/* Check validity of input transfer object */ /* Check validity of input transfer object */
if (!gmio_check_transfer(&err, trsf)) if (!gmio_check_rwargs(&err, args))
return stats; return stats;
/*if (stat_flags != 0) { if (stat_flags != 0) {
while (gmio_no_error(err)) { char overlap[14] = {0}; /* 14 == 2*(strlen("endfacet") - 1) */
gmio_bool_t endsolid_found = GMIO_FALSE;
while (!endsolid_found && gmio_no_error(err)) {
const char* substr_at = NULL;
const size_t read_size = const size_t read_size =
gmio_stream_read(stream, buffer_ptr, 1, buffer_size); gmio_stream_read(stream, mblock_ptr, 1, mblock_size);
const int stream_err = gmio_stream_error(trsf->stream); const int stream_err = gmio_stream_error(&args->stream);
const gmio_bool_t overlap_has_contents = overlap[0] != 0;
gmio_bool_t endsolid_in_overlap = GMIO_FALSE;
err = stream_err; err = stream_err;
strbuff.len = read_size;
strbuff.ptr[strbuff.len] = 0;
/* Copy first half of overlap buffer */
if (overlap_has_contents) {
strncpy(&overlap[BUFF_OVERLAP_SIZE_DIV2],
mblock_ptr,
GMIO_MIN(BUFF_OVERLAP_SIZE_DIV2, read_size));
}
/* Find "endsolid" in overlap */
if (overlap_has_contents) {
substr_at = strstr(overlap, "endsolid");
endsolid_found = substr_at != NULL;
endsolid_in_overlap = endsolid_found;
}
/* Find "endsolid" in memblock */
if (!endsolid_found) {
substr_at = find_substr(&strbuff, 0, "endsolid");
endsolid_found = substr_at != NULL;
}
/* Update stream size */
if (flag_size) {
/* Note: strlen("endsolid") == 8 */
if (endsolid_found) {
if (!endsolid_in_overlap)
stats.size += (substr_at - strbuff.ptr) + 8;
/* TODO : gérer le cas où "endsolid" se trouve dans overlap */
}
else {
stats.size += read_size;
}
}
/* Find "endfacet" tokens */
if (flag_facet_count && !endsolid_in_overlap) {
const char* endsolid_ptr =
endsolid_found ? substr_at : gmio_string_end(&strbuff);
/* Check in overlap */
const gmio_bool_t endfacet_in_overlap =
overlap_has_contents
&& strstr(overlap, "endfacet") != NULL;
stats.facet_count += endfacet_in_overlap ? 1 : 0;
/* Check in memblock */
stats.facet_count += stla_facet_count(&strbuff, endsolid_ptr);
}
/* Copy second half of overlap buffer */
if (!endsolid_found && read_size >= BUFF_OVERLAP_SIZE_DIV2) {
memset(&overlap, 0, sizeof(overlap));
strncpy(overlap,
&strbuff.ptr[read_size - BUFF_OVERLAP_SIZE_DIV2],
GMIO_MIN(BUFF_OVERLAP_SIZE_DIV2, read_size));
}
}
} }
}*/
return stats; return stats;
} }

10
src/gmio_stl/stla_stats.h
View File

@ -25,12 +25,12 @@
#include "stl_global.h" #include "stl_global.h"
#include "../gmio_core/transfer.h" #include "../gmio_core/rwargs.h"
#include "../gmio_core/internal/helper_stream.h" #include "../gmio_core/internal/helper_stream.h"
#include <stddef.h> #include <stddef.h>
/*! Statistics of some STL ascii solid */ /*! Statistics of some STL ascii contents(eg. file) */
struct gmio_stla_stats struct gmio_stla_stats
{ {
/*! Count of facets(triangles) */ /*! Count of facets(triangles) */
@ -43,7 +43,6 @@ struct gmio_stla_stats
/*! Size of the STL ascii contents in bytes, including the "endsolid" tag */ /*! Size of the STL ascii contents in bytes, including the "endsolid" tag */
size_t size; size_t size;
}; };
typedef struct gmio_stla_stats gmio_stla_stats_t;
/*! Flags(OR-combinations) for each STL ascii statistic */ /*! Flags(OR-combinations) for each STL ascii statistic */
enum gmio_stla_stat_flag enum gmio_stla_stat_flag
@ -53,13 +52,12 @@ enum gmio_stla_stat_flag
GMIO_STLA_STAT_FLAG_SIZE = 0x04, GMIO_STLA_STAT_FLAG_SIZE = 0x04,
GMIO_STLA_STAT_FLAG_ALL = 0xFF GMIO_STLA_STAT_FLAG_ALL = 0xFF
}; };
typedef enum gmio_stla_stat_flag gmio_stla_stat_flag_t;
GMIO_C_LINKAGE_BEGIN GMIO_C_LINKAGE_BEGIN
GMIO_LIBSTL_EXPORT GMIO_LIBSTL_EXPORT
gmio_stla_stats_t gmio_stla_stats_get( struct gmio_stla_stats gmio_stla_stats_get(
gmio_transfer_t* trsf, unsigned stat_flags, size_t size_limit); struct gmio_rwargs* args, unsigned stat_flags);
GMIO_C_LINKAGE_END GMIO_C_LINKAGE_END

1
src/gmio_stl/stlb_header.h
View File

@ -33,7 +33,6 @@ struct gmio_stlb_header
{ {
uint8_t data[GMIO_STLB_HEADER_SIZE]; uint8_t data[GMIO_STLB_HEADER_SIZE];
}; };
typedef struct gmio_stlb_header gmio_stlb_header_t;
#endif /* GMIO_STLB_HEADER_H */ #endif /* GMIO_STLB_HEADER_H */
/*! @} */ /*! @} */

44
src/gmio_stl/stlb_read.c
View File

@ -25,23 +25,23 @@
#include "../gmio_core/error.h" #include "../gmio_core/error.h"
#include "../gmio_core/internal/byte_swap.h" #include "../gmio_core/internal/byte_swap.h"
#include "../gmio_core/internal/convert.h" #include "../gmio_core/internal/convert.h"
#include "../gmio_core/internal/helper_rwargs.h"
#include "../gmio_core/internal/helper_stream.h" #include "../gmio_core/internal/helper_stream.h"
#include "../gmio_core/internal/helper_transfer.h"
#include "../gmio_core/internal/safe_cast.h" #include "../gmio_core/internal/safe_cast.h"
#include <string.h> #include <string.h>
GMIO_INLINE void read_triangle_memcpy( GMIO_INLINE void read_triangle_memcpy(
const uint8_t* buffer, gmio_stl_triangle_t* triangle) const uint8_t* buffer, struct gmio_stl_triangle* triangle)
{ {
/* *triangle = *((gmio_stl_triangle_t*)(buffer)); */ /* *triangle = *((struct gmio_stl_triangle*)(buffer)); */
memcpy(triangle, buffer, GMIO_STLB_TRIANGLE_RAWSIZE); memcpy(triangle, buffer, GMIO_STLB_TRIANGLE_RAWSIZE);
} }
static void gmio_stlb_read_facets( static void gmio_stlb_read_facets(
gmio_stl_mesh_creator_t* creator, struct gmio_stl_mesh_creator* creator,
const uint8_t* buffer, const uint8_t* buffer,
const gmio_stlb_readwrite_helper_t* rparams) const struct gmio_stlb_readwrite_helper* rparams)
{ {
const uint32_t facet_count = rparams->facet_count; const uint32_t facet_count = rparams->facet_count;
const uint32_t i_facet_offset = rparams->i_facet_offset; const uint32_t i_facet_offset = rparams->i_facet_offset;
@ -51,7 +51,7 @@ static void gmio_stlb_read_facets(
const gmio_stl_mesh_creator_func_add_triangle_t func_add_triangle = const gmio_stl_mesh_creator_func_add_triangle_t func_add_triangle =
creator != NULL ? creator->func_add_triangle : NULL; creator != NULL ? creator->func_add_triangle : NULL;
void* cookie = creator->cookie; void* cookie = creator->cookie;
gmio_stl_triangle_t triangle; struct gmio_stl_triangle triangle;
uint32_t buffer_offset = 0; uint32_t buffer_offset = 0;
uint32_t i_facet = 0; uint32_t i_facet = 0;
@ -70,25 +70,25 @@ static void gmio_stlb_read_facets(
} }
int gmio_stlb_read( int gmio_stlb_read(
gmio_transfer_t* trsf, struct gmio_rwargs* args,
gmio_stl_mesh_creator_t *creator, struct gmio_stl_mesh_creator *creator,
gmio_endianness_t byte_order) enum gmio_endianness byte_order)
{ {
/* Constants */ /* Constants */
const uint32_t max_facet_count_per_read = const uint32_t max_facet_count_per_read =
trsf != NULL ? args != NULL ?
gmio_size_to_uint32( gmio_size_to_uint32(
trsf->memblock.size / GMIO_STLB_TRIANGLE_RAWSIZE) args->memblock.size / GMIO_STLB_TRIANGLE_RAWSIZE)
: 0; : 0;
/* Variables */ /* Variables */
void* mblock_ptr = trsf != NULL ? trsf->memblock.ptr : NULL; void* mblock_ptr = args != NULL ? args->memblock.ptr : NULL;
gmio_stlb_readwrite_helper_t rparams = {0}; struct gmio_stlb_readwrite_helper rparams = {0};
gmio_stlb_header_t header; struct gmio_stlb_header header;
uint32_t total_facet_count = 0; /* Facet count, as declared in the stream */ uint32_t total_facet_count = 0; /* Facet count, as declared in the stream */
int error = GMIO_ERROR_OK; /* Helper to store function result error code */ int error = GMIO_ERROR_OK; /* Helper to store function result error code */
/* Check validity of input parameters */ /* Check validity of input parameters */
if (!gmio_stlb_check_params(&error, trsf, byte_order)) if (!gmio_stlb_check_params(&error, args, byte_order))
return error; return error;
/* Initialize rparams */ /* Initialize rparams */
@ -96,14 +96,14 @@ int gmio_stlb_read(
rparams.func_fix_endian = gmio_stl_triangle_bswap; rparams.func_fix_endian = gmio_stl_triangle_bswap;
/* Read header */ /* Read header */
if (gmio_stream_read(&trsf->stream, &header, GMIO_STLB_HEADER_SIZE, 1) if (gmio_stream_read(&args->stream, &header, GMIO_STLB_HEADER_SIZE, 1)
!= 1) != 1)
{ {
return GMIO_STL_ERROR_HEADER_WRONG_SIZE; return GMIO_STL_ERROR_HEADER_WRONG_SIZE;
} }
/* Read facet count */ /* Read facet count */
if (gmio_stream_read(&trsf->stream, mblock_ptr, sizeof(uint32_t), 1) if (gmio_stream_read(&args->stream, mblock_ptr, sizeof(uint32_t), 1)
!= 1) != 1)
{ {
return GMIO_STL_ERROR_FACET_COUNT; return GMIO_STL_ERROR_FACET_COUNT;
@ -121,17 +121,17 @@ int gmio_stlb_read(
while (gmio_no_error(error) while (gmio_no_error(error)
&& rparams.i_facet_offset < total_facet_count) && rparams.i_facet_offset < total_facet_count)
{ {
gmio_transfer_handle_progress( gmio_rwargs_handle_progress(
trsf, rparams.i_facet_offset, total_facet_count); args, rparams.i_facet_offset, total_facet_count);
rparams.facet_count = rparams.facet_count =
gmio_size_to_uint32( gmio_size_to_uint32(
gmio_stream_read( gmio_stream_read(
&trsf->stream, &args->stream,
mblock_ptr, mblock_ptr,
GMIO_STLB_TRIANGLE_RAWSIZE, GMIO_STLB_TRIANGLE_RAWSIZE,
max_facet_count_per_read)); max_facet_count_per_read));
if (gmio_stream_error(&trsf->stream) != 0) if (gmio_stream_error(&args->stream) != 0)
error = GMIO_ERROR_STREAM; error = GMIO_ERROR_STREAM;
else if (rparams.facet_count > 0) else if (rparams.facet_count > 0)
error = GMIO_ERROR_OK; error = GMIO_ERROR_OK;
@ -141,7 +141,7 @@ int gmio_stlb_read(
if (gmio_no_error(error)) { if (gmio_no_error(error)) {
gmio_stlb_read_facets(creator, mblock_ptr, &rparams); gmio_stlb_read_facets(creator, mblock_ptr, &rparams);
rparams.i_facet_offset += rparams.facet_count; rparams.i_facet_offset += rparams.facet_count;
if (gmio_transfer_is_stop_requested(trsf)) if (gmio_rwargs_is_stop_requested(args))
error = GMIO_ERROR_TRANSFER_STOPPED; error = GMIO_ERROR_TRANSFER_STOPPED;
} }
} /* end while */ } /* end while */

18
src/gmio_support/stl_occ.cpp
View File

@ -31,7 +31,7 @@ static StlMesh_Mesh* occMeshPtr(const Handle_StlMesh_Mesh& mesh)
} }
static void occmesh_add_triangle( static void occmesh_add_triangle(
void* cookie, uint32_t tri_id, const gmio_stl_triangle_t* tri) void* cookie, uint32_t tri_id, const struct gmio_stl_triangle* tri)
{ {
StlMesh_Mesh* mesh = static_cast<StlMesh_Mesh*>(cookie); StlMesh_Mesh* mesh = static_cast<StlMesh_Mesh*>(cookie);
if (tri_id == 0) if (tri_id == 0)
@ -47,10 +47,10 @@ static void occmesh_add_triangle(
} }
static void occmesh_get_triangle( static void occmesh_get_triangle(
const void* cookie, uint32_t tri_id, gmio_stl_triangle_t* tri) const void* cookie, uint32_t tri_id, struct gmio_stl_triangle* tri)
{ {
const gmio_occ_stl_mesh_domain_t* mesh_domain = const struct gmio_occ_stl_mesh_domain* mesh_domain =
static_cast<const gmio_occ_stl_mesh_domain_t*>(cookie); static_cast<const struct gmio_occ_stl_mesh_domain*>(cookie);
const Handle_StlMesh_MeshTriangle& occTri = const Handle_StlMesh_MeshTriangle& occTri =
mesh_domain->triangles()->Value(tri_id + 1); mesh_domain->triangles()->Value(tri_id + 1);
int idV1; int idV1;
@ -87,9 +87,9 @@ static void occmesh_get_triangle(
} // namespace internal } // namespace internal
gmio_stl_mesh_t gmio_stl_occmesh(const gmio_occ_stl_mesh_domain_t* mesh_domain) struct gmio_stl_mesh gmio_stl_occmesh(const struct gmio_occ_stl_mesh_domain* mesh_domain)
{ {
gmio_stl_mesh_t mesh = {0}; struct gmio_stl_mesh mesh = {0};
mesh.cookie = mesh_domain; mesh.cookie = mesh_domain;
if (mesh_domain != NULL && mesh_domain->mesh() != NULL) { if (mesh_domain != NULL && mesh_domain->mesh() != NULL) {
mesh.triangle_count = mesh.triangle_count =
@ -99,15 +99,15 @@ gmio_stl_mesh_t gmio_stl_occmesh(const gmio_occ_stl_mesh_domain_t* mesh_domain)
return mesh; return mesh;
} }
gmio_stl_mesh_creator_t gmio_stl_occmesh_creator(StlMesh_Mesh* mesh) struct gmio_stl_mesh_creator gmio_stl_occmesh_creator(StlMesh_Mesh* mesh)
{ {
gmio_stl_mesh_creator_t creator = {0}; struct gmio_stl_mesh_creator creator = {0};
creator.cookie = mesh; creator.cookie = mesh;
creator.func_add_triangle = internal::occmesh_add_triangle; creator.func_add_triangle = internal::occmesh_add_triangle;
return creator; return creator;
} }
gmio_stl_mesh_creator_t gmio_stl_hnd_occmesh_creator(const Handle_StlMesh_Mesh &hnd) struct gmio_stl_mesh_creator gmio_stl_hnd_occmesh_creator(const Handle_StlMesh_Mesh &hnd)
{ {
return gmio_stl_occmesh_creator(internal::occMeshPtr(hnd)); return gmio_stl_occmesh_creator(internal::occMeshPtr(hnd));
} }

7
src/gmio_support/stl_occ.h
View File

@ -57,14 +57,13 @@ private:
const StlMesh_SequenceOfMeshTriangle* m_triangles; const StlMesh_SequenceOfMeshTriangle* m_triangles;
const TColgp_SequenceOfXYZ* m_vertices; const TColgp_SequenceOfXYZ* m_vertices;
}; };
typedef struct gmio_occ_stl_mesh_domain gmio_occ_stl_mesh_domain_t;
/*! Returns a gmio_stl_mesh mapped to domain in StlMesh_Mesh /*! Returns a gmio_stl_mesh mapped to domain in StlMesh_Mesh
* *
* The mesh's cookie will point to \p mesh_domain * The mesh's cookie will point to \p mesh_domain
*/ */
GMIO_LIBSUPPORT_EXPORT GMIO_LIBSUPPORT_EXPORT
gmio_stl_mesh_t gmio_stl_occmesh(const gmio_occ_stl_mesh_domain_t* mesh_domain); struct gmio_stl_mesh gmio_stl_occmesh(const struct gmio_occ_stl_mesh_domain* mesh_domain);
/*! Returns a gmio_stl_mesh_creator that will build a new domain in a /*! Returns a gmio_stl_mesh_creator that will build a new domain in a
* StlMesh_Mesh object * StlMesh_Mesh object
@ -72,7 +71,7 @@ gmio_stl_mesh_t gmio_stl_occmesh(const gmio_occ_stl_mesh_domain_t* mesh_domain);
* The creator's cookie will point \p mesh * The creator's cookie will point \p mesh
*/ */
GMIO_LIBSUPPORT_EXPORT GMIO_LIBSUPPORT_EXPORT
gmio_stl_mesh_creator_t gmio_stl_occmesh_creator(StlMesh_Mesh* mesh); struct gmio_stl_mesh_creator gmio_stl_occmesh_creator(StlMesh_Mesh* mesh);
/*! Same as gmio_stl_occmesh_creator(StlMesh_Mesh*) but takes a handle /*! Same as gmio_stl_occmesh_creator(StlMesh_Mesh*) but takes a handle
* *
@ -80,7 +79,7 @@ gmio_stl_mesh_creator_t gmio_stl_occmesh_creator(StlMesh_Mesh* mesh);
* handle \p hnd * handle \p hnd
*/ */
GMIO_LIBSUPPORT_EXPORT GMIO_LIBSUPPORT_EXPORT
gmio_stl_mesh_creator_t gmio_stl_hnd_occmesh_creator(const Handle_StlMesh_Mesh& hnd); struct gmio_stl_mesh_creator gmio_stl_hnd_occmesh_creator(const Handle_StlMesh_Mesh& hnd);

26
src/gmio_support/stream_cpp.h
View File

@ -35,11 +35,11 @@
/*! Returns a gmio_stream for C++ input stream (cookie will hold \p s ) */ /*! Returns a gmio_stream for C++ input stream (cookie will hold \p s ) */
template<typename CHAR, typename TRAITS> template<typename CHAR, typename TRAITS>
gmio_stream_t gmio_istream_cpp(std::basic_istream<CHAR, TRAITS>* s); gmio_stream gmio_istream_cpp(std::basic_istream<CHAR, TRAITS>* s);
/*! Returns a gmio_stream for C++ output stream (cookie will hold \p s ) */ /*! Returns a gmio_stream for C++ output stream (cookie will hold \p s ) */
template<typename CHAR, typename TRAITS> template<typename CHAR, typename TRAITS>
gmio_stream_t gmio_ostream_cpp(std::basic_ostream<CHAR, TRAITS>* s); gmio_stream gmio_ostream_cpp(std::basic_ostream<CHAR, TRAITS>* s);
@ -111,12 +111,12 @@ gmio_streamsize_t ostream_cpp_size(void* cookie)
return end_pos - begin_pos; return end_pos - begin_pos;
} }
GMIO_INLINE void copy_cpp_streampos(gmio_stream_pos_t* pos, std::streampos spos) GMIO_INLINE void copy_cpp_streampos(gmio_stream_pos* pos, std::streampos spos)
{ {
std::memcpy(&pos->cookie[0], &spos, sizeof(std::streampos)); std::memcpy(&pos->cookie[0], &spos, sizeof(std::streampos));
} }
GMIO_INLINE std::streampos to_cpp_streampos(const gmio_stream_pos_t* pos) GMIO_INLINE std::streampos to_cpp_streampos(const gmio_stream_pos* pos)
{ {
std::streampos spos; std::streampos spos;
std::memcpy(&spos, &pos->cookie[0], sizeof(std::streampos)); std::memcpy(&spos, &pos->cookie[0], sizeof(std::streampos));
@ -124,35 +124,35 @@ GMIO_INLINE std::streampos to_cpp_streampos(const gmio_stream_pos_t* pos)
} }
template<typename STREAM> template<typename STREAM>
int istream_cpp_get_pos(void* cookie, gmio_stream_pos_t* pos) int istream_cpp_get_pos(void* cookie, gmio_stream_pos* pos)
{ {
copy_cpp_streampos(pos, static_cast<STREAM*>(cookie)->tellg()); copy_cpp_streampos(pos, static_cast<STREAM*>(cookie)->tellg());
return 0; return 0;
} }
template<typename STREAM> template<typename STREAM>
int istream_cpp_set_pos(void* cookie, const gmio_stream_pos_t* pos) int istream_cpp_set_pos(void* cookie, const gmio_stream_pos* pos)
{ {
static_cast<STREAM*>(cookie)->seekg(to_cpp_streampos(pos)); static_cast<STREAM*>(cookie)->seekg(to_cpp_streampos(pos));
return 0; // TODO: return error code return 0; // TODO: return error code
} }
template<typename STREAM> template<typename STREAM>
int ostream_cpp_get_pos(void* cookie, gmio_stream_pos_t* pos) int ostream_cpp_get_pos(void* cookie, gmio_stream_pos* pos)
{ {
copy_cpp_streampos(pos, static_cast<STREAM*>(cookie)->tellp()); copy_cpp_streampos(pos, static_cast<STREAM*>(cookie)->tellp());
return 0; return 0;
} }
template<typename STREAM> template<typename STREAM>
static int ostream_cpp_set_pos(void* cookie, const gmio_stream_pos_t* pos) static int ostream_cpp_set_pos(void* cookie, const gmio_stream_pos* pos)
{ {
static_cast<STREAM*>(cookie)->seekp(to_cpp_streampos(pos)); static_cast<STREAM*>(cookie)->seekp(to_cpp_streampos(pos));
return 0; // TODO: return error code return 0; // TODO: return error code
} }
template<typename STREAM> template<typename STREAM>
void stream_cpp_init_common(STREAM* s, gmio_stream_t* stream) void stream_cpp_init_common(STREAM* s, gmio_stream* stream)
{ {
*stream = gmio_stream_null(); *stream = gmio_stream_null();
stream->cookie = s; stream->cookie = s;
@ -164,10 +164,10 @@ void stream_cpp_init_common(STREAM* s, gmio_stream_t* stream)
} // namespace gmio } // namespace gmio
template<typename CHAR, typename TRAITS> template<typename CHAR, typename TRAITS>
gmio_stream_t gmio_istream_cpp(std::basic_istream<CHAR, TRAITS>* s) gmio_stream gmio_istream_cpp(std::basic_istream<CHAR, TRAITS>* s)
{ {
typedef std::basic_istream<CHAR, TRAITS> CppStream; typedef std::basic_istream<CHAR, TRAITS> CppStream;
gmio_stream_t stream; gmio_stream stream;
gmio::internal::stream_cpp_init_common(s, &stream); gmio::internal::stream_cpp_init_common(s, &stream);
stream.func_size = gmio::internal::istream_cpp_size<CppStream>; stream.func_size = gmio::internal::istream_cpp_size<CppStream>;
stream.func_read = gmio::internal::istream_cpp_read<CppStream>; stream.func_read = gmio::internal::istream_cpp_read<CppStream>;
@ -177,10 +177,10 @@ gmio_stream_t gmio_istream_cpp(std::basic_istream<CHAR, TRAITS>* s)
} }
template<typename CHAR, typename TRAITS> template<typename CHAR, typename TRAITS>
gmio_stream_t gmio_ostream_cpp(std::basic_ostream<CHAR, TRAITS>* s) gmio_stream gmio_ostream_cpp(std::basic_ostream<CHAR, TRAITS>* s)
{ {
typedef std::basic_ostream<CHAR, TRAITS> CppStream; typedef std::basic_ostream<CHAR, TRAITS> CppStream;
gmio_stream_t stream; gmio_stream stream;
gmio::internal::stream_cpp_init_common(s, &stream); gmio::internal::stream_cpp_init_common(s, &stream);
stream.func_size = gmio::internal::ostream_cpp_size<CppStream>; stream.func_size = gmio::internal::ostream_cpp_size<CppStream>;
stream.func_write = gmio::internal::ostream_cpp_write<CppStream>; stream.func_write = gmio::internal::ostream_cpp_write<CppStream>;

8
src/gmio_support/stream_qt.cpp
View File

@ -64,7 +64,7 @@ static gmio_streamsize_t gmio_stream_qiodevice_size(void* cookie)
return device->size(); return device->size();
} }
static int gmio_stream_qiodevice_get_pos(void* cookie, gmio_stream_pos_t* pos) static int gmio_stream_qiodevice_get_pos(void* cookie, struct gmio_stream_pos* pos)
{ {
QIODevice* device = static_cast<QIODevice*>(cookie); QIODevice* device = static_cast<QIODevice*>(cookie);
qint64 qpos = device->pos(); qint64 qpos = device->pos();
@ -73,7 +73,7 @@ static int gmio_stream_qiodevice_get_pos(void* cookie, gmio_stream_pos_t* pos)
} }
static int gmio_stream_qiodevice_set_pos( static int gmio_stream_qiodevice_set_pos(
void* cookie, const gmio_stream_pos_t* pos) void* cookie, const struct gmio_stream_pos* pos)
{ {
QIODevice* device = static_cast<QIODevice*>(cookie); QIODevice* device = static_cast<QIODevice*>(cookie);
qint64 qpos; qint64 qpos;
@ -83,9 +83,9 @@ static int gmio_stream_qiodevice_set_pos(
return -1; /* TODO: return error code */ return -1; /* TODO: return error code */
} }
gmio_stream_t gmio_stream_qiodevice(QIODevice* device) struct gmio_stream gmio_stream_qiodevice(QIODevice* device)
{ {
gmio_stream_t stream = {0}; struct gmio_stream stream = {0};
stream.cookie = device; stream.cookie = device;
stream.func_at_end = gmio_stream_qiodevice_at_end; stream.func_at_end = gmio_stream_qiodevice_at_end;
stream.func_error = gmio_stream_qiodevice_error; stream.func_error = gmio_stream_qiodevice_error;

2
src/gmio_support/stream_qt.h
View File

@ -37,7 +37,7 @@ QT_END_NAMESPACE
/*! Returns a gmio_stream for \c QIODevice* (cookie will hold \p device) */ /*! Returns a gmio_stream for \c QIODevice* (cookie will hold \p device) */
GMIO_LIBSUPPORT_EXPORT GMIO_LIBSUPPORT_EXPORT
gmio_stream_t gmio_stream_qiodevice( struct gmio_stream gmio_stream_qiodevice(
#ifndef DOXYGEN #ifndef DOXYGEN
QT_PREPEND_NAMESPACE(QIODevice)* device QT_PREPEND_NAMESPACE(QIODevice)* device
#else #else

3
tests/CMakeLists.txt
View File

@ -50,8 +50,9 @@ file(COPY ${CMAKE_CURRENT_SOURCE_DIR}/models
DESTINATION ${CMAKE_CURRENT_BINARY_DIR}) DESTINATION ${CMAKE_CURRENT_BINARY_DIR})
set(GMIO_TEST_STL_SRC set(GMIO_TEST_STL_SRC
main_test_stl.c main_test_stl.c
test_stl_io.c
test_stl_internal.c test_stl_internal.c
test_stl_io.c
test_stla_stats.c
core_utils.c core_utils.c
stl_utils.c) stl_utils.c)
if(GMIO_BUILD_SHARED_LIBS) if(GMIO_BUILD_SHARED_LIBS)

2
tests/main_test_stl.c
View File

@ -21,6 +21,7 @@ const char* test_stl_read();
const char* test_stlb_write_header(); const char* test_stlb_write_header();
const char* test_stlb_write(); const char* test_stlb_write();
const char* test_stla_write(); const char* test_stla_write();
const char* test_stla_stats();
const char* all_tests() const char* all_tests()
{ {
@ -32,6 +33,7 @@ const char* all_tests()
UTEST_RUN(test_stlb_write_header); UTEST_RUN(test_stlb_write_header);
UTEST_RUN(test_stlb_write); UTEST_RUN(test_stlb_write);
UTEST_RUN(test_stla_write); UTEST_RUN(test_stla_write);
UTEST_RUN(test_stla_stats);
return NULL; return NULL;
} }

44
tests/stl_utils.c
View File

@ -24,19 +24,19 @@
#include <ctype.h> #include <ctype.h>
void gmio_stl_nop_add_triangle( void gmio_stl_nop_add_triangle(
void *cookie, uint32_t tri_id, const gmio_stl_triangle_t *triangle) void *cookie, uint32_t tri_id, const struct gmio_stl_triangle *triangle)
{ {
GMIO_UNUSED(cookie); GMIO_UNUSED(cookie);
GMIO_UNUSED(tri_id); GMIO_UNUSED(tri_id);
GMIO_UNUSED(triangle); GMIO_UNUSED(triangle);
} }
gmio_stl_triangle_array_t gmio_stl_triangle_array_malloc(size_t tri_count) struct gmio_stl_triangle_array gmio_stl_triangle_array_malloc(size_t tri_count)
{ {
gmio_stl_triangle_array_t array = {0}; struct gmio_stl_triangle_array array = {0};
if (tri_count > 0) { if (tri_count > 0) {
array.ptr = array.ptr =
(gmio_stl_triangle_t*)calloc(tri_count, sizeof(gmio_stl_triangle_t)); (struct gmio_stl_triangle*)calloc(tri_count, sizeof(struct gmio_stl_triangle));
} }
array.count = gmio_size_to_uint32(tri_count); array.count = gmio_size_to_uint32(tri_count);
array.capacity = array.count; array.capacity = array.count;
@ -46,7 +46,7 @@ gmio_stl_triangle_array_t gmio_stl_triangle_array_malloc(size_t tri_count)
static void gmio_stl_data__ascii_begin_solid( static void gmio_stl_data__ascii_begin_solid(
void* cookie, gmio_streamsize_t stream_size, const char* solid_name) void* cookie, gmio_streamsize_t stream_size, const char* solid_name)
{ {
gmio_stl_data_t* data = (gmio_stl_data_t*)cookie; struct gmio_stl_data* data = (struct gmio_stl_data*)cookie;
memset(&data->solid_name[0], 0, sizeof(data->solid_name)); memset(&data->solid_name[0], 0, sizeof(data->solid_name));
if (solid_name != NULL) { if (solid_name != NULL) {
@ -66,22 +66,22 @@ static void gmio_stl_data__ascii_begin_solid(
} }
static void gmio_stl_data__binary_begin_solid( static void gmio_stl_data__binary_begin_solid(
void* cookie, uint32_t tri_count, const gmio_stlb_header_t* header) void* cookie, uint32_t tri_count, const struct gmio_stlb_header* header)
{ {
gmio_stl_data_t* data = (gmio_stl_data_t*)cookie; struct gmio_stl_data* data = (struct gmio_stl_data*)cookie;
memcpy(&data->header, header, GMIO_STLB_HEADER_SIZE); memcpy(&data->header, header, GMIO_STLB_HEADER_SIZE);
data->tri_array = gmio_stl_triangle_array_malloc(tri_count); data->tri_array = gmio_stl_triangle_array_malloc(tri_count);
} }
static void gmio_stl_data__add_triangle( static void gmio_stl_data__add_triangle(
void* cookie, uint32_t tri_id, const gmio_stl_triangle_t* triangle) void* cookie, uint32_t tri_id, const struct gmio_stl_triangle* triangle)
{ {
gmio_stl_data_t* data = (gmio_stl_data_t*)cookie; struct gmio_stl_data* data = (struct gmio_stl_data*)cookie;
if (tri_id >= data->tri_array.capacity) { if (tri_id >= data->tri_array.capacity) {
uint32_t cap = data->tri_array.capacity; uint32_t cap = data->tri_array.capacity;
cap += cap >> 3; /* Add 12.5% more capacity */ cap += cap >> 3; /* Add 12.5% more capacity */
data->tri_array.ptr = data->tri_array.ptr =
realloc(data->tri_array.ptr, cap * sizeof(gmio_stl_triangle_t)); realloc(data->tri_array.ptr, cap * sizeof(struct gmio_stl_triangle));
data->tri_array.capacity = cap; data->tri_array.capacity = cap;
} }
memcpy(&data->tri_array.ptr[tri_id], triangle, GMIO_STLB_TRIANGLE_RAWSIZE); memcpy(&data->tri_array.ptr[tri_id], triangle, GMIO_STLB_TRIANGLE_RAWSIZE);
@ -89,15 +89,15 @@ static void gmio_stl_data__add_triangle(
} }
static void gmio_stl_data__get_triangle( static void gmio_stl_data__get_triangle(
const void* cookie, uint32_t tri_id, gmio_stl_triangle_t* triangle) const void* cookie, uint32_t tri_id, struct gmio_stl_triangle* triangle)
{ {
const gmio_stl_data_t* data = (const gmio_stl_data_t*)cookie; const struct gmio_stl_data* data = (const struct gmio_stl_data*)cookie;
*triangle = data->tri_array.ptr[tri_id]; *triangle = data->tri_array.ptr[tri_id];
} }
gmio_stl_mesh_creator_t gmio_stl_data_mesh_creator(gmio_stl_data_t *data) struct gmio_stl_mesh_creator gmio_stl_data_mesh_creator(struct gmio_stl_data *data)
{ {
gmio_stl_mesh_creator_t creator = {0}; struct gmio_stl_mesh_creator creator = {0};
creator.cookie = data; creator.cookie = data;
creator.func_ascii_begin_solid = &gmio_stl_data__ascii_begin_solid; creator.func_ascii_begin_solid = &gmio_stl_data__ascii_begin_solid;
creator.func_binary_begin_solid = &gmio_stl_data__binary_begin_solid; creator.func_binary_begin_solid = &gmio_stl_data__binary_begin_solid;
@ -105,9 +105,9 @@ gmio_stl_mesh_creator_t gmio_stl_data_mesh_creator(gmio_stl_data_t *data)
return creator; return creator;
} }
gmio_stl_mesh_t gmio_stl_data_mesh(const gmio_stl_data_t *data) struct gmio_stl_mesh gmio_stl_data_mesh(const struct gmio_stl_data *data)
{ {
gmio_stl_mesh_t mesh = {0}; struct gmio_stl_mesh mesh = {0};
mesh.cookie = data; mesh.cookie = data;
mesh.triangle_count = data->tri_array.count; mesh.triangle_count = data->tri_array.count;
mesh.func_get_triangle = &gmio_stl_data__get_triangle; mesh.func_get_triangle = &gmio_stl_data__get_triangle;
@ -115,7 +115,7 @@ gmio_stl_mesh_t gmio_stl_data_mesh(const gmio_stl_data_t *data)
} }
void gmio_stlb_header_to_printable_string( void gmio_stlb_header_to_printable_string(
const gmio_stlb_header_t *header, char *str, char replacement) const struct gmio_stlb_header *header, char *str, char replacement)
{ {
size_t i = 0; size_t i = 0;
for (; i < GMIO_STLB_HEADER_SIZE; ++i) { for (; i < GMIO_STLB_HEADER_SIZE; ++i) {
@ -127,8 +127,8 @@ void gmio_stlb_header_to_printable_string(
} }
gmio_bool_t gmio_stl_coords_equal( gmio_bool_t gmio_stl_coords_equal(
const gmio_stl_coords_t *lhs, const struct gmio_stl_coords *lhs,
const gmio_stl_coords_t *rhs, const struct gmio_stl_coords *rhs,
uint32_t max_ulp_diff) uint32_t max_ulp_diff)
{ {
return gmio_float32_equals_by_ulp(lhs->x, rhs->x, max_ulp_diff) return gmio_float32_equals_by_ulp(lhs->x, rhs->x, max_ulp_diff)
@ -137,8 +137,8 @@ gmio_bool_t gmio_stl_coords_equal(
} }
gmio_bool_t gmio_stl_triangle_equal( gmio_bool_t gmio_stl_triangle_equal(
const gmio_stl_triangle_t *lhs, const struct gmio_stl_triangle *lhs,
const gmio_stl_triangle_t *rhs, const struct gmio_stl_triangle *rhs,
uint32_t max_ulp_diff) uint32_t max_ulp_diff)
{ {
return gmio_stl_coords_equal(&lhs->normal, &rhs->normal, max_ulp_diff) return gmio_stl_coords_equal(&lhs->normal, &rhs->normal, max_ulp_diff)
@ -149,7 +149,7 @@ gmio_bool_t gmio_stl_triangle_equal(
} }
void gmio_stl_nop_get_triangle( void gmio_stl_nop_get_triangle(
const void *cookie, uint32_t tri_id, gmio_stl_triangle_t *triangle) const void *cookie, uint32_t tri_id, struct gmio_stl_triangle *triangle)
{ {
GMIO_UNUSED(cookie); GMIO_UNUSED(cookie);
GMIO_UNUSED(tri_id); GMIO_UNUSED(tri_id);

32
tests/stl_utils.h
View File

@ -25,60 +25,58 @@
#include <string.h> #include <string.h>
gmio_bool_t gmio_stl_coords_equal( gmio_bool_t gmio_stl_coords_equal(
const gmio_stl_coords_t* lhs, const struct gmio_stl_coords* lhs,
const gmio_stl_coords_t* rhs, const struct gmio_stl_coords* rhs,
uint32_t max_ulp_diff); uint32_t max_ulp_diff);
gmio_bool_t gmio_stl_triangle_equal( gmio_bool_t gmio_stl_triangle_equal(
const gmio_stl_triangle_t* lhs, const struct gmio_stl_triangle* lhs,
const gmio_stl_triangle_t* rhs, const struct gmio_stl_triangle* rhs,
uint32_t max_ulp_diff); uint32_t max_ulp_diff);
/*! Does binary STL header \p lhs compare equal to \p rhs ? */ /*! Does binary STL header \p lhs compare equal to \p rhs ? */
GMIO_INLINE gmio_bool_t gmio_stlb_header_equal( GMIO_INLINE gmio_bool_t gmio_stlb_header_equal(
const gmio_stlb_header_t* lhs, const gmio_stlb_header_t* rhs) const struct gmio_stlb_header* lhs, const struct gmio_stlb_header* rhs)
{ {
return memcmp(lhs, rhs, GMIO_STLB_HEADER_SIZE) == 0; return memcmp(lhs, rhs, GMIO_STLB_HEADER_SIZE) == 0;
} }
void gmio_stlb_header_to_printable_string( void gmio_stlb_header_to_printable_string(
const gmio_stlb_header_t* header, char* str, char replacement); const struct gmio_stlb_header* header, char* str, char replacement);
/*! Callback for gmio_stl_mesh_creator::func_add_triangle that does /*! Callback for gmio_stl_mesh_creator::func_add_triangle that does
* nothing(ie "no operation") */ * nothing(ie "no operation") */
void gmio_stl_nop_add_triangle( void gmio_stl_nop_add_triangle(
void* cookie, uint32_t tri_id, const gmio_stl_triangle_t* triangle); void* cookie, uint32_t tri_id, const struct gmio_stl_triangle* triangle);
/*! Callback for gmio_stl_mesh::func_get_triangle that does nothing */ /*! Callback for gmio_stl_mesh::func_get_triangle that does nothing */
void gmio_stl_nop_get_triangle( void gmio_stl_nop_get_triangle(
const void* cookie, uint32_t tri_id, gmio_stl_triangle_t* triangle); const void* cookie, uint32_t tri_id, struct gmio_stl_triangle* triangle);
/*! Holds an array of STL triangles */ /*! Holds an array of STL triangles */
struct gmio_stl_triangle_array struct gmio_stl_triangle_array
{ {
gmio_stl_triangle_t* ptr; struct gmio_stl_triangle* ptr;
uint32_t count; uint32_t count;
uint32_t capacity; uint32_t capacity;
}; };
typedef struct gmio_stl_triangle_array gmio_stl_triangle_array_t;
/*! Returns an dynamically allocated array of gmio_stl_triangle_t /*! Returns an dynamically allocated array of struct gmio_stl_triangle
* *
* Contents of the memory block beginnning at gmio_stl_triangle_array::ptr * Contents of the memory block beginnning at gmio_stl_triangle_array::ptr
* is initialized with zeroes * is initialized with zeroes
*/ */
gmio_stl_triangle_array_t gmio_stl_triangle_array_malloc(size_t tri_count); struct gmio_stl_triangle_array gmio_stl_triangle_array_malloc(size_t tri_count);
/*! Holds complete STL data (usable for both binary and ascii formats) */ /*! Holds complete STL data (usable for both binary and ascii formats) */
struct gmio_stl_data struct gmio_stl_data
{ {
gmio_stlb_header_t header; struct gmio_stlb_header header;
char solid_name[1024]; char solid_name[1024];
gmio_stl_triangle_array_t tri_array; struct gmio_stl_triangle_array tri_array;
}; };
typedef struct gmio_stl_data gmio_stl_data_t;
gmio_stl_mesh_creator_t gmio_stl_data_mesh_creator(gmio_stl_data_t* data); struct gmio_stl_mesh_creator gmio_stl_data_mesh_creator(struct gmio_stl_data* data);
gmio_stl_mesh_t gmio_stl_data_mesh(const gmio_stl_data_t* data); struct gmio_stl_mesh gmio_stl_data_mesh(const struct gmio_stl_data* data);
#endif /* GMIO_TESTS_STL_UTILS_H */ #endif /* GMIO_TESTS_STL_UTILS_H */

14
tests/stream_buffer.c
View File

@ -58,7 +58,7 @@ static size_t gmio_stream_buffer_write(
void* cookie, const void* ptr, size_t item_size, size_t item_count) void* cookie, const void* ptr, size_t item_size, size_t item_count)
{ {
if (item_size > 0 && item_count > 0) { if (item_size > 0 && item_count > 0) {
gmio_rw_buffer_t* buff = (gmio_rw_buffer_t*)cookie; struct gmio_rw_buffer* buff = (struct gmio_rw_buffer*)cookie;
const size_t buff_remaining_size = buff->len - buff->pos; const size_t buff_remaining_size = buff->len - buff->pos;
const size_t wanted_write_size = item_size * item_count; const size_t wanted_write_size = item_size * item_count;
const size_t next_write_size = const size_t next_write_size =
@ -84,23 +84,23 @@ static gmio_streamsize_t gmio_stream_buffer_size(void* cookie)
return buff->len; return buff->len;
} }
static int gmio_stream_buffer_get_pos(void* cookie, gmio_stream_pos_t* pos) static int gmio_stream_buffer_get_pos(void* cookie, struct gmio_stream_pos* pos)
{ {
gmio_ro_buffer_t* buff = (gmio_ro_buffer_t*)cookie; gmio_ro_buffer_t* buff = (gmio_ro_buffer_t*)cookie;
memcpy(&pos->cookie[0], &buff->pos, sizeof(size_t)); memcpy(&pos->cookie[0], &buff->pos, sizeof(size_t));
return 0; return 0;
} }
static int gmio_stream_buffer_set_pos(void* cookie, const gmio_stream_pos_t* pos) static int gmio_stream_buffer_set_pos(void* cookie, const struct gmio_stream_pos* pos)
{ {
gmio_ro_buffer_t* buff = (gmio_ro_buffer_t*)cookie; gmio_ro_buffer_t* buff = (gmio_ro_buffer_t*)cookie;
memcpy(&buff->pos, &pos->cookie[0], sizeof(size_t)); memcpy(&buff->pos, &pos->cookie[0], sizeof(size_t));
return 0; return 0;
} }
gmio_stream_t gmio_istream_buffer(gmio_ro_buffer_t* buff) struct gmio_stream gmio_istream_buffer(gmio_ro_buffer_t* buff)
{ {
gmio_stream_t stream = {0}; struct gmio_stream stream = {0};
stream.cookie = buff; stream.cookie = buff;
stream.func_at_end = gmio_stream_buffer_at_end; stream.func_at_end = gmio_stream_buffer_at_end;
stream.func_error = gmio_stream_buffer_error; stream.func_error = gmio_stream_buffer_error;
@ -111,9 +111,9 @@ gmio_stream_t gmio_istream_buffer(gmio_ro_buffer_t* buff)
return stream; return stream;
} }
gmio_stream_t gmio_stream_buffer(gmio_rw_buffer_t* buff) struct gmio_stream gmio_stream_buffer(struct gmio_rw_buffer* buff)
{ {
gmio_stream_t stream = gmio_istream_buffer((gmio_ro_buffer_t*)buff); struct gmio_stream stream = gmio_istream_buffer((gmio_ro_buffer_t*)buff);
stream.func_write = gmio_stream_buffer_write; stream.func_write = gmio_stream_buffer_write;
return stream; return stream;
} }

5
tests/stream_buffer.h
View File

@ -34,9 +34,8 @@ struct gmio_rw_buffer
size_t len; size_t len;
size_t pos; size_t pos;
}; };
typedef struct gmio_rw_buffer gmio_rw_buffer_t;
gmio_stream_t gmio_istream_buffer(gmio_ro_buffer_t* buff); struct gmio_stream gmio_istream_buffer(gmio_ro_buffer_t* buff);
gmio_stream_t gmio_iostream_buffer(gmio_rw_buffer_t* buff); struct gmio_stream gmio_iostream_buffer(struct gmio_rw_buffer* buff);
#endif /* GMIO_STREAM_BUFFER_H */ #endif /* GMIO_STREAM_BUFFER_H */

14
tests/test_core.c
View File

@ -23,7 +23,7 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
static gmio_memblock_t buffer_ctor() static struct gmio_memblock buffer_ctor()
{ {
return gmio_memblock_calloc(4, 256); return gmio_memblock_calloc(4, 256);
} }
@ -36,7 +36,7 @@ const char* test_core__buffer()
const size_t obj_size = 256; const size_t obj_size = 256;
const size_t buff_size = obj_count * obj_size; const size_t buff_size = obj_count * obj_size;
const uint8_t zero_buff[4 * 256] = {0}; const uint8_t zero_buff[4 * 256] = {0};
gmio_memblock_t buff = gmio_memblock_calloc(obj_count, obj_size); struct gmio_memblock buff = gmio_memblock_calloc(obj_count, obj_size);
UTEST_ASSERT(buff.ptr != NULL); UTEST_ASSERT(buff.ptr != NULL);
UTEST_ASSERT(buff.size == buff_size); UTEST_ASSERT(buff.size == buff_size);
UTEST_ASSERT(memcmp(buff.ptr, &zero_buff[0], buff_size) == 0); UTEST_ASSERT(memcmp(buff.ptr, &zero_buff[0], buff_size) == 0);
@ -49,7 +49,7 @@ const char* test_core__buffer()
/* gmio_memblock_malloc() */ /* gmio_memblock_malloc() */
{ {
const size_t buff_size = 2 * 1024; /* 2KB */ const size_t buff_size = 2 * 1024; /* 2KB */
gmio_memblock_t buff = gmio_memblock_malloc(buff_size); struct gmio_memblock buff = gmio_memblock_malloc(buff_size);
UTEST_ASSERT(buff.ptr != NULL); UTEST_ASSERT(buff.ptr != NULL);
UTEST_ASSERT(buff.size == buff_size); UTEST_ASSERT(buff.size == buff_size);
UTEST_ASSERT(buff.func_deallocate == &free); UTEST_ASSERT(buff.func_deallocate == &free);
@ -58,7 +58,7 @@ const char* test_core__buffer()
/* gmio_memblock_realloc() */ /* gmio_memblock_realloc() */
{ {
const size_t buff_size = 1024; /* 1KB */ const size_t buff_size = 1024; /* 1KB */
gmio_memblock_t buff = gmio_memblock_malloc(buff_size); struct gmio_memblock buff = gmio_memblock_malloc(buff_size);
buff = gmio_memblock_realloc(buff.ptr, 2 * buff_size); buff = gmio_memblock_realloc(buff.ptr, 2 * buff_size);
UTEST_ASSERT(buff.ptr != NULL); UTEST_ASSERT(buff.ptr != NULL);
UTEST_ASSERT(buff.size == (2 * buff_size)); UTEST_ASSERT(buff.size == (2 * buff_size));
@ -100,9 +100,9 @@ const char* test_core__error()
const char* test_core__stream() const char* test_core__stream()
{ {
{ {
const gmio_stream_t null_stream = gmio_stream_null(); const struct gmio_stream null_stream = gmio_stream_null();
const uint8_t null_bytes[sizeof(gmio_stream_t)] = {0}; const uint8_t null_bytes[sizeof(struct gmio_stream)] = {0};
UTEST_ASSERT(memcmp(&null_stream, &null_bytes, sizeof(gmio_stream_t)) UTEST_ASSERT(memcmp(&null_stream, &null_bytes, sizeof(struct gmio_stream))
== 0); == 0);
} }

10
tests/test_core_internal.c
View File

@ -131,7 +131,7 @@ const char* test_internal__gmio_fast_atof()
{ {
char strbuff[2048] = {0}; char strbuff[2048] = {0};
gmio_stringstream_t it = {0}; struct gmio_stringstream it = {0};
gmio_ro_buffer_t streambuff = { fstr, sizeof(fstr) - 1, 0 }; gmio_ro_buffer_t streambuff = { fstr, sizeof(fstr) - 1, 0 };
float f2; float f2;
@ -182,10 +182,10 @@ const char* test_internal__stringstream()
char small_fwd_it_str[4]; char small_fwd_it_str[4];
char fwd_it_str[32]; char fwd_it_str[32];
gmio_stringstream_t fwd_it = {0}; struct gmio_stringstream fwd_it = {0};
char copy_str[128]; char copy_str[128];
gmio_string_t copy_strbuff; struct gmio_string copy_strbuff;
fwd_it.stream = gmio_istream_buffer(&buff); fwd_it.stream = gmio_istream_buffer(&buff);
fwd_it.strbuff.ptr = fwd_it_str; fwd_it.strbuff.ptr = fwd_it_str;
@ -237,10 +237,10 @@ const char* test_internal__stringstream()
gmio_ro_buffer_t buff = { text, sizeof(text) - 1, 0 }; gmio_ro_buffer_t buff = { text, sizeof(text) - 1, 0 };
char fwd_it_str[32]; char fwd_it_str[32];
gmio_stringstream_t fwd_it = {0}; struct gmio_stringstream fwd_it = {0};
char copy_str[128]; char copy_str[128];
gmio_string_t copy_strbuff; struct gmio_string copy_strbuff;
fwd_it.stream = gmio_istream_buffer(&buff); fwd_it.stream = gmio_istream_buffer(&buff);
fwd_it.strbuff.ptr = fwd_it_str; fwd_it.strbuff.ptr = fwd_it_str;

41
tests/test_core_platform.c
View File

@ -16,7 +16,7 @@
#include "utest_assert.h" #include "utest_assert.h"
#include "../src/gmio_core/global.h" #include "../src/gmio_core/global.h"
#include "../src/gmio_core/transfer.h" #include "../src/gmio_core/rwargs.h"
#include "../src/gmio_stl/stl_triangle.h" #include "../src/gmio_stl/stl_triangle.h"
#include <stddef.h> #include <stddef.h>
@ -27,17 +27,17 @@ GMIO_PRAGMA_MSVC_WARNING_PUSH_AND_DISABLE(4127)
const char* test_platform__alignment() const char* test_platform__alignment()
{ {
UTEST_ASSERT(offsetof(gmio_stl_coords_t, x) == 0); UTEST_ASSERT(offsetof(struct gmio_stl_coords, x) == 0);
UTEST_ASSERT(offsetof(gmio_stl_coords_t, y) == 4); UTEST_ASSERT(offsetof(struct gmio_stl_coords, y) == 4);
UTEST_ASSERT(offsetof(gmio_stl_coords_t, z) == 8); UTEST_ASSERT(offsetof(struct gmio_stl_coords, z) == 8);
UTEST_ASSERT(sizeof(gmio_stl_coords_t) == GMIO_STL_COORDS_RAWSIZE); UTEST_ASSERT(sizeof(struct gmio_stl_coords) == GMIO_STL_COORDS_RAWSIZE);
UTEST_ASSERT(offsetof(gmio_stl_triangle_t, normal) == 0); UTEST_ASSERT(offsetof(struct gmio_stl_triangle, normal) == 0);
UTEST_ASSERT(offsetof(gmio_stl_triangle_t, v1) == GMIO_STL_COORDS_RAWSIZE); UTEST_ASSERT(offsetof(struct gmio_stl_triangle, v1) == GMIO_STL_COORDS_RAWSIZE);
UTEST_ASSERT(offsetof(gmio_stl_triangle_t, v2) == 2*GMIO_STL_COORDS_RAWSIZE); UTEST_ASSERT(offsetof(struct gmio_stl_triangle, v2) == 2*GMIO_STL_COORDS_RAWSIZE);
UTEST_ASSERT(offsetof(gmio_stl_triangle_t, v3) == 3*GMIO_STL_COORDS_RAWSIZE); UTEST_ASSERT(offsetof(struct gmio_stl_triangle, v3) == 3*GMIO_STL_COORDS_RAWSIZE);
UTEST_ASSERT(offsetof(gmio_stl_triangle_t, attribute_byte_count) == 4*GMIO_STL_COORDS_RAWSIZE); UTEST_ASSERT(offsetof(struct gmio_stl_triangle, attribute_byte_count) == 4*GMIO_STL_COORDS_RAWSIZE);
UTEST_ASSERT(sizeof(gmio_stl_triangle_t) >= GMIO_STLB_TRIANGLE_RAWSIZE); UTEST_ASSERT(sizeof(struct gmio_stl_triangle) >= GMIO_STLB_TRIANGLE_RAWSIZE);
return NULL; return NULL;
} }
@ -75,20 +75,21 @@ const char* test_platform__compiler()
* See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119 * See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53119
*/ */
{ {
const gmio_transfer_t trsf_null_bracket0 = {0}; const struct gmio_rwargs args_null_bracket0 = {0};
gmio_transfer_t trsf_null_memset0; struct gmio_rwargs args_null_memset0;
memset(&trsf_null_memset0, 0, sizeof(gmio_transfer_t)); memset(&args_null_memset0, 0, sizeof(struct gmio_rwargs));
UTEST_ASSERT(memcmp( UTEST_ASSERT(memcmp(
&trsf_null_bracket0, &args_null_bracket0,
&trsf_null_memset0, &args_null_memset0,
sizeof(gmio_transfer_t)) sizeof(struct gmio_rwargs))
== 0); == 0);
UTEST_ASSERT(sizeof(gmio_transfer_t) >= (sizeof(gmio_stream_t) UTEST_ASSERT(sizeof(struct gmio_rwargs)
+ sizeof(gmio_memblock_t) >= (sizeof(struct gmio_stream)
+ sizeof(gmio_task_iface_t))); + sizeof(struct gmio_memblock)
+ sizeof(struct gmio_task_iface)));
} }
/* Check sizeof() operator with fixed-size arrays */ /* Check sizeof() operator with fixed-size arrays */

41
tests/test_stl_internal.c
View File

@ -18,6 +18,7 @@
#include "stl_utils.h" #include "stl_utils.h"
#include "../src/gmio_core/error.h" #include "../src/gmio_core/error.h"
#include "../src/gmio_core/rwargs.h"
#include "../src/gmio_stl/internal/stl_rw_common.h" #include "../src/gmio_stl/internal/stl_rw_common.h"
#include "../src/gmio_stl/stl_error.h" #include "../src/gmio_stl/stl_error.h"
#include "../src/gmio_stl/stl_io.h" #include "../src/gmio_stl/stl_io.h"
@ -30,47 +31,47 @@ const char* test_stl_internal__rw_common()
{ {
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
uint8_t buff[128] = {0}; uint8_t buff[128] = {0};
gmio_transfer_t trsf = {0}; struct gmio_rwargs rwargs = {0};
UTEST_ASSERT(!gmio_check_transfer(&error, NULL)); UTEST_ASSERT(!gmio_check_rwargs(&error, NULL));
UTEST_ASSERT(error == GMIO_ERROR_NULL_TRANSFER); UTEST_ASSERT(error == GMIO_ERROR_NULL_RWARGS);
UTEST_ASSERT(!gmio_check_transfer(&error, &trsf)); UTEST_ASSERT(!gmio_check_rwargs(&error, &rwargs));
UTEST_ASSERT(error == GMIO_ERROR_NULL_MEMBLOCK); UTEST_ASSERT(error == GMIO_ERROR_NULL_MEMBLOCK);
trsf.memblock = gmio_memblock(&buff[0], 0, NULL); rwargs.memblock = gmio_memblock(&buff[0], 0, NULL);
UTEST_ASSERT(!gmio_check_transfer(&error, &trsf)); UTEST_ASSERT(!gmio_check_rwargs(&error, &rwargs));
UTEST_ASSERT(error == GMIO_ERROR_INVALID_MEMBLOCK_SIZE); UTEST_ASSERT(error == GMIO_ERROR_INVALID_MEMBLOCK_SIZE);
/* Verify that gmio_check_transfer() doesn't touch error when in case of /* Verify that gmio_check_transfer() doesn't touch error when in case of
* success */ * success */
trsf.memblock = gmio_memblock(&buff[0], sizeof(buff), NULL); rwargs.memblock = gmio_memblock(&buff[0], sizeof(buff), NULL);
UTEST_ASSERT(!gmio_check_transfer(&error, &trsf)); UTEST_ASSERT(!gmio_check_rwargs(&error, &rwargs));
UTEST_ASSERT(error == GMIO_ERROR_INVALID_MEMBLOCK_SIZE); UTEST_ASSERT(error == GMIO_ERROR_INVALID_MEMBLOCK_SIZE);
error = GMIO_ERROR_OK; error = GMIO_ERROR_OK;
UTEST_ASSERT(gmio_check_transfer(&error, &trsf)); UTEST_ASSERT(gmio_check_rwargs(&error, &rwargs));
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
} }
/* gmio_stl_check_mesh() */ /* gmio_stl_check_mesh() */
{ {
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
gmio_stl_mesh_t mesh = {0}; struct gmio_stl_mesh mesh = {0};
UTEST_ASSERT(!gmio_stl_check_mesh(&error, NULL)); UTEST_ASSERT(!gmio_stl_check_mesh(&error, NULL));
UTEST_ASSERT(error == GMIO_STL_ERROR_NULL_GET_TRIANGLE_FUNC); UTEST_ASSERT(error == GMIO_STL_ERROR_NULL_FUNC_GET_TRIANGLE);
mesh.triangle_count = 100; mesh.triangle_count = 100;
UTEST_ASSERT(!gmio_stl_check_mesh(&error, &mesh)); UTEST_ASSERT(!gmio_stl_check_mesh(&error, &mesh));
UTEST_ASSERT(error == GMIO_STL_ERROR_NULL_GET_TRIANGLE_FUNC); UTEST_ASSERT(error == GMIO_STL_ERROR_NULL_FUNC_GET_TRIANGLE);
/* Verify that gmio_stl_check_mesh() doesn't touch error when in case of /* Verify that gmio_stl_check_mesh() doesn't touch error when in case of
* success */ * success */
mesh.triangle_count = 0; mesh.triangle_count = 0;
mesh.func_get_triangle = &gmio_stl_nop_get_triangle; mesh.func_get_triangle = &gmio_stl_nop_get_triangle;
UTEST_ASSERT(!gmio_stl_check_mesh(&error, &mesh)); UTEST_ASSERT(!gmio_stl_check_mesh(&error, &mesh));
UTEST_ASSERT(error == GMIO_STL_ERROR_NULL_GET_TRIANGLE_FUNC); UTEST_ASSERT(error == GMIO_STL_ERROR_NULL_FUNC_GET_TRIANGLE);
error = GMIO_ERROR_OK; error = GMIO_ERROR_OK;
UTEST_ASSERT(gmio_stl_check_mesh(&error, &mesh)); UTEST_ASSERT(gmio_stl_check_mesh(&error, &mesh));
@ -80,23 +81,23 @@ const char* test_stl_internal__rw_common()
/* gmio_stlb_check_params() */ /* gmio_stlb_check_params() */
{ {
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
gmio_transfer_t trsf = {0}; struct gmio_rwargs rwargs = {0};
uint8_t buff[1024] = {0}; uint8_t buff[1024] = {0};
UTEST_ASSERT(!gmio_stlb_check_params(&error, NULL, GMIO_ENDIANNESS_HOST)); UTEST_ASSERT(!gmio_stlb_check_params(&error, NULL, GMIO_ENDIANNESS_HOST));
UTEST_ASSERT(error == GMIO_ERROR_NULL_TRANSFER); UTEST_ASSERT(error == GMIO_ERROR_NULL_RWARGS);
error = GMIO_ERROR_OK; error = GMIO_ERROR_OK;
trsf.memblock = gmio_memblock(&buff[0], GMIO_STLB_MIN_CONTENTS_SIZE / 2, NULL); rwargs.memblock = gmio_memblock(&buff[0], GMIO_STLB_MIN_CONTENTS_SIZE / 2, NULL);
UTEST_ASSERT(!gmio_stlb_check_params(&error, &trsf, GMIO_ENDIANNESS_HOST)); UTEST_ASSERT(!gmio_stlb_check_params(&error, &rwargs, GMIO_ENDIANNESS_HOST));
UTEST_ASSERT(error == GMIO_ERROR_INVALID_MEMBLOCK_SIZE); UTEST_ASSERT(error == GMIO_ERROR_INVALID_MEMBLOCK_SIZE);
error = GMIO_ERROR_OK; error = GMIO_ERROR_OK;
trsf.memblock = gmio_memblock(&buff[0], sizeof(buff), NULL); rwargs.memblock = gmio_memblock(&buff[0], sizeof(buff), NULL);
UTEST_ASSERT(gmio_stlb_check_params(&error, &trsf, GMIO_ENDIANNESS_HOST)); UTEST_ASSERT(gmio_stlb_check_params(&error, &rwargs, GMIO_ENDIANNESS_HOST));
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
UTEST_ASSERT(!gmio_stlb_check_params(&error, &trsf, GMIO_ENDIANNESS_UNKNOWN)); UTEST_ASSERT(!gmio_stlb_check_params(&error, &rwargs, GMIO_ENDIANNESS_UNKNOWN));
UTEST_ASSERT(error == GMIO_STL_ERROR_UNSUPPORTED_BYTE_ORDER); UTEST_ASSERT(error == GMIO_STL_ERROR_UNSUPPORTED_BYTE_ORDER);
} }

81
tests/test_stl_io.c
View File

@ -22,11 +22,12 @@
#include "../src/gmio_core/internal/min_max.h" #include "../src/gmio_core/internal/min_max.h"
#include "../src/gmio_stl/stl_error.h" #include "../src/gmio_stl/stl_error.h"
#include "../src/gmio_stl/stl_io.h" #include "../src/gmio_stl/stl_io.h"
#include "../src/gmio_stl/stl_io_options.h"
#include <stddef.h> #include <stddef.h>
#include <stdlib.h> #include <stdlib.h>
static const char* stl_grabcad_arm11_filepath = static const char stl_grabcad_arm11_filepath[] =
"models/solid_grabcad_arm11_link0_hb.le_stlb"; "models/solid_grabcad_arm11_link0_hb.le_stlb";
struct stl_testcase_result struct stl_testcase_result
@ -51,7 +52,7 @@ struct stl_testcase
{ {
const char* filepath; const char* filepath;
int errorcode; int errorcode;
gmio_stl_format_t format; enum gmio_stl_format format;
const char* solid_name; const char* solid_name;
}; };
typedef struct stl_testcase stl_testcase; typedef struct stl_testcase stl_testcase;
@ -128,7 +129,7 @@ const char* test_stl_read()
const size_t expected_count = const size_t expected_count =
sizeof(expected) / sizeof(stl_testcase); sizeof(expected) / sizeof(stl_testcase);
size_t i; /* for loop counter */ size_t i; /* for loop counter */
gmio_stl_mesh_creator_t meshc = {0}; struct gmio_stl_mesh_creator meshc = {0};
stl_testcase_result_t result = {0}; stl_testcase_result_t result = {0};
meshc.cookie = &result; meshc.cookie = &result;
@ -136,10 +137,10 @@ const char* test_stl_read()
meshc.func_add_triangle = &gmio_stl_nop_add_triangle; meshc.func_add_triangle = &gmio_stl_nop_add_triangle;
for (i = 0; i < expected_count; ++i) { for (i = 0; i < expected_count; ++i) {
const gmio_stl_format_t format = const enum gmio_stl_format format =
gmio_stl_get_format_file(expected[i].filepath); gmio_stl_get_format_file(expected[i].filepath);
const int err = const int err =
gmio_stl_read_file(expected[i].filepath, &meshc, NULL); gmio_stl_read_file(expected[i].filepath, NULL, &meshc);
/* Check format */ /* Check format */
if (format != expected[i].format) { if (format != expected[i].format) {
@ -185,13 +186,13 @@ const char* test_stl_read()
const char* test_stlb_write_header() const char* test_stlb_write_header()
{ {
const char* filepath = "temp/solid.stlb"; const char* filepath = "temp/solid.stlb";
gmio_stlb_header_t header = {0}; struct gmio_stlb_header header = {0};
const char* header_str = "temp/solid.stlb generated with gmio library"; const char* header_str = "temp/solid.stlb generated with gmio library";
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
{ {
FILE* outfile = fopen(filepath, "wb"); FILE* outfile = fopen(filepath, "wb");
gmio_stream_t stream = gmio_stream_stdio(outfile); struct gmio_stream stream = gmio_stream_stdio(outfile);
memcpy(&header, memcpy(&header,
header_str, header_str,
GMIO_MIN(GMIO_STLB_HEADER_SIZE, strlen(header_str))); GMIO_MIN(GMIO_STLB_HEADER_SIZE, strlen(header_str)));
@ -202,9 +203,9 @@ const char* test_stlb_write_header()
} }
{ {
gmio_stl_data_t data = {0}; struct gmio_stl_data data = {0};
gmio_stl_mesh_creator_t mesh_creator = gmio_stl_data_mesh_creator(&data); struct gmio_stl_mesh_creator mesh_creator = gmio_stl_data_mesh_creator(&data);
error = gmio_stl_read_file(filepath, &mesh_creator, NULL); error = gmio_stl_read_file(filepath, NULL, &mesh_creator);
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
UTEST_ASSERT(gmio_stlb_header_equal(&header, &data.header)); UTEST_ASSERT(gmio_stlb_header_equal(&header, &data.header));
UTEST_ASSERT(data.tri_array.count == 0); UTEST_ASSERT(data.tri_array.count == 0);
@ -227,13 +228,13 @@ const char* test_stlb_write()
const char* model_filepath = stl_grabcad_arm11_filepath; const char* model_filepath = stl_grabcad_arm11_filepath;
const char* model_filepath_out = "temp/solid.le_stlb"; const char* model_filepath_out = "temp/solid.le_stlb";
const char* model_filepath_out_be = "temp/solid.be_stlb"; const char* model_filepath_out_be = "temp/solid.be_stlb";
gmio_stl_data_t data = {0}; struct gmio_stl_data data = {0};
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
/* Read input model file */ /* Read input model file */
{ {
gmio_stl_mesh_creator_t creator = gmio_stl_data_mesh_creator(&data); struct gmio_stl_mesh_creator creator = gmio_stl_data_mesh_creator(&data);
error = gmio_stl_read_file(model_filepath, &creator, NULL); error = gmio_stl_read_file(model_filepath, NULL, &creator);
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
} }
@ -241,16 +242,16 @@ const char* test_stlb_write()
* Write also the model file in big-endian STL format * Write also the model file in big-endian STL format
*/ */
{ {
gmio_stl_write_options_t options = {0}; struct gmio_stl_write_options options = {0};
const gmio_stl_mesh_t mesh = gmio_stl_data_mesh(&data); const struct gmio_stl_mesh mesh = gmio_stl_data_mesh(&data);
options.stlb_header_data = &data.header; options.stlb_header_data = &data.header;
error = gmio_stl_write_file( error = gmio_stl_write_file(
GMIO_STL_FORMAT_BINARY_LE, model_filepath_out, &mesh, NULL, &options); model_filepath_out, NULL, &mesh, GMIO_STL_FORMAT_BINARY_LE, &options);
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
/* Big-endian version */ /* Big-endian version */
error = gmio_stl_write_file( error = gmio_stl_write_file(
GMIO_STL_FORMAT_BINARY_BE, model_filepath_out_be, &mesh, NULL, &options); model_filepath_out_be, NULL, &mesh, GMIO_STL_FORMAT_BINARY_BE, &options);
} }
/* Check input and output models are equal */ /* Check input and output models are equal */
@ -285,15 +286,15 @@ const char* test_stlb_write()
/* Check output LE/BE models are equal */ /* Check output LE/BE models are equal */
{ {
gmio_stl_data_t data_be = {0}; struct gmio_stl_data data_be = {0};
gmio_stl_mesh_creator_t creator = gmio_stl_data_mesh_creator(&data_be); struct gmio_stl_mesh_creator creator = gmio_stl_data_mesh_creator(&data_be);
error = gmio_stl_read_file(model_filepath_out_be, &creator, NULL); error = gmio_stl_read_file(model_filepath_out_be, NULL, &creator);
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
UTEST_ASSERT(gmio_stlb_header_equal(&data.header, &data_be.header)); UTEST_ASSERT(gmio_stlb_header_equal(&data.header, &data_be.header));
UTEST_ASSERT(data.tri_array.count == data_be.tri_array.count); UTEST_ASSERT(data.tri_array.count == data_be.tri_array.count);
UTEST_ASSERT(memcmp(data.tri_array.ptr, UTEST_ASSERT(memcmp(data.tri_array.ptr,
data_be.tri_array.ptr, data_be.tri_array.ptr,
data.tri_array.count * sizeof(gmio_stl_triangle_t)) data.tri_array.count * sizeof(struct gmio_stl_triangle))
== 0); == 0);
free(data_be.tri_array.ptr); free(data_be.tri_array.ptr);
} }
@ -307,45 +308,45 @@ const char* test_stla_write()
{ {
const char* model_filepath = stl_grabcad_arm11_filepath; const char* model_filepath = stl_grabcad_arm11_filepath;
const char* model_filepath_out = "temp/solid.stla"; const char* model_filepath_out = "temp/solid.stla";
gmio_stl_data_t data = {0}; struct gmio_stl_data data = {0};
char header_str[GMIO_STLB_HEADER_SIZE + 1] = {0}; char header_str[GMIO_STLB_HEADER_SIZE + 1] = {0};
int error = GMIO_ERROR_OK; int error = GMIO_ERROR_OK;
/* Read input model file */ /* Read input model file */
{ {
gmio_stl_mesh_creator_t creator = gmio_stl_data_mesh_creator(&data); struct gmio_stl_mesh_creator creator = gmio_stl_data_mesh_creator(&data);
error = gmio_stl_read_file(model_filepath, &creator, NULL); error = gmio_stl_read_file(model_filepath, NULL, &creator);
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
} }
/* Write the model to STL ascii format */ /* Write the model to STL ascii format */
{ {
gmio_stl_write_options_t options = {0}; struct gmio_stl_write_options options = {0};
const gmio_stl_mesh_t mesh = gmio_stl_data_mesh(&data); const struct gmio_stl_mesh mesh = gmio_stl_data_mesh(&data);
gmio_stlb_header_to_printable_string(&data.header, &header_str[0], '_'); gmio_stlb_header_to_printable_string(&data.header, &header_str[0], '_');
options.stla_solid_name = &header_str[0]; options.stla_solid_name = &header_str[0];
options.stla_float32_prec = 7; options.stla_float32_prec = 7;
options.stla_float32_format = GMIO_FLOAT_TEXT_FORMAT_SHORTEST_LOWERCASE; options.stla_float32_format = GMIO_FLOAT_TEXT_FORMAT_SHORTEST_LOWERCASE;
error = gmio_stl_write_file( error = gmio_stl_write_file(
GMIO_STL_FORMAT_ASCII, model_filepath_out, &mesh, NULL, &options); model_filepath_out, NULL, &mesh, GMIO_STL_FORMAT_ASCII, &options);
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
} }
/* Read the output STL ascii model */ /* Read the output STL ascii model */
{ {
char trim_header_str[sizeof(header_str)] = {0}; char trim_header_str[sizeof(header_str)] = {0};
gmio_stl_data_t data_stla = {0}; struct gmio_stl_data data_stla = {0};
gmio_stl_mesh_creator_t creator = gmio_stl_data_mesh_creator(&data_stla); struct gmio_stl_mesh_creator creator = gmio_stl_data_mesh_creator(&data_stla);
size_t i = 0; size_t i = 0;
strncpy(&trim_header_str[0], &header_str[0], sizeof(header_str)); strncpy(&trim_header_str[0], &header_str[0], sizeof(header_str));
gmio_string_trim_from_end(trim_header_str, sizeof(header_str)); gmio_string_trim_from_end(trim_header_str, sizeof(header_str));
error = gmio_stl_read_file(model_filepath_out, &creator, NULL); error = gmio_stl_read_file(model_filepath_out, NULL, &creator);
UTEST_ASSERT(error == GMIO_ERROR_OK); UTEST_ASSERT(error == GMIO_ERROR_OK);
UTEST_ASSERT(data.tri_array.count == data_stla.tri_array.count); UTEST_ASSERT(data.tri_array.count == data_stla.tri_array.count);
UTEST_ASSERT(strcmp(&trim_header_str[0], &data_stla.solid_name[0]) == 0); UTEST_ASSERT(strcmp(&trim_header_str[0], &data_stla.solid_name[0]) == 0);
for (i = 0; i < data.tri_array.count; ++i) { for (i = 0; i < data.tri_array.count; ++i) {
const gmio_stl_triangle_t* lhs = &data.tri_array.ptr[i]; const struct gmio_stl_triangle* lhs = &data.tri_array.ptr[i];
const gmio_stl_triangle_t* rhs = &data_stla.tri_array.ptr[i]; const struct gmio_stl_triangle* rhs = &data_stla.tri_array.ptr[i];
const gmio_bool_t tri_equal = gmio_stl_triangle_equal(lhs, rhs, 5); const gmio_bool_t tri_equal = gmio_stl_triangle_equal(lhs, rhs, 5);
UTEST_ASSERT(tri_equal); UTEST_ASSERT(tri_equal);
} }
@ -358,37 +359,37 @@ void generate_stlb_tests_models()
{ {
{ {
FILE* outfile = fopen("models/solid_empty.stlb", "wb"); FILE* outfile = fopen("models/solid_empty.stlb", "wb");
gmio_stream_t stream = gmio_stream_stdio(outfile); struct gmio_stream stream = gmio_stream_stdio(outfile);
gmio_stlb_write_header(&stream, GMIO_ENDIANNESS_LITTLE, NULL, 0); gmio_stlb_write_header(&stream, GMIO_ENDIANNESS_LITTLE, NULL, 0);
fclose(outfile); fclose(outfile);
} }
{ {
gmio_stl_mesh_t mesh = {0}; struct gmio_stl_mesh mesh = {0};
gmio_stl_triangle_t tri = { struct gmio_stl_triangle tri = {
{ 0.f, 0.f, 1.f }, /* normal */ { 0.f, 0.f, 1.f }, /* normal */
{ 0.f, 0.f, 0.f }, /* v1 */ { 0.f, 0.f, 0.f }, /* v1 */
{ 10.f, 0.f, 0.f }, /* v2 */ { 10.f, 0.f, 0.f }, /* v2 */
{ 5.f, 10.f, 0.f }, /* v3 */ { 5.f, 10.f, 0.f }, /* v3 */
0 /* attr */ 0 /* attr */
}; };
gmio_stl_data_t data = {0}; struct gmio_stl_data data = {0};
data.tri_array.ptr = &tri; data.tri_array.ptr = &tri;
data.tri_array.count = 1; data.tri_array.count = 1;
mesh = gmio_stl_data_mesh(&data); mesh = gmio_stl_data_mesh(&data);
gmio_stl_write_file( gmio_stl_write_file(
GMIO_STL_FORMAT_BINARY_LE,
"models/solid_one_facet.le_stlb", "models/solid_one_facet.le_stlb",
&mesh,
NULL, NULL,
&mesh,
GMIO_STL_FORMAT_BINARY_LE,
NULL); NULL);
gmio_stl_write_file( gmio_stl_write_file(
GMIO_STL_FORMAT_BINARY_BE,
"models/solid_one_facet.be_stlb", "models/solid_one_facet.be_stlb",
&mesh,
NULL, NULL,
&mesh,
GMIO_STL_FORMAT_BINARY_BE,
NULL); NULL);
} }
} }

44
src/gmio_core/transfer.h → tests/test_stla_stats.c
View File

@ -13,35 +13,31 @@
** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html". ** "http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html".
****************************************************************************/ ****************************************************************************/
/*! \file transfer.h #include "utest_assert.h"
* Declaration of gmio_transfer
*
* \addtogroup gmio_core
* @{
*/
#ifndef GMIO_TRANSFER_H #include "../src/gmio_stl/stla_stats.h"
#define GMIO_TRANSFER_H
#include "global.h" #include <stdio.h>
#include "memblock.h"
#include "stream.h"
#include "task_iface.h"
/*! Defines objects required for any transfer(read/write) operation */ static const char stl_jburkardt_sphere_filepath[] =
struct gmio_transfer "models/solid_jburkardt_sphere.stla";
const char* test_stla_stats()
{ {
/*! The stream object to be used for I/O */ FILE* stla_file = fopen(stl_jburkardt_sphere_filepath, "rb");
gmio_stream_t stream; struct gmio_rwargs rwargs = {0};
struct gmio_stla_stats stats = {0};
/*! The memory block used by the transfer for stream buffering */ rwargs.memblock = gmio_memblock_malloc(8 * 1024); /* 8Ko */
gmio_memblock_t memblock; rwargs.stream = gmio_stream_stdio(stla_file);
/*! The interface object by which the transfer task can be controlled */ stats = gmio_stla_stats_get(&rwargs, GMIO_STLA_STAT_FLAG_ALL);
gmio_task_iface_t task_iface;
};
typedef struct gmio_transfer gmio_transfer_t; gmio_memblock_deallocate(&rwargs.memblock);
fclose(stla_file);
#endif /* GMIO_TRANSFER_H */ UTEST_ASSERT(stats.facet_count == 228);
/*! @} */ /*UTEST_ASSERT(stats.size == 54297);*/
return NULL;
}