Home | History | Annotate | Download | only in client2 
      1 /*
      2  * Copyright (C) 2012-2018 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-StreamingProcessor"
     18 #define ATRACE_TAG ATRACE_TAG_CAMERA
     19 //#define LOG_NDEBUG 0
     20 //#define LOG_NNDEBUG 0 // Per-frame verbose logging
     21 
     22 #ifdef LOG_NNDEBUG
     23 #define ALOGVV(...) ALOGV(__VA_ARGS__)
     24 #else
     25 #define ALOGVV(...) ((void)0)
     26 #endif
     27 
     28 #include <cutils/properties.h>
     29 #include <utils/Log.h>
     30 #include <utils/Trace.h>
     31 #include <gui/BufferItem.h>
     32 #include <gui/Surface.h>
     33 #include <media/hardware/HardwareAPI.h>
     34 
     35 #include "common/CameraDeviceBase.h"
     36 #include "api1/Camera2Client.h"
     37 #include "api1/client2/StreamingProcessor.h"
     38 #include "api1/client2/Camera2Heap.h"
     39 
     40 namespace android {
     41 namespace camera2 {
     42 
     43 StreamingProcessor::StreamingProcessor(sp<Camera2Client> client):
     44         mClient(client),
     45         mDevice(client->getCameraDevice()),
     46         mId(client->getCameraId()),
     47         mActiveRequest(NONE),
     48         mPaused(false),
     49         mPreviewRequestId(Camera2Client::kPreviewRequestIdStart),
     50         mPreviewStreamId(NO_STREAM),
     51         mRecordingRequestId(Camera2Client::kRecordingRequestIdStart),
     52         mRecordingStreamId(NO_STREAM)
     53 {
     54 }
     55 
     56 StreamingProcessor::~StreamingProcessor() {
     57     deletePreviewStream();
     58     deleteRecordingStream();
     59 }
     60 
     61 status_t StreamingProcessor::setPreviewWindow(const sp<Surface>& window) {
     62     ATRACE_CALL();
     63     status_t res;
     64 
     65     res = deletePreviewStream();
     66     if (res != OK) return res;
     67 
     68     Mutex::Autolock m(mMutex);
     69 
     70     mPreviewWindow = window;
     71 
     72     return OK;
     73 }
     74 
     75 status_t StreamingProcessor::setRecordingWindow(const sp<Surface>& window) {
     76     ATRACE_CALL();
     77     status_t res;
     78 
     79     res = deleteRecordingStream();
     80     if (res != OK) return res;
     81 
     82     Mutex::Autolock m(mMutex);
     83 
     84     mRecordingWindow = window;
     85 
     86     return OK;
     87 }
     88 
     89 bool StreamingProcessor::haveValidPreviewWindow() const {
     90     Mutex::Autolock m(mMutex);
     91     return mPreviewWindow != 0;
     92 }
     93 
     94 bool StreamingProcessor::haveValidRecordingWindow() const {
     95     Mutex::Autolock m(mMutex);
     96     return mRecordingWindow != nullptr;
     97 }
     98 
     99 status_t StreamingProcessor::updatePreviewRequest(const Parameters &params) {
    100     ATRACE_CALL();
    101     status_t res;
    102     sp<CameraDeviceBase> device = mDevice.promote();
    103     if (device == 0) {
    104         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    105         return INVALID_OPERATION;
    106     }
    107 
    108     Mutex::Autolock m(mMutex);
    109     if (mPreviewRequest.entryCount() == 0) {
    110         sp<Camera2Client> client = mClient.promote();
    111         if (client == 0) {
    112             ALOGE("%s: Camera %d: Client does not exist", __FUNCTION__, mId);
    113             return INVALID_OPERATION;
    114         }
    115 
    116         // Use CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG for ZSL streaming case.
    117         if (params.useZeroShutterLag() && !params.recordingHint) {
    118             res = device->createDefaultRequest(
    119                     CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG, &mPreviewRequest);
    120         } else {
    121             res = device->createDefaultRequest(CAMERA3_TEMPLATE_PREVIEW,
    122                     &mPreviewRequest);
    123         }
    124 
    125         if (res != OK) {
    126             ALOGE("%s: Camera %d: Unable to create default preview request: "
    127                     "%s (%d)", __FUNCTION__, mId, strerror(-res), res);
    128             return res;
    129         }
    130     }
    131 
    132     res = params.updateRequest(&mPreviewRequest);
    133     if (res != OK) {
    134         ALOGE("%s: Camera %d: Unable to update common entries of preview "
    135                 "request: %s (%d)", __FUNCTION__, mId,
    136                 strerror(-res), res);
    137         return res;
    138     }
    139 
    140     res = mPreviewRequest.update(ANDROID_REQUEST_ID,
    141             &mPreviewRequestId, 1);
    142     if (res != OK) {
    143         ALOGE("%s: Camera %d: Unable to update request id for preview: %s (%d)",
    144                 __FUNCTION__, mId, strerror(-res), res);
    145         return res;
    146     }
    147 
    148     return OK;
    149 }
    150 
    151 status_t StreamingProcessor::updatePreviewStream(const Parameters &params) {
    152     ATRACE_CALL();
    153     Mutex::Autolock m(mMutex);
    154 
    155     status_t res;
    156     sp<CameraDeviceBase> device = mDevice.promote();
    157     if (device == 0) {
    158         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    159         return INVALID_OPERATION;
    160     }
    161 
    162     if (mPreviewStreamId != NO_STREAM) {
    163         // Check if stream parameters have to change
    164         CameraDeviceBase::StreamInfo streamInfo;
    165         res = device->getStreamInfo(mPreviewStreamId, &streamInfo);
    166         if (res != OK) {
    167             ALOGE("%s: Camera %d: Error querying preview stream info: "
    168                     "%s (%d)", __FUNCTION__, mId, strerror(-res), res);
    169             return res;
    170         }
    171         if (streamInfo.width != (uint32_t)params.previewWidth ||
    172                 streamInfo.height != (uint32_t)params.previewHeight) {
    173             ALOGV("%s: Camera %d: Preview size switch: %d x %d -> %d x %d",
    174                     __FUNCTION__, mId, streamInfo.width, streamInfo.height,
    175                     params.previewWidth, params.previewHeight);
    176             res = device->waitUntilDrained();
    177             if (res != OK) {
    178                 ALOGE("%s: Camera %d: Error waiting for preview to drain: "
    179                         "%s (%d)", __FUNCTION__, mId, strerror(-res), res);
    180                 return res;
    181             }
    182             res = device->deleteStream(mPreviewStreamId);
    183             if (res != OK) {
    184                 ALOGE("%s: Camera %d: Unable to delete old output stream "
    185                         "for preview: %s (%d)", __FUNCTION__, mId,
    186                         strerror(-res), res);
    187                 return res;
    188             }
    189             mPreviewStreamId = NO_STREAM;
    190         }
    191     }
    192 
    193     if (mPreviewStreamId == NO_STREAM) {
    194         res = device->createStream(mPreviewWindow,
    195                 params.previewWidth, params.previewHeight,
    196                 CAMERA2_HAL_PIXEL_FORMAT_OPAQUE, HAL_DATASPACE_UNKNOWN,
    197                 CAMERA3_STREAM_ROTATION_0, &mPreviewStreamId, String8());
    198         if (res != OK) {
    199             ALOGE("%s: Camera %d: Unable to create preview stream: %s (%d)",
    200                     __FUNCTION__, mId, strerror(-res), res);
    201             return res;
    202         }
    203     }
    204 
    205     res = device->setStreamTransform(mPreviewStreamId,
    206             params.previewTransform);
    207     if (res != OK) {
    208         ALOGE("%s: Camera %d: Unable to set preview stream transform: "
    209                 "%s (%d)", __FUNCTION__, mId, strerror(-res), res);
    210         return res;
    211     }
    212 
    213     return OK;
    214 }
    215 
    216 status_t StreamingProcessor::deletePreviewStream() {
    217     ATRACE_CALL();
    218     status_t res;
    219 
    220     Mutex::Autolock m(mMutex);
    221 
    222     if (mPreviewStreamId != NO_STREAM) {
    223         sp<CameraDeviceBase> device = mDevice.promote();
    224         if (device == 0) {
    225             ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    226             return INVALID_OPERATION;
    227         }
    228 
    229         ALOGV("%s: for cameraId %d on streamId %d",
    230             __FUNCTION__, mId, mPreviewStreamId);
    231 
    232         res = device->waitUntilDrained();
    233         if (res != OK) {
    234             ALOGE("%s: Error waiting for preview to drain: %s (%d)",
    235                     __FUNCTION__, strerror(-res), res);
    236             return res;
    237         }
    238         res = device->deleteStream(mPreviewStreamId);
    239         if (res != OK) {
    240             ALOGE("%s: Unable to delete old preview stream: %s (%d)",
    241                     __FUNCTION__, strerror(-res), res);
    242             return res;
    243         }
    244         mPreviewStreamId = NO_STREAM;
    245     }
    246     return OK;
    247 }
    248 
    249 int StreamingProcessor::getPreviewStreamId() const {
    250     Mutex::Autolock m(mMutex);
    251     return mPreviewStreamId;
    252 }
    253 
    254 status_t StreamingProcessor::updateRecordingRequest(const Parameters &params) {
    255     ATRACE_CALL();
    256     status_t res;
    257     Mutex::Autolock m(mMutex);
    258 
    259     sp<CameraDeviceBase> device = mDevice.promote();
    260     if (device == 0) {
    261         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    262         return INVALID_OPERATION;
    263     }
    264 
    265     if (mRecordingRequest.entryCount() == 0) {
    266         res = device->createDefaultRequest(CAMERA2_TEMPLATE_VIDEO_RECORD,
    267                 &mRecordingRequest);
    268         if (res != OK) {
    269             ALOGE("%s: Camera %d: Unable to create default recording request:"
    270                     " %s (%d)", __FUNCTION__, mId, strerror(-res), res);
    271             return res;
    272         }
    273     }
    274 
    275     res = params.updateRequest(&mRecordingRequest);
    276     if (res != OK) {
    277         ALOGE("%s: Camera %d: Unable to update common entries of recording "
    278                 "request: %s (%d)", __FUNCTION__, mId,
    279                 strerror(-res), res);
    280         return res;
    281     }
    282 
    283     res = mRecordingRequest.update(ANDROID_REQUEST_ID,
    284             &mRecordingRequestId, 1);
    285     if (res != OK) {
    286         ALOGE("%s: Camera %d: Unable to update request id for request: %s (%d)",
    287                 __FUNCTION__, mId, strerror(-res), res);
    288         return res;
    289     }
    290 
    291     return OK;
    292 }
    293 
    294 status_t StreamingProcessor::recordingStreamNeedsUpdate(
    295         const Parameters &params, bool *needsUpdate) {
    296     status_t res;
    297 
    298     if (needsUpdate == 0) {
    299         ALOGE("%s: Camera %d: invalid argument", __FUNCTION__, mId);
    300         return INVALID_OPERATION;
    301     }
    302 
    303     if (mRecordingStreamId == NO_STREAM) {
    304         *needsUpdate = true;
    305         return OK;
    306     }
    307 
    308     sp<CameraDeviceBase> device = mDevice.promote();
    309     if (device == 0) {
    310         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    311         return INVALID_OPERATION;
    312     }
    313 
    314     CameraDeviceBase::StreamInfo streamInfo;
    315     res = device->getStreamInfo(mRecordingStreamId, &streamInfo);
    316     if (res != OK) {
    317         ALOGE("%s: Camera %d: Error querying recording output stream info: "
    318                 "%s (%d)", __FUNCTION__, mId,
    319                 strerror(-res), res);
    320         return res;
    321     }
    322 
    323     if (mRecordingWindow == nullptr ||
    324             streamInfo.width != (uint32_t)params.videoWidth ||
    325             streamInfo.height != (uint32_t)params.videoHeight ||
    326             !streamInfo.matchFormat((uint32_t)params.videoFormat) ||
    327             !streamInfo.matchDataSpace(params.videoDataSpace)) {
    328         *needsUpdate = true;
    329         return res;
    330     }
    331     *needsUpdate = false;
    332     return res;
    333 }
    334 
    335 status_t StreamingProcessor::updateRecordingStream(const Parameters &params) {
    336     ATRACE_CALL();
    337     status_t res;
    338     Mutex::Autolock m(mMutex);
    339 
    340     sp<CameraDeviceBase> device = mDevice.promote();
    341     if (device == 0) {
    342         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    343         return INVALID_OPERATION;
    344     }
    345 
    346     if (mRecordingStreamId != NO_STREAM) {
    347         // Check if stream parameters have to change
    348         CameraDeviceBase::StreamInfo streamInfo;
    349         res = device->getStreamInfo(mRecordingStreamId, &streamInfo);
    350         if (res != OK) {
    351             ALOGE("%s: Camera %d: Error querying recording output stream info: "
    352                     "%s (%d)", __FUNCTION__, mId,
    353                     strerror(-res), res);
    354             return res;
    355         }
    356         if (streamInfo.width != (uint32_t)params.videoWidth ||
    357                 streamInfo.height != (uint32_t)params.videoHeight ||
    358                 !streamInfo.matchFormat((uint32_t)params.videoFormat) ||
    359                 !streamInfo.matchDataSpace(params.videoDataSpace)) {
    360             // TODO: Should wait to be sure previous recording has finished
    361             res = device->deleteStream(mRecordingStreamId);
    362 
    363             if (res == -EBUSY) {
    364                 ALOGV("%s: Camera %d: Device is busy, call "
    365                       "updateRecordingStream after it becomes idle",
    366                       __FUNCTION__, mId);
    367                 return res;
    368             } else if (res != OK) {
    369                 ALOGE("%s: Camera %d: Unable to delete old output stream "
    370                         "for recording: %s (%d)", __FUNCTION__,
    371                         mId, strerror(-res), res);
    372                 return res;
    373             }
    374             mRecordingStreamId = NO_STREAM;
    375         }
    376     }
    377 
    378     if (mRecordingStreamId == NO_STREAM) {
    379         res = device->createStream(mRecordingWindow,
    380                 params.videoWidth, params.videoHeight,
    381                 params.videoFormat, params.videoDataSpace,
    382                 CAMERA3_STREAM_ROTATION_0, &mRecordingStreamId,
    383                 String8());
    384         if (res != OK) {
    385             ALOGE("%s: Camera %d: Can't create output stream for recording: "
    386                     "%s (%d)", __FUNCTION__, mId,
    387                     strerror(-res), res);
    388             return res;
    389         }
    390     }
    391 
    392     return OK;
    393 }
    394 
    395 status_t StreamingProcessor::deleteRecordingStream() {
    396     ATRACE_CALL();
    397     status_t res;
    398 
    399     Mutex::Autolock m(mMutex);
    400 
    401     if (mRecordingStreamId != NO_STREAM) {
    402         sp<CameraDeviceBase> device = mDevice.promote();
    403         if (device == 0) {
    404             ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    405             return INVALID_OPERATION;
    406         }
    407 
    408         res = device->waitUntilDrained();
    409         if (res != OK) {
    410             ALOGE("%s: Error waiting for HAL to drain: %s (%d)",
    411                     __FUNCTION__, strerror(-res), res);
    412             return res;
    413         }
    414         res = device->deleteStream(mRecordingStreamId);
    415         if (res != OK) {
    416             ALOGE("%s: Unable to delete recording stream: %s (%d)",
    417                     __FUNCTION__, strerror(-res), res);
    418             return res;
    419         }
    420         mRecordingStreamId = NO_STREAM;
    421     }
    422     return OK;
    423 }
    424 
    425 int StreamingProcessor::getRecordingStreamId() const {
    426     return mRecordingStreamId;
    427 }
    428 
    429 status_t StreamingProcessor::startStream(StreamType type,
    430         const Vector<int32_t> &outputStreams) {
    431     ATRACE_CALL();
    432     status_t res;
    433 
    434     if (type == NONE) return INVALID_OPERATION;
    435 
    436     sp<CameraDeviceBase> device = mDevice.promote();
    437     if (device == 0) {
    438         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    439         return INVALID_OPERATION;
    440     }
    441 
    442     ALOGV("%s: Camera %d: type = %d", __FUNCTION__, mId, type);
    443 
    444     Mutex::Autolock m(mMutex);
    445 
    446     CameraMetadata &request = (type == PREVIEW) ?
    447             mPreviewRequest : mRecordingRequest;
    448 
    449     res = request.update(
    450         ANDROID_REQUEST_OUTPUT_STREAMS,
    451         outputStreams);
    452     if (res != OK) {
    453         ALOGE("%s: Camera %d: Unable to set up preview request: %s (%d)",
    454                 __FUNCTION__, mId, strerror(-res), res);
    455         return res;
    456     }
    457 
    458     res = request.sort();
    459     if (res != OK) {
    460         ALOGE("%s: Camera %d: Error sorting preview request: %s (%d)",
    461                 __FUNCTION__, mId, strerror(-res), res);
    462         return res;
    463     }
    464 
    465     res = device->setStreamingRequest(request);
    466     if (res != OK) {
    467         ALOGE("%s: Camera %d: Unable to set preview request to start preview: "
    468                 "%s (%d)",
    469                 __FUNCTION__, mId, strerror(-res), res);
    470         return res;
    471     }
    472     mActiveRequest = type;
    473     mPaused = false;
    474     mActiveStreamIds = outputStreams;
    475     return OK;
    476 }
    477 
    478 status_t StreamingProcessor::togglePauseStream(bool pause) {
    479     ATRACE_CALL();
    480     status_t res;
    481 
    482     sp<CameraDeviceBase> device = mDevice.promote();
    483     if (device == 0) {
    484         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    485         return INVALID_OPERATION;
    486     }
    487 
    488     ALOGV("%s: Camera %d: toggling pause to %d", __FUNCTION__, mId, pause);
    489 
    490     Mutex::Autolock m(mMutex);
    491 
    492     if (mActiveRequest == NONE) {
    493         ALOGE("%s: Camera %d: Can't toggle pause, streaming was not started",
    494               __FUNCTION__, mId);
    495         return INVALID_OPERATION;
    496     }
    497 
    498     if (mPaused == pause) {
    499         return OK;
    500     }
    501 
    502     if (pause) {
    503         res = device->clearStreamingRequest();
    504         if (res != OK) {
    505             ALOGE("%s: Camera %d: Can't clear stream request: %s (%d)",
    506                     __FUNCTION__, mId, strerror(-res), res);
    507             return res;
    508         }
    509     } else {
    510         CameraMetadata &request =
    511                 (mActiveRequest == PREVIEW) ? mPreviewRequest
    512                                             : mRecordingRequest;
    513         res = device->setStreamingRequest(request);
    514         if (res != OK) {
    515             ALOGE("%s: Camera %d: Unable to set preview request to resume: "
    516                     "%s (%d)",
    517                     __FUNCTION__, mId, strerror(-res), res);
    518             return res;
    519         }
    520     }
    521 
    522     mPaused = pause;
    523     return OK;
    524 }
    525 
    526 status_t StreamingProcessor::stopStream() {
    527     ATRACE_CALL();
    528     status_t res;
    529 
    530     Mutex::Autolock m(mMutex);
    531 
    532     sp<CameraDeviceBase> device = mDevice.promote();
    533     if (device == 0) {
    534         ALOGE("%s: Camera %d: Device does not exist", __FUNCTION__, mId);
    535         return INVALID_OPERATION;
    536     }
    537 
    538     res = device->clearStreamingRequest();
    539     if (res != OK) {
    540         ALOGE("%s: Camera %d: Can't clear stream request: %s (%d)",
    541                 __FUNCTION__, mId, strerror(-res), res);
    542         return res;
    543     }
    544 
    545     mActiveRequest = NONE;
    546     mActiveStreamIds.clear();
    547     mPaused = false;
    548 
    549     return OK;
    550 }
    551 
    552 int32_t StreamingProcessor::getActiveRequestId() const {
    553     Mutex::Autolock m(mMutex);
    554     switch (mActiveRequest) {
    555         case NONE:
    556             return 0;
    557         case PREVIEW:
    558             return mPreviewRequestId;
    559         case RECORD:
    560             return mRecordingRequestId;
    561         default:
    562             ALOGE("%s: Unexpected mode %d", __FUNCTION__, mActiveRequest);
    563             return 0;
    564     }
    565 }
    566 
    567 status_t StreamingProcessor::incrementStreamingIds() {
    568     ATRACE_CALL();
    569     Mutex::Autolock m(mMutex);
    570 
    571     mPreviewRequestId++;
    572     if (mPreviewRequestId >= Camera2Client::kPreviewRequestIdEnd) {
    573         mPreviewRequestId = Camera2Client::kPreviewRequestIdStart;
    574     }
    575     mRecordingRequestId++;
    576     if (mRecordingRequestId >= Camera2Client::kRecordingRequestIdEnd) {
    577         mRecordingRequestId = Camera2Client::kRecordingRequestIdStart;
    578     }
    579     return OK;
    580 }
    581 
    582 status_t StreamingProcessor::dump(int fd, const Vector<String16>& /*args*/) {
    583     String8 result;
    584 
    585     result.append("  Current requests:\n");
    586     if (mPreviewRequest.entryCount() != 0) {
    587         result.append("    Preview request:\n");
    588         write(fd, result.string(), result.size());
    589         mPreviewRequest.dump(fd, 2, 6);
    590         result.clear();
    591     } else {
    592         result.append("    Preview request: undefined\n");
    593     }
    594 
    595     if (mRecordingRequest.entryCount() != 0) {
    596         result = "    Recording request:\n";
    597         write(fd, result.string(), result.size());
    598         mRecordingRequest.dump(fd, 2, 6);
    599         result.clear();
    600     } else {
    601         result = "    Recording request: undefined\n";
    602     }
    603 
    604     const char* streamTypeString[] = {
    605         "none", "preview", "record"
    606     };
    607     result.append(String8::format("   Active request: %s (paused: %s)\n",
    608                                   streamTypeString[mActiveRequest],
    609                                   mPaused ? "yes" : "no"));
    610 
    611     write(fd, result.string(), result.size());
    612 
    613     return OK;
    614 }
    615 
    616 }; // namespace camera2
    617 }; // namespace android
    618