You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
230 lines
7.1 KiB
230 lines
7.1 KiB
/*
|
|
* Copyright (C) 2012 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.
|
|
*/
|
|
|
|
/**
|
|
* The Scene class implements a simple physical simulation of a scene, using the
|
|
* CIE 1931 colorspace to represent light in physical units (lux).
|
|
*
|
|
* It's fairly approximate, but does provide a scene with realistic widely
|
|
* variable illumination levels and colors over time.
|
|
*
|
|
*/
|
|
|
|
#ifndef HW_EMULATOR_CAMERA2_SCENE_H
|
|
#define HW_EMULATOR_CAMERA2_SCENE_H
|
|
|
|
#include "android/frameworks/sensorservice/1.0/ISensorManager.h"
|
|
#include "android/frameworks/sensorservice/1.0/types.h"
|
|
#include "utils/Timers.h"
|
|
|
|
namespace android {
|
|
|
|
using ::android::frameworks::sensorservice::V1_0::IEventQueue;
|
|
using ::android::frameworks::sensorservice::V1_0::IEventQueueCallback;
|
|
using ::android::hardware::sensors::V1_0::Event;
|
|
using ::android::hardware::Return;
|
|
using ::android::hardware::Void;
|
|
|
|
class EmulatedScene : public RefBase {
|
|
public:
|
|
EmulatedScene(int sensor_width_px, int sensor_height_px,
|
|
float sensor_sensitivity, int sensor_orientation,
|
|
bool is_front_facing);
|
|
~EmulatedScene();
|
|
|
|
void InitializeSensorQueue();
|
|
|
|
void Initialize(int sensor_width_px, int sensor_height_px,
|
|
float sensor_sensitivity);
|
|
|
|
// Set the filter coefficients for the red, green, and blue filters on the
|
|
// sensor. Used as an optimization to pre-calculate various illuminance
|
|
// values. Two different green filters can be provided, to account for
|
|
// possible cross-talk on a Bayer sensor. Must be called before
|
|
// calculateScene.
|
|
void SetColorFilterXYZ(float rX, float rY, float rZ, float grX, float grY,
|
|
float grZ, float gbX, float gbY, float gbZ, float bX,
|
|
float bY, float bZ);
|
|
|
|
// Set time of day (24-hour clock). This controls the general light levels
|
|
// in the scene. Must be called before calculateScene.
|
|
void SetHour(int hour);
|
|
// Get current hour
|
|
int GetHour() const;
|
|
|
|
// Set the duration of exposure for determining luminous exposure.
|
|
// Must be called before calculateScene
|
|
void SetExposureDuration(float seconds);
|
|
|
|
// Set test pattern mode; this draws a solid-color image set to the color
|
|
// defined by test pattern data
|
|
void SetTestPattern(bool enabled);
|
|
void SetTestPatternData(uint32_t data[4]);
|
|
|
|
// Calculate scene information for current hour and the time offset since
|
|
// the hour. Resets pixel readout location to 0,0
|
|
void CalculateScene(nsecs_t time, int32_t handshake_divider);
|
|
|
|
// Set sensor pixel readout location.
|
|
void SetReadoutPixel(int x, int y);
|
|
|
|
// Get sensor response in physical units (electrons) for light hitting the
|
|
// current readout pixel, after passing through color filters. The readout
|
|
// pixel will be auto-incremented horizontally. The returned array can be
|
|
// indexed with ColorChannels.
|
|
const uint32_t* GetPixelElectrons();
|
|
|
|
// Get sensor response in physical units (electrons) for light hitting the
|
|
// current readout pixel, after passing through color filters. The readout
|
|
// pixel will be auto-incremented vertically. The returned array can be
|
|
// indexed with ColorChannels.
|
|
const uint32_t* GetPixelElectronsColumn();
|
|
|
|
enum ColorChannels { R = 0, Gr, Gb, B, Y, Cb, Cr, NUM_CHANNELS };
|
|
|
|
static const int kSceneWidth = 20;
|
|
static const int kSceneHeight = 20;
|
|
|
|
private:
|
|
class SensorHandler : public IEventQueueCallback {
|
|
public:
|
|
SensorHandler(wp<EmulatedScene> scene) : scene_(scene) {
|
|
}
|
|
|
|
// IEventQueueCallback interface
|
|
Return<void> onEvent(const Event& e) override;
|
|
|
|
private:
|
|
wp<EmulatedScene> scene_;
|
|
};
|
|
|
|
void InitiliazeSceneRotation(bool clock_wise);
|
|
|
|
int32_t sensor_handle_;
|
|
sp<IEventQueue> sensor_event_queue_;
|
|
std::atomic_uint32_t screen_rotation_;
|
|
uint8_t scene_rot0_[kSceneWidth*kSceneHeight];
|
|
uint8_t scene_rot90_[kSceneWidth*kSceneHeight];
|
|
uint8_t scene_rot180_[kSceneWidth*kSceneHeight];
|
|
uint8_t scene_rot270_[kSceneWidth*kSceneHeight];
|
|
uint8_t *current_scene_;
|
|
int32_t sensor_orientation_;
|
|
bool is_front_facing_;
|
|
|
|
// Sensor color filtering coefficients in XYZ
|
|
float filter_r_[3];
|
|
float filter_gr_[3];
|
|
float filter_gb_[3];
|
|
float filter_b_[3];
|
|
|
|
int offset_x_, offset_y_;
|
|
int map_div_;
|
|
|
|
int handshake_x_, handshake_y_;
|
|
|
|
int sensor_width_;
|
|
int sensor_height_;
|
|
int current_x_;
|
|
int current_y_;
|
|
int sub_x_;
|
|
int sub_y_;
|
|
int scene_x_;
|
|
int scene_y_;
|
|
int scene_idx_;
|
|
uint32_t* current_scene_material_;
|
|
|
|
int hour_;
|
|
float exposure_duration_;
|
|
float sensor_sensitivity_; // electrons per lux-second
|
|
|
|
bool test_pattern_mode_; // SOLID_COLOR only
|
|
uint32_t test_pattern_data_[4];
|
|
|
|
enum Materials {
|
|
GRASS = 0,
|
|
GRASS_SHADOW,
|
|
HILL,
|
|
WALL,
|
|
ROOF,
|
|
DOOR,
|
|
CHIMNEY,
|
|
WINDOW,
|
|
SUN,
|
|
SKY,
|
|
MOON,
|
|
NUM_MATERIALS
|
|
};
|
|
|
|
uint32_t current_colors_[NUM_MATERIALS * NUM_CHANNELS];
|
|
|
|
/**
|
|
* Constants for scene definition. These are various degrees of approximate.
|
|
*/
|
|
|
|
// Fake handshake parameters. Two shake frequencies per axis, plus magnitude
|
|
// as a fraction of a scene tile, and relative magnitudes for the frequencies
|
|
static const float kHorizShakeFreq1;
|
|
static const float kHorizShakeFreq2;
|
|
static const float kVertShakeFreq1;
|
|
static const float kVertShakeFreq2;
|
|
static const float kFreq1Magnitude;
|
|
static const float kFreq2Magnitude;
|
|
|
|
static const float kShakeFraction;
|
|
|
|
// Aperture of imaging lens
|
|
static const float kAperture;
|
|
|
|
// Sun, moon illuminance levels in 2-hour increments. These don't match any
|
|
// real day anywhere.
|
|
static const uint32_t kTimeStep = 2;
|
|
static const float kSunlight[];
|
|
static const float kMoonlight[];
|
|
static const int kSunOverhead;
|
|
static const int kMoonOverhead;
|
|
|
|
// Illumination levels for various conditions, in lux
|
|
static const float kDirectSunIllum;
|
|
static const float kDaylightShadeIllum;
|
|
static const float kSunsetIllum;
|
|
static const float kTwilightIllum;
|
|
static const float kFullMoonIllum;
|
|
static const float kClearNightIllum;
|
|
static const float kStarIllum;
|
|
static const float kLivingRoomIllum;
|
|
|
|
// Chromaticity of various illumination sources
|
|
static const float kIncandescentXY[2];
|
|
static const float kDirectSunlightXY[2];
|
|
static const float kDaylightXY[2];
|
|
static const float kNoonSkyXY[2];
|
|
static const float kMoonlightXY[2];
|
|
static const float kSunsetXY[2];
|
|
|
|
static const uint8_t kSelfLit;
|
|
static const uint8_t kShadowed;
|
|
static const uint8_t kSky;
|
|
|
|
static const float kMaterials_xyY[NUM_MATERIALS][3];
|
|
static const uint8_t kMaterialsFlags[NUM_MATERIALS];
|
|
|
|
static const uint8_t kScene[];
|
|
};
|
|
|
|
} // namespace android
|
|
|
|
#endif // HW_EMULATOR_CAMERA2_SCENE_H
|