500 lines
17 KiB
C++
500 lines
17 KiB
C++
/*
|
|
* 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 <ultrahdr/jpegdecoderhelper.h>
|
|
|
|
#include <utils/Log.h>
|
|
|
|
#include <errno.h>
|
|
#include <setjmp.h>
|
|
#include <string>
|
|
|
|
using namespace std;
|
|
|
|
namespace android::ultrahdr {
|
|
|
|
#define ALIGNM(x, m) ((((x) + ((m) - 1)) / (m)) * (m))
|
|
|
|
const uint32_t kAPP0Marker = JPEG_APP0; // JFIF
|
|
const uint32_t kAPP1Marker = JPEG_APP0 + 1; // EXIF, XMP
|
|
const uint32_t kAPP2Marker = JPEG_APP0 + 2; // ICC
|
|
|
|
const std::string kXmpNameSpace = "http://ns.adobe.com/xap/1.0/";
|
|
const std::string kExifIdCode = "Exif";
|
|
constexpr uint32_t kICCMarkerHeaderSize = 14;
|
|
constexpr uint8_t kICCSig[] = {
|
|
'I', 'C', 'C', '_', 'P', 'R', 'O', 'F', 'I', 'L', 'E', '\0',
|
|
};
|
|
|
|
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);
|
|
}
|
|
|
|
JpegDecoderHelper::JpegDecoderHelper() {
|
|
}
|
|
|
|
JpegDecoderHelper::~JpegDecoderHelper() {
|
|
}
|
|
|
|
bool JpegDecoderHelper::decompressImage(const void* image, int length, bool decodeToRGBA) {
|
|
if (image == nullptr || length <= 0) {
|
|
ALOGE("Image size can not be handled: %d", length);
|
|
return false;
|
|
}
|
|
|
|
mResultBuffer.clear();
|
|
mXMPBuffer.clear();
|
|
if (!decode(image, length, decodeToRGBA)) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void* JpegDecoderHelper::getDecompressedImagePtr() {
|
|
return mResultBuffer.data();
|
|
}
|
|
|
|
size_t JpegDecoderHelper::getDecompressedImageSize() {
|
|
return mResultBuffer.size();
|
|
}
|
|
|
|
void* JpegDecoderHelper::getXMPPtr() {
|
|
return mXMPBuffer.data();
|
|
}
|
|
|
|
size_t JpegDecoderHelper::getXMPSize() {
|
|
return mXMPBuffer.size();
|
|
}
|
|
|
|
void* JpegDecoderHelper::getEXIFPtr() {
|
|
return mEXIFBuffer.data();
|
|
}
|
|
|
|
size_t JpegDecoderHelper::getEXIFSize() {
|
|
return mEXIFBuffer.size();
|
|
}
|
|
|
|
void* JpegDecoderHelper::getICCPtr() {
|
|
return mICCBuffer.data();
|
|
}
|
|
|
|
size_t JpegDecoderHelper::getICCSize() {
|
|
return mICCBuffer.size();
|
|
}
|
|
|
|
size_t JpegDecoderHelper::getDecompressedImageWidth() {
|
|
return mWidth;
|
|
}
|
|
|
|
size_t JpegDecoderHelper::getDecompressedImageHeight() {
|
|
return mHeight;
|
|
}
|
|
|
|
bool JpegDecoderHelper::decode(const void* image, int length, bool decodeToRGBA) {
|
|
jpeg_decompress_struct cinfo;
|
|
jpegr_source_mgr mgr(static_cast<const uint8_t*>(image), length);
|
|
jpegrerror_mgr myerr;
|
|
bool status = true;
|
|
|
|
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);
|
|
|
|
jpeg_save_markers(&cinfo, kAPP0Marker, 0xFFFF);
|
|
jpeg_save_markers(&cinfo, kAPP1Marker, 0xFFFF);
|
|
jpeg_save_markers(&cinfo, kAPP2Marker, 0xFFFF);
|
|
|
|
cinfo.src = &mgr;
|
|
jpeg_read_header(&cinfo, TRUE);
|
|
|
|
// Save XMP data, EXIF data, and ICC data.
|
|
// Here we only handle the first XMP / EXIF / ICC package.
|
|
// We assume that all packages are starting with two bytes marker (eg FF E1 for EXIF package),
|
|
// two bytes of package length which is stored in marker->original_length, and the real data
|
|
// which is stored in marker->data.
|
|
bool exifAppears = false;
|
|
bool xmpAppears = false;
|
|
bool iccAppears = false;
|
|
for (jpeg_marker_struct* marker = cinfo.marker_list;
|
|
marker && !(exifAppears && xmpAppears && iccAppears);
|
|
marker = marker->next) {
|
|
|
|
if (marker->marker != kAPP1Marker && marker->marker != kAPP2Marker) {
|
|
continue;
|
|
}
|
|
const unsigned int len = marker->data_length;
|
|
if (!xmpAppears &&
|
|
len > kXmpNameSpace.size() &&
|
|
!strncmp(reinterpret_cast<const char*>(marker->data),
|
|
kXmpNameSpace.c_str(),
|
|
kXmpNameSpace.size())) {
|
|
mXMPBuffer.resize(len+1, 0);
|
|
memcpy(static_cast<void*>(mXMPBuffer.data()), marker->data, len);
|
|
xmpAppears = true;
|
|
} else if (!exifAppears &&
|
|
len > kExifIdCode.size() &&
|
|
!strncmp(reinterpret_cast<const char*>(marker->data),
|
|
kExifIdCode.c_str(),
|
|
kExifIdCode.size())) {
|
|
mEXIFBuffer.resize(len, 0);
|
|
memcpy(static_cast<void*>(mEXIFBuffer.data()), marker->data, len);
|
|
exifAppears = true;
|
|
} else if (!iccAppears &&
|
|
len > sizeof(kICCSig) &&
|
|
!memcmp(marker->data, kICCSig, sizeof(kICCSig))) {
|
|
mICCBuffer.resize(len, 0);
|
|
memcpy(static_cast<void*>(mICCBuffer.data()), marker->data, len);
|
|
iccAppears = true;
|
|
}
|
|
}
|
|
|
|
if (cinfo.image_width > kMaxWidth || cinfo.image_height > kMaxHeight) {
|
|
// constraint on max width and max height is only due to alloc constraints
|
|
// tune these values basing on the target device
|
|
status = false;
|
|
goto CleanUp;
|
|
}
|
|
|
|
mWidth = cinfo.image_width;
|
|
mHeight = cinfo.image_height;
|
|
|
|
if (decodeToRGBA) {
|
|
if (cinfo.jpeg_color_space == JCS_GRAYSCALE) {
|
|
// We don't intend to support decoding grayscale to RGBA
|
|
status = false;
|
|
ALOGE("%s: decoding grayscale to RGBA is unsupported", __func__);
|
|
goto CleanUp;
|
|
}
|
|
// 4 bytes per pixel
|
|
mResultBuffer.resize(cinfo.image_width * cinfo.image_height * 4);
|
|
cinfo.out_color_space = JCS_EXT_RGBA;
|
|
} else {
|
|
if (cinfo.jpeg_color_space == JCS_YCbCr) {
|
|
if (cinfo.comp_info[0].h_samp_factor != 2 ||
|
|
cinfo.comp_info[1].h_samp_factor != 1 ||
|
|
cinfo.comp_info[2].h_samp_factor != 1 ||
|
|
cinfo.comp_info[0].v_samp_factor != 2 ||
|
|
cinfo.comp_info[1].v_samp_factor != 1 ||
|
|
cinfo.comp_info[2].v_samp_factor != 1) {
|
|
status = false;
|
|
ALOGE("%s: decoding to YUV only supports 4:2:0 subsampling", __func__);
|
|
goto CleanUp;
|
|
}
|
|
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.out_color_space = cinfo.jpeg_color_space;
|
|
cinfo.raw_data_out = TRUE;
|
|
}
|
|
|
|
cinfo.dct_method = JDCT_IFAST;
|
|
|
|
jpeg_start_decompress(&cinfo);
|
|
|
|
if (!decompress(&cinfo, static_cast<const uint8_t*>(mResultBuffer.data()),
|
|
cinfo.jpeg_color_space == JCS_GRAYSCALE)) {
|
|
status = false;
|
|
goto CleanUp;
|
|
}
|
|
|
|
CleanUp:
|
|
jpeg_finish_decompress(&cinfo);
|
|
jpeg_destroy_decompress(&cinfo);
|
|
|
|
return status;
|
|
}
|
|
|
|
bool JpegDecoderHelper::decompress(jpeg_decompress_struct* cinfo, const uint8_t* dest,
|
|
bool isSingleChannel) {
|
|
if (isSingleChannel) {
|
|
return decompressSingleChannel(cinfo, dest);
|
|
}
|
|
if (cinfo->out_color_space == JCS_EXT_RGBA)
|
|
return decompressRGBA(cinfo, dest);
|
|
else
|
|
return decompressYUV(cinfo, dest);
|
|
}
|
|
|
|
bool JpegDecoderHelper::getCompressedImageParameters(const void* image, int length,
|
|
size_t *pWidth, size_t *pHeight,
|
|
std::vector<uint8_t> *iccData , std::vector<uint8_t> *exifData) {
|
|
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);
|
|
|
|
jpeg_save_markers(&cinfo, kAPP1Marker, 0xFFFF);
|
|
jpeg_save_markers(&cinfo, kAPP2Marker, 0xFFFF);
|
|
|
|
cinfo.src = &mgr;
|
|
if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK) {
|
|
jpeg_destroy_decompress(&cinfo);
|
|
return false;
|
|
}
|
|
|
|
if (pWidth != nullptr) {
|
|
*pWidth = cinfo.image_width;
|
|
}
|
|
if (pHeight != nullptr) {
|
|
*pHeight = cinfo.image_height;
|
|
}
|
|
|
|
if (iccData != nullptr) {
|
|
for (jpeg_marker_struct* marker = cinfo.marker_list; marker;
|
|
marker = marker->next) {
|
|
if (marker->marker != kAPP2Marker) {
|
|
continue;
|
|
}
|
|
if (marker->data_length <= kICCMarkerHeaderSize ||
|
|
memcmp(marker->data, kICCSig, sizeof(kICCSig)) != 0) {
|
|
continue;
|
|
}
|
|
|
|
iccData->insert(iccData->end(), marker->data, marker->data + marker->data_length);
|
|
}
|
|
}
|
|
|
|
if (exifData != nullptr) {
|
|
bool exifAppears = false;
|
|
for (jpeg_marker_struct* marker = cinfo.marker_list; marker && !exifAppears;
|
|
marker = marker->next) {
|
|
if (marker->marker != kAPP1Marker) {
|
|
continue;
|
|
}
|
|
|
|
const unsigned int len = marker->data_length;
|
|
if (len >= kExifIdCode.size() &&
|
|
!strncmp(reinterpret_cast<const char*>(marker->data), kExifIdCode.c_str(),
|
|
kExifIdCode.size())) {
|
|
exifData->resize(len, 0);
|
|
memcpy(static_cast<void*>(exifData->data()), marker->data, len);
|
|
exifAppears = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
jpeg_destroy_decompress(&cinfo);
|
|
return true;
|
|
}
|
|
|
|
bool JpegDecoderHelper::decompressRGBA(jpeg_decompress_struct* cinfo, const uint8_t* dest) {
|
|
JSAMPLE* decodeDst = (JSAMPLE*) dest;
|
|
uint32_t lines = 0;
|
|
// TODO: use batches for more effectiveness
|
|
while (lines < cinfo->image_height) {
|
|
uint32_t ret = jpeg_read_scanlines(cinfo, &decodeDst, 1);
|
|
if (ret == 0) {
|
|
break;
|
|
}
|
|
decodeDst += cinfo->image_width * 4;
|
|
lines++;
|
|
}
|
|
return lines == cinfo->image_height;
|
|
}
|
|
|
|
bool JpegDecoderHelper::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 = std::make_unique<uint8_t[]>(cinfo->image_width);
|
|
memset(empty.get(), 0, cinfo->image_width);
|
|
|
|
const int aligned_width = ALIGNM(cinfo->image_width, kCompressBatchSize);
|
|
bool is_width_aligned = (aligned_width == cinfo->image_width);
|
|
std::unique_ptr<uint8_t[]> buffer_intrm = nullptr;
|
|
uint8_t* y_plane_intrm = nullptr;
|
|
uint8_t* u_plane_intrm = nullptr;
|
|
uint8_t* v_plane_intrm = nullptr;
|
|
JSAMPROW y_intrm[kCompressBatchSize];
|
|
JSAMPROW cb_intrm[kCompressBatchSize / 2];
|
|
JSAMPROW cr_intrm[kCompressBatchSize / 2];
|
|
JSAMPARRAY planes_intrm[3] {y_intrm, cb_intrm, cr_intrm};
|
|
if (!is_width_aligned) {
|
|
size_t mcu_row_size = aligned_width * kCompressBatchSize * 3 / 2;
|
|
buffer_intrm = std::make_unique<uint8_t[]>(mcu_row_size);
|
|
y_plane_intrm = buffer_intrm.get();
|
|
u_plane_intrm = y_plane_intrm + (aligned_width * kCompressBatchSize);
|
|
v_plane_intrm = u_plane_intrm + (aligned_width * kCompressBatchSize) / 4;
|
|
for (int i = 0; i < kCompressBatchSize; ++i) {
|
|
y_intrm[i] = y_plane_intrm + i * aligned_width;
|
|
}
|
|
for (int i = 0; i < kCompressBatchSize / 2; ++i) {
|
|
int offset_intrm = i * (aligned_width / 2);
|
|
cb_intrm[i] = u_plane_intrm + offset_intrm;
|
|
cr_intrm[i] = v_plane_intrm + offset_intrm;
|
|
}
|
|
}
|
|
|
|
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, is_width_aligned ? planes : planes_intrm,
|
|
kCompressBatchSize);
|
|
if (processed != kCompressBatchSize) {
|
|
ALOGE("Number of processed lines does not equal input lines.");
|
|
return false;
|
|
}
|
|
if (!is_width_aligned) {
|
|
for (int i = 0; i < kCompressBatchSize; ++i) {
|
|
memcpy(y[i], y_intrm[i], cinfo->image_width);
|
|
}
|
|
for (int i = 0; i < kCompressBatchSize / 2; ++i) {
|
|
memcpy(cb[i], cb_intrm[i], cinfo->image_width / 2);
|
|
memcpy(cr[i], cr_intrm[i], cinfo->image_width / 2);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool JpegDecoderHelper::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 = std::make_unique<uint8_t[]>(cinfo->image_width);
|
|
memset(empty.get(), 0, cinfo->image_width);
|
|
|
|
int aligned_width = ALIGNM(cinfo->image_width, kCompressBatchSize);
|
|
bool is_width_aligned = (aligned_width == cinfo->image_width);
|
|
std::unique_ptr<uint8_t[]> buffer_intrm = nullptr;
|
|
uint8_t* y_plane_intrm = nullptr;
|
|
JSAMPROW y_intrm[kCompressBatchSize];
|
|
JSAMPARRAY planes_intrm[1] {y_intrm};
|
|
if (!is_width_aligned) {
|
|
size_t mcu_row_size = aligned_width * kCompressBatchSize;
|
|
buffer_intrm = std::make_unique<uint8_t[]>(mcu_row_size);
|
|
y_plane_intrm = buffer_intrm.get();
|
|
for (int i = 0; i < kCompressBatchSize; ++i) {
|
|
y_intrm[i] = y_plane_intrm + i * aligned_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, is_width_aligned ? planes : planes_intrm,
|
|
kCompressBatchSize);
|
|
if (processed != kCompressBatchSize / 2) {
|
|
ALOGE("Number of processed lines does not equal input lines.");
|
|
return false;
|
|
}
|
|
if (!is_width_aligned) {
|
|
for (int i = 0; i < kCompressBatchSize; ++i) {
|
|
memcpy(y[i], y_intrm[i], cinfo->image_width);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
} // namespace ultrahdr
|