CameraHal: Add getBuffers() method to BufferSourceAdapter

- Added a method in BufferProvider which can provide
  the CameraBuffer list

Change-Id: Ia9ea8e0ac7e59e969fd5bedcfaf057f3607ab963
Signed-off-by: Sundar Raman <a0393242@ti.com>
Signed-off-by: Vladimir Petrov <vppetrov@mm-sol.com>

1 files changed, 116 insertions, 0 deletions

diff --git a/camera/BufferSourceAdapter.cpp b/camera/BufferSourceAdapter.cpp
index b4317e4..036ce72 100644
--- a/camera/BufferSourceAdapter.cpp
+++ b/camera/BufferSourceAdapter.cpp
@@ -112,6 +112,11 @@ static int getHeightFromFormat(const char* format, int stride, int size) {
 /*--------------------BufferSourceAdapter Class STARTS here-----------------------------*/
 
 
+///Constant definitions
+// TODO(XXX): Temporarily increase number of buffers we can allocate from ANW
+// until faux-NPA mode is implemented
+const int BufferSourceAdapter::NO_BUFFERS_IMAGE_CAPTURE_SYSTEM_HEAP = 15;
+
 /**
  * Display Adapter class STARTS here..
  */
@@ -505,6 +510,117 @@ CameraBuffer* BufferSourceAdapter::allocateBufferList(int width, int dummyHeight
 
 }
 
+CameraBuffer *BufferSourceAdapter::getBuffers(bool reset) {
+    int undequeued = 0;
+    status_t err;
+    android::Mutex::Autolock lock(mLock);
+
+    if (!mBufferSource || !mBuffers) {
+        CAMHAL_LOGE("Adapter is not set up properly: "
+                    "mBufferSource:%p mBuffers:%p",
+                     mBufferSource, mBuffers);
+        goto fail;
+    }
+
+    // CameraHal is indicating to us that the state of the mBuffer
+    // might have changed. We might need to check the state of the
+    // buffer list and pass a new one depending on the state of our
+    // surface
+    if (reset) {
+        const int lnumBufs = mBufferCount;
+        android::GraphicBufferMapper &mapper = android::GraphicBufferMapper::get();
+        android::Rect bounds(mFrameWidth, mFrameHeight);
+        void *y_uv[2];
+        CameraBuffer * newBuffers = NULL;
+        unsigned int index = 0;
+        android::KeyedVector<void*, int> missingIndices;
+
+        newBuffers = new CameraBuffer [lnumBufs];
+        memset (newBuffers, 0, sizeof(CameraBuffer) * lnumBufs);
+
+        // Use this vector to figure out missing indices
+        for (int i = 0; i < mBufferCount; i++) {
+            missingIndices.add(mBuffers[i].opaque, i);
+        }
+
+        // assign buffers that we have already dequeued
+        for (index = 0; index < mFramesWithCameraAdapterMap.size(); index++) {
+            int value = mFramesWithCameraAdapterMap.valueAt(index);
+            newBuffers[index].opaque = mBuffers[value].opaque;
+            newBuffers[index].type = mBuffers[value].type;
+            newBuffers[index].format = mBuffers[value].format;
+            newBuffers[index].mapped = mBuffers[value].mapped;
+            mFramesWithCameraAdapterMap.replaceValueAt(index, index);
+            missingIndices.removeItem(newBuffers[index].opaque);
+        }
+
+        mBufferSource->get_min_undequeued_buffer_count(mBufferSource, &undequeued);
+
+        // dequeue the rest of the buffers
+        for (index; index < (unsigned int)(mBufferCount-undequeued); index++) {
+            buffer_handle_t *handle;
+            int stride;  // dummy variable to get stride
+
+            err = mBufferSource->dequeue_buffer(mBufferSource, &handle, &stride);
+            if (err != 0) {
+                CAMHAL_LOGEB("dequeueBuffer failed: %s (%d)", strerror(-err), -err);
+                if ( ENODEV == err ) {
+                    CAMHAL_LOGEA("Preview surface abandoned!");
+                    mBufferSource = NULL;
+                }
+                goto fail;
+            }
+            newBuffers[index].opaque = (void *)handle;
+            newBuffers[index].type = CAMERA_BUFFER_ANW;
+            newBuffers[index].format = mPixelFormat;
+            mFramesWithCameraAdapterMap.add(handle, index);
+
+            mBufferSource->lock_buffer(mBufferSource, handle);
+            mapper.lock(*handle, CAMHAL_GRALLOC_USAGE, bounds, y_uv);
+            newBuffers[index].mapped = y_uv[0];
+            CAMHAL_LOGDB("got handle %p", handle);
+
+            missingIndices.removeItem(newBuffers[index].opaque);
+        }
+
+        // now we need to figure out which buffers aren't dequeued
+        // which are in mBuffers but not newBuffers yet
+        if ((mBufferCount - index) != missingIndices.size()) {
+            CAMHAL_LOGD("Hrmm somethings gone awry. We are missing a different number"
+                        " of buffers than we can fill");
+        }
+        for (unsigned int i = 0; i < missingIndices.size(); i++) {
+            int j = missingIndices.valueAt(i);
+
+            CAMHAL_LOGD("Filling at %d", j);
+            newBuffers[index].opaque = mBuffers[j].opaque;
+            newBuffers[index].type = mBuffers[j].type;
+            newBuffers[index].format = mBuffers[j].format;
+            newBuffers[index].mapped = mBuffers[j].mapped;
+        }
+
+        delete [] mBuffers;
+        mBuffers = newBuffers;
+    }
+
+    return mBuffers;
+
+ fail:
+    return NULL;
+}
+
+unsigned int BufferSourceAdapter::getSize() {
+    android::Mutex::Autolock lock(mLock);
+    return CameraHal::calculateBufferSize(mPixelFormat, mFrameWidth, mFrameHeight);
+}
+
+int BufferSourceAdapter::getBufferCount() {
+    int count = -1;
+
+    android::Mutex::Autolock lock(mLock);
+    return NO_BUFFERS_IMAGE_CAPTURE_SYSTEM_HEAP;
+}
+
 CameraBuffer* BufferSourceAdapter::getBufferList(int *num) {
     LOG_FUNCTION_NAME;
     status_t err;