KImageFormats

avif.cpp
1/*
2 AV1 Image File Format (AVIF) support for QImage.
3
4 SPDX-FileCopyrightText: 2020 Daniel Novomesky <dnovomesky@gmail.com>
5
6 SPDX-License-Identifier: BSD-2-Clause
7*/
8
9#include <QThread>
10#include <QtGlobal>
11
12#include <QColorSpace>
13
14#include "avif_p.h"
15#include "microexif_p.h"
16#include "util_p.h"
17
18#include <cfloat>
19
20/*
21Quality range - compression/subsampling
22100 - lossless RGB compression
23< KIMG_AVIF_QUALITY_BEST, 100 ) - YUV444 color subsampling
24< KIMG_AVIF_QUALITY_HIGH, KIMG_AVIF_QUALITY_BEST ) - YUV422 color subsampling
25< 0, KIMG_AVIF_QUALITY_HIGH ) - YUV420 color subsampling
26< 0, KIMG_AVIF_QUALITY_LOW ) - lossy compression of alpha channel
27*/
28
29#ifndef KIMG_AVIF_DEFAULT_QUALITY
30#define KIMG_AVIF_DEFAULT_QUALITY 68
31#endif
32
33#ifndef KIMG_AVIF_QUALITY_BEST
34#define KIMG_AVIF_QUALITY_BEST 90
35#endif
36
37#ifndef KIMG_AVIF_QUALITY_HIGH
38#define KIMG_AVIF_QUALITY_HIGH 80
39#endif
40
41#ifndef KIMG_AVIF_QUALITY_LOW
42#define KIMG_AVIF_QUALITY_LOW 51
43#endif
44
45QAVIFHandler::QAVIFHandler()
46 : m_parseState(ParseAvifNotParsed)
47 , m_quality(KIMG_AVIF_DEFAULT_QUALITY)
48 , m_container_width(0)
49 , m_container_height(0)
50 , m_rawAvifData(AVIF_DATA_EMPTY)
51 , m_decoder(nullptr)
52 , m_must_jump_to_next_image(false)
53{
54}
55
56QAVIFHandler::~QAVIFHandler()
57{
58 if (m_decoder) {
59 avifDecoderDestroy(m_decoder);
60 }
61}
62
63bool QAVIFHandler::canRead() const
64{
65 if (m_parseState == ParseAvifNotParsed && !canRead(device())) {
66 return false;
67 }
68
69 if (m_parseState != ParseAvifError) {
70 setFormat("avif");
71
72 if (m_parseState == ParseAvifFinished) {
73 return false;
74 }
75
76 return true;
77 }
78 return false;
79}
80
81bool QAVIFHandler::canRead(QIODevice *device)
82{
83 if (!device) {
84 return false;
85 }
86 QByteArray header = device->peek(144);
87 if (header.size() < 12) {
88 return false;
89 }
90
91 avifROData input;
92 input.data = reinterpret_cast<const uint8_t *>(header.constData());
93 input.size = header.size();
94
95 if (avifPeekCompatibleFileType(&input)) {
96 return true;
97 }
98 return false;
99}
100
101bool QAVIFHandler::ensureParsed() const
102{
103 if (m_parseState == ParseAvifSuccess || m_parseState == ParseAvifMetadata || m_parseState == ParseAvifFinished) {
104 return true;
105 }
106 if (m_parseState == ParseAvifError) {
107 return false;
108 }
109
110 QAVIFHandler *that = const_cast<QAVIFHandler *>(this);
111
112 return that->ensureDecoder();
113}
114
115bool QAVIFHandler::ensureOpened() const
116{
117 if (m_parseState == ParseAvifSuccess || m_parseState == ParseAvifFinished) {
118 return true;
119 }
120 if (m_parseState == ParseAvifError) {
121 return false;
122 }
123
124 QAVIFHandler *that = const_cast<QAVIFHandler *>(this);
125 if (ensureParsed()) {
126 if (m_parseState == ParseAvifMetadata) {
127 bool success = that->jumpToNextImage();
128 that->m_parseState = success ? ParseAvifSuccess : ParseAvifError;
129 return success;
130 }
131 }
132
133 that->m_parseState = ParseAvifError;
134 return false;
135}
136
137bool QAVIFHandler::ensureDecoder()
138{
139 if (m_decoder) {
140 return true;
141 }
142
143 m_rawData = device()->readAll();
144
145 m_rawAvifData.data = reinterpret_cast<const uint8_t *>(m_rawData.constData());
146 m_rawAvifData.size = m_rawData.size();
147
148 if (avifPeekCompatibleFileType(&m_rawAvifData) == AVIF_FALSE) {
149 m_parseState = ParseAvifError;
150 return false;
151 }
152
153 m_decoder = avifDecoderCreate();
154
155#if AVIF_VERSION >= 80400
156 m_decoder->maxThreads = qBound(1, QThread::idealThreadCount(), 64);
157#endif
158
159#if AVIF_VERSION >= 90100
160 m_decoder->strictFlags = AVIF_STRICT_DISABLED;
161#endif
162
163#if AVIF_VERSION >= 110000
164 m_decoder->imageDimensionLimit = 65535;
165#endif
166
167 avifResult decodeResult;
168
169 decodeResult = avifDecoderSetIOMemory(m_decoder, m_rawAvifData.data, m_rawAvifData.size);
170 if (decodeResult != AVIF_RESULT_OK) {
171 qWarning("ERROR: avifDecoderSetIOMemory failed: %s", avifResultToString(decodeResult));
172
173 avifDecoderDestroy(m_decoder);
174 m_decoder = nullptr;
175 m_parseState = ParseAvifError;
176 return false;
177 }
178
179 decodeResult = avifDecoderParse(m_decoder);
180 if (decodeResult != AVIF_RESULT_OK) {
181 qWarning("ERROR: Failed to parse input: %s", avifResultToString(decodeResult));
182
183 avifDecoderDestroy(m_decoder);
184 m_decoder = nullptr;
185 m_parseState = ParseAvifError;
186 return false;
187 }
188
189 m_container_width = m_decoder->image->width;
190 m_container_height = m_decoder->image->height;
191
192 if ((m_container_width > 65535) || (m_container_height > 65535)) {
193 qWarning("AVIF image (%dx%d) is too large!", m_container_width, m_container_height);
194 m_parseState = ParseAvifError;
195 return false;
196 }
197
198 if ((m_container_width == 0) || (m_container_height == 0)) {
199 qWarning("Empty image, nothing to decode");
200 m_parseState = ParseAvifError;
201 return false;
202 }
203
204 if (m_container_width > ((16384 * 16384) / m_container_height)) {
205 qWarning("AVIF image (%dx%d) has more than 256 megapixels!", m_container_width, m_container_height);
206 m_parseState = ParseAvifError;
207 return false;
208 }
209
210 // calculate final dimensions with crop and rotate operations applied
211 int new_width = m_container_width;
212 int new_height = m_container_height;
213
214 if (m_decoder->image->transformFlags & AVIF_TRANSFORM_CLAP) {
215 if ((m_decoder->image->clap.widthD > 0) && (m_decoder->image->clap.heightD > 0) && (m_decoder->image->clap.horizOffD > 0)
216 && (m_decoder->image->clap.vertOffD > 0)) {
217 int crop_width = (int)((double)(m_decoder->image->clap.widthN) / (m_decoder->image->clap.widthD) + 0.5);
218 if (crop_width < new_width && crop_width > 0) {
219 new_width = crop_width;
220 }
221 int crop_height = (int)((double)(m_decoder->image->clap.heightN) / (m_decoder->image->clap.heightD) + 0.5);
222 if (crop_height < new_height && crop_height > 0) {
223 new_height = crop_height;
224 }
225 }
226 }
227
228 if (m_decoder->image->transformFlags & AVIF_TRANSFORM_IROT) {
229 if (m_decoder->image->irot.angle == 1 || m_decoder->image->irot.angle == 3) {
230 int tmp = new_width;
231 new_width = new_height;
232 new_height = tmp;
233 }
234 }
235
236 m_estimated_dimensions.setWidth(new_width);
237 m_estimated_dimensions.setHeight(new_height);
238
239 m_parseState = ParseAvifMetadata;
240 return true;
241}
242
243bool QAVIFHandler::decode_one_frame()
244{
245 if (!ensureParsed()) {
246 return false;
247 }
248
249 bool loadalpha;
250 bool loadgray = false;
251
252 if (m_decoder->image->alphaPlane) {
253 loadalpha = true;
254 } else {
255 loadalpha = false;
256 if (m_decoder->image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400) {
257 loadgray = true;
258 }
259 }
260
261 QImage::Format resultformat;
262
263 if (m_decoder->image->depth > 8) {
264 if (loadalpha) {
265 resultformat = QImage::Format_RGBA64;
266 } else {
267 resultformat = QImage::Format_RGBX64;
268 }
269 } else {
270 if (loadalpha) {
271 resultformat = QImage::Format_ARGB32;
272 } else {
273 resultformat = QImage::Format_RGB32;
274 }
275 }
276
277 QImage result = imageAlloc(m_decoder->image->width, m_decoder->image->height, resultformat);
278 if (result.isNull()) {
279 qWarning("Memory cannot be allocated");
280 return false;
281 }
282
283 QColorSpace colorspace;
284 if (m_decoder->image->icc.data && (m_decoder->image->icc.size > 0)) {
285 const QByteArray icc_data(reinterpret_cast<const char *>(m_decoder->image->icc.data), m_decoder->image->icc.size);
286 colorspace = QColorSpace::fromIccProfile(icc_data);
287 if (!colorspace.isValid()) {
288 qWarning("AVIF image has Qt-unsupported or invalid ICC profile!");
289 }
290#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
291 else {
292 if (colorspace.colorModel() == QColorSpace::ColorModel::Cmyk) {
293 qWarning("CMYK ICC profile is not extected for AVIF, discarding the ICCprofile!");
294 colorspace = QColorSpace();
295 } else if (colorspace.colorModel() == QColorSpace::ColorModel::Rgb && loadgray) {
296 // Input is GRAY but ICC is RGB, we will return RGB image
297 loadgray = false;
298 } else if (colorspace.colorModel() == QColorSpace::ColorModel::Gray && !loadgray) {
299 // ICC is GRAY but we must return RGB (image has alpha channel for example)
300 // we create similar RGB profile (same whitepoint and TRC)
301 QPointF gray_whitePoint = colorspace.whitePoint();
302 if (gray_whitePoint.isNull()) {
303 gray_whitePoint = QPointF(0.3127f, 0.329f);
304 }
305
306 const QPointF redP(0.64f, 0.33f);
307 const QPointF greenP(0.3f, 0.6f);
308 const QPointF blueP(0.15f, 0.06f);
309
310 QColorSpace::TransferFunction trc_new = colorspace.transferFunction();
311 float gamma_new = colorspace.gamma();
312 if (trc_new == QColorSpace::TransferFunction::Custom) {
313 trc_new = QColorSpace::TransferFunction::SRgb;
314 }
315 colorspace = QColorSpace(gray_whitePoint, redP, greenP, blueP, trc_new, gamma_new);
316 if (!colorspace.isValid()) {
317 qWarning("AVIF plugin created invalid QColorSpace!");
318 }
319 }
320 }
321#endif
322 } else {
323 float prim[8] = {0.64f, 0.33f, 0.3f, 0.6f, 0.15f, 0.06f, 0.3127f, 0.329f};
324 // outPrimaries: rX, rY, gX, gY, bX, bY, wX, wY
325 avifColorPrimariesGetValues(m_decoder->image->colorPrimaries, prim);
326
327 const QPointF redPoint(QAVIFHandler::CompatibleChromacity(prim[0], prim[1]));
328 const QPointF greenPoint(QAVIFHandler::CompatibleChromacity(prim[2], prim[3]));
329 const QPointF bluePoint(QAVIFHandler::CompatibleChromacity(prim[4], prim[5]));
330 const QPointF whitePoint(QAVIFHandler::CompatibleChromacity(prim[6], prim[7]));
331
332 QColorSpace::TransferFunction q_trc = QColorSpace::TransferFunction::Custom;
333 float q_trc_gamma = 0.0f;
334
335 switch (m_decoder->image->transferCharacteristics) {
336 /* AVIF_TRANSFER_CHARACTERISTICS_BT470M */
337 case 4:
338 q_trc = QColorSpace::TransferFunction::Gamma;
339 q_trc_gamma = 2.2f;
340 break;
341 /* AVIF_TRANSFER_CHARACTERISTICS_BT470BG */
342 case 5:
343 q_trc = QColorSpace::TransferFunction::Gamma;
344 q_trc_gamma = 2.8f;
345 break;
346 /* AVIF_TRANSFER_CHARACTERISTICS_LINEAR */
347 case 8:
348 q_trc = QColorSpace::TransferFunction::Linear;
349 break;
350 /* AVIF_TRANSFER_CHARACTERISTICS_SRGB */
351 case 0:
352 case 2: /* AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED */
353 case 13:
354 q_trc = QColorSpace::TransferFunction::SRgb;
355 break;
356#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
357 case 16: /* AVIF_TRANSFER_CHARACTERISTICS_PQ */
358 q_trc = QColorSpace::TransferFunction::St2084;
359 break;
360 case 18: /* AVIF_TRANSFER_CHARACTERISTICS_HLG */
361 q_trc = QColorSpace::TransferFunction::Hlg;
362 break;
363#endif
364 default:
365 qWarning("CICP colorPrimaries: %d, transferCharacteristics: %d\nThe colorspace is unsupported by this plug-in yet.",
366 m_decoder->image->colorPrimaries,
367 m_decoder->image->transferCharacteristics);
368 q_trc = QColorSpace::TransferFunction::SRgb;
369 break;
370 }
371
372 if (q_trc != QColorSpace::TransferFunction::Custom) { // we create new colorspace using Qt
373#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
374 if (loadgray) {
375 colorspace = QColorSpace(whitePoint, q_trc, q_trc_gamma);
376 } else {
377#endif
378 switch (m_decoder->image->colorPrimaries) {
379 /* AVIF_COLOR_PRIMARIES_BT709 */
380 case 0:
381 case 1:
382 case 2: /* AVIF_COLOR_PRIMARIES_UNSPECIFIED */
383 colorspace = QColorSpace(QColorSpace::Primaries::SRgb, q_trc, q_trc_gamma);
384 break;
385 /* AVIF_COLOR_PRIMARIES_SMPTE432 */
386 case 12:
387 colorspace = QColorSpace(QColorSpace::Primaries::DciP3D65, q_trc, q_trc_gamma);
388 break;
389 default:
390 colorspace = QColorSpace(whitePoint, redPoint, greenPoint, bluePoint, q_trc, q_trc_gamma);
391 break;
392 }
393#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
394 }
395#endif
396 }
397
398 if (!colorspace.isValid()) {
399 qWarning("AVIF plugin created invalid QColorSpace from NCLX/CICP!");
400 }
401 }
402
403 avifRGBImage rgb;
404 avifRGBImageSetDefaults(&rgb, m_decoder->image);
405
406#if AVIF_VERSION >= 1000000
407 rgb.maxThreads = m_decoder->maxThreads;
408#endif
409
410 if (m_decoder->image->depth > 8) {
411 rgb.depth = 16;
412 rgb.format = AVIF_RGB_FORMAT_RGBA;
413
414 if (loadgray) {
415 resultformat = QImage::Format_Grayscale16;
416 }
417 } else {
418 rgb.depth = 8;
419#if Q_BYTE_ORDER == Q_LITTLE_ENDIAN
420 rgb.format = AVIF_RGB_FORMAT_BGRA;
421#else
422 rgb.format = AVIF_RGB_FORMAT_ARGB;
423#endif
424
425#if AVIF_VERSION >= 80400
426 if (m_decoder->imageCount > 1) {
427 /* accelerate animated AVIF */
428 rgb.chromaUpsampling = AVIF_CHROMA_UPSAMPLING_FASTEST;
429 }
430#endif
431
432 if (loadgray) {
433 resultformat = QImage::Format_Grayscale8;
434 }
435 }
436
437 rgb.rowBytes = result.bytesPerLine();
438 rgb.pixels = result.bits();
439
440 avifResult res = avifImageYUVToRGB(m_decoder->image, &rgb);
441 if (res != AVIF_RESULT_OK) {
442 qWarning("ERROR in avifImageYUVToRGB: %s", avifResultToString(res));
443 return false;
444 }
445
446 if (m_decoder->image->transformFlags & AVIF_TRANSFORM_CLAP) {
447 if ((m_decoder->image->clap.widthD > 0) && (m_decoder->image->clap.heightD > 0) && (m_decoder->image->clap.horizOffD > 0)
448 && (m_decoder->image->clap.vertOffD > 0)) {
449 int new_width = (int)((double)(m_decoder->image->clap.widthN) / (m_decoder->image->clap.widthD) + 0.5);
450 if (new_width > result.width()) {
451 new_width = result.width();
452 }
453
454 int new_height = (int)((double)(m_decoder->image->clap.heightN) / (m_decoder->image->clap.heightD) + 0.5);
455 if (new_height > result.height()) {
456 new_height = result.height();
457 }
458
459 if (new_width > 0 && new_height > 0) {
460 int offx =
461 ((double)((int32_t)m_decoder->image->clap.horizOffN)) / (m_decoder->image->clap.horizOffD) + (result.width() - new_width) / 2.0 + 0.5;
462 if (offx < 0) {
463 offx = 0;
464 } else if (offx > (result.width() - new_width)) {
465 offx = result.width() - new_width;
466 }
467
468 int offy =
469 ((double)((int32_t)m_decoder->image->clap.vertOffN)) / (m_decoder->image->clap.vertOffD) + (result.height() - new_height) / 2.0 + 0.5;
470 if (offy < 0) {
471 offy = 0;
472 } else if (offy > (result.height() - new_height)) {
473 offy = result.height() - new_height;
474 }
475
476 result = result.copy(offx, offy, new_width, new_height);
477 }
478 }
479
480 else { // Zero values, we need to avoid 0 divide.
481 qWarning("ERROR: Wrong values in avifCleanApertureBox");
482 }
483 }
484
485 if (m_decoder->image->transformFlags & AVIF_TRANSFORM_IROT) {
486 QTransform transform;
487 switch (m_decoder->image->irot.angle) {
488 case 1:
489 transform.rotate(-90);
490 result = result.transformed(transform);
491 break;
492 case 2:
493 transform.rotate(180);
494 result = result.transformed(transform);
495 break;
496 case 3:
497 transform.rotate(90);
498 result = result.transformed(transform);
499 break;
500 }
501 }
502
503 if (m_decoder->image->transformFlags & AVIF_TRANSFORM_IMIR) {
504#if AVIF_VERSION > 90100 && AVIF_VERSION < 1000000
505 switch (m_decoder->image->imir.mode) {
506#else
507 switch (m_decoder->image->imir.axis) {
508#endif
509#if QT_VERSION < QT_VERSION_CHECK(6, 9, 0)
510 case 0: // top-to-bottom
511 result = result.mirrored(false, true);
512 break;
513 case 1: // left-to-right
514 result = result.mirrored(true, false);
515 break;
516#else
517 case 0: // top-to-bottom
518 result = result.flipped(Qt::Vertical);
519 break;
520 case 1: // left-to-right
521 result = result.flipped(Qt::Horizontal);
522 break;
523#endif
524 }
525 }
526
527 if (resultformat == result.format()) {
528 m_current_image = result;
529 } else {
530 m_current_image = result.convertToFormat(resultformat);
531 }
532
533 m_current_image.setColorSpace(colorspace);
534
535 if (m_decoder->image->exif.size) {
536 auto exif = MicroExif::fromRawData(reinterpret_cast<const char *>(m_decoder->image->exif.data), m_decoder->image->exif.size);
537 exif.updateImageResolution(m_current_image);
538 exif.updateImageMetadata(m_current_image);
539 }
540
541 if (m_decoder->image->xmp.size) {
542 auto ba = QByteArray::fromRawData(reinterpret_cast<const char *>(m_decoder->image->xmp.data), m_decoder->image->xmp.size);
543 m_current_image.setText(QStringLiteral(META_KEY_XMP_ADOBE), QString::fromUtf8(ba));
544 }
545
546 m_estimated_dimensions = m_current_image.size();
547
548 m_must_jump_to_next_image = false;
549 return true;
550}
551
552static void setMetadata(avifImage *avif, const QImage& image)
553{
554 auto xmp = image.text(QStringLiteral(META_KEY_XMP_ADOBE)).toUtf8();
555 if (!xmp.isEmpty()) {
556#if AVIF_VERSION >= 1000000
557 auto res = avifImageSetMetadataXMP(avif, reinterpret_cast<const uint8_t *>(xmp.constData()), xmp.size());
558 if (res != AVIF_RESULT_OK) {
559 qWarning("ERROR in avifImageSetMetadataXMP: %s", avifResultToString(res));
560 }
561#else
562 avifImageSetMetadataXMP(avif, reinterpret_cast<const uint8_t *>(xmp.constData()), xmp.size());
563#endif
564 }
565 auto exif = MicroExif::fromImage(image).toByteArray();
566 if (!exif.isEmpty()) {
567#if AVIF_VERSION >= 1000000
568 auto res = avifImageSetMetadataExif(avif, reinterpret_cast<const uint8_t *>(exif.constData()), exif.size());
569 if (res != AVIF_RESULT_OK) {
570 qWarning("ERROR in avifImageSetMetadataExif: %s", avifResultToString(res));
571 }
572#else
573 avifImageSetMetadataExif(avif, reinterpret_cast<const uint8_t *>(exif.constData()), exif.size());
574#endif
575 }
576}
577
578bool QAVIFHandler::read(QImage *image)
579{
580 if (!ensureOpened()) {
581 return false;
582 }
583
584 if (m_must_jump_to_next_image) {
585 jumpToNextImage();
586 }
587
588 *image = m_current_image;
589 if (imageCount() >= 2) {
590 m_must_jump_to_next_image = true;
591 if (m_decoder->imageIndex >= m_decoder->imageCount - 1) {
592 // all frames in animation have been read
593 m_parseState = ParseAvifFinished;
594 }
595 } else {
596 // the static image has been read
597 m_parseState = ParseAvifFinished;
598 }
599 return true;
600}
601
602bool QAVIFHandler::write(const QImage &image)
603{
604 if (image.format() == QImage::Format_Invalid) {
605 qWarning("No image data to save!");
606 return false;
607 }
608
609 if ((image.width() > 0) && (image.height() > 0)) {
610 if ((image.width() > 65535) || (image.height() > 65535)) {
611 qWarning("Image (%dx%d) is too large to save!", image.width(), image.height());
612 return false;
613 }
614
615 if (image.width() > ((16384 * 16384) / image.height())) {
616 qWarning("Image (%dx%d) will not be saved because it has more than 256 megapixels!", image.width(), image.height());
617 return false;
618 }
619
620 if ((image.width() > 32768) || (image.height() > 32768)) {
621 qWarning("Image (%dx%d) has a dimension above 32768 pixels, saved AVIF may not work in other software!", image.width(), image.height());
622 }
623 } else {
624 qWarning("Image has zero dimension!");
625 return false;
626 }
627
628 const char *encoder_name = avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_ENCODE);
629 if (!encoder_name) {
630 qWarning("Cannot save AVIF images because libavif was built without AV1 encoders!");
631 return false;
632 }
633
634 bool lossless = false;
635 if (m_quality >= 100) {
636 if (avifCodecName(AVIF_CODEC_CHOICE_AOM, AVIF_CODEC_FLAG_CAN_ENCODE)) {
637 lossless = true;
638 } else {
639 qWarning("You are using %s encoder. It is recommended to enable libAOM encoder in libavif to use lossless compression.", encoder_name);
640 }
641 }
642
643 if (m_quality > 100) {
644 m_quality = 100;
645 } else if (m_quality < 0) {
646 m_quality = KIMG_AVIF_DEFAULT_QUALITY;
647 }
648
649#if AVIF_VERSION < 1000000
650 int maxQuantizer = AVIF_QUANTIZER_WORST_QUALITY * (100 - qBound(0, m_quality, 100)) / 100;
651 int minQuantizer = 0;
652 int maxQuantizerAlpha = 0;
653#endif
654 avifResult res;
655
656 bool save_grayscale; // true - monochrome, false - colors
657 int save_depth; // 8 or 10bit per channel
658 QImage::Format tmpformat; // format for temporary image
659
660 avifImage *avif = nullptr;
661
662 // grayscale detection
663 switch (image.format()) {
664 case QImage::Format_Mono:
665 case QImage::Format_MonoLSB:
666 case QImage::Format_Grayscale8:
667 case QImage::Format_Grayscale16:
668 save_grayscale = true;
669 break;
670 case QImage::Format_Indexed8:
671 save_grayscale = image.isGrayscale();
672 break;
673 default:
674 save_grayscale = false;
675 break;
676 }
677
678 // depth detection
679 switch (image.format()) {
680 case QImage::Format_BGR30:
681 case QImage::Format_A2BGR30_Premultiplied:
682 case QImage::Format_RGB30:
683 case QImage::Format_A2RGB30_Premultiplied:
684 case QImage::Format_Grayscale16:
685 case QImage::Format_RGBX64:
686 case QImage::Format_RGBA64:
687 case QImage::Format_RGBA64_Premultiplied:
688 save_depth = 10;
689 break;
690 default:
691 if (image.depth() > 32) {
692 save_depth = 10;
693 } else {
694 save_depth = 8;
695 }
696 break;
697 }
698
699#if AVIF_VERSION < 1000000
700 // deprecated quality settings
701 if (maxQuantizer > 20) {
702 minQuantizer = maxQuantizer - 20;
703 if (maxQuantizer > 40) { // we decrease quality of alpha channel here
704 maxQuantizerAlpha = maxQuantizer - 40;
705 }
706 }
707#endif
708
709 if (save_grayscale && !image.hasAlphaChannel()) { // we are going to save grayscale image without alpha channel
710 if (save_depth > 8) {
711 tmpformat = QImage::Format_Grayscale16;
712 } else {
713 tmpformat = QImage::Format_Grayscale8;
714 }
715 QImage tmpgrayimage = image.convertToFormat(tmpformat);
716
717 avif = avifImageCreate(tmpgrayimage.width(), tmpgrayimage.height(), save_depth, AVIF_PIXEL_FORMAT_YUV400);
718#if AVIF_VERSION >= 110000
719 res = avifImageAllocatePlanes(avif, AVIF_PLANES_YUV);
720 if (res != AVIF_RESULT_OK) {
721 qWarning("ERROR in avifImageAllocatePlanes: %s", avifResultToString(res));
722 return false;
723 }
724#else
725 avifImageAllocatePlanes(avif, AVIF_PLANES_YUV);
726#endif
727 // set EXIF and XMP metadata
728 setMetadata(avif, tmpgrayimage);
729
730 if (tmpgrayimage.colorSpace().isValid()) {
731 avif->colorPrimaries = (avifColorPrimaries)1;
732 avif->matrixCoefficients = (avifMatrixCoefficients)1;
733
734 switch (tmpgrayimage.colorSpace().transferFunction()) {
735 case QColorSpace::TransferFunction::Linear:
736 /* AVIF_TRANSFER_CHARACTERISTICS_LINEAR */
737 avif->transferCharacteristics = (avifTransferCharacteristics)8;
738 break;
739 case QColorSpace::TransferFunction::SRgb:
740 /* AVIF_TRANSFER_CHARACTERISTICS_SRGB */
741 avif->transferCharacteristics = (avifTransferCharacteristics)13;
742 break;
743#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
744 case QColorSpace::TransferFunction::St2084:
745 avif->transferCharacteristics = (avifTransferCharacteristics)16;
746 break;
747 case QColorSpace::TransferFunction::Hlg:
748 avif->transferCharacteristics = (avifTransferCharacteristics)18;
749 break;
750#endif
751 default:
752 /* AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED */
753 break;
754 }
755 }
756
757 if (save_depth > 8) { // QImage::Format_Grayscale16
758 for (int y = 0; y < tmpgrayimage.height(); y++) {
759 const uint16_t *src16bit = reinterpret_cast<const uint16_t *>(tmpgrayimage.constScanLine(y));
760 uint16_t *dest16bit = reinterpret_cast<uint16_t *>(avif->yuvPlanes[0] + y * avif->yuvRowBytes[0]);
761 for (int x = 0; x < tmpgrayimage.width(); x++) {
762 int tmp_pixelval = (int)(((float)(*src16bit) / 65535.0f) * 1023.0f + 0.5f); // downgrade to 10 bits
763 *dest16bit = qBound(0, tmp_pixelval, 1023);
764 dest16bit++;
765 src16bit++;
766 }
767 }
768 } else { // QImage::Format_Grayscale8
769 for (int y = 0; y < tmpgrayimage.height(); y++) {
770 const uchar *src8bit = tmpgrayimage.constScanLine(y);
771 uint8_t *dest8bit = avif->yuvPlanes[0] + y * avif->yuvRowBytes[0];
772 for (int x = 0; x < tmpgrayimage.width(); x++) {
773 *dest8bit = *src8bit;
774 dest8bit++;
775 src8bit++;
776 }
777 }
778 }
779
780 } else { // we are going to save color image
781 if (save_depth > 8) {
782 if (image.hasAlphaChannel()) {
783 tmpformat = QImage::Format_RGBA64;
784 } else {
785 tmpformat = QImage::Format_RGBX64;
786 }
787 } else { // 8bit depth
788 if (image.hasAlphaChannel()) {
789 tmpformat = QImage::Format_RGBA8888;
790 } else {
791 tmpformat = QImage::Format_RGB888;
792 }
793 }
794
795#if QT_VERSION >= QT_VERSION_CHECK(6, 8, 0)
796 QImage tmpcolorimage;
797 auto cs = image.colorSpace();
798 if (cs.isValid() && cs.colorModel() == QColorSpace::ColorModel::Cmyk && image.format() == QImage::Format_CMYK8888) {
799 tmpcolorimage = image.convertedToColorSpace(QColorSpace(QColorSpace::SRgb), tmpformat);
800 } else if (cs.isValid() && cs.colorModel() == QColorSpace::ColorModel::Gray) {
801 QColorSpace::TransferFunction trc_new = cs.transferFunction();
802 float gamma_new = cs.gamma();
803 if (trc_new == QColorSpace::TransferFunction::Custom) {
804 trc_new = QColorSpace::TransferFunction::SRgb;
805 }
806 tmpcolorimage = image.convertedToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, trc_new, gamma_new), tmpformat);
807 } else {
808 tmpcolorimage = image.convertToFormat(tmpformat);
809 }
810#else
811 QImage tmpcolorimage = image.convertToFormat(tmpformat);
812#endif
813
814 avifPixelFormat pixel_format = AVIF_PIXEL_FORMAT_YUV420;
815 if (m_quality >= KIMG_AVIF_QUALITY_HIGH) {
816 if (m_quality >= KIMG_AVIF_QUALITY_BEST) {
817 pixel_format = AVIF_PIXEL_FORMAT_YUV444; // best quality
818 } else {
819 pixel_format = AVIF_PIXEL_FORMAT_YUV422; // high quality
820 }
821 }
822
823 avifMatrixCoefficients matrix_to_save = (avifMatrixCoefficients)1; // default for Qt 5.12 and 5.13;
824
825 avifColorPrimaries primaries_to_save = (avifColorPrimaries)2;
826 avifTransferCharacteristics transfer_to_save = (avifTransferCharacteristics)2;
827 QByteArray iccprofile;
828
829 if (tmpcolorimage.colorSpace().isValid()) {
830 switch (tmpcolorimage.colorSpace().primaries()) {
831 case QColorSpace::Primaries::SRgb:
832 /* AVIF_COLOR_PRIMARIES_BT709 */
833 primaries_to_save = (avifColorPrimaries)1;
834 /* AVIF_MATRIX_COEFFICIENTS_BT709 */
835 matrix_to_save = (avifMatrixCoefficients)1;
836 break;
837 case QColorSpace::Primaries::DciP3D65:
838 /* AVIF_NCLX_COLOUR_PRIMARIES_P3, AVIF_NCLX_COLOUR_PRIMARIES_SMPTE432 */
839 primaries_to_save = (avifColorPrimaries)12;
840 /* AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL */
841 matrix_to_save = (avifMatrixCoefficients)12;
842 break;
843 default:
844 /* AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED */
845 primaries_to_save = (avifColorPrimaries)2;
846 /* AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED */
847 matrix_to_save = (avifMatrixCoefficients)2;
848 break;
849 }
850
851 switch (tmpcolorimage.colorSpace().transferFunction()) {
852 case QColorSpace::TransferFunction::Linear:
853 /* AVIF_TRANSFER_CHARACTERISTICS_LINEAR */
854 transfer_to_save = (avifTransferCharacteristics)8;
855 break;
856 case QColorSpace::TransferFunction::Gamma:
857 if (qAbs(tmpcolorimage.colorSpace().gamma() - 2.2f) < 0.1f) {
858 /* AVIF_TRANSFER_CHARACTERISTICS_BT470M */
859 transfer_to_save = (avifTransferCharacteristics)4;
860 } else if (qAbs(tmpcolorimage.colorSpace().gamma() - 2.8f) < 0.1f) {
861 /* AVIF_TRANSFER_CHARACTERISTICS_BT470BG */
862 transfer_to_save = (avifTransferCharacteristics)5;
863 } else {
864 /* AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED */
865 transfer_to_save = (avifTransferCharacteristics)2;
866 }
867 break;
868 case QColorSpace::TransferFunction::SRgb:
869 /* AVIF_TRANSFER_CHARACTERISTICS_SRGB */
870 transfer_to_save = (avifTransferCharacteristics)13;
871 break;
872#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
873 case QColorSpace::TransferFunction::St2084:
874 transfer_to_save = (avifTransferCharacteristics)16;
875 break;
876 case QColorSpace::TransferFunction::Hlg:
877 transfer_to_save = (avifTransferCharacteristics)18;
878 break;
879#endif
880 default:
881 /* AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED */
882 transfer_to_save = (avifTransferCharacteristics)2;
883 break;
884 }
885
886 // in case primaries or trc were not identified
887 if ((primaries_to_save == 2) || (transfer_to_save == 2)) {
888 if (lossless) {
889 iccprofile = tmpcolorimage.colorSpace().iccProfile();
890 } else {
891 // upgrade image to higher bit depth
892 if (save_depth == 8) {
893 save_depth = 10;
894 if (tmpcolorimage.hasAlphaChannel()) {
895 tmpcolorimage.convertTo(QImage::Format_RGBA64);
896 } else {
897 tmpcolorimage.convertTo(QImage::Format_RGBX64);
898 }
899 }
900
901 if ((primaries_to_save == 2) && (transfer_to_save != 2)) { // other primaries but known trc
902 primaries_to_save = (avifColorPrimaries)1; // AVIF_COLOR_PRIMARIES_BT709
903 matrix_to_save = (avifMatrixCoefficients)1; // AVIF_MATRIX_COEFFICIENTS_BT709
904
905 switch (transfer_to_save) {
906 case 8: // AVIF_TRANSFER_CHARACTERISTICS_LINEAR
907 tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::Linear));
908 break;
909 case 4: // AVIF_TRANSFER_CHARACTERISTICS_BT470M
910 tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, 2.2f));
911 break;
912 case 5: // AVIF_TRANSFER_CHARACTERISTICS_BT470BG
913 tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, 2.8f));
914 break;
915#if (QT_VERSION >= QT_VERSION_CHECK(6, 8, 0))
916 case 16:
917 tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::St2084));
918 break;
919 case 18:
920 tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::Hlg));
921 break;
922#endif
923 default: // AVIF_TRANSFER_CHARACTERISTICS_SRGB + any other
924 tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::SRgb));
925 transfer_to_save = (avifTransferCharacteristics)13;
926 break;
927 }
928 } else if ((primaries_to_save != 2) && (transfer_to_save == 2)) { // recognized primaries but other trc
929 transfer_to_save = (avifTransferCharacteristics)13;
930 tmpcolorimage.convertToColorSpace(tmpcolorimage.colorSpace().withTransferFunction(QColorSpace::TransferFunction::SRgb));
931 } else { // unrecognized profile
932 primaries_to_save = (avifColorPrimaries)1; // AVIF_COLOR_PRIMARIES_BT709
933 transfer_to_save = (avifTransferCharacteristics)13;
934 matrix_to_save = (avifMatrixCoefficients)1; // AVIF_MATRIX_COEFFICIENTS_BT709
935 tmpcolorimage.convertToColorSpace(QColorSpace(QColorSpace::Primaries::SRgb, QColorSpace::TransferFunction::SRgb));
936 }
937 }
938 }
939 } else { // profile is unsupported by Qt
940 iccprofile = tmpcolorimage.colorSpace().iccProfile();
941 if (iccprofile.size() > 0) {
942 matrix_to_save = (avifMatrixCoefficients)6;
943 }
944 }
945
946 if (lossless && pixel_format == AVIF_PIXEL_FORMAT_YUV444) {
947 matrix_to_save = (avifMatrixCoefficients)0;
948 }
949 avif = avifImageCreate(tmpcolorimage.width(), tmpcolorimage.height(), save_depth, pixel_format);
950 avif->matrixCoefficients = matrix_to_save;
951
952 avif->colorPrimaries = primaries_to_save;
953 avif->transferCharacteristics = transfer_to_save;
954
955 // set EXIF and XMP metadata
956 setMetadata(avif, tmpcolorimage);
957
958 if (iccprofile.size() > 0) {
959#if AVIF_VERSION >= 1000000
960 res = avifImageSetProfileICC(avif, reinterpret_cast<const uint8_t *>(iccprofile.constData()), iccprofile.size());
961 if (res != AVIF_RESULT_OK) {
962 qWarning("ERROR in avifImageSetProfileICC: %s", avifResultToString(res));
963 return false;
964 }
965#else
966 avifImageSetProfileICC(avif, reinterpret_cast<const uint8_t *>(iccprofile.constData()), iccprofile.size());
967#endif
968 }
969
970 avifRGBImage rgb;
971 avifRGBImageSetDefaults(&rgb, avif);
972 rgb.rowBytes = tmpcolorimage.bytesPerLine();
973 rgb.pixels = const_cast<uint8_t *>(tmpcolorimage.constBits());
974
975 if (save_depth > 8) { // 10bit depth
976 rgb.depth = 16;
977
978 if (!tmpcolorimage.hasAlphaChannel()) {
979 rgb.ignoreAlpha = AVIF_TRUE;
980 }
981
982 rgb.format = AVIF_RGB_FORMAT_RGBA;
983 } else { // 8bit depth
984 rgb.depth = 8;
985
986 if (tmpcolorimage.hasAlphaChannel()) {
987 rgb.format = AVIF_RGB_FORMAT_RGBA;
988 } else {
989 rgb.format = AVIF_RGB_FORMAT_RGB;
990 }
991 }
992
993 res = avifImageRGBToYUV(avif, &rgb);
994 if (res != AVIF_RESULT_OK) {
995 qWarning("ERROR in avifImageRGBToYUV: %s", avifResultToString(res));
996 return false;
997 }
998 }
999
1000 avifRWData raw = AVIF_DATA_EMPTY;
1001 avifEncoder *encoder = avifEncoderCreate();
1002 encoder->maxThreads = qBound(1, QThread::idealThreadCount(), 64);
1003
1004#if AVIF_VERSION < 1000000
1005 encoder->minQuantizer = minQuantizer;
1006 encoder->maxQuantizer = maxQuantizer;
1007
1008 if (image.hasAlphaChannel()) {
1009 encoder->minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
1010 encoder->maxQuantizerAlpha = maxQuantizerAlpha;
1011 }
1012#else
1013 encoder->quality = m_quality;
1014
1015 if (image.hasAlphaChannel()) {
1016 if (m_quality >= KIMG_AVIF_QUALITY_LOW) {
1017 encoder->qualityAlpha = 100;
1018 } else {
1019 encoder->qualityAlpha = 100 - (KIMG_AVIF_QUALITY_LOW - m_quality) / 2;
1020 }
1021 }
1022#endif
1023
1024 encoder->speed = 6;
1025
1026 res = avifEncoderWrite(encoder, avif, &raw);
1027 avifEncoderDestroy(encoder);
1028 avifImageDestroy(avif);
1029
1030 if (res == AVIF_RESULT_OK) {
1031 qint64 status = device()->write(reinterpret_cast<const char *>(raw.data), raw.size);
1032 avifRWDataFree(&raw);
1033
1034 if (status > 0) {
1035 return true;
1036 } else if (status == -1) {
1037 qWarning("Write error: %s", qUtf8Printable(device()->errorString()));
1038 return false;
1039 }
1040 } else {
1041 qWarning("ERROR: Failed to encode: %s", avifResultToString(res));
1042 }
1043
1044 return false;
1045}
1046
1047QVariant QAVIFHandler::option(ImageOption option) const
1048{
1049 if (option == Quality) {
1050 return m_quality;
1051 }
1052
1053 if (!supportsOption(option) || !ensureParsed()) {
1054 return QVariant();
1055 }
1056
1057 switch (option) {
1058 case Size:
1059 return m_estimated_dimensions;
1060 case Animation:
1061 if (imageCount() >= 2) {
1062 return true;
1063 } else {
1064 return false;
1065 }
1066 default:
1067 return QVariant();
1068 }
1069}
1070
1071void QAVIFHandler::setOption(ImageOption option, const QVariant &value)
1072{
1073 switch (option) {
1074 case Quality:
1075 m_quality = value.toInt();
1076 if (m_quality > 100) {
1077 m_quality = 100;
1078 } else if (m_quality < 0) {
1079 m_quality = KIMG_AVIF_DEFAULT_QUALITY;
1080 }
1081 return;
1082 default:
1083 break;
1084 }
1085 QImageIOHandler::setOption(option, value);
1086}
1087
1088bool QAVIFHandler::supportsOption(ImageOption option) const
1089{
1090 return option == Quality || option == Size || option == Animation;
1091}
1092
1093int QAVIFHandler::imageCount() const
1094{
1095 if (!ensureParsed()) {
1096 return 0;
1097 }
1098
1099 if (m_decoder->imageCount >= 1) {
1100 return m_decoder->imageCount;
1101 }
1102 return 0;
1103}
1104
1105int QAVIFHandler::currentImageNumber() const
1106{
1107 if (m_parseState == ParseAvifNotParsed) {
1108 return -1;
1109 }
1110
1111 if (m_parseState == ParseAvifError || !m_decoder) {
1112 return 0;
1113 }
1114
1115 if (m_parseState == ParseAvifMetadata) {
1116 if (m_decoder->imageCount >= 2) {
1117 return -1;
1118 } else {
1119 return 0;
1120 }
1121 }
1122
1123 return m_decoder->imageIndex;
1124}
1125
1126bool QAVIFHandler::jumpToNextImage()
1127{
1128 if (!ensureParsed()) {
1129 return false;
1130 }
1131
1132 avifResult decodeResult;
1133
1134 if (m_decoder->imageIndex >= 0) {
1135 if (m_decoder->imageCount < 2) {
1136 m_parseState = ParseAvifSuccess;
1137 return true;
1138 }
1139
1140 if (m_decoder->imageIndex >= m_decoder->imageCount - 1) { // start from beginning
1141 decodeResult = avifDecoderReset(m_decoder);
1142 if (decodeResult != AVIF_RESULT_OK) {
1143 qWarning("ERROR in avifDecoderReset: %s", avifResultToString(decodeResult));
1144 m_parseState = ParseAvifError;
1145 return false;
1146 }
1147 }
1148 }
1149
1150 decodeResult = avifDecoderNextImage(m_decoder);
1151
1152 if (decodeResult != AVIF_RESULT_OK) {
1153 qWarning("ERROR: Failed to decode Next image in sequence: %s", avifResultToString(decodeResult));
1154 m_parseState = ParseAvifError;
1155 return false;
1156 }
1157
1158 if ((m_container_width != m_decoder->image->width) || (m_container_height != m_decoder->image->height)) {
1159 qWarning("Decoded image sequence size (%dx%d) do not match first image size (%dx%d)!",
1160 m_decoder->image->width,
1161 m_decoder->image->height,
1162 m_container_width,
1163 m_container_height);
1164
1165 m_parseState = ParseAvifError;
1166 return false;
1167 }
1168
1169 if (decode_one_frame()) {
1170 m_parseState = ParseAvifSuccess;
1171 return true;
1172 } else {
1173 m_parseState = ParseAvifError;
1174 return false;
1175 }
1176}
1177
1178bool QAVIFHandler::jumpToImage(int imageNumber)
1179{
1180 if (!ensureParsed()) {
1181 return false;
1182 }
1183
1184 if (m_decoder->imageCount < 2) { // not an animation
1185 if (imageNumber == 0) {
1186 if (ensureOpened()) {
1187 m_parseState = ParseAvifSuccess;
1188 return true;
1189 }
1190 }
1191 return false;
1192 }
1193
1194 if (imageNumber < 0 || imageNumber >= m_decoder->imageCount) { // wrong index
1195 return false;
1196 }
1197
1198 if (imageNumber == m_decoder->imageIndex) { // we are here already
1199 m_must_jump_to_next_image = false;
1200 m_parseState = ParseAvifSuccess;
1201 return true;
1202 }
1203
1204 avifResult decodeResult = avifDecoderNthImage(m_decoder, imageNumber);
1205
1206 if (decodeResult != AVIF_RESULT_OK) {
1207 qWarning("ERROR: Failed to decode %d th Image in sequence: %s", imageNumber, avifResultToString(decodeResult));
1208 m_parseState = ParseAvifError;
1209 return false;
1210 }
1211
1212 if ((m_container_width != m_decoder->image->width) || (m_container_height != m_decoder->image->height)) {
1213 qWarning("Decoded image sequence size (%dx%d) do not match declared container size (%dx%d)!",
1214 m_decoder->image->width,
1215 m_decoder->image->height,
1216 m_container_width,
1217 m_container_height);
1218
1219 m_parseState = ParseAvifError;
1220 return false;
1221 }
1222
1223 if (decode_one_frame()) {
1224 m_parseState = ParseAvifSuccess;
1225 return true;
1226 } else {
1227 m_parseState = ParseAvifError;
1228 return false;
1229 }
1230}
1231
1232int QAVIFHandler::nextImageDelay() const
1233{
1234 if (!ensureOpened()) {
1235 return 0;
1236 }
1237
1238 if (m_decoder->imageCount < 2) {
1239 return 0;
1240 }
1241
1242 int delay_ms = 1000.0 * m_decoder->imageTiming.duration;
1243 if (delay_ms < 1) {
1244 delay_ms = 1;
1245 }
1246 return delay_ms;
1247}
1248
1249int QAVIFHandler::loopCount() const
1250{
1251 if (!ensureParsed()) {
1252 return 0;
1253 }
1254
1255 if (m_decoder->imageCount < 2) {
1256 return 0;
1257 }
1258
1259#if AVIF_VERSION >= 1000000
1260 if (m_decoder->repetitionCount >= 0) {
1261 return m_decoder->repetitionCount;
1262 }
1263#endif
1264 // Endless loop to work around https://github.com/AOMediaCodec/libavif/issues/347
1265 return -1;
1266}
1267
1268QPointF QAVIFHandler::CompatibleChromacity(qreal chrX, qreal chrY)
1269{
1270 chrX = qBound(qreal(0.0), chrX, qreal(1.0));
1271 chrY = qBound(qreal(DBL_MIN), chrY, qreal(1.0));
1272
1273 if ((chrX + chrY) > qreal(1.0)) {
1274 chrX = qreal(1.0) - chrY;
1275 }
1276
1277 return QPointF(chrX, chrY);
1278}
1279
1280QImageIOPlugin::Capabilities QAVIFPlugin::capabilities(QIODevice *device, const QByteArray &format) const
1281{
1282 static const bool isAvifDecoderAvailable(avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_DECODE) != nullptr);
1283 static const bool isAvifEncoderAvailable(avifCodecName(AVIF_CODEC_CHOICE_AUTO, AVIF_CODEC_FLAG_CAN_ENCODE) != nullptr);
1284
1285 if (format == "avif") {
1286 Capabilities format_cap;
1287 if (isAvifDecoderAvailable) {
1288 format_cap |= CanRead;
1289 }
1290 if (isAvifEncoderAvailable) {
1291 format_cap |= CanWrite;
1292 }
1293 return format_cap;
1294 }
1295
1296 if (format == "avifs") {
1297 Capabilities format_cap;
1298 if (isAvifDecoderAvailable) {
1299 format_cap |= CanRead;
1300 }
1301 return format_cap;
1302 }
1303
1304 if (!format.isEmpty()) {
1305 return {};
1306 }
1307 if (!device->isOpen()) {
1308 return {};
1309 }
1310
1311 Capabilities cap;
1312 if (device->isReadable() && QAVIFHandler::canRead(device) && isAvifDecoderAvailable) {
1313 cap |= CanRead;
1314 }
1315 if (device->isWritable() && isAvifEncoderAvailable) {
1316 cap |= CanWrite;
1317 }
1318 return cap;
1319}
1320
1321QImageIOHandler *QAVIFPlugin::create(QIODevice *device, const QByteArray &format) const
1322{
1323 QImageIOHandler *handler = new QAVIFHandler;
1324 handler->setDevice(device);
1325 handler->setFormat(format);
1326 return handler;
1327}
1328
1329#include "moc_avif_p.cpp"
status
Q_SCRIPTABLE CaptureState status()
KDocTools::transform
KDOCTOOLS_EXPORT QString transform(const QString &file, const QString &stylesheet, const QList< const char * > &params=QList< const char * >())
KGameAudioScene::Capabilities
QFlags< Capability > Capabilities
Okular::errorString
OKULARCORE_EXPORT QString errorString(SigningResult result, const QVariant &additionalMessage)
QByteArray::constData
const char * constData() const const
QByteArray::data
char * data()
QByteArray::fromRawData
QByteArray fromRawData(const char *data, qsizetype size)
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::primaries
Primaries primaries() const const
QColorSpace::transferFunction
TransferFunction transferFunction() const const
QColorSpace::withTransferFunction
QColorSpace withTransferFunction(TransferFunction transferFunction, float gamma) const const
QImage::bits
uchar * bits()
QImage::bytesPerLine
qsizetype bytesPerLine() const const
QImage::colorSpace
QColorSpace colorSpace() const const
QImage::constBits
const uchar * constBits() const const
QImage::constScanLine
const uchar * constScanLine(int i) const const
QImage::convertTo
void convertTo(Format format, Qt::ImageConversionFlags flags)
QImage::convertToColorSpace
void convertToColorSpace(const QColorSpace &colorSpace)
QImage::convertToFormat
QImage convertToFormat(Format format, Qt::ImageConversionFlags flags) &&
QImage::convertedToColorSpace
QImage convertedToColorSpace(const QColorSpace &colorSpace) const const
QImage::copy
QImage copy(const QRect &rectangle) 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::isGrayscale
bool isGrayscale() const const
QImage::isNull
bool isNull() const const
QImage::mirrored
QImage mirrored(bool horizontal, bool vertical) &&
QImage::text
QString text(const QString &key) const const
QImage::transformed
QImage transformed(const QTransform &matrix, Qt::TransformationMode mode) 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::readAll
QByteArray readAll()
QIODevice::write
qint64 write(const QByteArray &data)
QPointF::isNull
bool isNull() const const
QString::fromUtf8
QString fromUtf8(QByteArrayView str)
QString::toUtf8
QByteArray toUtf8() const const
Qt::Vertical
Vertical
QThread::idealThreadCount
int idealThreadCount()
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.