/*
* Copyright 2016 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 "HdrPlusClientUtils"
#include <log/log.h>
#include <fstream>
#include <inttypes.h>
#include <system/graphics.h>
#include "HdrPlusClientUtils.h"
namespace android {
namespace hdrplus_client_utils {
// Get the RGB values of the pixel at (x, y).
static status_t getRgb(uint8_t *r, uint8_t *g, uint8_t* b, uint32_t x, uint32_t y,
const pbcamera::StreamConfiguration &streamConfig,
const pbcamera::StreamBuffer &buffer) {
switch (streamConfig.image.format) {
case HAL_PIXEL_FORMAT_YCrCb_420_SP:
{
// Check the stream configuration has two planes.
if (streamConfig.image.planes.size() != 2) {
ALOGE("%s: NV21 should have 2 planes but it has %zu", __FUNCTION__,
streamConfig.image.planes.size());
return BAD_VALUE;
}
// Find the indices of Y, V, and U in the buffer.
uint32_t yIndex = y * streamConfig.image.planes[0].stride + x;
uint32_t vIndex = streamConfig.image.planes[0].scanline *
streamConfig.image.planes[0].stride +
(y / 2) * streamConfig.image.planes[1].stride + (x & ~0x1);
uint32_t uIndex = vIndex + 1;
// Convert YUV to RGB.
int32_t yc = ((uint8_t*)buffer.data)[yIndex];
int32_t vc = ((uint8_t*)buffer.data)[vIndex] - 128;
int32_t uc = ((uint8_t*)buffer.data)[uIndex] - 128;
*r = std::min(std::max(yc + 0.003036f * uc + 1.399457f * vc, 0.0f), 255.0f);
*g = std::min(std::max(yc - 0.344228f * uc - 0.717202f * vc, 0.0f), 255.0f);
*b = std::min(std::max(yc + 1.772431f * uc - 0.006137f * vc, 0.0f), 255.0f);
return OK;
}
case HAL_PIXEL_FORMAT_RGB_888:
{
// Check the stream configuration has 1 plane.
if (streamConfig.image.planes.size() != 1) {
ALOGE("%s: RGB_888 should have 1 plane but it has %zu", __FUNCTION__,
streamConfig.image.planes.size());
return BAD_VALUE;
}
uint32_t offset = y * streamConfig.image.planes[0].stride + x * 3;
*r = ((uint8_t*)buffer.data)[offset];
*g = ((uint8_t*)buffer.data)[offset + 1];
*b = ((uint8_t*)buffer.data)[offset + 2];
return OK;
}
default:
ALOGE("%s: Format %d is not supported.", __FUNCTION__, streamConfig.image.format);
return BAD_VALUE;
}
}
status_t writePpm(const std::string &filename, const pbcamera::StreamConfiguration &streamConfig,
const pbcamera::StreamBuffer &buffer) {
if (streamConfig.image.format != HAL_PIXEL_FORMAT_YCrCb_420_SP &&
streamConfig.image.format != HAL_PIXEL_FORMAT_RGB_888) {
ALOGE("%s: format 0x%x is not supported.", __FUNCTION__, streamConfig.image.format);
return BAD_VALUE;
}
std::ofstream outfile(filename, std::ios::binary);
if (!outfile.is_open()) {
ALOGE("%s: Opening file (%s) failed.", __FUNCTION__, filename.data());
return NO_INIT;
}
uint32_t width = streamConfig.image.width;
uint32_t height = streamConfig.image.height;
// Write headers of the ppm file.
outfile << "P6";
outfile << " " << std::to_string(width) << " " << std::to_string(height) << " 255 ";
// Write RGB values of the image.
uint8_t r, g, b;
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
status_t res = getRgb(&r, &g, &b, x, y, streamConfig, buffer);
if (res != OK) {
ALOGE("%s: Getting RGB failed: %s (%d).", __FUNCTION__, strerror(-res), res);
return res;
}
outfile << r << g << b;
}
}
ALOGD("%s: Saved file: %s", __FUNCTION__, filename.data());
outfile.close();
return OK;
}
status_t comparePpm(const std::string &filename, const pbcamera::StreamConfiguration &streamConfig,
const pbcamera::StreamBuffer &buffer, float *diffRatio) {
if (streamConfig.image.format != HAL_PIXEL_FORMAT_YCrCb_420_SP) {
ALOGE("%s: format 0x%x is not supported.", __FUNCTION__, streamConfig.image.format);
return BAD_VALUE;
}
std::ifstream ifile(filename, std::ios::binary);
if (!ifile.is_open()) {
ALOGE("%s: Opening file (%s) failed.", __FUNCTION__, filename.data());
return NO_INIT;
}
std::string s;
// Read headers of the ppm file.
ifile >> s;
if (s != "P6") {
ALOGE("%s: Invalid PPM file header: %s", __FUNCTION__, s.c_str());
return BAD_VALUE;
}
// Read width and height.
ifile >> s;
uint32_t width = std::stoul(s);
ifile >> s;
uint32_t height = std::stoul(s);
if (width != streamConfig.image.width || height != streamConfig.image.height) {
ALOGE("%s: Image resolution doesn't match. image %dx%d ppm %dx%d",
__FUNCTION__, streamConfig.image.width, streamConfig.image.height,
width, height);
return BAD_VALUE;
}
ifile >> s;
if (s != "255") {
ALOGE("%s: Expecting 255 but got %s", __FUNCTION__, s.c_str());
return BAD_VALUE;
}
char c;
// Get a space
ifile.get(c);
// Now the RGB values start.
uint8_t r, g, b;
uint64_t diff = 0;
for (uint32_t y = 0; y < height; y++) {
for (uint32_t x = 0; x < width; x++) {
status_t res = getRgb(&r, &g, &b, x, y, streamConfig, buffer);
if (res != OK) {
ALOGE("%s: Getting RGB failed: %s (%d).", __FUNCTION__, strerror(-res), res);
return res;
}
// Get r, g, b from golden image and accumulate the differences.
ifile.get(c);
diff += abs(static_cast<int32_t>(c) - r);
ifile.get(c);
diff += abs(static_cast<int32_t>(c) - g);
ifile.get(c);
diff += abs(static_cast<int32_t>(c) - b);
}
}
if (diffRatio != nullptr) {
*diffRatio = diff / (static_cast<float>(width) * height * 3 * 256);
}
return OK;
}
} // hdrplus_client_utils
} // namespace android