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

Commit 0a6dc6a2 authored by Austin Borger's avatar Austin Borger Committed by Android (Google) Code Review
Browse files

Merge "Camera VTS: Add test validating stream configuration metadata" into udc-dev

parents 67eafddd 0918fc86
Loading
Loading
Loading
Loading
+41 −0
Original line number Diff line number Diff line
@@ -3051,6 +3051,47 @@ TEST_P(CameraAidlTest, configureStreamsUseCases) {
    configureStreamUseCaseInternal(previewStreamThreshold);
}

// Validate the integrity of stream configuration metadata
TEST_P(CameraAidlTest, validateStreamConfigurations) {
    std::vector<std::string> cameraDeviceNames = getCameraDeviceNames(mProvider);
    std::vector<AvailableStream> outputStreams;

    const int32_t scalerSizesTag = ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS;
    const int32_t scalerMinFrameDurationsTag = ANDROID_SCALER_AVAILABLE_MIN_FRAME_DURATIONS;
    const int32_t scalerStallDurationsTag = ANDROID_SCALER_AVAILABLE_STALL_DURATIONS;

    for (const auto& name : cameraDeviceNames) {
        CameraMetadata meta;
        std::shared_ptr<ICameraDevice> cameraDevice;

        openEmptyDeviceSession(name, mProvider, &mSession /*out*/, &meta /*out*/,
                               &cameraDevice /*out*/);
        camera_metadata_t* staticMeta = reinterpret_cast<camera_metadata_t*>(meta.metadata.data());

        if (is10BitDynamicRangeCapable(staticMeta)) {
            std::vector<std::tuple<size_t, size_t>> supportedP010Sizes, supportedBlobSizes;

            getSupportedSizes(staticMeta, scalerSizesTag, HAL_PIXEL_FORMAT_BLOB,
                              &supportedBlobSizes);
            getSupportedSizes(staticMeta, scalerSizesTag, HAL_PIXEL_FORMAT_YCBCR_P010,
                              &supportedP010Sizes);
            ASSERT_FALSE(supportedP010Sizes.empty());

            std::vector<int64_t> blobMinDurations, blobStallDurations;
            getSupportedDurations(staticMeta, scalerMinFrameDurationsTag, HAL_PIXEL_FORMAT_BLOB,
                                  supportedP010Sizes, &blobMinDurations);
            getSupportedDurations(staticMeta, scalerStallDurationsTag, HAL_PIXEL_FORMAT_BLOB,
                                  supportedP010Sizes, &blobStallDurations);
            ASSERT_FALSE(blobStallDurations.empty());
            ASSERT_FALSE(blobMinDurations.empty());
            ASSERT_EQ(supportedP010Sizes.size(), blobMinDurations.size());
            ASSERT_EQ(blobMinDurations.size(), blobStallDurations.size());
        }

        // Validate other aspects of stream configuration metadata...
    }
}

GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(CameraAidlTest);
INSTANTIATE_TEST_SUITE_P(
        PerInstance, CameraAidlTest,
+45 −0
Original line number Diff line number Diff line
@@ -3703,3 +3703,48 @@ void CameraAidlTest::processZoomSettingsOverrideRequests(
        ASSERT_TRUE(ret.isOk());
    }
}

void CameraAidlTest::getSupportedSizes(const camera_metadata_t* ch, uint32_t tag, int32_t format,
                                       std::vector<std::tuple<size_t, size_t>>* sizes /*out*/) {
    if (sizes == nullptr) {
        return;
    }

    camera_metadata_ro_entry entry;
    int retcode = find_camera_metadata_ro_entry(ch, tag, &entry);
    if ((0 == retcode) && (entry.count > 0)) {
        // Scaler entry contains 4 elements (format, width, height, type)
        for (size_t i = 0; i < entry.count; i += 4) {
            if ((entry.data.i32[i] == format) &&
                (entry.data.i32[i + 3] == ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT)) {
                sizes->push_back(std::make_tuple(entry.data.i32[i + 1], entry.data.i32[i + 2]));
            }
        }
    }
}

void CameraAidlTest::getSupportedDurations(const camera_metadata_t* ch, uint32_t tag,
                                           int32_t format,
                                           const std::vector<std::tuple<size_t, size_t>>& sizes,
                                           std::vector<int64_t>* durations /*out*/) {
    if (durations == nullptr) {
        return;
    }

    camera_metadata_ro_entry entry;
    int retcode = find_camera_metadata_ro_entry(ch, tag, &entry);
    if ((0 == retcode) && (entry.count > 0)) {
        // Duration entry contains 4 elements (format, width, height, duration)
        for (const auto& size : sizes) {
            int64_t width = std::get<0>(size);
            int64_t height = std::get<1>(size);
            for (size_t i = 0; i < entry.count; i += 4) {
                if ((entry.data.i64[i] == format) && (entry.data.i64[i + 1] == width) &&
                    (entry.data.i64[i + 2] == height)) {
                    durations->push_back(entry.data.i64[i + 3]);
                    break;
                }
            }
        }
    }
}
+7 −0
Original line number Diff line number Diff line
@@ -418,6 +418,13 @@ class CameraAidlTest : public ::testing::TestWithParam<std::string> {
    bool supportsCroppedRawUseCase(const camera_metadata_t *staticMeta);
    bool isPerFrameControl(const camera_metadata_t* staticMeta);

    void getSupportedSizes(const camera_metadata_t* ch, uint32_t tag, int32_t format,
                           std::vector<std::tuple<size_t, size_t>>* sizes /*out*/);

    void getSupportedDurations(const camera_metadata_t* ch, uint32_t tag, int32_t format,
                               const std::vector<std::tuple<size_t, size_t>>& sizes,
                               std::vector<int64_t>* durations /*out*/);

  protected:
    // In-flight queue for tracking completion of capture requests.
    struct InFlightRequest {