1 /*
2 * Copyright 2022 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <ultrahdr/jpegr.h>
18 #include <ultrahdr/jpegencoderhelper.h>
19 #include <ultrahdr/jpegdecoderhelper.h>
20 #include <ultrahdr/gainmapmath.h>
21 #include <ultrahdr/jpegrutils.h>
22 #include <ultrahdr/multipictureformat.h>
23 #include <ultrahdr/icc.h>
24
25 #include <image_io/jpeg/jpeg_marker.h>
26 #include <image_io/jpeg/jpeg_info.h>
27 #include <image_io/jpeg/jpeg_scanner.h>
28 #include <image_io/jpeg/jpeg_info_builder.h>
29 #include <image_io/base/data_segment_data_source.h>
30 #include <utils/Log.h>
31
32 #include <map>
33 #include <memory>
34 #include <sstream>
35 #include <string>
36 #include <cmath>
37 #include <condition_variable>
38 #include <deque>
39 #include <mutex>
40 #include <thread>
41 #include <unistd.h>
42
43 using namespace std;
44 using namespace photos_editing_formats::image_io;
45
46 namespace android::ultrahdr {
47
48 #define USE_SRGB_INVOETF_LUT 1
49 #define USE_HLG_OETF_LUT 1
50 #define USE_PQ_OETF_LUT 1
51 #define USE_HLG_INVOETF_LUT 1
52 #define USE_PQ_INVOETF_LUT 1
53 #define USE_APPLY_GAIN_LUT 1
54
55 #define JPEGR_CHECK(x) \
56 { \
57 status_t status = (x); \
58 if ((status) != NO_ERROR) { \
59 return status; \
60 } \
61 }
62
63 // The current JPEGR version that we encode to
64 static const char* const kJpegrVersion = "1.0";
65
66 // Map is quarter res / sixteenth size
67 static const size_t kMapDimensionScaleFactor = 4;
68
69 // Gain Map width is (image_width / kMapDimensionScaleFactor). If we were to
70 // compress 420 GainMap in jpeg, then we need at least 2 samples. For Grayscale
71 // 1 sample is sufficient. We are using 2 here anyways
72 static const int kMinWidth = 2 * kMapDimensionScaleFactor;
73 static const int kMinHeight = 2 * kMapDimensionScaleFactor;
74
75 // JPEG block size.
76 // JPEG encoding / decoding will require block based DCT transform 16 x 16 for luma,
77 // and 8 x 8 for chroma.
78 // Width must be 16 dividable for luma, and 8 dividable for chroma.
79 // If this criteria is not facilitated, we will pad zeros based to each line on the
80 // required block size.
81 static const size_t kJpegBlock = JpegEncoderHelper::kCompressBatchSize;
82 // JPEG compress quality (0 ~ 100) for gain map
83 static const int kMapCompressQuality = 85;
84
85 #define CONFIG_MULTITHREAD 1
GetCPUCoreCount()86 int GetCPUCoreCount() {
87 int cpuCoreCount = 1;
88 #if CONFIG_MULTITHREAD
89 #if defined(_SC_NPROCESSORS_ONLN)
90 cpuCoreCount = sysconf(_SC_NPROCESSORS_ONLN);
91 #else
92 // _SC_NPROC_ONLN must be defined...
93 cpuCoreCount = sysconf(_SC_NPROC_ONLN);
94 #endif
95 #endif
96 return cpuCoreCount;
97 }
98
areInputArgumentsValid(jr_uncompressed_ptr uncompressed_p010_image,jr_uncompressed_ptr uncompressed_yuv_420_image,ultrahdr_transfer_function hdr_tf,jr_compressed_ptr dest)99 status_t JpegR::areInputArgumentsValid(jr_uncompressed_ptr uncompressed_p010_image,
100 jr_uncompressed_ptr uncompressed_yuv_420_image,
101 ultrahdr_transfer_function hdr_tf,
102 jr_compressed_ptr dest) {
103 if (uncompressed_p010_image == nullptr || uncompressed_p010_image->data == nullptr) {
104 ALOGE("received nullptr for uncompressed p010 image");
105 return ERROR_JPEGR_INVALID_NULL_PTR;
106 }
107
108 if (uncompressed_p010_image->width % 2 != 0
109 || uncompressed_p010_image->height % 2 != 0) {
110 ALOGE("Image dimensions cannot be odd, image dimensions %dx%d",
111 uncompressed_p010_image->width, uncompressed_p010_image->height);
112 return ERROR_JPEGR_INVALID_INPUT_TYPE;
113 }
114
115 if (uncompressed_p010_image->width < kMinWidth
116 || uncompressed_p010_image->height < kMinHeight) {
117 ALOGE("Image dimensions cannot be less than %dx%d, image dimensions %dx%d",
118 kMinWidth, kMinHeight, uncompressed_p010_image->width, uncompressed_p010_image->height);
119 return ERROR_JPEGR_INVALID_INPUT_TYPE;
120 }
121
122 if (uncompressed_p010_image->width > kMaxWidth
123 || uncompressed_p010_image->height > kMaxHeight) {
124 ALOGE("Image dimensions cannot be larger than %dx%d, image dimensions %dx%d",
125 kMaxWidth, kMaxHeight, uncompressed_p010_image->width, uncompressed_p010_image->height);
126 return ERROR_JPEGR_INVALID_INPUT_TYPE;
127 }
128
129 if (uncompressed_p010_image->colorGamut <= ULTRAHDR_COLORGAMUT_UNSPECIFIED
130 || uncompressed_p010_image->colorGamut > ULTRAHDR_COLORGAMUT_MAX) {
131 ALOGE("Unrecognized p010 color gamut %d", uncompressed_p010_image->colorGamut);
132 return ERROR_JPEGR_INVALID_INPUT_TYPE;
133 }
134
135 if (uncompressed_p010_image->luma_stride != 0
136 && uncompressed_p010_image->luma_stride < uncompressed_p010_image->width) {
137 ALOGE("Luma stride can not be smaller than width, stride=%d, width=%d",
138 uncompressed_p010_image->luma_stride, uncompressed_p010_image->width);
139 return ERROR_JPEGR_INVALID_INPUT_TYPE;
140 }
141
142 if (uncompressed_p010_image->chroma_data != nullptr
143 && uncompressed_p010_image->chroma_stride < uncompressed_p010_image->width) {
144 ALOGE("Chroma stride can not be smaller than width, stride=%d, width=%d",
145 uncompressed_p010_image->chroma_stride,
146 uncompressed_p010_image->width);
147 return ERROR_JPEGR_INVALID_INPUT_TYPE;
148 }
149
150 if (dest == nullptr || dest->data == nullptr) {
151 ALOGE("received nullptr for destination");
152 return ERROR_JPEGR_INVALID_NULL_PTR;
153 }
154
155 if (hdr_tf <= ULTRAHDR_TF_UNSPECIFIED || hdr_tf > ULTRAHDR_TF_MAX
156 || hdr_tf == ULTRAHDR_TF_SRGB) {
157 ALOGE("Invalid hdr transfer function %d", hdr_tf);
158 return ERROR_JPEGR_INVALID_INPUT_TYPE;
159 }
160
161 if (uncompressed_yuv_420_image == nullptr) {
162 return NO_ERROR;
163 }
164
165 if (uncompressed_yuv_420_image->data == nullptr) {
166 ALOGE("received nullptr for uncompressed 420 image");
167 return ERROR_JPEGR_INVALID_NULL_PTR;
168 }
169
170 if (uncompressed_yuv_420_image->luma_stride != 0) {
171 ALOGE("Stride is not supported for YUV420 image");
172 return ERROR_JPEGR_UNSUPPORTED_FEATURE;
173 }
174
175 if (uncompressed_yuv_420_image->chroma_data != nullptr) {
176 ALOGE("Pointer to chroma plane is not supported for YUV420 image, chroma data must"
177 "be immediately after the luma data.");
178 return ERROR_JPEGR_UNSUPPORTED_FEATURE;
179 }
180
181 if (uncompressed_p010_image->width != uncompressed_yuv_420_image->width
182 || uncompressed_p010_image->height != uncompressed_yuv_420_image->height) {
183 ALOGE("Image resolutions mismatch: P010: %dx%d, YUV420: %dx%d",
184 uncompressed_p010_image->width,
185 uncompressed_p010_image->height,
186 uncompressed_yuv_420_image->width,
187 uncompressed_yuv_420_image->height);
188 return ERROR_JPEGR_RESOLUTION_MISMATCH;
189 }
190
191 if (uncompressed_yuv_420_image->colorGamut <= ULTRAHDR_COLORGAMUT_UNSPECIFIED
192 || uncompressed_yuv_420_image->colorGamut > ULTRAHDR_COLORGAMUT_MAX) {
193 ALOGE("Unrecognized 420 color gamut %d", uncompressed_yuv_420_image->colorGamut);
194 return ERROR_JPEGR_INVALID_INPUT_TYPE;
195 }
196
197 return NO_ERROR;
198 }
199
areInputArgumentsValid(jr_uncompressed_ptr uncompressed_p010_image,jr_uncompressed_ptr uncompressed_yuv_420_image,ultrahdr_transfer_function hdr_tf,jr_compressed_ptr dest,int quality)200 status_t JpegR::areInputArgumentsValid(jr_uncompressed_ptr uncompressed_p010_image,
201 jr_uncompressed_ptr uncompressed_yuv_420_image,
202 ultrahdr_transfer_function hdr_tf,
203 jr_compressed_ptr dest,
204 int quality) {
205 if (status_t ret = areInputArgumentsValid(
206 uncompressed_p010_image, uncompressed_yuv_420_image, hdr_tf, dest) != NO_ERROR) {
207 return ret;
208 }
209
210 if (quality < 0 || quality > 100) {
211 ALOGE("quality factor is out side range [0-100], quality factor : %d", quality);
212 return ERROR_JPEGR_INVALID_INPUT_TYPE;
213 }
214
215 return NO_ERROR;
216 }
217
218 /* Encode API-0 */
encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,ultrahdr_transfer_function hdr_tf,jr_compressed_ptr dest,int quality,jr_exif_ptr exif)219 status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
220 ultrahdr_transfer_function hdr_tf,
221 jr_compressed_ptr dest,
222 int quality,
223 jr_exif_ptr exif) {
224 if (status_t ret = areInputArgumentsValid(
225 uncompressed_p010_image, /* uncompressed_yuv_420_image */ nullptr,
226 hdr_tf, dest, quality) != NO_ERROR) {
227 return ret;
228 }
229
230 if (exif != nullptr && exif->data == nullptr) {
231 ALOGE("received nullptr for exif metadata");
232 return ERROR_JPEGR_INVALID_NULL_PTR;
233 }
234
235 ultrahdr_metadata_struct metadata;
236 metadata.version = kJpegrVersion;
237
238 jpegr_uncompressed_struct uncompressed_yuv_420_image;
239 unique_ptr<uint8_t[]> uncompressed_yuv_420_image_data = make_unique<uint8_t[]>(
240 uncompressed_p010_image->width * uncompressed_p010_image->height * 3 / 2);
241 uncompressed_yuv_420_image.data = uncompressed_yuv_420_image_data.get();
242 JPEGR_CHECK(toneMap(uncompressed_p010_image, &uncompressed_yuv_420_image));
243
244 jpegr_uncompressed_struct map;
245 JPEGR_CHECK(generateGainMap(
246 &uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map));
247 std::unique_ptr<uint8_t[]> map_data;
248 map_data.reset(reinterpret_cast<uint8_t*>(map.data));
249
250 JpegEncoderHelper jpeg_encoder_gainmap;
251 JPEGR_CHECK(compressGainMap(&map, &jpeg_encoder_gainmap));
252 jpegr_compressed_struct compressed_map;
253 compressed_map.maxLength = jpeg_encoder_gainmap.getCompressedImageSize();
254 compressed_map.length = compressed_map.maxLength;
255 compressed_map.data = jpeg_encoder_gainmap.getCompressedImagePtr();
256 compressed_map.colorGamut = ULTRAHDR_COLORGAMUT_UNSPECIFIED;
257
258 sp<DataStruct> icc = IccHelper::writeIccProfile(ULTRAHDR_TF_SRGB,
259 uncompressed_yuv_420_image.colorGamut);
260
261 // Convert to Bt601 YUV encoding for JPEG encode
262 JPEGR_CHECK(convertYuv(&uncompressed_yuv_420_image, uncompressed_yuv_420_image.colorGamut,
263 ULTRAHDR_COLORGAMUT_P3));
264
265 JpegEncoderHelper jpeg_encoder;
266 if (!jpeg_encoder.compressImage(uncompressed_yuv_420_image.data,
267 uncompressed_yuv_420_image.width,
268 uncompressed_yuv_420_image.height, quality,
269 icc->getData(), icc->getLength())) {
270 return ERROR_JPEGR_ENCODE_ERROR;
271 }
272 jpegr_compressed_struct jpeg;
273 jpeg.data = jpeg_encoder.getCompressedImagePtr();
274 jpeg.length = jpeg_encoder.getCompressedImageSize();
275
276 // No ICC since JPEG encode already did it
277 JPEGR_CHECK(appendGainMap(&jpeg, &compressed_map, exif, /* icc */ nullptr, /* icc size */ 0,
278 &metadata, dest));
279
280 return NO_ERROR;
281 }
282
283 /* Encode API-1 */
encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,jr_uncompressed_ptr uncompressed_yuv_420_image,ultrahdr_transfer_function hdr_tf,jr_compressed_ptr dest,int quality,jr_exif_ptr exif)284 status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
285 jr_uncompressed_ptr uncompressed_yuv_420_image,
286 ultrahdr_transfer_function hdr_tf,
287 jr_compressed_ptr dest,
288 int quality,
289 jr_exif_ptr exif) {
290 if (uncompressed_yuv_420_image == nullptr) {
291 ALOGE("received nullptr for uncompressed 420 image");
292 return ERROR_JPEGR_INVALID_NULL_PTR;
293 }
294
295 if (exif != nullptr && exif->data == nullptr) {
296 ALOGE("received nullptr for exif metadata");
297 return ERROR_JPEGR_INVALID_NULL_PTR;
298 }
299
300 if (status_t ret = areInputArgumentsValid(
301 uncompressed_p010_image, uncompressed_yuv_420_image, hdr_tf,
302 dest, quality) != NO_ERROR) {
303 return ret;
304 }
305
306 ultrahdr_metadata_struct metadata;
307 metadata.version = kJpegrVersion;
308
309 jpegr_uncompressed_struct map;
310 JPEGR_CHECK(generateGainMap(
311 uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map));
312 std::unique_ptr<uint8_t[]> map_data;
313 map_data.reset(reinterpret_cast<uint8_t*>(map.data));
314
315 JpegEncoderHelper jpeg_encoder_gainmap;
316 JPEGR_CHECK(compressGainMap(&map, &jpeg_encoder_gainmap));
317 jpegr_compressed_struct compressed_map;
318 compressed_map.maxLength = jpeg_encoder_gainmap.getCompressedImageSize();
319 compressed_map.length = compressed_map.maxLength;
320 compressed_map.data = jpeg_encoder_gainmap.getCompressedImagePtr();
321 compressed_map.colorGamut = ULTRAHDR_COLORGAMUT_UNSPECIFIED;
322
323 sp<DataStruct> icc = IccHelper::writeIccProfile(ULTRAHDR_TF_SRGB,
324 uncompressed_yuv_420_image->colorGamut);
325
326 // Convert to Bt601 YUV encoding for JPEG encode; make a copy so as to no clobber client data
327 unique_ptr<uint8_t[]> yuv_420_bt601_data = make_unique<uint8_t[]>(
328 uncompressed_yuv_420_image->width * uncompressed_yuv_420_image->height * 3 / 2);
329 memcpy(yuv_420_bt601_data.get(), uncompressed_yuv_420_image->data,
330 uncompressed_yuv_420_image->width * uncompressed_yuv_420_image->height * 3 / 2);
331
332 jpegr_uncompressed_struct yuv_420_bt601_image = {
333 yuv_420_bt601_data.get(), uncompressed_yuv_420_image->width, uncompressed_yuv_420_image->height,
334 uncompressed_yuv_420_image->colorGamut };
335 JPEGR_CHECK(convertYuv(&yuv_420_bt601_image, yuv_420_bt601_image.colorGamut,
336 ULTRAHDR_COLORGAMUT_P3));
337
338 JpegEncoderHelper jpeg_encoder;
339 if (!jpeg_encoder.compressImage(yuv_420_bt601_image.data,
340 yuv_420_bt601_image.width,
341 yuv_420_bt601_image.height, quality,
342 icc->getData(), icc->getLength())) {
343 return ERROR_JPEGR_ENCODE_ERROR;
344 }
345 jpegr_compressed_struct jpeg;
346 jpeg.data = jpeg_encoder.getCompressedImagePtr();
347 jpeg.length = jpeg_encoder.getCompressedImageSize();
348
349 // No ICC since jpeg encode already did it
350 JPEGR_CHECK(appendGainMap(&jpeg, &compressed_map, exif, /* icc */ nullptr, /* icc size */ 0,
351 &metadata, dest));
352
353 return NO_ERROR;
354 }
355
356 /* Encode API-2 */
encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,jr_uncompressed_ptr uncompressed_yuv_420_image,jr_compressed_ptr compressed_jpeg_image,ultrahdr_transfer_function hdr_tf,jr_compressed_ptr dest)357 status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
358 jr_uncompressed_ptr uncompressed_yuv_420_image,
359 jr_compressed_ptr compressed_jpeg_image,
360 ultrahdr_transfer_function hdr_tf,
361 jr_compressed_ptr dest) {
362 if (uncompressed_yuv_420_image == nullptr) {
363 ALOGE("received nullptr for uncompressed 420 image");
364 return ERROR_JPEGR_INVALID_NULL_PTR;
365 }
366
367 if (compressed_jpeg_image == nullptr || compressed_jpeg_image->data == nullptr) {
368 ALOGE("received nullptr for compressed jpeg image");
369 return ERROR_JPEGR_INVALID_NULL_PTR;
370 }
371
372 if (status_t ret = areInputArgumentsValid(
373 uncompressed_p010_image, uncompressed_yuv_420_image, hdr_tf, dest) != NO_ERROR) {
374 return ret;
375 }
376
377 ultrahdr_metadata_struct metadata;
378 metadata.version = kJpegrVersion;
379
380 jpegr_uncompressed_struct map;
381 JPEGR_CHECK(generateGainMap(
382 uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map));
383 std::unique_ptr<uint8_t[]> map_data;
384 map_data.reset(reinterpret_cast<uint8_t*>(map.data));
385
386 JpegEncoderHelper jpeg_encoder_gainmap;
387 JPEGR_CHECK(compressGainMap(&map, &jpeg_encoder_gainmap));
388 jpegr_compressed_struct compressed_map;
389 compressed_map.maxLength = jpeg_encoder_gainmap.getCompressedImageSize();
390 compressed_map.length = compressed_map.maxLength;
391 compressed_map.data = jpeg_encoder_gainmap.getCompressedImagePtr();
392 compressed_map.colorGamut = ULTRAHDR_COLORGAMUT_UNSPECIFIED;
393
394 // We just want to check if ICC is present, so don't do a full decode. Note,
395 // this doesn't verify that the ICC is valid.
396 JpegDecoderHelper decoder;
397 std::vector<uint8_t> icc;
398 decoder.getCompressedImageParameters(compressed_jpeg_image->data, compressed_jpeg_image->length,
399 /* pWidth */ nullptr, /* pHeight */ nullptr,
400 &icc, /* exifData */ nullptr);
401
402 // Add ICC if not already present.
403 if (icc.size() > 0) {
404 JPEGR_CHECK(appendGainMap(compressed_jpeg_image, &compressed_map, /* exif */ nullptr,
405 /* icc */ nullptr, /* icc size */ 0, &metadata, dest));
406 } else {
407 sp<DataStruct> newIcc = IccHelper::writeIccProfile(ULTRAHDR_TF_SRGB,
408 uncompressed_yuv_420_image->colorGamut);
409 JPEGR_CHECK(appendGainMap(compressed_jpeg_image, &compressed_map, /* exif */ nullptr,
410 newIcc->getData(), newIcc->getLength(), &metadata, dest));
411 }
412
413 return NO_ERROR;
414 }
415
416 /* Encode API-3 */
encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,jr_compressed_ptr compressed_jpeg_image,ultrahdr_transfer_function hdr_tf,jr_compressed_ptr dest)417 status_t JpegR::encodeJPEGR(jr_uncompressed_ptr uncompressed_p010_image,
418 jr_compressed_ptr compressed_jpeg_image,
419 ultrahdr_transfer_function hdr_tf,
420 jr_compressed_ptr dest) {
421 if (compressed_jpeg_image == nullptr || compressed_jpeg_image->data == nullptr) {
422 ALOGE("received nullptr for compressed jpeg image");
423 return ERROR_JPEGR_INVALID_NULL_PTR;
424 }
425
426 if (status_t ret = areInputArgumentsValid(
427 uncompressed_p010_image, /* uncompressed_yuv_420_image */ nullptr,
428 hdr_tf, dest) != NO_ERROR) {
429 return ret;
430 }
431
432 // Note: output is Bt.601 YUV encoded regardless of gamut, due to jpeg decode.
433 JpegDecoderHelper jpeg_decoder;
434 if (!jpeg_decoder.decompressImage(compressed_jpeg_image->data, compressed_jpeg_image->length)) {
435 return ERROR_JPEGR_DECODE_ERROR;
436 }
437 jpegr_uncompressed_struct uncompressed_yuv_420_image;
438 uncompressed_yuv_420_image.data = jpeg_decoder.getDecompressedImagePtr();
439 uncompressed_yuv_420_image.width = jpeg_decoder.getDecompressedImageWidth();
440 uncompressed_yuv_420_image.height = jpeg_decoder.getDecompressedImageHeight();
441 uncompressed_yuv_420_image.colorGamut = compressed_jpeg_image->colorGamut;
442
443 if (uncompressed_p010_image->width != uncompressed_yuv_420_image.width
444 || uncompressed_p010_image->height != uncompressed_yuv_420_image.height) {
445 return ERROR_JPEGR_RESOLUTION_MISMATCH;
446 }
447
448 ultrahdr_metadata_struct metadata;
449 metadata.version = kJpegrVersion;
450
451 jpegr_uncompressed_struct map;
452 // Indicate that the SDR image is Bt.601 YUV encoded.
453 JPEGR_CHECK(generateGainMap(
454 &uncompressed_yuv_420_image, uncompressed_p010_image, hdr_tf, &metadata, &map,
455 true /* sdr_is_601 */ ));
456 std::unique_ptr<uint8_t[]> map_data;
457 map_data.reset(reinterpret_cast<uint8_t*>(map.data));
458
459 JpegEncoderHelper jpeg_encoder_gainmap;
460 JPEGR_CHECK(compressGainMap(&map, &jpeg_encoder_gainmap));
461 jpegr_compressed_struct compressed_map;
462 compressed_map.maxLength = jpeg_encoder_gainmap.getCompressedImageSize();
463 compressed_map.length = compressed_map.maxLength;
464 compressed_map.data = jpeg_encoder_gainmap.getCompressedImagePtr();
465 compressed_map.colorGamut = ULTRAHDR_COLORGAMUT_UNSPECIFIED;
466
467 // We just want to check if ICC is present, so don't do a full decode. Note,
468 // this doesn't verify that the ICC is valid.
469 JpegDecoderHelper decoder;
470 std::vector<uint8_t> icc;
471 decoder.getCompressedImageParameters(compressed_jpeg_image->data, compressed_jpeg_image->length,
472 /* pWidth */ nullptr, /* pHeight */ nullptr,
473 &icc, /* exifData */ nullptr);
474
475 // Add ICC if not already present.
476 if (icc.size() > 0) {
477 JPEGR_CHECK(appendGainMap(compressed_jpeg_image, &compressed_map, /* exif */ nullptr,
478 /* icc */ nullptr, /* icc size */ 0, &metadata, dest));
479 } else {
480 sp<DataStruct> newIcc = IccHelper::writeIccProfile(ULTRAHDR_TF_SRGB,
481 uncompressed_yuv_420_image.colorGamut);
482 JPEGR_CHECK(appendGainMap(compressed_jpeg_image, &compressed_map, /* exif */ nullptr,
483 newIcc->getData(), newIcc->getLength(), &metadata, dest));
484 }
485
486 return NO_ERROR;
487 }
488
489 /* Encode API-4 */
encodeJPEGR(jr_compressed_ptr compressed_jpeg_image,jr_compressed_ptr compressed_gainmap,ultrahdr_metadata_ptr metadata,jr_compressed_ptr dest)490 status_t JpegR::encodeJPEGR(jr_compressed_ptr compressed_jpeg_image,
491 jr_compressed_ptr compressed_gainmap,
492 ultrahdr_metadata_ptr metadata,
493 jr_compressed_ptr dest) {
494 if (compressed_jpeg_image == nullptr || compressed_jpeg_image->data == nullptr) {
495 ALOGE("received nullptr for compressed jpeg image");
496 return ERROR_JPEGR_INVALID_NULL_PTR;
497 }
498
499 if (compressed_gainmap == nullptr || compressed_gainmap->data == nullptr) {
500 ALOGE("received nullptr for compressed gain map");
501 return ERROR_JPEGR_INVALID_NULL_PTR;
502 }
503
504 if (dest == nullptr || dest->data == nullptr) {
505 ALOGE("received nullptr for destination");
506 return ERROR_JPEGR_INVALID_NULL_PTR;
507 }
508
509 // We just want to check if ICC is present, so don't do a full decode. Note,
510 // this doesn't verify that the ICC is valid.
511 JpegDecoderHelper decoder;
512 std::vector<uint8_t> icc;
513 decoder.getCompressedImageParameters(compressed_jpeg_image->data, compressed_jpeg_image->length,
514 /* pWidth */ nullptr, /* pHeight */ nullptr,
515 &icc, /* exifData */ nullptr);
516
517 // Add ICC if not already present.
518 if (icc.size() > 0) {
519 JPEGR_CHECK(appendGainMap(compressed_jpeg_image, compressed_gainmap, /* exif */ nullptr,
520 /* icc */ nullptr, /* icc size */ 0, metadata, dest));
521 } else {
522 sp<DataStruct> newIcc = IccHelper::writeIccProfile(ULTRAHDR_TF_SRGB,
523 compressed_jpeg_image->colorGamut);
524 JPEGR_CHECK(appendGainMap(compressed_jpeg_image, compressed_gainmap, /* exif */ nullptr,
525 newIcc->getData(), newIcc->getLength(), metadata, dest));
526 }
527
528 return NO_ERROR;
529 }
530
getJPEGRInfo(jr_compressed_ptr compressed_jpegr_image,jr_info_ptr jpegr_info)531 status_t JpegR::getJPEGRInfo(jr_compressed_ptr compressed_jpegr_image, jr_info_ptr jpegr_info) {
532 if (compressed_jpegr_image == nullptr || compressed_jpegr_image->data == nullptr) {
533 ALOGE("received nullptr for compressed jpegr image");
534 return ERROR_JPEGR_INVALID_NULL_PTR;
535 }
536
537 if (jpegr_info == nullptr) {
538 ALOGE("received nullptr for compressed jpegr info struct");
539 return ERROR_JPEGR_INVALID_NULL_PTR;
540 }
541
542 jpegr_compressed_struct primary_image, gainmap_image;
543 status_t status =
544 extractPrimaryImageAndGainMap(compressed_jpegr_image, &primary_image, &gainmap_image);
545 if (status != NO_ERROR && status != ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND) {
546 return status;
547 }
548
549 JpegDecoderHelper jpeg_decoder;
550 if (!jpeg_decoder.getCompressedImageParameters(primary_image.data, primary_image.length,
551 &jpegr_info->width, &jpegr_info->height,
552 jpegr_info->iccData, jpegr_info->exifData)) {
553 return ERROR_JPEGR_DECODE_ERROR;
554 }
555
556 return status;
557 }
558
559 /* Decode API */
decodeJPEGR(jr_compressed_ptr compressed_jpegr_image,jr_uncompressed_ptr dest,float max_display_boost,jr_exif_ptr exif,ultrahdr_output_format output_format,jr_uncompressed_ptr gain_map,ultrahdr_metadata_ptr metadata)560 status_t JpegR::decodeJPEGR(jr_compressed_ptr compressed_jpegr_image,
561 jr_uncompressed_ptr dest,
562 float max_display_boost,
563 jr_exif_ptr exif,
564 ultrahdr_output_format output_format,
565 jr_uncompressed_ptr gain_map,
566 ultrahdr_metadata_ptr metadata) {
567 if (compressed_jpegr_image == nullptr || compressed_jpegr_image->data == nullptr) {
568 ALOGE("received nullptr for compressed jpegr image");
569 return ERROR_JPEGR_INVALID_NULL_PTR;
570 }
571
572 if (dest == nullptr || dest->data == nullptr) {
573 ALOGE("received nullptr for dest image");
574 return ERROR_JPEGR_INVALID_NULL_PTR;
575 }
576
577 if (max_display_boost < 1.0f) {
578 ALOGE("received bad value for max_display_boost %f", max_display_boost);
579 return ERROR_JPEGR_INVALID_INPUT_TYPE;
580 }
581
582 if (exif != nullptr && exif->data == nullptr) {
583 ALOGE("received nullptr address for exif data");
584 return ERROR_JPEGR_INVALID_INPUT_TYPE;
585 }
586
587 if (output_format <= ULTRAHDR_OUTPUT_UNSPECIFIED || output_format > ULTRAHDR_OUTPUT_MAX) {
588 ALOGE("received bad value for output format %d", output_format);
589 return ERROR_JPEGR_INVALID_INPUT_TYPE;
590 }
591
592 jpegr_compressed_struct primary_image, gainmap_image;
593 status_t status =
594 extractPrimaryImageAndGainMap(compressed_jpegr_image, &primary_image, &gainmap_image);
595 if (status != NO_ERROR) {
596 if (output_format != ULTRAHDR_OUTPUT_SDR || status != ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND) {
597 ALOGE("received invalid compressed jpegr image");
598 return status;
599 }
600 }
601
602 JpegDecoderHelper jpeg_decoder;
603 if (!jpeg_decoder.decompressImage(primary_image.data, primary_image.length,
604 (output_format == ULTRAHDR_OUTPUT_SDR))) {
605 return ERROR_JPEGR_DECODE_ERROR;
606 }
607
608 if (output_format == ULTRAHDR_OUTPUT_SDR) {
609 if ((jpeg_decoder.getDecompressedImageWidth() *
610 jpeg_decoder.getDecompressedImageHeight() * 4) >
611 jpeg_decoder.getDecompressedImageSize()) {
612 return ERROR_JPEGR_CALCULATION_ERROR;
613 }
614 } else {
615 if ((jpeg_decoder.getDecompressedImageWidth() *
616 jpeg_decoder.getDecompressedImageHeight() * 3 / 2) >
617 jpeg_decoder.getDecompressedImageSize()) {
618 return ERROR_JPEGR_CALCULATION_ERROR;
619 }
620 }
621
622 if (exif != nullptr) {
623 if (exif->data == nullptr) {
624 return ERROR_JPEGR_INVALID_NULL_PTR;
625 }
626 if (exif->length < jpeg_decoder.getEXIFSize()) {
627 return ERROR_JPEGR_BUFFER_TOO_SMALL;
628 }
629 memcpy(exif->data, jpeg_decoder.getEXIFPtr(), jpeg_decoder.getEXIFSize());
630 exif->length = jpeg_decoder.getEXIFSize();
631 }
632
633 if (output_format == ULTRAHDR_OUTPUT_SDR) {
634 dest->width = jpeg_decoder.getDecompressedImageWidth();
635 dest->height = jpeg_decoder.getDecompressedImageHeight();
636 memcpy(dest->data, jpeg_decoder.getDecompressedImagePtr(), dest->width * dest->height * 4);
637 return NO_ERROR;
638 }
639
640 JpegDecoderHelper gain_map_decoder;
641 if (!gain_map_decoder.decompressImage(gainmap_image.data, gainmap_image.length)) {
642 return ERROR_JPEGR_DECODE_ERROR;
643 }
644 if ((gain_map_decoder.getDecompressedImageWidth() *
645 gain_map_decoder.getDecompressedImageHeight()) >
646 gain_map_decoder.getDecompressedImageSize()) {
647 return ERROR_JPEGR_CALCULATION_ERROR;
648 }
649
650 jpegr_uncompressed_struct map;
651 map.data = gain_map_decoder.getDecompressedImagePtr();
652 map.width = gain_map_decoder.getDecompressedImageWidth();
653 map.height = gain_map_decoder.getDecompressedImageHeight();
654
655 if (gain_map != nullptr) {
656 gain_map->width = map.width;
657 gain_map->height = map.height;
658 int size = gain_map->width * gain_map->height;
659 gain_map->data = malloc(size);
660 memcpy(gain_map->data, map.data, size);
661 }
662
663 ultrahdr_metadata_struct uhdr_metadata;
664 if (!getMetadataFromXMP(static_cast<uint8_t*>(gain_map_decoder.getXMPPtr()),
665 gain_map_decoder.getXMPSize(), &uhdr_metadata)) {
666 return ERROR_JPEGR_INVALID_METADATA;
667 }
668
669 if (metadata != nullptr) {
670 metadata->version = uhdr_metadata.version;
671 metadata->minContentBoost = uhdr_metadata.minContentBoost;
672 metadata->maxContentBoost = uhdr_metadata.maxContentBoost;
673 metadata->gamma = uhdr_metadata.gamma;
674 metadata->offsetSdr = uhdr_metadata.offsetSdr;
675 metadata->offsetHdr = uhdr_metadata.offsetHdr;
676 metadata->hdrCapacityMin = uhdr_metadata.hdrCapacityMin;
677 metadata->hdrCapacityMax = uhdr_metadata.hdrCapacityMax;
678 }
679
680 jpegr_uncompressed_struct uncompressed_yuv_420_image;
681 uncompressed_yuv_420_image.data = jpeg_decoder.getDecompressedImagePtr();
682 uncompressed_yuv_420_image.width = jpeg_decoder.getDecompressedImageWidth();
683 uncompressed_yuv_420_image.height = jpeg_decoder.getDecompressedImageHeight();
684 uncompressed_yuv_420_image.colorGamut = IccHelper::readIccColorGamut(
685 jpeg_decoder.getICCPtr(), jpeg_decoder.getICCSize());
686
687 JPEGR_CHECK(applyGainMap(&uncompressed_yuv_420_image, &map, &uhdr_metadata, output_format,
688 max_display_boost, dest));
689 return NO_ERROR;
690 }
691
compressGainMap(jr_uncompressed_ptr uncompressed_gain_map,JpegEncoderHelper * jpeg_encoder)692 status_t JpegR::compressGainMap(jr_uncompressed_ptr uncompressed_gain_map,
693 JpegEncoderHelper* jpeg_encoder) {
694 if (uncompressed_gain_map == nullptr || jpeg_encoder == nullptr) {
695 return ERROR_JPEGR_INVALID_NULL_PTR;
696 }
697
698 // Don't need to convert YUV to Bt601 since single channel
699 if (!jpeg_encoder->compressImage(uncompressed_gain_map->data,
700 uncompressed_gain_map->width,
701 uncompressed_gain_map->height,
702 kMapCompressQuality,
703 nullptr,
704 0,
705 true /* isSingleChannel */)) {
706 return ERROR_JPEGR_ENCODE_ERROR;
707 }
708
709 return NO_ERROR;
710 }
711
712 const int kJobSzInRows = 16;
713 static_assert(kJobSzInRows > 0 && kJobSzInRows % kMapDimensionScaleFactor == 0,
714 "align job size to kMapDimensionScaleFactor");
715
716 class JobQueue {
717 public:
718 bool dequeueJob(size_t& rowStart, size_t& rowEnd);
719 void enqueueJob(size_t rowStart, size_t rowEnd);
720 void markQueueForEnd();
721 void reset();
722
723 private:
724 bool mQueuedAllJobs = false;
725 std::deque<std::tuple<size_t, size_t>> mJobs;
726 std::mutex mMutex;
727 std::condition_variable mCv;
728 };
729
dequeueJob(size_t & rowStart,size_t & rowEnd)730 bool JobQueue::dequeueJob(size_t& rowStart, size_t& rowEnd) {
731 std::unique_lock<std::mutex> lock{mMutex};
732 while (true) {
733 if (mJobs.empty()) {
734 if (mQueuedAllJobs) {
735 return false;
736 } else {
737 mCv.wait_for(lock, std::chrono::milliseconds(100));
738 }
739 } else {
740 auto it = mJobs.begin();
741 rowStart = std::get<0>(*it);
742 rowEnd = std::get<1>(*it);
743 mJobs.erase(it);
744 return true;
745 }
746 }
747 return false;
748 }
749
enqueueJob(size_t rowStart,size_t rowEnd)750 void JobQueue::enqueueJob(size_t rowStart, size_t rowEnd) {
751 std::unique_lock<std::mutex> lock{mMutex};
752 mJobs.push_back(std::make_tuple(rowStart, rowEnd));
753 lock.unlock();
754 mCv.notify_one();
755 }
756
markQueueForEnd()757 void JobQueue::markQueueForEnd() {
758 std::unique_lock<std::mutex> lock{mMutex};
759 mQueuedAllJobs = true;
760 lock.unlock();
761 mCv.notify_all();
762 }
763
reset()764 void JobQueue::reset() {
765 std::unique_lock<std::mutex> lock{mMutex};
766 mJobs.clear();
767 mQueuedAllJobs = false;
768 }
769
generateGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,jr_uncompressed_ptr uncompressed_p010_image,ultrahdr_transfer_function hdr_tf,ultrahdr_metadata_ptr metadata,jr_uncompressed_ptr dest,bool sdr_is_601)770 status_t JpegR::generateGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
771 jr_uncompressed_ptr uncompressed_p010_image,
772 ultrahdr_transfer_function hdr_tf,
773 ultrahdr_metadata_ptr metadata,
774 jr_uncompressed_ptr dest,
775 bool sdr_is_601) {
776 if (uncompressed_yuv_420_image == nullptr
777 || uncompressed_p010_image == nullptr
778 || metadata == nullptr
779 || dest == nullptr) {
780 return ERROR_JPEGR_INVALID_NULL_PTR;
781 }
782
783 if (uncompressed_yuv_420_image->width != uncompressed_p010_image->width
784 || uncompressed_yuv_420_image->height != uncompressed_p010_image->height) {
785 return ERROR_JPEGR_RESOLUTION_MISMATCH;
786 }
787
788 if (uncompressed_yuv_420_image->colorGamut == ULTRAHDR_COLORGAMUT_UNSPECIFIED
789 || uncompressed_p010_image->colorGamut == ULTRAHDR_COLORGAMUT_UNSPECIFIED) {
790 return ERROR_JPEGR_INVALID_COLORGAMUT;
791 }
792
793 size_t image_width = uncompressed_yuv_420_image->width;
794 size_t image_height = uncompressed_yuv_420_image->height;
795 size_t map_width = image_width / kMapDimensionScaleFactor;
796 size_t map_height = image_height / kMapDimensionScaleFactor;
797 size_t map_stride = static_cast<size_t>(
798 floor((map_width + kJpegBlock - 1) / kJpegBlock)) * kJpegBlock;
799 size_t map_height_aligned = ((map_height + 1) >> 1) << 1;
800
801 dest->width = map_stride;
802 dest->height = map_height_aligned;
803 dest->colorGamut = ULTRAHDR_COLORGAMUT_UNSPECIFIED;
804 dest->data = new uint8_t[map_stride * map_height_aligned];
805 std::unique_ptr<uint8_t[]> map_data;
806 map_data.reset(reinterpret_cast<uint8_t*>(dest->data));
807
808 ColorTransformFn hdrInvOetf = nullptr;
809 float hdr_white_nits = kSdrWhiteNits;
810 switch (hdr_tf) {
811 case ULTRAHDR_TF_LINEAR:
812 hdrInvOetf = identityConversion;
813 break;
814 case ULTRAHDR_TF_HLG:
815 #if USE_HLG_INVOETF_LUT
816 hdrInvOetf = hlgInvOetfLUT;
817 #else
818 hdrInvOetf = hlgInvOetf;
819 #endif
820 hdr_white_nits = kHlgMaxNits;
821 break;
822 case ULTRAHDR_TF_PQ:
823 #if USE_PQ_INVOETF_LUT
824 hdrInvOetf = pqInvOetfLUT;
825 #else
826 hdrInvOetf = pqInvOetf;
827 #endif
828 hdr_white_nits = kPqMaxNits;
829 break;
830 default:
831 // Should be impossible to hit after input validation.
832 return ERROR_JPEGR_INVALID_TRANS_FUNC;
833 }
834
835 metadata->maxContentBoost = hdr_white_nits / kSdrWhiteNits;
836 metadata->minContentBoost = 1.0f;
837 metadata->gamma = 1.0f;
838 metadata->offsetSdr = 0.0f;
839 metadata->offsetHdr = 0.0f;
840 metadata->hdrCapacityMin = 1.0f;
841 metadata->hdrCapacityMax = metadata->maxContentBoost;
842
843 float log2MinBoost = log2(metadata->minContentBoost);
844 float log2MaxBoost = log2(metadata->maxContentBoost);
845
846 ColorTransformFn hdrGamutConversionFn = getHdrConversionFn(
847 uncompressed_yuv_420_image->colorGamut, uncompressed_p010_image->colorGamut);
848
849 ColorCalculationFn luminanceFn = nullptr;
850 ColorTransformFn sdrYuvToRgbFn = nullptr;
851 switch (uncompressed_yuv_420_image->colorGamut) {
852 case ULTRAHDR_COLORGAMUT_BT709:
853 luminanceFn = srgbLuminance;
854 sdrYuvToRgbFn = srgbYuvToRgb;
855 break;
856 case ULTRAHDR_COLORGAMUT_P3:
857 luminanceFn = p3Luminance;
858 sdrYuvToRgbFn = p3YuvToRgb;
859 break;
860 case ULTRAHDR_COLORGAMUT_BT2100:
861 luminanceFn = bt2100Luminance;
862 sdrYuvToRgbFn = bt2100YuvToRgb;
863 break;
864 case ULTRAHDR_COLORGAMUT_UNSPECIFIED:
865 // Should be impossible to hit after input validation.
866 return ERROR_JPEGR_INVALID_COLORGAMUT;
867 }
868 if (sdr_is_601) {
869 sdrYuvToRgbFn = p3YuvToRgb;
870 }
871
872 ColorTransformFn hdrYuvToRgbFn = nullptr;
873 switch (uncompressed_p010_image->colorGamut) {
874 case ULTRAHDR_COLORGAMUT_BT709:
875 hdrYuvToRgbFn = srgbYuvToRgb;
876 break;
877 case ULTRAHDR_COLORGAMUT_P3:
878 hdrYuvToRgbFn = p3YuvToRgb;
879 break;
880 case ULTRAHDR_COLORGAMUT_BT2100:
881 hdrYuvToRgbFn = bt2100YuvToRgb;
882 break;
883 case ULTRAHDR_COLORGAMUT_UNSPECIFIED:
884 // Should be impossible to hit after input validation.
885 return ERROR_JPEGR_INVALID_COLORGAMUT;
886 }
887
888 std::mutex mutex;
889 const int threads = std::clamp(GetCPUCoreCount(), 1, 4);
890 size_t rowStep = threads == 1 ? image_height : kJobSzInRows;
891 JobQueue jobQueue;
892
893 std::function<void()> generateMap = [uncompressed_yuv_420_image, uncompressed_p010_image,
894 metadata, dest, hdrInvOetf, hdrGamutConversionFn,
895 luminanceFn, sdrYuvToRgbFn, hdrYuvToRgbFn, hdr_white_nits,
896 log2MinBoost, log2MaxBoost, &jobQueue]() -> void {
897 size_t rowStart, rowEnd;
898 size_t dest_map_width = uncompressed_yuv_420_image->width / kMapDimensionScaleFactor;
899 size_t dest_map_stride = dest->width;
900 while (jobQueue.dequeueJob(rowStart, rowEnd)) {
901 for (size_t y = rowStart; y < rowEnd; ++y) {
902 for (size_t x = 0; x < dest_map_width; ++x) {
903 Color sdr_yuv_gamma =
904 sampleYuv420(uncompressed_yuv_420_image, kMapDimensionScaleFactor, x, y);
905 Color sdr_rgb_gamma = sdrYuvToRgbFn(sdr_yuv_gamma);
906 // We are assuming the SDR input is always sRGB transfer.
907 #if USE_SRGB_INVOETF_LUT
908 Color sdr_rgb = srgbInvOetfLUT(sdr_rgb_gamma);
909 #else
910 Color sdr_rgb = srgbInvOetf(sdr_rgb_gamma);
911 #endif
912 float sdr_y_nits = luminanceFn(sdr_rgb) * kSdrWhiteNits;
913
914 Color hdr_yuv_gamma = sampleP010(uncompressed_p010_image, kMapDimensionScaleFactor, x, y);
915 Color hdr_rgb_gamma = hdrYuvToRgbFn(hdr_yuv_gamma);
916 Color hdr_rgb = hdrInvOetf(hdr_rgb_gamma);
917 hdr_rgb = hdrGamutConversionFn(hdr_rgb);
918 float hdr_y_nits = luminanceFn(hdr_rgb) * hdr_white_nits;
919
920 size_t pixel_idx = x + y * dest_map_stride;
921 reinterpret_cast<uint8_t*>(dest->data)[pixel_idx] =
922 encodeGain(sdr_y_nits, hdr_y_nits, metadata, log2MinBoost, log2MaxBoost);
923 }
924 }
925 }
926 };
927
928 // generate map
929 std::vector<std::thread> workers;
930 for (int th = 0; th < threads - 1; th++) {
931 workers.push_back(std::thread(generateMap));
932 }
933
934 rowStep = (threads == 1 ? image_height : kJobSzInRows) / kMapDimensionScaleFactor;
935 for (size_t rowStart = 0; rowStart < map_height;) {
936 size_t rowEnd = std::min(rowStart + rowStep, map_height);
937 jobQueue.enqueueJob(rowStart, rowEnd);
938 rowStart = rowEnd;
939 }
940 jobQueue.markQueueForEnd();
941 generateMap();
942 std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
943
944 map_data.release();
945 return NO_ERROR;
946 }
947
applyGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,jr_uncompressed_ptr uncompressed_gain_map,ultrahdr_metadata_ptr metadata,ultrahdr_output_format output_format,float max_display_boost,jr_uncompressed_ptr dest)948 status_t JpegR::applyGainMap(jr_uncompressed_ptr uncompressed_yuv_420_image,
949 jr_uncompressed_ptr uncompressed_gain_map,
950 ultrahdr_metadata_ptr metadata,
951 ultrahdr_output_format output_format,
952 float max_display_boost,
953 jr_uncompressed_ptr dest) {
954 if (uncompressed_yuv_420_image == nullptr
955 || uncompressed_gain_map == nullptr
956 || metadata == nullptr
957 || dest == nullptr) {
958 return ERROR_JPEGR_INVALID_NULL_PTR;
959 }
960
961 if (metadata->version.compare("1.0")) {
962 ALOGE("Unsupported metadata version: %s", metadata->version.c_str());
963 return ERROR_JPEGR_UNSUPPORTED_METADATA;
964 }
965 if (metadata->gamma != 1.0f) {
966 ALOGE("Unsupported metadata gamma: %f", metadata->gamma);
967 return ERROR_JPEGR_UNSUPPORTED_METADATA;
968 }
969 if (metadata->offsetSdr != 0.0f || metadata->offsetHdr != 0.0f) {
970 ALOGE("Unsupported metadata offset sdr, hdr: %f, %f", metadata->offsetSdr,
971 metadata->offsetHdr);
972 return ERROR_JPEGR_UNSUPPORTED_METADATA;
973 }
974 if (metadata->hdrCapacityMin != metadata->minContentBoost
975 || metadata->hdrCapacityMax != metadata->maxContentBoost) {
976 ALOGE("Unsupported metadata hdr capacity min, max: %f, %f", metadata->hdrCapacityMin,
977 metadata->hdrCapacityMax);
978 return ERROR_JPEGR_UNSUPPORTED_METADATA;
979 }
980
981 // TODO: remove once map scaling factor is computed based on actual map dims
982 size_t image_width = uncompressed_yuv_420_image->width;
983 size_t image_height = uncompressed_yuv_420_image->height;
984 size_t map_width = image_width / kMapDimensionScaleFactor;
985 size_t map_height = image_height / kMapDimensionScaleFactor;
986 map_width = static_cast<size_t>(
987 floor((map_width + kJpegBlock - 1) / kJpegBlock)) * kJpegBlock;
988 map_height = ((map_height + 1) >> 1) << 1;
989 if (map_width != uncompressed_gain_map->width
990 || map_height != uncompressed_gain_map->height) {
991 ALOGE("gain map dimensions and primary image dimensions are not to scale");
992 return ERROR_JPEGR_INVALID_INPUT_TYPE;
993 }
994
995 dest->width = uncompressed_yuv_420_image->width;
996 dest->height = uncompressed_yuv_420_image->height;
997 ShepardsIDW idwTable(kMapDimensionScaleFactor);
998 float display_boost = std::min(max_display_boost, metadata->maxContentBoost);
999 GainLUT gainLUT(metadata, display_boost);
1000
1001 JobQueue jobQueue;
1002 std::function<void()> applyRecMap = [uncompressed_yuv_420_image, uncompressed_gain_map,
1003 metadata, dest, &jobQueue, &idwTable, output_format,
1004 &gainLUT, display_boost]() -> void {
1005 size_t width = uncompressed_yuv_420_image->width;
1006 size_t height = uncompressed_yuv_420_image->height;
1007
1008 size_t rowStart, rowEnd;
1009 while (jobQueue.dequeueJob(rowStart, rowEnd)) {
1010 for (size_t y = rowStart; y < rowEnd; ++y) {
1011 for (size_t x = 0; x < width; ++x) {
1012 Color yuv_gamma_sdr = getYuv420Pixel(uncompressed_yuv_420_image, x, y);
1013 // Assuming the sdr image is a decoded JPEG, we should always use Rec.601 YUV coefficients
1014 Color rgb_gamma_sdr = p3YuvToRgb(yuv_gamma_sdr);
1015 // We are assuming the SDR base image is always sRGB transfer.
1016 #if USE_SRGB_INVOETF_LUT
1017 Color rgb_sdr = srgbInvOetfLUT(rgb_gamma_sdr);
1018 #else
1019 Color rgb_sdr = srgbInvOetf(rgb_gamma_sdr);
1020 #endif
1021 float gain;
1022 // TODO: determine map scaling factor based on actual map dims
1023 size_t map_scale_factor = kMapDimensionScaleFactor;
1024 // TODO: If map_scale_factor is guaranteed to be an integer, then remove the following.
1025 // Currently map_scale_factor is of type size_t, but it could be changed to a float
1026 // later.
1027 if (map_scale_factor != floorf(map_scale_factor)) {
1028 gain = sampleMap(uncompressed_gain_map, map_scale_factor, x, y);
1029 } else {
1030 gain = sampleMap(uncompressed_gain_map, map_scale_factor, x, y, idwTable);
1031 }
1032
1033 #if USE_APPLY_GAIN_LUT
1034 Color rgb_hdr = applyGainLUT(rgb_sdr, gain, gainLUT);
1035 #else
1036 Color rgb_hdr = applyGain(rgb_sdr, gain, metadata, display_boost);
1037 #endif
1038 rgb_hdr = rgb_hdr / display_boost;
1039 size_t pixel_idx = x + y * width;
1040
1041 switch (output_format) {
1042 case ULTRAHDR_OUTPUT_HDR_LINEAR:
1043 {
1044 uint64_t rgba_f16 = colorToRgbaF16(rgb_hdr);
1045 reinterpret_cast<uint64_t*>(dest->data)[pixel_idx] = rgba_f16;
1046 break;
1047 }
1048 case ULTRAHDR_OUTPUT_HDR_HLG:
1049 {
1050 #if USE_HLG_OETF_LUT
1051 ColorTransformFn hdrOetf = hlgOetfLUT;
1052 #else
1053 ColorTransformFn hdrOetf = hlgOetf;
1054 #endif
1055 Color rgb_gamma_hdr = hdrOetf(rgb_hdr);
1056 uint32_t rgba_1010102 = colorToRgba1010102(rgb_gamma_hdr);
1057 reinterpret_cast<uint32_t*>(dest->data)[pixel_idx] = rgba_1010102;
1058 break;
1059 }
1060 case ULTRAHDR_OUTPUT_HDR_PQ:
1061 {
1062 #if USE_HLG_OETF_LUT
1063 ColorTransformFn hdrOetf = pqOetfLUT;
1064 #else
1065 ColorTransformFn hdrOetf = pqOetf;
1066 #endif
1067 Color rgb_gamma_hdr = hdrOetf(rgb_hdr);
1068 uint32_t rgba_1010102 = colorToRgba1010102(rgb_gamma_hdr);
1069 reinterpret_cast<uint32_t*>(dest->data)[pixel_idx] = rgba_1010102;
1070 break;
1071 }
1072 default:
1073 {}
1074 // Should be impossible to hit after input validation.
1075 }
1076 }
1077 }
1078 }
1079 };
1080
1081 const int threads = std::clamp(GetCPUCoreCount(), 1, 4);
1082 std::vector<std::thread> workers;
1083 for (int th = 0; th < threads - 1; th++) {
1084 workers.push_back(std::thread(applyRecMap));
1085 }
1086 const int rowStep = threads == 1 ? uncompressed_yuv_420_image->height : kJobSzInRows;
1087 for (int rowStart = 0; rowStart < uncompressed_yuv_420_image->height;) {
1088 int rowEnd = std::min(rowStart + rowStep, uncompressed_yuv_420_image->height);
1089 jobQueue.enqueueJob(rowStart, rowEnd);
1090 rowStart = rowEnd;
1091 }
1092 jobQueue.markQueueForEnd();
1093 applyRecMap();
1094 std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
1095 return NO_ERROR;
1096 }
1097
extractPrimaryImageAndGainMap(jr_compressed_ptr compressed_jpegr_image,jr_compressed_ptr primary_image,jr_compressed_ptr gain_map)1098 status_t JpegR::extractPrimaryImageAndGainMap(jr_compressed_ptr compressed_jpegr_image,
1099 jr_compressed_ptr primary_image,
1100 jr_compressed_ptr gain_map) {
1101 if (compressed_jpegr_image == nullptr) {
1102 return ERROR_JPEGR_INVALID_NULL_PTR;
1103 }
1104
1105 MessageHandler msg_handler;
1106 std::shared_ptr<DataSegment> seg =
1107 DataSegment::Create(DataRange(0, compressed_jpegr_image->length),
1108 static_cast<const uint8_t*>(compressed_jpegr_image->data),
1109 DataSegment::BufferDispositionPolicy::kDontDelete);
1110 DataSegmentDataSource data_source(seg);
1111 JpegInfoBuilder jpeg_info_builder;
1112 jpeg_info_builder.SetImageLimit(2);
1113 JpegScanner jpeg_scanner(&msg_handler);
1114 jpeg_scanner.Run(&data_source, &jpeg_info_builder);
1115 data_source.Reset();
1116
1117 if (jpeg_scanner.HasError()) {
1118 return ERROR_JPEGR_INVALID_INPUT_TYPE;
1119 }
1120
1121 const auto& jpeg_info = jpeg_info_builder.GetInfo();
1122 const auto& image_ranges = jpeg_info.GetImageRanges();
1123
1124 if (image_ranges.empty()) {
1125 return ERROR_JPEGR_INVALID_INPUT_TYPE;
1126 }
1127
1128 if (primary_image != nullptr) {
1129 primary_image->data = static_cast<uint8_t*>(compressed_jpegr_image->data) +
1130 image_ranges[0].GetBegin();
1131 primary_image->length = image_ranges[0].GetLength();
1132 }
1133
1134 if (image_ranges.size() == 1) {
1135 return ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND;
1136 }
1137
1138 if (gain_map != nullptr) {
1139 gain_map->data = static_cast<uint8_t*>(compressed_jpegr_image->data) +
1140 image_ranges[1].GetBegin();
1141 gain_map->length = image_ranges[1].GetLength();
1142 }
1143
1144 // TODO: choose primary image and gain map image carefully
1145 if (image_ranges.size() > 2) {
1146 ALOGW("Number of jpeg images present %d, primary, gain map images may not be correctly chosen",
1147 (int)image_ranges.size());
1148 }
1149
1150 return NO_ERROR;
1151 }
1152
1153 // JPEG/R structure:
1154 // SOI (ff d8)
1155 //
1156 // (Optional, only if EXIF package is from outside)
1157 // APP1 (ff e1)
1158 // 2 bytes of length (2 + length of exif package)
1159 // EXIF package (this includes the first two bytes representing the package length)
1160 //
1161 // (Required, XMP package) APP1 (ff e1)
1162 // 2 bytes of length (2 + 29 + length of xmp package)
1163 // name space ("http://ns.adobe.com/xap/1.0/\0")
1164 // XMP
1165 //
1166 // (Required, MPF package) APP2 (ff e2)
1167 // 2 bytes of length
1168 // MPF
1169 //
1170 // (Required) primary image (without the first two bytes (SOI), may have other packages)
1171 //
1172 // SOI (ff d8)
1173 //
1174 // (Required, XMP package) APP1 (ff e1)
1175 // 2 bytes of length (2 + 29 + length of xmp package)
1176 // name space ("http://ns.adobe.com/xap/1.0/\0")
1177 // XMP
1178 //
1179 // (Required) secondary image (the gain map, without the first two bytes (SOI))
1180 //
1181 // Metadata versions we are using:
1182 // ECMA TR-98 for JFIF marker
1183 // Exif 2.2 spec for EXIF marker
1184 // Adobe XMP spec part 3 for XMP marker
1185 // ICC v4.3 spec for ICC
appendGainMap(jr_compressed_ptr compressed_jpeg_image,jr_compressed_ptr compressed_gain_map,jr_exif_ptr exif,void * icc,size_t icc_size,ultrahdr_metadata_ptr metadata,jr_compressed_ptr dest)1186 status_t JpegR::appendGainMap(jr_compressed_ptr compressed_jpeg_image,
1187 jr_compressed_ptr compressed_gain_map,
1188 jr_exif_ptr exif,
1189 void* icc, size_t icc_size,
1190 ultrahdr_metadata_ptr metadata,
1191 jr_compressed_ptr dest) {
1192 if (compressed_jpeg_image == nullptr
1193 || compressed_gain_map == nullptr
1194 || metadata == nullptr
1195 || dest == nullptr) {
1196 return ERROR_JPEGR_INVALID_NULL_PTR;
1197 }
1198
1199 if (metadata->version.compare("1.0")) {
1200 ALOGE("received bad value for version: %s", metadata->version.c_str());
1201 return ERROR_JPEGR_INVALID_INPUT_TYPE;
1202 }
1203 if (metadata->maxContentBoost < metadata->minContentBoost) {
1204 ALOGE("received bad value for content boost min %f, max %f", metadata->minContentBoost,
1205 metadata->maxContentBoost);
1206 return ERROR_JPEGR_INVALID_INPUT_TYPE;
1207 }
1208
1209 if (metadata->hdrCapacityMax < metadata->hdrCapacityMin || metadata->hdrCapacityMin < 1.0f) {
1210 ALOGE("received bad value for hdr capacity min %f, max %f", metadata->hdrCapacityMin,
1211 metadata->hdrCapacityMax);
1212 return ERROR_JPEGR_INVALID_INPUT_TYPE;
1213 }
1214
1215 if (metadata->offsetSdr < 0.0f || metadata->offsetHdr < 0.0f) {
1216 ALOGE("received bad value for offset sdr %f, hdr %f", metadata->offsetSdr,
1217 metadata->offsetHdr);
1218 return ERROR_JPEGR_INVALID_INPUT_TYPE;
1219 }
1220
1221 if (metadata->gamma <= 0.0f) {
1222 ALOGE("received bad value for gamma %f", metadata->gamma);
1223 return ERROR_JPEGR_INVALID_INPUT_TYPE;
1224 }
1225
1226 const string nameSpace = "http://ns.adobe.com/xap/1.0/";
1227 const int nameSpaceLength = nameSpace.size() + 1; // need to count the null terminator
1228
1229 // calculate secondary image length first, because the length will be written into the primary
1230 // image xmp
1231 const string xmp_secondary = generateXmpForSecondaryImage(*metadata);
1232 const int xmp_secondary_length = 2 /* 2 bytes representing the length of the package */
1233 + nameSpaceLength /* 29 bytes length of name space including \0 */
1234 + xmp_secondary.size(); /* length of xmp packet */
1235 const int secondary_image_size = 2 /* 2 bytes length of APP1 sign */
1236 + xmp_secondary_length
1237 + compressed_gain_map->length;
1238 // primary image
1239 const string xmp_primary = generateXmpForPrimaryImage(secondary_image_size, *metadata);
1240 // same as primary
1241 const int xmp_primary_length = 2 + nameSpaceLength + xmp_primary.size();
1242
1243 int pos = 0;
1244 // Begin primary image
1245 // Write SOI
1246 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
1247 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kSOI, 1, pos));
1248
1249 // Write EXIF
1250 if (exif != nullptr) {
1251 const int length = 2 + exif->length;
1252 const uint8_t lengthH = ((length >> 8) & 0xff);
1253 const uint8_t lengthL = (length & 0xff);
1254 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
1255 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kAPP1, 1, pos));
1256 JPEGR_CHECK(Write(dest, &lengthH, 1, pos));
1257 JPEGR_CHECK(Write(dest, &lengthL, 1, pos));
1258 JPEGR_CHECK(Write(dest, exif->data, exif->length, pos));
1259 }
1260
1261 // Prepare and write XMP
1262 {
1263 const int length = xmp_primary_length;
1264 const uint8_t lengthH = ((length >> 8) & 0xff);
1265 const uint8_t lengthL = (length & 0xff);
1266 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
1267 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kAPP1, 1, pos));
1268 JPEGR_CHECK(Write(dest, &lengthH, 1, pos));
1269 JPEGR_CHECK(Write(dest, &lengthL, 1, pos));
1270 JPEGR_CHECK(Write(dest, (void*)nameSpace.c_str(), nameSpaceLength, pos));
1271 JPEGR_CHECK(Write(dest, (void*)xmp_primary.c_str(), xmp_primary.size(), pos));
1272 }
1273
1274 // Write ICC
1275 if (icc != nullptr && icc_size > 0) {
1276 const int length = icc_size + 2;
1277 const uint8_t lengthH = ((length >> 8) & 0xff);
1278 const uint8_t lengthL = (length & 0xff);
1279 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
1280 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kAPP2, 1, pos));
1281 JPEGR_CHECK(Write(dest, &lengthH, 1, pos));
1282 JPEGR_CHECK(Write(dest, &lengthL, 1, pos));
1283 JPEGR_CHECK(Write(dest, icc, icc_size, pos));
1284 }
1285
1286 // Prepare and write MPF
1287 {
1288 const int length = 2 + calculateMpfSize();
1289 const uint8_t lengthH = ((length >> 8) & 0xff);
1290 const uint8_t lengthL = (length & 0xff);
1291 int primary_image_size = pos + length + compressed_jpeg_image->length;
1292 // between APP2 + package size + signature
1293 // ff e2 00 58 4d 50 46 00
1294 // 2 + 2 + 4 = 8 (bytes)
1295 // and ff d8 sign of the secondary image
1296 int secondary_image_offset = primary_image_size - pos - 8;
1297 sp<DataStruct> mpf = generateMpf(primary_image_size,
1298 0, /* primary_image_offset */
1299 secondary_image_size,
1300 secondary_image_offset);
1301 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
1302 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kAPP2, 1, pos));
1303 JPEGR_CHECK(Write(dest, &lengthH, 1, pos));
1304 JPEGR_CHECK(Write(dest, &lengthL, 1, pos));
1305 JPEGR_CHECK(Write(dest, (void*)mpf->getData(), mpf->getLength(), pos));
1306 }
1307
1308 // Write primary image
1309 JPEGR_CHECK(Write(dest,
1310 (uint8_t*)compressed_jpeg_image->data + 2, compressed_jpeg_image->length - 2, pos));
1311 // Finish primary image
1312
1313 // Begin secondary image (gain map)
1314 // Write SOI
1315 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
1316 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kSOI, 1, pos));
1317
1318 // Prepare and write XMP
1319 {
1320 const int length = xmp_secondary_length;
1321 const uint8_t lengthH = ((length >> 8) & 0xff);
1322 const uint8_t lengthL = (length & 0xff);
1323 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kStart, 1, pos));
1324 JPEGR_CHECK(Write(dest, &photos_editing_formats::image_io::JpegMarker::kAPP1, 1, pos));
1325 JPEGR_CHECK(Write(dest, &lengthH, 1, pos));
1326 JPEGR_CHECK(Write(dest, &lengthL, 1, pos));
1327 JPEGR_CHECK(Write(dest, (void*)nameSpace.c_str(), nameSpaceLength, pos));
1328 JPEGR_CHECK(Write(dest, (void*)xmp_secondary.c_str(), xmp_secondary.size(), pos));
1329 }
1330
1331 // Write secondary image
1332 JPEGR_CHECK(Write(dest,
1333 (uint8_t*)compressed_gain_map->data + 2, compressed_gain_map->length - 2, pos));
1334
1335 // Set back length
1336 dest->length = pos;
1337
1338 // Done!
1339 return NO_ERROR;
1340 }
1341
toneMap(jr_uncompressed_ptr src,jr_uncompressed_ptr dest)1342 status_t JpegR::toneMap(jr_uncompressed_ptr src, jr_uncompressed_ptr dest) {
1343 if (src == nullptr || dest == nullptr) {
1344 return ERROR_JPEGR_INVALID_NULL_PTR;
1345 }
1346
1347 uint16_t* src_luma_data = reinterpret_cast<uint16_t*>(src->data);
1348 size_t src_luma_stride = src->luma_stride == 0 ? src->width : src->luma_stride;
1349
1350 uint16_t* src_chroma_data;
1351 size_t src_chroma_stride;
1352 if (src->chroma_data == nullptr) {
1353 src_chroma_stride = src_luma_stride;
1354 src_chroma_data = &reinterpret_cast<uint16_t*>(src->data)[src_luma_stride * src->height];
1355 } else {
1356 src_chroma_stride = src->chroma_stride;
1357 src_chroma_data = reinterpret_cast<uint16_t*>(src->chroma_data);
1358 }
1359 dest->width = src->width;
1360 dest->height = src->height;
1361
1362 size_t dest_luma_pixel_count = dest->width * dest->height;
1363
1364 for (size_t y = 0; y < src->height; ++y) {
1365 for (size_t x = 0; x < src->width; ++x) {
1366 size_t src_y_idx = y * src_luma_stride + x;
1367 size_t src_u_idx = (y >> 1) * src_chroma_stride + (x & ~0x1);
1368 size_t src_v_idx = src_u_idx + 1;
1369
1370 uint16_t y_uint = src_luma_data[src_y_idx] >> 6;
1371 uint16_t u_uint = src_chroma_data[src_u_idx] >> 6;
1372 uint16_t v_uint = src_chroma_data[src_v_idx] >> 6;
1373
1374 size_t dest_y_idx = x + y * dest->width;
1375 size_t dest_uv_idx = x / 2 + (y / 2) * (dest->width / 2);
1376
1377 uint8_t* y = &reinterpret_cast<uint8_t*>(dest->data)[dest_y_idx];
1378 uint8_t* u = &reinterpret_cast<uint8_t*>(dest->data)[dest_luma_pixel_count + dest_uv_idx];
1379 uint8_t* v = &reinterpret_cast<uint8_t*>(
1380 dest->data)[dest_luma_pixel_count * 5 / 4 + dest_uv_idx];
1381
1382 *y = static_cast<uint8_t>((y_uint >> 2) & 0xff);
1383 *u = static_cast<uint8_t>((u_uint >> 2) & 0xff);
1384 *v = static_cast<uint8_t>((v_uint >> 2) & 0xff);
1385 }
1386 }
1387
1388 dest->colorGamut = src->colorGamut;
1389
1390 return NO_ERROR;
1391 }
1392
convertYuv(jr_uncompressed_ptr image,ultrahdr_color_gamut src_encoding,ultrahdr_color_gamut dest_encoding)1393 status_t JpegR::convertYuv(jr_uncompressed_ptr image,
1394 ultrahdr_color_gamut src_encoding,
1395 ultrahdr_color_gamut dest_encoding) {
1396 if (image == nullptr) {
1397 return ERROR_JPEGR_INVALID_NULL_PTR;
1398 }
1399
1400 if (src_encoding == ULTRAHDR_COLORGAMUT_UNSPECIFIED
1401 || dest_encoding == ULTRAHDR_COLORGAMUT_UNSPECIFIED) {
1402 return ERROR_JPEGR_INVALID_COLORGAMUT;
1403 }
1404
1405 ColorTransformFn conversionFn = nullptr;
1406 switch (src_encoding) {
1407 case ULTRAHDR_COLORGAMUT_BT709:
1408 switch (dest_encoding) {
1409 case ULTRAHDR_COLORGAMUT_BT709:
1410 return NO_ERROR;
1411 case ULTRAHDR_COLORGAMUT_P3:
1412 conversionFn = yuv709To601;
1413 break;
1414 case ULTRAHDR_COLORGAMUT_BT2100:
1415 conversionFn = yuv709To2100;
1416 break;
1417 default:
1418 // Should be impossible to hit after input validation
1419 return ERROR_JPEGR_INVALID_COLORGAMUT;
1420 }
1421 break;
1422 case ULTRAHDR_COLORGAMUT_P3:
1423 switch (dest_encoding) {
1424 case ULTRAHDR_COLORGAMUT_BT709:
1425 conversionFn = yuv601To709;
1426 break;
1427 case ULTRAHDR_COLORGAMUT_P3:
1428 return NO_ERROR;
1429 case ULTRAHDR_COLORGAMUT_BT2100:
1430 conversionFn = yuv601To2100;
1431 break;
1432 default:
1433 // Should be impossible to hit after input validation
1434 return ERROR_JPEGR_INVALID_COLORGAMUT;
1435 }
1436 break;
1437 case ULTRAHDR_COLORGAMUT_BT2100:
1438 switch (dest_encoding) {
1439 case ULTRAHDR_COLORGAMUT_BT709:
1440 conversionFn = yuv2100To709;
1441 break;
1442 case ULTRAHDR_COLORGAMUT_P3:
1443 conversionFn = yuv2100To601;
1444 break;
1445 case ULTRAHDR_COLORGAMUT_BT2100:
1446 return NO_ERROR;
1447 default:
1448 // Should be impossible to hit after input validation
1449 return ERROR_JPEGR_INVALID_COLORGAMUT;
1450 }
1451 break;
1452 default:
1453 // Should be impossible to hit after input validation
1454 return ERROR_JPEGR_INVALID_COLORGAMUT;
1455 }
1456
1457 if (conversionFn == nullptr) {
1458 // Should be impossible to hit after input validation
1459 return ERROR_JPEGR_INVALID_COLORGAMUT;
1460 }
1461
1462 for (size_t y = 0; y < image->height / 2; ++y) {
1463 for (size_t x = 0; x < image->width / 2; ++x) {
1464 transformYuv420(image, x, y, conversionFn);
1465 }
1466 }
1467
1468 return NO_ERROR;
1469 }
1470
1471 } // namespace android::ultrahdr
1472