libjpegrecoverymap: add JPEG decoder for YUV and single channel (0d12ba8b) · Commits · e / os / platform_frameworks_native

libs/jpegrecoverymap/Android.bp

+14 −0

Original line number	Diff line number	Diff line
		@@ -50,3 +50,17 @@ cc_library_static {
		"jpegencoder.cpp",
		],
		}

		cc_library_static {
		name: "libjpegdecoder",

		shared_libs: [
		"libjpeg",
		],

		export_include_dirs: ["include"],

		srcs: [
		"jpegdecoder.cpp",
		],
		}
		No newline at end of file

libs/jpegrecoverymap/include/jpegrecoverymap/jpegdecoder.h

0 → 100644

+62 −0

Original line number	Diff line number	Diff line

		/*
		* Copyright 2022 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.
		*/
		// We must include cstdio before jpeglib.h. It is a requirement of libjpeg.
		#include <cstdio>
		extern "C" {
		#include <jerror.h>
		#include <jpeglib.h>
		}
		#include <utils/Errors.h>
		#include <vector>
		namespace android::recoverymap {
		/*
		* Encapsulates a converter from JPEG to raw image (YUV420planer or grey-scale) format.
		* This class is not thread-safe.
		*/
		class JpegDecoder {
		public:
		JpegDecoder();
		~JpegDecoder();
		/*
		* Decompresses JPEG image to raw image (YUV420planer or grey-scale) format. After calling
		* this method, call getDecompressedImage() to get the image.
		* Returns false if decompressing the image fails.
		*/
		bool decompressImage(const void* image, int length);
		/*
		* Returns the decompressed raw image buffer pointer. This method must be called only after
		* calling decompressImage().
		*/
		const void* getDecompressedImagePtr();
		/*
		* Returns the decompressed raw image buffer size. This method must be called only after
		* calling decompressImage().
		*/
		size_t getDecompressedImageSize();
		private:
		bool decode(const void* image, int length);
		// Returns false if errors occur.
		bool decompress(jpeg_decompress_struct* cinfo, const uint8_t* dest, bool isSingleChannel);
		bool decompressYUV(jpeg_decompress_struct* cinfo, const uint8_t* dest);
		bool decompressSingleChannel(jpeg_decompress_struct* cinfo, const uint8_t* dest);
		// Process 16 lines of Y and 16 lines of U/V each time.
		// We must pass at least 16 scanlines according to libjpeg documentation.
		static const int kCompressBatchSize = 16;
		// The buffer that holds the compressed result.
		std::vector<JOCTET> mResultBuffer;
		};
		} /* namespace android */

libs/jpegrecoverymap/jpegdecoder.cpp

0 → 100644

+225 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 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.
		*/

		#include <jpegrecoverymap/jpegdecoder.h>

		#include <cutils/log.h>

		#include <errno.h>
		#include <setjmp.h>

		namespace android::recoverymap {
		struct jpegr_source_mgr : jpeg_source_mgr {
		jpegr_source_mgr(const uint8_t* ptr, int len);
		~jpegr_source_mgr();

		const uint8_t* mBufferPtr;
		size_t mBufferLength;
		};

		struct jpegrerror_mgr {
		struct jpeg_error_mgr pub;
		jmp_buf setjmp_buffer;
		};

		static void jpegr_init_source(j_decompress_ptr cinfo) {
		jpegr_source_mgr* src = static_cast<jpegr_source_mgr*>(cinfo->src);
		src->next_input_byte = static_cast<const JOCTET*>(src->mBufferPtr);
		src->bytes_in_buffer = src->mBufferLength;
		}

		static boolean jpegr_fill_input_buffer(j_decompress_ptr /* cinfo */) {
		ALOGE("%s : should not get here", __func__);
		return FALSE;
		}

		static void jpegr_skip_input_data(j_decompress_ptr cinfo, long num_bytes) {
		jpegr_source_mgr* src = static_cast<jpegr_source_mgr*>(cinfo->src);

		if (num_bytes > static_cast<long>(src->bytes_in_buffer)) {
		ALOGE("jpegr_skip_input_data - num_bytes > (long)src->bytes_in_buffer");
		} else {
		src->next_input_byte += num_bytes;
		src->bytes_in_buffer -= num_bytes;
		}
		}

		static void jpegr_term_source(j_decompress_ptr /cinfo/) {}

		jpegr_source_mgr::jpegr_source_mgr(const uint8_t* ptr, int len) :
		mBufferPtr(ptr), mBufferLength(len) {
		init_source = jpegr_init_source;
		fill_input_buffer = jpegr_fill_input_buffer;
		skip_input_data = jpegr_skip_input_data;
		resync_to_restart = jpeg_resync_to_restart;
		term_source = jpegr_term_source;
		}

		jpegr_source_mgr::~jpegr_source_mgr() {}

		static void jpegrerror_exit(j_common_ptr cinfo) {
		jpegrerror_mgr* err = reinterpret_cast<jpegrerror_mgr*>(cinfo->err);
		longjmp(err->setjmp_buffer, 1);
		}

		JpegDecoder::JpegDecoder() {
		}

		JpegDecoder::~JpegDecoder() {
		}

		bool JpegDecoder::decompressImage(const void* image, int length) {
		if (image == nullptr \|\| length <= 0) {
		ALOGE("Image size can not be handled: %d", length);
		return false;
		}

		mResultBuffer.clear();
		if (!decode(image, length)) {
		return false;
		}

		return true;
		}

		const void* JpegDecoder::getDecompressedImagePtr() {
		return mResultBuffer.data();
		}

		size_t JpegDecoder::getDecompressedImageSize() {
		return mResultBuffer.size();
		}

		bool JpegDecoder::decode(const void* image, int length) {
		jpeg_decompress_struct cinfo;
		jpegr_source_mgr mgr(static_cast<const uint8_t*>(image), length);
		jpegrerror_mgr myerr;
		cinfo.err = jpeg_std_error(&myerr.pub);
		myerr.pub.error_exit = jpegrerror_exit;

		if (setjmp(myerr.setjmp_buffer)) {
		jpeg_destroy_decompress(&cinfo);
		return false;
		}
		jpeg_create_decompress(&cinfo);

		cinfo.src = &mgr;
		jpeg_read_header(&cinfo, TRUE);

		if (cinfo.jpeg_color_space == JCS_YCbCr) {
		mResultBuffer.resize(cinfo.image_width * cinfo.image_height * 3 / 2, 0);
		} else if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
		mResultBuffer.resize(cinfo.image_width * cinfo.image_height, 0);
		}

		cinfo.raw_data_out = TRUE;
		cinfo.dct_method = JDCT_IFAST;
		cinfo.out_color_space = cinfo.jpeg_color_space;

		jpeg_start_decompress(&cinfo);

		if (!decompress(&cinfo, static_cast<const uint8_t*>(mResultBuffer.data()),
		cinfo.jpeg_color_space == JCS_GRAYSCALE)) {
		return false;
		}

		jpeg_finish_decompress(&cinfo);
		jpeg_destroy_decompress(&cinfo);

		return true;
		}

		bool JpegDecoder::decompress(jpeg_decompress_struct* cinfo, const uint8_t* dest,
		bool isSingleChannel) {
		if (isSingleChannel) {
		return decompressSingleChannel(cinfo, dest);
		}
		return decompressYUV(cinfo, dest);
		}

		bool JpegDecoder::decompressYUV(jpeg_decompress_struct* cinfo, const uint8_t* dest) {

		JSAMPROW y[kCompressBatchSize];
		JSAMPROW cb[kCompressBatchSize / 2];
		JSAMPROW cr[kCompressBatchSize / 2];
		JSAMPARRAY planes[3] {y, cb, cr};

		size_t y_plane_size = cinfo->image_width * cinfo->image_height;
		size_t uv_plane_size = y_plane_size / 4;
		uint8_t* y_plane = const_cast<uint8_t*>(dest);
		uint8_t* u_plane = const_cast<uint8_t*>(dest + y_plane_size);
		uint8_t* v_plane = const_cast<uint8_t*>(dest + y_plane_size + uv_plane_size);
		std::unique_ptr<uint8_t[]> empty(new uint8_t[cinfo->image_width]);
		memset(empty.get(), 0, cinfo->image_width);

		while (cinfo->output_scanline < cinfo->image_height) {
		for (int i = 0; i < kCompressBatchSize; ++i) {
		size_t scanline = cinfo->output_scanline + i;
		if (scanline < cinfo->image_height) {
		y[i] = y_plane + scanline * cinfo->image_width;
		} else {
		y[i] = empty.get();
		}
		}
		// cb, cr only have half scanlines
		for (int i = 0; i < kCompressBatchSize / 2; ++i) {
		size_t scanline = cinfo->output_scanline / 2 + i;
		if (scanline < cinfo->image_height / 2) {
		int offset = scanline * (cinfo->image_width / 2);
		cb[i] = u_plane + offset;
		cr[i] = v_plane + offset;
		} else {
		cb[i] = cr[i] = empty.get();
		}
		}

		int processed = jpeg_read_raw_data(cinfo, planes, kCompressBatchSize);
		if (processed != kCompressBatchSize) {
		ALOGE("Number of processed lines does not equal input lines.");
		return false;
		}
		}
		return true;
		}

		bool JpegDecoder::decompressSingleChannel(jpeg_decompress_struct* cinfo, const uint8_t* dest) {
		JSAMPROW y[kCompressBatchSize];
		JSAMPARRAY planes[1] {y};

		uint8_t* y_plane = const_cast<uint8_t*>(dest);
		std::unique_ptr<uint8_t[]> empty(new uint8_t[cinfo->image_width]);
		memset(empty.get(), 0, cinfo->image_width);

		while (cinfo->output_scanline < cinfo->image_height) {
		for (int i = 0; i < kCompressBatchSize; ++i) {
		size_t scanline = cinfo->output_scanline + i;
		if (scanline < cinfo->image_height) {
		y[i] = y_plane + scanline * cinfo->image_width;
		} else {
		y[i] = empty.get();
		}
		}

		int processed = jpeg_read_raw_data(cinfo, planes, kCompressBatchSize);
		if (processed != kCompressBatchSize / 2) {
		ALOGE("Number of processed lines does not equal input lines.");
		return false;
		}
		}
		return true;
		}

		} // namespace android
		No newline at end of file

libs/jpegrecoverymap/tests/Android.bp

+16 −0

Original line number	Diff line number	Diff line
		@@ -47,3 +47,19 @@ cc_test {
		"libgtest",
		],
		}

		cc_test {
		name: "libjpegdecoder_test",
		test_suites: ["device-tests"],
		srcs: [
		"jpegdecoder_test.cpp",
		],
		shared_libs: [
		"libjpeg",
		"liblog",
		],
		static_libs: [
		"libjpegdecoder",
		"libgtest",
		],
		}
		No newline at end of file

libs/jpegrecoverymap/tests/data/minnie-320x240-y.jpg

0 → 100644

+19.7 KiB

Loading image diff...