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

Commit de1909e8 authored by Jayant Chowdhary's avatar Jayant Chowdhary
Browse files

Camera: Add metadata support for cropped RAW streams. 



Bug: 247524520

Test: Camera CTS
Test: Camera VTS

Change-Id: Ie50359aca3fbbd6088e2e1525cca85c7d5eb0ad0
Signed-off-by: default avatarJayant Chowdhary <jchowdhary@google.com>
parent ba335e94

camera/metadata/aidl/aidl_api/android.hardware.camera.metadata/current/android/hardware/camera/metadata/CameraMetadataTag.aidl

+1 −0
Original line number Diff line number Diff line
@@ -204,6 +204,7 @@ enum CameraMetadataTag { 
  ANDROID_SCALER_AVAILABLE_INPUT_OUTPUT_FORMATS_MAP_MAXIMUM_RESOLUTION = 851991,

  ANDROID_SCALER_MULTI_RESOLUTION_STREAM_SUPPORTED = 851992,

  ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES = 851994,

  ANDROID_SCALER_RAW_CROP_REGION = 851995,

  ANDROID_SENSOR_EXPOSURE_TIME = 917504,

  ANDROID_SENSOR_FRAME_DURATION = 917505,

  ANDROID_SENSOR_SENSITIVITY = 917506,

camera/metadata/aidl/aidl_api/android.hardware.camera.metadata/current/android/hardware/camera/metadata/ScalerAvailableStreamUseCases.aidl

+1 −0
Original line number Diff line number Diff line
@@ -44,5 +44,6 @@ enum ScalerAvailableStreamUseCases { 
  ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD = 3,

  ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL = 4,

  ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL = 5,

  ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW = 6,

  ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START = 65536,

}

camera/metadata/aidl/android/hardware/camera/metadata/CameraMetadataTag.aidl

+7 −0
Original line number Diff line number Diff line
@@ -1283,6 +1283,13 @@ enum CameraMetadataTag { 
     * <p>The stream use cases supported by this camera device.</p>

     */

    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES = 851994,

    /**

     * android.scaler.rawCropRegion [dynamic, int32[], public]

     *

     * <p>The region of the sensor that corresponds to the RAW read out for this

     * capture when the stream use case of a RAW stream is set to CROPPED_RAW.</p>

     */

    ANDROID_SCALER_RAW_CROP_REGION,

    /**

     * android.sensor.exposureTime [dynamic, int64, public]

     *

camera/metadata/aidl/android/hardware/camera/metadata/ScalerAvailableStreamUseCases.aidl

+1 −0
Original line number Diff line number Diff line
@@ -35,5 +35,6 @@ enum ScalerAvailableStreamUseCases { 
    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_RECORD = 0x3L,

    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_PREVIEW_VIDEO_STILL = 0x4L,

    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL = 0x5L,

    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_CROPPED_RAW = 0x6L,

    ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VENDOR_START = 0x10000L,

}

camera/provider/aidl/vts/VtsAidlHalCameraProvider_TargetTest.cpp

+10 −103
Original line number Diff line number Diff line
@@ -3035,111 +3035,18 @@ TEST_P(CameraAidlTest, configureInjectionStreamsWithSessionParameters) { 
    }

}



TEST_P(CameraAidlTest, configureStreamsUseCasesCroppedRaw) {

    AvailableStream rawStreamThreshold =

            {INT_MAX, INT_MAX, static_cast<int32_t>(PixelFormat::RAW16)};

    configureStreamUseCaseInternal(rawStreamThreshold);

}



// Verify that  valid stream use cases can be configured successfully, and invalid use cases

// fail stream configuration.

TEST_P(CameraAidlTest, configureStreamsUseCases) {

    std::vector<std::string> cameraDeviceNames = getCameraDeviceNames(mProvider);



    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());

        // Check if camera support depth only

        if (isDepthOnly(staticMeta)) {

            ndk::ScopedAStatus ret = mSession->close();

            mSession = nullptr;

            ASSERT_TRUE(ret.isOk());

            continue;

        }



        std::vector<AvailableStream> outputPreviewStreams;

        AvailableStream previewThreshold = {kMaxPreviewWidth, kMaxPreviewHeight,

                                            static_cast<int32_t>(PixelFormat::YCBCR_420_888)};

        ASSERT_EQ(Status::OK,

                  getAvailableOutputStreams(staticMeta, outputPreviewStreams, &previewThreshold));

        ASSERT_NE(0u, outputPreviewStreams.size());



        // Combine valid and invalid stream use cases

        std::vector<int64_t> useCases(kMandatoryUseCases);

        useCases.push_back(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_VIDEO_CALL + 1);



        std::vector<int64_t> supportedUseCases;

        camera_metadata_ro_entry entry;

        auto retcode = find_camera_metadata_ro_entry(

                staticMeta, ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES, &entry);

        if ((0 == retcode) && (entry.count > 0)) {

            supportedUseCases.insert(supportedUseCases.end(), entry.data.i64,

                                     entry.data.i64 + entry.count);

        } else {

            supportedUseCases.push_back(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT);

        }



        std::vector<Stream> streams(1);

        streams[0] = {0,

                      StreamType::OUTPUT,

                      outputPreviewStreams[0].width,

                      outputPreviewStreams[0].height,

                      static_cast<PixelFormat>(outputPreviewStreams[0].format),

                      static_cast<::aidl::android::hardware::graphics::common::BufferUsage>(

                              GRALLOC1_CONSUMER_USAGE_CPU_READ),

                      Dataspace::UNKNOWN,

                      StreamRotation::ROTATION_0,

                      std::string(),

                      0,

                      -1,

                      {SensorPixelMode::ANDROID_SENSOR_PIXEL_MODE_DEFAULT},

                      RequestAvailableDynamicRangeProfilesMap::

                              ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD};



        int32_t streamConfigCounter = 0;

        CameraMetadata req;

        StreamConfiguration config;

        RequestTemplate reqTemplate = RequestTemplate::STILL_CAPTURE;

        ndk::ScopedAStatus ret = mSession->constructDefaultRequestSettings(reqTemplate, &req);

        ASSERT_TRUE(ret.isOk());

        config.sessionParams = req;



        for (int64_t useCase : useCases) {

            bool useCaseSupported = std::find(supportedUseCases.begin(), supportedUseCases.end(),

                                              useCase) != supportedUseCases.end();



            streams[0].useCase = static_cast<

                    aidl::android::hardware::camera::metadata::ScalerAvailableStreamUseCases>(

                    useCase);

            config.streams = streams;

            config.operationMode = StreamConfigurationMode::NORMAL_MODE;

            config.streamConfigCounter = streamConfigCounter;

            config.multiResolutionInputImage = false;



            bool combSupported;

            ret = cameraDevice->isStreamCombinationSupported(config, &combSupported);

            if (static_cast<int32_t>(Status::OPERATION_NOT_SUPPORTED) ==

                ret.getServiceSpecificError()) {

                continue;

            }



            ASSERT_TRUE(ret.isOk());

            ASSERT_EQ(combSupported, useCaseSupported);



            std::vector<HalStream> halStreams;

            ret = mSession->configureStreams(config, &halStreams);

            ALOGI("configureStreams returns status: %d", ret.getServiceSpecificError());

            if (useCaseSupported) {

                ASSERT_TRUE(ret.isOk());

                ASSERT_EQ(1u, halStreams.size());

            } else {

                ASSERT_EQ(static_cast<int32_t>(Status::ILLEGAL_ARGUMENT),

                          ret.getServiceSpecificError());

            }

        }

        ret = mSession->close();

        mSession = nullptr;

        ASSERT_TRUE(ret.isOk());

    }

    AvailableStream previewStreamThreshold =

            {kMaxPreviewWidth, kMaxPreviewHeight, static_cast<int32_t>(PixelFormat::YCBCR_420_888)};

    configureStreamUseCaseInternal(previewStreamThreshold);

}



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(CameraAidlTest);