Blender V5.3
customdata_file.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cstdio>
10#include <cstdlib>
11#include <cstring>
12
13#include "MEM_guardedalloc.h"
14
15#include "BLI_endian_defines.hh"
16#include "BLI_fileops.hh"
17#include "BLI_string.hh"
18#include "BLI_utildefines.hh"
19
20#include "BKE_customdata_file.h"
21
22namespace blender {
23
24/************************* File Format Definitions ***************************/
25
26#define CDF_ENDIAN_LITTLE 0
27#define CDF_ENDIAN_BIG 1
28
29#define CDF_DATA_FLOAT 0
30
32 char ID[4]; /* "BCDF" */
33 char endian; /* little, big */
34 char version; /* non-compatible versions */
35 char subversion; /* compatible sub versions */
36 char pad; /* padding */
37
38 int structbytes; /* size of this struct in bytes */
39 int type; /* image, mesh */
40 int totlayer; /* number of layers in the file */
41};
42
44 int structbytes; /* size of this struct in bytes */
45 int width; /* image width */
46 int height; /* image height */
47 int tile_size; /* tile size (required power of 2) */
48};
49
51 int structbytes; /* size of this struct in bytes */
52};
53
55 int structbytes; /* size of this struct in bytes */
56 int datatype; /* only float for now */
57 uint64_t datasize; /* size of data in layer */
58 int type; /* layer type */
59 char name[CDF_LAYER_NAME_MAX]; /* layer name */
60};
61
62/**************************** Other Definitions ******************************/
63
64#define CDF_VERSION 0
65#define CDF_SUBVERSION 0
66#define CDF_TILE_SIZE 64
67
84
85/********************************* Create/Free *******************************/
86
87static int cdf_endian()
88{
89 BLI_STATIC_ASSERT(ENDIAN_ORDER == L_ENDIAN, "Blender only builds on little endian systems")
90 return CDF_ENDIAN_LITTLE;
91}
92
94{
95 CDataFile *cdf = MEM_new_zeroed<CDataFile>("CDataFile");
96
97 cdf->type = type;
98
99 return cdf;
100}
101
103{
104 cdf_read_close(cdf);
105 cdf_write_close(cdf);
106
107 if (cdf->layer) {
108 MEM_delete(cdf->layer);
109 }
110
111 MEM_delete(cdf);
112}
113
114/********************************* Read/Write ********************************/
115
116static bool cdf_read_header(CDataFile *cdf)
117{
118 CDataFileHeader *header;
122 FILE *f = cdf->readf;
123 size_t offset = 0;
124 int a;
125
126 header = &cdf->header;
127
128 if (!fread(header, sizeof(CDataFileHeader), 1, cdf->readf)) {
129 return false;
130 }
131
132 if (memcmp(header->ID, "BCDF", sizeof(header->ID)) != 0) {
133 return false;
134 }
135 if (header->version > CDF_VERSION) {
136 return false;
137 }
138 if (header->endian != cdf_endian()) {
139 return false;
140 }
141
142 header->endian = cdf_endian();
143
144 /* NOTE: this is endianness-sensitive.
145 * Some non-char `header` data would need to be switched. */
146
147 if (!ELEM(header->type, CDF_TYPE_IMAGE, CDF_TYPE_MESH)) {
148 return false;
149 }
150
151 offset += header->structbytes;
152 header->structbytes = sizeof(CDataFileHeader);
153
154 if (BLI_fseek(f, offset, SEEK_SET) != 0) {
155 return false;
156 }
157
158 if (header->type == CDF_TYPE_IMAGE) {
159 image = &cdf->btype.image;
160 if (!fread(image, sizeof(CDataFileImageHeader), 1, f)) {
161 return false;
162 }
163
164 /* NOTE: this is endianness-sensitive.
165 * Some non-char `image` data would need to be switched. */
166
167 offset += image->structbytes;
168 image->structbytes = sizeof(CDataFileImageHeader);
169 }
170 else if (header->type == CDF_TYPE_MESH) {
171 mesh = &cdf->btype.mesh;
172 if (!fread(mesh, sizeof(CDataFileMeshHeader), 1, f)) {
173 return false;
174 }
175
176 /* NOTE: this is endianness-sensitive.
177 * Some non-char `mesh` data would need to be switched. */
178
179 offset += mesh->structbytes;
180 mesh->structbytes = sizeof(CDataFileMeshHeader);
181 }
182
183 if (BLI_fseek(f, offset, SEEK_SET) != 0) {
184 return false;
185 }
186
187 cdf->layer = MEM_new_array_zeroed<CDataFileLayer>(header->totlayer, "CDataFileLayer");
188 cdf->totlayer = header->totlayer;
189
190 if (!cdf->layer) {
191 return false;
192 }
193
194 for (a = 0; a < header->totlayer; a++) {
195 layer = &cdf->layer[a];
196
197 if (!fread(layer, sizeof(CDataFileLayer), 1, f)) {
198 return false;
199 }
200
201 /* NOTE: this is endianness-sensitive.
202 * Some non-char `layer` data would need to be switched. */
203
204 if (layer->datatype != CDF_DATA_FLOAT) {
205 return false;
206 }
207
208 offset += layer->structbytes;
209 layer->structbytes = sizeof(CDataFileLayer);
210
211 if (BLI_fseek(f, offset, SEEK_SET) != 0) {
212 return false;
213 }
214 }
215
216 cdf->dataoffset = offset;
217
218 return true;
219}
220
222{
223 CDataFileHeader *header;
227 FILE *f = cdf->writef;
228 int a;
229
230 header = &cdf->header;
231
232 if (!fwrite(header, sizeof(CDataFileHeader), 1, f)) {
233 return false;
234 }
235
236 if (header->type == CDF_TYPE_IMAGE) {
237 image = &cdf->btype.image;
238 if (!fwrite(image, sizeof(CDataFileImageHeader), 1, f)) {
239 return false;
240 }
241 }
242 else if (header->type == CDF_TYPE_MESH) {
243 mesh = &cdf->btype.mesh;
244 if (!fwrite(mesh, sizeof(CDataFileMeshHeader), 1, f)) {
245 return false;
246 }
247 }
248
249 for (a = 0; a < header->totlayer; a++) {
250 layer = &cdf->layer[a];
251
252 if (!fwrite(layer, sizeof(CDataFileLayer), 1, f)) {
253 return false;
254 }
255 }
256
257 return true;
258}
259
260bool cdf_read_open(CDataFile *cdf, const char *filepath)
261{
262 FILE *f;
263
264 f = BLI_fopen(filepath, "rb");
265 if (!f) {
266 return false;
267 }
268
269 cdf->readf = f;
270
271 if (!cdf_read_header(cdf)) {
272 cdf_read_close(cdf);
273 return false;
274 }
275
276 if (cdf->header.type != cdf->type) {
277 cdf_read_close(cdf);
278 return false;
279 }
280
281 return true;
282}
283
285{
286 size_t offset;
287 int a;
288
289 /* seek to right location in file */
290 offset = cdf->dataoffset;
291 for (a = 0; a < cdf->totlayer; a++) {
292 if (&cdf->layer[a] == blay) {
293 break;
294 }
295
296 offset += cdf->layer[a].datasize;
297 }
298
299 return (BLI_fseek(cdf->readf, offset, SEEK_SET) == 0);
300}
301
302bool cdf_read_data(CDataFile *cdf, uint size, void *data)
303{
304 /* read data */
305 if (!fread(data, size, 1, cdf->readf)) {
306 return false;
307 }
308
309 /* NOTE: this is endianness-sensitive.
310 * `data` would need to be switched. */
311
312 return true;
313}
314
316{
317 if (cdf->readf) {
318 fclose(cdf->readf);
319 cdf->readf = nullptr;
320 }
321}
322
323bool cdf_write_open(CDataFile *cdf, const char *filepath)
324{
325 CDataFileHeader *header;
328 FILE *f;
329
330 f = BLI_fopen(filepath, "wb");
331 if (!f) {
332 return false;
333 }
334
335 cdf->writef = f;
336
337 /* Fill header. */
338 header = &cdf->header;
339 /* Copy "BCDF" (string terminator out of range). */
340 header->ID[0] = 'B';
341 header->ID[1] = 'C';
342 header->ID[2] = 'D';
343 header->ID[3] = 'F';
344 header->endian = cdf_endian();
345 header->version = CDF_VERSION;
346 header->subversion = CDF_SUBVERSION;
347
348 header->structbytes = sizeof(CDataFileHeader);
349 header->type = cdf->type;
350 header->totlayer = cdf->totlayer;
351
352 if (cdf->type == CDF_TYPE_IMAGE) {
353 /* fill image header */
354 image = &cdf->btype.image;
355 image->structbytes = sizeof(CDataFileImageHeader);
356 image->tile_size = CDF_TILE_SIZE;
357 }
358 else if (cdf->type == CDF_TYPE_MESH) {
359 /* fill mesh header */
360 mesh = &cdf->btype.mesh;
361 mesh->structbytes = sizeof(CDataFileMeshHeader);
362 }
363
364 cdf_write_header(cdf);
365
366 return true;
367}
368
369bool cdf_write_layer(CDataFile * /*cdf*/, CDataFileLayer * /*blay*/)
370{
371 return true;
372}
373
374bool cdf_write_data(CDataFile *cdf, uint size, const void *data)
375{
376 /* write data */
377 if (!fwrite(data, size, 1, cdf->writef)) {
378 return false;
379 }
380
381 return true;
382}
383
385{
386 if (cdf->writef) {
387 fclose(cdf->writef);
388 cdf->writef = nullptr;
389 }
390}
391
392void cdf_remove(const char *filepath)
393{
394 BLI_delete(filepath, false, false);
395}
396
397/********************************** Layers ***********************************/
398
399CDataFileLayer *cdf_layer_find(CDataFile *cdf, int type, const char *name)
400{
402 int a;
403
404 for (a = 0; a < cdf->totlayer; a++) {
405 layer = &cdf->layer[a];
406
407 if (layer->type == type && STREQ(layer->name, name)) {
408 return layer;
409 }
410 }
411
412 return nullptr;
413}
414
415CDataFileLayer *cdf_layer_add(CDataFile *cdf, int type, const char *name, size_t datasize)
416{
417 CDataFileLayer *newlayer, *layer;
418
419 /* expand array */
420 newlayer = MEM_new_array_zeroed<CDataFileLayer>(size_t(cdf->totlayer) + 1, "CDataFileLayer");
421 if (cdf->totlayer > 0) {
422 memcpy(newlayer, cdf->layer, sizeof(CDataFileLayer) * cdf->totlayer);
423 }
424 cdf->layer = newlayer;
425
426 cdf->totlayer++;
427
428 /* fill in new layer */
429 layer = &cdf->layer[cdf->totlayer - 1];
430 layer->structbytes = sizeof(CDataFileLayer);
431 layer->datatype = CDF_DATA_FLOAT;
432 layer->datasize = datasize;
433 layer->type = type;
434 STRNCPY(layer->name, name);
435
436 return layer;
437}
438
439} // namespace blender
#define CDF_TYPE_MESH
#define CDF_LAYER_NAME_MAX
#define CDF_TYPE_IMAGE
#define L_ENDIAN
#define ENDIAN_ORDER
File and directory operations.
Read Blender memory allocation and freeing.
#define ELEM(...)
#define STREQ(a, b)
#define CDF_ENDIAN_LITTLE
#define CDF_TILE_SIZE
#define CDF_DATA_FLOAT
#define CDF_VERSION
#define CDF_SUBVERSION
#define layer
BMesh Iterators.
void cdf_write_close(CDataFile *cdf)
unsigned __int64 uint64_t
Definition BKE_text.h:91
bool cdf_read_data(CDataFile *cdf, unsigned int size, void *data)
BLI_STATIC_ASSERT(ARRAY_SIZE(data_mode_strings)==CTX_MODE_NUM+1, "Must have a string for each context mode") const char *CTX_data_mode_string(const bContext *C)
char * STRNCPY(char(&dst)[N], const char *src)
unsigned int uint
Definition BKE_text.h:55
bool cdf_write_layer(CDataFile *cdf, CDataFileLayer *blay)
FILE * BLI_fopen(const char *filepath, const char *mode) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
int BLI_fseek(FILE *stream, int64_t offset, int whence)
Definition storage.cc:201
static bool cdf_write_header(CDataFile *cdf)
bool cdf_write_data(CDataFile *cdf, unsigned int size, const void *data)
void cdf_free(CDataFile *cdf)
bool cdf_read_open(CDataFile *cdf, const char *filepath)
static int cdf_endian()
void cdf_remove(const char *filepath)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
BMesh const char void * data
int BLI_delete(const char *path, bool dir, bool recursive) ATTR_NONNULL()
bool cdf_read_layer(CDataFile *cdf, const CDataFileLayer *blay)
CDataFileLayer * cdf_layer_find(CDataFile *cdf, int type, const char *name)
CDataFileLayer * cdf_layer_add(CDataFile *cdf, int type, const char *name, size_t datasize)
CDataFile * cdf_create(int type)
static bool cdf_read_header(CDataFile *cdf)
bool cdf_write_open(CDataFile *cdf, const char *filepath)
void cdf_read_close(CDataFile *cdf)
void * MEM_new_array_zeroed(size_t len, size_t size, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1
char name[CDF_LAYER_NAME_MAX]
CDataFileLayer * layer
CDataFileHeader header
union blender::CDataFile::@046371354302373211127230047060037177224114375037 btype