services/camera/libcameraservice/tests/NV12Compressor.cpp - platform/frameworks/av - Git at Google

 /*
 * Copyright (C) 2019 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 LOG_NDEBUG 0
 #define LOG_TAG "Test_NV12Compressor"

 #include "NV12Compressor.h"

 #include <libexif/exif-data.h>
 #include <netinet/in.h>

 using namespace android;
 using namespace android::camera3;

 namespace std {
 template <>
 struct default_delete<ExifEntry> {
     inline void operator()(ExifEntry* entry) const { exif_entry_unref(entry); }
 };

 template <>
 struct default_delete<ExifData> {
     inline void operator()(ExifData* data) const { exif_data_unref(data); }
 };

 }  // namespace std

 bool NV12Compressor::compress(const unsigned char* data, int width, int height, int quality) {
     if (!configureCompressor(width, height, quality)) {
         // the method will have logged a more detailed error message than we can
         // provide here so just return.
         return false;
     }

     return compressData(data, /*exifData*/ nullptr);
 }

 bool NV12Compressor::compressWithExifOrientation(const unsigned char* data, int width, int height,
         int quality, android::camera3::ExifOrientation exifValue) {
     std::unique_ptr<ExifData> exifData(exif_data_new());
     if (exifData.get() == nullptr) {
         return false;
     }

     exif_data_set_option(exifData.get(), EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
     exif_data_set_data_type(exifData.get(), EXIF_DATA_TYPE_COMPRESSED);
     exif_data_set_byte_order(exifData.get(), EXIF_BYTE_ORDER_INTEL);
     std::unique_ptr<ExifEntry> exifEntry(exif_entry_new());
     if (exifEntry.get() ==  nullptr) {
         return false;
     }

     exifEntry->tag = EXIF_TAG_ORIENTATION;
     exif_content_add_entry(exifData->ifd[EXIF_IFD_0], exifEntry.get());
     exif_entry_initialize(exifEntry.get(), exifEntry->tag);
     exif_set_short(exifEntry->data, EXIF_BYTE_ORDER_INTEL, exifValue);

     if (!configureCompressor(width, height, quality)) {
         return false;
     }

     return compressData(data, exifData.get());
 }

 const std::vector<uint8_t>& NV12Compressor::getCompressedData() const {
     return mDestManager.mBuffer;
 }

 bool NV12Compressor::configureCompressor(int width, int height, int quality) {
     mCompressInfo.err = jpeg_std_error(&mErrorManager);
     // NOTE! DANGER! Do not construct any non-trivial objects below setjmp!
     // The compiler will not generate code to destroy them during the return
     // below so they will leak. Additionally, do not place any calls to libjpeg
     // that can fail above this line or any error will cause undefined behavior.
     if (setjmp(mErrorManager.mJumpBuffer)) {
         // This is where the error handler will jump in case setup fails
         // The error manager will ALOG an appropriate error message
         return false;
     }

     jpeg_create_compress(&mCompressInfo);

     mCompressInfo.image_width = width;
     mCompressInfo.image_height = height;
     mCompressInfo.input_components = 3;
     mCompressInfo.in_color_space = JCS_YCbCr;
     jpeg_set_defaults(&mCompressInfo);

     jpeg_set_quality(&mCompressInfo, quality, TRUE);
     // It may seem weird to set color space here again but this will also set
     // other fields. These fields might be overwritten by jpeg_set_defaults
     jpeg_set_colorspace(&mCompressInfo, JCS_YCbCr);
     mCompressInfo.raw_data_in = TRUE;
     mCompressInfo.dct_method = JDCT_IFAST;
     // Set sampling factors
     mCompressInfo.comp_info[0].h_samp_factor = 2;
     mCompressInfo.comp_info[0].v_samp_factor = 2;
     mCompressInfo.comp_info[1].h_samp_factor = 1;
     mCompressInfo.comp_info[1].v_samp_factor = 1;
     mCompressInfo.comp_info[2].h_samp_factor = 1;
     mCompressInfo.comp_info[2].v_samp_factor = 1;

     mCompressInfo.dest = &mDestManager;

     return true;
 }

 static void deinterleave(const uint8_t* vuPlanar, std::vector<uint8_t>& uRows,
         std::vector<uint8_t>& vRows, int rowIndex, int width, int height, int stride) {
     int numRows = (height - rowIndex) / 2;
     if (numRows > 8) numRows = 8;
     for (int row = 0; row < numRows; ++row) {
         int offset = ((rowIndex >> 1) + row) * stride;
         const uint8_t* vu = vuPlanar + offset;
         for (int i = 0; i < (width >> 1); ++i) {
             int index = row * (width >> 1) + i;
             uRows[index] = vu[1];
             vRows[index] = vu[0];
             vu += 2;
         }
     }
 }

 bool NV12Compressor::compressData(const unsigned char* data, ExifData* exifData) {
     const uint8_t* y[16];
     const uint8_t* cb[8];
     const uint8_t* cr[8];
     const uint8_t** planes[3] = { y, cb, cr };

     int i, offset;
     int width = mCompressInfo.image_width;
     int height = mCompressInfo.image_height;
     const uint8_t* yPlanar = data;
     const uint8_t* vuPlanar = data + (width * height);
     std::vector<uint8_t> uRows(8 * (width >> 1));
     std::vector<uint8_t> vRows(8 * (width >> 1));

     // NOTE! DANGER! Do not construct any non-trivial objects below setjmp!
     // The compiler will not generate code to destroy them during the return
     // below so they will leak. Additionally, do not place any calls to libjpeg
     // that can fail above this line or any error will cause undefined behavior.
     if (setjmp(mErrorManager.mJumpBuffer)) {
         // This is where the error handler will jump in case compression fails
         // The error manager will ALOG an appropriate error message
         return false;
     }

     jpeg_start_compress(&mCompressInfo, TRUE);

     attachExifData(exifData);

     // process 16 lines of Y and 8 lines of U/V each time.
     while (mCompressInfo.next_scanline < mCompressInfo.image_height) {
         //deinterleave u and v
         deinterleave(vuPlanar, uRows, vRows, mCompressInfo.next_scanline,
                      width, height, width);

         // Jpeg library ignores the rows whose indices are greater than height.
         for (i = 0; i < 16; i++) {
             // y row
             y[i] = yPlanar + (mCompressInfo.next_scanline + i) * width;

             // construct u row and v row
             if ((i & 1) == 0) {
                 // height and width are both halved because of downsampling
                 offset = (i >> 1) * (width >> 1);
                 cb[i/2] = &uRows[offset];
                 cr[i/2] = &vRows[offset];
             }
           }
         jpeg_write_raw_data(&mCompressInfo, const_cast<JSAMPIMAGE>(planes), 16);
     }

     jpeg_finish_compress(&mCompressInfo);
     jpeg_destroy_compress(&mCompressInfo);

     return true;
 }

 bool NV12Compressor::attachExifData(ExifData* exifData) {
     if (exifData == nullptr) {
         // This is not an error, we don't require EXIF data
         return true;
     }

     // Save the EXIF data to memory
     unsigned char* rawData = nullptr;
     unsigned int size = 0;
     exif_data_save_data(exifData, &rawData, &size);
     if (rawData == nullptr) {
         ALOGE("Failed to create EXIF data block");
         return false;
     }

     jpeg_write_marker(&mCompressInfo, JPEG_APP0 + 1, rawData, size);
     free(rawData);
     return true;
 }

 NV12Compressor::ErrorManager::ErrorManager() {
     error_exit = &onJpegError;
 }

 void NV12Compressor::ErrorManager::onJpegError(j_common_ptr cinfo) {
     // NOTE! Do not construct any non-trivial objects in this method at the top
     // scope. Their destructors will not be called. If you do need such an
     // object create a local scope that does not include the longjmp call,
     // that ensures the object is destroyed before longjmp is called.
     ErrorManager* errorManager = reinterpret_cast<ErrorManager*>(cinfo->err);

     // Format and log error message
     char errorMessage[JMSG_LENGTH_MAX];
     (*errorManager->format_message)(cinfo, errorMessage);
     errorMessage[sizeof(errorMessage) - 1] = '\0';
     ALOGE("JPEG compression error: %s", errorMessage);
     jpeg_destroy(cinfo);

     // And through the looking glass we go
     longjmp(errorManager->mJumpBuffer, 1);
 }

 NV12Compressor::DestinationManager::DestinationManager() {
     init_destination = &initDestination;
     empty_output_buffer = &emptyOutputBuffer;
     term_destination = &termDestination;
 }

 void NV12Compressor::DestinationManager::initDestination(j_compress_ptr cinfo) {
     auto manager = reinterpret_cast<DestinationManager*>(cinfo->dest);

     // Start out with some arbitrary but not too large buffer size
     manager->mBuffer.resize(16 * 1024);
     manager->next_output_byte = &manager->mBuffer[0];
     manager->free_in_buffer = manager->mBuffer.size();
 }

 boolean NV12Compressor::DestinationManager::emptyOutputBuffer(
         j_compress_ptr cinfo) {
     auto manager = reinterpret_cast<DestinationManager*>(cinfo->dest);

     // Keep doubling the size of the buffer for a very low, amortized
     // performance cost of the allocations
     size_t oldSize = manager->mBuffer.size();
     manager->mBuffer.resize(oldSize * 2);
     manager->next_output_byte = &manager->mBuffer[oldSize];
     manager->free_in_buffer = manager->mBuffer.size() - oldSize;
     return manager->free_in_buffer != 0;
 }

 void NV12Compressor::DestinationManager::termDestination(j_compress_ptr cinfo) {
     auto manager = reinterpret_cast<DestinationManager*>(cinfo->dest);

     // Resize down to the exact size of the output, that is remove as many
     // bytes as there are left in the buffer
     manager->mBuffer.resize(manager->mBuffer.size() - manager->free_in_buffer);
 }

 status_t NV12Compressor::findJpegSize(uint8_t *jpegBuffer, size_t maxSize, size_t *size /*out*/) {
     if ((size == nullptr) || (jpegBuffer == nullptr)) {
         return BAD_VALUE;
     }

     if (checkJpegStart(jpegBuffer) == 0) {
         return BAD_VALUE;
     }

     // Read JFIF segment markers, skip over segment data
     *size = kMarkerLength; //jump to Start Of Image
     while (*size <= maxSize - kMarkerLength) {
         segment_t *segment = (segment_t*)(jpegBuffer + *size);
         uint8_t type = checkJpegMarker(segment->marker);
         if (type == 0) { // invalid marker, no more segments, begin JPEG data
             break;
         }
         if (type == kEndOfImage || *size > maxSize - sizeof(segment_t)) {
             return BAD_VALUE;
         }

         size_t length = ntohs(segment->length);
         *size += length + kMarkerLength;
     }

     // Find End of Image
     // Scan JPEG buffer until End of Image
     bool foundEnd = false;
     for ( ; *size <= maxSize - kMarkerLength; (*size)++) {
         if (checkJpegEnd(jpegBuffer + *size)) {
             foundEnd = true;
             *size += kMarkerLength;
             break;
         }
     }

     if (!foundEnd) {
         return BAD_VALUE;
     }

     if (*size > maxSize) {
         *size = maxSize;
     }

     return OK;
 }

 status_t NV12Compressor::getJpegImageDimensions(uint8_t *jpegBuffer,
         size_t jpegBufferSize, size_t *width /*out*/, size_t *height /*out*/) {
     if ((jpegBuffer == nullptr) || (width == nullptr) || (height == nullptr) ||
             (jpegBufferSize == 0u)) {
         return BAD_VALUE;
     }

     // Scan JPEG buffer until Start of Frame
     bool foundSOF = false;
     size_t currentPos;
     for (currentPos = 0; currentPos <= jpegBufferSize - kMarkerLength; currentPos++) {
         if (checkStartOfFrame(jpegBuffer + currentPos)) {
             foundSOF = true;
             currentPos += kMarkerLength;
             break;
         }
     }

     if (!foundSOF) {
         ALOGE("%s: Start of Frame not found", __func__);
         return BAD_VALUE;
     }

     sof_t *startOfFrame = reinterpret_cast<sof_t *> (jpegBuffer + currentPos);
     *width = ntohs(startOfFrame->width);
     *height = ntohs(startOfFrame->height);

     return OK;
 }

 status_t NV12Compressor::getExifOrientation(uint8_t *jpegBuffer, size_t jpegBufferSize,
         ExifOrientation *exifValue /*out*/) {
     if ((jpegBuffer == nullptr) || (exifValue == nullptr) || (jpegBufferSize == 0u)) {
         return BAD_VALUE;
     }

     std::unique_ptr<ExifData> exifData(exif_data_new());
     exif_data_load_data(exifData.get(), jpegBuffer, jpegBufferSize);
     ExifEntry *orientation = exif_content_get_entry(exifData->ifd[EXIF_IFD_0],
             EXIF_TAG_ORIENTATION);
     if ((orientation == nullptr) || (orientation->size != sizeof(ExifShort))) {
         return BAD_VALUE;
     }

     auto orientationValue = exif_get_short(orientation->data,
             exif_data_get_byte_order(exifData.get()));
     status_t ret;
     switch (orientationValue) {
         case ExifOrientation::ORIENTATION_0_DEGREES:
         case ExifOrientation::ORIENTATION_90_DEGREES:
         case ExifOrientation::ORIENTATION_180_DEGREES:
         case ExifOrientation::ORIENTATION_270_DEGREES:
             *exifValue = static_cast<ExifOrientation> (orientationValue);
             ret = OK;
             break;
         default:
             ALOGE("%s: Unexpected EXIF orientation value: %u", __FUNCTION__, orientationValue);
             ret = BAD_VALUE;
     }

     return ret;
 }
	/*
	* Copyright (C) 2019 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 LOG_NDEBUG 0
	#define LOG_TAG "Test_NV12Compressor"

	#include "NV12Compressor.h"

	#include <libexif/exif-data.h>
	#include <netinet/in.h>

	using namespace android;
	using namespace android::camera3;

	namespace std {
	template <>
	struct default_delete<ExifEntry> {
	inline void operator()(ExifEntry* entry) const { exif_entry_unref(entry); }
	};

	template <>
	struct default_delete<ExifData> {
	inline void operator()(ExifData* data) const { exif_data_unref(data); }
	};

	} // namespace std

	bool NV12Compressor::compress(const unsigned char* data, int width, int height, int quality) {
	if (!configureCompressor(width, height, quality)) {
	// the method will have logged a more detailed error message than we can
	// provide here so just return.
	return false;
	}

	return compressData(data, /exifData/ nullptr);
	}

	bool NV12Compressor::compressWithExifOrientation(const unsigned char* data, int width, int height,
	int quality, android::camera3::ExifOrientation exifValue) {
	std::unique_ptr<ExifData> exifData(exif_data_new());
	if (exifData.get() == nullptr) {
	return false;
	}

	exif_data_set_option(exifData.get(), EXIF_DATA_OPTION_FOLLOW_SPECIFICATION);
	exif_data_set_data_type(exifData.get(), EXIF_DATA_TYPE_COMPRESSED);
	exif_data_set_byte_order(exifData.get(), EXIF_BYTE_ORDER_INTEL);
	std::unique_ptr<ExifEntry> exifEntry(exif_entry_new());
	if (exifEntry.get() == nullptr) {
	return false;
	}

	exifEntry->tag = EXIF_TAG_ORIENTATION;
	exif_content_add_entry(exifData->ifd[EXIF_IFD_0], exifEntry.get());
	exif_entry_initialize(exifEntry.get(), exifEntry->tag);
	exif_set_short(exifEntry->data, EXIF_BYTE_ORDER_INTEL, exifValue);

	if (!configureCompressor(width, height, quality)) {
	return false;
	}

	return compressData(data, exifData.get());
	}

	const std::vector<uint8_t>& NV12Compressor::getCompressedData() const {
	return mDestManager.mBuffer;
	}

	bool NV12Compressor::configureCompressor(int width, int height, int quality) {
	mCompressInfo.err = jpeg_std_error(&mErrorManager);
	// NOTE! DANGER! Do not construct any non-trivial objects below setjmp!
	// The compiler will not generate code to destroy them during the return
	// below so they will leak. Additionally, do not place any calls to libjpeg
	// that can fail above this line or any error will cause undefined behavior.
	if (setjmp(mErrorManager.mJumpBuffer)) {
	// This is where the error handler will jump in case setup fails
	// The error manager will ALOG an appropriate error message
	return false;
	}

	jpeg_create_compress(&mCompressInfo);

	mCompressInfo.image_width = width;
	mCompressInfo.image_height = height;
	mCompressInfo.input_components = 3;
	mCompressInfo.in_color_space = JCS_YCbCr;
	jpeg_set_defaults(&mCompressInfo);

	jpeg_set_quality(&mCompressInfo, quality, TRUE);
	// It may seem weird to set color space here again but this will also set
	// other fields. These fields might be overwritten by jpeg_set_defaults
	jpeg_set_colorspace(&mCompressInfo, JCS_YCbCr);
	mCompressInfo.raw_data_in = TRUE;
	mCompressInfo.dct_method = JDCT_IFAST;
	// Set sampling factors
	mCompressInfo.comp_info[0].h_samp_factor = 2;
	mCompressInfo.comp_info[0].v_samp_factor = 2;
	mCompressInfo.comp_info[1].h_samp_factor = 1;
	mCompressInfo.comp_info[1].v_samp_factor = 1;
	mCompressInfo.comp_info[2].h_samp_factor = 1;
	mCompressInfo.comp_info[2].v_samp_factor = 1;

	mCompressInfo.dest = &mDestManager;

	return true;
	}

	static void deinterleave(const uint8_t* vuPlanar, std::vector<uint8_t>& uRows,
	std::vector<uint8_t>& vRows, int rowIndex, int width, int height, int stride) {
	int numRows = (height - rowIndex) / 2;
	if (numRows > 8) numRows = 8;
	for (int row = 0; row < numRows; ++row) {
	int offset = ((rowIndex >> 1) + row) * stride;
	const uint8_t* vu = vuPlanar + offset;
	for (int i = 0; i < (width >> 1); ++i) {
	int index = row * (width >> 1) + i;
	uRows[index] = vu[1];
	vRows[index] = vu[0];
	vu += 2;
	}
	}
	}

	bool NV12Compressor::compressData(const unsigned char* data, ExifData* exifData) {
	const uint8_t* y[16];
	const uint8_t* cb[8];
	const uint8_t* cr[8];
	const uint8_t** planes[3] = { y, cb, cr };

	int i, offset;
	int width = mCompressInfo.image_width;
	int height = mCompressInfo.image_height;
	const uint8_t* yPlanar = data;
	const uint8_t* vuPlanar = data + (width * height);
	std::vector<uint8_t> uRows(8 * (width >> 1));
	std::vector<uint8_t> vRows(8 * (width >> 1));

	// NOTE! DANGER! Do not construct any non-trivial objects below setjmp!
	// The compiler will not generate code to destroy them during the return
	// below so they will leak. Additionally, do not place any calls to libjpeg
	// that can fail above this line or any error will cause undefined behavior.
	if (setjmp(mErrorManager.mJumpBuffer)) {
	// This is where the error handler will jump in case compression fails
	// The error manager will ALOG an appropriate error message
	return false;
	}

	jpeg_start_compress(&mCompressInfo, TRUE);

	attachExifData(exifData);

	// process 16 lines of Y and 8 lines of U/V each time.
	while (mCompressInfo.next_scanline < mCompressInfo.image_height) {
	//deinterleave u and v
	deinterleave(vuPlanar, uRows, vRows, mCompressInfo.next_scanline,
	width, height, width);

	// Jpeg library ignores the rows whose indices are greater than height.
	for (i = 0; i < 16; i++) {
	// y row
	y[i] = yPlanar + (mCompressInfo.next_scanline + i) * width;

	// construct u row and v row
	if ((i & 1) == 0) {
	// height and width are both halved because of downsampling
	offset = (i >> 1) * (width >> 1);
	cb[i/2] = &uRows[offset];
	cr[i/2] = &vRows[offset];
	}
	}
	jpeg_write_raw_data(&mCompressInfo, const_cast<JSAMPIMAGE>(planes), 16);
	}

	jpeg_finish_compress(&mCompressInfo);
	jpeg_destroy_compress(&mCompressInfo);

	return true;
	}

	bool NV12Compressor::attachExifData(ExifData* exifData) {
	if (exifData == nullptr) {
	// This is not an error, we don't require EXIF data
	return true;
	}

	// Save the EXIF data to memory
	unsigned char* rawData = nullptr;
	unsigned int size = 0;
	exif_data_save_data(exifData, &rawData, &size);
	if (rawData == nullptr) {
	ALOGE("Failed to create EXIF data block");
	return false;
	}

	jpeg_write_marker(&mCompressInfo, JPEG_APP0 + 1, rawData, size);
	free(rawData);
	return true;
	}

	NV12Compressor::ErrorManager::ErrorManager() {
	error_exit = &onJpegError;
	}

	void NV12Compressor::ErrorManager::onJpegError(j_common_ptr cinfo) {
	// NOTE! Do not construct any non-trivial objects in this method at the top
	// scope. Their destructors will not be called. If you do need such an
	// object create a local scope that does not include the longjmp call,
	// that ensures the object is destroyed before longjmp is called.
	ErrorManager* errorManager = reinterpret_cast<ErrorManager*>(cinfo->err);

	// Format and log error message
	char errorMessage[JMSG_LENGTH_MAX];
	(*errorManager->format_message)(cinfo, errorMessage);
	errorMessage[sizeof(errorMessage) - 1] = '\0';
	ALOGE("JPEG compression error: %s", errorMessage);
	jpeg_destroy(cinfo);

	// And through the looking glass we go
	longjmp(errorManager->mJumpBuffer, 1);
	}

	NV12Compressor::DestinationManager::DestinationManager() {
	init_destination = &initDestination;
	empty_output_buffer = &emptyOutputBuffer;
	term_destination = &termDestination;
	}

	void NV12Compressor::DestinationManager::initDestination(j_compress_ptr cinfo) {
	auto manager = reinterpret_cast<DestinationManager*>(cinfo->dest);

	// Start out with some arbitrary but not too large buffer size
	manager->mBuffer.resize(16 * 1024);
	manager->next_output_byte = &manager->mBuffer[0];
	manager->free_in_buffer = manager->mBuffer.size();
	}

	boolean NV12Compressor::DestinationManager::emptyOutputBuffer(
	j_compress_ptr cinfo) {
	auto manager = reinterpret_cast<DestinationManager*>(cinfo->dest);

	// Keep doubling the size of the buffer for a very low, amortized
	// performance cost of the allocations
	size_t oldSize = manager->mBuffer.size();
	manager->mBuffer.resize(oldSize * 2);
	manager->next_output_byte = &manager->mBuffer[oldSize];
	manager->free_in_buffer = manager->mBuffer.size() - oldSize;
	return manager->free_in_buffer != 0;
	}

	void NV12Compressor::DestinationManager::termDestination(j_compress_ptr cinfo) {
	auto manager = reinterpret_cast<DestinationManager*>(cinfo->dest);

	// Resize down to the exact size of the output, that is remove as many
	// bytes as there are left in the buffer
	manager->mBuffer.resize(manager->mBuffer.size() - manager->free_in_buffer);
	}

	status_t NV12Compressor::findJpegSize(uint8_t jpegBuffer, size_t maxSize, size_t size /out/) {
	if ((size == nullptr) \|\| (jpegBuffer == nullptr)) {
	return BAD_VALUE;
	}

	if (checkJpegStart(jpegBuffer) == 0) {
	return BAD_VALUE;
	}

	// Read JFIF segment markers, skip over segment data
	*size = kMarkerLength; //jump to Start Of Image
	while (*size <= maxSize - kMarkerLength) {
	segment_t segment = (segment_t)(jpegBuffer + *size);
	uint8_t type = checkJpegMarker(segment->marker);
	if (type == 0) { // invalid marker, no more segments, begin JPEG data
	break;
	}
	if (type == kEndOfImage \|\| *size > maxSize - sizeof(segment_t)) {
	return BAD_VALUE;
	}

	size_t length = ntohs(segment->length);
	*size += length + kMarkerLength;
	}

	// Find End of Image
	// Scan JPEG buffer until End of Image
	bool foundEnd = false;
	for ( ; size <= maxSize - kMarkerLength; (size)++) {
	if (checkJpegEnd(jpegBuffer + *size)) {
	foundEnd = true;
	*size += kMarkerLength;
	break;
	}
	}

	if (!foundEnd) {
	return BAD_VALUE;
	}

	if (*size > maxSize) {
	*size = maxSize;
	}

	return OK;
	}

	status_t NV12Compressor::getJpegImageDimensions(uint8_t *jpegBuffer,
	size_t jpegBufferSize, size_t width /out/, size_t height /out/) {
	if ((jpegBuffer == nullptr) \|\| (width == nullptr) \|\| (height == nullptr) \|\|
	(jpegBufferSize == 0u)) {
	return BAD_VALUE;
	}

	// Scan JPEG buffer until Start of Frame
	bool foundSOF = false;
	size_t currentPos;
	for (currentPos = 0; currentPos <= jpegBufferSize - kMarkerLength; currentPos++) {
	if (checkStartOfFrame(jpegBuffer + currentPos)) {
	foundSOF = true;
	currentPos += kMarkerLength;
	break;
	}
	}

	if (!foundSOF) {
	ALOGE("%s: Start of Frame not found", __func__);
	return BAD_VALUE;
	}

	sof_t startOfFrame = reinterpret_cast<sof_t > (jpegBuffer + currentPos);
	*width = ntohs(startOfFrame->width);
	*height = ntohs(startOfFrame->height);

	return OK;
	}

	status_t NV12Compressor::getExifOrientation(uint8_t *jpegBuffer, size_t jpegBufferSize,
	ExifOrientation exifValue /out*/) {
	if ((jpegBuffer == nullptr) \|\| (exifValue == nullptr) \|\| (jpegBufferSize == 0u)) {
	return BAD_VALUE;
	}

	std::unique_ptr<ExifData> exifData(exif_data_new());
	exif_data_load_data(exifData.get(), jpegBuffer, jpegBufferSize);
	ExifEntry *orientation = exif_content_get_entry(exifData->ifd[EXIF_IFD_0],
	EXIF_TAG_ORIENTATION);
	if ((orientation == nullptr) \|\| (orientation->size != sizeof(ExifShort))) {
	return BAD_VALUE;
	}

	auto orientationValue = exif_get_short(orientation->data,
	exif_data_get_byte_order(exifData.get()));
	status_t ret;
	switch (orientationValue) {
	case ExifOrientation::ORIENTATION_0_DEGREES:
	case ExifOrientation::ORIENTATION_90_DEGREES:
	case ExifOrientation::ORIENTATION_180_DEGREES:
	case ExifOrientation::ORIENTATION_270_DEGREES:
	*exifValue = static_cast<ExifOrientation> (orientationValue);
	ret = OK;
	break;
	default:
	ALOGE("%s: Unexpected EXIF orientation value: %u", __FUNCTION__, orientationValue);
	ret = BAD_VALUE;
	}

	return ret;
	}