LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

am e53a7733: Merge "Added white balance settings to the camera Emulator."

Browse Source 
* commit 'e53a773396e977793f5fed465d93068f345deb9a':
  Added white balance settings to the camera Emulator.
This commit is contained in:
Eddy Talvala
2011-10-24 11:22:10 -07:00
committed by Android Git Automerger
parent bef291d86f e53a773396
commit 8807dcadc5
6 changed files with 165 additions and 24 deletions
Download Patch File Download Diff File Expand all files Collapse all files

49
tools/emulator/system/camera/EmulatedCamera.cpp
View File

@@ -28,7 +28,7 @@
#include <cutils/log.h>
#include <ui/Rect.h>
#include "EmulatedCamera.h"
#include "EmulatedFakeCameraDevice.h"
//#include "EmulatedFakeCameraDevice.h"
#include "Converters.h"
/* Defines whether we should trace parameter changes. */
@@ -99,12 +99,8 @@ status_t EmulatedCamera::Initialize()
* Fake required parameters.
*/
mParameters.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES,
"320x240,0x0");
mParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "6");
mParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-6");
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5");
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
mParameters.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, "320x240,0x0");
mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "512");
mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "384");
mParameters.set(CameraParameters::KEY_JPEG_QUALITY, "90");
@@ -137,10 +133,22 @@ status_t EmulatedCamera::Initialize()
CameraParameters::PIXEL_FORMAT_JPEG);
mParameters.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);
/*
* Not supported features
*/
/* Sets the default exposure compensation support to be disabled. */
mParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "0");
mParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "0");
/* Sets auto white balance as default. */
getCameraDevice()->initializeWhiteBalanceModes(
CameraParameters::WHITE_BALANCE_AUTO, 1.0f, 1.0f);
mParameters.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
CameraParameters::WHITE_BALANCE_AUTO);
mParameters.set(CameraParameters::KEY_WHITE_BALANCE,
CameraParameters::WHITE_BALANCE_AUTO);
getCameraDevice()->setWhiteBalanceMode(
mParameters.get(CameraParameters::KEY_WHITE_BALANCE));
/* Not supported features
*/
mParameters.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES,
CameraParameters::FOCUS_MODE_FIXED);
mParameters.set(CameraParameters::KEY_FOCUS_MODE,
@@ -408,6 +416,9 @@ status_t EmulatedCamera::setParameters(const char* parms)
String8 str8_param(parms);
new_param.unflatten(str8_param);
/*
* Check for new exposure compensation parameter.
*/
int new_exposure_compensation = new_param.getInt(
CameraParameters::KEY_EXPOSURE_COMPENSATION);
const int min_exposure_compensation = new_param.getInt(
@@ -435,6 +446,24 @@ status_t EmulatedCamera::setParameters(const char* parms)
exposure_value);
}
}
const char* new_white_balance = new_param.get(
CameraParameters::KEY_WHITE_BALANCE);
const char* supported_white_balance = new_param.get(
CameraParameters::KEY_SUPPORTED_WHITE_BALANCE);
if ((supported_white_balance != NULL) && (new_white_balance != NULL) &&
(strstr(supported_white_balance, new_white_balance) != NULL)) {
const char* current_white_balance = mParameters.get(
CameraParameters::KEY_WHITE_BALANCE);
if ((current_white_balance == NULL) ||
(strcmp(current_white_balance, new_white_balance) != 0)) {
LOGV("Setting white balance to %s", new_white_balance);
getCameraDevice()->setWhiteBalanceMode(new_white_balance);
}
}
mParameters = new_param;
return NO_ERROR;

45
tools/emulator/system/camera/EmulatedCameraDevice.cpp
View File

@@ -29,25 +29,33 @@
#include <sys/select.h>
#include <cmath>
#include "EmulatedCameraDevice.h"
#include "Converters.h"
namespace android {
const float GAMMA_CORRECTION = 2.2f;
EmulatedCameraDevice::EmulatedCameraDevice(EmulatedCamera* camera_hal)
: mObjectLock(),
mCurFrameTimestamp(0),
mCameraHAL(camera_hal),
mCurrentFrame(NULL),
mExposureCompensation(1.0f),
mWhiteBalanceScale(NULL),
mSupportedWhiteBalanceScale(),
mState(ECDS_CONSTRUCTED)
{
}
EmulatedCameraDevice::~EmulatedCameraDevice()
{
LOGV("EmulatedCameraDevice destructor");
if (mCurrentFrame != NULL) {
delete[] mCurrentFrame;
}
for (int i = 0; i < mSupportedWhiteBalanceScale.size(); ++i) {
if (mSupportedWhiteBalanceScale.valueAt(i) != NULL) {
delete[] mSupportedWhiteBalanceScale.valueAt(i);
}
}
}
/****************************************************************************
@@ -110,10 +118,43 @@ void EmulatedCameraDevice::setExposureCompensation(const float ev) {
LOGW("%s: Fake camera device is not started.", __FUNCTION__);
}
mExposureCompensation = std::pow(2.0f, ev);
mExposureCompensation = std::pow(2.0f, ev / GAMMA_CORRECTION);
LOGV("New exposure compensation is %f", mExposureCompensation);
}
void EmulatedCameraDevice::initializeWhiteBalanceModes(const char* mode,
const float r_scale,
const float b_scale) {
LOGV("%s with %s, %f, %f", __FUNCTION__, mode, r_scale, b_scale);
float* value = new float[3];
value[0] = r_scale; value[1] = 1.0f; value[2] = b_scale;
mSupportedWhiteBalanceScale.add(String8(mode), value);
}
void EmulatedCameraDevice::setWhiteBalanceMode(const char* mode) {
LOGV("%s with white balance %s", __FUNCTION__, mode);
mWhiteBalanceScale =
mSupportedWhiteBalanceScale.valueFor(String8(mode));
}
/* Computes the pixel value after adjusting the white balance to the current
* one. The input the y, u, v channel of the pixel and the adjusted value will
* be stored in place. The adjustment is done in RGB space.
*/
void EmulatedCameraDevice::changeWhiteBalance(uint8_t& y,
uint8_t& u,
uint8_t& v) const {
float r_scale = mWhiteBalanceScale[0];
float b_scale = mWhiteBalanceScale[2];
int r = static_cast<float>(YUV2R(y, u, v)) / r_scale;
int g = YUV2G(y, u, v);
int b = static_cast<float>(YUV2B(y, u, v)) / b_scale;
y = RGB2Y(r, g, b);
u = RGB2U(r, g, b);
v = RGB2V(r, g, b);
}
status_t EmulatedCameraDevice::getCurrentPreviewFrame(void* buffer)
{
if (!isStarted()) {

46
tools/emulator/system/camera/EmulatedCameraDevice.h
View File

@@ -27,7 +27,10 @@
*/
#include <utils/threads.h>
#include <utils/KeyedVector.h>
#include <utils/String8.h>
#include "EmulatedCameraCommon.h"
#include "Converters.h"
namespace android {
@@ -116,6 +119,21 @@ public:
*/
virtual status_t Initialize();
/* Initializes the white balance modes parameters.
* The parameters are passed by each individual derived camera API to
* represent that different camera manufacturers may have different
* preferences on the white balance parameters. Green channel in the RGB
* color space is fixed to keep the luminance to be reasonably constant.
*
* Param:
* mode the text describing the current white balance mode
* r_scale the scale factor for the R channel in RGB space
* b_scale the scale factor for the B channel in RGB space.
*/
void initializeWhiteBalanceModes(const char* mode,
const float r_scale,
const float b_scale);
/* Starts delivering frames captured from the camera device.
* This method will start the worker thread that would be pulling frames from
* the camera device, and will deliver the pulled frames back to the emulated
@@ -145,7 +163,11 @@ public:
/* Sets the exposure compensation for the camera device.
*/
virtual void setExposureCompensation(const float ev);
void setExposureCompensation(const float ev);
/* Sets the white balance mode for the device.
*/
void setWhiteBalanceMode(const char* mode);
/* Gets current framebuffer, converted into preview frame format.
* This method must be called on a connected instance of this class with a
@@ -269,6 +291,24 @@ protected:
*/
virtual void commonStopDevice();
/** Computes a luminance value after taking the exposure compensation.
* value into account.
*
* Param:
* inputY - The input luminance value.
* Return:
* The luminance value after adjusting the exposure compensation.
*/
inline uint8_t changeExposure(const uint8_t& inputY) const {
return static_cast<uint8_t>(clamp(static_cast<float>(inputY) *
mExposureCompensation));
}
/** Computes the pixel value in YUV space after adjusting to the current
* white balance mode.
*/
void changeWhiteBalance(uint8_t& y, uint8_t& u, uint8_t& v) const;
/****************************************************************************
* Worker thread management.
* Typicaly when emulated camera device starts capturing frames from the
@@ -478,6 +518,10 @@ protected:
/* Exposure compensation value */
float mExposureCompensation;
float* mWhiteBalanceScale;
DefaultKeyedVector<String8, float*> mSupportedWhiteBalanceScale;
/* Defines possible states of the emulated camera device object.
*/
enum EmulatedCameraDeviceState {

27
tools/emulator/system/camera/EmulatedFakeCamera.cpp
View File

@@ -61,6 +61,33 @@ status_t EmulatedFakeCamera::Initialize()
gEmulatedCameraFactory.getFakeCameraOrientation());
res = EmulatedCamera::Initialize();
mParameters.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "6");
mParameters.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-6");
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5");
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0");
LOGV("Set camera supported exposure values");
// Sets the white balance modes and the device-dependent scale factors.
mFakeCameraDevice.initializeWhiteBalanceModes(
CameraParameters::WHITE_BALANCE_INCANDESCENT, 1.38f, 0.60f);
mFakeCameraDevice.initializeWhiteBalanceModes(
CameraParameters::WHITE_BALANCE_DAYLIGHT, 1.09f, 0.92f);
mFakeCameraDevice.initializeWhiteBalanceModes(
CameraParameters::WHITE_BALANCE_TWILIGHT, 0.92f, 1.22f);
char supported_white_balance[1024];
snprintf(supported_white_balance, sizeof(supported_white_balance),
"%s,%s,%s,%s",
mParameters.get(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE),
CameraParameters::WHITE_BALANCE_INCANDESCENT,
CameraParameters::WHITE_BALANCE_DAYLIGHT,
CameraParameters::WHITE_BALANCE_TWILIGHT);
mParameters.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE,
supported_white_balance);
LOGV("Set camera supported white balance modes");
if (res != NO_ERROR) {
return res;
}

17
tools/emulator/system/camera/EmulatedFakeCameraDevice.cpp
View File

@@ -46,11 +46,11 @@ EmulatedFakeCameraDevice::EmulatedFakeCameraDevice(EmulatedFakeCamera* camera_ha
{
// Makes the image with the original exposure compensation darker.
// So the effects of changing the exposure compensation can be seen.
mBlackYUV.Y = mBlackYUV.Y / 4;
mWhiteYUV.Y = mWhiteYUV.Y / 4;
mRedYUV.Y = mRedYUV.Y / 4;
mGreenYUV.Y = mGreenYUV.Y / 4;
mBlueYUV.Y = mBlueYUV.Y / 4;
mBlackYUV.Y = mBlackYUV.Y / 2;
mWhiteYUV.Y = mWhiteYUV.Y / 2;
mRedYUV.Y = mRedYUV.Y / 2;
mGreenYUV.Y = mGreenYUV.Y / 2;
mBlueYUV.Y = mBlueYUV.Y / 2;
}
EmulatedFakeCameraDevice::~EmulatedFakeCameraDevice()
@@ -256,6 +256,9 @@ void EmulatedFakeCameraDevice::drawCheckerboard()
uint8_t* U = U_pos;
uint8_t* V = V_pos;
YUVPixel adjustedWhite = YUVPixel(mWhiteYUV);
changeWhiteBalance(adjustedWhite.Y, adjustedWhite.U, adjustedWhite.V);
for(int y = 0; y < mFrameHeight; y++) {
int countx = checkxremainder;
bool current = black;
@@ -263,7 +266,7 @@ void EmulatedFakeCameraDevice::drawCheckerboard()
if (current) {
mBlackYUV.get(Y, U, V);
} else {
mWhiteYUV.get(Y, U, V);
adjustedWhite.get(Y, U, V);
}
*Y = changeExposure(*Y);
Y[1] = *Y;
@@ -407,7 +410,7 @@ int EmulatedFakeCameraDevice::rotateFrame()
}
} else if (mCurrentFrameType == 0) {
LOGD("********** Rotated to the CHECKERBOARD frame **********");
} else {
} else if (mCurrentFrameType == 1) {
LOGD("********** Rotated to the STRIPED frame **********");
}
}

5
tools/emulator/system/camera/EmulatedFakeCameraDevice.h
View File

@@ -99,6 +99,7 @@ protected:
***************************************************************************/
private:
/* Draws a black and white checker board in the current frame buffer. */
void drawCheckerboard();
@@ -110,10 +111,6 @@ private:
*/
void drawSquare(int x, int y, int size, const YUVPixel* color);
inline uint8_t changeExposure(uint8_t inputY) {
return static_cast<uint8_t>(static_cast<float>(inputY) *
mExposureCompensation);
}
#if EFCD_ROTATE_FRAME
void drawSolid(YUVPixel* color);
void drawStripes();