aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorRam Mohan <ram.mohan@ittiam.com>2023-11-02 03:07:05 +0530
committerRam Mohan M <ram.mohan@ittiam.com>2023-11-02 04:47:43 +0530
commit5be8a63f2ab459f0bc0dbda4a4c0d858d88c43b3 (patch)
treef97f610e05596f9e3b8de9cddda066bf8fb84440
parenta5b025b2a85d9f4095bf4932c2535826ca4c302c (diff)
downloadlibultrahdr-5be8a63f2ab459f0bc0dbda4a4c0d858d88c43b3.tar.gz
avoid using labels that conflict with system headers tokens
OK, UNKNOWN_ERROR are commonly defined in system headers. While adding support for other platforms, new header inclusions is causing compilation issues. rename some variable names of ultrahdr::status_t
Diffstat
-rw-r--r--examples/ultrahdr_app.cpp16
-rw-r--r--fuzzer/ultrahdr_enc_fuzzer.cpp8
-rw-r--r--lib/jpegr.cpp171
-rw-r--r--lib/jpegr.h35
-rw-r--r--lib/jpegrutils.cpp2
-rw-r--r--tests/jpegr_test.cpp281
6 files changed, 258 insertions, 255 deletions
diff --git a/examples/ultrahdr_app.cpp b/examples/ultrahdr_app.cpp
index 56a0d16..25170c9 100644
--- a/examples/ultrahdr_app.cpp
+++ b/examples/ultrahdr_app.cpp
@@ -256,7 +256,7 @@ bool UltraHdrAppInput::encode() {
}
JpegR jpegHdr;
- status_t status = UNKNOWN_ERROR;
+ status_t status = JPEGR_UNKNOWN_ERROR;
#ifdef PROFILE_ENABLE
const int profileCount = 10;
Profiler profileEncode;
@@ -265,7 +265,7 @@ bool UltraHdrAppInput::encode() {
#endif
if (mYuv420File == nullptr && mYuv420JpegFile == nullptr) { // api-0
status = jpegHdr.encodeJPEGR(&mRawP010Image, mTf, &mJpegImgR, mQuality, nullptr);
- if (OK != status) {
+ if (JPEGR_NO_ERROR != status) {
std::cerr << "Encountered error during encodeJPEGR call, error code " << status
<< std::endl;
return false;
@@ -273,7 +273,7 @@ bool UltraHdrAppInput::encode() {
} else if (mYuv420File != nullptr && mYuv420JpegFile == nullptr) { // api-1
status =
jpegHdr.encodeJPEGR(&mRawP010Image, &mRawYuv420Image, mTf, &mJpegImgR, mQuality, nullptr);
- if (OK != status) {
+ if (JPEGR_NO_ERROR != status) {
std::cerr << "Encountered error during encodeJPEGR call, error code " << status
<< std::endl;
return false;
@@ -281,14 +281,14 @@ bool UltraHdrAppInput::encode() {
} else if (mYuv420File != nullptr && mYuv420JpegFile != nullptr) { // api-2
status =
jpegHdr.encodeJPEGR(&mRawP010Image, &mRawYuv420Image, &mYuv420JpegImage, mTf, &mJpegImgR);
- if (OK != status) {
+ if (JPEGR_NO_ERROR != status) {
std::cerr << "Encountered error during encodeJPEGR call, error code " << status
<< std::endl;
return false;
}
} else if (mYuv420File == nullptr && mYuv420JpegFile != nullptr) { // api-3
status = jpegHdr.encodeJPEGR(&mRawP010Image, &mYuv420JpegImage, mTf, &mJpegImgR);
- if (OK != status) {
+ if (JPEGR_NO_ERROR != status) {
std::cerr << "Encountered error during encodeJPEGR call, error code " << status
<< std::endl;
return false;
@@ -311,7 +311,7 @@ bool UltraHdrAppInput::decode() {
jpegr_info_struct info{0, 0, &iccData, &exifData};
JpegR jpegHdr;
status_t status = jpegHdr.getJPEGRInfo(&mJpegImgR, &info);
- if (OK == status) {
+ if (JPEGR_NO_ERROR == status) {
size_t outSize = info.width * info.height * ((mOf == ULTRAHDR_OUTPUT_HDR_LINEAR) ? 8 : 4);
mDestImage.data = malloc(outSize);
if (mDestImage.data == nullptr) {
@@ -326,7 +326,7 @@ bool UltraHdrAppInput::decode() {
#endif
status =
jpegHdr.decodeJPEGR(&mJpegImgR, &mDestImage, FLT_MAX, nullptr, mOf, nullptr, nullptr);
- if (OK != status) {
+ if (JPEGR_NO_ERROR != status) {
std::cerr << "Encountered error during decodeJPEGR call, error code " << status
<< std::endl;
return false;
@@ -927,5 +927,5 @@ int main(int argc, char* argv[]) {
return -1;
}
- return 0;
+ return 0;
}
diff --git a/fuzzer/ultrahdr_enc_fuzzer.cpp b/fuzzer/ultrahdr_enc_fuzzer.cpp
index ad28db3..db6021e 100644
--- a/fuzzer/ultrahdr_enc_fuzzer.cpp
+++ b/fuzzer/ultrahdr_enc_fuzzer.cpp
@@ -224,7 +224,7 @@ void UltraHdrEncFuzzer::process() {
#endif
JpegR jpegHdr;
- status_t status = UNKNOWN_ERROR;
+ status_t status = JPEGR_UNKNOWN_ERROR;
if (muxSwitch == 0) { // api 0
jpegImgR.length = 0;
status = jpegHdr.encodeJPEGR(&p010Img, tf, &jpegImgR, quality, nullptr);
@@ -288,12 +288,12 @@ void UltraHdrEncFuzzer::process() {
}
}
}
- if (status == OK) {
+ if (status == JPEGR_NO_ERROR) {
std::vector<uint8_t> iccData(0);
std::vector<uint8_t> exifData(0);
jpegr_info_struct info{0, 0, &iccData, &exifData};
status = jpegHdr.getJPEGRInfo(&jpegImgR, &info);
- if (status == OK) {
+ if (status == JPEGR_NO_ERROR) {
size_t outSize = info.width * info.height * ((of == ULTRAHDR_OUTPUT_HDR_LINEAR) ? 8 : 4);
jpegr_uncompressed_struct decodedJpegR;
auto decodedRaw = std::make_unique<uint8_t[]>(outSize);
@@ -303,7 +303,7 @@ void UltraHdrEncFuzzer::process() {
status = jpegHdr.decodeJPEGR(&jpegImgR, &decodedJpegR,
mFdp.ConsumeFloatingPointInRange<float>(1.0, FLT_MAX), nullptr,
of, &decodedGainMap, &metadata);
- if (status != OK) {
+ if (status != JPEGR_NO_ERROR) {
ALOGE("encountered error during decoding %d", status);
}
if (decodedGainMap.data) free(decodedGainMap.data);
diff --git a/lib/jpegr.cpp b/lib/jpegr.cpp
index 9676ed5..6fb8922 100644
--- a/lib/jpegr.cpp
+++ b/lib/jpegr.cpp
@@ -45,12 +45,12 @@ namespace ultrahdr {
#define USE_PQ_INVOETF_LUT 1
#define USE_APPLY_GAIN_LUT 1
-#define JPEGR_CHECK(x) \
- { \
- status_t status = (x); \
- if ((status) != NO_ERROR) { \
- return status; \
- } \
+#define JPEGR_CHECK(x) \
+ { \
+ status_t status = (x); \
+ if ((status) != JPEGR_NO_ERROR) { \
+ return status; \
+ } \
}
// JPEG compress quality (0 ~ 100) for gain map
@@ -108,65 +108,65 @@ status_t JpegR::areInputArgumentsValid(jr_uncompressed_ptr p010_image_ptr,
jr_compressed_ptr dest_ptr) {
if (p010_image_ptr == nullptr || p010_image_ptr->data == nullptr) {
ALOGE("Received nullptr for input p010 image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (p010_image_ptr->width % 2 != 0 || p010_image_ptr->height % 2 != 0) {
ALOGE("Image dimensions cannot be odd, image dimensions %zux%zu", p010_image_ptr->width,
p010_image_ptr->height);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_UNSUPPORTED_WIDTH_HEIGHT;
}
if (p010_image_ptr->width < kMinWidth || p010_image_ptr->height < kMinHeight) {
ALOGE("Image dimensions cannot be less than %dx%d, image dimensions %zux%zu", kMinWidth,
kMinHeight, p010_image_ptr->width, p010_image_ptr->height);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_UNSUPPORTED_WIDTH_HEIGHT;
}
if (p010_image_ptr->width > kMaxWidth || p010_image_ptr->height > kMaxHeight) {
ALOGE("Image dimensions cannot be larger than %dx%d, image dimensions %zux%zu", kMaxWidth,
kMaxHeight, p010_image_ptr->width, p010_image_ptr->height);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_UNSUPPORTED_WIDTH_HEIGHT;
}
if (p010_image_ptr->colorGamut <= ULTRAHDR_COLORGAMUT_UNSPECIFIED ||
p010_image_ptr->colorGamut > ULTRAHDR_COLORGAMUT_MAX) {
ALOGE("Unrecognized p010 color gamut %d", p010_image_ptr->colorGamut);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_COLORGAMUT;
}
if (p010_image_ptr->luma_stride != 0 && p010_image_ptr->luma_stride < p010_image_ptr->width) {
ALOGE("Luma stride must not be smaller than width, stride=%zu, width=%zu",
p010_image_ptr->luma_stride, p010_image_ptr->width);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_STRIDE;
}
if (p010_image_ptr->chroma_data != nullptr &&
p010_image_ptr->chroma_stride < p010_image_ptr->width) {
ALOGE("Chroma stride must not be smaller than width, stride=%zu, width=%zu",
p010_image_ptr->chroma_stride, p010_image_ptr->width);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_STRIDE;
}
if (dest_ptr == nullptr || dest_ptr->data == nullptr) {
ALOGE("Received nullptr for destination");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (hdr_tf <= ULTRAHDR_TF_UNSPECIFIED || hdr_tf > ULTRAHDR_TF_MAX || hdr_tf == ULTRAHDR_TF_SRGB) {
ALOGE("Invalid hdr transfer function %d", hdr_tf);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_TRANS_FUNC;
}
if (yuv420_image_ptr == nullptr) {
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
if (yuv420_image_ptr->data == nullptr) {
ALOGE("Received nullptr for uncompressed 420 image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (yuv420_image_ptr->luma_stride != 0 &&
yuv420_image_ptr->luma_stride < yuv420_image_ptr->width) {
ALOGE("Luma stride must not be smaller than width, stride=%zu, width=%zu",
yuv420_image_ptr->luma_stride, yuv420_image_ptr->width);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_STRIDE;
}
if (yuv420_image_ptr->chroma_data != nullptr &&
yuv420_image_ptr->chroma_stride < yuv420_image_ptr->width / 2) {
ALOGE("Chroma stride must not be smaller than (width / 2), stride=%zu, width=%zu",
yuv420_image_ptr->chroma_stride, yuv420_image_ptr->width);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_STRIDE;
}
if (p010_image_ptr->width != yuv420_image_ptr->width ||
p010_image_ptr->height != yuv420_image_ptr->height) {
@@ -177,9 +177,9 @@ status_t JpegR::areInputArgumentsValid(jr_uncompressed_ptr p010_image_ptr,
if (yuv420_image_ptr->colorGamut <= ULTRAHDR_COLORGAMUT_UNSPECIFIED ||
yuv420_image_ptr->colorGamut > ULTRAHDR_COLORGAMUT_MAX) {
ALOGE("Unrecognized 420 color gamut %d", yuv420_image_ptr->colorGamut);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_COLORGAMUT;
}
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
status_t JpegR::areInputArgumentsValid(jr_uncompressed_ptr p010_image_ptr,
@@ -188,7 +188,7 @@ status_t JpegR::areInputArgumentsValid(jr_uncompressed_ptr p010_image_ptr,
jr_compressed_ptr dest_ptr, int quality) {
if (quality < 0 || quality > 100) {
ALOGE("quality factor is out side range [0-100], quality factor : %d", quality);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_QUALITY_FACTOR;
}
return areInputArgumentsValid(p010_image_ptr, yuv420_image_ptr, hdr_tf, dest_ptr);
}
@@ -198,12 +198,12 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr p010_image_ptr, ultrahdr_transfe
jr_compressed_ptr dest, int quality, jr_exif_ptr exif) {
// validate input arguments
if (auto ret = areInputArgumentsValid(p010_image_ptr, nullptr, hdr_tf, dest, quality);
- ret != NO_ERROR) {
+ ret != JPEGR_NO_ERROR) {
return ret;
}
if (exif != nullptr && exif->data == nullptr) {
ALOGE("received nullptr for exif metadata");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
// clean up input structure for later usage
@@ -274,7 +274,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr p010_image_ptr, ultrahdr_transfe
JPEGR_CHECK(appendGainMap(&jpeg, &compressed_map, exif, /* icc */ nullptr, /* icc size */ 0,
&metadata, dest));
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
/* Encode API-1 */
@@ -284,14 +284,14 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr p010_image_ptr,
// validate input arguments
if (yuv420_image_ptr == nullptr) {
ALOGE("received nullptr for uncompressed 420 image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (exif != nullptr && exif->data == nullptr) {
ALOGE("received nullptr for exif metadata");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (auto ret = areInputArgumentsValid(p010_image_ptr, yuv420_image_ptr, hdr_tf, dest, quality);
- ret != NO_ERROR) {
+ ret != JPEGR_NO_ERROR) {
return ret;
}
@@ -412,7 +412,7 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr p010_image_ptr,
// append gain map, no ICC since JPEG encode already did it
JPEGR_CHECK(appendGainMap(&jpeg, &compressed_map, exif, /* icc */ nullptr, /* icc size */ 0,
&metadata, dest));
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
/* Encode API-2 */
@@ -423,14 +423,14 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr p010_image_ptr,
// validate input arguments
if (yuv420_image_ptr == nullptr) {
ALOGE("received nullptr for uncompressed 420 image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (yuv420jpg_image_ptr == nullptr || yuv420jpg_image_ptr->data == nullptr) {
ALOGE("received nullptr for compressed jpeg image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (auto ret = areInputArgumentsValid(p010_image_ptr, yuv420_image_ptr, hdr_tf, dest);
- ret != NO_ERROR) {
+ ret != JPEGR_NO_ERROR) {
return ret;
}
@@ -476,9 +476,10 @@ status_t JpegR::encodeJPEGR(jr_uncompressed_ptr p010_image_ptr,
// validate input arguments
if (yuv420jpg_image_ptr == nullptr || yuv420jpg_image_ptr->data == nullptr) {
ALOGE("received nullptr for compressed jpeg image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
- if (auto ret = areInputArgumentsValid(p010_image_ptr, nullptr, hdr_tf, dest); ret != NO_ERROR) {
+ if (auto ret = areInputArgumentsValid(p010_image_ptr, nullptr, hdr_tf, dest);
+ ret != JPEGR_NO_ERROR) {
return ret;
}
@@ -540,15 +541,15 @@ status_t JpegR::encodeJPEGR(jr_compressed_ptr yuv420jpg_image_ptr,
jr_compressed_ptr dest) {
if (yuv420jpg_image_ptr == nullptr || yuv420jpg_image_ptr->data == nullptr) {
ALOGE("received nullptr for compressed jpeg image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (gainmapjpg_image_ptr == nullptr || gainmapjpg_image_ptr->data == nullptr) {
ALOGE("received nullptr for compressed gain map");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (dest == nullptr || dest->data == nullptr) {
ALOGE("received nullptr for destination");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
// We just want to check if ICC is present, so don't do a full decode. Note,
@@ -570,22 +571,22 @@ status_t JpegR::encodeJPEGR(jr_compressed_ptr yuv420jpg_image_ptr,
newIcc->getData(), newIcc->getLength(), metadata, dest));
}
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
status_t JpegR::getJPEGRInfo(jr_compressed_ptr jpegr_image_ptr, jr_info_ptr jpeg_image_info_ptr) {
if (jpegr_image_ptr == nullptr || jpegr_image_ptr->data == nullptr) {
ALOGE("received nullptr for compressed jpegr image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (jpeg_image_info_ptr == nullptr) {
ALOGE("received nullptr for compressed jpegr info struct");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
jpegr_compressed_struct primary_image, gainmap_image;
status_t status = extractPrimaryImageAndGainMap(jpegr_image_ptr, &primary_image, &gainmap_image);
- if (status != NO_ERROR && status != ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND) {
+ if (status != JPEGR_NO_ERROR && status != ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND) {
return status;
}
@@ -607,29 +608,29 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr jpegr_image_ptr, jr_uncompressed_p
jr_uncompressed_ptr gainmap_image_ptr, ultrahdr_metadata_ptr metadata) {
if (jpegr_image_ptr == nullptr || jpegr_image_ptr->data == nullptr) {
ALOGE("received nullptr for compressed jpegr image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (dest == nullptr || dest->data == nullptr) {
ALOGE("received nullptr for dest image");
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (max_display_boost < 1.0f) {
ALOGE("received bad value for max_display_boost %f", max_display_boost);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_DISPLAY_BOOST;
}
if (exif != nullptr && exif->data == nullptr) {
ALOGE("received nullptr address for exif data");
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_BAD_PTR;
}
if (output_format <= ULTRAHDR_OUTPUT_UNSPECIFIED || output_format > ULTRAHDR_OUTPUT_MAX) {
ALOGE("received bad value for output format %d", output_format);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_INVALID_OUTPUT_FORMAT;
}
jpegr_compressed_struct primary_jpeg_image, gainmap_jpeg_image;
status_t status =
extractPrimaryImageAndGainMap(jpegr_image_ptr, &primary_jpeg_image, &gainmap_jpeg_image);
- if (status != NO_ERROR) {
+ if (status != JPEGR_NO_ERROR) {
if (output_format != ULTRAHDR_OUTPUT_SDR || status != ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND) {
ALOGE("received invalid compressed jpegr image");
return status;
@@ -646,19 +647,19 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr jpegr_image_ptr, jr_uncompressed_p
if ((jpeg_dec_obj_yuv420.getDecompressedImageWidth() *
jpeg_dec_obj_yuv420.getDecompressedImageHeight() * 4) >
jpeg_dec_obj_yuv420.getDecompressedImageSize()) {
- return ERROR_JPEGR_CALCULATION_ERROR;
+ return ERROR_JPEGR_DECODE_ERROR;
}
} else {
if ((jpeg_dec_obj_yuv420.getDecompressedImageWidth() *
jpeg_dec_obj_yuv420.getDecompressedImageHeight() * 3 / 2) >
jpeg_dec_obj_yuv420.getDecompressedImageSize()) {
- return ERROR_JPEGR_CALCULATION_ERROR;
+ return ERROR_JPEGR_DECODE_ERROR;
}
}
if (exif != nullptr) {
if (exif->data == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (exif->length < jpeg_dec_obj_yuv420.getEXIFSize()) {
return ERROR_JPEGR_BUFFER_TOO_SMALL;
@@ -672,7 +673,7 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr jpegr_image_ptr, jr_uncompressed_p
dest->height = jpeg_dec_obj_yuv420.getDecompressedImageHeight();
memcpy(dest->data, jpeg_dec_obj_yuv420.getDecompressedImagePtr(),
dest->width * dest->height * 4);
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
JpegDecoderHelper jpeg_dec_obj_gm;
@@ -681,7 +682,7 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr jpegr_image_ptr, jr_uncompressed_p
}
if ((jpeg_dec_obj_gm.getDecompressedImageWidth() * jpeg_dec_obj_gm.getDecompressedImageHeight()) >
jpeg_dec_obj_gm.getDecompressedImageSize()) {
- return ERROR_JPEGR_CALCULATION_ERROR;
+ return ERROR_JPEGR_DECODE_ERROR;
}
jpegr_uncompressed_struct gainmap_image;
@@ -700,7 +701,7 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr jpegr_image_ptr, jr_uncompressed_p
ultrahdr_metadata_struct uhdr_metadata;
if (!getMetadataFromXMP(static_cast<uint8_t*>(jpeg_dec_obj_gm.getXMPPtr()),
jpeg_dec_obj_gm.getXMPSize(), &uhdr_metadata)) {
- return ERROR_JPEGR_INVALID_METADATA;
+ return ERROR_JPEGR_METADATA_ERROR;
}
if (metadata != nullptr) {
@@ -727,13 +728,13 @@ status_t JpegR::decodeJPEGR(jr_compressed_ptr jpegr_image_ptr, jr_uncompressed_p
JPEGR_CHECK(applyGainMap(&yuv420_image, &gainmap_image, &uhdr_metadata, output_format,
max_display_boost, dest));
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
status_t JpegR::compressGainMap(jr_uncompressed_ptr gainmap_image_ptr,
JpegEncoderHelper* jpeg_enc_obj_ptr) {
if (gainmap_image_ptr == nullptr || jpeg_enc_obj_ptr == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
// Don't need to convert YUV to Bt601 since single channel
@@ -744,7 +745,7 @@ status_t JpegR::compressGainMap(jr_uncompressed_ptr gainmap_image_ptr,
return ERROR_JPEGR_ENCODE_ERROR;
}
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
const int kJobSzInRows = 16;
@@ -813,7 +814,7 @@ status_t JpegR::generateGainMap(jr_uncompressed_ptr yuv420_image_ptr,
dest == nullptr || yuv420_image_ptr->data == nullptr ||
yuv420_image_ptr->chroma_data == nullptr || p010_image_ptr->data == nullptr ||
p010_image_ptr->chroma_data == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (yuv420_image_ptr->width != p010_image_ptr->width ||
yuv420_image_ptr->height != p010_image_ptr->height) {
@@ -975,7 +976,7 @@ status_t JpegR::generateGainMap(jr_uncompressed_ptr yuv420_image_ptr,
std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
map_data.release();
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
status_t JpegR::applyGainMap(jr_uncompressed_ptr yuv420_image_ptr,
@@ -985,25 +986,25 @@ status_t JpegR::applyGainMap(jr_uncompressed_ptr yuv420_image_ptr,
if (yuv420_image_ptr == nullptr || gainmap_image_ptr == nullptr || metadata == nullptr ||
dest == nullptr || yuv420_image_ptr->data == nullptr ||
yuv420_image_ptr->chroma_data == nullptr || gainmap_image_ptr->data == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (metadata->version.compare(kJpegrVersion)) {
ALOGE("Unsupported metadata version: %s", metadata->version.c_str());
- return ERROR_JPEGR_UNSUPPORTED_METADATA;
+ return ERROR_JPEGR_BAD_METADATA;
}
if (metadata->gamma != 1.0f) {
ALOGE("Unsupported metadata gamma: %f", metadata->gamma);
- return ERROR_JPEGR_UNSUPPORTED_METADATA;
+ return ERROR_JPEGR_BAD_METADATA;
}
if (metadata->offsetSdr != 0.0f || metadata->offsetHdr != 0.0f) {
ALOGE("Unsupported metadata offset sdr, hdr: %f, %f", metadata->offsetSdr, metadata->offsetHdr);
- return ERROR_JPEGR_UNSUPPORTED_METADATA;
+ return ERROR_JPEGR_BAD_METADATA;
}
if (metadata->hdrCapacityMin != metadata->minContentBoost ||
metadata->hdrCapacityMax != metadata->maxContentBoost) {
ALOGE("Unsupported metadata hdr capacity min, max: %f, %f", metadata->hdrCapacityMin,
metadata->hdrCapacityMax);
- return ERROR_JPEGR_UNSUPPORTED_METADATA;
+ return ERROR_JPEGR_BAD_METADATA;
}
// TODO: remove once map scaling factor is computed based on actual map dims
@@ -1016,7 +1017,7 @@ status_t JpegR::applyGainMap(jr_uncompressed_ptr yuv420_image_ptr,
"gain map dimensions and primary image dimensions are not to scale, computed gain map "
"resolution is %zux%zu, received gain map resolution is %zux%zu",
map_width, map_height, gainmap_image_ptr->width, gainmap_image_ptr->height);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_RESOLUTION_MISMATCH;
}
dest->width = yuv420_image_ptr->width;
@@ -1115,14 +1116,14 @@ status_t JpegR::applyGainMap(jr_uncompressed_ptr yuv420_image_ptr,
jobQueue.markQueueForEnd();
applyRecMap();
std::for_each(workers.begin(), workers.end(), [](std::thread& t) { t.join(); });
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
status_t JpegR::extractPrimaryImageAndGainMap(jr_compressed_ptr jpegr_image_ptr,
jr_compressed_ptr primary_jpg_image_ptr,
jr_compressed_ptr gainmap_jpg_image_ptr) {
if (jpegr_image_ptr == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
MessageHandler msg_handler;
@@ -1138,14 +1139,14 @@ status_t JpegR::extractPrimaryImageAndGainMap(jr_compressed_ptr jpegr_image_ptr,
data_source.Reset();
if (jpeg_scanner.HasError()) {
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return JPEGR_UNKNOWN_ERROR;
}
const auto& jpeg_info = jpeg_info_builder.GetInfo();
const auto& image_ranges = jpeg_info.GetImageRanges();
if (image_ranges.empty()) {
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_NO_IMAGES_FOUND;
}
if (primary_jpg_image_ptr != nullptr) {
@@ -1170,7 +1171,7 @@ status_t JpegR::extractPrimaryImageAndGainMap(jr_compressed_ptr jpegr_image_ptr,
(int)image_ranges.size());
}
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
// JPEG/R structure:
@@ -1213,29 +1214,29 @@ status_t JpegR::appendGainMap(jr_compressed_ptr primary_jpg_image_ptr,
jr_compressed_ptr dest) {
if (primary_jpg_image_ptr == nullptr || gainmap_jpg_image_ptr == nullptr || metadata == nullptr ||
dest == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (metadata->version.compare("1.0")) {
ALOGE("received bad value for version: %s", metadata->version.c_str());
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_BAD_METADATA;
}
if (metadata->maxContentBoost < metadata->minContentBoost) {
ALOGE("received bad value for content boost min %f, max %f", metadata->minContentBoost,
metadata->maxContentBoost);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_BAD_METADATA;
}
if (metadata->hdrCapacityMax < metadata->hdrCapacityMin || metadata->hdrCapacityMin < 1.0f) {
ALOGE("received bad value for hdr capacity min %f, max %f", metadata->hdrCapacityMin,
metadata->hdrCapacityMax);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_BAD_METADATA;
}
if (metadata->offsetSdr < 0.0f || metadata->offsetHdr < 0.0f) {
ALOGE("received bad value for offset sdr %f, hdr %f", metadata->offsetSdr, metadata->offsetHdr);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_BAD_METADATA;
}
if (metadata->gamma <= 0.0f) {
ALOGE("received bad value for gamma %f", metadata->gamma);
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_BAD_METADATA;
}
const string nameSpace = "http://ns.adobe.com/xap/1.0/";
@@ -1268,7 +1269,7 @@ status_t JpegR::appendGainMap(jr_compressed_ptr primary_jpg_image_ptr,
if (decoder.getEXIFPos() >= 0) {
if (pExif != nullptr) {
ALOGE("received EXIF from outside while the primary image already contains EXIF");
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_MULTIPLE_EXIFS_RECEIVED;
}
copyJpegWithoutExif(&new_jpg_image, primary_jpg_image_ptr, decoder.getEXIFPos(),
decoder.getEXIFSize());
@@ -1375,15 +1376,15 @@ status_t JpegR::appendGainMap(jr_compressed_ptr primary_jpg_image_ptr,
dest->length = pos;
// Done!
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
status_t JpegR::toneMap(jr_uncompressed_ptr src, jr_uncompressed_ptr dest) {
if (src == nullptr || dest == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (src->width != dest->width || src->height != dest->height) {
- return ERROR_JPEGR_INVALID_INPUT_TYPE;
+ return ERROR_JPEGR_RESOLUTION_MISMATCH;
}
uint16_t* src_y_data = reinterpret_cast<uint16_t*>(src->data);
uint8_t* dst_y_data = reinterpret_cast<uint8_t*>(dest->data);
@@ -1418,13 +1419,13 @@ status_t JpegR::toneMap(jr_uncompressed_ptr src, jr_uncompressed_ptr dest) {
}
}
dest->colorGamut = src->colorGamut;
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
status_t JpegR::convertYuv(jr_uncompressed_ptr image, ultrahdr_color_gamut src_encoding,
ultrahdr_color_gamut dest_encoding) {
if (image == nullptr) {
- return ERROR_JPEGR_INVALID_NULL_PTR;
+ return ERROR_JPEGR_BAD_PTR;
}
if (src_encoding == ULTRAHDR_COLORGAMUT_UNSPECIFIED ||
dest_encoding == ULTRAHDR_COLORGAMUT_UNSPECIFIED) {
@@ -1436,7 +1437,7 @@ status_t JpegR::convertYuv(jr_uncompressed_ptr image, ultrahdr_color_gamut src_e
case ULTRAHDR_COLORGAMUT_BT709:
switch (dest_encoding) {
case ULTRAHDR_COLORGAMUT_BT709:
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
case ULTRAHDR_COLORGAMUT_P3:
conversionFn = yuv709To601;
break;
@@ -1454,7 +1455,7 @@ status_t JpegR::convertYuv(jr_uncompressed_ptr image, ultrahdr_color_gamut src_e
conversionFn = yuv601To709;
break;
case ULTRAHDR_COLORGAMUT_P3:
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
case ULTRAHDR_COLORGAMUT_BT2100:
conversionFn = yuv601To2100;
break;
@@ -1472,7 +1473,7 @@ status_t JpegR::convertYuv(jr_uncompressed_ptr image, ultrahdr_color_gamut src_e
conversionFn = yuv2100To601;
break;
case ULTRAHDR_COLORGAMUT_BT2100:
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
default:
// Should be impossible to hit after input validation
return ERROR_JPEGR_INVALID_COLORGAMUT;
@@ -1494,7 +1495,7 @@ status_t JpegR::convertYuv(jr_uncompressed_ptr image, ultrahdr_color_gamut src_e
}
}
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
} // namespace ultrahdr
diff --git a/lib/jpegr.h b/lib/jpegr.h
index 0e0352a..5c8f9c3 100644
--- a/lib/jpegr.h
+++ b/lib/jpegr.h
@@ -38,30 +38,31 @@ static const int kMinWidth = 2 * kMapDimensionScaleFactor;
static const int kMinHeight = 2 * kMapDimensionScaleFactor;
typedef enum {
- OK = 0,
- NO_ERROR = OK,
- UNKNOWN_ERROR = (-2147483647 - 1),
+ JPEGR_NO_ERROR = 0,
+ JPEGR_UNKNOWN_ERROR = -1,
JPEGR_IO_ERROR_BASE = -10000,
- ERROR_JPEGR_INVALID_INPUT_TYPE = JPEGR_IO_ERROR_BASE,
- ERROR_JPEGR_INVALID_OUTPUT_TYPE = JPEGR_IO_ERROR_BASE - 1,
- ERROR_JPEGR_INVALID_NULL_PTR = JPEGR_IO_ERROR_BASE - 2,
- ERROR_JPEGR_RESOLUTION_MISMATCH = JPEGR_IO_ERROR_BASE - 3,
- ERROR_JPEGR_BUFFER_TOO_SMALL = JPEGR_IO_ERROR_BASE - 4,
- ERROR_JPEGR_INVALID_COLORGAMUT = JPEGR_IO_ERROR_BASE - 5,
- ERROR_JPEGR_INVALID_TRANS_FUNC = JPEGR_IO_ERROR_BASE - 6,
- ERROR_JPEGR_INVALID_METADATA = JPEGR_IO_ERROR_BASE - 7,
- ERROR_JPEGR_UNSUPPORTED_METADATA = JPEGR_IO_ERROR_BASE - 8,
- ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND = JPEGR_IO_ERROR_BASE - 9,
+ ERROR_JPEGR_BAD_PTR = JPEGR_IO_ERROR_BASE - 1,
+ ERROR_JPEGR_UNSUPPORTED_WIDTH_HEIGHT = JPEGR_IO_ERROR_BASE - 2,
+ ERROR_JPEGR_INVALID_COLORGAMUT = JPEGR_IO_ERROR_BASE - 3,
+ ERROR_JPEGR_INVALID_STRIDE = JPEGR_IO_ERROR_BASE - 4,
+ ERROR_JPEGR_INVALID_TRANS_FUNC = JPEGR_IO_ERROR_BASE - 5,
+ ERROR_JPEGR_RESOLUTION_MISMATCH = JPEGR_IO_ERROR_BASE - 6,
+ ERROR_JPEGR_INVALID_QUALITY_FACTOR = JPEGR_IO_ERROR_BASE - 7,
+ ERROR_JPEGR_INVALID_DISPLAY_BOOST = JPEGR_IO_ERROR_BASE - 8,
+ ERROR_JPEGR_INVALID_OUTPUT_FORMAT = JPEGR_IO_ERROR_BASE - 9,
+ ERROR_JPEGR_BAD_METADATA = JPEGR_IO_ERROR_BASE - 10,
JPEGR_RUNTIME_ERROR_BASE = -20000,
ERROR_JPEGR_ENCODE_ERROR = JPEGR_RUNTIME_ERROR_BASE - 1,
ERROR_JPEGR_DECODE_ERROR = JPEGR_RUNTIME_ERROR_BASE - 2,
- ERROR_JPEGR_CALCULATION_ERROR = JPEGR_RUNTIME_ERROR_BASE - 3,
- ERROR_JPEGR_METADATA_ERROR = JPEGR_RUNTIME_ERROR_BASE - 4,
- ERROR_JPEGR_TONEMAP_ERROR = JPEGR_RUNTIME_ERROR_BASE - 5,
+ ERROR_JPEGR_GAIN_MAP_IMAGE_NOT_FOUND = JPEGR_RUNTIME_ERROR_BASE - 3,
+ ERROR_JPEGR_BUFFER_TOO_SMALL = JPEGR_RUNTIME_ERROR_BASE - 4,
+ ERROR_JPEGR_METADATA_ERROR = JPEGR_RUNTIME_ERROR_BASE - 5,
+ ERROR_JPEGR_NO_IMAGES_FOUND = JPEGR_RUNTIME_ERROR_BASE - 6,
+ ERROR_JPEGR_MULTIPLE_EXIFS_RECEIVED = JPEGR_RUNTIME_ERROR_BASE - 7,
- ERROR_JPEGR_UNSUPPORTED_FEATURE = -20000,
+ ERROR_JPEGR_UNSUPPORTED_FEATURE = -30000,
} status_t;
/*
diff --git a/lib/jpegrutils.cpp b/lib/jpegrutils.cpp
index 7660753..2fdc347 100644
--- a/lib/jpegrutils.cpp
+++ b/lib/jpegrutils.cpp
@@ -99,7 +99,7 @@ status_t Write(jr_compressed_ptr destination, const void* source, size_t length,
memcpy((uint8_t*)destination->data + sizeof(uint8_t) * position, source, length);
position += length;
- return NO_ERROR;
+ return JPEGR_NO_ERROR;
}
// Extremely simple XML Handler - just searches for interesting elements
diff --git a/tests/jpegr_test.cpp b/tests/jpegr_test.cpp
index b4c391f..07977c2 100644
--- a/tests/jpegr_test.cpp
+++ b/tests/jpegr_test.cpp
@@ -302,14 +302,14 @@ void decodeJpegRImg(jr_compressed_ptr img, [[maybe_unused]] const char* outFileN
std::vector<uint8_t> exifData(0);
jpegr_info_struct info{0, 0, &iccData, &exifData};
JpegR jpegHdr;
- ASSERT_EQ(OK, jpegHdr.getJPEGRInfo(img, &info));
+ ASSERT_EQ(JPEGR_NO_ERROR, jpegHdr.getJPEGRInfo(img, &info));
ASSERT_EQ(kImageWidth, info.width);
ASSERT_EQ(kImageHeight, info.height);
size_t outSize = info.width * info.height * 8;
std::unique_ptr<uint8_t[]> data = std::make_unique<uint8_t[]>(outSize);
jpegr_uncompressed_struct destImage{};
destImage.data = data.get();
- ASSERT_EQ(OK, jpegHdr.decodeJPEGR(img, &destImage));
+ ASSERT_EQ(JPEGR_NO_ERROR, jpegHdr.decodeJPEGR(img, &destImage));
ASSERT_EQ(kImageWidth, destImage.width);
ASSERT_EQ(kImageHeight, destImage.height);
#ifdef DUMP_OUTPUT
@@ -339,29 +339,29 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), -1, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad jpeg quality factor";
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), 101, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad jpeg quality factor";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_UNSPECIFIED,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(),
static_cast<ultrahdr_transfer_function>(
ultrahdr_transfer_function::ULTRAHDR_TF_MAX + 1),
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), static_cast<ultrahdr_transfer_function>(-10),
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
}
@@ -374,13 +374,13 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
nullptr, kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
UhdrCompressedStructWrapper jpgImg2(16, 16);
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
}
@@ -388,7 +388,7 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
{
ASSERT_NE(uHdrLib.encodeJPEGR(nullptr, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
UhdrUnCompressedStructWrapper rawImg(16, 16, YCbCr_p010);
@@ -396,7 +396,7 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
}
@@ -407,7 +407,7 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
UhdrUnCompressedStructWrapper rawImg2(16, 16, YCbCr_p010);
@@ -417,7 +417,7 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg2.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
}
@@ -432,28 +432,28 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
rawImgP010->height = kHeight;
ASSERT_NE(uHdrLib.encodeJPEGR(rawImgP010, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
rawImgP010->height = kHeight - 1;
ASSERT_NE(uHdrLib.encodeJPEGR(rawImgP010, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = 0;
rawImgP010->height = kHeight;
ASSERT_NE(uHdrLib.encodeJPEGR(rawImgP010, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
rawImgP010->height = 0;
ASSERT_NE(uHdrLib.encodeJPEGR(rawImgP010, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = kWidth;
@@ -461,7 +461,7 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
rawImgP010->luma_stride = kWidth - 2;
ASSERT_NE(uHdrLib.encodeJPEGR(rawImgP010, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad luma stride";
rawImgP010->width = kWidth;
@@ -471,7 +471,7 @@ TEST(JpegRTest, EncodeAPI0WithInvalidArgs) {
rawImgP010->chroma_stride = kWidth - 2;
ASSERT_NE(uHdrLib.encodeJPEGR(rawImgP010, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad chroma stride";
}
}
@@ -495,29 +495,29 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), -1, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad jpeg quality factor";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), 101, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad jpeg quality factor";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_UNSPECIFIED,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
static_cast<ultrahdr_transfer_function>(
ultrahdr_transfer_function::ULTRAHDR_TF_MAX + 1),
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
static_cast<ultrahdr_transfer_function>(-10),
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
}
@@ -533,13 +533,13 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, nullptr, kQuality,
nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
UhdrCompressedStructWrapper jpgImg2(16, 16);
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
}
@@ -551,7 +551,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(nullptr, rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
UhdrUnCompressedStructWrapper rawImg(16, 16, YCbCr_p010);
@@ -559,7 +559,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
}
@@ -580,7 +580,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
rawImgP010->width = kWidth;
@@ -590,7 +590,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
rawImgP010->width = kWidth - 1;
@@ -599,7 +599,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
@@ -607,7 +607,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = 0;
@@ -615,7 +615,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
@@ -623,7 +623,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = kWidth;
@@ -632,7 +632,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad luma stride";
rawImgP010->width = kWidth;
@@ -643,7 +643,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad chroma stride";
}
@@ -655,7 +655,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), nullptr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr 420 image";
UhdrUnCompressedStructWrapper rawImg2(16, 16, YCbCr_420);
@@ -663,7 +663,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr 420 image";
}
{
@@ -683,7 +683,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad 420 color gamut";
rawImg420->width = kWidth;
@@ -693,7 +693,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad 420 color gamut";
rawImg420->width = kWidth - 1;
@@ -702,7 +702,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width for 420";
rawImg420->width = kWidth;
@@ -710,7 +710,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height for 420";
rawImg420->width = 0;
@@ -718,7 +718,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width for 420";
rawImg420->width = kWidth;
@@ -726,7 +726,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height for 420";
rawImg420->width = kWidth;
@@ -735,7 +735,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad luma stride for 420";
rawImg420->width = kWidth;
@@ -746,7 +746,7 @@ TEST(JpegRTest, EncodeAPI1WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad chroma stride for 420";
}
}
@@ -770,19 +770,19 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(
rawImg.getImageHandle(), rawImg2.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_UNSPECIFIED, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
jpgImg.getImageHandle(),
static_cast<ultrahdr_transfer_function>(
ultrahdr_transfer_function::ULTRAHDR_TF_MAX + 1),
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(uHdrLib.encodeJPEGR(
rawImg.getImageHandle(), rawImg2.getImageHandle(), jpgImg.getImageHandle(),
static_cast<ultrahdr_transfer_function>(-10), jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
}
@@ -798,13 +798,13 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(),
jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
UhdrCompressedStructWrapper jpgImg2(16, 16);
ASSERT_NE(uHdrLib.encodeJPEGR(
rawImg.getImageHandle(), rawImg2.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
}
@@ -820,13 +820,13 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), rawImg2.getImageHandle(), nullptr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr for compressed image";
UhdrCompressedStructWrapper jpgImg2(16, 16);
ASSERT_NE(uHdrLib.encodeJPEGR(
rawImg.getImageHandle(), rawImg2.getImageHandle(), jpgImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr for compressed image";
}
@@ -838,7 +838,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(nullptr, rawImg2.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
UhdrUnCompressedStructWrapper rawImg(16, 16, YCbCr_p010);
@@ -846,7 +846,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(
rawImg.getImageHandle(), rawImg2.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
}
@@ -867,7 +867,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
rawImgP010->width = kWidth;
@@ -877,7 +877,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
rawImgP010->width = kWidth - 1;
@@ -886,7 +886,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
@@ -894,7 +894,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = 0;
@@ -902,7 +902,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
@@ -910,7 +910,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = kWidth;
@@ -919,7 +919,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad luma stride";
rawImgP010->width = kWidth;
@@ -930,7 +930,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad chroma stride";
}
@@ -942,7 +942,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), nullptr, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr 420 image";
UhdrUnCompressedStructWrapper rawImg2(16, 16, YCbCr_420);
@@ -950,7 +950,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(
rawImg.getImageHandle(), rawImg2.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr 420 image";
}
{
@@ -970,7 +970,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad 420 color gamut";
rawImg420->width = kWidth;
@@ -980,7 +980,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad 420 color gamut";
rawImg420->width = kWidth - 1;
@@ -989,7 +989,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width for 420";
rawImg420->width = kWidth;
@@ -997,7 +997,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height for 420";
rawImg420->width = 0;
@@ -1005,7 +1005,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width for 420";
rawImg420->width = kWidth;
@@ -1013,7 +1013,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height for 420";
rawImg420->width = kWidth;
@@ -1022,7 +1022,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad luma stride for 420";
rawImg420->width = kWidth;
@@ -1033,7 +1033,7 @@ TEST(JpegRTest, EncodeAPI2WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, rawImg420, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad chroma stride for 420";
}
}
@@ -1054,18 +1054,18 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_UNSPECIFIED,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), jpgImg.getImageHandle(),
static_cast<ultrahdr_transfer_function>(
ultrahdr_transfer_function::ULTRAHDR_TF_MAX + 1),
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), jpgImg.getImageHandle(),
static_cast<ultrahdr_transfer_function>(-10), jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad hdr transfer function";
}
@@ -1077,13 +1077,13 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(uHdrLib.encodeJPEGR(rawImg.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
UhdrCompressedStructWrapper jpgImg2(16, 16);
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
}
@@ -1096,13 +1096,13 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), nullptr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr for compressed image";
UhdrCompressedStructWrapper jpgImg2(16, 16);
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), jpgImg2.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr for compressed image";
}
@@ -1111,7 +1111,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(nullptr, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
UhdrUnCompressedStructWrapper rawImg(16, 16, YCbCr_p010);
@@ -1119,7 +1119,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr p010 image";
}
@@ -1136,7 +1136,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
rawImgP010->width = kWidth;
@@ -1146,7 +1146,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad p010 color gamut";
rawImgP010->width = kWidth - 1;
@@ -1155,7 +1155,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
@@ -1163,7 +1163,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = 0;
@@ -1171,7 +1171,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image width";
rawImgP010->width = kWidth;
@@ -1179,7 +1179,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad image height";
rawImgP010->width = kWidth;
@@ -1188,7 +1188,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad luma stride";
rawImgP010->width = kWidth;
@@ -1199,7 +1199,7 @@ TEST(JpegRTest, EncodeAPI3WithInvalidArgs) {
ASSERT_NE(
uHdrLib.encodeJPEGR(rawImgP010, jpgImg.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad chroma stride";
}
}
@@ -1213,29 +1213,29 @@ TEST(JpegRTest, EncodeAPI4WithInvalidArgs) {
// test dest
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), nullptr, nullptr),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), nullptr,
jpgImg2.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr dest";
// test primary image
ASSERT_NE(uHdrLib.encodeJPEGR(nullptr, jpgImg.getImageHandle(), nullptr, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr primary image";
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg2.getImageHandle(), jpgImg.getImageHandle(), nullptr,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr primary image";
// test gain map
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), nullptr, nullptr, jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr gain map image";
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg2.getImageHandle(), nullptr,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows nullptr gain map image";
// test metadata
@@ -1253,49 +1253,49 @@ TEST(JpegRTest, EncodeAPI4WithInvalidArgs) {
metadata.version = "1.1";
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), &metadata,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad metadata version";
metadata = good_metadata;
metadata.minContentBoost = 3.0f;
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), &metadata,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad metadata content boost";
metadata = good_metadata;
metadata.gamma = -0.1f;
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), &metadata,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad metadata gamma";
metadata = good_metadata;
metadata.offsetSdr = -0.1f;
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), &metadata,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad metadata offset sdr";
metadata = good_metadata;
metadata.offsetHdr = -0.1f;
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), &metadata,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad metadata offset hdr";
metadata = good_metadata;
metadata.hdrCapacityMax = 0.5f;
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), &metadata,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad metadata hdr capacity max";
metadata = good_metadata;
metadata.hdrCapacityMin = 0.5f;
ASSERT_NE(uHdrLib.encodeJPEGR(jpgImg.getImageHandle(), jpgImg.getImageHandle(), &metadata,
jpgImg.getImageHandle()),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows bad metadata hdr capacity min";
}
@@ -1310,32 +1310,32 @@ TEST(JpegRTest, DecodeAPIWithInvalidArgs) {
destImage.data = data.get();
// test jpegr image
- ASSERT_NE(uHdrLib.decodeJPEGR(nullptr, &destImage), OK)
+ ASSERT_NE(uHdrLib.decodeJPEGR(nullptr, &destImage), JPEGR_NO_ERROR)
<< "fail, API allows nullptr for jpegr img";
- ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage), OK)
+ ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage), JPEGR_NO_ERROR)
<< "fail, API allows nullptr for jpegr img";
ASSERT_TRUE(jpgImg.allocateMemory());
// test dest image
- ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), nullptr), OK)
+ ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), nullptr), JPEGR_NO_ERROR)
<< "fail, API allows nullptr for dest";
destImage.data = nullptr;
- ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage), OK)
+ ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage), JPEGR_NO_ERROR)
<< "fail, API allows nullptr for dest";
destImage.data = data.get();
// test max display boost
- ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage, 0.5), OK)
+ ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage, 0.5), JPEGR_NO_ERROR)
<< "fail, API allows invalid max display boost";
// test output format
ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage, FLT_MAX, nullptr,
static_cast<ultrahdr_output_format>(-1)),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows invalid output format";
ASSERT_NE(uHdrLib.decodeJPEGR(jpgImg.getImageHandle(), &destImage, FLT_MAX, nullptr,
static_cast<ultrahdr_output_format>(ULTRAHDR_OUTPUT_MAX + 1)),
- OK)
+ JPEGR_NO_ERROR)
<< "fail, API allows invalid output format";
}
@@ -1395,7 +1395,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI0AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
// encode with luma stride set
{
UhdrUnCompressedStructWrapper rawImg2(kImageWidth, kImageHeight, YCbCr_p010);
@@ -1408,7 +1408,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI0AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1427,7 +1427,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI0AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1446,7 +1446,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI0AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1464,7 +1464,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI0AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2.getImageHandle(), ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1497,7 +1497,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
// encode with luma stride set p010
{
UhdrUnCompressedStructWrapper rawImg2P010(kImageWidth, kImageHeight, YCbCr_p010);
@@ -1510,7 +1510,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), rawImg420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1529,7 +1529,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), rawImg420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1548,7 +1548,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), rawImg420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1566,7 +1566,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), rawImg420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1584,7 +1584,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg2420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1603,7 +1603,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg2420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1622,7 +1622,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg2420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1640,7 +1640,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI1AndDecodeTest) {
ASSERT_EQ(uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg2420.getImageHandle(),
ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
jpgImg2.getImageHandle(), kQuality, nullptr),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1678,7 +1678,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI2AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg420.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
// encode with luma stride set
{
UhdrUnCompressedStructWrapper rawImg2P010(kImageWidth, kImageHeight, YCbCr_p010);
@@ -1691,7 +1691,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI2AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), rawImg420.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1710,7 +1710,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI2AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), rawImg420.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1729,7 +1729,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI2AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), rawImg420.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1747,7 +1747,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI2AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg2420.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1766,7 +1766,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI2AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg2420.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1785,7 +1785,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI2AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), rawImg2420.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1819,7 +1819,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI3AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImgP010.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
// encode with luma stride set
{
UhdrUnCompressedStructWrapper rawImg2P010(kImageWidth, kImageHeight, YCbCr_p010);
@@ -1832,7 +1832,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI3AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1851,7 +1851,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI3AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1870,7 +1870,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI3AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1888,7 +1888,7 @@ TEST_P(JpegRAPIEncodeAndDecodeTest, EncodeAPI3AndDecodeTest) {
ASSERT_EQ(
uHdrLib.encodeJPEGR(rawImg2P010.getImageHandle(), sdr,
ultrahdr_transfer_function::ULTRAHDR_TF_HLG, jpgImg2.getImageHandle()),
- OK);
+ JPEGR_NO_ERROR);
auto jpg1 = jpgImg.getImageHandle();
auto jpg2 = jpgImg2.getImageHandle();
ASSERT_EQ(jpg1->length, jpg2->length);
@@ -1955,8 +1955,9 @@ void JpegRBenchmark::BenchmarkGenerateGainMap(jr_uncompressed_ptr yuv420Image,
Profiler profileGenerateMap;
profileGenerateMap.timerStart();
for (auto i = 0; i < kProfileCount; i++) {
- ASSERT_EQ(OK, generateGainMap(yuv420Image, p010Image,
- ultrahdr_transfer_function::ULTRAHDR_TF_HLG, metadata, map));
+ ASSERT_EQ(JPEGR_NO_ERROR,
+ generateGainMap(yuv420Image, p010Image, ultrahdr_transfer_function::ULTRAHDR_TF_HLG,
+ metadata, map));
if (i != kProfileCount - 1) {
delete[] static_cast<uint8_t*>(map->data);
map->data = nullptr;
@@ -1973,8 +1974,8 @@ void JpegRBenchmark::BenchmarkApplyGainMap(jr_uncompressed_ptr yuv420Image, jr_u
Profiler profileRecMap;
profileRecMap.timerStart();
for (auto i = 0; i < kProfileCount; i++) {
- ASSERT_EQ(OK, applyGainMap(yuv420Image, map, metadata, ULTRAHDR_OUTPUT_HDR_HLG,
- metadata->maxContentBoost /* displayBoost */, dest));
+ ASSERT_EQ(JPEGR_NO_ERROR, applyGainMap(yuv420Image, map, metadata, ULTRAHDR_OUTPUT_HDR_HLG,
+ metadata->maxContentBoost /* displayBoost */, dest));
}
profileRecMap.timerStop();
ALOGE("Apply Gain Map:- Res = %zu x %zu, time = %f ms", yuv420Image->width, yuv420Image->height,
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-23 10:24:06 +0000