1 /* vim: set ts=8 sw=8 noexpandtab: */
3 // Copyright (C) 2009 Mozilla Foundation
4 // Copyright (C) 1998-2007 Marti Maria
6 // Permission is hereby granted, free of charge, to any person obtaining
7 // a copy of this software and associated documentation files (the "Software"),
8 // to deal in the Software without restriction, including without limitation
9 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 // and/or sell copies of the Software, and to permit persons to whom the Software
11 // is furnished to do so, subject to the following conditions:
13 // The above copyright notice and this permission notice shall be included in
14 // all copies or substantial portions of the Software.
16 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
18 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
20 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 #include <string.h> //memset
30 /* It might be worth having a unified limit on content controlled
31 * allocation per profile. This would remove the need for many
32 * of the arbitrary limits that we used */
34 typedef uint32_t be32
;
35 typedef uint16_t be16
;
39 /* __builtin_bswap isn't available in older gccs
40 * so open code it for now */
41 static be32
cpu_to_be32(int32_t v
)
43 #ifdef IS_LITTLE_ENDIAN
44 return ((v
& 0xff) << 24) | ((v
& 0xff00) << 8) | ((v
& 0xff0000) >> 8) | ((v
& 0xff000000) >> 24);
45 //return __builtin_bswap32(v);
51 static uint32_t be32_to_cpu(be32 v
)
53 #ifdef IS_LITTLE_ENDIAN
54 return ((v
& 0xff) << 24) | ((v
& 0xff00) << 8) | ((v
& 0xff0000) >> 8) | ((v
& 0xff000000) >> 24);
55 //return __builtin_bswap32(v);
61 static uint16_t be16_to_cpu(be16 v
)
63 #ifdef IS_LITTLE_ENDIAN
64 return ((v
& 0xff) << 8) | ((v
& 0xff00) >> 8);
70 /* a wrapper around the memory that we are going to parse
71 * into a qcms_profile */
74 const unsigned char *buf
;
77 const char *invalid_reason
;
80 static void invalid_source(struct mem_source
*mem
, const char *reason
)
83 mem
->invalid_reason
= reason
;
86 static uint32_t read_u32(struct mem_source
*mem
, size_t offset
)
88 /* Subtract from mem->size instead of the more intuitive adding to offset.
89 * This avoids overflowing offset. The subtraction is safe because
90 * mem->size is guaranteed to be > 4 */
91 if (offset
> mem
->size
- 4) {
92 invalid_source(mem
, "Invalid offset");
96 memcpy(&k
, mem
->buf
+ offset
, sizeof(k
));
97 return be32_to_cpu(k
);
101 static uint16_t read_u16(struct mem_source
*mem
, size_t offset
)
103 if (offset
> mem
->size
- 2) {
104 invalid_source(mem
, "Invalid offset");
108 memcpy(&k
, mem
->buf
+ offset
, sizeof(k
));
109 return be16_to_cpu(k
);
113 static uint8_t read_u8(struct mem_source
*mem
, size_t offset
)
115 if (offset
> mem
->size
- 1) {
116 invalid_source(mem
, "Invalid offset");
119 return *(uint8_t*)(mem
->buf
+ offset
);
123 static s15Fixed16Number
read_s15Fixed16Number(struct mem_source
*mem
, size_t offset
)
125 return read_u32(mem
, offset
);
128 static uInt8Number
read_uInt8Number(struct mem_source
*mem
, size_t offset
)
130 return read_u8(mem
, offset
);
133 static uInt16Number
read_uInt16Number(struct mem_source
*mem
, size_t offset
)
135 return read_u16(mem
, offset
);
138 #define BAD_VALUE_PROFILE NULL
139 #define INVALID_PROFILE NULL
140 #define NO_MEM_PROFILE NULL
142 /* An arbitrary 4MB limit on profile size */
143 #define MAX_PROFILE_SIZE 1024*1024*4
144 #define MAX_TAG_COUNT 1024
146 static void check_CMM_type_signature(struct mem_source
*src
)
148 //uint32_t CMM_type_signature = read_u32(src, 4);
151 static void check_profile_version(struct mem_source
*src
)
154 uint8_t major_revision = read_u8(src, 8 + 0);
155 uint8_t minor_revision = read_u8(src, 8 + 1);
157 uint8_t reserved1
= read_u8(src
, 8 + 2);
158 uint8_t reserved2
= read_u8(src
, 8 + 3);
159 /* Checking the version doesn't buy us anything
160 if (major_revision != 0x4) {
161 if (major_revision > 0x2)
162 invalid_source(src, "Unsupported major revision");
163 if (minor_revision > 0x40)
164 invalid_source(src, "Unsupported minor revision");
167 if (reserved1
!= 0 || reserved2
!= 0)
168 invalid_source(src
, "Invalid reserved bytes");
171 #define INPUT_DEVICE_PROFILE 0x73636e72 // 'scnr'
172 #define DISPLAY_DEVICE_PROFILE 0x6d6e7472 // 'mntr'
173 #define OUTPUT_DEVICE_PROFILE 0x70727472 // 'prtr'
174 #define DEVICE_LINK_PROFILE 0x6c696e6b // 'link'
175 #define COLOR_SPACE_PROFILE 0x73706163 // 'spac'
176 #define ABSTRACT_PROFILE 0x61627374 // 'abst'
177 #define NAMED_COLOR_PROFILE 0x6e6d636c // 'nmcl'
179 static void read_class_signature(qcms_profile
*profile
, struct mem_source
*mem
)
181 profile
->class = read_u32(mem
, 12);
182 switch (profile
->class) {
183 case DISPLAY_DEVICE_PROFILE
:
184 case INPUT_DEVICE_PROFILE
:
185 case OUTPUT_DEVICE_PROFILE
:
186 case COLOR_SPACE_PROFILE
:
189 invalid_source(mem
, "Invalid Profile/Device Class signature");
193 static void read_color_space(qcms_profile
*profile
, struct mem_source
*mem
)
195 profile
->color_space
= read_u32(mem
, 16);
196 switch (profile
->color_space
) {
201 invalid_source(mem
, "Unsupported colorspace");
205 static void read_pcs(qcms_profile
*profile
, struct mem_source
*mem
)
207 profile
->pcs
= read_u32(mem
, 20);
208 switch (profile
->pcs
) {
213 invalid_source(mem
, "Unsupported pcs");
228 static struct tag_index
read_tag_table(qcms_profile
*profile
, struct mem_source
*mem
)
230 struct tag_index index
= {0, NULL
};
233 index
.count
= read_u32(mem
, 128);
234 if (index
.count
> MAX_TAG_COUNT
) {
235 invalid_source(mem
, "max number of tags exceeded");
239 index
.tags
= malloc(sizeof(struct tag
)*index
.count
);
241 for (i
= 0; i
< index
.count
; i
++) {
242 index
.tags
[i
].signature
= read_u32(mem
, 128 + 4 + 4*i
*3);
243 index
.tags
[i
].offset
= read_u32(mem
, 128 + 4 + 4*i
*3 + 4);
244 index
.tags
[i
].size
= read_u32(mem
, 128 + 4 + 4*i
*3 + 8);
251 // Checks a profile for obvious inconsistencies and returns
252 // true if the profile looks bogus and should probably be
254 qcms_bool
qcms_profile_is_bogus(qcms_profile
*profile
)
256 float sum
[3], target
[3], tolerance
[3];
257 float rX
, rY
, rZ
, gX
, gY
, gZ
, bX
, bY
, bZ
;
261 // We currently only check the bogosity of RGB profiles
262 if (profile
->color_space
!= RGB_SIGNATURE
)
265 if (qcms_supports_iccv4
&& (profile
->A2B0
|| profile
->B2A0
))
268 rX
= s15Fixed16Number_to_float(profile
->redColorant
.X
);
269 rY
= s15Fixed16Number_to_float(profile
->redColorant
.Y
);
270 rZ
= s15Fixed16Number_to_float(profile
->redColorant
.Z
);
272 gX
= s15Fixed16Number_to_float(profile
->greenColorant
.X
);
273 gY
= s15Fixed16Number_to_float(profile
->greenColorant
.Y
);
274 gZ
= s15Fixed16Number_to_float(profile
->greenColorant
.Z
);
276 bX
= s15Fixed16Number_to_float(profile
->blueColorant
.X
);
277 bY
= s15Fixed16Number_to_float(profile
->blueColorant
.Y
);
278 bZ
= s15Fixed16Number_to_float(profile
->blueColorant
.Z
);
280 // Check if any of the XYZ values are negative (see mozilla bug 498245)
281 // CIEXYZ tristimulus values cannot be negative according to the spec.
283 (rX
< 0) || (rY
< 0) || (rZ
< 0) ||
284 (gX
< 0) || (gY
< 0) || (gZ
< 0) ||
285 (bX
< 0) || (bY
< 0) || (bZ
< 0);
291 // Sum the values; they should add up to something close to white
292 sum
[0] = rX
+ gX
+ bX
;
293 sum
[1] = rY
+ gY
+ bY
;
294 sum
[2] = rZ
+ gZ
+ bZ
;
296 #if defined (_MSC_VER)
297 #pragma warning(push)
298 /* Disable double to float truncation warning 4305 */
299 #pragma warning(disable:4305)
301 // Build our target vector (see mozilla bug 460629)
306 // Our tolerance vector - Recommended by Chris Murphy based on
307 // conversion from the LAB space criterion of no more than 3 in any one
308 // channel. This is similar to, but slightly more tolerant than Adobe's
314 #if defined (_MSC_VER)
315 /* Restore warnings */
318 // Compare with our tolerance
319 for (i
= 0; i
< 3; ++i
) {
320 if (!(((sum
[i
] - tolerance
[i
]) <= target
[i
]) &&
321 ((sum
[i
] + tolerance
[i
]) >= target
[i
])))
329 #define TAG_bXYZ 0x6258595a
330 #define TAG_gXYZ 0x6758595a
331 #define TAG_rXYZ 0x7258595a
332 #define TAG_rTRC 0x72545243
333 #define TAG_bTRC 0x62545243
334 #define TAG_gTRC 0x67545243
335 #define TAG_kTRC 0x6b545243
336 #define TAG_A2B0 0x41324230
337 #define TAG_B2A0 0x42324130
338 #define TAG_CHAD 0x63686164
339 #define TAG_desc 0x64657363
340 #define TAG_vcgt 0x76636774
342 static struct tag
*find_tag(struct tag_index index
, uint32_t tag_id
)
346 for (i
= 0; i
< index
.count
; i
++) {
347 if (index
.tags
[i
].signature
== tag_id
)
348 return &index
.tags
[i
];
354 #define DESC_TYPE 0x64657363 // 'desc'
355 #define MLUC_TYPE 0x6d6c7563 // 'mluc'
356 #define MMOD_TYPE 0x6D6D6F64 // 'mmod'
357 #define VCGT_TYPE 0x76636774 // 'vcgt'
359 static qcms_bool
read_tag_vcgtType(qcms_profile
*profile
, struct mem_source
*src
, struct tag_index index
)
361 size_t tag_offset
= find_tag(index
, TAG_vcgt
)->offset
;
362 uint32_t tag_type
= read_u32(src
, tag_offset
);
363 uint32_t vcgt_type
= read_u32(src
, tag_offset
+ 8);
364 uint16_t channels
= read_u16(src
, tag_offset
+ 12);
365 uint16_t elements
= read_u16(src
, tag_offset
+ 14);
366 uint16_t byte_depth
= read_u16(src
, tag_offset
+ 16);
367 size_t table_offset
= tag_offset
+ 18;
371 if (!src
->valid
|| tag_type
!= VCGT_TYPE
)
372 goto invalid_vcgt_tag
;
374 // Only support 3 channels.
377 // Only support single or double byte values.
378 if (byte_depth
!= 1 && byte_depth
!= 2)
380 // Only support table data, not equation.
383 // Limit the table to a sensible size; 10-bit gamma is a reasonable
384 // maximum for hardware correction.
388 // Empty table is invalid.
390 goto invalid_vcgt_tag
;
392 profile
->vcgt
.length
= elements
;
393 profile
->vcgt
.data
= malloc(3 * elements
* sizeof(uint16_t));
394 if (!profile
->vcgt
.data
)
397 dest
= profile
->vcgt
.data
;
399 for (i
= 0; i
< 3 * elements
; ++i
) {
400 if (byte_depth
== 1) {
401 *dest
++ = read_u8(src
, table_offset
) * 256;
403 *dest
++ = read_u16(src
, table_offset
);
406 table_offset
+= byte_depth
;
409 goto invalid_vcgt_tag
;
415 invalid_source(src
, "invalid vcgt tag");
419 static bool read_tag_descType(qcms_profile
*profile
, struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
421 struct tag
*tag
= find_tag(index
, tag_id
);
423 const uint32_t limit
= sizeof profile
->description
;
424 uint32_t offset
= tag
->offset
;
425 uint32_t type
= read_u32(src
, offset
);
426 uint32_t length
= read_u32(src
, offset
+8);
427 uint32_t i
, description_offset
;
429 if (length
&& type
== MLUC_TYPE
) {
430 length
= read_u32(src
, offset
+20);
431 if (!length
|| (length
& 1) || (read_u32(src
, offset
+12) != 12))
432 goto invalid_desc_tag
;
433 description_offset
= offset
+ read_u32(src
, offset
+24);
435 goto invalid_desc_tag
;
437 } else if (length
&& type
== DESC_TYPE
) {
438 description_offset
= offset
+ 12;
440 goto invalid_desc_tag
;
444 for (i
= 0; i
< length
; ++i
) {
445 uint8_t value
= read_u8(src
, description_offset
+ i
);
447 goto invalid_desc_tag
;
450 profile
->description
[i
] = value
;
452 profile
->description
[length
] = 0;
454 goto invalid_desc_tag
;
461 invalid_source(src
, "invalid description");
465 #if defined(__APPLE__)
467 // Use the dscm tag to change profile description "Display" to its more specific en-localized monitor name, if any.
469 #define TAG_dscm 0x6473636D // 'dscm'
471 static bool read_tag_dscmType(qcms_profile
*profile
, struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
473 if (strcmp(profile
->description
, "Display") != 0)
476 struct tag
*tag
= find_tag(index
, tag_id
);
478 uint32_t offset
= tag
->offset
;
479 uint32_t type
= read_u32(src
, offset
);
480 uint32_t records
= read_u32(src
, offset
+8);
482 if (!src
->valid
|| !records
|| type
!= MLUC_TYPE
)
483 goto invalid_dscm_tag
;
484 if (read_u32(src
, offset
+12) != 12) // MLUC record size: bytes
485 goto invalid_dscm_tag
;
487 for (uint32_t i
= 0; i
< records
; ++i
) {
488 const uint32_t limit
= sizeof profile
->description
;
489 const uint16_t isoen
= 0x656E; // ISO-3166-1 language 'en'
491 uint16_t language
= read_u16(src
, offset
+ 16 + (i
* 12) + 0);
492 uint32_t length
= read_u32(src
, offset
+ 16 + (i
* 12) + 4);
493 uint32_t description_offset
= read_u32(src
, offset
+ 16 + (i
* 12) + 8);
495 if (!src
->valid
|| !length
|| (length
& 1))
496 goto invalid_dscm_tag
;
497 if (language
!= isoen
)
500 // Use a prefix to identify the display description source
501 strcpy(profile
->description
, "dscm:");
506 for (uint32_t j
= 5; j
< length
; ++j
) {
507 uint8_t value
= read_u8(src
, offset
+ description_offset
+ j
- 5);
509 goto invalid_dscm_tag
;
510 profile
->description
[j
] = value
? value
: '.';
512 profile
->description
[length
] = 0;
521 invalid_source(src
, "invalid dscm tag");
525 // Use the mmod tag to change profile description "Display" to its specific mmod maker model data, if any.
527 #define TAG_mmod 0x6D6D6F64 // 'mmod'
529 static bool read_tag_mmodType(qcms_profile
*profile
, struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
531 if (strcmp(profile
->description
, "Display") != 0)
534 struct tag
*tag
= find_tag(index
, tag_id
);
536 const uint8_t length
= 4 * 4; // Four 4-byte fields: 'mmod', 0, maker, model.
538 uint32_t offset
= tag
->offset
;
539 if (tag
->size
< 40 || read_u32(src
, offset
) != MMOD_TYPE
)
540 goto invalid_mmod_tag
;
542 for (uint8_t i
= 0; i
< length
; ++i
) {
543 uint8_t value
= read_u8(src
, offset
+ i
);
545 goto invalid_mmod_tag
;
546 profile
->description
[i
] = value
? value
: '.';
548 profile
->description
[length
] = 0;
555 invalid_source(src
, "invalid mmod tag");
561 #define XYZ_TYPE 0x58595a20 // 'XYZ '
562 #define CURVE_TYPE 0x63757276 // 'curv'
563 #define PARAMETRIC_CURVE_TYPE 0x70617261 // 'para'
564 #define LUT16_TYPE 0x6d667432 // 'mft2'
565 #define LUT8_TYPE 0x6d667431 // 'mft1'
566 #define LUT_MAB_TYPE 0x6d414220 // 'mAB '
567 #define LUT_MBA_TYPE 0x6d424120 // 'mBA '
568 #define CHROMATIC_TYPE 0x73663332 // 'sf32'
570 static struct matrix
read_tag_s15Fixed16ArrayType(struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
572 struct tag
*tag
= find_tag(index
, tag_id
);
573 struct matrix matrix
;
576 uint32_t offset
= tag
->offset
;
577 uint32_t type
= read_u32(src
, offset
);
579 // Check mandatory type signature for s16Fixed16ArrayType
580 if (type
!= CHROMATIC_TYPE
) {
581 invalid_source(src
, "unexpected type, expected 'sf32'");
584 for (i
= 0; i
< 9; i
++) {
585 matrix
.m
[i
/3][i
%3] = s15Fixed16Number_to_float(read_s15Fixed16Number(src
, offset
+8+i
*4));
587 matrix
.invalid
= false;
589 matrix
.invalid
= true;
590 invalid_source(src
, "missing sf32tag");
595 static struct XYZNumber
read_tag_XYZType(struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
597 struct XYZNumber num
= {0, 0, 0};
598 struct tag
*tag
= find_tag(index
, tag_id
);
600 uint32_t offset
= tag
->offset
;
602 uint32_t type
= read_u32(src
, offset
);
603 if (type
!= XYZ_TYPE
)
604 invalid_source(src
, "unexpected type, expected XYZ");
605 num
.X
= read_s15Fixed16Number(src
, offset
+8);
606 num
.Y
= read_s15Fixed16Number(src
, offset
+12);
607 num
.Z
= read_s15Fixed16Number(src
, offset
+16);
609 invalid_source(src
, "missing xyztag");
614 // Read the tag at a given offset rather then the tag_index.
615 // This method is used when reading mAB tags where nested curveType are
616 // present that are not part of the tag_index.
617 static struct curveType
*read_curveType(struct mem_source
*src
, uint32_t offset
, uint32_t *len
)
619 static const uint32_t COUNT_TO_LENGTH
[5] = {1, 3, 4, 5, 7};
620 struct curveType
*curve
= NULL
;
621 uint32_t type
= read_u32(src
, offset
);
625 if (type
!= CURVE_TYPE
&& type
!= PARAMETRIC_CURVE_TYPE
) {
626 invalid_source(src
, "unexpected type, expected CURV or PARA");
630 if (type
== CURVE_TYPE
) {
631 count
= read_u32(src
, offset
+8);
633 #define MAX_CURVE_ENTRIES 40000 //arbitrary
634 if (count
> MAX_CURVE_ENTRIES
) {
635 invalid_source(src
, "curve size too large");
638 curve
= malloc(sizeof(struct curveType
) + sizeof(uInt16Number
)*count
);
642 curve
->count
= count
;
645 for (i
=0; i
<count
; i
++) {
646 curve
->data
[i
] = read_u16(src
, offset
+ 12 + i
*2);
648 *len
= 12 + count
* 2;
649 } else { //PARAMETRIC_CURVE_TYPE
650 count
= read_u16(src
, offset
+8);
653 invalid_source(src
, "parametric function type not supported.");
657 curve
= malloc(sizeof(struct curveType
));
661 curve
->count
= count
;
664 for (i
=0; i
< COUNT_TO_LENGTH
[count
]; i
++) {
665 curve
->parameter
[i
] = s15Fixed16Number_to_float(read_s15Fixed16Number(src
, offset
+ 12 + i
*4));
667 *len
= 12 + COUNT_TO_LENGTH
[count
] * 4;
669 if ((count
== 1 || count
== 2)) {
670 /* we have a type 1 or type 2 function that has a division by 'a' */
671 float a
= curve
->parameter
[1];
673 invalid_source(src
, "parametricCurve definition causes division by zero.");
680 static struct curveType
*read_tag_curveType(struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
682 struct tag
*tag
= find_tag(index
, tag_id
);
683 struct curveType
*curve
= NULL
;
686 return read_curveType(src
, tag
->offset
, &len
);
688 invalid_source(src
, "missing curvetag");
694 #define MAX_CLUT_SIZE 500000 // arbitrary
695 #define MAX_CHANNELS 10 // arbitrary
696 static void read_nested_curveType(struct mem_source
*src
, struct curveType
*(*curveArray
)[MAX_CHANNELS
], uint8_t num_channels
, uint32_t curve_offset
)
698 uint32_t channel_offset
= 0;
700 for (i
= 0; i
< num_channels
; i
++) {
701 uint32_t tag_len
= ~0;
703 (*curveArray
)[i
] = read_curveType(src
, curve_offset
+ channel_offset
, &tag_len
);
704 if (!(*curveArray
)[i
]) {
705 invalid_source(src
, "invalid nested curveType curve");
709 invalid_source(src
, "invalid nested curveType tag length");
713 channel_offset
+= tag_len
;
715 if ((tag_len
% 4) != 0)
716 channel_offset
+= 4 - (tag_len
% 4);
720 static void mAB_release(struct lutmABType
*lut
)
724 for (i
= 0; i
< lut
->num_in_channels
; i
++){
725 free(lut
->a_curves
[i
]);
727 for (i
= 0; i
< lut
->num_out_channels
; i
++){
728 free(lut
->b_curves
[i
]);
729 free(lut
->m_curves
[i
]);
734 /* See section 10.10 for specs */
735 static struct lutmABType
*read_tag_lutmABType(struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
737 struct tag
*tag
= find_tag(index
, tag_id
);
738 uint32_t offset
= tag
->offset
;
739 uint32_t a_curve_offset
, b_curve_offset
, m_curve_offset
;
740 uint32_t matrix_offset
;
741 uint32_t clut_offset
;
742 uint32_t clut_size
= 1;
743 uint8_t clut_precision
;
744 uint32_t type
= read_u32(src
, offset
);
745 uint8_t num_in_channels
, num_out_channels
;
746 struct lutmABType
*lut
;
749 if (type
!= LUT_MAB_TYPE
&& type
!= LUT_MBA_TYPE
) {
753 num_in_channels
= read_u8(src
, offset
+ 8);
754 num_out_channels
= read_u8(src
, offset
+ 8);
755 if (num_in_channels
> MAX_CHANNELS
|| num_out_channels
> MAX_CHANNELS
)
758 // We require 3in/out channels since we only support RGB->XYZ (or RGB->LAB)
759 // XXX: If we remove this restriction make sure that the number of channels
760 // is less or equal to the maximum number of mAB curves in qcmsint.h
761 // also check for clut_size overflow. Also make sure it's != 0
762 if (num_in_channels
!= 3 || num_out_channels
!= 3)
765 // some of this data is optional and is denoted by a zero offset
766 // we also use this to track their existance
767 a_curve_offset
= read_u32(src
, offset
+ 28);
768 clut_offset
= read_u32(src
, offset
+ 24);
769 m_curve_offset
= read_u32(src
, offset
+ 20);
770 matrix_offset
= read_u32(src
, offset
+ 16);
771 b_curve_offset
= read_u32(src
, offset
+ 12);
773 // Convert offsets relative to the tag to relative to the profile
774 // preserve zero for optional fields
776 a_curve_offset
+= offset
;
778 clut_offset
+= offset
;
780 m_curve_offset
+= offset
;
782 matrix_offset
+= offset
;
784 b_curve_offset
+= offset
;
787 assert (num_in_channels
== 3);
788 // clut_size can not overflow since lg(256^num_in_channels) = 24 bits.
789 for (i
= 0; i
< num_in_channels
; i
++) {
790 clut_size
*= read_u8(src
, clut_offset
+ i
);
791 if (clut_size
== 0) {
792 invalid_source(src
, "bad clut_size");
799 // 24bits * 3 won't overflow either
800 clut_size
= clut_size
* num_out_channels
;
802 if (clut_size
> MAX_CLUT_SIZE
)
805 lut
= malloc(sizeof(struct lutmABType
) + (clut_size
) * sizeof(float));
808 // we'll fill in the rest below
809 memset(lut
, 0, sizeof(struct lutmABType
));
810 lut
->clut_table
= &lut
->clut_table_data
[0];
813 for (i
= 0; i
< num_in_channels
; i
++) {
814 lut
->num_grid_points
[i
] = read_u8(src
, clut_offset
+ i
);
815 if (lut
->num_grid_points
[i
] == 0) {
816 invalid_source(src
, "bad grid_points");
821 // Reverse the processing of transformation elements for mBA type.
822 lut
->reversed
= (type
== LUT_MBA_TYPE
);
824 lut
->num_in_channels
= num_in_channels
;
825 lut
->num_out_channels
= num_out_channels
;
828 // read the matrix if we have it
829 lut
->e00
= read_s15Fixed16Number(src
, matrix_offset
+4*0);
830 lut
->e01
= read_s15Fixed16Number(src
, matrix_offset
+4*1);
831 lut
->e02
= read_s15Fixed16Number(src
, matrix_offset
+4*2);
832 lut
->e10
= read_s15Fixed16Number(src
, matrix_offset
+4*3);
833 lut
->e11
= read_s15Fixed16Number(src
, matrix_offset
+4*4);
834 lut
->e12
= read_s15Fixed16Number(src
, matrix_offset
+4*5);
835 lut
->e20
= read_s15Fixed16Number(src
, matrix_offset
+4*6);
836 lut
->e21
= read_s15Fixed16Number(src
, matrix_offset
+4*7);
837 lut
->e22
= read_s15Fixed16Number(src
, matrix_offset
+4*8);
838 lut
->e03
= read_s15Fixed16Number(src
, matrix_offset
+4*9);
839 lut
->e13
= read_s15Fixed16Number(src
, matrix_offset
+4*10);
840 lut
->e23
= read_s15Fixed16Number(src
, matrix_offset
+4*11);
843 if (a_curve_offset
) {
844 read_nested_curveType(src
, &lut
->a_curves
, num_in_channels
, a_curve_offset
);
846 if (m_curve_offset
) {
847 read_nested_curveType(src
, &lut
->m_curves
, num_out_channels
, m_curve_offset
);
849 if (b_curve_offset
) {
850 read_nested_curveType(src
, &lut
->b_curves
, num_out_channels
, b_curve_offset
);
852 invalid_source(src
, "B curves required");
856 clut_precision
= read_u8(src
, clut_offset
+ 16);
857 if (clut_precision
== 1) {
858 for (i
= 0; i
< clut_size
; i
++) {
859 lut
->clut_table
[i
] = uInt8Number_to_float(read_uInt8Number(src
, clut_offset
+ 20 + i
*1));
861 } else if (clut_precision
== 2) {
862 for (i
= 0; i
< clut_size
; i
++) {
863 lut
->clut_table
[i
] = uInt16Number_to_float(read_uInt16Number(src
, clut_offset
+ 20 + i
*2));
866 invalid_source(src
, "Invalid clut precision");
878 static struct lutType
*read_tag_lutType(struct mem_source
*src
, struct tag_index index
, uint32_t tag_id
)
880 struct tag
*tag
= find_tag(index
, tag_id
);
881 uint32_t offset
= tag
->offset
;
882 uint32_t type
= read_u32(src
, offset
);
883 uint16_t num_input_table_entries
;
884 uint16_t num_output_table_entries
;
885 uint8_t in_chan
, grid_points
, out_chan
;
886 size_t clut_offset
, output_offset
;
892 /* I'm not sure why the spec specifies a fixed number of entries for LUT8 tables even though
893 * they have room for the num_entries fields */
894 if (type
== LUT8_TYPE
) {
895 num_input_table_entries
= 256;
896 num_output_table_entries
= 256;
898 } else if (type
== LUT16_TYPE
) {
899 num_input_table_entries
= read_u16(src
, offset
+ 48);
900 num_output_table_entries
= read_u16(src
, offset
+ 50);
901 if (num_input_table_entries
== 0 || num_output_table_entries
== 0) {
902 invalid_source(src
, "Bad channel count");
907 assert(0); // the caller checks that this doesn't happen
908 invalid_source(src
, "Unexpected lut type");
912 in_chan
= read_u8(src
, offset
+ 8);
913 out_chan
= read_u8(src
, offset
+ 9);
914 grid_points
= read_u8(src
, offset
+ 10);
916 clut_size
= pow(grid_points
, in_chan
);
917 if (clut_size
> MAX_CLUT_SIZE
) {
918 invalid_source(src
, "CLUT too large");
922 if (in_chan
!= 3 || out_chan
!= 3) {
923 invalid_source(src
, "CLUT only supports RGB");
927 lut
= malloc(sizeof(struct lutType
) + (num_input_table_entries
* in_chan
+ clut_size
*out_chan
+ num_output_table_entries
* out_chan
)*sizeof(float));
929 invalid_source(src
, "CLUT too large");
933 /* compute the offsets of tables */
934 lut
->input_table
= &lut
->table_data
[0];
935 lut
->clut_table
= &lut
->table_data
[in_chan
*num_input_table_entries
];
936 lut
->output_table
= &lut
->table_data
[in_chan
*num_input_table_entries
+ clut_size
*out_chan
];
938 lut
->num_input_table_entries
= num_input_table_entries
;
939 lut
->num_output_table_entries
= num_output_table_entries
;
940 lut
->num_input_channels
= in_chan
;
941 lut
->num_output_channels
= out_chan
;
942 lut
->num_clut_grid_points
= grid_points
;
943 lut
->e00
= read_s15Fixed16Number(src
, offset
+12);
944 lut
->e01
= read_s15Fixed16Number(src
, offset
+16);
945 lut
->e02
= read_s15Fixed16Number(src
, offset
+20);
946 lut
->e10
= read_s15Fixed16Number(src
, offset
+24);
947 lut
->e11
= read_s15Fixed16Number(src
, offset
+28);
948 lut
->e12
= read_s15Fixed16Number(src
, offset
+32);
949 lut
->e20
= read_s15Fixed16Number(src
, offset
+36);
950 lut
->e21
= read_s15Fixed16Number(src
, offset
+40);
951 lut
->e22
= read_s15Fixed16Number(src
, offset
+44);
953 for (i
= 0; i
< lut
->num_input_table_entries
* in_chan
; i
++) {
954 if (type
== LUT8_TYPE
) {
955 lut
->input_table
[i
] = uInt8Number_to_float(read_uInt8Number(src
, offset
+ 52 + i
* entry_size
));
957 lut
->input_table
[i
] = uInt16Number_to_float(read_uInt16Number(src
, offset
+ 52 + i
* entry_size
));
961 clut_offset
= offset
+ 52 + lut
->num_input_table_entries
* in_chan
* entry_size
;
962 for (i
= 0; i
< clut_size
* out_chan
; i
+=3) {
963 if (type
== LUT8_TYPE
) {
964 lut
->clut_table
[i
+0] = uInt8Number_to_float(read_uInt8Number(src
, clut_offset
+ i
*entry_size
+ 0));
965 lut
->clut_table
[i
+1] = uInt8Number_to_float(read_uInt8Number(src
, clut_offset
+ i
*entry_size
+ 1));
966 lut
->clut_table
[i
+2] = uInt8Number_to_float(read_uInt8Number(src
, clut_offset
+ i
*entry_size
+ 2));
968 lut
->clut_table
[i
+0] = uInt16Number_to_float(read_uInt16Number(src
, clut_offset
+ i
*entry_size
+ 0));
969 lut
->clut_table
[i
+1] = uInt16Number_to_float(read_uInt16Number(src
, clut_offset
+ i
*entry_size
+ 2));
970 lut
->clut_table
[i
+2] = uInt16Number_to_float(read_uInt16Number(src
, clut_offset
+ i
*entry_size
+ 4));
974 output_offset
= clut_offset
+ clut_size
* out_chan
* entry_size
;
975 for (i
= 0; i
< lut
->num_output_table_entries
* out_chan
; i
++) {
976 if (type
== LUT8_TYPE
) {
977 lut
->output_table
[i
] = uInt8Number_to_float(read_uInt8Number(src
, output_offset
+ i
*entry_size
));
979 lut
->output_table
[i
] = uInt16Number_to_float(read_uInt16Number(src
, output_offset
+ i
*entry_size
));
986 static void read_rendering_intent(qcms_profile
*profile
, struct mem_source
*src
)
988 profile
->rendering_intent
= read_u32(src
, 64);
989 switch (profile
->rendering_intent
) {
990 case QCMS_INTENT_PERCEPTUAL
:
991 case QCMS_INTENT_SATURATION
:
992 case QCMS_INTENT_RELATIVE_COLORIMETRIC
:
993 case QCMS_INTENT_ABSOLUTE_COLORIMETRIC
:
996 invalid_source(src
, "unknown rendering intent");
1000 qcms_profile
*qcms_profile_create(void)
1002 return calloc(sizeof(qcms_profile
), 1);
1007 /* build sRGB gamma table */
1008 /* based on cmsBuildParametricGamma() */
1009 static uint16_t *build_sRGB_gamma_table(int num_entries
)
1012 /* taken from lcms: Build_sRGBGamma() */
1014 double a
= 1./1.055;
1015 double b
= 0.055/1.055;
1016 double c
= 1./12.92;
1019 uint16_t *table
= malloc(sizeof(uint16_t) * num_entries
);
1023 for (i
=0; i
<num_entries
; i
++) {
1024 double x
= (double)i
/ (num_entries
-1);
1026 // IEC 61966-2.1 (sRGB)
1027 // Y = (aX + b)^Gamma | X >= d
1030 double e
= (a
*x
+ b
);
1039 // Saturate -- this could likely move to a separate function
1040 output
= y
* 65535. + .5;
1041 if (output
> 65535.)
1045 table
[i
] = (uint16_t)floor(output
);
1050 static struct curveType
*curve_from_table(uint16_t *table
, int num_entries
)
1052 struct curveType
*curve
;
1054 curve
= malloc(sizeof(struct curveType
) + sizeof(uInt16Number
)*num_entries
);
1057 curve
->type
= CURVE_TYPE
;
1058 curve
->count
= num_entries
;
1059 for (i
= 0; i
< num_entries
; i
++) {
1060 curve
->data
[i
] = table
[i
];
1065 static uint16_t float_to_u8Fixed8Number(float a
)
1067 if (a
> (255.f
+ 255.f
/256))
1072 return floor(a
*256.f
+ .5f
);
1075 static struct curveType
*curve_from_gamma(float gamma
)
1077 struct curveType
*curve
;
1078 int num_entries
= 1;
1079 curve
= malloc(sizeof(struct curveType
) + sizeof(uInt16Number
)*num_entries
);
1082 curve
->count
= num_entries
;
1083 curve
->data
[0] = float_to_u8Fixed8Number(gamma
);
1088 //XXX: it would be nice if we had a way of ensuring
1089 // everything in a profile was initialized regardless of how it was created
1091 //XXX: should this also be taking a black_point?
1092 /* similar to CGColorSpaceCreateCalibratedRGB */
1093 qcms_profile
* qcms_profile_create_rgb_with_gamma(
1094 qcms_CIE_xyY white_point
,
1095 qcms_CIE_xyYTRIPLE primaries
,
1098 qcms_profile
* profile
= qcms_profile_create();
1100 return NO_MEM_PROFILE
;
1102 //XXX: should store the whitepoint
1103 if (!set_rgb_colorants(profile
, white_point
, primaries
)) {
1104 qcms_profile_release(profile
);
1105 return INVALID_PROFILE
;
1108 profile
->redTRC
= curve_from_gamma(gamma
);
1109 profile
->blueTRC
= curve_from_gamma(gamma
);
1110 profile
->greenTRC
= curve_from_gamma(gamma
);
1112 if (!profile
->redTRC
|| !profile
->blueTRC
|| !profile
->greenTRC
) {
1113 qcms_profile_release(profile
);
1114 return NO_MEM_PROFILE
;
1116 profile
->class = DISPLAY_DEVICE_PROFILE
;
1117 profile
->rendering_intent
= QCMS_INTENT_PERCEPTUAL
;
1118 profile
->color_space
= RGB_SIGNATURE
;
1119 profile
->pcs
= XYZ_SIGNATURE
;
1123 qcms_profile
* qcms_profile_create_rgb_with_table(
1124 qcms_CIE_xyY white_point
,
1125 qcms_CIE_xyYTRIPLE primaries
,
1126 uint16_t *table
, int num_entries
)
1128 qcms_profile
* profile
= qcms_profile_create();
1130 return NO_MEM_PROFILE
;
1132 //XXX: should store the whitepoint
1133 if (!set_rgb_colorants(profile
, white_point
, primaries
)) {
1134 qcms_profile_release(profile
);
1135 return INVALID_PROFILE
;
1138 profile
->redTRC
= curve_from_table(table
, num_entries
);
1139 profile
->blueTRC
= curve_from_table(table
, num_entries
);
1140 profile
->greenTRC
= curve_from_table(table
, num_entries
);
1142 if (!profile
->redTRC
|| !profile
->blueTRC
|| !profile
->greenTRC
) {
1143 qcms_profile_release(profile
);
1144 return NO_MEM_PROFILE
;
1146 profile
->class = DISPLAY_DEVICE_PROFILE
;
1147 profile
->rendering_intent
= QCMS_INTENT_PERCEPTUAL
;
1148 profile
->color_space
= RGB_SIGNATURE
;
1149 profile
->pcs
= XYZ_SIGNATURE
;
1153 /* from lcms: cmsWhitePointFromTemp */
1154 /* tempK must be >= 4000. and <= 25000.
1155 * Invalid values of tempK will return
1156 * (x,y,Y) = (-1.0, -1.0, -1.0)
1157 * similar to argyll: icx_DTEMP2XYZ() */
1158 static qcms_CIE_xyY
white_point_from_temp(int temp_K
)
1160 qcms_CIE_xyY white_point
;
1165 // No optimization provided.
1170 // For correlated color temperature (T) between 4000K and 7000K:
1171 if (T
>= 4000. && T
<= 7000.) {
1172 x
= -4.6070*(1E9
/T3
) + 2.9678*(1E6
/T2
) + 0.09911*(1E3
/T
) + 0.244063;
1174 // or for correlated color temperature (T) between 7000K and 25000K:
1175 if (T
> 7000.0 && T
<= 25000.0) {
1176 x
= -2.0064*(1E9
/T3
) + 1.9018*(1E6
/T2
) + 0.24748*(1E3
/T
) + 0.237040;
1179 white_point
.x
= -1.0;
1180 white_point
.y
= -1.0;
1181 white_point
.Y
= -1.0;
1183 assert(0 && "invalid temp");
1191 y
= -3.000*(x
*x
) + 2.870*x
- 0.275;
1193 // wave factors (not used, but here for futures extensions)
1195 // M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);
1196 // M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);
1198 // Fill white_point struct
1201 white_point
.Y
= 1.0;
1206 qcms_profile
* qcms_profile_sRGB(void)
1208 qcms_profile
*profile
;
1211 qcms_CIE_xyYTRIPLE Rec709Primaries
= {
1212 {0.6400, 0.3300, 1.0},
1213 {0.3000, 0.6000, 1.0},
1214 {0.1500, 0.0600, 1.0}
1218 D65
= white_point_from_temp(6504);
1220 table
= build_sRGB_gamma_table(1024);
1223 return NO_MEM_PROFILE
;
1225 profile
= qcms_profile_create_rgb_with_table(D65
, Rec709Primaries
, table
, 1024);
1227 strcpy(profile
->description
, "sRGB IEC61966-2.1");
1233 /* qcms_profile_from_memory does not hold a reference to the memory passed in */
1234 qcms_profile
* qcms_profile_from_memory(const void *mem
, size_t size
)
1237 struct mem_source source
;
1238 struct mem_source
*src
= &source
;
1239 struct tag_index index
;
1240 qcms_profile
*profile
;
1244 source
.valid
= true;
1247 return INVALID_PROFILE
;
1249 length
= read_u32(src
, 0);
1250 if (length
<= size
) {
1251 // shrink the area that we can read if appropriate
1252 source
.size
= length
;
1254 return INVALID_PROFILE
;
1257 /* ensure that the profile size is sane so it's easier to reason about */
1258 if (source
.size
<= 64 || source
.size
>= MAX_PROFILE_SIZE
)
1259 return INVALID_PROFILE
;
1261 profile
= qcms_profile_create();
1263 return NO_MEM_PROFILE
;
1265 check_CMM_type_signature(src
);
1266 check_profile_version(src
);
1267 read_class_signature(profile
, src
);
1268 read_rendering_intent(profile
, src
);
1269 read_color_space(profile
, src
);
1270 read_pcs(profile
, src
);
1271 //TODO read rest of profile stuff
1274 goto invalid_profile
;
1276 index
= read_tag_table(profile
, src
);
1277 if (!src
->valid
|| !index
.tags
)
1278 goto invalid_tag_table
;
1280 if (!read_tag_descType(profile
, src
, index
, TAG_desc
))
1281 goto invalid_tag_table
;
1282 #if defined(__APPLE__)
1283 if (!read_tag_dscmType(profile
, src
, index
, TAG_dscm
))
1284 goto invalid_tag_table
;
1285 if (!read_tag_mmodType(profile
, src
, index
, TAG_mmod
))
1286 goto invalid_tag_table
;
1289 if (find_tag(index
, TAG_CHAD
)) {
1290 profile
->chromaticAdaption
= read_tag_s15Fixed16ArrayType(src
, index
, TAG_CHAD
);
1292 profile
->chromaticAdaption
.invalid
= true; //Signal the data is not present
1295 if (find_tag(index
, TAG_vcgt
)) {
1296 if (!read_tag_vcgtType(profile
, src
, index
))
1297 goto invalid_tag_table
;
1300 if (profile
->class == DISPLAY_DEVICE_PROFILE
|| profile
->class == INPUT_DEVICE_PROFILE
||
1301 profile
->class == OUTPUT_DEVICE_PROFILE
|| profile
->class == COLOR_SPACE_PROFILE
) {
1302 if (profile
->color_space
== RGB_SIGNATURE
) {
1303 if (find_tag(index
, TAG_A2B0
)) {
1304 if (read_u32(src
, find_tag(index
, TAG_A2B0
)->offset
) == LUT8_TYPE
||
1305 read_u32(src
, find_tag(index
, TAG_A2B0
)->offset
) == LUT16_TYPE
) {
1306 profile
->A2B0
= read_tag_lutType(src
, index
, TAG_A2B0
);
1307 } else if (read_u32(src
, find_tag(index
, TAG_A2B0
)->offset
) == LUT_MAB_TYPE
) {
1308 profile
->mAB
= read_tag_lutmABType(src
, index
, TAG_A2B0
);
1311 if (find_tag(index
, TAG_B2A0
)) {
1312 if (read_u32(src
, find_tag(index
, TAG_B2A0
)->offset
) == LUT8_TYPE
||
1313 read_u32(src
, find_tag(index
, TAG_B2A0
)->offset
) == LUT16_TYPE
) {
1314 profile
->B2A0
= read_tag_lutType(src
, index
, TAG_B2A0
);
1315 } else if (read_u32(src
, find_tag(index
, TAG_B2A0
)->offset
) == LUT_MBA_TYPE
) {
1316 profile
->mBA
= read_tag_lutmABType(src
, index
, TAG_B2A0
);
1319 if (find_tag(index
, TAG_rXYZ
) || !qcms_supports_iccv4
) {
1320 profile
->redColorant
= read_tag_XYZType(src
, index
, TAG_rXYZ
);
1321 profile
->greenColorant
= read_tag_XYZType(src
, index
, TAG_gXYZ
);
1322 profile
->blueColorant
= read_tag_XYZType(src
, index
, TAG_bXYZ
);
1326 goto invalid_tag_table
;
1328 if (find_tag(index
, TAG_rTRC
) || !qcms_supports_iccv4
) {
1329 profile
->redTRC
= read_tag_curveType(src
, index
, TAG_rTRC
);
1330 profile
->greenTRC
= read_tag_curveType(src
, index
, TAG_gTRC
);
1331 profile
->blueTRC
= read_tag_curveType(src
, index
, TAG_bTRC
);
1333 if (!profile
->redTRC
|| !profile
->blueTRC
|| !profile
->greenTRC
)
1334 goto invalid_tag_table
;
1336 } else if (profile
->color_space
== GRAY_SIGNATURE
) {
1338 profile
->grayTRC
= read_tag_curveType(src
, index
, TAG_kTRC
);
1339 if (!profile
->grayTRC
)
1340 goto invalid_tag_table
;
1343 assert(0 && "read_color_space protects against entering here");
1344 goto invalid_tag_table
;
1347 goto invalid_tag_table
;
1351 goto invalid_tag_table
;
1360 qcms_profile_release(profile
);
1361 return INVALID_PROFILE
;
1364 qcms_bool
qcms_profile_match(qcms_profile
*p1
, qcms_profile
*p2
)
1366 return memcmp(p1
->description
, p2
->description
, sizeof p1
->description
) == 0;
1369 const char* qcms_profile_get_description(qcms_profile
*profile
)
1371 return profile
->description
;
1374 qcms_intent
qcms_profile_get_rendering_intent(qcms_profile
*profile
)
1376 return profile
->rendering_intent
;
1379 qcms_color_space
qcms_profile_get_color_space(qcms_profile
*profile
)
1381 return profile
->color_space
;
1384 size_t qcms_profile_get_vcgt_channel_length(qcms_profile
*profile
)
1386 return profile
->vcgt
.length
;
1389 // Check unsigned short is uint16_t.
1390 typedef char assert_short_not_16b
[(sizeof(unsigned short) == sizeof(uint16_t)) ? 1 : -1];
1392 qcms_bool
qcms_profile_get_vcgt_rgb_channels(qcms_profile
*profile
, unsigned short *data
)
1394 size_t vcgt_channel_bytes
= qcms_profile_get_vcgt_channel_length(profile
) * sizeof(uint16_t);
1396 if (!vcgt_channel_bytes
|| !data
)
1399 memcpy(data
, profile
->vcgt
.data
, 3 * vcgt_channel_bytes
);
1403 static void lut_release(struct lutType
*lut
)
1408 void qcms_profile_release(qcms_profile
*profile
)
1410 if (profile
->output_table_r
)
1411 precache_release(profile
->output_table_r
);
1412 if (profile
->output_table_g
)
1413 precache_release(profile
->output_table_g
);
1414 if (profile
->output_table_b
)
1415 precache_release(profile
->output_table_b
);
1418 lut_release(profile
->A2B0
);
1420 lut_release(profile
->B2A0
);
1423 mAB_release(profile
->mAB
);
1425 mAB_release(profile
->mBA
);
1427 if (profile
->vcgt
.data
)
1428 free(profile
->vcgt
.data
);
1430 free(profile
->redTRC
);
1431 free(profile
->blueTRC
);
1432 free(profile
->greenTRC
);
1433 free(profile
->grayTRC
);
1439 qcms_profile
* qcms_profile_from_file(FILE *file
)
1441 uint32_t length
, remaining_length
;
1442 qcms_profile
*profile
;
1447 if (fread(&length_be
, 1, sizeof(length_be
), file
) != sizeof(length_be
))
1448 return BAD_VALUE_PROFILE
;
1450 length
= be32_to_cpu(length_be
);
1451 if (length
> MAX_PROFILE_SIZE
|| length
< sizeof(length_be
))
1452 return BAD_VALUE_PROFILE
;
1454 /* allocate room for the entire profile */
1455 data
= malloc(length
);
1457 return NO_MEM_PROFILE
;
1459 /* copy in length to the front so that the buffer will contain the entire profile */
1460 *((be32
*)data
) = length_be
;
1461 remaining_length
= length
- sizeof(length_be
);
1463 /* read the rest profile */
1464 read_length
= fread((unsigned char*)data
+ sizeof(length_be
), 1, remaining_length
, file
);
1465 if (read_length
!= remaining_length
) {
1467 return INVALID_PROFILE
;
1470 profile
= qcms_profile_from_memory(data
, length
);
1475 qcms_profile
* qcms_profile_from_path(const char *path
)
1477 qcms_profile
*profile
= NULL
;
1478 FILE *file
= fopen(path
, "rb");
1480 profile
= qcms_profile_from_file(file
);
1487 /* Unicode path version */
1488 qcms_profile
* qcms_profile_from_unicode_path(const wchar_t *path
)
1490 qcms_profile
*profile
= NULL
;
1491 FILE *file
= _wfopen(path
, L
"rb");
1493 profile
= qcms_profile_from_file(file
);