Blender  V3.3
dpxlib.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 1999-2002 David Hodson <hodsond@acm.org>. */
3 
10 #include "dpxlib.h"
11 #include "logmemfile.h"
12 
13 #include <math.h>
14 #include <stdio.h>
15 #include <stdlib.h>
16 #include <string.h>
17 #include <sys/types.h>
18 #include <time.h>
19 
20 #include "BLI_fileops.h"
21 #include "BLI_utildefines.h"
22 
23 #include "MEM_guardedalloc.h"
24 
25 /*
26  * For debug purpose
27  */
28 
29 static int verbose = 0;
30 
31 void dpxSetVerbose(int verbosity)
32 {
33  verbose = verbosity;
34 }
35 
36 /*
37  * Headers
38  */
39 
41  DpxMainHeader *header,
42  const char *filename,
43  const char *creator)
44 {
45  time_t fileClock;
46  struct tm *fileTime;
47 
48  memset(header, 0, sizeof(DpxMainHeader));
49 
50  /* --- File header --- */
52  header->fileHeader.offset = swap_uint(dpx->element[0].dataOffset, dpx->isMSB);
53  strcpy(header->fileHeader.version, "V2.0");
54  header->fileHeader.file_size = swap_uint(
55  dpx->element[0].dataOffset + dpx->height * getRowLength(dpx->width, dpx->element[0]),
56  dpx->isMSB);
57  header->fileHeader.ditto_key = 0;
59  sizeof(DpxFileHeader) + sizeof(DpxImageHeader) + sizeof(DpxOrientationHeader), dpx->isMSB);
61  dpx->isMSB);
63  strncpy(header->fileHeader.file_name, filename, 99);
64  header->fileHeader.file_name[99] = 0;
65  fileClock = time(NULL);
66  fileTime = localtime(&fileClock);
67  strftime(header->fileHeader.creation_date, 24, "%Y:%m:%d:%H:%M:%S%Z", fileTime);
68  header->fileHeader.creation_date[23] = 0;
69  strncpy(header->fileHeader.creator, creator, 99);
70  header->fileHeader.creator[99] = 0;
71  header->fileHeader.project[0] = 0;
72  header->fileHeader.copyright[0] = 0;
73  header->fileHeader.key = 0xFFFFFFFF;
74 
75  /* --- Image header --- */
76  header->imageHeader.orientation = 0;
78  header->imageHeader.pixels_per_line = swap_uint(dpx->width, dpx->isMSB);
79  header->imageHeader.lines_per_element = swap_uint(dpx->height, dpx->isMSB);
80 
81  /* Fills element */
82  header->imageHeader.element[0].data_sign = 0;
83  header->imageHeader.element[0].ref_low_data = swap_uint(dpx->element[0].refLowData, dpx->isMSB);
85  dpx->isMSB);
87  dpx->isMSB);
89  dpx->isMSB);
90  header->imageHeader.element[0].descriptor = dpx->element[0].descriptor;
91  header->imageHeader.element[0].transfer = dpx->element[0].transfer;
92  header->imageHeader.element[0].colorimetric = 0;
94  header->imageHeader.element[0].packing = swap_ushort(dpx->element[0].packing, dpx->isMSB);
95  header->imageHeader.element[0].encoding = 0;
96  header->imageHeader.element[0].data_offset = swap_uint(dpx->element[0].dataOffset, dpx->isMSB);
97  header->imageHeader.element[0].line_padding = 0;
98  header->imageHeader.element[0].element_padding = 0;
99  header->imageHeader.element[0].description[0] = 0;
100 
101  /* --- Orientation header --- */
102  /* we leave it blank */
103 
104  /* --- Television header --- */
115  header->televisionHeader.gamma = swap_float(dpx->gamma, dpx->isMSB);
121 }
122 
123 LogImageFile *dpxOpen(const unsigned char *byteStuff, int fromMemory, size_t bufferSize)
124 {
125  DpxMainHeader header;
126  LogImageFile *dpx = (LogImageFile *)MEM_mallocN(sizeof(LogImageFile), __func__);
127  const char *filepath = (const char *)byteStuff;
128  int i;
129 
130  if (dpx == NULL) {
131  if (verbose) {
132  printf("DPX: Failed to malloc dpx file structure.\n");
133  }
134  return NULL;
135  }
136 
137  /* zero the header */
138  memset(&header, 0, sizeof(DpxMainHeader));
139 
140  /* for close routine */
141  dpx->file = NULL;
142 
143  if (fromMemory == 0) {
144  /* byteStuff is then the filepath */
145  dpx->file = BLI_fopen(filepath, "rb");
146  if (dpx->file == NULL) {
147  if (verbose) {
148  printf("DPX: Failed to open file \"%s\".\n", filepath);
149  }
150  logImageClose(dpx);
151  return NULL;
152  }
153  /* not used in this case */
154  dpx->memBuffer = NULL;
155  dpx->memCursor = NULL;
156  dpx->memBufferSize = 0;
157  }
158  else {
159  dpx->memBuffer = (unsigned char *)byteStuff;
160  dpx->memCursor = (unsigned char *)byteStuff;
161  dpx->memBufferSize = bufferSize;
162  }
163 
164  if (logimage_fread(&header, sizeof(header), 1, dpx) == 0) {
165  if (verbose) {
166  printf("DPX: Not enough data for header in \"%s\".\n", byteStuff);
167  }
168  logImageClose(dpx);
169  return NULL;
170  }
171 
172  /* endianness determination */
173  if (header.fileHeader.magic_num == swap_uint(DPX_FILE_MAGIC, 1)) {
174  dpx->isMSB = 1;
175  if (verbose) {
176  printf("DPX: File is MSB.\n");
177  }
178  }
179  else if (header.fileHeader.magic_num == DPX_FILE_MAGIC) {
180  dpx->isMSB = 0;
181  if (verbose) {
182  printf("DPX: File is LSB.\n");
183  }
184  }
185  else {
186  if (verbose) {
187  printf("DPX: Bad magic number %u in \"%s\".\n", header.fileHeader.magic_num, byteStuff);
188  }
189  logImageClose(dpx);
190  return NULL;
191  }
192 
193  dpx->srcFormat = format_DPX;
195  size_t max_elements = ARRAY_SIZE(header.imageHeader.element);
196  if (dpx->numElements == 0 || dpx->numElements >= max_elements) {
197  if (verbose) {
198  printf("DPX: Wrong number of elements: %d\n", dpx->numElements);
199  }
200  logImageClose(dpx);
201  return NULL;
202  }
203 
204  dpx->width = swap_uint(header.imageHeader.pixels_per_line, dpx->isMSB);
205  dpx->height = swap_uint(header.imageHeader.lines_per_element, dpx->isMSB);
206 
207  if (dpx->width == 0 || dpx->height == 0) {
208  if (verbose) {
209  printf("DPX: Wrong image dimension: %dx%d\n", dpx->width, dpx->height);
210  }
211  logImageClose(dpx);
212  return NULL;
213  }
214 
215  dpx->depth = 0;
216 
217  for (i = 0; i < dpx->numElements; i++) {
218  dpx->element[i].descriptor = header.imageHeader.element[i].descriptor;
219 
220  switch (dpx->element[i].descriptor) {
221  case descriptor_Red:
222  case descriptor_Green:
223  case descriptor_Blue:
224  case descriptor_Alpha:
227  dpx->depth++;
228  dpx->element[i].depth = 1;
229  break;
230 
231  case descriptor_CbYCrY:
232  dpx->depth += 2;
233  dpx->element[i].depth = 2;
234  break;
235 
236  case descriptor_RGB:
237  case descriptor_CbYCr:
238  case descriptor_CbYACrYA:
239  dpx->depth += 3;
240  dpx->element[i].depth = 3;
241  break;
242 
243  case descriptor_RGBA:
244  case descriptor_ABGR:
245  case descriptor_CbYCrA:
246  dpx->depth += 4;
247  dpx->element[i].depth = 4;
248  break;
249 
250  case descriptor_Depth:
252  /* unsupported */
253  break;
254  }
255 
256  if (dpx->depth == 0 || dpx->depth > 4) {
257  if (verbose) {
258  printf("DPX: Unsupported image depth: %d\n", dpx->depth);
259  }
260  logImageClose(dpx);
261  return NULL;
262  }
263 
265  if (!ELEM(dpx->element[i].bitsPerSample, 1, 8, 10, 12, 16)) {
266  if (verbose) {
267  printf("DPX: Unsupported bitsPerSample for elements %d: %d\n",
268  i,
269  dpx->element[i].bitsPerSample);
270  }
271  logImageClose(dpx);
272  return NULL;
273  }
274 
275  dpx->element[i].maxValue = powf(2, dpx->element[i].bitsPerSample) - 1.0f;
276 
277  dpx->element[i].packing = swap_ushort(header.imageHeader.element[i].packing, dpx->isMSB);
278  if (dpx->element[i].packing > 2) {
279  if (verbose) {
280  printf("DPX: Unsupported packing for element %d: %d\n", i, dpx->element[i].packing);
281  }
282  logImageClose(dpx);
283  return NULL;
284  }
285 
286  /* Sometimes, the offset is not set correctly in the header */
287  dpx->element[i].dataOffset = swap_uint(header.imageHeader.element[i].data_offset, dpx->isMSB);
288  if (dpx->element[i].dataOffset == 0 && dpx->numElements == 1) {
289  dpx->element[i].dataOffset = swap_uint(header.fileHeader.offset, dpx->isMSB);
290  }
291 
292  if (dpx->element[i].dataOffset == 0) {
293  if (verbose) {
294  printf("DPX: Image header is corrupted.\n");
295  }
296  logImageClose(dpx);
297  return NULL;
298  }
299 
300  dpx->element[i].transfer = header.imageHeader.element[i].transfer;
301 
302  /* if undefined, assign default */
303  dpx->element[i].refLowData = swap_uint(header.imageHeader.element[i].ref_low_data, dpx->isMSB);
305  dpx->isMSB);
307  dpx->isMSB);
309  dpx->isMSB);
310 
311  switch (dpx->element[i].descriptor) {
312  case descriptor_Red:
313  case descriptor_Green:
314  case descriptor_Blue:
315  case descriptor_Alpha:
316  case descriptor_RGB:
317  case descriptor_RGBA:
318  case descriptor_ABGR:
319  if (dpx->element[i].refLowData == DPX_UNDEFINED_U32) {
320  dpx->element[i].refLowData = 0;
321  }
322 
323  if (dpx->element[i].refHighData == DPX_UNDEFINED_U32) {
324  dpx->element[i].refHighData = (unsigned int)dpx->element[i].maxValue;
325  }
326 
328  dpx->element[i].refLowQuantity = 0.0f;
329  }
330 
333  dpx->element[i].refHighQuantity = 2.048f;
334  }
335  else {
336  dpx->element[i].refHighQuantity = dpx->element[i].maxValue;
337  }
338  }
339 
340  break;
341 
344  case descriptor_CbYCrY:
345  case descriptor_CbYCr:
346  case descriptor_CbYACrYA:
347  case descriptor_CbYCrA:
348  if (dpx->element[i].refLowData == DPX_UNDEFINED_U32) {
349  dpx->element[i].refLowData = 16.0f / 255.0f * dpx->element[i].maxValue;
350  }
351 
352  if (dpx->element[i].refHighData == DPX_UNDEFINED_U32) {
353  dpx->element[i].refHighData = 235.0f / 255.0f * dpx->element[i].maxValue;
354  }
355 
357  dpx->element[i].refLowQuantity = 0.0f;
358  }
359 
361  dpx->element[i].refHighQuantity = 0.7f;
362  }
363 
364  break;
365 
366  default:
367  break;
368  }
369  }
370 
373  dpx->gamma = swap_float(header.televisionHeader.gamma, dpx->isMSB);
374 
377  (dpx->gamma <= 0 || IS_DPX_UNDEFINED_R32(dpx->gamma))) {
378  dpx->referenceBlack = 95.0f / 1023.0f * dpx->element[0].maxValue;
379  dpx->referenceWhite = 685.0f / 1023.0f * dpx->element[0].maxValue;
380  dpx->gamma = 1.7f;
381  }
382 
383  if (verbose) {
384  printf("size %d x %d x %d elements\n", dpx->width, dpx->height, dpx->numElements);
385  for (i = 0; i < dpx->numElements; i++) {
386  printf(" Element %d:\n", i);
387  printf(" Bits per sample: %d\n", dpx->element[i].bitsPerSample);
388  printf(" Depth: %d\n", dpx->element[i].depth);
389  printf(" Transfer characteristics: %d\n", dpx->element[i].transfer);
390  printf(" Packing: %d\n", dpx->element[i].packing);
391  printf(" Descriptor: %d\n", dpx->element[i].descriptor);
392  printf(" Data offset: %d\n", dpx->element[i].dataOffset);
393  printf(" Reference low data: %u\n", dpx->element[i].refLowData);
394  printf(" Reference low quantity: %f\n", dpx->element[i].refLowQuantity);
395  printf(" Reference high data: %u\n", dpx->element[i].refHighData);
396  printf(" Reference high quantity: %f\n", dpx->element[i].refHighQuantity);
397  printf("\n");
398  }
399 
400  printf("Gamma: %f\n", dpx->gamma);
401  printf("Reference black: %f\n", dpx->referenceBlack);
402  printf("Reference white: %f\n", dpx->referenceWhite);
403  printf("Orientation: %d\n", header.imageHeader.orientation);
404  printf("----------------------------\n");
405  }
406  return dpx;
407 }
408 
409 LogImageFile *dpxCreate(const char *filepath,
410  int width,
411  int height,
412  int bitsPerSample,
413  int hasAlpha,
414  int isLogarithmic,
415  int referenceWhite,
416  int referenceBlack,
417  float gamma,
418  const char *creator)
419 {
420  DpxMainHeader header;
421  const char *shortFilename = NULL;
422  unsigned char pad[6044];
423 
424  LogImageFile *dpx = (LogImageFile *)MEM_mallocN(sizeof(LogImageFile), __func__);
425  if (dpx == NULL) {
426  if (verbose) {
427  printf("DPX: Failed to malloc dpx file structure.\n");
428  }
429  return NULL;
430  }
431 
432  dpx->width = width;
433  dpx->height = height;
434  dpx->element[0].bitsPerSample = bitsPerSample;
435  dpx->element[0].dataOffset = 8092;
436  dpx->element[0].maxValue = powf(2, dpx->element[0].bitsPerSample) - 1.0f;
437  dpx->isMSB = 1;
438  dpx->numElements = 1;
439 
440  switch (bitsPerSample) {
441  case 8:
442  case 16:
443  dpx->element[0].packing = 0;
444  break;
445 
446  case 10:
447  case 12:
448  /* Packed Type A padding is the most common 10/12 bits format */
449  dpx->element[0].packing = 1;
450  break;
451 
452  default:
453  if (verbose) {
454  printf("DPX: bitsPerSample not supported: %d\n", bitsPerSample);
455  }
456  logImageClose(dpx);
457  return NULL;
458  }
459 
460  if (hasAlpha == 0) {
461  dpx->depth = 3;
462  dpx->element[0].depth = 3;
464  }
465  else {
466  dpx->depth = 4;
467  dpx->element[0].depth = 4;
469  }
470 
471  if (isLogarithmic == 0) {
472  dpx->element[0].transfer = transfer_Linear;
473  dpx->element[0].refHighQuantity = dpx->element[0].maxValue;
474  }
475  else {
477  dpx->element[0].refHighQuantity = 2.048f;
478  }
479 
480  dpx->element[0].refLowQuantity = 0;
481  dpx->element[0].refLowData = 0;
482  dpx->element[0].refHighData = dpx->element[0].maxValue;
483 
484  if (referenceWhite > 0) {
485  dpx->referenceWhite = referenceWhite;
486  }
487  else {
488  dpx->referenceWhite = 685.0f / 1023.0f * dpx->element[0].maxValue;
489  }
490 
491  if (referenceBlack > 0) {
492  dpx->referenceBlack = referenceBlack;
493  }
494  else {
495  dpx->referenceBlack = 95.0f / 1023.0f * dpx->element[0].maxValue;
496  }
497 
498  if (gamma > 0.0f) {
499  dpx->gamma = gamma;
500  }
501  else {
502  dpx->gamma = 1.7f;
503  }
504 
505  shortFilename = strrchr(filepath, PATHSEP_CHAR);
506  if (shortFilename == NULL) {
507  shortFilename = filepath;
508  }
509  else {
510  shortFilename++;
511  }
512 
513  dpx->file = BLI_fopen(filepath, "wb");
514 
515  if (dpx->file == NULL) {
516  if (verbose) {
517  printf("DPX: Couldn't open file %s\n", filepath);
518  }
519  logImageClose(dpx);
520  return NULL;
521  }
522 
523  fillDpxMainHeader(dpx, &header, shortFilename, creator);
524 
525  if (fwrite(&header, sizeof(header), 1, dpx->file) == 0) {
526  if (verbose) {
527  printf("DPX: Couldn't write image header\n");
528  }
529  logImageClose(dpx);
530  return NULL;
531  }
532 
533  /* Header should be rounded to next 8k block
534  * 6044 = 8092 - sizeof(DpxMainHeader) */
535  memset(&pad, 0, 6044);
536  if (fwrite(&pad, 6044, 1, dpx->file) == 0) {
537  if (verbose) {
538  printf("DPX: Couldn't write image header\n");
539  }
540  logImageClose(dpx);
541  return NULL;
542  }
543 
544  return dpx;
545 }
File and directory operations.
FILE * BLI_fopen(const char *filepath, const char *mode) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition: fileops.c:906
#define ARRAY_SIZE(arr)
#define ELEM(...)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei height
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei width
Read Guarded memory(de)allocation.
int pad[32 - sizeof(int)]
#define powf(x, y)
Definition: cuda/compat.h:103
double time
void dpxSetVerbose(int verbosity)
Definition: dpxlib.c:31
static int verbose
Definition: dpxlib.c:29
static void fillDpxMainHeader(LogImageFile *dpx, DpxMainHeader *header, const char *filename, const char *creator)
Definition: dpxlib.c:40
LogImageFile * dpxCreate(const char *filepath, int width, int height, int bitsPerSample, int hasAlpha, int isLogarithmic, int referenceWhite, int referenceBlack, float gamma, const char *creator)
Definition: dpxlib.c:409
LogImageFile * dpxOpen(const unsigned char *byteStuff, int fromMemory, size_t bufferSize)
Definition: dpxlib.c:123
#define DPX_UNDEFINED_U32
Definition: dpxlib.h:23
#define DPX_UNDEFINED_U8
Definition: dpxlib.h:21
#define DPX_UNDEFINED_R32
Definition: dpxlib.h:24
#define IS_DPX_UNDEFINED_R32(x)
Definition: dpxlib.h:25
#define DPX_FILE_MAGIC
Definition: dpxlib.h:20
void logImageClose(LogImageFile *logImage)
Definition: logImageCore.c:175
size_t getRowLength(size_t width, LogImageElement logElement)
Definition: logImageCore.c:197
@ format_DPX
Definition: logImageCore.h:39
@ descriptor_Chrominance
Definition: logImageCore.h:151
@ descriptor_CbYCr
Definition: logImageCore.h:159
@ descriptor_Red
Definition: logImageCore.h:146
@ descriptor_Composite
Definition: logImageCore.h:153
@ descriptor_Depth
Definition: logImageCore.h:152
@ descriptor_CbYCrA
Definition: logImageCore.h:160
@ descriptor_Luminance
Definition: logImageCore.h:150
@ descriptor_Green
Definition: logImageCore.h:147
@ descriptor_ABGR
Definition: logImageCore.h:156
@ descriptor_CbYCrY
Definition: logImageCore.h:157
@ descriptor_Blue
Definition: logImageCore.h:148
@ descriptor_RGB
Definition: logImageCore.h:154
@ descriptor_CbYACrYA
Definition: logImageCore.h:158
@ descriptor_Alpha
Definition: logImageCore.h:149
@ descriptor_RGBA
Definition: logImageCore.h:155
BLI_INLINE float swap_float(float x, int swap)
Definition: logImageCore.h:224
@ transfer_PrintingDensity
Definition: logImageCore.h:104
@ transfer_Linear
Definition: logImageCore.h:105
@ transfer_Logarithmic
Definition: logImageCore.h:106
BLI_INLINE unsigned short swap_ushort(unsigned short x, int swap)
Definition: logImageCore.h:204
#define PATHSEP_CHAR
Definition: logImageCore.h:25
BLI_INLINE unsigned int swap_uint(unsigned int x, int swap)
Definition: logImageCore.h:214
int logimage_fread(void *buffer, size_t size, unsigned int count, LogImageFile *logFile)
Definition: logmemfile.c:57
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
unsigned int line_padding
Definition: dpxlib.h:59
unsigned int ref_low_data
Definition: dpxlib.h:48
float ref_high_quantity
Definition: dpxlib.h:51
unsigned int element_padding
Definition: dpxlib.h:60
unsigned int data_offset
Definition: dpxlib.h:58
unsigned char bits_per_sample
Definition: dpxlib.h:55
unsigned short encoding
Definition: dpxlib.h:57
unsigned short packing
Definition: dpxlib.h:56
unsigned char colorimetric
Definition: dpxlib.h:54
unsigned char transfer
Definition: dpxlib.h:53
unsigned int ref_high_data
Definition: dpxlib.h:50
float ref_low_quantity
Definition: dpxlib.h:49
unsigned int data_sign
Definition: dpxlib.h:47
char description[32]
Definition: dpxlib.h:61
unsigned char descriptor
Definition: dpxlib.h:52
unsigned int file_size
Definition: dpxlib.h:32
unsigned int magic_num
Definition: dpxlib.h:29
char copyright[200]
Definition: dpxlib.h:41
char version[8]
Definition: dpxlib.h:31
unsigned int user_data_size
Definition: dpxlib.h:36
unsigned int key
Definition: dpxlib.h:42
unsigned int ind_hdr_size
Definition: dpxlib.h:35
char file_name[100]
Definition: dpxlib.h:37
char project[200]
Definition: dpxlib.h:40
unsigned int offset
Definition: dpxlib.h:30
unsigned int ditto_key
Definition: dpxlib.h:33
unsigned int gen_hdr_size
Definition: dpxlib.h:34
char creation_date[24]
Definition: dpxlib.h:38
char creator[100]
Definition: dpxlib.h:39
DpxElementHeader element[8]
Definition: dpxlib.h:69
unsigned int lines_per_element
Definition: dpxlib.h:68
unsigned int pixels_per_line
Definition: dpxlib.h:67
unsigned short elements_per_image
Definition: dpxlib.h:66
unsigned short orientation
Definition: dpxlib.h:65
DpxFileHeader fileHeader
Definition: dpxlib.h:127
DpxTelevisionHeader televisionHeader
Definition: dpxlib.h:131
DpxImageHeader imageHeader
Definition: dpxlib.h:128
unsigned char interlace
Definition: dpxlib.h:109
unsigned int time_code
Definition: dpxlib.h:107
unsigned char padding
Definition: dpxlib.h:112
float horizontal_sample_rate
Definition: dpxlib.h:113
unsigned int user_bits
Definition: dpxlib.h:108
float vertical_sample_rate
Definition: dpxlib.h:114
unsigned char field_number
Definition: dpxlib.h:110
float integration_times
Definition: dpxlib.h:122
unsigned char video_signal
Definition: dpxlib.h:111
unsigned int refLowData
Definition: logImageCore.h:50
float refLowQuantity
Definition: logImageCore.h:52
float refHighQuantity
Definition: logImageCore.h:53
unsigned int refHighData
Definition: logImageCore.h:51
uintptr_t memBufferSize
Definition: logImageCore.h:73
float referenceWhite
Definition: logImageCore.h:67
unsigned char * memBuffer
Definition: logImageCore.h:72
unsigned char * memCursor
Definition: logImageCore.h:74
LogImageElement element[8]
Definition: logImageCore.h:63
float referenceBlack
Definition: logImageCore.h:66