Home | History | Annotate | Download | only in fake-pipeline2 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 //#define LOG_NDEBUG 0
     18 #define LOG_TAG "EmulatedCamera_Scene"
     19 #include <utils/Log.h>
     20 #include <stdlib.h>
     21 #include <cmath>
     22 #include "Scene.h"
     23 
     24 // TODO: This should probably be done host-side in OpenGL for speed and better
     25 // quality
     26 
     27 namespace android {
     28 
     29 // Define single-letter shortcuts for scene definition, for directly indexing
     30 // mCurrentColors
     31 #define G (Scene::GRASS * Scene::NUM_CHANNELS)
     32 #define S (Scene::GRASS_SHADOW * Scene::NUM_CHANNELS)
     33 #define H (Scene::HILL * Scene::NUM_CHANNELS)
     34 #define W (Scene::WALL * Scene::NUM_CHANNELS)
     35 #define R (Scene::ROOF * Scene::NUM_CHANNELS)
     36 #define D (Scene::DOOR * Scene::NUM_CHANNELS)
     37 #define C (Scene::CHIMNEY * Scene::NUM_CHANNELS)
     38 #define I (Scene::WINDOW * Scene::NUM_CHANNELS)
     39 #define U (Scene::SUN * Scene::NUM_CHANNELS)
     40 #define K (Scene::SKY * Scene::NUM_CHANNELS)
     41 #define M (Scene::MOON * Scene::NUM_CHANNELS)
     42 
     43 const int Scene::kSceneWidth = 20;
     44 const int Scene::kSceneHeight = 20;
     45 
     46 const uint8_t Scene::kScene[Scene::kSceneWidth * Scene::kSceneHeight] = {
     47     //      5         10        15        20
     48     K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
     49     K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
     50     K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
     51     K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
     52     K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, // 5
     53     K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
     54     K,K,K,K,K,K,K,K,H,H,H,H,H,H,H,H,H,H,H,H,
     55     K,K,K,K,K,K,K,K,H,H,H,H,H,H,H,C,C,H,H,H,
     56     K,K,K,K,K,K,H,H,H,H,H,H,H,H,H,C,C,H,H,H,
     57     H,K,K,K,K,K,H,R,R,R,R,R,R,R,R,R,R,R,R,H, // 10
     58     H,K,K,K,K,H,H,R,R,R,R,R,R,R,R,R,R,R,R,H,
     59     H,H,H,K,K,H,H,R,R,R,R,R,R,R,R,R,R,R,R,H,
     60     H,H,H,K,K,H,H,H,W,W,W,W,W,W,W,W,W,W,H,H,
     61     S,S,S,G,G,S,S,S,W,W,W,W,W,W,W,W,W,W,S,S,
     62     S,G,G,G,G,S,S,S,W,I,I,W,D,D,W,I,I,W,S,S, // 15
     63     G,G,G,G,G,G,S,S,W,I,I,W,D,D,W,I,I,W,S,S,
     64     G,G,G,G,G,G,G,G,W,W,W,W,D,D,W,W,W,W,G,G,
     65     G,G,G,G,G,G,G,G,W,W,W,W,D,D,W,W,W,W,G,G,
     66     G,G,G,G,G,G,G,G,S,S,S,S,S,S,S,S,S,S,G,G,
     67     G,G,G,G,G,G,G,G,S,S,S,S,S,S,S,S,S,S,G,G, // 20
     68     //      5         10        15        20
     69 };
     70 
     71 #undef G
     72 #undef S
     73 #undef H
     74 #undef W
     75 #undef R
     76 #undef D
     77 #undef C
     78 #undef I
     79 #undef U
     80 #undef K
     81 #undef M
     82 
     83 Scene::Scene(
     84     int sensorWidthPx,
     85     int sensorHeightPx,
     86     float sensorSensitivity):
     87         mSensorWidth(sensorWidthPx),
     88         mSensorHeight(sensorHeightPx),
     89         mHour(12),
     90         mExposureDuration(0.033f),
     91         mSensorSensitivity(sensorSensitivity)
     92 {
     93     // Map scene to sensor pixels
     94     if (mSensorWidth > mSensorHeight) {
     95         mMapDiv = (mSensorWidth / (kSceneWidth + 1) ) + 1;
     96     } else {
     97         mMapDiv = (mSensorHeight / (kSceneHeight + 1) ) + 1;
     98     }
     99     mOffsetX = (kSceneWidth * mMapDiv - mSensorWidth) / 2;
    100     mOffsetY = (kSceneHeight * mMapDiv - mSensorHeight) / 2;
    101 
    102     // Assume that sensor filters are sRGB primaries to start
    103     mFilterR[0]  =  3.2406f; mFilterR[1]  = -1.5372f; mFilterR[2]  = -0.4986f;
    104     mFilterGr[0] = -0.9689f; mFilterGr[1] =  1.8758f; mFilterGr[2] =  0.0415f;
    105     mFilterGb[0] = -0.9689f; mFilterGb[1] =  1.8758f; mFilterGb[2] =  0.0415f;
    106     mFilterB[0]  =  0.0557f; mFilterB[1]  = -0.2040f; mFilterB[2]  =  1.0570f;
    107 
    108 
    109 }
    110 
    111 Scene::~Scene() {
    112 }
    113 
    114 void Scene::setColorFilterXYZ(
    115         float rX, float rY, float rZ,
    116         float grX, float grY, float grZ,
    117         float gbX, float gbY, float gbZ,
    118         float bX, float bY, float bZ) {
    119     mFilterR[0]  = rX;  mFilterR[1]  = rY;  mFilterR[2]  = rZ;
    120     mFilterGr[0] = grX; mFilterGr[1] = grY; mFilterGr[2] = grZ;
    121     mFilterGb[0] = gbX; mFilterGb[1] = gbY; mFilterGb[2] = gbZ;
    122     mFilterB[0]  = bX;  mFilterB[1]  = bY;  mFilterB[2]  = bZ;
    123 }
    124 
    125 void Scene::setHour(int hour) {
    126     ALOGV("Hour set to: %d", hour);
    127     mHour = hour % 24;
    128 }
    129 
    130 int Scene::getHour() {
    131     return mHour;
    132 }
    133 
    134 void Scene::setExposureDuration(float seconds) {
    135     mExposureDuration = seconds;
    136 }
    137 
    138 void Scene::calculateScene(nsecs_t time) {
    139     // Calculate time fractions for interpolation
    140     int timeIdx = mHour / kTimeStep;
    141     int nextTimeIdx = (timeIdx + 1) % (24 / kTimeStep);
    142     const nsecs_t kOneHourInNsec = 1e9 * 60 * 60;
    143     nsecs_t timeSinceIdx = (mHour - timeIdx * kTimeStep) * kOneHourInNsec + time;
    144     float timeFrac = timeSinceIdx / (float)(kOneHourInNsec * kTimeStep);
    145 
    146     // Determine overall sunlight levels
    147     float sunLux =
    148             kSunlight[timeIdx] * (1 - timeFrac) +
    149             kSunlight[nextTimeIdx] * timeFrac;
    150     ALOGV("Sun lux: %f", sunLux);
    151 
    152     float sunShadeLux = sunLux * (kDaylightShadeIllum / kDirectSunIllum);
    153 
    154     // Determine sun/shade illumination chromaticity
    155     float currentSunXY[2];
    156     float currentShadeXY[2];
    157 
    158     const float *prevSunXY, *nextSunXY;
    159     const float *prevShadeXY, *nextShadeXY;
    160     if (kSunlight[timeIdx] == kSunsetIllum ||
    161             kSunlight[timeIdx] == kTwilightIllum) {
    162         prevSunXY = kSunsetXY;
    163         prevShadeXY = kSunsetXY;
    164     } else {
    165         prevSunXY = kDirectSunlightXY;
    166         prevShadeXY = kDaylightXY;
    167     }
    168     if (kSunlight[nextTimeIdx] == kSunsetIllum ||
    169             kSunlight[nextTimeIdx] == kTwilightIllum) {
    170         nextSunXY = kSunsetXY;
    171         nextShadeXY = kSunsetXY;
    172     } else {
    173         nextSunXY = kDirectSunlightXY;
    174         nextShadeXY = kDaylightXY;
    175     }
    176     currentSunXY[0] = prevSunXY[0] * (1 - timeFrac) +
    177             nextSunXY[0] * timeFrac;
    178     currentSunXY[1] = prevSunXY[1] * (1 - timeFrac) +
    179             nextSunXY[1] * timeFrac;
    180 
    181     currentShadeXY[0] = prevShadeXY[0] * (1 - timeFrac) +
    182             nextShadeXY[0] * timeFrac;
    183     currentShadeXY[1] = prevShadeXY[1] * (1 - timeFrac) +
    184             nextShadeXY[1] * timeFrac;
    185 
    186     ALOGV("Sun XY: %f, %f, Shade XY: %f, %f",
    187             currentSunXY[0], currentSunXY[1],
    188             currentShadeXY[0], currentShadeXY[1]);
    189 
    190     // Converting for xyY to XYZ:
    191     // X = Y / y * x
    192     // Y = Y
    193     // Z = Y / y * (1 - x - y);
    194     float sunXYZ[3] = {
    195         sunLux / currentSunXY[1] * currentSunXY[0],
    196         sunLux,
    197         sunLux / currentSunXY[1] *
    198         (1 - currentSunXY[0] - currentSunXY[1])
    199     };
    200     float sunShadeXYZ[3] = {
    201         sunShadeLux / currentShadeXY[1] * currentShadeXY[0],
    202         sunShadeLux,
    203         sunShadeLux / currentShadeXY[1] *
    204         (1 - currentShadeXY[0] - currentShadeXY[1])
    205     };
    206     ALOGV("Sun XYZ: %f, %f, %f",
    207             sunXYZ[0], sunXYZ[1], sunXYZ[2]);
    208     ALOGV("Sun shade XYZ: %f, %f, %f",
    209             sunShadeXYZ[0], sunShadeXYZ[1], sunShadeXYZ[2]);
    210 
    211     // Determine moonlight levels
    212     float moonLux =
    213             kMoonlight[timeIdx] * (1 - timeFrac) +
    214             kMoonlight[nextTimeIdx] * timeFrac;
    215     float moonShadeLux = moonLux * (kDaylightShadeIllum / kDirectSunIllum);
    216 
    217     float moonXYZ[3] = {
    218         moonLux / kMoonlightXY[1] * kMoonlightXY[0],
    219         moonLux,
    220         moonLux / kMoonlightXY[1] *
    221         (1 - kMoonlightXY[0] - kMoonlightXY[1])
    222     };
    223     float moonShadeXYZ[3] = {
    224         moonShadeLux / kMoonlightXY[1] * kMoonlightXY[0],
    225         moonShadeLux,
    226         moonShadeLux / kMoonlightXY[1] *
    227         (1 - kMoonlightXY[0] - kMoonlightXY[1])
    228     };
    229 
    230     // Determine starlight level
    231     const float kClearNightXYZ[3] = {
    232         kClearNightIllum / kMoonlightXY[1] * kMoonlightXY[0],
    233         kClearNightIllum,
    234         kClearNightIllum / kMoonlightXY[1] *
    235             (1 - kMoonlightXY[0] - kMoonlightXY[1])
    236     };
    237 
    238     // Calculate direct and shaded light
    239     float directIllumXYZ[3] = {
    240         sunXYZ[0] + moonXYZ[0] + kClearNightXYZ[0],
    241         sunXYZ[1] + moonXYZ[1] + kClearNightXYZ[1],
    242         sunXYZ[2] + moonXYZ[2] + kClearNightXYZ[2],
    243     };
    244 
    245     float shadeIllumXYZ[3] = {
    246         kClearNightXYZ[0],
    247         kClearNightXYZ[1],
    248         kClearNightXYZ[2]
    249     };
    250 
    251     shadeIllumXYZ[0] += (mHour < kSunOverhead) ? sunXYZ[0] : sunShadeXYZ[0];
    252     shadeIllumXYZ[1] += (mHour < kSunOverhead) ? sunXYZ[1] : sunShadeXYZ[1];
    253     shadeIllumXYZ[2] += (mHour < kSunOverhead) ? sunXYZ[2] : sunShadeXYZ[2];
    254 
    255     // Moon up period covers 23->0 transition, shift for simplicity
    256     int adjHour = (mHour + 12) % 24;
    257     int adjMoonOverhead = (kMoonOverhead + 12 ) % 24;
    258     shadeIllumXYZ[0] += (adjHour < adjMoonOverhead) ?
    259             moonXYZ[0] : moonShadeXYZ[0];
    260     shadeIllumXYZ[1] += (adjHour < adjMoonOverhead) ?
    261             moonXYZ[1] : moonShadeXYZ[1];
    262     shadeIllumXYZ[2] += (adjHour < adjMoonOverhead) ?
    263             moonXYZ[2] : moonShadeXYZ[2];
    264 
    265     ALOGV("Direct XYZ: %f, %f, %f",
    266             directIllumXYZ[0],directIllumXYZ[1],directIllumXYZ[2]);
    267     ALOGV("Shade XYZ: %f, %f, %f",
    268             shadeIllumXYZ[0], shadeIllumXYZ[1], shadeIllumXYZ[2]);
    269 
    270     for (int i = 0; i < NUM_MATERIALS; i++) {
    271         // Converting for xyY to XYZ:
    272         // X = Y / y * x
    273         // Y = Y
    274         // Z = Y / y * (1 - x - y);
    275         float matXYZ[3] = {
    276             kMaterials_xyY[i][2] / kMaterials_xyY[i][1] *
    277               kMaterials_xyY[i][0],
    278             kMaterials_xyY[i][2],
    279             kMaterials_xyY[i][2] / kMaterials_xyY[i][1] *
    280               (1 - kMaterials_xyY[i][0] - kMaterials_xyY[i][1])
    281         };
    282 
    283         if (kMaterialsFlags[i] == 0 || kMaterialsFlags[i] & kSky) {
    284             matXYZ[0] *= directIllumXYZ[0];
    285             matXYZ[1] *= directIllumXYZ[1];
    286             matXYZ[2] *= directIllumXYZ[2];
    287         } else if (kMaterialsFlags[i] & kShadowed) {
    288             matXYZ[0] *= shadeIllumXYZ[0];
    289             matXYZ[1] *= shadeIllumXYZ[1];
    290             matXYZ[2] *= shadeIllumXYZ[2];
    291         } // else if (kMaterialsFlags[i] * kSelfLit), do nothing
    292 
    293         ALOGV("Mat %d XYZ: %f, %f, %f", i, matXYZ[0], matXYZ[1], matXYZ[2]);
    294         float luxToElectrons = mSensorSensitivity * mExposureDuration /
    295                 (kAperture * kAperture);
    296         mCurrentColors[i*NUM_CHANNELS + 0] =
    297                 (mFilterR[0] * matXYZ[0] +
    298                  mFilterR[1] * matXYZ[1] +
    299                  mFilterR[2] * matXYZ[2])
    300                 * luxToElectrons;
    301         mCurrentColors[i*NUM_CHANNELS + 1] =
    302                 (mFilterGr[0] * matXYZ[0] +
    303                  mFilterGr[1] * matXYZ[1] +
    304                  mFilterGr[2] * matXYZ[2])
    305                 * luxToElectrons;
    306         mCurrentColors[i*NUM_CHANNELS + 2] =
    307                 (mFilterGb[0] * matXYZ[0] +
    308                  mFilterGb[1] * matXYZ[1] +
    309                  mFilterGb[2] * matXYZ[2])
    310                 * luxToElectrons;
    311         mCurrentColors[i*NUM_CHANNELS + 3] =
    312                 (mFilterB[0] * matXYZ[0] +
    313                  mFilterB[1] * matXYZ[1] +
    314                  mFilterB[2] * matXYZ[2])
    315                 * luxToElectrons;
    316 
    317         ALOGV("Color %d RGGB: %d, %d, %d, %d", i,
    318                 mCurrentColors[i*NUM_CHANNELS + 0],
    319                 mCurrentColors[i*NUM_CHANNELS + 1],
    320                 mCurrentColors[i*NUM_CHANNELS + 2],
    321                 mCurrentColors[i*NUM_CHANNELS + 3]);
    322     }
    323     // Shake viewpoint; horizontal and vertical sinusoids at roughly
    324     // human handshake frequencies
    325     mHandshakeX =
    326             ( kFreq1Magnitude * std::sin(kHorizShakeFreq1 * timeSinceIdx) +
    327               kFreq2Magnitude * std::sin(kHorizShakeFreq2 * timeSinceIdx) ) *
    328             mMapDiv * kShakeFraction;
    329 
    330     mHandshakeY =
    331             ( kFreq1Magnitude * std::sin(kVertShakeFreq1 * timeSinceIdx) +
    332               kFreq2Magnitude * std::sin(kVertShakeFreq2 * timeSinceIdx) ) *
    333             mMapDiv * kShakeFraction;
    334 
    335     // Set starting pixel
    336     setReadoutPixel(0,0);
    337 }
    338 
    339 void Scene::setReadoutPixel(int x, int y) {
    340     mCurrentX = x;
    341     mCurrentY = y;
    342     mSubX = (x + mOffsetX + mHandshakeX) % mMapDiv;
    343     mSubY = (y + mOffsetY + mHandshakeY) % mMapDiv;
    344     mSceneX = (x + mOffsetX + mHandshakeX) / mMapDiv;
    345     mSceneY = (y + mOffsetY + mHandshakeY) / mMapDiv;
    346     mSceneIdx = mSceneY * kSceneWidth + mSceneX;
    347     mCurrentSceneMaterial = &(mCurrentColors[kScene[mSceneIdx]]);
    348 }
    349 
    350 const uint32_t* Scene::getPixelElectrons() {
    351     const uint32_t *pixel = mCurrentSceneMaterial;
    352     mCurrentX++;
    353     mSubX++;
    354     if (mCurrentX >= mSensorWidth) {
    355         mCurrentX = 0;
    356         mCurrentY++;
    357         if (mCurrentY >= mSensorHeight) mCurrentY = 0;
    358         setReadoutPixel(mCurrentX, mCurrentY);
    359     } else if (mSubX > mMapDiv) {
    360         mSceneIdx++;
    361         mSceneX++;
    362         mCurrentSceneMaterial = &(mCurrentColors[kScene[mSceneIdx]]);
    363         mSubX = 0;
    364     }
    365     return pixel;
    366 }
    367 
    368 // Handshake model constants.
    369 // Frequencies measured in a nanosecond timebase
    370 const float Scene::kHorizShakeFreq1 = 2 * M_PI * 2  / 1e9; // 2 Hz
    371 const float Scene::kHorizShakeFreq2 = 2 * M_PI * 13 / 1e9; // 13 Hz
    372 const float Scene::kVertShakeFreq1  = 2 * M_PI * 3  / 1e9; // 3 Hz
    373 const float Scene::kVertShakeFreq2  = 2 * M_PI * 11 / 1e9; // 1 Hz
    374 const float Scene::kFreq1Magnitude  = 5;
    375 const float Scene::kFreq2Magnitude  = 1;
    376 const float Scene::kShakeFraction   = 0.03; // As a fraction of a scene tile
    377 
    378 // RGB->YUV, Jpeg standard
    379 const float Scene::kRgb2Yuv[12] = {
    380        0.299f,    0.587f,    0.114f,    0.f,
    381     -0.16874f, -0.33126f,      0.5f, -128.f,
    382          0.5f, -0.41869f, -0.08131f, -128.f,
    383 };
    384 
    385 // Aperture of imaging lens
    386 const float Scene::kAperture = 2.8;
    387 
    388 // Sun illumination levels through the day
    389 const float Scene::kSunlight[24/kTimeStep] =
    390 {
    391     0, // 00:00
    392     0,
    393     0,
    394     kTwilightIllum, // 06:00
    395     kDirectSunIllum,
    396     kDirectSunIllum,
    397     kDirectSunIllum, // 12:00
    398     kDirectSunIllum,
    399     kDirectSunIllum,
    400     kSunsetIllum, // 18:00
    401     kTwilightIllum,
    402     0
    403 };
    404 
    405 // Moon illumination levels through the day
    406 const float Scene::kMoonlight[24/kTimeStep] =
    407 {
    408     kFullMoonIllum, // 00:00
    409     kFullMoonIllum,
    410     0,
    411     0, // 06:00
    412     0,
    413     0,
    414     0, // 12:00
    415     0,
    416     0,
    417     0, // 18:00
    418     0,
    419     kFullMoonIllum
    420 };
    421 
    422 const int Scene::kSunOverhead = 12;
    423 const int Scene::kMoonOverhead = 0;
    424 
    425 // Used for sun illumination levels
    426 const float Scene::kDirectSunIllum     = 100000;
    427 const float Scene::kSunsetIllum        = 400;
    428 const float Scene::kTwilightIllum      = 4;
    429 // Used for moon illumination levels
    430 const float Scene::kFullMoonIllum      = 1;
    431 // Other illumination levels
    432 const float Scene::kDaylightShadeIllum = 20000;
    433 const float Scene::kClearNightIllum    = 2e-3;
    434 const float Scene::kStarIllum          = 2e-6;
    435 const float Scene::kLivingRoomIllum    = 50;
    436 
    437 const float Scene::kIncandescentXY[2]   = { 0.44757f, 0.40745f};
    438 const float Scene::kDirectSunlightXY[2] = { 0.34842f, 0.35161f};
    439 const float Scene::kDaylightXY[2]       = { 0.31271f, 0.32902f};
    440 const float Scene::kNoonSkyXY[2]        = { 0.346f,   0.359f};
    441 const float Scene::kMoonlightXY[2]      = { 0.34842f, 0.35161f};
    442 const float Scene::kSunsetXY[2]         = { 0.527f,   0.413f};
    443 
    444 const uint8_t Scene::kSelfLit  = 0x01;
    445 const uint8_t Scene::kShadowed = 0x02;
    446 const uint8_t Scene::kSky      = 0x04;
    447 
    448 // For non-self-lit materials, the Y component is normalized with 1=full
    449 // reflectance; for self-lit materials, it's the constant illuminance in lux.
    450 const float Scene::kMaterials_xyY[Scene::NUM_MATERIALS][3] = {
    451     { 0.3688f, 0.4501f, .1329f }, // GRASS
    452     { 0.3688f, 0.4501f, .1329f }, // GRASS_SHADOW
    453     { 0.3986f, 0.5002f, .4440f }, // HILL
    454     { 0.3262f, 0.5040f, .2297f }, // WALL
    455     { 0.4336f, 0.3787f, .1029f }, // ROOF
    456     { 0.3316f, 0.2544f, .0639f }, // DOOR
    457     { 0.3425f, 0.3577f, .0887f }, // CHIMNEY
    458     { kIncandescentXY[0], kIncandescentXY[1], kLivingRoomIllum }, // WINDOW
    459     { kDirectSunlightXY[0], kDirectSunlightXY[1], kDirectSunIllum }, // SUN
    460     { kNoonSkyXY[0], kNoonSkyXY[1], kDaylightShadeIllum / kDirectSunIllum }, // SKY
    461     { kMoonlightXY[0], kMoonlightXY[1], kFullMoonIllum } // MOON
    462 };
    463 
    464 const uint8_t Scene::kMaterialsFlags[Scene::NUM_MATERIALS] = {
    465     0,
    466     kShadowed,
    467     kShadowed,
    468     kShadowed,
    469     kShadowed,
    470     kShadowed,
    471     kShadowed,
    472     kSelfLit,
    473     kSelfLit,
    474     kSky,
    475     kSelfLit,
    476 };
    477 
    478 } // namespace android
    479