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

Commit ff805c11 authored by Shuzhen Wang's avatar Shuzhen Wang
Browse files

Camera: VTS: Adjust test to handle optional readoutTimestamp support 

With readout timestamp support becomes optional in b/309543399, we
need to adjust the VTS test to handle it.

Test: vendor testing
Bug: 354875531
Change-Id: I552b223f7834df83b8c0bae9f23ab7393a42b64a
parent 09315923

camera/device/aidl/android/hardware/camera/device/ShutterMsg.aidl

+3 −0
Original line number Original line Diff line number Diff line
@@ -40,6 +40,9 @@ parcelable ShutterMsg { 
     * as timestamp, and for a rolling shutter sensor, the value must be

     * as timestamp, and for a rolling shutter sensor, the value must be

     * timestamp + exposureTime + t_crop_top where t_crop_top is the exposure time

     * timestamp + exposureTime + t_crop_top where t_crop_top is the exposure time

     * skew of the cropped lines on the top.

     * skew of the cropped lines on the top.

     *

     * If ANDROID_SENSOR_READOUT_TIMESTAMP is set to NOT_SUPPORTED, this field

     * will be ignored by the camera framework.

     */

     */

    long readoutTimestamp;

    long readoutTimestamp;

}
 
}

camera/provider/aidl/vts/camera_aidl_test.cpp

+26 −9
Original line number Original line Diff line number Diff line
@@ -456,6 +456,22 @@ Status CameraAidlTest::isLogicalMultiCamera(const camera_metadata_t* staticMeta) 
    return ret;

    return ret;

}

}





bool CameraAidlTest::isReadoutTimestampSupported(const camera_metadata_t* staticMeta) {

    camera_metadata_ro_entry readoutTimestampEntry;

    int rc = find_camera_metadata_ro_entry(staticMeta, ANDROID_SENSOR_READOUT_TIMESTAMP,

                                           &readoutTimestampEntry);

    if (rc != 0) {

        ALOGI("%s: Failed to find ANDROID_SENSOR_READOUT_TIMESTAMP", __FUNCTION__);

        return true;

    }

    if (readoutTimestampEntry.count == 1 && !readoutTimestampEntry.data.u8[0]) {

        ALOGI("%s: readout timestamp not supported", __FUNCTION__);

        return false;

    }

    ALOGI("%s: readout timestamp supported", __FUNCTION__);

    return true;

}



void CameraAidlTest::verifyLogicalCameraResult(const camera_metadata_t* staticMetadata,

void CameraAidlTest::verifyLogicalCameraResult(const camera_metadata_t* staticMetadata,

                                               const std::vector<uint8_t>& resultMetadata) {

                                               const std::vector<uint8_t>& resultMetadata) {

    camera_metadata_t* metadata = (camera_metadata_t*)resultMetadata.data();

    camera_metadata_t* metadata = (camera_metadata_t*)resultMetadata.data();
@@ -2380,13 +2396,13 @@ void CameraAidlTest::processCaptureRequestInternal(uint64_t bufferUsage, 
            ASSERT_NE(inflightReq->resultOutputBuffers.size(), 0u);

            ASSERT_NE(inflightReq->resultOutputBuffers.size(), 0u);

            ASSERT_EQ(testStream.id, inflightReq->resultOutputBuffers[0].buffer.streamId);

            ASSERT_EQ(testStream.id, inflightReq->resultOutputBuffers[0].buffer.streamId);





            // shutterReadoutTimestamp must be available, and it must

            // shutterReadoutTimestamp, if supported, must

            // be >= shutterTimestamp + exposureTime,

            // be >= shutterTimestamp + exposureTime,

            // and < shutterTimestamp + exposureTime + rollingShutterSkew / 2.

            // and < shutterTimestamp + exposureTime + rollingShutterSkew / 2.

            ASSERT_TRUE(inflightReq->shutterReadoutTimestampValid);

            ASSERT_FALSE(inflightReq->collectedResult.isEmpty());

            ASSERT_FALSE(inflightReq->collectedResult.isEmpty());





            if (inflightReq->collectedResult.exists(ANDROID_SENSOR_EXPOSURE_TIME)) {

            if (mSupportReadoutTimestamp &&

                inflightReq->collectedResult.exists(ANDROID_SENSOR_EXPOSURE_TIME)) {

                camera_metadata_entry_t exposureTimeResult =

                camera_metadata_entry_t exposureTimeResult =

                        inflightReq->collectedResult.find(ANDROID_SENSOR_EXPOSURE_TIME);

                        inflightReq->collectedResult.find(ANDROID_SENSOR_EXPOSURE_TIME);

                nsecs_t exposureToReadout =

                nsecs_t exposureToReadout =
@@ -2901,13 +2917,14 @@ void CameraAidlTest::processPreviewStabilizationCaptureRequestInternal( 
            ASSERT_FALSE(inflightReq->errorCodeValid);

            ASSERT_FALSE(inflightReq->errorCodeValid);

            ASSERT_NE(inflightReq->resultOutputBuffers.size(), 0u);

            ASSERT_NE(inflightReq->resultOutputBuffers.size(), 0u);

            ASSERT_EQ(testStream.id, inflightReq->resultOutputBuffers[0].buffer.streamId);

            ASSERT_EQ(testStream.id, inflightReq->resultOutputBuffers[0].buffer.streamId);

            ASSERT_TRUE(inflightReq->shutterReadoutTimestampValid);

            nsecs_t captureTimestamp = mSupportReadoutTimestamp

            nsecs_t readoutTimestamp = inflightReq->shutterReadoutTimestamp;

                                               ? inflightReq->shutterReadoutTimestamp

                                               : inflightReq->shutterTimestamp;





            if (previewStabilizationOn) {

            if (previewStabilizationOn) {

                // Here we collect the time difference between the buffer ready

                // Here we collect the time difference between the buffer ready

                // timestamp - notify readout timestamp.

                // timestamp - notify timestamp.

                // timeLag = buffer ready timestamp - notify readout timestamp.

                // timeLag = buffer ready timestamp - notify timestamp.

                // timeLag(previewStabilization) must be <=

                // timeLag(previewStabilization) must be <=

                //        timeLag(stabilization off) + 1 frame duration.

                //        timeLag(stabilization off) + 1 frame duration.

                auto it = cameraDeviceToTimeLag.find(name);

                auto it = cameraDeviceToTimeLag.find(name);
@@ -2918,12 +2935,12 @@ void CameraAidlTest::processPreviewStabilizationCaptureRequestInternal( 
                ASSERT_TRUE(it != cameraDeviceToTimeLag.end());

                ASSERT_TRUE(it != cameraDeviceToTimeLag.end());





                nsecs_t previewStabOnLagTime =

                nsecs_t previewStabOnLagTime =

                        inflightReq->resultOutputBuffers[0].timeStamp - readoutTimestamp;

                        inflightReq->resultOutputBuffers[0].timeStamp - captureTimestamp;

                ASSERT_TRUE(previewStabOnLagTime <= (it->second + frameDuration));

                ASSERT_TRUE(previewStabOnLagTime <= (it->second + frameDuration));

            } else {

            } else {

                // Fill in the buffer ready timestamp - notify timestamp;

                // Fill in the buffer ready timestamp - notify timestamp;

                cameraDeviceToTimeLag[std::string(name)] =

                cameraDeviceToTimeLag[std::string(name)] =

                        inflightReq->resultOutputBuffers[0].timeStamp - readoutTimestamp;

                        inflightReq->resultOutputBuffers[0].timeStamp - captureTimestamp;

            }

            }

        }

        }

camera/provider/aidl/vts/camera_aidl_test.h

+4 −5
Original line number Original line Diff line number Diff line
@@ -346,6 +346,8 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> { 




    static Status isOfflineSessionSupported(const camera_metadata_t* staticMeta);

    static Status isOfflineSessionSupported(const camera_metadata_t* staticMeta);





    static bool isReadoutTimestampSupported(const camera_metadata_t* staticMeta);



    static Status getPhysicalCameraIds(const camera_metadata_t* staticMeta,

    static Status getPhysicalCameraIds(const camera_metadata_t* staticMeta,

                                       std::unordered_set<std::string>* physicalIds /*out*/);

                                       std::unordered_set<std::string>* physicalIds /*out*/);
@@ -456,8 +458,6 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> { 
    struct InFlightRequest {

    struct InFlightRequest {

        // Set by notify() SHUTTER call.

        // Set by notify() SHUTTER call.

        nsecs_t shutterTimestamp;

        nsecs_t shutterTimestamp;



        bool shutterReadoutTimestampValid;

        nsecs_t shutterReadoutTimestamp;

        nsecs_t shutterReadoutTimestamp;





        bool errorCodeValid;

        bool errorCodeValid;
@@ -523,7 +523,6 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> { 




        InFlightRequest()

        InFlightRequest()

            : shutterTimestamp(0),

            : shutterTimestamp(0),

              shutterReadoutTimestampValid(false),

              shutterReadoutTimestamp(0),

              shutterReadoutTimestamp(0),

              errorCodeValid(false),

              errorCodeValid(false),

              errorCode(ErrorCode::ERROR_BUFFER),

              errorCode(ErrorCode::ERROR_BUFFER),
@@ -541,7 +540,6 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> { 
        InFlightRequest(ssize_t numBuffers, bool hasInput, bool partialResults,

        InFlightRequest(ssize_t numBuffers, bool hasInput, bool partialResults,

                        int32_t partialCount, std::shared_ptr<ResultMetadataQueue> queue = nullptr)

                        int32_t partialCount, std::shared_ptr<ResultMetadataQueue> queue = nullptr)

            : shutterTimestamp(0),

            : shutterTimestamp(0),

              shutterReadoutTimestampValid(false),

              shutterReadoutTimestamp(0),

              shutterReadoutTimestamp(0),

              errorCodeValid(false),

              errorCodeValid(false),

              errorCode(ErrorCode::ERROR_BUFFER),

              errorCode(ErrorCode::ERROR_BUFFER),
@@ -561,7 +559,6 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> { 
                        const std::unordered_set<std::string>& extraPhysicalResult,

                        const std::unordered_set<std::string>& extraPhysicalResult,

                        std::shared_ptr<ResultMetadataQueue> queue = nullptr)

                        std::shared_ptr<ResultMetadataQueue> queue = nullptr)

            : shutterTimestamp(0),

            : shutterTimestamp(0),

              shutterReadoutTimestampValid(false),

              shutterReadoutTimestamp(0),

              shutterReadoutTimestamp(0),

              errorCodeValid(false),

              errorCodeValid(false),

              errorCode(ErrorCode::ERROR_BUFFER),

              errorCode(ErrorCode::ERROR_BUFFER),
@@ -631,6 +628,8 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> { 




    HandleImporter mHandleImporter;

    HandleImporter mHandleImporter;





    bool mSupportReadoutTimestamp;



    friend class DeviceCb;

    friend class DeviceCb;

    friend class SimpleDeviceCb;

    friend class SimpleDeviceCb;

    friend class TorchProviderCb;

    friend class TorchProviderCb;

camera/provider/aidl/vts/device_cb.cpp

+7 −8
Original line number Original line Diff line number Diff line
@@ -32,10 +32,11 @@ const int64_t kBufferReturnTimeoutSec = 1; 




DeviceCb::DeviceCb(CameraAidlTest* parent, camera_metadata_t* staticMeta) : mParent(parent) {

DeviceCb::DeviceCb(CameraAidlTest* parent, camera_metadata_t* staticMeta) : mParent(parent) {

    mStaticMetadata = staticMeta;

    mStaticMetadata = staticMeta;

    parent->mSupportReadoutTimestamp = CameraAidlTest::isReadoutTimestampSupported(staticMeta);

}

}





ScopedAStatus DeviceCb::notify(const std::vector<NotifyMsg>& msgs) {

ScopedAStatus DeviceCb::notify(const std::vector<NotifyMsg>& msgs) {

    std::vector<std::pair<bool, nsecs_t>> readoutTimestamps;

    std::vector<nsecs_t> readoutTimestamps;





    size_t count = msgs.size();

    size_t count = msgs.size();

    readoutTimestamps.resize(count);

    readoutTimestamps.resize(count);
@@ -44,11 +45,11 @@ ScopedAStatus DeviceCb::notify(const std::vector<NotifyMsg>& msgs) { 
        const NotifyMsg& msg = msgs[i];

        const NotifyMsg& msg = msgs[i];

        switch (msg.getTag()) {

        switch (msg.getTag()) {

            case NotifyMsg::Tag::error:

            case NotifyMsg::Tag::error:

                readoutTimestamps[i] = {false, 0};

                readoutTimestamps[i] = 0;

                break;

                break;

            case NotifyMsg::Tag::shutter:

            case NotifyMsg::Tag::shutter:

                const auto& shutter = msg.get<NotifyMsg::Tag::shutter>();

                const auto& shutter = msg.get<NotifyMsg::Tag::shutter>();

                readoutTimestamps[i] = {true, shutter.readoutTimestamp};

                readoutTimestamps[i] = shutter.readoutTimestamp;

                break;

                break;

        }

        }

    }

    }
@@ -446,9 +447,8 @@ bool DeviceCb::processCaptureResultLocked( 
    return notify;

    return notify;

}

}





ScopedAStatus DeviceCb::notifyHelper(

ScopedAStatus DeviceCb::notifyHelper(const std::vector<NotifyMsg>& msgs,

        const std::vector<NotifyMsg>& msgs,

                                     const std::vector<nsecs_t>& readoutTimestamps) {

        const std::vector<std::pair<bool, nsecs_t>>& readoutTimestamps) {

    std::lock_guard<std::mutex> l(mParent->mLock);

    std::lock_guard<std::mutex> l(mParent->mLock);





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

    for (size_t i = 0; i < msgs.size(); i++) {
@@ -514,8 +514,7 @@ ScopedAStatus DeviceCb::notifyHelper( 
                }

                }

                auto& r = itr->second;

                auto& r = itr->second;

                r->shutterTimestamp = msg.get<NotifyMsg::Tag::shutter>().timestamp;

                r->shutterTimestamp = msg.get<NotifyMsg::Tag::shutter>().timestamp;

                r->shutterReadoutTimestampValid = readoutTimestamps[i].first;

                r->shutterReadoutTimestamp = readoutTimestamps[i];

                r->shutterReadoutTimestamp = readoutTimestamps[i].second;

                break;

                break;

        }

        }

    }

    }

camera/provider/aidl/vts/device_cb.h

+1 −1
Original line number Original line Diff line number Diff line
@@ -60,7 +60,7 @@ class DeviceCb : public BnCameraDeviceCallback { 
    bool processCaptureResultLocked(const CaptureResult& results,

    bool processCaptureResultLocked(const CaptureResult& results,

                                    std::vector<PhysicalCameraMetadata> physicalCameraMetadata);

                                    std::vector<PhysicalCameraMetadata> physicalCameraMetadata);

    ScopedAStatus notifyHelper(const std::vector<NotifyMsg>& msgs,

    ScopedAStatus notifyHelper(const std::vector<NotifyMsg>& msgs,

                               const std::vector<std::pair<bool, nsecs_t>>& readoutTimestamps);

                               const std::vector<nsecs_t>& readoutTimestamps);





    CameraAidlTest* mParent;  // Parent object

    CameraAidlTest* mParent;  // Parent object