KImageFormats

heif.cpp
1/*
2 High Efficiency Image File Format (HEIF) support for QImage.
3
4 SPDX-FileCopyrightText: 2020 Sirius Bakke <sirius@bakke.co>
5 SPDX-FileCopyrightText: 2021 Daniel Novomesky <dnovomesky@gmail.com>
6
7 SPDX-License-Identifier: LGPL-2.0-or-later
8*/
9
10#include "heif_p.h"
11#include "microexif_p.h"
12#include "util_p.h"
13#include <libheif/heif.h>
14
15#include <QColorSpace>
16#include <QDebug>
17#include <QPointF>
18#include <QSysInfo>
19#include <cstring>
20#include <limits>
21
22#ifndef HEIF_MAX_METADATA_SIZE
23/*!
24 * XMP and EXIF maximum size.
25 */
26#define HEIF_MAX_METADATA_SIZE (4 * 1024 * 1024)
27#endif
28
29size_t HEIFHandler::m_initialized_count = 0;
30bool HEIFHandler::m_plugins_queried = false;
31bool HEIFHandler::m_heif_decoder_available = false;
32bool HEIFHandler::m_heif_encoder_available = false;
33bool HEIFHandler::m_hej2_decoder_available = false;
34bool HEIFHandler::m_hej2_encoder_available = false;
35bool HEIFHandler::m_avci_decoder_available = false;
36
37extern "C" {
38static struct heif_error heifhandler_write_callback(struct heif_context * /* ctx */, const void *data, size_t size, void *userdata)
39{
40 heif_error error;
41 error.code = heif_error_Ok;
42 error.subcode = heif_suberror_Unspecified;
43 error.message = "Success";
44
45 if (!userdata || !data || size == 0) {
46 error.code = heif_error_Usage_error;
47 error.subcode = heif_suberror_Null_pointer_argument;
48 error.message = "Wrong parameters!";
49 return error;
50 }
51
52 QIODevice *ioDevice = static_cast<QIODevice *>(userdata);
53 qint64 bytesWritten = ioDevice->write(static_cast<const char *>(data), size);
54
55 if (bytesWritten < static_cast<qint64>(size)) {
56 error.code = heif_error_Encoding_error;
57 error.message = "Bytes written to QIODevice are smaller than input data size";
58 error.subcode = heif_suberror_Cannot_write_output_data;
59 }
60
61 return error;
62}
63}
64
65HEIFHandler::HEIFHandler()
66 : m_parseState(ParseHeicNotParsed)
67 , m_quality(100)
68{
69}
70
71bool HEIFHandler::canRead() const
72{
73 if (m_parseState == ParseHeicNotParsed) {
74 QIODevice *dev = device();
75 if (dev) {
76 const QByteArray header = dev->peek(28);
77
78 if (HEIFHandler::isSupportedBMFFType(header)) {
79 setFormat("heif");
80 return true;
81 }
82
83 if (HEIFHandler::isSupportedHEJ2(header)) {
84 setFormat("hej2");
85 return true;
86 }
87
88 if (HEIFHandler::isSupportedAVCI(header)) {
89 setFormat("avci");
90 return true;
91 }
92 }
93 return false;
94 }
95
96 if (m_parseState != ParseHeicError) {
97 return true;
98 }
99 return false;
100}
101
102bool HEIFHandler::read(QImage *outImage)
103{
104 if (!ensureParsed()) {
105 return false;
106 }
107
108 *outImage = m_current_image;
109 return true;
110}
111
112bool HEIFHandler::write(const QImage &image)
113{
114 if (image.format() == QImage::Format_Invalid || image.isNull()) {
115 qWarning("No image data to save");
116 return false;
117 }
118
119#if LIBHEIF_HAVE_VERSION(1, 13, 0)
120 startHeifLib();
121#endif
122
123 bool success = write_helper(image);
124
125#if LIBHEIF_HAVE_VERSION(1, 13, 0)
126 finishHeifLib();
127#endif
128
129 return success;
130}
131
132bool HEIFHandler::write_helper(const QImage &image)
133{
134 int save_depth; // 8 or 10bit per channel
135 QImage::Format tmpformat; // format for temporary image
136 const bool save_alpha = image.hasAlphaChannel();
137
138 switch (image.format()) {
139 case QImage::Format_BGR30:
140 case QImage::Format_A2BGR30_Premultiplied:
141 case QImage::Format_RGB30:
142 case QImage::Format_A2RGB30_Premultiplied:
143 case QImage::Format_Grayscale16:
144 case QImage::Format_RGBX64:
145 case QImage::Format_RGBA64:
146 case QImage::Format_RGBA64_Premultiplied:
147 save_depth = 10;
148 break;
149 default:
150 if (image.depth() > 32) {
151 save_depth = 10;
152 } else {
153 save_depth = 8;
154 }
155 break;
156 }
157
158 heif_compression_format encoder_codec = heif_compression_HEVC;
159#if LIBHEIF_HAVE_VERSION(1, 13, 0)
160 if (format() == "hej2") {
161 encoder_codec = heif_compression_JPEG2000;
162 save_depth = 8; // for compatibility reasons
163 }
164#endif
165
166 heif_chroma chroma;
167 if (save_depth > 8) {
168 if (save_alpha) {
169 tmpformat = QImage::Format_RGBA64;
170 chroma = (QSysInfo::ByteOrder == QSysInfo::LittleEndian) ? heif_chroma_interleaved_RRGGBBAA_LE : heif_chroma_interleaved_RRGGBBAA_BE;
171 } else {
172 tmpformat = QImage::Format_RGBX64;
173 chroma = (QSysInfo::ByteOrder == QSysInfo::LittleEndian) ? heif_chroma_interleaved_RRGGBB_LE : heif_chroma_interleaved_RRGGBB_BE;
174 }
175 } else {
176 if (save_alpha) {
177 tmpformat = QImage::Format_RGBA8888;
178 chroma = heif_chroma_interleaved_RGBA;
179 } else {
180 tmpformat = QImage::Format_RGB888;
181 chroma = heif_chroma_interleaved_RGB;
182 }
183 }
184
185#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
186 QImage tmpimage;
187 auto cs = image.colorSpace();
188 if (cs.isValid() && cs.colorModel() == QColorSpace::ColorModel::Cmyk && image.format() == QImage::Format_CMYK8888) {
189 tmpimage = image.convertedToColorSpace(QColorSpace(QColorSpace::SRgb), tmpformat);
190 } else if (cs.isValid() && cs.colorModel() == QColorSpace::ColorModel::Gray
191 && (image.format() == QImage::Format_Grayscale8 || image.format() == QImage::Format_Grayscale16)) {
192 QColorSpace::TransferFunction trc_new = cs.transferFunction();
193 float gamma_new = cs.gamma();
194 if (trc_new == QColorSpace::TransferFunction::Custom) {
195 trc_new = QColorSpace::TransferFunction::SRgb;
196 }
197 tmpimage = image.convertedToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, trc_new, gamma_new), tmpformat);
198 } else {
199 tmpimage = image.convertToFormat(tmpformat);
200 }
201#else
202 QImage tmpimage = image.convertToFormat(tmpformat);
203#endif
204
205 struct heif_context *context = heif_context_alloc();
206 struct heif_error err;
207 struct heif_image *h_image = nullptr;
208
209 err = heif_image_create(tmpimage.width(), tmpimage.height(), heif_colorspace_RGB, chroma, &h_image);
210 if (err.code) {
211 qWarning() << "heif_image_create error:" << err.message;
212 heif_context_free(context);
213 return false;
214 }
215
216 QByteArray iccprofile = tmpimage.colorSpace().iccProfile();
217 if (iccprofile.size() > 0) {
218 heif_image_set_raw_color_profile(h_image, "prof", iccprofile.constData(), iccprofile.size());
219 }
220
221 heif_image_add_plane(h_image, heif_channel_interleaved, image.width(), image.height(), save_depth);
222 int stride = 0;
223 uint8_t *const dst = heif_image_get_plane(h_image, heif_channel_interleaved, &stride);
224 size_t rowbytes;
225
226 switch (save_depth) {
227 case 10:
228 if (save_alpha) {
229 for (int y = 0; y < tmpimage.height(); y++) {
230 const uint16_t *src_word = reinterpret_cast<const uint16_t *>(tmpimage.constScanLine(y));
231 uint16_t *dest_word = reinterpret_cast<uint16_t *>(dst + (y * stride));
232 for (int x = 0; x < tmpimage.width(); x++) {
233 int tmp_pixelval;
234 // R
235 tmp_pixelval = (int)(((float)(*src_word) / 65535.0f) * 1023.0f + 0.5f);
236 *dest_word = qBound(0, tmp_pixelval, 1023);
237 src_word++;
238 dest_word++;
239 // G
240 tmp_pixelval = (int)(((float)(*src_word) / 65535.0f) * 1023.0f + 0.5f);
241 *dest_word = qBound(0, tmp_pixelval, 1023);
242 src_word++;
243 dest_word++;
244 // B
245 tmp_pixelval = (int)(((float)(*src_word) / 65535.0f) * 1023.0f + 0.5f);
246 *dest_word = qBound(0, tmp_pixelval, 1023);
247 src_word++;
248 dest_word++;
249 // A
250 tmp_pixelval = (int)(((float)(*src_word) / 65535.0f) * 1023.0f + 0.5f);
251 *dest_word = qBound(0, tmp_pixelval, 1023);
252 src_word++;
253 dest_word++;
254 }
255 }
256 } else { // no alpha channel
257 for (int y = 0; y < tmpimage.height(); y++) {
258 const uint16_t *src_word = reinterpret_cast<const uint16_t *>(tmpimage.constScanLine(y));
259 uint16_t *dest_word = reinterpret_cast<uint16_t *>(dst + (y * stride));
260 for (int x = 0; x < tmpimage.width(); x++) {
261 int tmp_pixelval;
262 // R
263 tmp_pixelval = (int)(((float)(*src_word) / 65535.0f) * 1023.0f + 0.5f);
264 *dest_word = qBound(0, tmp_pixelval, 1023);
265 src_word++;
266 dest_word++;
267 // G
268 tmp_pixelval = (int)(((float)(*src_word) / 65535.0f) * 1023.0f + 0.5f);
269 *dest_word = qBound(0, tmp_pixelval, 1023);
270 src_word++;
271 dest_word++;
272 // B
273 tmp_pixelval = (int)(((float)(*src_word) / 65535.0f) * 1023.0f + 0.5f);
274 *dest_word = qBound(0, tmp_pixelval, 1023);
275 src_word++;
276 dest_word++;
277 // X
278 src_word++;
279 }
280 }
281 }
282 break;
283 case 8:
284 rowbytes = save_alpha ? (tmpimage.width() * 4) : (tmpimage.width() * 3);
285 for (int y = 0; y < tmpimage.height(); y++) {
286 memcpy(dst + (y * stride), tmpimage.constScanLine(y), rowbytes);
287 }
288 break;
289 default:
290 qWarning() << "Unsupported depth:" << save_depth;
291 heif_image_release(h_image);
292 heif_context_free(context);
293 return false;
294 break;
295 }
296
297 struct heif_encoder *encoder = nullptr;
298 err = heif_context_get_encoder_for_format(context, encoder_codec, &encoder);
299 if (err.code) {
300 qWarning() << "Unable to get an encoder instance:" << err.message;
301 heif_image_release(h_image);
302 heif_context_free(context);
303 return false;
304 }
305
306 heif_encoder_set_lossy_quality(encoder, m_quality);
307 if (m_quality > 90) {
308 if (m_quality == 100) {
309 heif_encoder_set_lossless(encoder, true);
310 }
311 heif_encoder_set_parameter_string(encoder, "chroma", "444");
312 }
313
314 struct heif_encoding_options *encoder_options = heif_encoding_options_alloc();
315 encoder_options->save_alpha_channel = save_alpha;
316
317 if ((tmpimage.width() % 2 == 1) || (tmpimage.height() % 2 == 1)) {
318 qWarning() << "Image has odd dimension!\nUse even-numbered dimension(s) for better compatibility with other HEIF implementations.";
319 if (save_alpha) {
320 // This helps to save alpha channel when image has odd dimension
321 encoder_options->macOS_compatibility_workaround = 0;
322 }
323 }
324
325 struct heif_image_handle *handle;
326 err = heif_context_encode_image(context, h_image, encoder, encoder_options, &handle);
327
328 // exif metadata
329 if (err.code == heif_error_Ok) {
330 auto exif = MicroExif::fromImage(tmpimage);
331 if (!exif.isEmpty()) {
332 auto ba = exif.toByteArray();
333 err = heif_context_add_exif_metadata(context, handle, ba.constData(), ba.size());
334 }
335 }
336 // xmp metadata
337 if (err.code == heif_error_Ok) {
338 auto xmp = image.text(QStringLiteral(META_KEY_XMP_ADOBE));
339 if (!xmp.isEmpty()) {
340 auto ba = xmp.toUtf8();
341 err = heif_context_add_XMP_metadata(context, handle, ba.constData(), ba.size());
342 }
343 }
344
345 if (encoder_options) {
346 heif_encoding_options_free(encoder_options);
347 }
348
349 if (err.code) {
350 qWarning() << "heif_context_encode_image failed:" << err.message;
351 heif_encoder_release(encoder);
352 heif_image_release(h_image);
353 heif_context_free(context);
354 return false;
355 }
356
357 struct heif_writer writer;
358 writer.writer_api_version = 1;
359 writer.write = heifhandler_write_callback;
360
361 err = heif_context_write(context, &writer, device());
362
363 heif_encoder_release(encoder);
364 heif_image_release(h_image);
365
366 if (err.code) {
367 qWarning() << "Writing HEIF image failed:" << err.message;
368 heif_context_free(context);
369 return false;
370 }
371
372 heif_context_free(context);
373 return true;
374}
375
376bool HEIFHandler::isSupportedBMFFType(const QByteArray &header)
377{
378 if (header.size() < 28) {
379 return false;
380 }
381
382 const char *buffer = header.constData();
383 if (memcmp(buffer + 4, "ftyp", 4) == 0) {
384 if (memcmp(buffer + 8, "heic", 4) == 0) {
385 return true;
386 }
387 if (memcmp(buffer + 8, "heis", 4) == 0) {
388 return true;
389 }
390 if (memcmp(buffer + 8, "heix", 4) == 0) {
391 return true;
392 }
393
394 /* we want to avoid loading AVIF files via this plugin */
395 if (memcmp(buffer + 8, "mif1", 4) == 0) {
396 for (int offset = 16; offset <= 24; offset += 4) {
397 if (memcmp(buffer + offset, "avif", 4) == 0) {
398 return false;
399 }
400 }
401 return true;
402 }
403
404 if (memcmp(buffer + 8, "mif2", 4) == 0) {
405 return true;
406 }
407 if (memcmp(buffer + 8, "msf1", 4) == 0) {
408 return true;
409 }
410 }
411
412 return false;
413}
414
415bool HEIFHandler::isSupportedHEJ2(const QByteArray &header)
416{
417 if (header.size() < 28) {
418 return false;
419 }
420
421 const char *buffer = header.constData();
422 if (memcmp(buffer + 4, "ftypj2ki", 8) == 0) {
423 return true;
424 }
425
426 return false;
427}
428
429bool HEIFHandler::isSupportedAVCI(const QByteArray &header)
430{
431 if (header.size() < 28) {
432 return false;
433 }
434
435 const char *buffer = header.constData();
436 if (memcmp(buffer + 4, "ftypavci", 8) == 0) {
437 return true;
438 }
439
440 return false;
441}
442
443QVariant HEIFHandler::option(ImageOption option) const
444{
445 if (option == Quality) {
446 return m_quality;
447 }
448
449 if (!supportsOption(option) || !ensureParsed()) {
450 return QVariant();
451 }
452
453 switch (option) {
454 case Size:
455 return m_current_image.size();
456 break;
457 default:
458 return QVariant();
459 break;
460 }
461}
462
463void HEIFHandler::setOption(ImageOption option, const QVariant &value)
464{
465 switch (option) {
466 case Quality:
467 m_quality = value.toInt();
468 if (m_quality > 100) {
469 m_quality = 100;
470 } else if (m_quality < 0) {
471 m_quality = 100;
472 }
473 break;
474 default:
475 QImageIOHandler::setOption(option, value);
476 break;
477 }
478}
479
480bool HEIFHandler::supportsOption(ImageOption option) const
481{
482 return option == Quality || option == Size;
483}
484
485bool HEIFHandler::ensureParsed() const
486{
487 if (m_parseState == ParseHeicSuccess) {
488 return true;
489 }
490 if (m_parseState == ParseHeicError) {
491 return false;
492 }
493
494 HEIFHandler *that = const_cast<HEIFHandler *>(this);
495
496#if LIBHEIF_HAVE_VERSION(1, 13, 0)
497 startHeifLib();
498#endif
499
500 bool success = that->ensureDecoder();
501
502#if LIBHEIF_HAVE_VERSION(1, 13, 0)
503 finishHeifLib();
504#endif
505 return success;
506}
507
508bool HEIFHandler::ensureDecoder()
509{
510 if (m_parseState != ParseHeicNotParsed) {
511 if (m_parseState == ParseHeicSuccess) {
512 return true;
513 }
514 return false;
515 }
516
517 const QByteArray buffer = device()->readAll();
518 if (!HEIFHandler::isSupportedBMFFType(buffer) && !HEIFHandler::isSupportedHEJ2(buffer) && !HEIFHandler::isSupportedAVCI(buffer)) {
519 m_parseState = ParseHeicError;
520 return false;
521 }
522
523 struct heif_context *ctx = heif_context_alloc();
524 struct heif_error err = heif_context_read_from_memory(ctx, static_cast<const void *>(buffer.constData()), buffer.size(), nullptr);
525
526 if (err.code) {
527 qWarning() << "heif_context_read_from_memory error:" << err.message;
528 heif_context_free(ctx);
529 m_parseState = ParseHeicError;
530 return false;
531 }
532
533 struct heif_image_handle *handle = nullptr;
534 err = heif_context_get_primary_image_handle(ctx, &handle);
535 if (err.code) {
536 qWarning() << "heif_context_get_primary_image_handle error:" << err.message;
537 heif_context_free(ctx);
538 m_parseState = ParseHeicError;
539 return false;
540 }
541
542 if ((heif_image_handle_get_width(handle) == 0) || (heif_image_handle_get_height(handle) == 0)) {
543 m_parseState = ParseHeicError;
544 heif_image_handle_release(handle);
545 heif_context_free(ctx);
546 qWarning() << "HEIC image has zero dimension";
547 return false;
548 }
549
550 const int bit_depth = heif_image_handle_get_luma_bits_per_pixel(handle);
551
552 if (bit_depth < 8) {
553 m_parseState = ParseHeicError;
554 heif_image_handle_release(handle);
555 heif_context_free(ctx);
556 qWarning() << "HEIF image with undefined or unsupported bit depth.";
557 return false;
558 }
559
560 const bool hasAlphaChannel = heif_image_handle_has_alpha_channel(handle);
561 heif_chroma chroma;
562
563 QImage::Format target_image_format;
564
565 if (bit_depth == 10 || bit_depth == 12 || bit_depth == 16) {
566 if (hasAlphaChannel) {
567 chroma = (QSysInfo::ByteOrder == QSysInfo::LittleEndian) ? heif_chroma_interleaved_RRGGBBAA_LE : heif_chroma_interleaved_RRGGBBAA_BE;
568 target_image_format = QImage::Format_RGBA64;
569 } else {
570 chroma = (QSysInfo::ByteOrder == QSysInfo::LittleEndian) ? heif_chroma_interleaved_RRGGBB_LE : heif_chroma_interleaved_RRGGBB_BE;
571 target_image_format = QImage::Format_RGBX64;
572 }
573 } else if (bit_depth == 8) {
574 if (hasAlphaChannel) {
575 chroma = heif_chroma_interleaved_RGBA;
576 target_image_format = QImage::Format_ARGB32;
577 } else {
578 chroma = heif_chroma_interleaved_RGB;
579 target_image_format = QImage::Format_RGB32;
580 }
581 } else {
582 m_parseState = ParseHeicError;
583 heif_image_handle_release(handle);
584 heif_context_free(ctx);
585 qWarning() << "Unsupported bit depth:" << bit_depth;
586 return false;
587 }
588
589 struct heif_decoding_options *decoder_option = heif_decoding_options_alloc();
590
591#if LIBHEIF_HAVE_VERSION(1, 13, 0)
592 decoder_option->strict_decoding = 1;
593#endif
594
595 struct heif_image *img = nullptr;
596 err = heif_decode_image(handle, &img, heif_colorspace_RGB, chroma, decoder_option);
597
598#if LIBHEIF_HAVE_VERSION(1, 13, 0)
599 if (err.code == heif_error_Invalid_input && err.subcode == heif_suberror_Unknown_NCLX_matrix_coefficients && img == nullptr && buffer.contains("Xiaomi")) {
600 qWarning() << "Non-standard HEIF image with invalid matrix_coefficients, probably made by a Xiaomi device!";
601
602 // second try to decode with strict decoding disabled
603 decoder_option->strict_decoding = 0;
604 err = heif_decode_image(handle, &img, heif_colorspace_RGB, chroma, decoder_option);
605 }
606#endif
607
608 if (decoder_option) {
609 heif_decoding_options_free(decoder_option);
610 }
611
612 if (err.code) {
613 qWarning() << "heif_decode_image error:" << err.message;
614 heif_image_handle_release(handle);
615 heif_context_free(ctx);
616 m_parseState = ParseHeicError;
617 return false;
618 }
619
620 const int imageWidth = heif_image_get_width(img, heif_channel_interleaved);
621 const int imageHeight = heif_image_get_height(img, heif_channel_interleaved);
622
623 QSize imageSize(imageWidth, imageHeight);
624
625 if (!imageSize.isValid()) {
626 heif_image_release(img);
627 heif_image_handle_release(handle);
628 heif_context_free(ctx);
629 m_parseState = ParseHeicError;
630 qWarning() << "HEIC image size invalid:" << imageSize;
631 return false;
632 }
633
634 int stride = 0;
635 const uint8_t *const src = heif_image_get_plane_readonly(img, heif_channel_interleaved, &stride);
636
637 if (!src || stride <= 0) {
638 heif_image_release(img);
639 heif_image_handle_release(handle);
640 heif_context_free(ctx);
641 m_parseState = ParseHeicError;
642 qWarning() << "HEIC data pixels information not valid!";
643 return false;
644 }
645
646 m_current_image = imageAlloc(imageSize, target_image_format);
647 if (m_current_image.isNull()) {
648 heif_image_release(img);
649 heif_image_handle_release(handle);
650 heif_context_free(ctx);
651 m_parseState = ParseHeicError;
652 qWarning() << "Unable to allocate memory!";
653 return false;
654 }
655
656 switch (bit_depth) {
657 case 16:
658 if (hasAlphaChannel) {
659 for (int y = 0; y < imageHeight; y++) {
660 memcpy(m_current_image.scanLine(y), src + (y * stride), 8 * size_t(imageWidth));
661 }
662 } else { // no alpha channel
663 for (int y = 0; y < imageHeight; y++) {
664 const uint16_t *src_word = reinterpret_cast<const uint16_t *>(src + (y * stride));
665 uint16_t *dest_data = reinterpret_cast<uint16_t *>(m_current_image.scanLine(y));
666 for (int x = 0; x < imageWidth; x++) {
667 // R
668 *dest_data = *src_word;
669 src_word++;
670 dest_data++;
671 // G
672 *dest_data = *src_word;
673 src_word++;
674 dest_data++;
675 // B
676 *dest_data = *src_word;
677 src_word++;
678 dest_data++;
679 // X = 0xffff
680 *dest_data = 0xffff;
681 dest_data++;
682 }
683 }
684 }
685 break;
686 case 12:
687 if (hasAlphaChannel) {
688 for (int y = 0; y < imageHeight; y++) {
689 const uint16_t *src_word = reinterpret_cast<const uint16_t *>(src + (y * stride));
690 uint16_t *dest_data = reinterpret_cast<uint16_t *>(m_current_image.scanLine(y));
691 for (int x = 0; x < imageWidth; x++) {
692 int tmpvalue;
693 // R
694 tmpvalue = (int)(((float)(0x0fff & (*src_word)) / 4095.0f) * 65535.0f + 0.5f);
695 tmpvalue = qBound(0, tmpvalue, 65535);
696 *dest_data = (uint16_t)tmpvalue;
697 src_word++;
698 dest_data++;
699 // G
700 tmpvalue = (int)(((float)(0x0fff & (*src_word)) / 4095.0f) * 65535.0f + 0.5f);
701 tmpvalue = qBound(0, tmpvalue, 65535);
702 *dest_data = (uint16_t)tmpvalue;
703 src_word++;
704 dest_data++;
705 // B
706 tmpvalue = (int)(((float)(0x0fff & (*src_word)) / 4095.0f) * 65535.0f + 0.5f);
707 tmpvalue = qBound(0, tmpvalue, 65535);
708 *dest_data = (uint16_t)tmpvalue;
709 src_word++;
710 dest_data++;
711 // A
712 tmpvalue = (int)(((float)(0x0fff & (*src_word)) / 4095.0f) * 65535.0f + 0.5f);
713 tmpvalue = qBound(0, tmpvalue, 65535);
714 *dest_data = (uint16_t)tmpvalue;
715 src_word++;
716 dest_data++;
717 }
718 }
719 } else { // no alpha channel
720 for (int y = 0; y < imageHeight; y++) {
721 const uint16_t *src_word = reinterpret_cast<const uint16_t *>(src + (y * stride));
722 uint16_t *dest_data = reinterpret_cast<uint16_t *>(m_current_image.scanLine(y));
723 for (int x = 0; x < imageWidth; x++) {
724 int tmpvalue;
725 // R
726 tmpvalue = (int)(((float)(0x0fff & (*src_word)) / 4095.0f) * 65535.0f + 0.5f);
727 tmpvalue = qBound(0, tmpvalue, 65535);
728 *dest_data = (uint16_t)tmpvalue;
729 src_word++;
730 dest_data++;
731 // G
732 tmpvalue = (int)(((float)(0x0fff & (*src_word)) / 4095.0f) * 65535.0f + 0.5f);
733 tmpvalue = qBound(0, tmpvalue, 65535);
734 *dest_data = (uint16_t)tmpvalue;
735 src_word++;
736 dest_data++;
737 // B
738 tmpvalue = (int)(((float)(0x0fff & (*src_word)) / 4095.0f) * 65535.0f + 0.5f);
739 tmpvalue = qBound(0, tmpvalue, 65535);
740 *dest_data = (uint16_t)tmpvalue;
741 src_word++;
742 dest_data++;
743 // X = 0xffff
744 *dest_data = 0xffff;
745 dest_data++;
746 }
747 }
748 }
749 break;
750 case 10:
751 if (hasAlphaChannel) {
752 for (int y = 0; y < imageHeight; y++) {
753 const uint16_t *src_word = reinterpret_cast<const uint16_t *>(src + (y * stride));
754 uint16_t *dest_data = reinterpret_cast<uint16_t *>(m_current_image.scanLine(y));
755 for (int x = 0; x < imageWidth; x++) {
756 int tmpvalue;
757 // R
758 tmpvalue = (int)(((float)(0x03ff & (*src_word)) / 1023.0f) * 65535.0f + 0.5f);
759 tmpvalue = qBound(0, tmpvalue, 65535);
760 *dest_data = (uint16_t)tmpvalue;
761 src_word++;
762 dest_data++;
763 // G
764 tmpvalue = (int)(((float)(0x03ff & (*src_word)) / 1023.0f) * 65535.0f + 0.5f);
765 tmpvalue = qBound(0, tmpvalue, 65535);
766 *dest_data = (uint16_t)tmpvalue;
767 src_word++;
768 dest_data++;
769 // B
770 tmpvalue = (int)(((float)(0x03ff & (*src_word)) / 1023.0f) * 65535.0f + 0.5f);
771 tmpvalue = qBound(0, tmpvalue, 65535);
772 *dest_data = (uint16_t)tmpvalue;
773 src_word++;
774 dest_data++;
775 // A
776 tmpvalue = (int)(((float)(0x03ff & (*src_word)) / 1023.0f) * 65535.0f + 0.5f);
777 tmpvalue = qBound(0, tmpvalue, 65535);
778 *dest_data = (uint16_t)tmpvalue;
779 src_word++;
780 dest_data++;
781 }
782 }
783 } else { // no alpha channel
784 for (int y = 0; y < imageHeight; y++) {
785 const uint16_t *src_word = reinterpret_cast<const uint16_t *>(src + (y * stride));
786 uint16_t *dest_data = reinterpret_cast<uint16_t *>(m_current_image.scanLine(y));
787 for (int x = 0; x < imageWidth; x++) {
788 int tmpvalue;
789 // R
790 tmpvalue = (int)(((float)(0x03ff & (*src_word)) / 1023.0f) * 65535.0f + 0.5f);
791 tmpvalue = qBound(0, tmpvalue, 65535);
792 *dest_data = (uint16_t)tmpvalue;
793 src_word++;
794 dest_data++;
795 // G
796 tmpvalue = (int)(((float)(0x03ff & (*src_word)) / 1023.0f) * 65535.0f + 0.5f);
797 tmpvalue = qBound(0, tmpvalue, 65535);
798 *dest_data = (uint16_t)tmpvalue;
799 src_word++;
800 dest_data++;
801 // B
802 tmpvalue = (int)(((float)(0x03ff & (*src_word)) / 1023.0f) * 65535.0f + 0.5f);
803 tmpvalue = qBound(0, tmpvalue, 65535);
804 *dest_data = (uint16_t)tmpvalue;
805 src_word++;
806 dest_data++;
807 // X = 0xffff
808 *dest_data = 0xffff;
809 dest_data++;
810 }
811 }
812 }
813 break;
814 case 8:
815 if (hasAlphaChannel) {
816 for (int y = 0; y < imageHeight; y++) {
817 const uint8_t *src_byte = src + (y * stride);
818 uint32_t *dest_pixel = reinterpret_cast<uint32_t *>(m_current_image.scanLine(y));
819 for (int x = 0; x < imageWidth; x++) {
820 int red = *src_byte++;
821 int green = *src_byte++;
822 int blue = *src_byte++;
823 int alpha = *src_byte++;
824 *dest_pixel = qRgba(red, green, blue, alpha);
825 dest_pixel++;
826 }
827 }
828 } else { // no alpha channel
829 for (int y = 0; y < imageHeight; y++) {
830 const uint8_t *src_byte = src + (y * stride);
831 uint32_t *dest_pixel = reinterpret_cast<uint32_t *>(m_current_image.scanLine(y));
832 for (int x = 0; x < imageWidth; x++) {
833 int red = *src_byte++;
834 int green = *src_byte++;
835 int blue = *src_byte++;
836 *dest_pixel = qRgb(red, green, blue);
837 dest_pixel++;
838 }
839 }
840 }
841 break;
842 default:
843 heif_image_release(img);
844 heif_image_handle_release(handle);
845 heif_context_free(ctx);
846 m_parseState = ParseHeicError;
847 qWarning() << "Unsupported bit depth:" << bit_depth;
848 return false;
849 break;
850 }
851
852 heif_color_profile_type profileType = heif_image_handle_get_color_profile_type(handle);
853 if (profileType == heif_color_profile_type_prof || profileType == heif_color_profile_type_rICC) {
854 size_t rawProfileSize = heif_image_handle_get_raw_color_profile_size(handle);
855 if (rawProfileSize > 0 && rawProfileSize < std::numeric_limits<int>::max()) {
856 QByteArray ba(rawProfileSize, 0);
857 err = heif_image_handle_get_raw_color_profile(handle, ba.data());
858 if (err.code) {
859 qWarning() << "icc profile loading failed";
860 } else {
861 QColorSpace colorspace = QColorSpace::fromIccProfile(ba);
862 if (!colorspace.isValid()) {
863 qWarning() << "HEIC image has Qt-unsupported or invalid ICC profile!";
864 }
865#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
866 else if (colorspace.colorModel() == QColorSpace::ColorModel::Cmyk) {
867 qWarning("CMYK ICC profile is not expected for HEIF, discarding the ICCprofile!");
868 colorspace = QColorSpace();
869 } else if (colorspace.colorModel() == QColorSpace::ColorModel::Gray) {
870 if (hasAlphaChannel) {
871 QPointF gray_whitePoint = colorspace.whitePoint();
872 if (gray_whitePoint.isNull()) {
873 gray_whitePoint = QPointF(0.3127f, 0.329f);
874 }
875
876 const QPointF redP(0.64f, 0.33f);
877 const QPointF greenP(0.3f, 0.6f);
878 const QPointF blueP(0.15f, 0.06f);
879
880 QColorSpace::TransferFunction trc_new = colorspace.transferFunction();
881 float gamma_new = colorspace.gamma();
882 if (trc_new == QColorSpace::TransferFunction::Custom) {
883 trc_new = QColorSpace::TransferFunction::SRgb;
884 }
885 colorspace = QColorSpace(gray_whitePoint, redP, greenP, blueP, trc_new, gamma_new);
886 if (!colorspace.isValid()) {
887 qWarning("HEIF plugin created invalid QColorSpace!");
888 }
889 } else { // no alpha channel
890 m_current_image.convertTo(bit_depth > 8 ? QImage::Format_Grayscale16 : QImage::Format_Grayscale8);
891 }
892 }
893#endif
894 m_current_image.setColorSpace(colorspace);
895 }
896 } else {
897 qWarning() << "icc profile is empty or above limits";
898 }
899
900 } else if (profileType == heif_color_profile_type_nclx) {
901 struct heif_color_profile_nclx *nclx = nullptr;
902 err = heif_image_handle_get_nclx_color_profile(handle, &nclx);
903 if (err.code || !nclx) {
904 qWarning() << "nclx profile loading failed";
905 } else {
906 const QPointF redPoint(nclx->color_primary_red_x, nclx->color_primary_red_y);
907 const QPointF greenPoint(nclx->color_primary_green_x, nclx->color_primary_green_y);
908 const QPointF bluePoint(nclx->color_primary_blue_x, nclx->color_primary_blue_y);
909 const QPointF whitePoint(nclx->color_primary_white_x, nclx->color_primary_white_y);
910
911 QColorSpace::TransferFunction q_trc = QColorSpace::TransferFunction::Custom;
912 float q_trc_gamma = 0.0f;
913
914 switch (nclx->transfer_characteristics) {
915 case 4:
916 q_trc = QColorSpace::TransferFunction::Gamma;
917 q_trc_gamma = 2.2f;
918 break;
919 case 5:
920 q_trc = QColorSpace::TransferFunction::Gamma;
921 q_trc_gamma = 2.8f;
922 break;
923 case 8:
924 q_trc = QColorSpace::TransferFunction::Linear;
925 break;
926 case 2:
927 case 13:
928 q_trc = QColorSpace::TransferFunction::SRgb;
929 break;
930#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
931 case 16:
932 q_trc = QColorSpace::TransferFunction::St2084;
933 break;
934 case 18:
935 q_trc = QColorSpace::TransferFunction::Hlg;
936 break;
937#endif
938 default:
939 qWarning("CICP color_primaries: %d, transfer_characteristics: %d\nThe colorspace is unsupported by this plug-in yet.",
940 nclx->color_primaries,
941 nclx->transfer_characteristics);
942 q_trc = QColorSpace::TransferFunction::SRgb;
943 break;
944 }
945
946 if (q_trc != QColorSpace::TransferFunction::Custom) { // we create new colorspace using Qt
947 switch (nclx->color_primaries) {
948 case 1:
949 case 2:
950 m_current_image.setColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, q_trc, q_trc_gamma));
951 break;
952 case 12:
953 m_current_image.setColorSpace(QColorSpace(QColorSpace::Primaries::DciP3D65, q_trc, q_trc_gamma));
954 break;
955 default:
956 m_current_image.setColorSpace(QColorSpace(whitePoint, redPoint, greenPoint, bluePoint, q_trc, q_trc_gamma));
957 break;
958 }
959 }
960 heif_nclx_color_profile_free(nclx);
961
962 if (!m_current_image.colorSpace().isValid()) {
963 qWarning() << "HEIC plugin created invalid QColorSpace from NCLX!";
964 }
965 }
966
967 } else {
968 m_current_image.setColorSpace(QColorSpace(QColorSpace::SRgb));
969 }
970
971 // read metadata
972 if (auto numMetadata = heif_image_handle_get_number_of_metadata_blocks(handle, nullptr)) {
973 QVector<heif_item_id> ids(numMetadata);
974 heif_image_handle_get_list_of_metadata_block_IDs(handle, nullptr, ids.data(), numMetadata);
975 for (int n = 0; n < numMetadata; ++n) {
976 auto itemtype = heif_image_handle_get_metadata_type(handle, ids[n]);
977 auto contenttype = heif_image_handle_get_metadata_content_type(handle, ids[n]);
978 auto isExif = !std::strcmp(itemtype, "Exif");
979 auto isXmp = !std::strcmp(contenttype, "application/rdf+xml");
980 if (isExif || isXmp) {
981 auto sz = heif_image_handle_get_metadata_size(handle, ids[n]);
982 if (sz == 0 || sz >= HEIF_MAX_METADATA_SIZE)
983 continue;
984 QByteArray ba(sz, char());
985 auto err = heif_image_handle_get_metadata(handle, ids[n], ba.data());
986 if (err.code != heif_error_Ok) {
987 qWarning() << "Error while reading metadata" << err.message;
988 continue;
989 }
990 if (isXmp) {
991 m_current_image.setText(QStringLiteral(META_KEY_XMP_ADOBE), QString::fromUtf8(ba));
992 } else if (isExif) {
993 auto exif = MicroExif::fromByteArray(ba, true);
994 if (!exif.isEmpty()) {
995 exif.updateImageResolution(m_current_image);
996 exif.updateImageMetadata(m_current_image);
997 }
998 }
999 }
1000 }
1001 }
1002
1003 heif_image_release(img);
1004 heif_image_handle_release(handle);
1005 heif_context_free(ctx);
1006 m_parseState = ParseHeicSuccess;
1007 return true;
1008}
1009
1010bool HEIFHandler::isHeifDecoderAvailable()
1011{
1012 HEIFHandler::queryHeifLib();
1013
1014 return m_heif_decoder_available;
1015}
1016
1017bool HEIFHandler::isHeifEncoderAvailable()
1018{
1019 HEIFHandler::queryHeifLib();
1020
1021 return m_heif_encoder_available;
1022}
1023
1024bool HEIFHandler::isHej2DecoderAvailable()
1025{
1026 HEIFHandler::queryHeifLib();
1027
1028 return m_hej2_decoder_available;
1029}
1030
1031bool HEIFHandler::isHej2EncoderAvailable()
1032{
1033 HEIFHandler::queryHeifLib();
1034
1035 return m_hej2_encoder_available;
1036}
1037
1038bool HEIFHandler::isAVCIDecoderAvailable()
1039{
1040 HEIFHandler::queryHeifLib();
1041
1042 return m_avci_decoder_available;
1043}
1044
1045void HEIFHandler::queryHeifLib()
1046{
1047 QMutexLocker locker(&getHEIFHandlerMutex());
1048
1049 if (!m_plugins_queried) {
1050#if LIBHEIF_HAVE_VERSION(1, 13, 0)
1051 if (m_initialized_count == 0) {
1052 heif_init(nullptr);
1053 }
1054#endif
1055
1056 m_heif_encoder_available = heif_have_encoder_for_format(heif_compression_HEVC);
1057 m_heif_decoder_available = heif_have_decoder_for_format(heif_compression_HEVC);
1058#if LIBHEIF_HAVE_VERSION(1, 13, 0)
1059 m_hej2_decoder_available = heif_have_decoder_for_format(heif_compression_JPEG2000);
1060 m_hej2_encoder_available = heif_have_encoder_for_format(heif_compression_JPEG2000);
1061#endif
1062#if LIBHEIF_HAVE_VERSION(1, 19, 6)
1063 m_avci_decoder_available = heif_have_decoder_for_format(heif_compression_AVC);
1064#endif
1065 m_plugins_queried = true;
1066
1067#if LIBHEIF_HAVE_VERSION(1, 13, 0)
1068 if (m_initialized_count == 0) {
1069 heif_deinit();
1070 }
1071#endif
1072 }
1073}
1074
1075void HEIFHandler::startHeifLib()
1076{
1077#if LIBHEIF_HAVE_VERSION(1, 13, 0)
1078 QMutexLocker locker(&getHEIFHandlerMutex());
1079
1080 if (m_initialized_count == 0) {
1081 heif_init(nullptr);
1082 }
1083
1084 m_initialized_count++;
1085#endif
1086}
1087
1088void HEIFHandler::finishHeifLib()
1089{
1090#if LIBHEIF_HAVE_VERSION(1, 13, 0)
1091 QMutexLocker locker(&getHEIFHandlerMutex());
1092
1093 if (m_initialized_count == 0) {
1094 return;
1095 }
1096
1097 m_initialized_count--;
1098 if (m_initialized_count == 0) {
1099 heif_deinit();
1100 }
1101
1102#endif
1103}
1104
1105QMutex &HEIFHandler::getHEIFHandlerMutex()
1106{
1107 static QMutex heif_handler_mutex;
1108 return heif_handler_mutex;
1109}
1110
1111QImageIOPlugin::Capabilities HEIFPlugin::capabilities(QIODevice *device, const QByteArray &format) const
1112{
1113 if (format == "heif" || format == "heic") {
1114 Capabilities format_cap;
1115 if (HEIFHandler::isHeifDecoderAvailable()) {
1116 format_cap |= CanRead;
1117 }
1118 if (HEIFHandler::isHeifEncoderAvailable()) {
1119 format_cap |= CanWrite;
1120 }
1121 return format_cap;
1122 }
1123
1124 if (format == "hej2") {
1125 Capabilities format_cap;
1126 if (HEIFHandler::isHej2DecoderAvailable()) {
1127 format_cap |= CanRead;
1128 }
1129 if (HEIFHandler::isHej2EncoderAvailable()) {
1130 format_cap |= CanWrite;
1131 }
1132 return format_cap;
1133 }
1134
1135 if (format == "avci") {
1136 Capabilities format_cap;
1137 if (HEIFHandler::isAVCIDecoderAvailable()) {
1138 format_cap |= CanRead;
1139 }
1140 return format_cap;
1141 }
1142
1143 if (!format.isEmpty()) {
1144 return {};
1145 }
1146 if (!device->isOpen()) {
1147 return {};
1148 }
1149
1150 Capabilities cap;
1151 if (device->isReadable()) {
1152 const QByteArray header = device->peek(28);
1153
1154 if ((HEIFHandler::isSupportedBMFFType(header) && HEIFHandler::isHeifDecoderAvailable())
1155 || (HEIFHandler::isSupportedHEJ2(header) && HEIFHandler::isHej2DecoderAvailable())
1156 || (HEIFHandler::isSupportedAVCI(header) && HEIFHandler::isAVCIDecoderAvailable())) {
1157 cap |= CanRead;
1158 }
1159 }
1160
1161 if (device->isWritable() && (HEIFHandler::isHeifEncoderAvailable() || HEIFHandler::isHej2EncoderAvailable())) {
1162 cap |= CanWrite;
1163 }
1164 return cap;
1165}
1166
1167QImageIOHandler *HEIFPlugin::create(QIODevice *device, const QByteArray &format) const
1168{
1169 QImageIOHandler *handler = new HEIFHandler;
1170 handler->setDevice(device);
1171 handler->setFormat(format);
1172 return handler;
1173}
1174
1175#include "moc_heif_p.cpp"
KColorUtils::chroma
KGUIADDONS_EXPORT qreal chroma(const QColor &)
KGameAudioScene::Capabilities
QFlags< Capability > Capabilities
KMessageBox::error
void error(QWidget *parent, const QString &text, const QString &title, const KGuiItem &buttonOk, Options options=Notify)
QByteArray::constData
const char * constData() const const
QByteArray::contains
bool contains(QByteArrayView bv) const const
QByteArray::isEmpty
bool isEmpty() const const
QByteArray::size
qsizetype size() const const
QColorSpace::fromIccProfile
QColorSpace fromIccProfile(const QByteArray &iccProfile)
QColorSpace::gamma
float gamma() const const
QColorSpace::iccProfile
QByteArray iccProfile() const const
QColorSpace::isValid
bool isValid() const const
QColorSpace::transferFunction
TransferFunction transferFunction() const const
QImage::colorSpace
QColorSpace colorSpace() const const
QImage::constScanLine
const uchar * constScanLine(int i) const const
QImage::convertToFormat
QImage convertToFormat(Format format, Qt::ImageConversionFlags flags) &&
QImage::convertedToColorSpace
QImage convertedToColorSpace(const QColorSpace &colorSpace) const const
QImage::depth
int depth() const const
QImage::format
Format format() const const
QImage::hasAlphaChannel
bool hasAlphaChannel() const const
QImage::height
int height() const const
QImage::isNull
bool isNull() const const
QImage::text
QString text(const QString &key) const const
QImage::width
int width() const const
QImageIOHandler::setDevice
void setDevice(QIODevice *device)
QImageIOHandler::setFormat
void setFormat(const QByteArray &format)
QImageIOHandler::setOption
virtual void setOption(ImageOption option, const QVariant &value)
QImageIOPlugin::Capabilities
typedef Capabilities
QIODevice::isOpen
bool isOpen() const const
QIODevice::isReadable
bool isReadable() const const
QIODevice::isWritable
bool isWritable() const const
QIODevice::peek
QByteArray peek(qint64 maxSize)
QIODevice::write
qint64 write(const QByteArray &data)
QPointF::isNull
bool isNull() const const
QString::fromUtf8
QString fromUtf8(QByteArrayView str)
QVariant::toInt
int toInt(bool *ok) const const
This file is part of the KDE documentation.
Documentation copyright © 1996-2025 The KDE developers.
Generated on Fri Apr 25 2025 11:46:32 by doxygen 1.13.2 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.