1 files changed, 54 insertions, 41 deletions

diff --git a/camera/device/1.0/default/CameraDevice.cpp b/camera/device/1.0/default/CameraDevice.cpp
index 6eeda1caa3..877c6e7728 100644
--- a/camera/device/1.0/default/CameraDevice.cpp
+++ b/camera/device/1.0/default/CameraDevice.cpp
@@ -18,6 +18,7 @@
 #include <utils/Log.h>
 #include <hardware/camera.h>
 #include <hardware/gralloc1.h>
+#include <hidlmemory/mapping.h>
 #include <utils/Trace.h>
 
 #include "CameraDevice_1_0.h"
@@ -102,6 +103,12 @@ CameraDevice::CameraDevice(
                 __FUNCTION__, mCameraId.c_str());
         mInitFail = true;
     }
+
+    mAshmemAllocator = IAllocator::getService("ashmem");
+    if (mAshmemAllocator == nullptr) {
+        ALOGI("%s: cannot get ashmemAllocator", __FUNCTION__);
+        mInitFail = true;
+    }
 }
 
 CameraDevice::~CameraDevice() {
@@ -289,35 +296,66 @@ int CameraDevice::sGetMinUndequeuedBufferCount(
     return getStatusT(s);
 }
 
-CameraDevice::CameraHeapMemory::CameraHeapMemory(int fd, size_t buf_size, uint_t num_buffers) :
+CameraDevice::CameraHeapMemory::CameraHeapMemory(
+    int fd, size_t buf_size, uint_t num_buffers) :
         mBufSize(buf_size),
         mNumBufs(num_buffers) {
-    mHeap = new MemoryHeapBase(fd, buf_size * num_buffers);
+    mHidlHandle = native_handle_create(1,0);
+    mHidlHandle->data[0] = fcntl(fd, F_DUPFD_CLOEXEC, 0);
+    const size_t pagesize = getpagesize();
+    size_t size = ((buf_size * num_buffers + pagesize-1) & ~(pagesize-1));
+    mHidlHeap = hidl_memory("ashmem", mHidlHandle, size);
     commonInitialization();
 }
 
-CameraDevice::CameraHeapMemory::CameraHeapMemory(size_t buf_size, uint_t num_buffers) :
+CameraDevice::CameraHeapMemory::CameraHeapMemory(
+    sp<IAllocator> ashmemAllocator,
+    size_t buf_size, uint_t num_buffers) :
         mBufSize(buf_size),
         mNumBufs(num_buffers) {
-    mHeap = new MemoryHeapBase(buf_size * num_buffers);
+    const size_t pagesize = getpagesize();
+    size_t size = ((buf_size * num_buffers + pagesize-1) & ~(pagesize-1));
+    ashmemAllocator->allocate(size,
+        [&](bool success, const hidl_memory& mem) {
+            if (!success) {
+                ALOGE("%s: allocating ashmem of %zu bytes failed!",
+                        __FUNCTION__, buf_size * num_buffers);
+                return;
+            }
+            mHidlHandle = native_handle_clone(mem.handle());
+            mHidlHeap = hidl_memory("ashmem", mHidlHandle, size);
+        });
+
     commonInitialization();
 }
 
 void CameraDevice::CameraHeapMemory::commonInitialization() {
-    handle.data = mHeap->base();
+    mHidlHeapMemory = mapMemory(mHidlHeap);
+    if (mHidlHeapMemory == nullptr) {
+        ALOGE("%s: memory map failed!", __FUNCTION__);
+        native_handle_close(mHidlHandle); // close FD for the shared memory
+        native_handle_delete(mHidlHandle);
+        mHidlHeap = hidl_memory();
+        mHidlHandle = nullptr;
+        return;
+    }
+    mHidlHeapMemData = mHidlHeapMemory->getPointer();
+    handle.data = mHidlHeapMemData;
     handle.size = mBufSize * mNumBufs;
     handle.handle = this;
-
-    mBuffers = new sp<MemoryBase>[mNumBufs];
-    for (uint_t i = 0; i < mNumBufs; i++) {
-        mBuffers[i] = new MemoryBase(mHeap, i * mBufSize, mBufSize);
-    }
-
     handle.release = sPutMemory;
 }
 
 CameraDevice::CameraHeapMemory::~CameraHeapMemory() {
-    delete [] mBuffers;
+    if (mHidlHeapMemory != nullptr) {
+        mHidlHeapMemData = nullptr;
+        mHidlHeapMemory.clear(); // The destructor will trigger munmap
+    }
+
+    if (mHidlHandle) {
+        native_handle_close(mHidlHandle); // close FD for the shared memory
+        native_handle_delete(mHidlHandle);
+    }
 }
 
 // shared memory methods
@@ -330,22 +368,13 @@ camera_memory_t* CameraDevice::sGetMemory(int fd, size_t buf_size, uint_t num_bu
     }
 
     CameraHeapMemory* mem;
-    native_handle_t* handle = native_handle_create(1,0);
-
-    if (handle == nullptr) {
-        ALOGE("%s: native_handle_create failed!", __FUNCTION__);
-        return nullptr;
-    }
-
     if (fd < 0) {
-        mem = new CameraHeapMemory(buf_size, num_bufs);
+        mem = new CameraHeapMemory(object->mAshmemAllocator, buf_size, num_bufs);
     } else {
         mem = new CameraHeapMemory(fd, buf_size, num_bufs);
     }
-    handle->data[0] = mem->mHeap->getHeapID();
     mem->incStrong(mem);
-
-    hidl_handle hidlHandle = handle;
+    hidl_handle hidlHandle = mem->mHidlHandle;
     MemoryId id = object->mDeviceCallback->registerMemory(hidlHandle, buf_size, num_bufs);
     mem->handle.mId = id;
     if (object->mMemoryMap.count(id) != 0) {
@@ -353,7 +382,6 @@ camera_memory_t* CameraDevice::sGetMemory(int fd, size_t buf_size, uint_t num_bu
     }
     object->mMemoryMap[id] = mem;
     mem->handle.mDevice = object;
-    native_handle_delete(handle);
     return &mem->handle;
 }
 
@@ -471,7 +499,7 @@ void CameraDevice::sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
     if (object->mMetadataMode) {
         if (mem->mBufSize == sizeof(VideoNativeHandleMetadata)) {
             VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
-                    mem->mBuffers[index]->pointer();
+                    ((uint8_t*) mem->mHidlHeapMemData + index * mem->mBufSize);
             if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {
                 handle = md->pHandle;
             }
@@ -801,27 +829,12 @@ void CameraDevice::releaseRecordingFrameLocked(
     }
     if (mDevice->ops->release_recording_frame) {
         CameraHeapMemory* camMemory = mMemoryMap.at(memId);
-        sp<MemoryHeapBase> heap = camMemory->mHeap;
         if (bufferIndex >= camMemory->mNumBufs) {
             ALOGE("%s: bufferIndex %d exceeds number of buffers %d",
                     __FUNCTION__, bufferIndex, camMemory->mNumBufs);
             return;
         }
-        sp<IMemory> mem = camMemory->mBuffers[bufferIndex];
-        // TODO: simplify below logic once we verify offset is indeed idx * mBufSize
-        //       and heap == heap2
-        ssize_t offset;
-        size_t size;
-        sp<IMemoryHeap> heap2 = mem->getMemory(&offset, &size);
-        if ((size_t)offset != bufferIndex * camMemory->mBufSize) {
-            ALOGI("%s: unexpected offset %zd (was expecting %zu)",
-                    __FUNCTION__, offset, bufferIndex * camMemory->mBufSize);
-        }
-        if (heap != heap2) {
-            ALOGE("%s: heap mismatch!", __FUNCTION__);
-            return;
-        }
-        void *data = ((uint8_t *)heap->base()) + offset;
+        void *data = ((uint8_t *) camMemory->mHidlHeapMemData) + bufferIndex * camMemory->mBufSize;
         if (handle) {
             VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) data;
             if (md->eType == VideoNativeHandleMetadata::kMetadataBufferTypeNativeHandleSource) {