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

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

Merge "gralloc: enforce aidl and hidl types are the same"

parents 3d8c78c3 5b28548c

services/surfaceflinger/tests/Android.bp

+4 −0
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ cc_test { 
    test_suites: ["device-tests"],

    srcs: [

        "BufferGenerator.cpp",

        "CommonTypes_test.cpp",

        "Credentials_test.cpp",

        "DereferenceSurfaceControl_test.cpp",

        "DisplayActiveConfig_test.cpp",
@@ -41,6 +42,8 @@ cc_test { 
        "libtrace_proto",

    ],

    shared_libs: [

        "android.hardware.graphics.common@1.2",

        "android.hardware.graphics.composer@2.1",

        "libandroid",

        "libbinder",

        "libcutils",
@@ -53,6 +56,7 @@ cc_test { 
        "libtimestats_proto",

        "libui",

        "libutils",

        "vintf-graphics-common-ndk_platform",

    ]

}

services/surfaceflinger/tests/CommonTypes_test.cpp

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

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

 */

#include <aidl/android/hardware/graphics/common/BlendMode.h>

#include <aidl/android/hardware/graphics/common/Dataspace.h>



#include <android/hardware/graphics/common/1.2/types.h>

#include <android/hardware/graphics/composer/2.1/IComposerClient.h>



using AidlBlendMode = aidl::android::hardware::graphics::common::BlendMode;

using AidlDataspace = aidl::android::hardware::graphics::common::Dataspace;



using HidlBlendMode = android::hardware::graphics::composer::V2_1::IComposerClient::BlendMode;

using HidlDataspace = android::hardware::graphics::common::V1_2::Dataspace;



static_assert(static_cast<uint32_t>(AidlBlendMode::INVALID) ==

              static_cast<uint32_t>(HidlBlendMode::INVALID));

static_assert(static_cast<uint32_t>(AidlBlendMode::NONE) ==

              static_cast<uint32_t>(HidlBlendMode::NONE));

static_assert(static_cast<uint32_t>(AidlBlendMode::PREMULTIPLIED) ==

              static_cast<uint32_t>(HidlBlendMode::PREMULTIPLIED));

static_assert(static_cast<uint32_t>(AidlBlendMode::COVERAGE) ==

              static_cast<uint32_t>(HidlBlendMode::COVERAGE));



static_assert(static_cast<uint32_t>(AidlDataspace::UNKNOWN) ==

              static_cast<uint32_t>(HidlDataspace::UNKNOWN));

static_assert(static_cast<uint32_t>(AidlDataspace::ARBITRARY) ==

              static_cast<uint32_t>(HidlDataspace::ARBITRARY));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_SHIFT) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_SHIFT));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_MASK) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_MASK));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_UNSPECIFIED) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_UNSPECIFIED));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT709) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT709));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_625) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_625));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_625_UNADJUSTED) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_625_UNADJUSTED));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_525) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_525));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT601_525_UNADJUSTED) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT601_525_UNADJUSTED));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT2020) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT2020));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT2020_CONSTANT_LUMINANCE) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT2020_CONSTANT_LUMINANCE));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_BT470M) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_BT470M));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_FILM) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_FILM));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_DCI_P3) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_DCI_P3));

static_assert(static_cast<uint32_t>(AidlDataspace::STANDARD_ADOBE_RGB) ==

              static_cast<uint32_t>(HidlDataspace::STANDARD_ADOBE_RGB));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_SHIFT) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_SHIFT));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_MASK) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_MASK));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_UNSPECIFIED) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_UNSPECIFIED));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_SRGB) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_SRGB));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_SMPTE_170M) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_SMPTE_170M));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_GAMMA2_2) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_GAMMA2_2));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_GAMMA2_6) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_GAMMA2_6));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_GAMMA2_8) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_GAMMA2_8));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_ST2084) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_ST2084));

static_assert(static_cast<uint32_t>(AidlDataspace::TRANSFER_HLG) ==

              static_cast<uint32_t>(HidlDataspace::TRANSFER_HLG));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_SHIFT) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_SHIFT));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_MASK) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_MASK));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_UNSPECIFIED) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_UNSPECIFIED));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_FULL) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_FULL));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_LIMITED) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_LIMITED));

static_assert(static_cast<uint32_t>(AidlDataspace::RANGE_EXTENDED) ==

              static_cast<uint32_t>(HidlDataspace::RANGE_EXTENDED));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_SRGB_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::V0_SRGB_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_SCRGB_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::V0_SCRGB_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_SRGB) ==

              static_cast<uint32_t>(HidlDataspace::V0_SRGB));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_SCRGB) ==

              static_cast<uint32_t>(HidlDataspace::V0_SCRGB));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_JFIF) ==

              static_cast<uint32_t>(HidlDataspace::V0_JFIF));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_BT601_625) ==

              static_cast<uint32_t>(HidlDataspace::V0_BT601_625));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_BT601_525) ==

              static_cast<uint32_t>(HidlDataspace::V0_BT601_525));

static_assert(static_cast<uint32_t>(AidlDataspace::V0_BT709) ==

              static_cast<uint32_t>(HidlDataspace::V0_BT709));

static_assert(static_cast<uint32_t>(AidlDataspace::DCI_P3_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::DCI_P3_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::DCI_P3) ==

              static_cast<uint32_t>(HidlDataspace::DCI_P3));

static_assert(static_cast<uint32_t>(AidlDataspace::DISPLAY_P3_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::DISPLAY_P3_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::DISPLAY_P3) ==

              static_cast<uint32_t>(HidlDataspace::DISPLAY_P3));

static_assert(static_cast<uint32_t>(AidlDataspace::ADOBE_RGB) ==

              static_cast<uint32_t>(HidlDataspace::ADOBE_RGB));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_LINEAR) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020) ==

              static_cast<uint32_t>(HidlDataspace::BT2020));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_PQ) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_PQ));

static_assert(static_cast<uint32_t>(AidlDataspace::DEPTH) ==

              static_cast<uint32_t>(HidlDataspace::DEPTH));

static_assert(static_cast<uint32_t>(AidlDataspace::SENSOR) ==

              static_cast<uint32_t>(HidlDataspace::SENSOR));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_ITU) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_ITU));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_ITU_PQ) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_ITU_PQ));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_ITU_HLG) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_ITU_HLG));

static_assert(static_cast<uint32_t>(AidlDataspace::BT2020_HLG) ==

              static_cast<uint32_t>(HidlDataspace::BT2020_HLG));

static_assert(static_cast<uint32_t>(AidlDataspace::DISPLAY_BT2020) ==

              static_cast<uint32_t>(HidlDataspace::DISPLAY_BT2020));

static_assert(static_cast<uint32_t>(AidlDataspace::DYNAMIC_DEPTH) ==

              static_cast<uint32_t>(HidlDataspace::DYNAMIC_DEPTH));

static_assert(static_cast<uint32_t>(AidlDataspace::JPEG_APP_SEGMENTS) ==

              static_cast<uint32_t>(HidlDataspace::JPEG_APP_SEGMENTS));

static_assert(static_cast<uint32_t>(AidlDataspace::HEIF) ==

              static_cast<uint32_t>(HidlDataspace::HEIF));



// Below are the dataspaces that have been deprecated for sometime. They are required to behave

// the same as their V0_* counterparts. We redefined them in AIDL to be the same as the

// their V0_* counterparts.

static_assert(static_cast<uint32_t>(AidlDataspace::SRGB_LINEAR) ==

              static_cast<uint32_t>(AidlDataspace::V0_SRGB_LINEAR));

static_assert(static_cast<uint32_t>(AidlDataspace::SRGB) ==

              static_cast<uint32_t>(AidlDataspace::V0_SRGB));

static_assert(static_cast<uint32_t>(AidlDataspace::JFIF) ==

              static_cast<uint32_t>(AidlDataspace::V0_JFIF));

static_assert(static_cast<uint32_t>(AidlDataspace::BT601_625) ==

              static_cast<uint32_t>(AidlDataspace::V0_BT601_625));

static_assert(static_cast<uint32_t>(AidlDataspace::BT601_525) ==

              static_cast<uint32_t>(AidlDataspace::V0_BT601_525));

static_assert(static_cast<uint32_t>(AidlDataspace::BT709) ==

              static_cast<uint32_t>(AidlDataspace::V0_BT709));