BinaryWriter.cpp 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748
  1. /*
  2. * Copyright (c) 2023, Nico Weber <thakis@chromium.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Utf16View.h>
  7. #include <LibGfx/ICC/BinaryFormat.h>
  8. #include <LibGfx/ICC/BinaryWriter.h>
  9. #include <LibGfx/ICC/Profile.h>
  10. #include <time.h>
  11. #pragma GCC diagnostic ignored "-Warray-bounds"
  12. namespace Gfx::ICC {
  13. static ErrorOr<ByteBuffer> encode_chromaticity(ChromaticityTagData const& tag_data)
  14. {
  15. // ICC v4, 10.2 chromaticityType
  16. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + 2 * sizeof(u16) + tag_data.xy_coordinates().size() * 2 * sizeof(u16Fixed16Number)));
  17. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(ChromaticityTagData::Type);
  18. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  19. *bit_cast<BigEndian<u16>*>(bytes.data() + 8) = tag_data.xy_coordinates().size();
  20. *bit_cast<BigEndian<u16>*>(bytes.data() + 10) = static_cast<u16>(tag_data.phosphor_or_colorant_type());
  21. auto* coordinates = bit_cast<BigEndian<u16Fixed16Number>*>(bytes.data() + 12);
  22. for (size_t i = 0; i < tag_data.xy_coordinates().size(); ++i) {
  23. coordinates[2 * i] = tag_data.xy_coordinates()[i].x.raw();
  24. coordinates[2 * i + 1] = tag_data.xy_coordinates()[i].y.raw();
  25. }
  26. return bytes;
  27. }
  28. static ErrorOr<ByteBuffer> encode_cipc(CicpTagData const& tag_data)
  29. {
  30. // ICC v4, 10.3 cicpType
  31. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + 4));
  32. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(CicpTagData::Type);
  33. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  34. bytes.data()[8] = tag_data.color_primaries();
  35. bytes.data()[9] = tag_data.transfer_characteristics();
  36. bytes.data()[10] = tag_data.matrix_coefficients();
  37. bytes.data()[11] = tag_data.video_full_range_flag();
  38. return bytes;
  39. }
  40. static u32 curve_encoded_size(CurveTagData const& tag_data)
  41. {
  42. return 3 * sizeof(u32) + tag_data.values().size() * sizeof(u16);
  43. }
  44. static void encode_curve_to(CurveTagData const& tag_data, Bytes bytes)
  45. {
  46. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(CurveTagData::Type);
  47. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  48. *bit_cast<BigEndian<u32>*>(bytes.data() + 8) = tag_data.values().size();
  49. auto* values = bit_cast<BigEndian<u16>*>(bytes.data() + 12);
  50. for (size_t i = 0; i < tag_data.values().size(); ++i)
  51. values[i] = tag_data.values()[i];
  52. }
  53. static ErrorOr<ByteBuffer> encode_curve(CurveTagData const& tag_data)
  54. {
  55. // ICC v4, 10.6 curveType
  56. auto bytes = TRY(ByteBuffer::create_uninitialized(curve_encoded_size(tag_data)));
  57. encode_curve_to(tag_data, bytes.bytes());
  58. return bytes;
  59. }
  60. static ErrorOr<ByteBuffer> encode_lut_16(Lut16TagData const& tag_data)
  61. {
  62. // ICC v4, 10.10 lut16Type
  63. u32 input_tables_size = tag_data.input_tables().size();
  64. u32 clut_values_size = tag_data.clut_values().size();
  65. u32 output_tables_size = tag_data.output_tables().size();
  66. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + sizeof(LUTHeader) + 2 * sizeof(u16) + sizeof(u16) * (input_tables_size + clut_values_size + output_tables_size)));
  67. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(Lut16TagData::Type);
  68. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  69. auto& header = *bit_cast<LUTHeader*>(bytes.data() + 8);
  70. header.number_of_input_channels = tag_data.number_of_input_channels();
  71. header.number_of_output_channels = tag_data.number_of_output_channels();
  72. header.number_of_clut_grid_points = tag_data.number_of_clut_grid_points();
  73. header.reserved_for_padding = 0;
  74. for (int i = 0; i < 9; ++i)
  75. header.e_parameters[i] = tag_data.e_matrix().e[i].raw();
  76. *bit_cast<BigEndian<u16>*>(bytes.data() + 8 + sizeof(LUTHeader)) = tag_data.number_of_input_table_entries();
  77. *bit_cast<BigEndian<u16>*>(bytes.data() + 8 + sizeof(LUTHeader) + 2) = tag_data.number_of_output_table_entries();
  78. auto* values = bit_cast<BigEndian<u16>*>(bytes.data() + 8 + sizeof(LUTHeader) + 4);
  79. for (u16 input_value : tag_data.input_tables())
  80. *values++ = input_value;
  81. for (u16 clut_value : tag_data.clut_values())
  82. *values++ = clut_value;
  83. for (u16 output_value : tag_data.output_tables())
  84. *values++ = output_value;
  85. return bytes;
  86. }
  87. static ErrorOr<ByteBuffer> encode_lut_8(Lut8TagData const& tag_data)
  88. {
  89. // ICC v4, 10.11 lut8Type
  90. u32 input_tables_size = tag_data.input_tables().size();
  91. u32 clut_values_size = tag_data.clut_values().size();
  92. u32 output_tables_size = tag_data.output_tables().size();
  93. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + sizeof(LUTHeader) + input_tables_size + clut_values_size + output_tables_size));
  94. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(Lut8TagData::Type);
  95. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  96. auto& header = *bit_cast<LUTHeader*>(bytes.data() + 8);
  97. header.number_of_input_channels = tag_data.number_of_input_channels();
  98. header.number_of_output_channels = tag_data.number_of_output_channels();
  99. header.number_of_clut_grid_points = tag_data.number_of_clut_grid_points();
  100. header.reserved_for_padding = 0;
  101. for (int i = 0; i < 9; ++i)
  102. header.e_parameters[i] = tag_data.e_matrix().e[i].raw();
  103. u8* values = bytes.data() + 8 + sizeof(LUTHeader);
  104. memcpy(values, tag_data.input_tables().data(), input_tables_size);
  105. values += input_tables_size;
  106. memcpy(values, tag_data.clut_values().data(), clut_values_size);
  107. values += clut_values_size;
  108. memcpy(values, tag_data.output_tables().data(), output_tables_size);
  109. return bytes;
  110. }
  111. static u32 curve_encoded_size(CurveTagData const&);
  112. static void encode_curve_to(CurveTagData const&, Bytes);
  113. static u32 parametric_curve_encoded_size(ParametricCurveTagData const&);
  114. static void encode_parametric_curve_to(ParametricCurveTagData const&, Bytes);
  115. static u32 byte_size_of_curve(LutCurveType const& curve)
  116. {
  117. VERIFY(curve->type() == Gfx::ICC::CurveTagData::Type || curve->type() == Gfx::ICC::ParametricCurveTagData::Type);
  118. if (curve->type() == Gfx::ICC::CurveTagData::Type)
  119. return curve_encoded_size(static_cast<CurveTagData const&>(*curve));
  120. return parametric_curve_encoded_size(static_cast<ParametricCurveTagData const&>(*curve));
  121. }
  122. static u32 byte_size_of_curves(Vector<LutCurveType> const& curves)
  123. {
  124. u32 size = 0;
  125. for (auto const& curve : curves)
  126. size += align_up_to(byte_size_of_curve(curve), 4);
  127. return size;
  128. }
  129. static void write_curve(Bytes bytes, LutCurveType const& curve)
  130. {
  131. VERIFY(curve->type() == Gfx::ICC::CurveTagData::Type || curve->type() == Gfx::ICC::ParametricCurveTagData::Type);
  132. if (curve->type() == Gfx::ICC::CurveTagData::Type)
  133. encode_curve_to(static_cast<CurveTagData const&>(*curve), bytes);
  134. if (curve->type() == Gfx::ICC::ParametricCurveTagData::Type)
  135. encode_parametric_curve_to(static_cast<ParametricCurveTagData const&>(*curve), bytes);
  136. }
  137. static void write_curves(Bytes bytes, Vector<LutCurveType> const& curves)
  138. {
  139. u32 offset = 0;
  140. for (auto const& curve : curves) {
  141. u32 size = byte_size_of_curve(curve);
  142. write_curve(bytes.slice(offset, size), curve);
  143. offset += align_up_to(size, 4);
  144. }
  145. }
  146. static u32 byte_size_of_clut(CLUTData const& clut)
  147. {
  148. u32 data_size = clut.values.visit(
  149. [](Vector<u8> const& v) { return v.size(); },
  150. [](Vector<u16> const& v) { return 2 * v.size(); });
  151. return align_up_to(sizeof(CLUTHeader) + data_size, 4);
  152. }
  153. static void write_clut(Bytes bytes, CLUTData const& clut)
  154. {
  155. auto& clut_header = *bit_cast<CLUTHeader*>(bytes.data());
  156. memset(clut_header.number_of_grid_points_in_dimension, 0, sizeof(clut_header.number_of_grid_points_in_dimension));
  157. VERIFY(clut.number_of_grid_points_in_dimension.size() <= sizeof(clut_header.number_of_grid_points_in_dimension));
  158. for (size_t i = 0; i < clut.number_of_grid_points_in_dimension.size(); ++i)
  159. clut_header.number_of_grid_points_in_dimension[i] = clut.number_of_grid_points_in_dimension[i];
  160. clut_header.precision_of_data_elements = clut.values.visit(
  161. [](Vector<u8> const&) { return 1; },
  162. [](Vector<u16> const&) { return 2; });
  163. memset(clut_header.reserved_for_padding, 0, sizeof(clut_header.reserved_for_padding));
  164. clut.values.visit(
  165. [&bytes](Vector<u8> const& v) {
  166. memcpy(bytes.data() + sizeof(CLUTHeader), v.data(), v.size());
  167. },
  168. [&bytes](Vector<u16> const& v) {
  169. auto* raw_clut = bit_cast<BigEndian<u16>*>(bytes.data() + sizeof(CLUTHeader));
  170. for (size_t i = 0; i < v.size(); ++i)
  171. raw_clut[i] = v[i];
  172. });
  173. }
  174. static void write_matrix(Bytes bytes, EMatrix3x4 const& e_matrix)
  175. {
  176. auto* raw_e = bit_cast<BigEndian<s15Fixed16Number>*>(bytes.data());
  177. for (int i = 0; i < 12; ++i)
  178. raw_e[i] = e_matrix.e[i].raw();
  179. }
  180. static ErrorOr<ByteBuffer> encode_lut_a_to_b(LutAToBTagData const& tag_data)
  181. {
  182. // ICC v4, 10.12 lutAToBType
  183. u32 a_curves_size = tag_data.a_curves().map(byte_size_of_curves).value_or(0);
  184. u32 clut_size = tag_data.clut().map(byte_size_of_clut).value_or(0);
  185. u32 m_curves_size = tag_data.m_curves().map(byte_size_of_curves).value_or(0);
  186. u32 e_matrix_size = tag_data.e_matrix().has_value() ? 12 * sizeof(s15Fixed16Number) : 0;
  187. u32 b_curves_size = byte_size_of_curves(tag_data.b_curves());
  188. auto bytes = TRY(ByteBuffer::create_zeroed(2 * sizeof(u32) + sizeof(AdvancedLUTHeader) + a_curves_size + clut_size + m_curves_size + e_matrix_size + b_curves_size));
  189. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(LutAToBTagData::Type);
  190. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  191. auto& header = *bit_cast<AdvancedLUTHeader*>(bytes.data() + 8);
  192. header.number_of_input_channels = tag_data.number_of_input_channels();
  193. header.number_of_output_channels = tag_data.number_of_output_channels();
  194. header.reserved_for_padding = 0;
  195. header.offset_to_b_curves = 0;
  196. header.offset_to_matrix = 0;
  197. header.offset_to_m_curves = 0;
  198. header.offset_to_clut = 0;
  199. header.offset_to_a_curves = 0;
  200. u32 offset = 2 * sizeof(u32) + sizeof(AdvancedLUTHeader);
  201. auto advance = [&offset](BigEndian<u32>& header_slot, u32 size) {
  202. header_slot = offset;
  203. VERIFY(size % 4 == 0);
  204. offset += size;
  205. };
  206. if (auto const& a_curves = tag_data.a_curves(); a_curves.has_value()) {
  207. write_curves(bytes.bytes().slice(offset, a_curves_size), a_curves.value());
  208. advance(header.offset_to_a_curves, a_curves_size);
  209. }
  210. if (auto const& clut = tag_data.clut(); clut.has_value()) {
  211. write_clut(bytes.bytes().slice(offset, clut_size), clut.value());
  212. advance(header.offset_to_clut, clut_size);
  213. }
  214. if (auto const& m_curves = tag_data.m_curves(); m_curves.has_value()) {
  215. write_curves(bytes.bytes().slice(offset, m_curves_size), m_curves.value());
  216. advance(header.offset_to_m_curves, m_curves_size);
  217. }
  218. if (auto const& e_matrix = tag_data.e_matrix(); e_matrix.has_value()) {
  219. write_matrix(bytes.bytes().slice(offset, e_matrix_size), e_matrix.value());
  220. advance(header.offset_to_matrix, e_matrix_size);
  221. }
  222. write_curves(bytes.bytes().slice(offset, b_curves_size), tag_data.b_curves());
  223. advance(header.offset_to_b_curves, b_curves_size);
  224. return bytes;
  225. }
  226. static ErrorOr<ByteBuffer> encode_lut_b_to_a(LutBToATagData const& tag_data)
  227. {
  228. // ICC v4, 10.13 lutBToAType
  229. u32 b_curves_size = byte_size_of_curves(tag_data.b_curves());
  230. u32 e_matrix_size = tag_data.e_matrix().has_value() ? 12 * sizeof(s15Fixed16Number) : 0;
  231. u32 m_curves_size = tag_data.m_curves().map(byte_size_of_curves).value_or(0);
  232. u32 clut_size = tag_data.clut().map(byte_size_of_clut).value_or(0);
  233. u32 a_curves_size = tag_data.a_curves().map(byte_size_of_curves).value_or(0);
  234. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + sizeof(AdvancedLUTHeader) + b_curves_size + e_matrix_size + m_curves_size + clut_size + a_curves_size));
  235. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(LutBToATagData::Type);
  236. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  237. auto& header = *bit_cast<AdvancedLUTHeader*>(bytes.data() + 8);
  238. header.number_of_input_channels = tag_data.number_of_input_channels();
  239. header.number_of_output_channels = tag_data.number_of_output_channels();
  240. header.reserved_for_padding = 0;
  241. header.offset_to_b_curves = 0;
  242. header.offset_to_matrix = 0;
  243. header.offset_to_m_curves = 0;
  244. header.offset_to_clut = 0;
  245. header.offset_to_a_curves = 0;
  246. u32 offset = 2 * sizeof(u32) + sizeof(AdvancedLUTHeader);
  247. auto advance = [&offset](BigEndian<u32>& header_slot, u32 size) {
  248. header_slot = offset;
  249. VERIFY(size % 4 == 0);
  250. offset += size;
  251. };
  252. write_curves(bytes.bytes().slice(offset, b_curves_size), tag_data.b_curves());
  253. advance(header.offset_to_b_curves, b_curves_size);
  254. if (auto const& e_matrix = tag_data.e_matrix(); e_matrix.has_value()) {
  255. write_matrix(bytes.bytes().slice(offset, e_matrix_size), e_matrix.value());
  256. advance(header.offset_to_matrix, e_matrix_size);
  257. }
  258. if (auto const& m_curves = tag_data.m_curves(); m_curves.has_value()) {
  259. write_curves(bytes.bytes().slice(offset, m_curves_size), m_curves.value());
  260. advance(header.offset_to_m_curves, m_curves_size);
  261. }
  262. if (auto const& clut = tag_data.clut(); clut.has_value()) {
  263. write_clut(bytes.bytes().slice(offset, clut_size), clut.value());
  264. advance(header.offset_to_clut, clut_size);
  265. }
  266. if (auto const& a_curves = tag_data.a_curves(); a_curves.has_value()) {
  267. write_curves(bytes.bytes().slice(offset, a_curves_size), a_curves.value());
  268. advance(header.offset_to_a_curves, a_curves_size);
  269. }
  270. return bytes;
  271. }
  272. static ErrorOr<ByteBuffer> encode_measurement(MeasurementTagData const& tag_data)
  273. {
  274. // ICC v4, 10.14 measurementType
  275. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + sizeof(MeasurementHeader)));
  276. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(MeasurementTagData::Type);
  277. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  278. auto& header = *bit_cast<MeasurementHeader*>(bytes.data() + 8);
  279. header.standard_observer = tag_data.standard_observer();
  280. header.tristimulus_value_for_measurement_backing = tag_data.tristimulus_value_for_measurement_backing();
  281. header.measurement_geometry = tag_data.measurement_geometry();
  282. header.measurement_flare = tag_data.measurement_flare().raw();
  283. header.standard_illuminant = tag_data.standard_illuminant();
  284. return bytes;
  285. }
  286. static ErrorOr<ByteBuffer> encode_multi_localized_unicode(MultiLocalizedUnicodeTagData const& tag_data)
  287. {
  288. // ICC v4, 10.15 multiLocalizedUnicodeType
  289. // "The Unicode strings in storage should be encoded as 16-bit big-endian, UTF-16BE,
  290. // and should not be NULL terminated."
  291. size_t number_of_records = tag_data.records().size();
  292. size_t header_and_record_size = 4 * sizeof(u32) + number_of_records * sizeof(MultiLocalizedUnicodeRawRecord);
  293. size_t number_of_codepoints = 0;
  294. Vector<Utf16Data> utf16_strings;
  295. TRY(utf16_strings.try_ensure_capacity(number_of_records));
  296. for (auto const& record : tag_data.records()) {
  297. TRY(utf16_strings.try_append(TRY(utf8_to_utf16(record.text))));
  298. number_of_codepoints += utf16_strings.last().size();
  299. }
  300. size_t string_table_size = number_of_codepoints * sizeof(u16);
  301. auto bytes = TRY(ByteBuffer::create_uninitialized(header_and_record_size + string_table_size));
  302. auto* header = bit_cast<BigEndian<u32>*>(bytes.data());
  303. header[0] = static_cast<u32>(MultiLocalizedUnicodeTagData::Type);
  304. header[1] = 0;
  305. header[2] = number_of_records;
  306. header[3] = sizeof(MultiLocalizedUnicodeRawRecord);
  307. size_t offset = header_and_record_size;
  308. auto* records = bit_cast<MultiLocalizedUnicodeRawRecord*>(bytes.data() + 16);
  309. for (size_t i = 0; i < number_of_records; ++i) {
  310. records[i].language_code = tag_data.records()[i].iso_639_1_language_code;
  311. records[i].country_code = tag_data.records()[i].iso_3166_1_country_code;
  312. records[i].string_length_in_bytes = utf16_strings[i].size() * sizeof(u16);
  313. records[i].string_offset_in_bytes = offset;
  314. offset += records[i].string_length_in_bytes;
  315. }
  316. auto* string_table = bit_cast<BigEndian<u16>*>(bytes.data() + header_and_record_size);
  317. for (auto const& utf16_string : utf16_strings) {
  318. for (size_t i = 0; i < utf16_string.size(); ++i)
  319. string_table[i] = utf16_string[i];
  320. string_table += utf16_string.size();
  321. }
  322. return bytes;
  323. }
  324. static ErrorOr<ByteBuffer> encode_named_color_2(NamedColor2TagData const& tag_data)
  325. {
  326. // ICC v4, 10.17 namedColor2Type
  327. unsigned const record_byte_size = 32 + sizeof(u16) * (3 + tag_data.number_of_device_coordinates());
  328. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + sizeof(NamedColorHeader) + tag_data.size() * record_byte_size));
  329. *bit_cast<BigEndian<u32>*>(bytes.data()) = (u32)NamedColor2TagData::Type;
  330. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  331. auto& header = *bit_cast<NamedColorHeader*>(bytes.data() + 8);
  332. header.vendor_specific_flag = tag_data.vendor_specific_flag();
  333. header.count_of_named_colors = tag_data.size();
  334. header.number_of_device_coordinates_of_each_named_color = tag_data.number_of_device_coordinates();
  335. memset(header.prefix_for_each_color_name, 0, 32);
  336. memcpy(header.prefix_for_each_color_name, tag_data.prefix().bytes().data(), tag_data.prefix().bytes().size());
  337. memset(header.suffix_for_each_color_name, 0, 32);
  338. memcpy(header.suffix_for_each_color_name, tag_data.suffix().bytes().data(), tag_data.suffix().bytes().size());
  339. u8* record = bytes.data() + 8 + sizeof(NamedColorHeader);
  340. for (size_t i = 0; i < tag_data.size(); ++i) {
  341. memset(record, 0, 32);
  342. memcpy(record, tag_data.root_name(i).bytes().data(), tag_data.root_name(i).bytes().size());
  343. auto* components = bit_cast<BigEndian<u16>*>(record + 32);
  344. components[0] = tag_data.pcs_coordinates(i).xyz.x;
  345. components[1] = tag_data.pcs_coordinates(i).xyz.y;
  346. components[2] = tag_data.pcs_coordinates(i).xyz.z;
  347. for (size_t j = 0; j < tag_data.number_of_device_coordinates(); ++j)
  348. components[3 + j] = tag_data.device_coordinates(i)[j];
  349. record += record_byte_size;
  350. }
  351. return bytes;
  352. }
  353. static u32 parametric_curve_encoded_size(ParametricCurveTagData const& tag_data)
  354. {
  355. return 2 * sizeof(u32) + 2 * sizeof(u16) + tag_data.parameter_count() * sizeof(s15Fixed16Number);
  356. }
  357. static void encode_parametric_curve_to(ParametricCurveTagData const& tag_data, Bytes bytes)
  358. {
  359. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(ParametricCurveTagData::Type);
  360. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  361. *bit_cast<BigEndian<u16>*>(bytes.data() + 8) = static_cast<u16>(tag_data.function_type());
  362. *bit_cast<BigEndian<u16>*>(bytes.data() + 10) = 0;
  363. auto* parameters = bit_cast<BigEndian<s15Fixed16Number>*>(bytes.data() + 12);
  364. for (size_t i = 0; i < tag_data.parameter_count(); ++i)
  365. parameters[i] = tag_data.parameter(i).raw();
  366. }
  367. static ErrorOr<ByteBuffer> encode_parametric_curve(ParametricCurveTagData const& tag_data)
  368. {
  369. // ICC v4, 10.18 parametricCurveType
  370. auto bytes = TRY(ByteBuffer::create_uninitialized(parametric_curve_encoded_size(tag_data)));
  371. encode_parametric_curve_to(tag_data, bytes.bytes());
  372. return bytes;
  373. }
  374. static ErrorOr<ByteBuffer> encode_s15_fixed_array(S15Fixed16ArrayTagData const& tag_data)
  375. {
  376. // ICC v4, 10.22 s15Fixed16ArrayType
  377. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + tag_data.values().size() * sizeof(s15Fixed16Number)));
  378. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(S15Fixed16ArrayTagData::Type);
  379. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  380. auto* values = bit_cast<BigEndian<s15Fixed16Number>*>(bytes.data() + 8);
  381. for (size_t i = 0; i < tag_data.values().size(); ++i)
  382. values[i] = tag_data.values()[i].raw();
  383. return bytes;
  384. }
  385. static ErrorOr<ByteBuffer> encode_signature(SignatureTagData const& tag_data)
  386. {
  387. // ICC v4, 10.23 signatureType
  388. auto bytes = TRY(ByteBuffer::create_uninitialized(3 * sizeof(u32)));
  389. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(SignatureTagData::Type);
  390. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  391. *bit_cast<BigEndian<u32>*>(bytes.data() + 8) = tag_data.signature();
  392. return bytes;
  393. }
  394. static ErrorOr<ByteBuffer> encode_text_description(TextDescriptionTagData const& tag_data)
  395. {
  396. // ICC v2, 6.5.17 textDescriptionType
  397. // All lengths include room for a trailing nul character.
  398. // See also the many comments in TextDescriptionTagData::from_bytes().
  399. u32 ascii_size = sizeof(u32) + tag_data.ascii_description().bytes().size() + 1;
  400. // FIXME: Include tag_data.unicode_description() if it's set.
  401. u32 unicode_size = 2 * sizeof(u32);
  402. // FIXME: Include tag_data.macintosh_description() if it's set.
  403. u32 macintosh_size = sizeof(u16) + sizeof(u8) + 67;
  404. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + ascii_size + unicode_size + macintosh_size));
  405. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(TextDescriptionTagData::Type);
  406. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  407. // ASCII
  408. *bit_cast<BigEndian<u32>*>(bytes.data() + 8) = tag_data.ascii_description().bytes().size() + 1;
  409. memcpy(bytes.data() + 12, tag_data.ascii_description().bytes().data(), tag_data.ascii_description().bytes().size());
  410. bytes.data()[12 + tag_data.ascii_description().bytes().size()] = '\0';
  411. // Unicode
  412. // "Because the Unicode language code and Unicode count immediately follow the ASCII description,
  413. // their alignment is not correct when the ASCII count is not a multiple of four"
  414. // So we can't use BigEndian<u32> here.
  415. u8* cursor = bytes.data() + 8 + ascii_size;
  416. u32 unicode_language_code = 0; // FIXME: Set to tag_data.unicode_language_code() once this writes unicode data.
  417. cursor[0] = unicode_language_code >> 24;
  418. cursor[1] = (unicode_language_code >> 16) & 0xff;
  419. cursor[2] = (unicode_language_code >> 8) & 0xff;
  420. cursor[3] = unicode_language_code & 0xff;
  421. cursor += 4;
  422. // FIXME: Include tag_data.unicode_description() if it's set.
  423. u32 ucs2_count = 0; // FIXME: If tag_data.unicode_description() is set, set this to its length plus room for one nul character.
  424. cursor[0] = ucs2_count >> 24;
  425. cursor[1] = (ucs2_count >> 16) & 0xff;
  426. cursor[2] = (ucs2_count >> 8) & 0xff;
  427. cursor[3] = ucs2_count & 0xff;
  428. cursor += 4;
  429. // Macintosh scriptcode
  430. u16 scriptcode_code = 0; // MacRoman
  431. cursor[0] = (scriptcode_code >> 8) & 0xff;
  432. cursor[1] = scriptcode_code & 0xff;
  433. cursor += 2;
  434. u8 macintosh_description_length = 0; // FIXME: If tag_data.macintosh_description() is set, set this to tis length plus room for one nul character.
  435. cursor[0] = macintosh_description_length;
  436. cursor += 1;
  437. memset(cursor, 0, 67);
  438. return bytes;
  439. }
  440. static ErrorOr<ByteBuffer> encode_text(TextTagData const& tag_data)
  441. {
  442. // ICC v4, 10.24 textType
  443. // "The textType is a simple text structure that contains a 7-bit ASCII text string. The length of the string is obtained
  444. // by subtracting 8 from the element size portion of the tag itself. This string shall be terminated with a 00h byte."
  445. auto text_bytes = tag_data.text().bytes();
  446. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + text_bytes.size() + 1));
  447. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(TextTagData::Type);
  448. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  449. memcpy(bytes.data() + 8, text_bytes.data(), text_bytes.size());
  450. *(bytes.data() + 8 + text_bytes.size()) = '\0';
  451. return bytes;
  452. }
  453. static ErrorOr<ByteBuffer> encode_viewing_conditions(ViewingConditionsTagData const& tag_data)
  454. {
  455. // ICC v4, 10.30 viewingConditionsType
  456. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + sizeof(ViewingConditionsHeader)));
  457. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(ViewingConditionsTagData::Type);
  458. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  459. auto& header = *bit_cast<ViewingConditionsHeader*>(bytes.data() + 8);
  460. header.unnormalized_ciexyz_values_for_illuminant = tag_data.unnormalized_ciexyz_values_for_illuminant();
  461. header.unnormalized_ciexyz_values_for_surround = tag_data.unnormalized_ciexyz_values_for_surround();
  462. header.illuminant_type = tag_data.illuminant_type();
  463. return bytes;
  464. }
  465. static ErrorOr<ByteBuffer> encode_xyz(XYZTagData const& tag_data)
  466. {
  467. // ICC v4, 10.31 XYZType
  468. auto bytes = TRY(ByteBuffer::create_uninitialized(2 * sizeof(u32) + tag_data.xyzs().size() * sizeof(XYZNumber)));
  469. *bit_cast<BigEndian<u32>*>(bytes.data()) = static_cast<u32>(XYZTagData::Type);
  470. *bit_cast<BigEndian<u32>*>(bytes.data() + 4) = 0;
  471. auto* xyzs = bit_cast<XYZNumber*>(bytes.data() + 8);
  472. for (size_t i = 0; i < tag_data.xyzs().size(); ++i)
  473. xyzs[i] = tag_data.xyzs()[i];
  474. return bytes;
  475. }
  476. static ErrorOr<Optional<ByteBuffer>> encode_tag_data(TagData const& tag_data)
  477. {
  478. switch (tag_data.type()) {
  479. case ChromaticityTagData::Type:
  480. return encode_chromaticity(static_cast<ChromaticityTagData const&>(tag_data));
  481. case CicpTagData::Type:
  482. return encode_cipc(static_cast<CicpTagData const&>(tag_data));
  483. case CurveTagData::Type:
  484. return encode_curve(static_cast<CurveTagData const&>(tag_data));
  485. case Lut16TagData::Type:
  486. return encode_lut_16(static_cast<Lut16TagData const&>(tag_data));
  487. case Lut8TagData::Type:
  488. return encode_lut_8(static_cast<Lut8TagData const&>(tag_data));
  489. case LutAToBTagData::Type:
  490. return encode_lut_a_to_b(static_cast<LutAToBTagData const&>(tag_data));
  491. case LutBToATagData::Type:
  492. return encode_lut_b_to_a(static_cast<LutBToATagData const&>(tag_data));
  493. case MeasurementTagData::Type:
  494. return encode_measurement(static_cast<MeasurementTagData const&>(tag_data));
  495. case MultiLocalizedUnicodeTagData::Type:
  496. return encode_multi_localized_unicode(static_cast<MultiLocalizedUnicodeTagData const&>(tag_data));
  497. case NamedColor2TagData::Type:
  498. return encode_named_color_2(static_cast<NamedColor2TagData const&>(tag_data));
  499. case ParametricCurveTagData::Type:
  500. return encode_parametric_curve(static_cast<ParametricCurveTagData const&>(tag_data));
  501. case S15Fixed16ArrayTagData::Type:
  502. return encode_s15_fixed_array(static_cast<S15Fixed16ArrayTagData const&>(tag_data));
  503. case SignatureTagData::Type:
  504. return encode_signature(static_cast<SignatureTagData const&>(tag_data));
  505. case TextDescriptionTagData::Type:
  506. return encode_text_description(static_cast<TextDescriptionTagData const&>(tag_data));
  507. case TextTagData::Type:
  508. return encode_text(static_cast<TextTagData const&>(tag_data));
  509. case ViewingConditionsTagData::Type:
  510. return encode_viewing_conditions(static_cast<ViewingConditionsTagData const&>(tag_data));
  511. case XYZTagData::Type:
  512. return encode_xyz(static_cast<XYZTagData const&>(tag_data));
  513. }
  514. return OptionalNone {};
  515. }
  516. static ErrorOr<Vector<ByteBuffer>> encode_tag_datas(Profile const& profile, HashMap<TagData*, size_t>& tag_data_map)
  517. {
  518. Vector<ByteBuffer> tag_data_bytes;
  519. TRY(tag_data_bytes.try_ensure_capacity(profile.tag_count()));
  520. TRY(profile.try_for_each_tag([&](auto, auto tag_data) -> ErrorOr<void> {
  521. if (tag_data_map.contains(tag_data.ptr()))
  522. return {};
  523. auto encoded_tag_data = TRY(encode_tag_data(tag_data));
  524. if (!encoded_tag_data.has_value())
  525. return {};
  526. tag_data_bytes.append(encoded_tag_data.release_value());
  527. TRY(tag_data_map.try_set(tag_data.ptr(), tag_data_bytes.size() - 1));
  528. return {};
  529. }));
  530. return tag_data_bytes;
  531. }
  532. static ErrorOr<void> encode_tag_table(ByteBuffer& bytes, Profile const& profile, u32 number_of_serialized_tags, Vector<size_t> const& offsets,
  533. Vector<ByteBuffer> const& tag_data_bytes, HashMap<TagData*, size_t> const& tag_data_map)
  534. {
  535. // ICC v4, 7.3 Tag table
  536. // ICC v4, 7.3.1 Overview
  537. VERIFY(bytes.size() >= sizeof(ICCHeader) + sizeof(u32) + number_of_serialized_tags * sizeof(TagTableEntry));
  538. *bit_cast<BigEndian<u32>*>(bytes.data() + sizeof(ICCHeader)) = number_of_serialized_tags;
  539. TagTableEntry* tag_table_entries = bit_cast<TagTableEntry*>(bytes.data() + sizeof(ICCHeader) + sizeof(u32));
  540. int i = 0;
  541. profile.for_each_tag([&](auto tag_signature, auto tag_data) {
  542. auto index = tag_data_map.get(tag_data.ptr());
  543. if (!index.has_value())
  544. return;
  545. tag_table_entries[i].tag_signature = tag_signature;
  546. tag_table_entries[i].offset_to_beginning_of_tag_data_element = offsets[index.value()];
  547. tag_table_entries[i].size_of_tag_data_element = tag_data_bytes[index.value()].size();
  548. ++i;
  549. });
  550. return {};
  551. }
  552. static ErrorOr<void> encode_header(ByteBuffer& bytes, Profile const& profile)
  553. {
  554. VERIFY(bytes.size() >= sizeof(ICCHeader));
  555. auto& raw_header = *bit_cast<ICCHeader*>(bytes.data());
  556. raw_header.profile_size = bytes.size();
  557. raw_header.preferred_cmm_type = profile.preferred_cmm_type().value_or(PreferredCMMType { 0 });
  558. raw_header.profile_version_major = profile.version().major_version();
  559. raw_header.profile_version_minor_bugfix = profile.version().minor_and_bugfix_version();
  560. raw_header.profile_version_zero = 0;
  561. raw_header.profile_device_class = profile.device_class();
  562. raw_header.data_color_space = profile.data_color_space();
  563. raw_header.profile_connection_space = profile.connection_space();
  564. DateTime profile_timestamp = profile.creation_timestamp();
  565. raw_header.profile_creation_time.year = profile_timestamp.year;
  566. raw_header.profile_creation_time.month = profile_timestamp.month;
  567. raw_header.profile_creation_time.day = profile_timestamp.day;
  568. raw_header.profile_creation_time.hours = profile_timestamp.hours;
  569. raw_header.profile_creation_time.minutes = profile_timestamp.minutes;
  570. raw_header.profile_creation_time.seconds = profile_timestamp.seconds;
  571. raw_header.profile_file_signature = ProfileFileSignature;
  572. raw_header.primary_platform = profile.primary_platform().value_or(PrimaryPlatform { 0 });
  573. raw_header.profile_flags = profile.flags().bits();
  574. raw_header.device_manufacturer = profile.device_manufacturer().value_or(DeviceManufacturer { 0 });
  575. raw_header.device_model = profile.device_model().value_or(DeviceModel { 0 });
  576. raw_header.device_attributes = profile.device_attributes().bits();
  577. raw_header.rendering_intent = profile.rendering_intent();
  578. raw_header.pcs_illuminant = profile.pcs_illuminant();
  579. raw_header.profile_creator = profile.creator().value_or(Creator { 0 });
  580. memset(raw_header.reserved, 0, sizeof(raw_header.reserved));
  581. auto id = Profile::compute_id(bytes);
  582. static_assert(sizeof(id.data) == sizeof(raw_header.profile_id));
  583. memcpy(raw_header.profile_id, id.data, sizeof(id.data));
  584. return {};
  585. }
  586. ErrorOr<ByteBuffer> encode(Profile const& profile)
  587. {
  588. // Valid profiles always have tags. Profile only represents valid profiles.
  589. VERIFY(profile.tag_count() > 0);
  590. HashMap<TagData*, size_t> tag_data_map;
  591. Vector<ByteBuffer> tag_data_bytes = TRY(encode_tag_datas(profile, tag_data_map));
  592. u32 number_of_serialized_tags = 0;
  593. profile.for_each_tag([&](auto tag_signature, auto tag_data) {
  594. if (!tag_data_map.contains(tag_data.ptr())) {
  595. dbgln("ICC serialization: dropping tag {} because it has unknown type {}", tag_signature, tag_data->type());
  596. return;
  597. }
  598. number_of_serialized_tags++;
  599. });
  600. size_t tag_table_size = sizeof(u32) + number_of_serialized_tags * sizeof(TagTableEntry);
  601. size_t offset = sizeof(ICCHeader) + tag_table_size;
  602. Vector<size_t> offsets;
  603. for (auto const& bytes : tag_data_bytes) {
  604. TRY(offsets.try_append(offset));
  605. offset += align_up_to(bytes.size(), 4);
  606. }
  607. // Include padding after last element. Use create_zeroed() to fill padding bytes with null bytes.
  608. // ICC v4, 7.1.2:
  609. // "c) all tagged element data, including the last, shall be padded by no more than three following pad bytes to
  610. // reach a 4-byte boundary;
  611. // d) all pad bytes shall be NULL (as defined in ISO/IEC 646, character 0/0).
  612. // NOTE 1 This implies that the length is required to be a multiple of four."
  613. auto bytes = TRY(ByteBuffer::create_zeroed(offset));
  614. for (size_t i = 0; i < tag_data_bytes.size(); ++i)
  615. memcpy(bytes.data() + offsets[i], tag_data_bytes[i].data(), tag_data_bytes[i].size());
  616. TRY(encode_tag_table(bytes, profile, number_of_serialized_tags, offsets, tag_data_bytes, tag_data_map));
  617. TRY(encode_header(bytes, profile));
  618. return bytes;
  619. }
  620. }