/* * Copyright (C) 2025 Linux Studio Plugins Project * (C) 2025 Vladimir Sadovnikov * * This file is part of lsp-runtime-lib * Created on: 23 июл. 2025 г. * * lsp-runtime-lib is free software: you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as published by * the Free Software Foundation, either version 3 of the License, or * any later version. * * lsp-runtime-lib is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License * along with lsp-runtime-lib. If not, see . */ #include #include #include #include #include #include #include namespace lsp { namespace { enum call_type_t { EV_BEGIN_OBJECT, EV_END_OBJECT, EV_END_OF_DATA, EV_ADD_VERTEX, EV_ADD_PARAM_VERTEX, EV_ADD_NORMAL, EV_ADD_TEXTURE_VERTEX, EV_ADD_FACE, EV_ADD_POINTS, EV_ADD_LINE }; typedef struct call_t { call_type_t type; union { struct { float x, y, z, w; } vertex; struct { float dx, dy, dz, dw; } normal; struct { float u, v, w; } texcoord; char *name; struct { size_t count; obj::index_t *v; obj::index_t *t; obj::index_t *n; } indices; }; } call_t; class ObjRecorder: public obj::IObjHandler { protected: lltl::parray vCalls; protected: call_t *add_call(call_type_t type, size_t bytes) { call_t *call = reinterpret_cast(malloc(sizeof(call_t) + bytes)); if (call == NULL) return NULL; if (!vCalls.add(call)) { free(call); return NULL; } bzero(call, sizeof(call_t)); call->type = type; switch (type) { case EV_BEGIN_OBJECT: call->name = reinterpret_cast(&call[1]); break; case EV_ADD_FACE: call->indices.v = reinterpret_cast(&call[1]); call->indices.t = &call->indices.v[bytes / (3 * sizeof(obj::index_t))]; call->indices.n = &call->indices.t[bytes / (3 * sizeof(obj::index_t))]; break; case EV_ADD_POINTS: call->indices.v = reinterpret_cast(&call[1]); break; case EV_ADD_LINE: call->indices.v = reinterpret_cast(&call[1]); call->indices.t = &call->indices.v[bytes / (2 * sizeof(obj::index_t))]; break; default: break; } return call; } public: ObjRecorder() { } virtual ~ObjRecorder() override { for (size_t i=0, n = vCalls.size(); iname, name, bytes); return STATUS_OK; } virtual status_t begin_object(const LSPString *name) override { return begin_object(name->get_utf8()); } virtual status_t end_object() override { return (add_call(EV_END_OBJECT, 0) != NULL) ? STATUS_OK : STATUS_NO_MEM; } virtual status_t end_of_data() override { return (add_call(EV_END_OF_DATA, 0) != NULL) ? STATUS_OK : STATUS_NO_MEM; } virtual ssize_t add_vertex(float x, float y, float z, float w) override { call_t *call = add_call(EV_ADD_VERTEX, 0); if (call == NULL) return STATUS_NO_MEM; call->vertex.x = x; call->vertex.y = y; call->vertex.z = z; call->vertex.w = w; return STATUS_OK; } virtual ssize_t add_param_vertex(float x, float y, float z, float w) override { call_t *call = add_call(EV_ADD_PARAM_VERTEX, 0); if (call == NULL) return STATUS_NO_MEM; call->vertex.x = x; call->vertex.y = y; call->vertex.z = z; call->vertex.w = w; return STATUS_OK; } virtual ssize_t add_normal(float nx, float ny, float nz, float nw) override { call_t *call = add_call(EV_ADD_NORMAL, 0); if (call == NULL) return STATUS_NO_MEM; call->normal.dx = nx; call->normal.dy = ny; call->normal.dz = nz; call->normal.dw = nw; return STATUS_OK; } virtual ssize_t add_texture_vertex(float u, float v, float w) override { call_t *call = add_call(EV_ADD_TEXTURE_VERTEX, 0); if (call == NULL) return STATUS_NO_MEM; call->texcoord.u = u; call->texcoord.v = v; call->texcoord.w = w; return STATUS_OK; } virtual ssize_t add_face(const obj::index_t *vv, const obj::index_t *vn, const obj::index_t *vt, size_t n) override { call_t *call = add_call(EV_ADD_FACE, n * sizeof(obj::index_t) * 3); if (call == NULL) return STATUS_NO_MEM; call->indices.count = n; memcpy(call->indices.v, vv, n * sizeof(obj::index_t)); memcpy(call->indices.t, vt, n * sizeof(obj::index_t)); memcpy(call->indices.n, vn, n * sizeof(obj::index_t)); return STATUS_OK; } virtual ssize_t add_points(const obj::index_t *vv, size_t n) override { call_t *call = add_call(EV_ADD_POINTS, n * sizeof(obj::index_t)); if (call == NULL) return STATUS_NO_MEM; call->indices.count = n; memcpy(call->indices.v, vv, n * sizeof(obj::index_t)); return STATUS_OK; } virtual ssize_t add_line(const obj::index_t *vv, const obj::index_t *vt, size_t n) override { call_t *call = add_call(EV_ADD_LINE, n * sizeof(obj::index_t) * 2); if (call == NULL) return STATUS_NO_MEM; call->indices.count = n; memcpy(call->indices.v, vv, n * sizeof(obj::index_t)); memcpy(call->indices.t, vt, n * sizeof(obj::index_t)); return STATUS_OK; } public: inline const call_t *get(size_t i) const { return vCalls.get(i); } }; } } /* namespace lsp */ UTEST_BEGIN("runtime.fmt.obj", compressor) status_t read_obj_file(ObjRecorder *data, const io::Path *path) { obj::PushParser parser; return parser.parse_file(data, path); } status_t read_compressed_obj_file(ObjRecorder *data, const io::Path *path) { obj::Decompressor parser; return parser.parse_file(data, path); } ssize_t compare(const ObjRecorder *a, const ObjRecorder *b) { for (size_t i=0; ; ++i) { const call_t *ca = a->get(i); const call_t *cb = b->get(i); if (ca == NULL) { if (cb == NULL) return -1; printf("Missing record #%d for second file\n", int(i)); return i; } else if (cb == NULL) { printf("Missing record #%d for first file\n", int(i)); return i; } if (ca->type != cb->type) { printf("Record #%d type %d does not match record type %d\n", int(i), int(ca->type), int(cb->type)); return i; } switch (ca->type) { case EV_BEGIN_OBJECT: if (strcmp(ca->name, cb->name) != 0) { printf("Record #%d object name '%s' does not match object name '%s'\n", int(i), ca->name, cb->name); return i; } break; case EV_ADD_VERTEX: if ((ca->vertex.x != cb->vertex.x) || (ca->vertex.y != cb->vertex.y) || (ca->vertex.z != cb->vertex.z) || (ca->vertex.w != cb->vertex.w)) { printf("Record #%d vertex {%f, %f, %f, %f} does not match vertex {%f, %f, %f, %f}\n", int(i), ca->vertex.x, ca->vertex.y, ca->vertex.z, ca->vertex.w, cb->vertex.x, cb->vertex.y, cb->vertex.z, cb->vertex.w); return i; } break; case EV_ADD_PARAM_VERTEX: if ((ca->vertex.x != cb->vertex.x) || (ca->vertex.y != cb->vertex.y) || (ca->vertex.z != cb->vertex.z) || (ca->vertex.w != cb->vertex.w)) { printf("Record #%d parameter vertex {%f, %f, %f, %f} does not match parameter vertex {%f, %f, %f, %f}\n", int(i), ca->vertex.x, ca->vertex.y, ca->vertex.z, ca->vertex.w, cb->vertex.x, cb->vertex.y, cb->vertex.z, cb->vertex.w); return i; } break; case EV_ADD_NORMAL: if ((ca->normal.dx != cb->normal.dx) || (ca->normal.dy != cb->normal.dy) || (ca->normal.dz != cb->normal.dz) || (ca->normal.dw != cb->normal.dw)) { printf("Record #%d normal {%f, %f, %f, %f} does not match normal {%f, %f, %f, %f}\n", int(i), ca->normal.dx, ca->normal.dy, ca->normal.dz, ca->normal.dw, cb->normal.dx, cb->normal.dy, cb->normal.dz, cb->normal.dw); return i; } break; case EV_ADD_TEXTURE_VERTEX: if ((ca->texcoord.u != cb->texcoord.u) || (ca->texcoord.v != cb->texcoord.v) || (ca->texcoord.w != cb->texcoord.w)) { printf("Record #%d normal {%f, %f, %f} does not match normal {%f, %f, %f}\n", int(i), ca->texcoord.u, ca->texcoord.v, ca->texcoord.w, cb->texcoord.u, cb->texcoord.v, cb->texcoord.w); return i; } break; case EV_ADD_FACE: if (ca->indices.count != cb->indices.count) { printf("Record #%d number of face indices %d does not match %d\n", int(i), int(ca->indices.count), int(cb->indices.count)); return i; } for (size_t j=0; jindices.count; ++j) { if (ca->indices.v[j] != cb->indices.v[j]) { printf("Record #%d face vertex index #%d value %d differs to %d\n", int(i), int(j), int(ca->indices.v[j]), int(cb->indices.v[j])); return i; } } for (size_t j=0; jindices.count; ++j) { if (ca->indices.t[j] != cb->indices.t[j]) { printf("Record #%d face texture index #%d value %d differs to %d\n", int(i), int(j), int(ca->indices.t[j]), int(cb->indices.t[j])); return i; } } for (size_t j=0; jindices.count; ++j) { if (ca->indices.n[j] != cb->indices.n[j]) { printf("Record #%d face normal index #%d value %d differs to %d\n", int(i), int(j), int(ca->indices.n[j]), int(cb->indices.n[j])); return i; } } break; case EV_ADD_POINTS: if (ca->indices.count != cb->indices.count) { printf("Record #%d number of point indices %d does not match %d\n", int(i), int(ca->indices.count), int(cb->indices.count)); return i; } for (size_t j=0; jindices.count; ++j) { if (ca->indices.v[j] != cb->indices.v[j]) { printf("Record #%d point vertex index #%d value %d differs to %d\n", int(i), int(j), int(ca->indices.v[j]), int(cb->indices.v[j])); return i; } } break; case EV_ADD_LINE: if (ca->indices.count != cb->indices.count) { printf("Record #%d number of line indices %d does not match %d\n", int(i), int(ca->indices.count), int(cb->indices.count)); return i; } for (size_t j=0; jindices.count; ++j) { if (ca->indices.v[j] != cb->indices.v[j]) { printf("Record #%d line vertex index #%d value %d differs to %d\n", int(i), int(j), int(ca->indices.v[j]), int(cb->indices.v[j])); return i; } } for (size_t j=0; jindices.count; ++j) { if (ca->indices.t[j] != cb->indices.t[j]) { printf("Record #%d line texture index #%d value %d differs to %d\n", int(i), int(j), int(ca->indices.t[j]), int(cb->indices.t[j])); return i; } } break; case EV_END_OF_DATA: case EV_END_OBJECT: default: break; } } return -1; } void test_compress_obj_file(const char *fname, const char *postfix) { io::Path src, dst; UTEST_ASSERT(src.fmt("%s/%s", resources(), fname) > 0); UTEST_ASSERT(dst.fmt("%s/utest-%s-%s.cobj", tempdir(), full_name(), postfix) > 0); printf("Compressing %s -> %s\n", src.as_native(), dst.as_native()); obj::Compressor c; obj::PushParser p; UTEST_ASSERT(c.set_buffer_size(7) == STATUS_OK); UTEST_ASSERT(c.open(&dst, io::File::FM_WRITE_NEW) == STATUS_OK); UTEST_ASSERT(p.parse_file(&c, &src) == STATUS_OK); UTEST_ASSERT(c.close() == STATUS_OK); const wssize_t src_size = src.size(); UTEST_ASSERT(src_size >= 0); const wssize_t dst_size = dst.size(); UTEST_ASSERT(dst_size >= 0); printf("Stats: uncompressed size = %d, compressed size = %d, ratio: %.3f\n", int(src_size), int(dst_size), double(src_size) / double(dst_size)); printf("Validating result...\n"); ObjRecorder osrc, odst; status_t res = read_obj_file(&osrc, &src); UTEST_ASSERT_MSG(res == STATUS_OK, "read_obj_file failed with code=%d", int(res)); res = read_compressed_obj_file(&odst, &dst); UTEST_ASSERT_MSG(res == STATUS_OK, "read_compressed_obj_file failed with code=%d", int(res)); ssize_t diff = compare(&osrc, &odst); UTEST_ASSERT_MSG(diff < 0, "Source and destination records #%d differ", int(diff)); } UTEST_MAIN { printf("Testing compression of complicated OBJ files...\n"); test_compress_obj_file("fmt/obj/parking.obj", "parking"); test_compress_obj_file("fmt/obj/coliseum.obj", "coliseum"); test_compress_obj_file("fmt/obj/forest.obj", "forest"); test_compress_obj_file("fmt/obj/cooling-tower.obj", "cooling-tower"); test_compress_obj_file("fmt/obj/church.obj", "church"); } UTEST_END