Home | History | Annotate | Download | only in camera2 
      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_TAG "Camera2-CaptureSequencer"
     18 #define ATRACE_TAG ATRACE_TAG_CAMERA
     19 //#define LOG_NDEBUG 0
     20 
     21 #include <utils/Log.h>
     22 #include <utils/Trace.h>
     23 #include <utils/Vector.h>
     24 
     25 #include "CaptureSequencer.h"
     26 #include "BurstCapture.h"
     27 #include "../Camera2Device.h"
     28 #include "../Camera2Client.h"
     29 #include "Parameters.h"
     30 
     31 namespace android {
     32 namespace camera2 {
     33 
     34 /** Public members */
     35 
     36 CaptureSequencer::CaptureSequencer(wp<Camera2Client> client):
     37         Thread(false),
     38         mStartCapture(false),
     39         mBusy(false),
     40         mNewAEState(false),
     41         mNewFrameReceived(false),
     42         mNewCaptureReceived(false),
     43         mShutterNotified(false),
     44         mClient(client),
     45         mCaptureState(IDLE),
     46         mTriggerId(0),
     47         mTimeoutCount(0),
     48         mCaptureId(Camera2Client::kCaptureRequestIdStart) {
     49     ALOGV("%s", __FUNCTION__);
     50 }
     51 
     52 CaptureSequencer::~CaptureSequencer() {
     53     ALOGV("%s: Exit", __FUNCTION__);
     54 }
     55 
     56 void CaptureSequencer::setZslProcessor(wp<ZslProcessor> processor) {
     57     Mutex::Autolock l(mInputMutex);
     58     mZslProcessor = processor;
     59 }
     60 
     61 status_t CaptureSequencer::startCapture() {
     62     ALOGV("%s", __FUNCTION__);
     63     ATRACE_CALL();
     64     Mutex::Autolock l(mInputMutex);
     65     if (mBusy) {
     66         ALOGE("%s: Already busy capturing!", __FUNCTION__);
     67         return INVALID_OPERATION;
     68     }
     69     if (!mStartCapture) {
     70         mStartCapture = true;
     71         mStartCaptureSignal.signal();
     72     }
     73     return OK;
     74 }
     75 
     76 status_t CaptureSequencer::waitUntilIdle(nsecs_t timeout) {
     77     ATRACE_CALL();
     78     ALOGV("%s: Waiting for idle", __FUNCTION__);
     79     Mutex::Autolock l(mStateMutex);
     80     status_t res = -1;
     81     while (mCaptureState != IDLE) {
     82         nsecs_t startTime = systemTime();
     83 
     84         res = mStateChanged.waitRelative(mStateMutex, timeout);
     85         if (res != OK) return res;
     86 
     87         timeout -= (systemTime() - startTime);
     88     }
     89     ALOGV("%s: Now idle", __FUNCTION__);
     90     return OK;
     91 }
     92 
     93 void CaptureSequencer::notifyAutoExposure(uint8_t newState, int triggerId) {
     94     ATRACE_CALL();
     95     Mutex::Autolock l(mInputMutex);
     96     mAEState = newState;
     97     mAETriggerId = triggerId;
     98     if (!mNewAEState) {
     99         mNewAEState = true;
    100         mNewNotifySignal.signal();
    101     }
    102 }
    103 
    104 void CaptureSequencer::onFrameAvailable(int32_t frameId,
    105         const CameraMetadata &frame) {
    106     ALOGV("%s: Listener found new frame", __FUNCTION__);
    107     ATRACE_CALL();
    108     Mutex::Autolock l(mInputMutex);
    109     mNewFrameId = frameId;
    110     mNewFrame = frame;
    111     if (!mNewFrameReceived) {
    112         mNewFrameReceived = true;
    113         mNewFrameSignal.signal();
    114     }
    115 }
    116 
    117 void CaptureSequencer::onCaptureAvailable(nsecs_t timestamp,
    118         sp<MemoryBase> captureBuffer) {
    119     ATRACE_CALL();
    120     ALOGV("%s", __FUNCTION__);
    121     Mutex::Autolock l(mInputMutex);
    122     mCaptureTimestamp = timestamp;
    123     mCaptureBuffer = captureBuffer;
    124     if (!mNewCaptureReceived) {
    125         mNewCaptureReceived = true;
    126         mNewCaptureSignal.signal();
    127     }
    128 }
    129 
    130 
    131 void CaptureSequencer::dump(int fd, const Vector<String16>& args) {
    132     String8 result;
    133     if (mCaptureRequest.entryCount() != 0) {
    134         result = "    Capture request:\n";
    135         write(fd, result.string(), result.size());
    136         mCaptureRequest.dump(fd, 2, 6);
    137     } else {
    138         result = "    Capture request: undefined\n";
    139         write(fd, result.string(), result.size());
    140     }
    141     result = String8::format("    Current capture state: %s\n",
    142             kStateNames[mCaptureState]);
    143     result.append("    Latest captured frame:\n");
    144     write(fd, result.string(), result.size());
    145     mNewFrame.dump(fd, 2, 6);
    146 }
    147 
    148 /** Private members */
    149 
    150 const char* CaptureSequencer::kStateNames[CaptureSequencer::NUM_CAPTURE_STATES+1] =
    151 {
    152     "IDLE",
    153     "START",
    154     "ZSL_START",
    155     "ZSL_WAITING",
    156     "ZSL_REPROCESSING",
    157     "STANDARD_START",
    158     "STANDARD_PRECAPTURE_WAIT",
    159     "STANDARD_CAPTURE",
    160     "STANDARD_CAPTURE_WAIT",
    161     "BURST_CAPTURE_START",
    162     "BURST_CAPTURE_WAIT",
    163     "DONE",
    164     "ERROR",
    165     "UNKNOWN"
    166 };
    167 
    168 const CaptureSequencer::StateManager
    169         CaptureSequencer::kStateManagers[CaptureSequencer::NUM_CAPTURE_STATES-1] = {
    170     &CaptureSequencer::manageIdle,
    171     &CaptureSequencer::manageStart,
    172     &CaptureSequencer::manageZslStart,
    173     &CaptureSequencer::manageZslWaiting,
    174     &CaptureSequencer::manageZslReprocessing,
    175     &CaptureSequencer::manageStandardStart,
    176     &CaptureSequencer::manageStandardPrecaptureWait,
    177     &CaptureSequencer::manageStandardCapture,
    178     &CaptureSequencer::manageStandardCaptureWait,
    179     &CaptureSequencer::manageBurstCaptureStart,
    180     &CaptureSequencer::manageBurstCaptureWait,
    181     &CaptureSequencer::manageDone,
    182 };
    183 
    184 bool CaptureSequencer::threadLoop() {
    185     status_t res;
    186 
    187     sp<Camera2Client> client = mClient.promote();
    188     if (client == 0) return false;
    189 
    190     CaptureState currentState;
    191     {
    192         Mutex::Autolock l(mStateMutex);
    193         currentState = mCaptureState;
    194     }
    195 
    196     currentState = (this->*kStateManagers[currentState])(client);
    197 
    198     Mutex::Autolock l(mStateMutex);
    199     if (currentState != mCaptureState) {
    200         mCaptureState = currentState;
    201         ATRACE_INT("cam2_capt_state", mCaptureState);
    202         ALOGV("Camera %d: New capture state %s",
    203                 client->getCameraId(), kStateNames[mCaptureState]);
    204         mStateChanged.signal();
    205     }
    206 
    207     if (mCaptureState == ERROR) {
    208         ALOGE("Camera %d: Stopping capture sequencer due to error",
    209                 client->getCameraId());
    210         return false;
    211     }
    212 
    213     return true;
    214 }
    215 
    216 CaptureSequencer::CaptureState CaptureSequencer::manageIdle(sp<Camera2Client> &client) {
    217     status_t res;
    218     Mutex::Autolock l(mInputMutex);
    219     while (!mStartCapture) {
    220         res = mStartCaptureSignal.waitRelative(mInputMutex,
    221                 kWaitDuration);
    222         if (res == TIMED_OUT) break;
    223     }
    224     if (mStartCapture) {
    225         mStartCapture = false;
    226         mBusy = true;
    227         return START;
    228     }
    229     return IDLE;
    230 }
    231 
    232 CaptureSequencer::CaptureState CaptureSequencer::manageDone(sp<Camera2Client> &client) {
    233     status_t res = OK;
    234     ATRACE_CALL();
    235     mCaptureId++;
    236     if (mCaptureId >= Camera2Client::kCaptureRequestIdEnd) {
    237         mCaptureId = Camera2Client::kCaptureRequestIdStart;
    238     }
    239     {
    240         Mutex::Autolock l(mInputMutex);
    241         mBusy = false;
    242     }
    243 
    244     {
    245         SharedParameters::Lock l(client->getParameters());
    246         switch (l.mParameters.state) {
    247             case Parameters::DISCONNECTED:
    248                 ALOGW("%s: Camera %d: Discarding image data during shutdown ",
    249                         __FUNCTION__, client->getCameraId());
    250                 res = INVALID_OPERATION;
    251                 break;
    252             case Parameters::STILL_CAPTURE:
    253                 l.mParameters.state = Parameters::STOPPED;
    254                 break;
    255             case Parameters::VIDEO_SNAPSHOT:
    256                 l.mParameters.state = Parameters::RECORD;
    257                 break;
    258             default:
    259                 ALOGE("%s: Camera %d: Still image produced unexpectedly "
    260                         "in state %s!",
    261                         __FUNCTION__, client->getCameraId(),
    262                         Parameters::getStateName(l.mParameters.state));
    263                 res = INVALID_OPERATION;
    264         }
    265     }
    266     sp<ZslProcessor> processor = mZslProcessor.promote();
    267     if (processor != 0) {
    268         processor->clearZslQueue();
    269     }
    270 
    271     if (mCaptureBuffer != 0 && res == OK) {
    272         Camera2Client::SharedCameraClient::Lock l(client->mSharedCameraClient);
    273         ALOGV("%s: Sending still image to client", __FUNCTION__);
    274         if (l.mCameraClient != 0) {
    275             l.mCameraClient->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE,
    276                     mCaptureBuffer, NULL);
    277         } else {
    278             ALOGV("%s: No client!", __FUNCTION__);
    279         }
    280     }
    281     mCaptureBuffer.clear();
    282 
    283     return IDLE;
    284 }
    285 
    286 CaptureSequencer::CaptureState CaptureSequencer::manageStart(
    287         sp<Camera2Client> &client) {
    288     ALOGV("%s", __FUNCTION__);
    289     status_t res;
    290     ATRACE_CALL();
    291     SharedParameters::Lock l(client->getParameters());
    292     CaptureState nextState = DONE;
    293 
    294     res = updateCaptureRequest(l.mParameters, client);
    295     if (res != OK ) {
    296         ALOGE("%s: Camera %d: Can't update still image capture request: %s (%d)",
    297                 __FUNCTION__, client->getCameraId(), strerror(-res), res);
    298         return DONE;
    299     }
    300 
    301     if(l.mParameters.lightFx != Parameters::LIGHTFX_NONE &&
    302             l.mParameters.state == Parameters::STILL_CAPTURE) {
    303         nextState = BURST_CAPTURE_START;
    304     }
    305     else if (l.mParameters.zslMode &&
    306             l.mParameters.state == Parameters::STILL_CAPTURE &&
    307             l.mParameters.flashMode != Parameters::FLASH_MODE_ON) {
    308         nextState = ZSL_START;
    309     } else {
    310         nextState = STANDARD_START;
    311     }
    312     mShutterNotified = false;
    313 
    314     return nextState;
    315 }
    316 
    317 CaptureSequencer::CaptureState CaptureSequencer::manageZslStart(
    318         sp<Camera2Client> &client) {
    319     ALOGV("%s", __FUNCTION__);
    320     status_t res;
    321     sp<ZslProcessor> processor = mZslProcessor.promote();
    322     if (processor == 0) {
    323         ALOGE("%s: No ZSL queue to use!", __FUNCTION__);
    324         return DONE;
    325     }
    326 
    327     client->registerFrameListener(mCaptureId, mCaptureId + 1,
    328             this);
    329 
    330     // TODO: Actually select the right thing here.
    331     res = processor->pushToReprocess(mCaptureId);
    332     if (res != OK) {
    333         if (res == NOT_ENOUGH_DATA) {
    334             ALOGV("%s: Camera %d: ZSL queue doesn't have good frame, "
    335                     "falling back to normal capture", __FUNCTION__,
    336                     client->getCameraId());
    337         } else {
    338             ALOGE("%s: Camera %d: Error in ZSL queue: %s (%d)",
    339                     __FUNCTION__, client->getCameraId(), strerror(-res), res);
    340         }
    341         return STANDARD_START;
    342     }
    343 
    344     SharedParameters::Lock l(client->getParameters());
    345     /* warning: this also locks a SharedCameraClient */
    346     shutterNotifyLocked(l.mParameters, client);
    347     mShutterNotified = true;
    348     mTimeoutCount = kMaxTimeoutsForCaptureEnd;
    349     return STANDARD_CAPTURE_WAIT;
    350 }
    351 
    352 CaptureSequencer::CaptureState CaptureSequencer::manageZslWaiting(
    353         sp<Camera2Client> &client) {
    354     ALOGV("%s", __FUNCTION__);
    355     return DONE;
    356 }
    357 
    358 CaptureSequencer::CaptureState CaptureSequencer::manageZslReprocessing(
    359         sp<Camera2Client> &client) {
    360     ALOGV("%s", __FUNCTION__);
    361     return START;
    362 }
    363 
    364 CaptureSequencer::CaptureState CaptureSequencer::manageStandardStart(
    365         sp<Camera2Client> &client) {
    366     ATRACE_CALL();
    367     client->registerFrameListener(mCaptureId, mCaptureId + 1,
    368             this);
    369     {
    370         SharedParameters::Lock l(client->getParameters());
    371         mTriggerId = l.mParameters.precaptureTriggerCounter++;
    372     }
    373     client->getCameraDevice()->triggerPrecaptureMetering(mTriggerId);
    374 
    375     mAeInPrecapture = false;
    376     mTimeoutCount = kMaxTimeoutsForPrecaptureStart;
    377     return STANDARD_PRECAPTURE_WAIT;
    378 }
    379 
    380 CaptureSequencer::CaptureState CaptureSequencer::manageStandardPrecaptureWait(
    381         sp<Camera2Client> &client) {
    382     status_t res;
    383     ATRACE_CALL();
    384     Mutex::Autolock l(mInputMutex);
    385     while (!mNewAEState) {
    386         res = mNewNotifySignal.waitRelative(mInputMutex, kWaitDuration);
    387         if (res == TIMED_OUT) {
    388             mTimeoutCount--;
    389             break;
    390         }
    391     }
    392     if (mTimeoutCount <= 0) {
    393         ALOGW("Timed out waiting for precapture %s",
    394                 mAeInPrecapture ? "end" : "start");
    395         return STANDARD_CAPTURE;
    396     }
    397     if (mNewAEState) {
    398         if (!mAeInPrecapture) {
    399             // Waiting to see PRECAPTURE state
    400             if (mAETriggerId == mTriggerId &&
    401                     mAEState == ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
    402                 ALOGV("%s: Got precapture start", __FUNCTION__);
    403                 mAeInPrecapture = true;
    404                 mTimeoutCount = kMaxTimeoutsForPrecaptureEnd;
    405             }
    406         } else {
    407             // Waiting to see PRECAPTURE state end
    408             if (mAETriggerId == mTriggerId &&
    409                     mAEState != ANDROID_CONTROL_AE_STATE_PRECAPTURE) {
    410                 ALOGV("%s: Got precapture end", __FUNCTION__);
    411                 return STANDARD_CAPTURE;
    412             }
    413         }
    414         mNewAEState = false;
    415     }
    416     return STANDARD_PRECAPTURE_WAIT;
    417 }
    418 
    419 CaptureSequencer::CaptureState CaptureSequencer::manageStandardCapture(
    420         sp<Camera2Client> &client) {
    421     status_t res;
    422     ATRACE_CALL();
    423     SharedParameters::Lock l(client->getParameters());
    424     Vector<uint8_t> outputStreams;
    425 
    426     outputStreams.push(client->getPreviewStreamId());
    427     outputStreams.push(client->getCaptureStreamId());
    428 
    429     if (l.mParameters.previewCallbackFlags &
    430             CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) {
    431         outputStreams.push(client->getCallbackStreamId());
    432     }
    433 
    434     if (l.mParameters.state == Parameters::VIDEO_SNAPSHOT) {
    435         outputStreams.push(client->getRecordingStreamId());
    436     }
    437 
    438     res = mCaptureRequest.update(ANDROID_REQUEST_OUTPUT_STREAMS,
    439             outputStreams);
    440     if (res == OK) {
    441         res = mCaptureRequest.update(ANDROID_REQUEST_ID,
    442                 &mCaptureId, 1);
    443     }
    444     if (res == OK) {
    445         res = mCaptureRequest.sort();
    446     }
    447 
    448     if (res != OK) {
    449         ALOGE("%s: Camera %d: Unable to set up still capture request: %s (%d)",
    450                 __FUNCTION__, client->getCameraId(), strerror(-res), res);
    451         return DONE;
    452     }
    453 
    454     CameraMetadata captureCopy = mCaptureRequest;
    455     if (captureCopy.entryCount() == 0) {
    456         ALOGE("%s: Camera %d: Unable to copy capture request for HAL device",
    457                 __FUNCTION__, client->getCameraId());
    458         return DONE;
    459     }
    460 
    461     if (l.mParameters.state == Parameters::STILL_CAPTURE) {
    462         res = client->stopStream();
    463         if (res != OK) {
    464             ALOGE("%s: Camera %d: Unable to stop preview for still capture: "
    465                     "%s (%d)",
    466                     __FUNCTION__, client->getCameraId(), strerror(-res), res);
    467             return DONE;
    468         }
    469     }
    470     // TODO: Capture should be atomic with setStreamingRequest here
    471     res = client->getCameraDevice()->capture(captureCopy);
    472     if (res != OK) {
    473         ALOGE("%s: Camera %d: Unable to submit still image capture request: "
    474                 "%s (%d)",
    475                 __FUNCTION__, client->getCameraId(), strerror(-res), res);
    476         return DONE;
    477     }
    478 
    479     mTimeoutCount = kMaxTimeoutsForCaptureEnd;
    480     return STANDARD_CAPTURE_WAIT;
    481 }
    482 
    483 CaptureSequencer::CaptureState CaptureSequencer::manageStandardCaptureWait(
    484         sp<Camera2Client> &client) {
    485     status_t res;
    486     ATRACE_CALL();
    487     Mutex::Autolock l(mInputMutex);
    488     while (!mNewFrameReceived) {
    489         res = mNewFrameSignal.waitRelative(mInputMutex, kWaitDuration);
    490         if (res == TIMED_OUT) {
    491             mTimeoutCount--;
    492             break;
    493         }
    494     }
    495     if (mNewFrameReceived && !mShutterNotified) {
    496         SharedParameters::Lock l(client->getParameters());
    497         /* warning: this also locks a SharedCameraClient */
    498         shutterNotifyLocked(l.mParameters, client);
    499         mShutterNotified = true;
    500     }
    501     while (mNewFrameReceived && !mNewCaptureReceived) {
    502         res = mNewCaptureSignal.waitRelative(mInputMutex, kWaitDuration);
    503         if (res == TIMED_OUT) {
    504             mTimeoutCount--;
    505             break;
    506         }
    507     }
    508     if (mTimeoutCount <= 0) {
    509         ALOGW("Timed out waiting for capture to complete");
    510         return DONE;
    511     }
    512     if (mNewFrameReceived && mNewCaptureReceived) {
    513         if (mNewFrameId != mCaptureId) {
    514             ALOGW("Mismatched capture frame IDs: Expected %d, got %d",
    515                     mCaptureId, mNewFrameId);
    516         }
    517         camera_metadata_entry_t entry;
    518         entry = mNewFrame.find(ANDROID_SENSOR_TIMESTAMP);
    519         if (entry.count == 0) {
    520             ALOGE("No timestamp field in capture frame!");
    521         }
    522         if (entry.data.i64[0] != mCaptureTimestamp) {
    523             ALOGW("Mismatched capture timestamps: Metadata frame %lld,"
    524                     " captured buffer %lld", entry.data.i64[0], mCaptureTimestamp);
    525         }
    526         client->removeFrameListener(mCaptureId, mCaptureId + 1, this);
    527 
    528         mNewFrameReceived = false;
    529         mNewCaptureReceived = false;
    530         return DONE;
    531     }
    532     return STANDARD_CAPTURE_WAIT;
    533 }
    534 
    535 CaptureSequencer::CaptureState CaptureSequencer::manageBurstCaptureStart(
    536         sp<Camera2Client> &client) {
    537     ALOGV("%s", __FUNCTION__);
    538     status_t res;
    539     ATRACE_CALL();
    540 
    541     // check which burst mode is set, create respective burst object
    542     {
    543         SharedParameters::Lock l(client->getParameters());
    544 
    545         res = updateCaptureRequest(l.mParameters, client);
    546         if(res != OK) {
    547             return DONE;
    548         }
    549 
    550         //
    551         // check for burst mode type in mParameters here
    552         //
    553         mBurstCapture = new BurstCapture(client, this);
    554     }
    555 
    556     res = mCaptureRequest.update(ANDROID_REQUEST_ID, &mCaptureId, 1);
    557     if (res == OK) {
    558         res = mCaptureRequest.sort();
    559     }
    560     if (res != OK) {
    561         ALOGE("%s: Camera %d: Unable to set up still capture request: %s (%d)",
    562                 __FUNCTION__, client->getCameraId(), strerror(-res), res);
    563         return DONE;
    564     }
    565 
    566     CameraMetadata captureCopy = mCaptureRequest;
    567     if (captureCopy.entryCount() == 0) {
    568         ALOGE("%s: Camera %d: Unable to copy capture request for HAL device",
    569                 __FUNCTION__, client->getCameraId());
    570         return DONE;
    571     }
    572 
    573     Vector<CameraMetadata> requests;
    574     requests.push(mCaptureRequest);
    575     res = mBurstCapture->start(requests, mCaptureId);
    576     mTimeoutCount = kMaxTimeoutsForCaptureEnd * 10;
    577     return BURST_CAPTURE_WAIT;
    578 }
    579 
    580 CaptureSequencer::CaptureState CaptureSequencer::manageBurstCaptureWait(
    581         sp<Camera2Client> &client) {
    582     status_t res;
    583     ATRACE_CALL();
    584 
    585     while (!mNewCaptureReceived) {
    586         res = mNewCaptureSignal.waitRelative(mInputMutex, kWaitDuration);
    587         if (res == TIMED_OUT) {
    588             mTimeoutCount--;
    589             break;
    590         }
    591     }
    592 
    593     if (mTimeoutCount <= 0) {
    594         ALOGW("Timed out waiting for burst capture to complete");
    595         return DONE;
    596     }
    597     if (mNewCaptureReceived) {
    598         mNewCaptureReceived = false;
    599         // TODO: update mCaptureId to last burst's capture ID + 1?
    600         return DONE;
    601     }
    602 
    603     return BURST_CAPTURE_WAIT;
    604 }
    605 
    606 status_t CaptureSequencer::updateCaptureRequest(const Parameters &params,
    607         sp<Camera2Client> &client) {
    608     ATRACE_CALL();
    609     status_t res;
    610     if (mCaptureRequest.entryCount() == 0) {
    611         res = client->getCameraDevice()->createDefaultRequest(
    612                 CAMERA2_TEMPLATE_STILL_CAPTURE,
    613                 &mCaptureRequest);
    614         if (res != OK) {
    615             ALOGE("%s: Camera %d: Unable to create default still image request:"
    616                     " %s (%d)", __FUNCTION__, client->getCameraId(),
    617                     strerror(-res), res);
    618             return res;
    619         }
    620     }
    621 
    622     res = params.updateRequest(&mCaptureRequest);
    623     if (res != OK) {
    624         ALOGE("%s: Camera %d: Unable to update common entries of capture "
    625                 "request: %s (%d)", __FUNCTION__, client->getCameraId(),
    626                 strerror(-res), res);
    627         return res;
    628     }
    629 
    630     res = params.updateRequestJpeg(&mCaptureRequest);
    631     if (res != OK) {
    632         ALOGE("%s: Camera %d: Unable to update JPEG entries of capture "
    633                 "request: %s (%d)", __FUNCTION__, client->getCameraId(),
    634                 strerror(-res), res);
    635         return res;
    636     }
    637 
    638     return OK;
    639 }
    640 
    641 /*static*/ void CaptureSequencer::shutterNotifyLocked(const Parameters &params,
    642             sp<Camera2Client> client) {
    643     ATRACE_CALL();
    644 
    645     if (params.state == Parameters::STILL_CAPTURE && params.playShutterSound) {
    646         client->getCameraService()->playSound(CameraService::SOUND_SHUTTER);
    647     }
    648 
    649     {
    650         Camera2Client::SharedCameraClient::Lock l(client->mSharedCameraClient);
    651 
    652         ALOGV("%s: Notifying of shutter close to client", __FUNCTION__);
    653         if (l.mCameraClient != 0) {
    654             // ShutterCallback
    655             l.mCameraClient->notifyCallback(CAMERA_MSG_SHUTTER,
    656                                             /*ext1*/0, /*ext2*/0);
    657 
    658             // RawCallback with null buffer
    659             l.mCameraClient->notifyCallback(CAMERA_MSG_RAW_IMAGE_NOTIFY,
    660                                             /*ext1*/0, /*ext2*/0);
    661         } else {
    662             ALOGV("%s: No client!", __FUNCTION__);
    663         }
    664     }
    665 }
    666 
    667 
    668 }; // namespace camera2
    669 }; // namespace android
    670