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

Commit aa9bdd09 authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 11504324 from e9ee96cd to 24Q2-release

Change-Id: I6de4223f7eab04c422400518cc3abd7dd7b52774
parents ffa24c14 e9ee96cd
Loading
Loading
Loading
Loading
+8 −2
Original line number Diff line number Diff line
@@ -65,8 +65,6 @@ namespace aidl::android::hardware::audio::effect {
const std::string SpatializerSw::kEffectName = "SpatializerSw";

const std::vector<Range::SpatializerRange> SpatializerSw::kRanges = {
        MAKE_RANGE(Spatializer, supportedChannelLayout, std::vector<AudioChannelLayout>{},
                   std::vector<AudioChannelLayout>{}),
        MAKE_RANGE(Spatializer, spatializationLevel, Spatialization::Level::NONE,
                   Spatialization::Level::BED_PLUS_OBJECTS),
        MAKE_RANGE(Spatializer, spatializationMode, Spatialization::Mode::BINAURAL,
@@ -175,11 +173,19 @@ std::optional<Spatializer> SpatializerSwContext::getParam(TAG tag) {
    if (mParamsMap.find(tag) != mParamsMap.end()) {
        return mParamsMap.at(tag);
    }
    if (tag == Spatializer::supportedChannelLayout) {
        return Spatializer::make<Spatializer::supportedChannelLayout>(
                {AudioChannelLayout::make<AudioChannelLayout::layoutMask>(
                        AudioChannelLayout::LAYOUT_5POINT1)});
    }
    return std::nullopt;
}

template <typename TAG>
ndk::ScopedAStatus SpatializerSwContext::setParam(TAG tag, Spatializer spatializer) {
    RETURN_IF(tag == Spatializer::supportedChannelLayout, EX_ILLEGAL_ARGUMENT,
              "supportedChannelLayoutGetOnly");

    mParamsMap[tag] = spatializer;
    return ndk::ScopedAStatus::ok();
}
+2 −1
Original line number Diff line number Diff line
@@ -67,8 +67,9 @@ Dataspace ReadbackHelper::getDataspaceForColorMode(ColorMode mode) {
        case ColorMode::DISPLAY_P3:
            return Dataspace::DISPLAY_P3;
        case ColorMode::SRGB:
            return Dataspace::SRGB;
        default:
            return common::Dataspace::UNKNOWN;
            return Dataspace::UNKNOWN;
    }
}

+77 −0
Original line number Diff line number Diff line
@@ -522,6 +522,83 @@ TEST_P(GraphicsCompositionTest, ClientComposition) {
    }
}

TEST_P(GraphicsCompositionTest, MixedColorSpaces) {
    ASSERT_TRUE(
            mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
                    .isOk());
    const auto& [status, properties] = mComposerClient->getOverlaySupport();
    if (!status.isOk() && status.getExceptionCode() == EX_SERVICE_SPECIFIC &&
        status.getServiceSpecificError() == IComposerClient::EX_UNSUPPORTED) {
        GTEST_SUCCEED() << "getOverlaySupport is not supported";
        return;
    }

    if (properties.supportMixedColorSpaces == false) {
        GTEST_SUCCEED() << "supportMixedColorSpaces is not supported";
        return;
    }

    for (ColorMode mode : mTestColorModes) {
        EXPECT_TRUE(mComposerClient
                            ->setColorMode(getPrimaryDisplayId(), mode, RenderIntent::COLORIMETRIC)
                            .isOk());

        bool isSupported;
        ASSERT_NO_FATAL_FAILURE(isSupported = getHasReadbackBuffer());
        if (!isSupported) {
            GTEST_SUCCEED() << "Readback not supported or unsupported pixelFormat/dataspace";
            return;
        }

        // sRGB layer
        auto srgbLayer = std::make_shared<TestBufferLayer>(
                mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
                getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
        std::vector<Color> sRgbDeviceColors(srgbLayer->getWidth() * srgbLayer->getHeight());
        ReadbackHelper::fillColorsArea(sRgbDeviceColors, getDisplayWidth(),
                                       {0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
                                        static_cast<int32_t>(srgbLayer->getHeight())},
                                       GREEN);
        srgbLayer->setDisplayFrame({0, 0, static_cast<int32_t>(srgbLayer->getWidth()),
                                    static_cast<int32_t>(srgbLayer->getHeight())});
        srgbLayer->setZOrder(10);
        srgbLayer->setDataspace(Dataspace::SRGB);
        ASSERT_NO_FATAL_FAILURE(srgbLayer->setBuffer(sRgbDeviceColors));

        // display P3 layer
        auto displayP3Layer = std::make_shared<TestBufferLayer>(
                mComposerClient, *mTestRenderEngine, getPrimaryDisplayId(), getDisplayWidth(),
                getDisplayHeight() / 2, PixelFormat::RGBA_8888, *mWriter);
        std::vector<Color> displayP3DeviceColors(
                static_cast<size_t>(displayP3Layer->getWidth() * displayP3Layer->getHeight()));
        ReadbackHelper::fillColorsArea(displayP3DeviceColors, getDisplayWidth(),
                                       {0, 0, static_cast<int32_t>(displayP3Layer->getWidth()),
                                        static_cast<int32_t>(displayP3Layer->getHeight())},
                                       RED);
        displayP3Layer->setDisplayFrame(
                {0, getDisplayHeight() / 2, getDisplayWidth(), getDisplayHeight()});
        displayP3Layer->setZOrder(10);
        displayP3Layer->setDataspace(Dataspace::DISPLAY_P3);
        ASSERT_NO_FATAL_FAILURE(displayP3Layer->setBuffer(displayP3DeviceColors));

        writeLayers({srgbLayer, displayP3Layer});

        mWriter->validateDisplay(getPrimaryDisplayId(), ComposerClientWriter::kNoTimestamp,
                                 VtsComposerClient::kNoFrameIntervalNs);
        execute();

        auto changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
        ASSERT_TRUE(changedCompositionTypes.empty());

        mWriter->presentDisplay(getPrimaryDisplayId());
        execute();

        changedCompositionTypes = mReader.takeChangedCompositionTypes(getPrimaryDisplayId());
        ASSERT_TRUE(changedCompositionTypes.empty());
        ASSERT_TRUE(mReader.takeErrors().empty());
    }
}

TEST_P(GraphicsCompositionTest, DeviceAndClientComposition) {
    ASSERT_TRUE(
            mComposerClient->setClientTargetSlotCount(getPrimaryDisplayId(), kClientTargetSlotCount)
+5 −4
Original line number Diff line number Diff line
@@ -1086,6 +1086,7 @@ TEST_P(NewKeyGenerationTest, RsaWithSpecifiedValidity) {
    };
    for (auto notBefore : test_vector_not_before_millis) {
        uint64_t notAfter = notBefore + 378691200000 /* 12 years milliseconds*/;
        SCOPED_TRACE(testing::Message() << "notBefore: " << notBefore << " notAfter: " << notAfter);
        ASSERT_EQ(ErrorCode::OK,
                  GenerateKey(AuthorizationSetBuilder()
                                      .RsaSigningKey(2048, 65537)
@@ -1101,14 +1102,14 @@ TEST_P(NewKeyGenerationTest, RsaWithSpecifiedValidity) {

        const ASN1_TIME* not_before = X509_get0_notBefore(cert.get());
        ASSERT_NE(not_before, nullptr);
        time_t not_before_time;
        ASSERT_EQ(ASN1_TIME_to_time_t(not_before, &not_before_time), 1);
        int64_t not_before_time;
        ASSERT_EQ(ASN1_TIME_to_posix(not_before, &not_before_time), 1);
        EXPECT_EQ(not_before_time, (notBefore / 1000));

        const ASN1_TIME* not_after = X509_get0_notAfter(cert.get());
        ASSERT_NE(not_after, nullptr);
        time_t not_after_time;
        ASSERT_EQ(ASN1_TIME_to_time_t(not_after, &not_after_time), 1);
        int64_t not_after_time;
        ASSERT_EQ(ASN1_TIME_to_posix(not_after, &not_after_time), 1);
        EXPECT_EQ(not_after_time, (notAfter / 1000));
    }
}
+1 −0
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ rust_test {
        "android.hardware.security.secretkeeper-V1-rust",
        "libauthgraph_boringssl",
        "libauthgraph_core",
        "libauthgraph_wire",
        "libauthgraph_vts_test",
        "libbinder_rs",
        "libciborium",
Loading