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

Commit 523660cd authored by Devin Moore's avatar Devin Moore Committed by Android (Google) Code Review
Browse files

Revert "Revert "Convert from HIDL mapper to libui GraphicBufferM..." 

Revert submission 24913374-revert-24747509-camera_fail2-OVHUVTAXRP

Reason for revert: 32-bit TV build is fixed with `%zu` instead of `%lu` for size_t argument.

Reverted changes: /q/submissionid:24913374-revert-24747509-camera_fail2-OVHUVTAXRP

Change-Id: I16287ce2dbea034db41450a3a5e9c3f729e76335
parent 49ba82ce

camera/common/default/Android.bp

+2 −3
Original line number Diff line number Diff line
@@ -30,13 +30,12 @@ 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

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

#include "HandleImporter.h"



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

#include <gralloctypes/Gralloc4.h>

#include <log/log.h>

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

#include <ui/GraphicBufferMapper.h>



namespace android {

namespace hardware {
@@ -31,12 +32,6 @@ 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) {}
@@ -45,51 +40,20 @@ void HandleImporter::initializeLocked() { 
        return;

    }



    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;

    }



    GraphicBufferMapper::preloadHal();

    mInitialized = true;

    return;

}



void HandleImporter::cleanup() {

    mMapperV4.clear();

    mMapperV3.clear();

    mMapperV2.clear();

    mInitialized = false;

}



template <class M, class E>

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

    E error;

bool HandleImporter::importBufferInternal(buffer_handle_t& handle) {

    buffer_handle_t importedHandle;

    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) {

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

    if (status != OK) {

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

        return false;

    }
@@ -97,170 +61,32 @@ bool HandleImporter::importBufferInternal(const sp<M> mapper, buffer_handle_t& h 
    return true;

}



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;

}



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 HandleImporter::lockYCbCr(buffer_handle_t& buf, uint64_t cpuUsage,

                                        const android::Rect& accessRegion) {

    Mutex::Autolock lock(mLock);



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

    if (!mInitialized) {

        initializeLocked();

    }

                });

    android_ycbcr layout;



    gralloc4::decodePlaneLayouts(encodedPlaneLayouts, &planeLayouts);



    return planeLayouts;

}

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



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 (status != OK) {

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

    }

                 });



    if (mapped == nullptr) {

    return layout;

}



    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;

            }



            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;

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

    }



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;

    return planeLayouts;

}



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

    }



    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;

    return importBufferInternal(handle);

}



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

    }



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

        }

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

    if (status != OK) {

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

    }

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



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

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

    android::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 IMapper::Rect& accessRegion) {

                           const android::Rect& accessRegion) {

    Mutex::Autolock lock(mLock);



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



    void* ret = nullptr;



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

                            }

                        });

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

    if (status != OK) {

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

    }



    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;
@@ -444,35 +182,26 @@ status_t HandleImporter::getMonoPlanarStrideBytes(buffer_handle_t& buf, uint32_t 
        initializeLocked();

    }



    if (mMapperV4 != nullptr) {

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

    std::vector<PlaneLayout> planeLayouts = getPlaneLayouts(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) {

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

    int releaseFence = -1;



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

    if (status != OK) {

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

    }



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

    return -1;

    return releaseFence;

}



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

        initializeLocked();

    }



    if (mMapperV4 != nullptr) {

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

    } else {

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

    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;

    }



    return false;

    return metadata.has_value();

}



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

    }



    if (mMapperV4 != nullptr) {

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

    } else {

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

    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;

    }



    return false;

    return metadata.has_value();

}



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

    }



    if (mMapperV4 != nullptr) {

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

    } else {

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

    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;

    }



    return false;

    return metadata.has_value();

}



}  // namespace helper

camera/common/default/include/HandleImporter.h

+7 −19
Original line number Diff line number Diff line
@@ -17,15 +17,11 @@ 
#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 {
@@ -49,11 +45,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 IMapper::Rect& accessRegion);

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



    // Assumes caller has waited for acquire fences.

    YCbCrLayout lockYCbCr(buffer_handle_t& buf, uint64_t cpuUsage,

                          const IMapper::Rect& accessRegion);

    android_ycbcr lockYCbCr(buffer_handle_t& buf, uint64_t cpuUsage,

                            const android::Rect& accessRegion);



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

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

    void cleanup();



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

    bool importBufferInternal(buffer_handle_t& handle);

    int unlockInternal(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

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

        "libhardware",

        "libcamera_metadata",

        "libui",

    ],

    static_libs: [

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

camera/device/3.2/default/Android.bp

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

        "libcamera_metadata",

        "libfmq",

        "libui",

    ],

    static_libs: [

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