Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 2d6140b8 authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge changes from topic 'api1_zsl_rework' 

* changes:
  Camera2: Add native test for framework-backed ZSL
  Camera: Rework ZSL path when using API1 with HAL3
parents f26ad101 b12fb5d4

camera/tests/Android.mk

+2 −1
Original line number Diff line number Diff line
@@ -18,7 +18,8 @@ LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk 


LOCAL_SRC_FILES:= \

	VendorTagDescriptorTests.cpp \

	CameraBinderTests.cpp

	CameraBinderTests.cpp \

	CameraZSLTests.cpp



LOCAL_SHARED_LIBRARIES := \

	liblog \

camera/tests/CameraZSLTests.cpp

0 → 100644
+292 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2017 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.

 */



#define LOG_NDEBUG 0

#define LOG_TAG "CameraZSLTests"



#include <gtest/gtest.h>



#include <binder/ProcessState.h>

#include <utils/Errors.h>

#include <utils/Log.h>

#include <gui/Surface.h>

#include <gui/SurfaceComposerClient.h>

#include <camera/CameraParameters.h>

#include <camera/CameraMetadata.h>

#include <camera/Camera.h>

#include <android/hardware/ICameraService.h>



using namespace android;

using namespace android::hardware;



class CameraZSLTests : public ::testing::Test,

    public ::android::hardware::BnCameraClient {

protected:



    CameraZSLTests() : numCameras(0), mPreviewBufferCount(0),

    mAutoFocusMessage(false), mSnapshotNotification(false) {}



    //Gtest interface

    void SetUp() override;

    void TearDown() override;



    //CameraClient interface

    void notifyCallback(int32_t msgType, int32_t, int32_t) override;

    void dataCallback(int32_t msgType, const sp<IMemory>&,

            camera_frame_metadata_t *) override;

    void dataCallbackTimestamp(nsecs_t, int32_t,

            const sp<IMemory>&) override {};

    void recordingFrameHandleCallbackTimestamp(nsecs_t,

            native_handle_t*) override {};



    status_t waitForPreviewStart();

    status_t waitForEvent(Mutex &mutex, Condition &condition, bool &flag);



    mutable Mutex mPreviewLock;

    mutable Condition mPreviewCondition;

    mutable Mutex mAutoFocusLock;

    mutable Condition mAutoFocusCondition;

    mutable Mutex mSnapshotLock;

    mutable Condition mSnapshotCondition;



    int32_t numCameras;

    size_t mPreviewBufferCount;

    sp<ICameraService> mCameraService;

    sp<SurfaceComposerClient> mComposerClient;

    bool mAutoFocusMessage;

    bool mSnapshotNotification;

    static const int32_t kPreviewThreshold  = 8;

    static const nsecs_t kPreviewTimeout    = 5000000000;  // 5 [s.]

    static const nsecs_t kEventTimeout      = 10000000000; // 10 [s.]

};



void CameraZSLTests::SetUp() {

    ::android::binder::Status rc;

    ProcessState::self()->startThreadPool();

    sp<IServiceManager> sm = defaultServiceManager();

    sp<IBinder> binder = sm->getService(String16("media.camera"));

    mCameraService = interface_cast<ICameraService>(binder);

    rc = mCameraService->getNumberOfCameras(

            hardware::ICameraService::CAMERA_TYPE_ALL, &numCameras);

    EXPECT_TRUE(rc.isOk());



    mComposerClient = new SurfaceComposerClient;

    ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());

}



void CameraZSLTests::TearDown() {

    mCameraService.clear();

    mComposerClient->dispose();

}



void CameraZSLTests::notifyCallback(int32_t msgType, int32_t,

        int32_t) {

    if (CAMERA_MSG_FOCUS == msgType) {

        Mutex::Autolock l(mAutoFocusLock);

        mAutoFocusMessage = true;

        mAutoFocusCondition.broadcast();

    } else {

        ALOGV("%s: msgType: %d", __FUNCTION__, msgType);

    }

};



void CameraZSLTests::dataCallback(int32_t msgType, const sp<IMemory>& /*data*/,

        camera_frame_metadata_t *) {



    switch (msgType) {

    case CAMERA_MSG_PREVIEW_FRAME: {

        Mutex::Autolock l(mPreviewLock);

        mPreviewBufferCount++;

        mPreviewCondition.broadcast();

        break;

    }

    case CAMERA_MSG_COMPRESSED_IMAGE: {

        Mutex::Autolock l(mSnapshotLock);

        mSnapshotNotification = true;

        //TODO: Add checks on incoming Jpeg

        mSnapshotCondition.broadcast();

        break;

    }

    default:

        ALOGV("%s: msgType: %d", __FUNCTION__, msgType);

    }

};



status_t CameraZSLTests::waitForPreviewStart() {

    status_t rc = NO_ERROR;

    Mutex::Autolock l(mPreviewLock);

    mPreviewBufferCount = 0;



    while (mPreviewBufferCount < kPreviewThreshold) {

        rc = mPreviewCondition.waitRelative(mPreviewLock,

                kPreviewTimeout);

        if (NO_ERROR != rc) {

            break;

        }

    }



    return rc;

}



status_t CameraZSLTests::waitForEvent(Mutex &mutex,

        Condition &condition, bool &flag) {

    status_t rc = NO_ERROR;

    Mutex::Autolock l(mutex);

    flag = false;



    while (!flag) {

        rc = condition.waitRelative(mutex,

                kEventTimeout);

        if (NO_ERROR != rc) {

            break;

        }

    }



    return rc;

}



TEST_F(CameraZSLTests, TestAllPictureSizes) {

    ::android::binder::Status rc;



    for (int32_t cameraId = 0; cameraId < numCameras; cameraId++) {

        sp<Surface> previewSurface;

        sp<SurfaceControl> surfaceControl;

        sp<ICamera> cameraDevice;



        String16 cameraIdStr = String16(String8::format("%d", cameraId));

        bool isSupported = false;

        rc = mCameraService->supportsCameraApi(cameraIdStr,

                hardware::ICameraService::API_VERSION_1, &isSupported);

        EXPECT_TRUE(rc.isOk());



        // We only care about camera Camera1 ZSL support.

        if (!isSupported) {

            continue;

        }



        CameraMetadata metadata;

        rc = mCameraService->getCameraCharacteristics(cameraIdStr, &metadata);

        if (!rc.isOk()) {

            // The test is relevant only for cameras with Hal 3.x

            // support.

            continue;

        }

        EXPECT_FALSE(metadata.isEmpty());

        camera_metadata_entry_t availableCapabilities =

                metadata.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);

        EXPECT_TRUE(0 < availableCapabilities.count);

        bool isReprocessSupported = false;

        const uint8_t *caps = availableCapabilities.data.u8;

        for (size_t i = 0; i < availableCapabilities.count; i++) {

            if (ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING ==

                caps[i]) {

                isReprocessSupported = true;

                break;

            }

        }

        if (!isReprocessSupported) {

            // ZSL relies on this feature

            continue;

        }



        rc = mCameraService->connect(this, cameraId,

                String16("ZSLTest"), hardware::ICameraService::USE_CALLING_UID,

                hardware::ICameraService::USE_CALLING_PID, &cameraDevice);

        EXPECT_TRUE(rc.isOk());



        CameraParameters params(cameraDevice->getParameters());



        String8 focusModes(params.get(

                CameraParameters::KEY_SUPPORTED_FOCUS_MODES));

        bool isAFSupported = false;

        const char *focusMode = nullptr;

        if (focusModes.contains(CameraParameters::FOCUS_MODE_AUTO)) {

            // If supported 'auto' should be set by default

            isAFSupported = true;

        } else if (focusModes.contains(

                CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE)) {

            isAFSupported = true;

            focusMode = CameraParameters::FOCUS_MODE_CONTINUOUS_PICTURE;

        } else if (focusModes.contains(

                CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO)) {

            isAFSupported = true;

            focusMode = CameraParameters::FOCUS_MODE_CONTINUOUS_VIDEO;

        } else if (focusModes.contains(CameraParameters::FOCUS_MODE_MACRO)) {

            isAFSupported = true;

            focusMode = CameraParameters::FOCUS_MODE_MACRO;

        }



        if (!isAFSupported) {

            // AF state is needed

            continue;

        }



        if (nullptr != focusMode) {

            params.set(CameraParameters::KEY_FOCUS_MODE, focusMode);

            ASSERT_EQ(NO_ERROR, cameraDevice->setParameters(params.flatten()));

        }



        int previewWidth, previewHeight;

        params.getPreviewSize(&previewWidth, &previewHeight);

        ASSERT_TRUE((0 < previewWidth) && (0 < previewHeight));



        surfaceControl = mComposerClient->createSurface(

                String8("Test Surface"),

                previewWidth, previewHeight,

                CameraParameters::previewFormatToEnum(

                        params.getPreviewFormat()),

                GRALLOC_USAGE_HW_RENDER);



        ASSERT_TRUE(nullptr != surfaceControl.get());

        ASSERT_TRUE(surfaceControl->isValid());



        SurfaceComposerClient::openGlobalTransaction();

        ASSERT_EQ(NO_ERROR, surfaceControl->setLayer(0x7fffffff));

        ASSERT_EQ(NO_ERROR, surfaceControl->show());

        SurfaceComposerClient::closeGlobalTransaction();



        previewSurface = surfaceControl->getSurface();

        ASSERT_TRUE(previewSurface != NULL);

        ASSERT_EQ(NO_ERROR, cameraDevice->setPreviewTarget(

                previewSurface->getIGraphicBufferProducer()));



        cameraDevice->setPreviewCallbackFlag(

                CAMERA_FRAME_CALLBACK_FLAG_CAMCORDER);



        Vector<Size> pictureSizes;

        params.getSupportedPictureSizes(pictureSizes);

        for (size_t i = 0; i < pictureSizes.size(); i++) {

            params.setPictureSize(pictureSizes[i].width,

                    pictureSizes[i].height);

            ASSERT_EQ(NO_ERROR, cameraDevice->setParameters(params.flatten()));

            ASSERT_EQ(NO_ERROR, cameraDevice->startPreview());

            ASSERT_EQ(NO_ERROR, waitForPreviewStart());



            ASSERT_EQ(NO_ERROR, cameraDevice->autoFocus());

            ASSERT_EQ(NO_ERROR, waitForEvent(mAutoFocusLock,

                    mAutoFocusCondition, mAutoFocusMessage));



            ASSERT_EQ(NO_ERROR,

                    cameraDevice->takePicture(CAMERA_MSG_COMPRESSED_IMAGE));

            ASSERT_EQ(NO_ERROR, waitForEvent(mSnapshotLock, mSnapshotCondition,

                    mSnapshotNotification));

        }



        cameraDevice->stopPreview();

        rc = cameraDevice->disconnect();

        EXPECT_TRUE(rc.isOk());

    }

}

services/camera/libcameraservice/Android.mk

+0 −1
Original line number Diff line number Diff line
@@ -46,7 +46,6 @@ LOCAL_SRC_FILES := \ 
    device3/Camera3IOStreamBase.cpp \

    device3/Camera3InputStream.cpp \

    device3/Camera3OutputStream.cpp \

    device3/Camera3ZslStream.cpp \

    device3/Camera3DummyStream.cpp \

    device3/Camera3SharedOutputStream.cpp \

    device3/StatusTracker.cpp \

services/camera/libcameraservice/api1/client2/Parameters.cpp

+15 −3
Original line number Diff line number Diff line
@@ -911,14 +911,26 @@ status_t Parameters::initialize(const CameraMetadata *info, int deviceVersion) { 
            CameraParameters::FALSE);

    }



    bool isZslReprocessPresent = false;

    camera_metadata_ro_entry_t availableCapabilities =

        staticInfo(ANDROID_REQUEST_AVAILABLE_CAPABILITIES);

    if (0 < availableCapabilities.count) {

        const uint8_t *caps = availableCapabilities.data.u8;

        for (size_t i = 0; i < availableCapabilities.count; i++) {

            if (ANDROID_REQUEST_AVAILABLE_CAPABILITIES_PRIVATE_REPROCESSING ==

                caps[i]) {

                isZslReprocessPresent = true;

                break;

            }

        }

    }



    if (slowJpegMode || property_get_bool("camera.disable_zsl_mode", false)) {

        ALOGI("Camera %d: Disabling ZSL mode", cameraId);

        allowZslMode = false;

    } else {

        allowZslMode = true;

        allowZslMode = isZslReprocessPresent;

    }

    // TODO (b/34131351): turn ZSL back on after fixing the issue

    allowZslMode = false;



    ALOGI("%s: allowZslMode: %d slowJpegMode %d", __FUNCTION__, allowZslMode, slowJpegMode);

services/camera/libcameraservice/api1/client2/ZslProcessor.cpp

+307 −77

File changed.

Preview size limit exceeded, changes collapsed.