camera/jpeg.cpp - device/generic/goldfish - Git at Google

 /*
  * Copyright (C) 2023 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define FAILURE_DEBUG_PREFIX "jpeg"

 #include <inttypes.h>
 #include <setjmp.h>
 #include <algorithm>
 #include <vector>

 extern "C" {
 #include <jpeglib.h>
 }
 #include <libyuv/scale.h>
 #include <system/camera_metadata.h>

 #include "debug.h"
 #include "exif.h"
 #include "jpeg.h"
 #include "yuv.h"

 namespace android {
 namespace hardware {
 namespace camera {
 namespace provider {
 namespace implementation {
 namespace jpeg {
 namespace {
 constexpr int kJpegMCUSize = 16;  // we have to feed `jpeg_write_raw_data` in multiples of this

 // compressYUVImplPixelsFast handles the case where the image width is a multiple
 // of kJpegMCUSize. In this case no additional memcpy is required. See
 // compressYUVImplPixelsSlow below for the cases where the image width is not
 // a multiple of kJpegMCUSize.
 bool compressYUVImplPixelsFast(const android_ycbcr& image, jpeg_compress_struct* cinfo) {
     const uint8_t* y[kJpegMCUSize];
     const uint8_t* cb[kJpegMCUSize / 2];
     const uint8_t* cr[kJpegMCUSize / 2];
     const uint8_t** planes[] = { y, cb, cr };
     const int height = cinfo->image_height;
     const int height1 = height - 1;
     const int ystride = image.ystride;
     const int cstride = image.cstride;

     while (true) {
         const int nscl = cinfo->next_scanline;
         if (nscl >= height) {
             break;
         }

         for (int i = 0; i < kJpegMCUSize; ++i) {
             const int nscli = std::min(nscl + i, height1);
             y[i] = static_cast<const uint8_t*>(image.y) + nscli * ystride;
             if ((i & 1) == 0) {
                 const int offset = (nscli / 2) * cstride;
                 cb[i / 2] = static_cast<const uint8_t*>(image.cb) + offset;
                 cr[i / 2] = static_cast<const uint8_t*>(image.cr) + offset;
             }
         }

         if (!jpeg_write_raw_data(cinfo, const_cast<JSAMPIMAGE>(planes), kJpegMCUSize)) {
             return FAILURE(false);
         }
     }

     return true;
 }

 // Since JPEG processes everything in blocks of kJpegMCUSize, we have to make
 // both width and height a multiple of kJpegMCUSize. The height is handled by
 // repeating the last line. compressYUVImplPixelsSlow handles the case when the
 // image width is not a multiple of kJpegMCUSize by allocating a memory block
 // large enough to hold kJpegMCUSize rows of the image with width aligned up to
 // the next multiple of kJpegMCUSize. The original image has to be copied
 // chunk-by-chunk into this memory block.
 bool compressYUVImplPixelsSlow(const android_ycbcr& image, jpeg_compress_struct* cinfo,
                                const size_t alignedWidth, uint8_t* const alignedMemory) {
     uint8_t* y[kJpegMCUSize];
     uint8_t* cb[kJpegMCUSize / 2];
     uint8_t* cr[kJpegMCUSize / 2];
     uint8_t** planes[] = { y, cb, cr };

     {
         uint8_t* y0 = alignedMemory;
         for (int i = 0; i < kJpegMCUSize; ++i, y0 += alignedWidth) {
             y[i] = y0;
         }

         const size_t alignedWidth2 = alignedWidth / 2;
         uint8_t* cb0 = y0;
         uint8_t* cr0 = &cb0[kJpegMCUSize / 2 * alignedWidth2];

         for (int i = 0; i < kJpegMCUSize / 2; ++i, cb0 += alignedWidth2, cr0 += alignedWidth2) {
             cb[i] = cb0;
             cr[i] = cr0;
         }
     }

     const int width = cinfo->image_width;
     const int width2 = width / 2;
     const int height = cinfo->image_height;
     const int height1 = height - 1;
     const int ystride = image.ystride;
     const int cstride = image.cstride;

     while (true) {
         const int nscl = cinfo->next_scanline;
         if (nscl >= height) {
             break;
         }

         for (int i = 0; i < kJpegMCUSize; ++i) {
             const int nscli = std::min(nscl + i, height1);
             memcpy(y[i], static_cast<const uint8_t*>(image.y) + nscli * ystride, width);
             if ((i & 1) == 0) {
                 const int offset = (nscli / 2) * cstride;
                 memcpy(cb[i / 2], static_cast<const uint8_t*>(image.cb) + offset, width2);
                 memcpy(cr[i / 2], static_cast<const uint8_t*>(image.cr) + offset, width2);
             }
         }

         if (!jpeg_write_raw_data(cinfo, const_cast<JSAMPIMAGE>(planes), kJpegMCUSize)) {
             return FAILURE(false);
         }
     }

     return true;
 }

 struct JpegErrorMgr : public jpeg_error_mgr {
     JpegErrorMgr() {
         error_exit = &onJpegErrorS;
     }

     void onJpegError(j_common_ptr cinfo) {
         {
             char errorMessage[JMSG_LENGTH_MAX];
             memset(errorMessage, 0, sizeof(errorMessage));
             (*format_message)(cinfo, errorMessage);
             ALOGE("%s:%d: JPEG compression failed with '%s'",
                   __func__, __LINE__, errorMessage);
         }

         longjmp(jumpBuffer, 1);
     }

     static void onJpegErrorS(j_common_ptr cinfo) {
         static_cast<JpegErrorMgr*>(cinfo->err)->onJpegError(cinfo);
     }

     jmp_buf jumpBuffer;
 };

 bool compressYUVImpl(const android_ycbcr& image, const Rect<uint16_t> imageSize,
                      unsigned char* const rawExif, const unsigned rawExifSize,
                      const int quality,
                      jpeg_destination_mgr* sink) {
     if (image.chroma_step != 1) {
         return FAILURE(false);
     }

     std::vector<uint8_t> alignedMemory;
     jpeg_compress_struct cinfo;
     JpegErrorMgr err;
     bool result;

     cinfo.err = jpeg_std_error(&err);
     jpeg_create_compress(&cinfo);
     cinfo.image_width = imageSize.width;
     cinfo.image_height = imageSize.height;
     cinfo.input_components = 3;
     cinfo.in_color_space = JCS_YCbCr;
     jpeg_set_defaults(&cinfo);
     jpeg_set_quality(&cinfo, quality, TRUE);
     jpeg_default_colorspace(&cinfo);
     cinfo.raw_data_in = TRUE;
     cinfo.dct_method = JDCT_IFAST;
     cinfo.comp_info[0].h_samp_factor = 2;
     cinfo.comp_info[0].v_samp_factor = 2;
     cinfo.comp_info[1].h_samp_factor = 1;
     cinfo.comp_info[1].v_samp_factor = 1;
     cinfo.comp_info[2].h_samp_factor = 1;
     cinfo.comp_info[2].v_samp_factor = 1;
     cinfo.dest = sink;

     if (setjmp(err.jumpBuffer)) {
         jpeg_destroy_compress(&cinfo);
         return FAILURE(false);
     }

     jpeg_start_compress(&cinfo, TRUE);

     if (rawExif) {
         jpeg_write_marker(&cinfo, JPEG_APP0 + 1, rawExif, rawExifSize);
     }

     if (imageSize.width % kJpegMCUSize) {
         const size_t alignedWidth =
             ((imageSize.width + kJpegMCUSize) / kJpegMCUSize) * kJpegMCUSize;
         alignedMemory.resize(alignedWidth * kJpegMCUSize * 3 / 2);
         result = compressYUVImplPixelsSlow(image, &cinfo, alignedWidth, alignedMemory.data());
     } else {
         result = compressYUVImplPixelsFast(image, &cinfo);
     }

     jpeg_finish_compress(&cinfo);
     jpeg_destroy_compress(&cinfo);

     return result;
 }

 android_ycbcr resizeYUV(const android_ycbcr& srcYCbCr,
                         const Rect<uint16_t> srcSize,
                         const Rect<uint16_t> dstSize,
                         std::vector<uint8_t>* pDstData) {
     if (srcYCbCr.chroma_step != 1) {
         return FAILURE(android_ycbcr());
     }

     const size_t dstWidth = dstSize.width;
     const size_t dstHeight = dstSize.height;
     if ((dstWidth & 1) || (dstHeight & 1)) {
         return FAILURE(android_ycbcr());
     }

     std::vector<uint8_t> dstData(yuv::NV21size(dstWidth, dstHeight));
     const android_ycbcr dstYCbCr = yuv::NV21init(dstWidth, dstHeight, dstData.data());

     const int result = libyuv::I420Scale(
         static_cast<const uint8_t*>(srcYCbCr.y), srcYCbCr.ystride,
         static_cast<const uint8_t*>(srcYCbCr.cb), srcYCbCr.cstride,
         static_cast<const uint8_t*>(srcYCbCr.cr), srcYCbCr.cstride,
         srcSize.width, srcSize.height,
         static_cast<uint8_t*>(dstYCbCr.y), dstYCbCr.ystride,
         static_cast<uint8_t*>(dstYCbCr.cb), dstYCbCr.cstride,
         static_cast<uint8_t*>(dstYCbCr.cr), dstYCbCr.cstride,
         dstWidth, dstHeight,
         libyuv::kFilterBilinear);

     if (result) {
         return FAILURE_V(android_ycbcr(), "libyuv::I420Scale failed with %d", result);
     } else {
         *pDstData = std::move(dstData);
         return dstYCbCr;
     }
 }

 struct StaticBufferSink : public jpeg_destination_mgr {
     StaticBufferSink(void* dst, const size_t dstCapacity) {
         next_output_byte = static_cast<JOCTET*>(dst);
         free_in_buffer = dstCapacity;
         init_destination = &initDestinationS;
         empty_output_buffer = &emptyOutputBufferS;
         term_destination = &termDestinationS;
     }

     static void initDestinationS(j_compress_ptr) {}
     static boolean emptyOutputBufferS(j_compress_ptr) { return 0; }
     static void termDestinationS(j_compress_ptr) {}
 };

 constexpr int kDefaultQuality = 85;

 int sanitizeJpegQuality(const int quality) {
     if (quality <= 0) {
         return kDefaultQuality;
     } else if (quality > 100) {
         return 100;
     } else {
         return quality;
     }
 }

 }  // namespace

 size_t compressYUV(const android_ycbcr& image,
                    const Rect<uint16_t> imageSize,
                    const CameraMetadata& metadata,
                    void* const jpegData,
                    const size_t jpegDataCapacity) {
     std::vector<uint8_t> nv21data;
     const android_ycbcr imageNV21 =
         yuv::toNV21Shallow(imageSize.width, imageSize.height,
                            image, &nv21data);

     auto exifData = exif::createExifData(metadata, imageSize);
     if (!exifData) {
         return FAILURE(0);
     }

     const camera_metadata_t* const rawMetadata =
         reinterpret_cast<const camera_metadata_t*>(metadata.metadata.data());
     camera_metadata_ro_entry_t metadataEntry;

     do {
         Rect<uint16_t> thumbnailSize = {0, 0};
         int thumbnailQuality = 0;

         if (find_camera_metadata_ro_entry(rawMetadata, ANDROID_JPEG_THUMBNAIL_SIZE,
                                           &metadataEntry)) {
             break;
         } else {
             thumbnailSize.width = metadataEntry.data.i32[0];
             thumbnailSize.height = metadataEntry.data.i32[1];
             if ((thumbnailSize.width <= 0) || (thumbnailSize.height <= 0)) {
                 break;
             }
         }

         if (find_camera_metadata_ro_entry(rawMetadata, ANDROID_JPEG_THUMBNAIL_QUALITY,
                                           &metadataEntry)) {
             thumbnailQuality = kDefaultQuality;
         } else {
             thumbnailQuality = sanitizeJpegQuality(metadataEntry.data.i32[0]);
         }

         std::vector<uint8_t> thumbnailData;
         const android_ycbcr thumbmnail = resizeYUV(imageNV21, imageSize,
                                                    thumbnailSize, &thumbnailData);
         if (!thumbmnail.y) {
             return FAILURE(0);
         }

         StaticBufferSink sink(jpegData, jpegDataCapacity);
         if (!compressYUVImpl(thumbmnail, thumbnailSize, nullptr, 0,
                              thumbnailQuality, &sink)) {
             return FAILURE(0);
         }

         const size_t thumbnailJpegSize = jpegDataCapacity - sink.free_in_buffer;
         void* exifThumbnailJpegDataPtr = exif::exifDataAllocThumbnail(
             exifData.get(), thumbnailJpegSize);
         if (!exifThumbnailJpegDataPtr) {
             return FAILURE(0);
         }

         memcpy(exifThumbnailJpegDataPtr, jpegData, thumbnailJpegSize);
     } while (false);

     int quality;
     if (find_camera_metadata_ro_entry(rawMetadata, ANDROID_JPEG_QUALITY,
                                       &metadataEntry)) {
         quality = kDefaultQuality;
     } else {
         quality = sanitizeJpegQuality(metadataEntry.data.i32[0]);
     }

     unsigned char* rawExif = nullptr;
     unsigned rawExifSize = 0;
     exif_data_save_data(const_cast<ExifData*>(exifData.get()),
                         &rawExif, &rawExifSize);
     if (!rawExif) {
         return FAILURE(0);
     }

     StaticBufferSink sink(jpegData, jpegDataCapacity);
     const bool success = compressYUVImpl(imageNV21, imageSize, rawExif, rawExifSize,
                                          quality, &sink);
     free(rawExif);

     return success ? (jpegDataCapacity - sink.free_in_buffer) : 0;
 }

 }  // namespace jpeg
 }  // namespace implementation
 }  // namespace provider
 }  // namespace camera
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright (C) 2023 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define FAILURE_DEBUG_PREFIX "jpeg"

	#include <inttypes.h>
	#include <setjmp.h>
	#include <algorithm>
	#include <vector>

	extern "C" {
	#include <jpeglib.h>
	}
	#include <libyuv/scale.h>
	#include <system/camera_metadata.h>

	#include "debug.h"
	#include "exif.h"
	#include "jpeg.h"
	#include "yuv.h"

	namespace android {
	namespace hardware {
	namespace camera {
	namespace provider {
	namespace implementation {
	namespace jpeg {
	namespace {
	constexpr int kJpegMCUSize = 16; // we have to feed `jpeg_write_raw_data` in multiples of this

	// compressYUVImplPixelsFast handles the case where the image width is a multiple
	// of kJpegMCUSize. In this case no additional memcpy is required. See
	// compressYUVImplPixelsSlow below for the cases where the image width is not
	// a multiple of kJpegMCUSize.
	bool compressYUVImplPixelsFast(const android_ycbcr& image, jpeg_compress_struct* cinfo) {
	const uint8_t* y[kJpegMCUSize];
	const uint8_t* cb[kJpegMCUSize / 2];
	const uint8_t* cr[kJpegMCUSize / 2];
	const uint8_t** planes[] = { y, cb, cr };
	const int height = cinfo->image_height;
	const int height1 = height - 1;
	const int ystride = image.ystride;
	const int cstride = image.cstride;

	while (true) {
	const int nscl = cinfo->next_scanline;
	if (nscl >= height) {
	break;
	}

	for (int i = 0; i < kJpegMCUSize; ++i) {
	const int nscli = std::min(nscl + i, height1);
	y[i] = static_cast<const uint8_t>(image.y) + nscli ystride;
	if ((i & 1) == 0) {
	const int offset = (nscli / 2) * cstride;
	cb[i / 2] = static_cast<const uint8_t*>(image.cb) + offset;
	cr[i / 2] = static_cast<const uint8_t*>(image.cr) + offset;
	}
	}

	if (!jpeg_write_raw_data(cinfo, const_cast<JSAMPIMAGE>(planes), kJpegMCUSize)) {
	return FAILURE(false);
	}
	}

	return true;
	}

	// Since JPEG processes everything in blocks of kJpegMCUSize, we have to make
	// both width and height a multiple of kJpegMCUSize. The height is handled by
	// repeating the last line. compressYUVImplPixelsSlow handles the case when the
	// image width is not a multiple of kJpegMCUSize by allocating a memory block
	// large enough to hold kJpegMCUSize rows of the image with width aligned up to
	// the next multiple of kJpegMCUSize. The original image has to be copied
	// chunk-by-chunk into this memory block.
	bool compressYUVImplPixelsSlow(const android_ycbcr& image, jpeg_compress_struct* cinfo,
	const size_t alignedWidth, uint8_t* const alignedMemory) {
	uint8_t* y[kJpegMCUSize];
	uint8_t* cb[kJpegMCUSize / 2];
	uint8_t* cr[kJpegMCUSize / 2];
	uint8_t** planes[] = { y, cb, cr };

	{
	uint8_t* y0 = alignedMemory;
	for (int i = 0; i < kJpegMCUSize; ++i, y0 += alignedWidth) {
	y[i] = y0;
	}

	const size_t alignedWidth2 = alignedWidth / 2;
	uint8_t* cb0 = y0;
	uint8_t* cr0 = &cb0[kJpegMCUSize / 2 * alignedWidth2];

	for (int i = 0; i < kJpegMCUSize / 2; ++i, cb0 += alignedWidth2, cr0 += alignedWidth2) {
	cb[i] = cb0;
	cr[i] = cr0;
	}
	}

	const int width = cinfo->image_width;
	const int width2 = width / 2;
	const int height = cinfo->image_height;
	const int height1 = height - 1;
	const int ystride = image.ystride;
	const int cstride = image.cstride;

	while (true) {
	const int nscl = cinfo->next_scanline;
	if (nscl >= height) {
	break;
	}

	for (int i = 0; i < kJpegMCUSize; ++i) {
	const int nscli = std::min(nscl + i, height1);
	memcpy(y[i], static_cast<const uint8_t>(image.y) + nscli ystride, width);
	if ((i & 1) == 0) {
	const int offset = (nscli / 2) * cstride;
	memcpy(cb[i / 2], static_cast<const uint8_t*>(image.cb) + offset, width2);
	memcpy(cr[i / 2], static_cast<const uint8_t*>(image.cr) + offset, width2);
	}
	}

	if (!jpeg_write_raw_data(cinfo, const_cast<JSAMPIMAGE>(planes), kJpegMCUSize)) {
	return FAILURE(false);
	}
	}

	return true;
	}

	struct JpegErrorMgr : public jpeg_error_mgr {
	JpegErrorMgr() {
	error_exit = &onJpegErrorS;
	}

	void onJpegError(j_common_ptr cinfo) {
	{
	char errorMessage[JMSG_LENGTH_MAX];
	memset(errorMessage, 0, sizeof(errorMessage));
	(*format_message)(cinfo, errorMessage);
	ALOGE("%s:%d: JPEG compression failed with '%s'",
	__func__, __LINE__, errorMessage);
	}

	longjmp(jumpBuffer, 1);
	}

	static void onJpegErrorS(j_common_ptr cinfo) {
	static_cast<JpegErrorMgr*>(cinfo->err)->onJpegError(cinfo);
	}

	jmp_buf jumpBuffer;
	};

	bool compressYUVImpl(const android_ycbcr& image, const Rect<uint16_t> imageSize,
	unsigned char* const rawExif, const unsigned rawExifSize,
	const int quality,
	jpeg_destination_mgr* sink) {
	if (image.chroma_step != 1) {
	return FAILURE(false);
	}

	std::vector<uint8_t> alignedMemory;
	jpeg_compress_struct cinfo;
	JpegErrorMgr err;
	bool result;

	cinfo.err = jpeg_std_error(&err);
	jpeg_create_compress(&cinfo);
	cinfo.image_width = imageSize.width;
	cinfo.image_height = imageSize.height;
	cinfo.input_components = 3;
	cinfo.in_color_space = JCS_YCbCr;
	jpeg_set_defaults(&cinfo);
	jpeg_set_quality(&cinfo, quality, TRUE);
	jpeg_default_colorspace(&cinfo);
	cinfo.raw_data_in = TRUE;
	cinfo.dct_method = JDCT_IFAST;
	cinfo.comp_info[0].h_samp_factor = 2;
	cinfo.comp_info[0].v_samp_factor = 2;
	cinfo.comp_info[1].h_samp_factor = 1;
	cinfo.comp_info[1].v_samp_factor = 1;
	cinfo.comp_info[2].h_samp_factor = 1;
	cinfo.comp_info[2].v_samp_factor = 1;
	cinfo.dest = sink;

	if (setjmp(err.jumpBuffer)) {
	jpeg_destroy_compress(&cinfo);
	return FAILURE(false);
	}

	jpeg_start_compress(&cinfo, TRUE);

	if (rawExif) {
	jpeg_write_marker(&cinfo, JPEG_APP0 + 1, rawExif, rawExifSize);
	}

	if (imageSize.width % kJpegMCUSize) {
	const size_t alignedWidth =
	((imageSize.width + kJpegMCUSize) / kJpegMCUSize) * kJpegMCUSize;
	alignedMemory.resize(alignedWidth * kJpegMCUSize * 3 / 2);
	result = compressYUVImplPixelsSlow(image, &cinfo, alignedWidth, alignedMemory.data());
	} else {
	result = compressYUVImplPixelsFast(image, &cinfo);
	}

	jpeg_finish_compress(&cinfo);
	jpeg_destroy_compress(&cinfo);

	return result;
	}

	android_ycbcr resizeYUV(const android_ycbcr& srcYCbCr,
	const Rect<uint16_t> srcSize,
	const Rect<uint16_t> dstSize,
	std::vector<uint8_t>* pDstData) {
	if (srcYCbCr.chroma_step != 1) {
	return FAILURE(android_ycbcr());
	}

	const size_t dstWidth = dstSize.width;
	const size_t dstHeight = dstSize.height;
	if ((dstWidth & 1) \|\| (dstHeight & 1)) {
	return FAILURE(android_ycbcr());
	}

	std::vector<uint8_t> dstData(yuv::NV21size(dstWidth, dstHeight));
	const android_ycbcr dstYCbCr = yuv::NV21init(dstWidth, dstHeight, dstData.data());

	const int result = libyuv::I420Scale(
	static_cast<const uint8_t*>(srcYCbCr.y), srcYCbCr.ystride,
	static_cast<const uint8_t*>(srcYCbCr.cb), srcYCbCr.cstride,
	static_cast<const uint8_t*>(srcYCbCr.cr), srcYCbCr.cstride,
	srcSize.width, srcSize.height,
	static_cast<uint8_t*>(dstYCbCr.y), dstYCbCr.ystride,
	static_cast<uint8_t*>(dstYCbCr.cb), dstYCbCr.cstride,
	static_cast<uint8_t*>(dstYCbCr.cr), dstYCbCr.cstride,
	dstWidth, dstHeight,
	libyuv::kFilterBilinear);

	if (result) {
	return FAILURE_V(android_ycbcr(), "libyuv::I420Scale failed with %d", result);
	} else {
	*pDstData = std::move(dstData);
	return dstYCbCr;
	}
	}

	struct StaticBufferSink : public jpeg_destination_mgr {
	StaticBufferSink(void* dst, const size_t dstCapacity) {
	next_output_byte = static_cast<JOCTET*>(dst);
	free_in_buffer = dstCapacity;
	init_destination = &initDestinationS;
	empty_output_buffer = &emptyOutputBufferS;
	term_destination = &termDestinationS;
	}

	static void initDestinationS(j_compress_ptr) {}
	static boolean emptyOutputBufferS(j_compress_ptr) { return 0; }
	static void termDestinationS(j_compress_ptr) {}
	};

	constexpr int kDefaultQuality = 85;

	int sanitizeJpegQuality(const int quality) {
	if (quality <= 0) {
	return kDefaultQuality;
	} else if (quality > 100) {
	return 100;
	} else {
	return quality;
	}
	}

	} // namespace

	size_t compressYUV(const android_ycbcr& image,
	const Rect<uint16_t> imageSize,
	const CameraMetadata& metadata,
	void* const jpegData,
	const size_t jpegDataCapacity) {
	std::vector<uint8_t> nv21data;
	const android_ycbcr imageNV21 =
	yuv::toNV21Shallow(imageSize.width, imageSize.height,
	image, &nv21data);

	auto exifData = exif::createExifData(metadata, imageSize);
	if (!exifData) {
	return FAILURE(0);
	}

	const camera_metadata_t* const rawMetadata =
	reinterpret_cast<const camera_metadata_t*>(metadata.metadata.data());
	camera_metadata_ro_entry_t metadataEntry;

	do {
	Rect<uint16_t> thumbnailSize = {0, 0};
	int thumbnailQuality = 0;

	if (find_camera_metadata_ro_entry(rawMetadata, ANDROID_JPEG_THUMBNAIL_SIZE,
	&metadataEntry)) {
	break;
	} else {
	thumbnailSize.width = metadataEntry.data.i32[0];
	thumbnailSize.height = metadataEntry.data.i32[1];
	if ((thumbnailSize.width <= 0) \|\| (thumbnailSize.height <= 0)) {
	break;
	}
	}

	if (find_camera_metadata_ro_entry(rawMetadata, ANDROID_JPEG_THUMBNAIL_QUALITY,
	&metadataEntry)) {
	thumbnailQuality = kDefaultQuality;
	} else {
	thumbnailQuality = sanitizeJpegQuality(metadataEntry.data.i32[0]);
	}

	std::vector<uint8_t> thumbnailData;
	const android_ycbcr thumbmnail = resizeYUV(imageNV21, imageSize,
	thumbnailSize, &thumbnailData);
	if (!thumbmnail.y) {
	return FAILURE(0);
	}

	StaticBufferSink sink(jpegData, jpegDataCapacity);
	if (!compressYUVImpl(thumbmnail, thumbnailSize, nullptr, 0,
	thumbnailQuality, &sink)) {
	return FAILURE(0);
	}

	const size_t thumbnailJpegSize = jpegDataCapacity - sink.free_in_buffer;
	void* exifThumbnailJpegDataPtr = exif::exifDataAllocThumbnail(
	exifData.get(), thumbnailJpegSize);
	if (!exifThumbnailJpegDataPtr) {
	return FAILURE(0);
	}

	memcpy(exifThumbnailJpegDataPtr, jpegData, thumbnailJpegSize);
	} while (false);

	int quality;
	if (find_camera_metadata_ro_entry(rawMetadata, ANDROID_JPEG_QUALITY,
	&metadataEntry)) {
	quality = kDefaultQuality;
	} else {
	quality = sanitizeJpegQuality(metadataEntry.data.i32[0]);
	}

	unsigned char* rawExif = nullptr;
	unsigned rawExifSize = 0;
	exif_data_save_data(const_cast<ExifData*>(exifData.get()),
	&rawExif, &rawExifSize);
	if (!rawExif) {
	return FAILURE(0);
	}

	StaticBufferSink sink(jpegData, jpegDataCapacity);
	const bool success = compressYUVImpl(imageNV21, imageSize, rawExif, rawExifSize,
	quality, &sink);
	free(rawExif);

	return success ? (jpegDataCapacity - sink.free_in_buffer) : 0;
	}

	} // namespace jpeg
	} // namespace implementation
	} // namespace provider
	} // namespace camera
	} // namespace hardware
	} // namespace android