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

Commit efd99206 authored by Chia-I Wu's avatar Chia-I Wu
Browse files

graphics: make mapper 2.1 VTS utils more reusable 

Move V2_1::vts::Gralloc to android.hardware.graphics.mapper@2.1-vts.

Test: VTS
Change-Id: Iecb7fc3cb90b886ad2d9c23a5cab8aef2da6367f
parent 98923fcc

graphics/mapper/2.1/utils/OWNERS

0 → 100644
+4 −0
Original line number Diff line number Diff line 
# Graphics team

jessehall@google.com

olv@google.com

stoza@google.com

graphics/mapper/2.1/utils/vts/Android.bp

0 → 100644
+39 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2016 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.

//



cc_library_static {

    name: "android.hardware.graphics.mapper@2.1-vts",

    defaults: ["hidl_defaults"],

    srcs: ["MapperVts.cpp"],

    cflags: [

        "-O0",

        "-g",

    ],

    static_libs: [

        "VtsHalHidlTargetTestBase",

        "android.hardware.graphics.allocator@2.0",

        "android.hardware.graphics.mapper@2.0",

        "android.hardware.graphics.mapper@2.0-vts",

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

    ],

    export_static_lib_headers: [

        "android.hardware.graphics.allocator@2.0",

        "android.hardware.graphics.mapper@2.0",

        "android.hardware.graphics.mapper@2.0-vts",

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

    ],

    export_include_dirs: ["include"],

}

graphics/mapper/2.1/utils/vts/MapperVts.cpp

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

 * Copyright (C) 2017 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 <mapper-vts/2.1/MapperVts.h>



#include <VtsHalHidlTargetTestBase.h>



namespace android {

namespace hardware {

namespace graphics {

namespace mapper {

namespace V2_1 {

namespace vts {



using V2_0::Error;



// abuse VTS to check binary compatibility between BufferDescriptorInfos

using OldBufferDescriptorInfo =

    android::hardware::graphics::mapper::V2_0::IMapper::BufferDescriptorInfo;

static_assert(sizeof(OldBufferDescriptorInfo) == sizeof(IMapper::BufferDescriptorInfo) &&

                  offsetof(OldBufferDescriptorInfo, width) ==

                      offsetof(IMapper::BufferDescriptorInfo, width) &&

                  offsetof(OldBufferDescriptorInfo, height) ==

                      offsetof(IMapper::BufferDescriptorInfo, height) &&

                  offsetof(OldBufferDescriptorInfo, layerCount) ==

                      offsetof(IMapper::BufferDescriptorInfo, layerCount) &&

                  offsetof(OldBufferDescriptorInfo, format) ==

                      offsetof(IMapper::BufferDescriptorInfo, format) &&

                  offsetof(OldBufferDescriptorInfo, usage) ==

                      offsetof(IMapper::BufferDescriptorInfo, usage),

              "");



Gralloc::Gralloc(const std::string& allocatorServiceName, const std::string& mapperServiceName)

    : V2_0::vts::Gralloc(allocatorServiceName, mapperServiceName) {

    if (::testing::Test::HasFatalFailure()) {

        return;

    }

    init();

}



void Gralloc::init() {

    mMapperV2_1 = IMapper::castFrom(V2_0::vts::Gralloc::getMapper());

    ASSERT_NE(nullptr, mMapperV2_1.get()) << "failed to get mapper 2.1 service";

}



sp<IMapper> Gralloc::getMapper() const {

    return mMapperV2_1;

}



bool Gralloc::validateBufferSize(const native_handle_t* bufferHandle,

                                 const IMapper::BufferDescriptorInfo& descriptorInfo,

                                 uint32_t stride) {

    auto buffer = const_cast<native_handle_t*>(bufferHandle);



    Error error = mMapperV2_1->validateBufferSize(buffer, descriptorInfo, stride);

    return error == Error::NONE;

}



void Gralloc::getTransportSize(const native_handle_t* bufferHandle, uint32_t* outNumFds,

                               uint32_t* outNumInts) {

    auto buffer = const_cast<native_handle_t*>(bufferHandle);



    *outNumFds = 0;

    *outNumInts = 0;

    mMapperV2_1->getTransportSize(

        buffer, [&](const auto& tmpError, const auto& tmpNumFds, const auto& tmpNumInts) {

            ASSERT_EQ(Error::NONE, tmpError) << "failed to get transport size";

            ASSERT_GE(bufferHandle->numFds, int(tmpNumFds)) << "invalid numFds " << tmpNumFds;

            ASSERT_GE(bufferHandle->numInts, int(tmpNumInts)) << "invalid numInts " << tmpNumInts;



            *outNumFds = tmpNumFds;

            *outNumInts = tmpNumInts;

        });

}



BufferDescriptor Gralloc::createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo) {

    BufferDescriptor descriptor;

    mMapperV2_1->createDescriptor_2_1(

        descriptorInfo, [&](const auto& tmpError, const auto& tmpDescriptor) {

            ASSERT_EQ(Error::NONE, tmpError) << "failed to create descriptor";

            descriptor = tmpDescriptor;

        });



    return descriptor;

}



const native_handle_t* Gralloc::allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,

                                         bool import, uint32_t* outStride) {

    BufferDescriptor descriptor = createDescriptor(descriptorInfo);

    if (::testing::Test::HasFatalFailure()) {

        return nullptr;

    }



    auto buffers = V2_0::vts::Gralloc::allocate(descriptor, 1, import, outStride);

    if (::testing::Test::HasFatalFailure()) {

        return nullptr;

    }



    return buffers[0];

}



}  // namespace vts

}  // namespace V2_1

}  // namespace mapper

}  // namespace graphics

}  // namespace hardware

}  // namespace android

graphics/mapper/2.1/utils/vts/include/mapper-vts/2.1/MapperVts.h

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

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

 */



#pragma once



#include <android/hardware/graphics/mapper/2.1/IMapper.h>

#include <mapper-vts/2.0/MapperVts.h>



namespace android {

namespace hardware {

namespace graphics {

namespace mapper {

namespace V2_1 {

namespace vts {



using android::hardware::graphics::allocator::V2_0::IAllocator;

using V2_0::BufferDescriptor;



// A wrapper to IAllocator and IMapper.

class Gralloc : public V2_0::vts::Gralloc {

   public:

    Gralloc(const std::string& allocatorServiceName, const std::string& mapperServiceName);



    sp<IMapper> getMapper() const;



    bool validateBufferSize(const native_handle_t* bufferHandle,

                            const IMapper::BufferDescriptorInfo& descriptorInfo, uint32_t stride);

    void getTransportSize(const native_handle_t* bufferHandle, uint32_t* outNumFds,

                          uint32_t* outNumInts);



    BufferDescriptor createDescriptor(const IMapper::BufferDescriptorInfo& descriptorInfo);



    const native_handle_t* allocate(const IMapper::BufferDescriptorInfo& descriptorInfo,

                                    bool import = true, uint32_t* outStride = nullptr);



   protected:

    void init();



    sp<IMapper> mMapperV2_1;

};



}  // namespace vts

}  // namespace V2_1

}  // namespace mapper

}  // namespace graphics

}  // namespace hardware

}  // namespace android

graphics/mapper/2.1/vts/functional/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -24,5 +24,6 @@ cc_test { 
        "android.hardware.graphics.mapper@2.0",

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

        "android.hardware.graphics.mapper@2.0-vts",

        "android.hardware.graphics.mapper@2.1-vts",

    ],

}