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

3 files changed, 105 insertions, 103 deletions

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