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

Commit 49ba82ce authored by Michael Stokes's avatar Michael Stokes Committed by Android (Google) Code Review
Browse files

Revert "Convert from HIDL mapper to libui GraphicBufferMapper" 

Revert submission 24747509-camera_fail2

Reason for revert: DroidMonitor-triggered revert due to breakage
b/302990858.

This may cause CtsAppOpsTestCases b/300115646 to fail again,
unfortunately (b/300115646).

Bug: 302990858
Reverted changes: /q/submissionid:24747509-camera_fail2

Change-Id: I0191b3ee88846f5b2c6e37ebd6be6d1369d9dba9
parent 5e154097

camera/common/default/Android.bp

+3 −2
Original line number Diff line number Diff line
@@ -30,12 +30,13 @@ cc_library_static { 
        "libgralloctypes",

        "libhardware",

        "libcamera_metadata",

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

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

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

        "libexif",

        "libui",

    ],

    include_dirs: ["system/media/private/camera/include"],

    export_include_dirs: ["include"],

    export_shared_lib_headers: ["libui"],

}



// NOTE: Deprecated module kept for compatibility reasons.

camera/common/default/HandleImporter.cpp

+334 −65
Original line number Diff line number Diff line
@@ -17,10 +17,9 @@ 
#define LOG_TAG "HandleImporter"

#include "HandleImporter.h"



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

#include <gralloctypes/Gralloc4.h>

#include <log/log.h>

#include <ui/GraphicBufferMapper.h>

#include "aidl/android/hardware/graphics/common/Smpte2086.h"



namespace android {

namespace hardware {
@@ -32,6 +31,12 @@ using aidl::android::hardware::graphics::common::PlaneLayout; 
using aidl::android::hardware::graphics::common::PlaneLayoutComponent;

using aidl::android::hardware::graphics::common::PlaneLayoutComponentType;

using aidl::android::hardware::graphics::common::Smpte2086;

using MetadataType = android::hardware::graphics::mapper::V4_0::IMapper::MetadataType;

using MapperErrorV2 = android::hardware::graphics::mapper::V2_0::Error;

using MapperErrorV3 = android::hardware::graphics::mapper::V3_0::Error;

using MapperErrorV4 = android::hardware::graphics::mapper::V4_0::Error;

using IMapperV3 = android::hardware::graphics::mapper::V3_0::IMapper;

using IMapperV4 = android::hardware::graphics::mapper::V4_0::IMapper;



HandleImporter::HandleImporter() : mInitialized(false) {}
@@ -40,20 +45,51 @@ void HandleImporter::initializeLocked() { 
        return;

    }



    GraphicBufferMapper::preloadHal();

    mMapperV4 = IMapperV4::getService();

    if (mMapperV4 != nullptr) {

        mInitialized = true;

        return;

    }



    mMapperV3 = IMapperV3::getService();

    if (mMapperV3 != nullptr) {

        mInitialized = true;

        return;

    }



    mMapperV2 = IMapper::getService();

    if (mMapperV2 == nullptr) {

        ALOGE("%s: cannnot acccess graphics mapper HAL!", __FUNCTION__);

        return;

    }



    mInitialized = true;

    return;

}



void HandleImporter::cleanup() {

    mMapperV4.clear();

    mMapperV3.clear();

    mMapperV2.clear();

    mInitialized = false;

}



bool HandleImporter::importBufferInternal(buffer_handle_t& handle) {

template <class M, class E>

bool HandleImporter::importBufferInternal(const sp<M> mapper, buffer_handle_t& handle) {

    E error;

    buffer_handle_t importedHandle;

    auto status = GraphicBufferMapper::get().importBufferNoValidate(handle, &importedHandle);

    if (status != OK) {

        ALOGE("%s: mapper importBuffer failed: %d", __FUNCTION__, status);

    auto ret = mapper->importBuffer(

            hidl_handle(handle), [&](const auto& tmpError, const auto& tmpBufferHandle) {

                error = tmpError;

                importedHandle = static_cast<buffer_handle_t>(tmpBufferHandle);

            });



    if (!ret.isOk()) {

        ALOGE("%s: mapper importBuffer failed: %s", __FUNCTION__, ret.description().c_str());

        return false;

    }



    if (error != E::NONE) {

        return false;

    }
@@ -61,32 +97,170 @@ bool HandleImporter::importBufferInternal(buffer_handle_t& handle) { 
    return true;

}



android_ycbcr HandleImporter::lockYCbCr(buffer_handle_t& buf, uint64_t cpuUsage,

                                        const android::Rect& accessRegion) {

    Mutex::Autolock lock(mLock);

template <class M, class E>

YCbCrLayout HandleImporter::lockYCbCrInternal(const sp<M> mapper, buffer_handle_t& buf,

                                              uint64_t cpuUsage,

                                              const IMapper::Rect& accessRegion) {

    hidl_handle acquireFenceHandle;

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

    YCbCrLayout layout = {};



    typename M::Rect accessRegionCopy = {accessRegion.left, accessRegion.top, accessRegion.width,

                                         accessRegion.height};

    mapper->lockYCbCr(buffer, cpuUsage, accessRegionCopy, acquireFenceHandle,

                      [&](const auto& tmpError, const auto& tmpLayout) {

                          if (tmpError == E::NONE) {

                              // Member by member copy from different versions of YCbCrLayout.

                              layout.y = tmpLayout.y;

                              layout.cb = tmpLayout.cb;

                              layout.cr = tmpLayout.cr;

                              layout.yStride = tmpLayout.yStride;

                              layout.cStride = tmpLayout.cStride;

                              layout.chromaStep = tmpLayout.chromaStep;

                          } else {

                              ALOGE("%s: failed to lockYCbCr error %d!", __FUNCTION__, tmpError);

                          }

                      });

    return layout;

}



    if (!mInitialized) {

        initializeLocked();

bool isMetadataPesent(const sp<IMapperV4> mapper, const buffer_handle_t& buf,

                      MetadataType metadataType) {

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

    bool ret = false;

    hidl_vec<uint8_t> vec;

    mapper->get(buffer, metadataType, [&](const auto& tmpError, const auto& tmpMetadata) {

        if (tmpError == MapperErrorV4::NONE) {

            vec = tmpMetadata;

        } else {

            ALOGE("%s: failed to get metadata %d!", __FUNCTION__, tmpError);

        }

    });



    if (vec.size() > 0) {

        if (metadataType == gralloc4::MetadataType_Smpte2086) {

            std::optional<Smpte2086> realSmpte2086;

            gralloc4::decodeSmpte2086(vec, &realSmpte2086);

            ret = realSmpte2086.has_value();

        } else if (metadataType == gralloc4::MetadataType_Smpte2094_10) {

            std::optional<std::vector<uint8_t>> realSmpte2094_10;

            gralloc4::decodeSmpte2094_10(vec, &realSmpte2094_10);

            ret = realSmpte2094_10.has_value();

        } else if (metadataType == gralloc4::MetadataType_Smpte2094_40) {

            std::optional<std::vector<uint8_t>> realSmpte2094_40;

            gralloc4::decodeSmpte2094_40(vec, &realSmpte2094_40);

            ret = realSmpte2094_40.has_value();

        } else {

            ALOGE("%s: Unknown metadata type!", __FUNCTION__);

        }

    }



    return ret;

}

    android_ycbcr layout;



    status_t status = GraphicBufferMapper::get().lockYCbCr(buf, cpuUsage, accessRegion, &layout);

std::vector<PlaneLayout> getPlaneLayouts(const sp<IMapperV4> mapper, buffer_handle_t& buf) {

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

    std::vector<PlaneLayout> planeLayouts;

    hidl_vec<uint8_t> encodedPlaneLayouts;

    mapper->get(buffer, gralloc4::MetadataType_PlaneLayouts,

                [&](const auto& tmpError, const auto& tmpEncodedPlaneLayouts) {

                    if (tmpError == MapperErrorV4::NONE) {

                        encodedPlaneLayouts = tmpEncodedPlaneLayouts;

                    } else {

                        ALOGE("%s: failed to get plane layouts %d!", __FUNCTION__, tmpError);

                    }

                });



    gralloc4::decodePlaneLayouts(encodedPlaneLayouts, &planeLayouts);



    return planeLayouts;

}



    if (status != OK) {

        ALOGE("%s: failed to lockYCbCr error %d!", __FUNCTION__, status);

template <>

YCbCrLayout HandleImporter::lockYCbCrInternal<IMapperV4, MapperErrorV4>(

        const sp<IMapperV4> mapper, buffer_handle_t& buf, uint64_t cpuUsage,

        const IMapper::Rect& accessRegion) {

    hidl_handle acquireFenceHandle;

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

    YCbCrLayout layout = {};

    void* mapped = nullptr;



    typename IMapperV4::Rect accessRegionV4 = {accessRegion.left, accessRegion.top,

                                               accessRegion.width, accessRegion.height};

    mapper->lock(buffer, cpuUsage, accessRegionV4, acquireFenceHandle,

                 [&](const auto& tmpError, const auto& tmpPtr) {

                     if (tmpError == MapperErrorV4::NONE) {

                         mapped = tmpPtr;

                     } else {

                         ALOGE("%s: failed to lock error %d!", __FUNCTION__, tmpError);

                     }

                 });



    if (mapped == nullptr) {

        return layout;

    }



std::vector<PlaneLayout> getPlaneLayouts(buffer_handle_t& buf) {

    std::vector<PlaneLayout> planeLayouts;

    status_t status = GraphicBufferMapper::get().getPlaneLayouts(buf, &planeLayouts);

    if (status != OK) {

        ALOGE("%s: failed to get PlaneLayouts! Status %d", __FUNCTION__, status);

    std::vector<PlaneLayout> planeLayouts = getPlaneLayouts(mapper, buf);

    for (const auto& planeLayout : planeLayouts) {

        for (const auto& planeLayoutComponent : planeLayout.components) {

            const auto& type = planeLayoutComponent.type;



            if (!gralloc4::isStandardPlaneLayoutComponentType(type)) {

                continue;

            }



    return planeLayouts;

            uint8_t* data = reinterpret_cast<uint8_t*>(mapped);

            data += planeLayout.offsetInBytes;

            data += planeLayoutComponent.offsetInBits / 8;



            switch (static_cast<PlaneLayoutComponentType>(type.value)) {

                case PlaneLayoutComponentType::Y:

                    layout.y = data;

                    layout.yStride = planeLayout.strideInBytes;

                    break;

                case PlaneLayoutComponentType::CB:

                    layout.cb = data;

                    layout.cStride = planeLayout.strideInBytes;

                    layout.chromaStep = planeLayout.sampleIncrementInBits / 8;

                    break;

                case PlaneLayoutComponentType::CR:

                    layout.cr = data;

                    layout.cStride = planeLayout.strideInBytes;

                    layout.chromaStep = planeLayout.sampleIncrementInBits / 8;

                    break;

                default:

                    break;

            }

        }

    }



    return layout;

}



template <class M, class E>

int HandleImporter::unlockInternal(const sp<M> mapper, buffer_handle_t& buf) {

    int releaseFence = -1;

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



    mapper->unlock(buffer, [&](const auto& tmpError, const auto& tmpReleaseFence) {

        if (tmpError == E::NONE) {

            auto fenceHandle = tmpReleaseFence.getNativeHandle();

            if (fenceHandle) {

                if (fenceHandle->numInts != 0 || fenceHandle->numFds != 1) {

                    ALOGE("%s: bad release fence numInts %d numFds %d", __FUNCTION__,

                          fenceHandle->numInts, fenceHandle->numFds);

                    return;

                }

                releaseFence = dup(fenceHandle->data[0]);

                if (releaseFence < 0) {

                    ALOGE("%s: bad release fence FD %d", __FUNCTION__, releaseFence);

                }

            }

        } else {

            ALOGE("%s: failed to unlock error %d!", __FUNCTION__, tmpError);

        }

    });

    return releaseFence;

}



// In IComposer, any buffer_handle_t is owned by the caller and we need to
@@ -103,7 +277,20 @@ bool HandleImporter::importBuffer(buffer_handle_t& handle) { 
        initializeLocked();

    }



    return importBufferInternal(handle);

    if (mMapperV4 != nullptr) {

        return importBufferInternal<IMapperV4, MapperErrorV4>(mMapperV4, handle);

    }



    if (mMapperV3 != nullptr) {

        return importBufferInternal<IMapperV3, MapperErrorV3>(mMapperV3, handle);

    }



    if (mMapperV2 != nullptr) {

        return importBufferInternal<IMapper, MapperErrorV2>(mMapperV2, handle);

    }



    ALOGE("%s: mMapperV4, mMapperV3 and mMapperV2 are all null!", __FUNCTION__);

    return false;

}



void HandleImporter::freeBuffer(buffer_handle_t handle) {
@@ -116,9 +303,21 @@ void HandleImporter::freeBuffer(buffer_handle_t handle) { 
        initializeLocked();

    }



    status_t status = GraphicBufferMapper::get().freeBuffer(handle);

    if (status != OK) {

        ALOGE("%s: mapper freeBuffer failed. Status %d", __FUNCTION__, status);

    if (mMapperV4 != nullptr) {

        auto ret = mMapperV4->freeBuffer(const_cast<native_handle_t*>(handle));

        if (!ret.isOk()) {

            ALOGE("%s: mapper freeBuffer failed: %s", __FUNCTION__, ret.description().c_str());

        }

    } else if (mMapperV3 != nullptr) {

        auto ret = mMapperV3->freeBuffer(const_cast<native_handle_t*>(handle));

        if (!ret.isOk()) {

            ALOGE("%s: mapper freeBuffer failed: %s", __FUNCTION__, ret.description().c_str());

        }

    } else {

        auto ret = mMapperV2->freeBuffer(const_cast<native_handle_t*>(handle));

        if (!ret.isOk()) {

            ALOGE("%s: mapper freeBuffer failed: %s", __FUNCTION__, ret.description().c_str());

        }

    }

}
@@ -146,12 +345,12 @@ void HandleImporter::closeFence(int fd) const { 
}



void* HandleImporter::lock(buffer_handle_t& buf, uint64_t cpuUsage, size_t size) {

    android::Rect accessRegion{0, 0, static_cast<int>(size), 1};

    IMapper::Rect accessRegion{0, 0, static_cast<int>(size), 1};

    return lock(buf, cpuUsage, accessRegion);

}



void* HandleImporter::lock(buffer_handle_t& buf, uint64_t cpuUsage,

                           const android::Rect& accessRegion) {

                           const IMapper::Rect& accessRegion) {

    Mutex::Autolock lock(mLock);



    if (!mInitialized) {
@@ -159,18 +358,81 @@ void* HandleImporter::lock(buffer_handle_t& buf, uint64_t cpuUsage, 
    }



    void* ret = nullptr;

    status_t status = GraphicBufferMapper::get().lock(buf, cpuUsage, accessRegion, &ret);

    if (status != OK) {

        ALOGE("%s: failed to lock error %d!", __FUNCTION__, status);



    if (mMapperV4 == nullptr && mMapperV3 == nullptr && mMapperV2 == nullptr) {

        ALOGE("%s: mMapperV4, mMapperV3 and mMapperV2 are all null!", __FUNCTION__);

        return ret;

    }



    hidl_handle acquireFenceHandle;

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

    if (mMapperV4 != nullptr) {

        IMapperV4::Rect accessRegionV4{accessRegion.left, accessRegion.top, accessRegion.width,

                                       accessRegion.height};



        mMapperV4->lock(buffer, cpuUsage, accessRegionV4, acquireFenceHandle,

                        [&](const auto& tmpError, const auto& tmpPtr) {

                            if (tmpError == MapperErrorV4::NONE) {

                                ret = tmpPtr;

                            } else {

                                ALOGE("%s: failed to lock error %d!", __FUNCTION__, tmpError);

                            }

                        });

    } else if (mMapperV3 != nullptr) {

        IMapperV3::Rect accessRegionV3{accessRegion.left, accessRegion.top, accessRegion.width,

                                       accessRegion.height};



        mMapperV3->lock(buffer, cpuUsage, accessRegionV3, acquireFenceHandle,

                        [&](const auto& tmpError, const auto& tmpPtr, const auto& /*bytesPerPixel*/,

                            const auto& /*bytesPerStride*/) {

                            if (tmpError == MapperErrorV3::NONE) {

                                ret = tmpPtr;

                            } else {

                                ALOGE("%s: failed to lock error %d!", __FUNCTION__, tmpError);

                            }

                        });

    } else {

        mMapperV2->lock(buffer, cpuUsage, accessRegion, acquireFenceHandle,

                        [&](const auto& tmpError, const auto& tmpPtr) {

                            if (tmpError == MapperErrorV2::NONE) {

                                ret = tmpPtr;

                            } else {

                                ALOGE("%s: failed to lock error %d!", __FUNCTION__, tmpError);

                            }

                        });

    }



    ALOGV("%s: ptr %p accessRegion.top: %d accessRegion.left: %d accessRegion.width: %d "

          "accessRegion.height: %d",

          __FUNCTION__, ret, accessRegion.top, accessRegion.left, accessRegion.width(),

          accessRegion.height());

          __FUNCTION__, ret, accessRegion.top, accessRegion.left, accessRegion.width,

          accessRegion.height);

    return ret;

}



YCbCrLayout HandleImporter::lockYCbCr(buffer_handle_t& buf, uint64_t cpuUsage,

                                      const IMapper::Rect& accessRegion) {

    Mutex::Autolock lock(mLock);



    if (!mInitialized) {

        initializeLocked();

    }



    if (mMapperV4 != nullptr) {

        return lockYCbCrInternal<IMapperV4, MapperErrorV4>(mMapperV4, buf, cpuUsage, accessRegion);

    }



    if (mMapperV3 != nullptr) {

        return lockYCbCrInternal<IMapperV3, MapperErrorV3>(mMapperV3, buf, cpuUsage, accessRegion);

    }



    if (mMapperV2 != nullptr) {

        return lockYCbCrInternal<IMapper, MapperErrorV2>(mMapperV2, buf, cpuUsage, accessRegion);

    }



    ALOGE("%s: mMapperV4, mMapperV3 and mMapperV2 are all null!", __FUNCTION__);

    return {};

}



status_t HandleImporter::getMonoPlanarStrideBytes(buffer_handle_t& buf, uint32_t* stride /*out*/) {

    if (stride == nullptr) {

        return BAD_VALUE;
@@ -182,26 +444,35 @@ status_t HandleImporter::getMonoPlanarStrideBytes(buffer_handle_t& buf, uint32_t 
        initializeLocked();

    }



    std::vector<PlaneLayout> planeLayouts = getPlaneLayouts(buf);

    if (mMapperV4 != nullptr) {

        std::vector<PlaneLayout> planeLayouts = getPlaneLayouts(mMapperV4, buf);

        if (planeLayouts.size() != 1) {

            ALOGE("%s: Unexpected number of planes %zu!", __FUNCTION__, planeLayouts.size());

            return BAD_VALUE;

        }



        *stride = planeLayouts[0].strideInBytes;

    } else {

        ALOGE("%s: mMapperV4 is null! Query not supported!", __FUNCTION__);

        return NO_INIT;

    }



    return OK;

}



int HandleImporter::unlock(buffer_handle_t& buf) {

    int releaseFence = -1;



    status_t status = GraphicBufferMapper::get().unlockAsync(buf, &releaseFence);

    if (status != OK) {

        ALOGE("%s: failed to unlock error %d!", __FUNCTION__, status);

    if (mMapperV4 != nullptr) {

        return unlockInternal<IMapperV4, MapperErrorV4>(mMapperV4, buf);

    }

    if (mMapperV3 != nullptr) {

        return unlockInternal<IMapperV3, MapperErrorV3>(mMapperV3, buf);

    }

    if (mMapperV2 != nullptr) {

        return unlockInternal<IMapper, MapperErrorV2>(mMapperV2, buf);

    }



    return releaseFence;

    ALOGE("%s: mMapperV4, mMapperV3 and mMapperV2 are all null!", __FUNCTION__);

    return -1;

}



bool HandleImporter::isSmpte2086Present(const buffer_handle_t& buf) {
@@ -210,14 +481,14 @@ bool HandleImporter::isSmpte2086Present(const buffer_handle_t& buf) { 
    if (!mInitialized) {

        initializeLocked();

    }

    std::optional<ui::Smpte2086> metadata;

    status_t status = GraphicBufferMapper::get().getSmpte2086(buf, &metadata);

    if (status != OK) {

        ALOGE("%s: Mapper failed to get Smpte2094_40 metadata! Status: %d", __FUNCTION__, status);

        return false;



    if (mMapperV4 != nullptr) {

        return isMetadataPesent(mMapperV4, buf, gralloc4::MetadataType_Smpte2086);

    } else {

        ALOGE("%s: mMapperV4 is null! Query not supported!", __FUNCTION__);

    }



    return metadata.has_value();

    return false;

}



bool HandleImporter::isSmpte2094_10Present(const buffer_handle_t& buf) {
@@ -227,14 +498,13 @@ bool HandleImporter::isSmpte2094_10Present(const buffer_handle_t& buf) { 
        initializeLocked();

    }



    std::optional<std::vector<uint8_t>> metadata;

    status_t status = GraphicBufferMapper::get().getSmpte2094_10(buf, &metadata);

    if (status != OK) {

        ALOGE("%s: Mapper failed to get Smpte2094_40 metadata! Status: %d", __FUNCTION__, status);

        return false;

    if (mMapperV4 != nullptr) {

        return isMetadataPesent(mMapperV4, buf, gralloc4::MetadataType_Smpte2094_10);

    } else {

        ALOGE("%s: mMapperV4 is null! Query not supported!", __FUNCTION__);

    }



    return metadata.has_value();

    return false;

}



bool HandleImporter::isSmpte2094_40Present(const buffer_handle_t& buf) {
@@ -244,14 +514,13 @@ bool HandleImporter::isSmpte2094_40Present(const buffer_handle_t& buf) { 
        initializeLocked();

    }



    std::optional<std::vector<uint8_t>> metadata;

    status_t status = GraphicBufferMapper::get().getSmpte2094_40(buf, &metadata);

    if (status != OK) {

        ALOGE("%s: Mapper failed to get Smpte2094_40 metadata! Status: %d", __FUNCTION__, status);

        return false;

    if (mMapperV4 != nullptr) {

        return isMetadataPesent(mMapperV4, buf, gralloc4::MetadataType_Smpte2094_40);

    } else {

        ALOGE("%s: mMapperV4 is null! Query not supported!", __FUNCTION__);

    }



    return metadata.has_value();

    return false;

}



}  // namespace helper

camera/common/default/include/HandleImporter.h

+19 −7
Original line number Diff line number Diff line
@@ -17,11 +17,15 @@ 
#ifndef CAMERA_COMMON_1_0_HANDLEIMPORTED_H

#define CAMERA_COMMON_1_0_HANDLEIMPORTED_H



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

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

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

#include <cutils/native_handle.h>

#include <system/graphics.h>

#include <ui/Rect.h>

#include <utils/Mutex.h>



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

using android::hardware::graphics::mapper::V2_0::YCbCrLayout;



namespace android {

namespace hardware {

namespace camera {
@@ -45,11 +49,11 @@ class HandleImporter { 
    void* lock(buffer_handle_t& buf, uint64_t cpuUsage, size_t size);



    // Locks 2-D buffer. Assumes caller has waited for acquire fences.

    void* lock(buffer_handle_t& buf, uint64_t cpuUsage, const android::Rect& accessRegion);

    void* lock(buffer_handle_t& buf, uint64_t cpuUsage, const IMapper::Rect& accessRegion);



    // Assumes caller has waited for acquire fences.

    android_ycbcr lockYCbCr(buffer_handle_t& buf, uint64_t cpuUsage,

                            const android::Rect& accessRegion);

    YCbCrLayout lockYCbCr(buffer_handle_t& buf, uint64_t cpuUsage,

                          const IMapper::Rect& accessRegion);



    // Query the stride of the first plane in bytes.

    status_t getMonoPlanarStrideBytes(buffer_handle_t& buf, uint32_t* stride /*out*/);
@@ -65,11 +69,19 @@ class HandleImporter { 
    void initializeLocked();

    void cleanup();



    bool importBufferInternal(buffer_handle_t& handle);

    int unlockInternal(buffer_handle_t& buf);

    template <class M, class E>

    bool importBufferInternal(const sp<M> mapper, buffer_handle_t& handle);

    template <class M, class E>

    YCbCrLayout lockYCbCrInternal(const sp<M> mapper, buffer_handle_t& buf, uint64_t cpuUsage,

                                  const IMapper::Rect& accessRegion);

    template <class M, class E>

    int unlockInternal(const sp<M> mapper, buffer_handle_t& buf);



    Mutex mLock;

    bool mInitialized;

    sp<IMapper> mMapperV2;

    sp<graphics::mapper::V3_0::IMapper> mMapperV3;

    sp<graphics::mapper::V4_0::IMapper> mMapperV4;

};



}  // namespace helper

camera/device/1.0/default/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -32,7 +32,6 @@ cc_library_shared { 
        "libgralloctypes",

        "libhardware",

        "libcamera_metadata",

        "libui",

    ],

    static_libs: [

        "android.hardware.camera.common@1.0-helper",

camera/device/3.2/default/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ cc_library_shared { 
        "libhardware",

        "libcamera_metadata",

        "libfmq",

        "libui",

    ],

    static_libs: [

        "android.hardware.camera.common@1.0-helper",