Home | History | Annotate | Download | only in camera 
      1 /*
      2  * Copyright (C) 2011 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 /*
     18  * Contains implementation of a class EmulatedFakeCameraDevice that encapsulates
     19  * fake camera device.
     20  */
     21 
     22 #define LOG_NDEBUG 0
     23 #define LOG_TAG "EmulatedCamera_FakeDevice"
     24 #include <cutils/log.h>
     25 #include "EmulatedFakeCamera.h"
     26 #include "EmulatedFakeCameraDevice.h"
     27 
     28 namespace android {
     29 
     30 EmulatedFakeCameraDevice::EmulatedFakeCameraDevice(EmulatedFakeCamera* camera_hal)
     31     : EmulatedCameraDevice(camera_hal),
     32       mBlackYUV(kBlack32),
     33       mWhiteYUV(kWhite32),
     34       mRedYUV(kRed8),
     35       mGreenYUV(kGreen8),
     36       mBlueYUV(kBlue8),
     37       mLastRedrawn(0),
     38       mCheckX(0),
     39       mCheckY(0),
     40       mCcounter(0)
     41 #if EFCD_ROTATE_FRAME
     42       , mLastRotatedAt(0),
     43         mCurrentFrameType(0),
     44         mCurrentColor(&mWhiteYUV)
     45 #endif  // EFCD_ROTATE_FRAME
     46 {
     47     // Makes the image with the original exposure compensation darker.
     48     // So the effects of changing the exposure compensation can be seen.
     49     mBlackYUV.Y = mBlackYUV.Y / 2;
     50     mWhiteYUV.Y = mWhiteYUV.Y / 2;
     51     mRedYUV.Y = mRedYUV.Y / 2;
     52     mGreenYUV.Y = mGreenYUV.Y / 2;
     53     mBlueYUV.Y = mBlueYUV.Y / 2;
     54 }
     55 
     56 EmulatedFakeCameraDevice::~EmulatedFakeCameraDevice()
     57 {
     58 }
     59 
     60 /****************************************************************************
     61  * Emulated camera device abstract interface implementation.
     62  ***************************************************************************/
     63 
     64 status_t EmulatedFakeCameraDevice::connectDevice()
     65 {
     66     ALOGV("%s", __FUNCTION__);
     67 
     68     Mutex::Autolock locker(&mObjectLock);
     69     if (!isInitialized()) {
     70         ALOGE("%s: Fake camera device is not initialized.", __FUNCTION__);
     71         return EINVAL;
     72     }
     73     if (isConnected()) {
     74         ALOGW("%s: Fake camera device is already connected.", __FUNCTION__);
     75         return NO_ERROR;
     76     }
     77 
     78     /* There is no device to connect to. */
     79     mState = ECDS_CONNECTED;
     80 
     81     return NO_ERROR;
     82 }
     83 
     84 status_t EmulatedFakeCameraDevice::disconnectDevice()
     85 {
     86     ALOGV("%s", __FUNCTION__);
     87 
     88     Mutex::Autolock locker(&mObjectLock);
     89     if (!isConnected()) {
     90         ALOGW("%s: Fake camera device is already disconnected.", __FUNCTION__);
     91         return NO_ERROR;
     92     }
     93     if (isStarted()) {
     94         ALOGE("%s: Cannot disconnect from the started device.", __FUNCTION__);
     95         return EINVAL;
     96     }
     97 
     98     /* There is no device to disconnect from. */
     99     mState = ECDS_INITIALIZED;
    100 
    101     return NO_ERROR;
    102 }
    103 
    104 status_t EmulatedFakeCameraDevice::startDevice(int width,
    105                                                int height,
    106                                                uint32_t pix_fmt)
    107 {
    108     ALOGV("%s", __FUNCTION__);
    109 
    110     Mutex::Autolock locker(&mObjectLock);
    111     if (!isConnected()) {
    112         ALOGE("%s: Fake camera device is not connected.", __FUNCTION__);
    113         return EINVAL;
    114     }
    115     if (isStarted()) {
    116         ALOGE("%s: Fake camera device is already started.", __FUNCTION__);
    117         return EINVAL;
    118     }
    119 
    120     /* Initialize the base class. */
    121     const status_t res =
    122         EmulatedCameraDevice::commonStartDevice(width, height, pix_fmt);
    123     if (res == NO_ERROR) {
    124         /* Calculate U/V panes inside the framebuffer. */
    125         switch (mPixelFormat) {
    126             case V4L2_PIX_FMT_YVU420:
    127                 mFrameV = mCurrentFrame + mTotalPixels;
    128                 mFrameU = mFrameU + mTotalPixels / 4;
    129                 mUVStep = 1;
    130                 mUVTotalNum = mTotalPixels / 4;
    131                 break;
    132 
    133             case V4L2_PIX_FMT_YUV420:
    134                 mFrameU = mCurrentFrame + mTotalPixels;
    135                 mFrameV = mFrameU + mTotalPixels / 4;
    136                 mUVStep = 1;
    137                 mUVTotalNum = mTotalPixels / 4;
    138                 break;
    139 
    140             case V4L2_PIX_FMT_NV21:
    141                 /* Interleaved UV pane, V first. */
    142                 mFrameV = mCurrentFrame + mTotalPixels;
    143                 mFrameU = mFrameV + 1;
    144                 mUVStep = 2;
    145                 mUVTotalNum = mTotalPixels / 4;
    146                 break;
    147 
    148             case V4L2_PIX_FMT_NV12:
    149                 /* Interleaved UV pane, U first. */
    150                 mFrameU = mCurrentFrame + mTotalPixels;
    151                 mFrameV = mFrameU + 1;
    152                 mUVStep = 2;
    153                 mUVTotalNum = mTotalPixels / 4;
    154                 break;
    155 
    156             default:
    157                 ALOGE("%s: Unknown pixel format %.4s", __FUNCTION__,
    158                      reinterpret_cast<const char*>(&mPixelFormat));
    159                 return EINVAL;
    160         }
    161         /* Number of items in a single row inside U/V panes. */
    162         mUVInRow = (width / 2) * mUVStep;
    163         mState = ECDS_STARTED;
    164     } else {
    165         ALOGE("%s: commonStartDevice failed", __FUNCTION__);
    166     }
    167 
    168     return res;
    169 }
    170 
    171 status_t EmulatedFakeCameraDevice::stopDevice()
    172 {
    173     ALOGV("%s", __FUNCTION__);
    174 
    175     Mutex::Autolock locker(&mObjectLock);
    176     if (!isStarted()) {
    177         ALOGW("%s: Fake camera device is not started.", __FUNCTION__);
    178         return NO_ERROR;
    179     }
    180 
    181     mFrameU = mFrameV = NULL;
    182     EmulatedCameraDevice::commonStopDevice();
    183     mState = ECDS_CONNECTED;
    184 
    185     return NO_ERROR;
    186 }
    187 
    188 /****************************************************************************
    189  * Worker thread management overrides.
    190  ***************************************************************************/
    191 
    192 bool EmulatedFakeCameraDevice::inWorkerThread()
    193 {
    194     /* Wait till FPS timeout expires, or thread exit message is received. */
    195     WorkerThread::SelectRes res =
    196         getWorkerThread()->Select(-1, 1000000 / mEmulatedFPS);
    197     if (res == WorkerThread::EXIT_THREAD) {
    198         ALOGV("%s: Worker thread has been terminated.", __FUNCTION__);
    199         return false;
    200     }
    201 
    202     /* Lets see if we need to generate a new frame. */
    203     if ((systemTime(SYSTEM_TIME_MONOTONIC) - mLastRedrawn) >= mRedrawAfter) {
    204         /*
    205          * Time to generate a new frame.
    206          */
    207 
    208 #if EFCD_ROTATE_FRAME
    209         const int frame_type = rotateFrame();
    210         switch (frame_type) {
    211             case 0:
    212                 drawCheckerboard();
    213                 break;
    214             case 1:
    215                 drawStripes();
    216                 break;
    217             case 2:
    218                 drawSolid(mCurrentColor);
    219                 break;
    220         }
    221 #else
    222         /* Draw the checker board. */
    223         drawCheckerboard();
    224 
    225 #endif  // EFCD_ROTATE_FRAME
    226 
    227         mLastRedrawn = systemTime(SYSTEM_TIME_MONOTONIC);
    228     }
    229 
    230     /* Timestamp the current frame, and notify the camera HAL about new frame. */
    231     mCurFrameTimestamp = systemTime(SYSTEM_TIME_MONOTONIC);
    232     mCameraHAL->onNextFrameAvailable(mCurrentFrame, mCurFrameTimestamp, this);
    233 
    234     return true;
    235 }
    236 
    237 /****************************************************************************
    238  * Fake camera device private API
    239  ***************************************************************************/
    240 
    241 void EmulatedFakeCameraDevice::drawCheckerboard()
    242 {
    243     const int size = mFrameWidth / 10;
    244     bool black = true;
    245 
    246     if (size == 0) {
    247         // When this happens, it happens at a very high rate,
    248         //     so don't log any messages and just return.
    249         return;
    250     }
    251 
    252 
    253     if((mCheckX / size) & 1)
    254         black = false;
    255     if((mCheckY / size) & 1)
    256         black = !black;
    257 
    258     int county = mCheckY % size;
    259     int checkxremainder = mCheckX % size;
    260     uint8_t* Y = mCurrentFrame;
    261     uint8_t* U_pos = mFrameU;
    262     uint8_t* V_pos = mFrameV;
    263     uint8_t* U = U_pos;
    264     uint8_t* V = V_pos;
    265 
    266     YUVPixel adjustedWhite = YUVPixel(mWhiteYUV);
    267     changeWhiteBalance(adjustedWhite.Y, adjustedWhite.U, adjustedWhite.V);
    268 
    269     for(int y = 0; y < mFrameHeight; y++) {
    270         int countx = checkxremainder;
    271         bool current = black;
    272         for(int x = 0; x < mFrameWidth; x += 2) {
    273             if (current) {
    274                 mBlackYUV.get(Y, U, V);
    275             } else {
    276                 adjustedWhite.get(Y, U, V);
    277             }
    278             *Y = changeExposure(*Y);
    279             Y[1] = *Y;
    280             Y += 2; U += mUVStep; V += mUVStep;
    281             countx += 2;
    282             if(countx >= size) {
    283                 countx = 0;
    284                 current = !current;
    285             }
    286         }
    287         if (y & 0x1) {
    288             U_pos = U;
    289             V_pos = V;
    290         } else {
    291             U = U_pos;
    292             V = V_pos;
    293         }
    294         if(county++ >= size) {
    295             county = 0;
    296             black = !black;
    297         }
    298     }
    299     mCheckX += 3;
    300     mCheckY++;
    301 
    302     /* Run the square. */
    303     int sqx = ((mCcounter * 3) & 255);
    304     if(sqx > 128) sqx = 255 - sqx;
    305     int sqy = ((mCcounter * 5) & 255);
    306     if(sqy > 128) sqy = 255 - sqy;
    307     const int sqsize = mFrameWidth / 10;
    308     drawSquare(sqx * sqsize / 32, sqy * sqsize / 32, (sqsize * 5) >> 1,
    309                (mCcounter & 0x100) ? &mRedYUV : &mGreenYUV);
    310     mCcounter++;
    311 }
    312 
    313 void EmulatedFakeCameraDevice::drawSquare(int x,
    314                                           int y,
    315                                           int size,
    316                                           const YUVPixel* color)
    317 {
    318     const int square_xstop = min(mFrameWidth, x + size);
    319     const int square_ystop = min(mFrameHeight, y + size);
    320     uint8_t* Y_pos = mCurrentFrame + y * mFrameWidth + x;
    321 
    322     YUVPixel adjustedColor = *color;
    323     changeWhiteBalance(adjustedColor.Y, adjustedColor.U, adjustedColor.V);
    324 
    325     // Draw the square.
    326     for (; y < square_ystop; y++) {
    327         const int iUV = (y / 2) * mUVInRow + (x / 2) * mUVStep;
    328         uint8_t* sqU = mFrameU + iUV;
    329         uint8_t* sqV = mFrameV + iUV;
    330         uint8_t* sqY = Y_pos;
    331         for (int i = x; i < square_xstop; i += 2) {
    332             adjustedColor.get(sqY, sqU, sqV);
    333             *sqY = changeExposure(*sqY);
    334             sqY[1] = *sqY;
    335             sqY += 2; sqU += mUVStep; sqV += mUVStep;
    336         }
    337         Y_pos += mFrameWidth;
    338     }
    339 }
    340 
    341 #if EFCD_ROTATE_FRAME
    342 
    343 void EmulatedFakeCameraDevice::drawSolid(YUVPixel* color)
    344 {
    345     YUVPixel adjustedColor = *color;
    346     changeWhiteBalance(adjustedColor.Y, adjustedColor.U, adjustedColor.V);
    347 
    348     /* All Ys are the same. */
    349     memset(mCurrentFrame, changeExposure(adjustedColor.Y), mTotalPixels);
    350 
    351     /* Fill U, and V panes. */
    352     uint8_t* U = mFrameU;
    353     uint8_t* V = mFrameV;
    354     for (int k = 0; k < mUVTotalNum; k++, U += mUVStep, V += mUVStep) {
    355         *U = color->U;
    356         *V = color->V;
    357     }
    358 }
    359 
    360 void EmulatedFakeCameraDevice::drawStripes()
    361 {
    362     /* Divide frame into 4 stripes. */
    363     const int change_color_at = mFrameHeight / 4;
    364     const int each_in_row = mUVInRow / mUVStep;
    365     uint8_t* pY = mCurrentFrame;
    366     for (int y = 0; y < mFrameHeight; y++, pY += mFrameWidth) {
    367         /* Select the color. */
    368         YUVPixel* color;
    369         const int color_index = y / change_color_at;
    370         if (color_index == 0) {
    371             /* White stripe on top. */
    372             color = &mWhiteYUV;
    373         } else if (color_index == 1) {
    374             /* Then the red stripe. */
    375             color = &mRedYUV;
    376         } else if (color_index == 2) {
    377             /* Then the green stripe. */
    378             color = &mGreenYUV;
    379         } else {
    380             /* And the blue stripe at the bottom. */
    381             color = &mBlueYUV;
    382         }
    383         changeWhiteBalance(color->Y, color->U, color->V);
    384 
    385         /* All Ys at the row are the same. */
    386         memset(pY, changeExposure(color->Y), mFrameWidth);
    387 
    388         /* Offset of the current row inside U/V panes. */
    389         const int uv_off = (y / 2) * mUVInRow;
    390         /* Fill U, and V panes. */
    391         uint8_t* U = mFrameU + uv_off;
    392         uint8_t* V = mFrameV + uv_off;
    393         for (int k = 0; k < each_in_row; k++, U += mUVStep, V += mUVStep) {
    394             *U = color->U;
    395             *V = color->V;
    396         }
    397     }
    398 }
    399 
    400 int EmulatedFakeCameraDevice::rotateFrame()
    401 {
    402     if ((systemTime(SYSTEM_TIME_MONOTONIC) - mLastRotatedAt) >= mRotateFreq) {
    403         mLastRotatedAt = systemTime(SYSTEM_TIME_MONOTONIC);
    404         mCurrentFrameType++;
    405         if (mCurrentFrameType > 2) {
    406             mCurrentFrameType = 0;
    407         }
    408         if (mCurrentFrameType == 2) {
    409             ALOGD("********** Rotated to the SOLID COLOR frame **********");
    410             /* Solid color: lets rotate color too. */
    411             if (mCurrentColor == &mWhiteYUV) {
    412                 ALOGD("----- Painting a solid RED frame -----");
    413                 mCurrentColor = &mRedYUV;
    414             } else if (mCurrentColor == &mRedYUV) {
    415                 ALOGD("----- Painting a solid GREEN frame -----");
    416                 mCurrentColor = &mGreenYUV;
    417             } else if (mCurrentColor == &mGreenYUV) {
    418                 ALOGD("----- Painting a solid BLUE frame -----");
    419                 mCurrentColor = &mBlueYUV;
    420             } else {
    421                 /* Back to white. */
    422                 ALOGD("----- Painting a solid WHITE frame -----");
    423                 mCurrentColor = &mWhiteYUV;
    424             }
    425         } else if (mCurrentFrameType == 0) {
    426             ALOGD("********** Rotated to the CHECKERBOARD frame **********");
    427         } else if (mCurrentFrameType == 1) {
    428             ALOGD("********** Rotated to the STRIPED frame **********");
    429         }
    430     }
    431 
    432     return mCurrentFrameType;
    433 }
    434 
    435 #endif  // EFCD_ROTATE_FRAME
    436 
    437 }; /* namespace android */
    438