mm-video-v4l2: venc: update metadata-type used for HAL1 based recording

Update metadata buffer type from kMetadataBufferTypeCameraSource to
kMetadataBufferTypeNativeHandleSource as the latter is used by
camera-HALv1 that resides in a separate process.

Surface recording uses a different metadata as compared to
legacy camera metadata (HAL1).Cast the gralloc-meta to
appropriate struct to extract the handle

Since buffer-size is not known conclusively at the allocation
time of meta-handles, allow the least size to be allocated.
But check the buffer size before accessing in ETB

Bug: 26268807
Change-Id: I2cb40889517b4d740763bbde09e2fa4646b919e1

6 files changed, 80 insertions, 30 deletions

diff --git a/libstagefrighthw/Android.mk b/libstagefrighthw/Android.mk
index 47bc3bef..fce7684b 100644
--- a/libstagefrighthw/Android.mk
+++ b/libstagefrighthw/Android.mk
@@ -26,6 +26,10 @@ ifneq ($(call is-platform-sdk-version-at-least,19),true)
 LOCAL_CFLAGS += -DMETADATA_FOR_DYNAMIC_MODE
 endif
 
+ifeq ($(TARGET_USES_MEDIA_EXTENSIONS),true)
+LOCAL_CFLAGS += -DUSE_NATIVE_HANDLE_SOURCE
+endif
+
 LOCAL_C_INCLUDES:= \
         frameworks/native/include/media/openmax \
         frameworks/native/include/media/hardware
diff --git a/libstagefrighthw/QComOMXMetadata.h b/libstagefrighthw/QComOMXMetadata.h
index 044173d1..b37a38fc 100644
--- a/libstagefrighthw/QComOMXMetadata.h
+++ b/libstagefrighthw/QComOMXMetadata.h
@@ -23,6 +23,16 @@
 
 namespace android {
 
+#ifdef USE_NATIVE_HANDLE_SOURCE
+    typedef struct encoder_nativehandle_buffer_type {
+        MetadataBufferType buffer_type;
+        union {
+            buffer_handle_t meta_handle;
+            uint64_t padding;
+        };
+    } encoder_nativehandle_buffer_type;
+#endif
+
     typedef struct encoder_media_buffer_type {
         MetadataBufferType buffer_type;
         buffer_handle_t meta_handle;
diff --git a/mm-video-v4l2/vidc/venc/Android.mk b/mm-video-v4l2/vidc/venc/Android.mk
index c2f8b08d..97167b92 100644
--- a/mm-video-v4l2/vidc/venc/Android.mk
+++ b/mm-video-v4l2/vidc/venc/Android.mk
@@ -70,6 +70,10 @@ endif
 
 venc-inc       = $(TARGET_OUT_INTERMEDIATES)/KERNEL_OBJ/usr/include
 
+ifeq ($(TARGET_USES_MEDIA_EXTENSIONS),true)
+libmm-venc-def += -DUSE_NATIVE_HANDLE_SOURCE
+endif
+
 libmm-venc-def += -D_ANDROID_ICS_
 # ---------------------------------------------------------------------------------
 # 			Make the Shared library (libOmxVenc)
diff --git a/mm-video-v4l2/vidc/venc/inc/omx_video_base.h b/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
index b5c96e76..842e754e 100644
--- a/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
+++ b/mm-video-v4l2/vidc/venc/inc/omx_video_base.h
@@ -137,6 +137,15 @@ static const char* MEM_DEVICE = "/dev/pmem_smipool";
             & BITMASK_FLAG(mIndex)) == 0x0)
 #define MAX_NUM_INPUT_BUFFERS 32
 #define MAX_NUM_OUTPUT_BUFFERS 64
+
+#ifdef USE_NATIVE_HANDLE_SOURCE
+#define LEGACY_CAM_SOURCE kMetadataBufferTypeNativeHandleSource
+#define LEGACY_CAM_METADATA_TYPE encoder_nativehandle_buffer_type
+#else
+#define LEGACY_CAM_SOURCE kMetadataBufferTypeCameraSource
+#define LEGACY_CAM_METADATA_TYPE encoder_media_buffer_type
+#endif
+
 void* enc_message_thread(void *);
 
 // OMX video class
@@ -146,7 +155,7 @@ class omx_video: public qc_omx_component
 #ifdef _ANDROID_ICS_
         bool meta_mode_enable;
         bool c2d_opened;
-        encoder_media_buffer_type meta_buffers[MAX_NUM_INPUT_BUFFERS];
+        LEGACY_CAM_METADATA_TYPE meta_buffers[MAX_NUM_INPUT_BUFFERS];
         OMX_BUFFERHEADERTYPE *opaque_buffer_hdr[MAX_NUM_INPUT_BUFFERS];
         bool get_syntaxhdr_enable;
         OMX_BUFFERHEADERTYPE  *psource_frame;
diff --git a/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp b/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
index 2ef723e4..39bffada 100644
--- a/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
+++ b/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
@@ -1450,7 +1450,9 @@ OMX_ERRORTYPE  omx_video::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
                     memcpy(portDefn, &m_sInPortDef, sizeof(m_sInPortDef));
 #ifdef _ANDROID_ICS_
                     if (meta_mode_enable) {
-                        portDefn->nBufferSize = sizeof(encoder_media_buffer_type);
+                        // request size of largest metadata (happens to be NativeHandleSource) since
+                        // we do not know the exact metadata-type yet
+                        portDefn->nBufferSize = sizeof(LEGACY_CAM_METADATA_TYPE);
                     }
                     if (mUseProxyColorFormat) {
                         portDefn->format.video.eColorFormat =
@@ -2656,7 +2658,11 @@ OMX_ERRORTYPE omx_video::allocate_input_meta_buffer(
         OMX_U32              bytes)
 {
     unsigned index = 0;
-    if (!bufferHdr || bytes < sizeof(encoder_media_buffer_type)) {
+
+    // In meta-mode alloc-length is not known conclusively
+    // Allow allocation for atleast gralloc metadata handles
+    //  and check for size in ETB
+    if (!bufferHdr || bytes < sizeof(VideoGrallocMetadata)) {
         DEBUG_PRINT_ERROR("wrong params allocate_input_meta_buffer Hdr %p len %lu",
                 bufferHdr,bytes);
         return OMX_ErrorBadParameter;
@@ -3370,7 +3376,7 @@ OMX_ERRORTYPE  omx_video::empty_this_buffer_proxy(OMX_IN OMX_HANDLETYPE
     int push_cnt = 0;
     unsigned nBufIndex = 0;
     OMX_ERRORTYPE ret = OMX_ErrorNone;
-    encoder_media_buffer_type *media_buffer = NULL;
+    LEGACY_CAM_METADATA_TYPE *media_buffer = NULL;
 
 #ifdef _MSM8974_
     int fd = 0;
@@ -3390,13 +3396,18 @@ OMX_ERRORTYPE  omx_video::empty_this_buffer_proxy(OMX_IN OMX_HANDLETYPE
             DEBUG_PRINT_ERROR("ERROR: ETBProxy: Invalid meta-bufIndex = %u", nBufIndex);
             return OMX_ErrorBadParameter;
         }
-        media_buffer = (encoder_media_buffer_type *)meta_buffer_hdr[nBufIndex].pBuffer;
-        if (media_buffer) {
-            if (media_buffer->buffer_type != kMetadataBufferTypeCameraSource &&
+        media_buffer = (LEGACY_CAM_METADATA_TYPE *)meta_buffer_hdr[nBufIndex].pBuffer;
+        if ((media_buffer->buffer_type == LEGACY_CAM_SOURCE)
+                && buffer->nAllocLen != sizeof(LEGACY_CAM_METADATA_TYPE)) {
+            DEBUG_PRINT_ERROR("Invalid metadata size expected(%u) v/s recieved(%zu)",
+                    buffer->nAllocLen, sizeof(LEGACY_CAM_METADATA_TYPE));
+            met_error = true;
+        } else if (media_buffer) {
+            if (media_buffer->buffer_type != LEGACY_CAM_SOURCE &&
                     media_buffer->buffer_type != kMetadataBufferTypeGrallocSource) {
                 met_error = true;
             } else {
-                if (media_buffer->buffer_type == kMetadataBufferTypeCameraSource) {
+                if (media_buffer->buffer_type == LEGACY_CAM_SOURCE) {
                     if (media_buffer->meta_handle == NULL)
                         met_error = true;
                     else if ((media_buffer->meta_handle->numFds != 1 &&
@@ -3439,7 +3450,7 @@ OMX_ERRORTYPE  omx_video::empty_this_buffer_proxy(OMX_IN OMX_HANDLETYPE
             DEBUG_PRINT_ERROR("%s: invalid media_buffer",__FUNCTION__);
             return OMX_ErrorBadParameter;
         }
-        if (media_buffer->buffer_type == kMetadataBufferTypeCameraSource) {
+        if (media_buffer->buffer_type == LEGACY_CAM_SOURCE) {
             Input_pmem_info.buffer = media_buffer;
             Input_pmem_info.fd = media_buffer->meta_handle->data[0];
 #ifdef _MSM8974_
@@ -3451,7 +3462,8 @@ OMX_ERRORTYPE  omx_video::empty_this_buffer_proxy(OMX_IN OMX_HANDLETYPE
                     Input_pmem_info.fd, Input_pmem_info.offset,
                     Input_pmem_info.size);
         } else {
-            private_handle_t *handle = (private_handle_t *)media_buffer->meta_handle;
+            VideoGrallocMetadata *media_buffer = (VideoGrallocMetadata *)meta_buffer_hdr[nBufIndex].pBuffer;
+            private_handle_t *handle = (private_handle_t *)media_buffer->pHandle;
             Input_pmem_info.buffer = media_buffer;
             Input_pmem_info.fd = handle->fd;
 #ifdef _MSM8974_
@@ -4359,7 +4371,7 @@ void omx_video::free_ion_memory(struct venc_ion *buf_ion_info)
 void omx_video::omx_release_meta_buffer(OMX_BUFFERHEADERTYPE *buffer)
 {
     if (buffer && meta_mode_enable) {
-        encoder_media_buffer_type *media_ptr;
+        LEGACY_CAM_METADATA_TYPE *media_ptr;
         struct pmem Input_pmem;
         unsigned int index_pmem = 0;
         bool meta_error = false;
@@ -4371,9 +4383,9 @@ void omx_video::omx_release_meta_buffer(OMX_BUFFERHEADERTYPE *buffer)
                 DEBUG_PRINT_ERROR("omx_release_meta_buffer dev free failed");
             }
         } else {
-            media_ptr = (encoder_media_buffer_type *) buffer->pBuffer;
+            media_ptr = (LEGACY_CAM_METADATA_TYPE *) buffer->pBuffer;
             if (media_ptr && media_ptr->meta_handle) {
-                if (media_ptr->buffer_type == kMetadataBufferTypeCameraSource &&
+                if (media_ptr->buffer_type == LEGACY_CAM_SOURCE &&
                         media_ptr->meta_handle->numFds == 1 &&
                         media_ptr->meta_handle->numInts >= 2) {
                     Input_pmem.fd = media_ptr->meta_handle->data[0];
@@ -4384,7 +4396,8 @@ void omx_video::omx_release_meta_buffer(OMX_BUFFERHEADERTYPE *buffer)
                             Input_pmem.offset,
                             Input_pmem.size);
                 } else if (media_ptr->buffer_type == kMetadataBufferTypeGrallocSource) {
-                    private_handle_t *handle = (private_handle_t *)media_ptr->meta_handle;
+                    VideoGrallocMetadata *media_ptr = (VideoGrallocMetadata *)buffer->pBuffer;
+                    private_handle_t *handle = (private_handle_t *)media_ptr->pHandle;
                     Input_pmem.buffer = media_ptr;
                     Input_pmem.fd = handle->fd;
                     Input_pmem.offset = 0;
@@ -4537,7 +4550,7 @@ OMX_ERRORTYPE  omx_video::empty_this_buffer_opaque(OMX_IN OMX_HANDLETYPE hComp,
 {
     unsigned nBufIndex = 0;
     OMX_ERRORTYPE ret = OMX_ErrorNone;
-    encoder_media_buffer_type *media_buffer;
+    VideoGrallocMetadata *media_buffer; // This method primarily assumes gralloc-metadata
     private_handle_t *handle = NULL;
     DEBUG_PRINT_LOW("ETBProxyOpaque: buffer[%p]", buffer);
 
@@ -4551,22 +4564,30 @@ OMX_ERRORTYPE  omx_video::empty_this_buffer_opaque(OMX_IN OMX_HANDLETYPE hComp,
                 nBufIndex);
         return OMX_ErrorBadParameter;
     }
-    media_buffer = (encoder_media_buffer_type *)buffer->pBuffer;
-    if (!media_buffer && !(buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
-        DEBUG_PRINT_ERROR("NULL pointer is passed as media buffer");
-        m_pCallbacks.EmptyBufferDone(hComp, m_app_data, buffer);
+
+    media_buffer = (VideoGrallocMetadata *)buffer->pBuffer;
+    if ((media_buffer->eType == LEGACY_CAM_SOURCE)
+            && buffer->nAllocLen != sizeof(LEGACY_CAM_METADATA_TYPE)) {
+        DEBUG_PRINT_ERROR("Invalid metadata size expected(%u) v/s recieved(%zu)",
+                buffer->nAllocLen, sizeof(LEGACY_CAM_METADATA_TYPE));
         return OMX_ErrorBadParameter;
-    } else if ((!media_buffer->meta_handle)  &&
+    }
+
+    if (media_buffer && media_buffer->eType == LEGACY_CAM_SOURCE) {
+        return empty_this_buffer_proxy(hComp, buffer);
+    }
+
+    if ((!media_buffer || !media_buffer->pHandle || media_buffer->eType != kMetadataBufferTypeGrallocSource) &&
             !(buffer->nFlags & OMX_BUFFERFLAG_EOS)) {
         DEBUG_PRINT_ERROR("Incorrect Buffer queued media buffer = %p",
             media_buffer);
         m_pCallbacks.EmptyBufferDone(hComp, m_app_data, buffer);
         return OMX_ErrorBadParameter;
     } else if (media_buffer) {
-        handle = (private_handle_t *)media_buffer->meta_handle;
+        handle = (private_handle_t *)media_buffer->pHandle;
     }
 
-    if (media_buffer->buffer_type == kMetadataBufferTypeCameraSource) {
+    if (media_buffer->eType == kMetadataBufferTypeCameraSource) {
         return empty_this_buffer_proxy(hComp, buffer);
     }
 
@@ -4765,7 +4786,7 @@ OMX_ERRORTYPE omx_video::push_input_buffer(OMX_HANDLETYPE hComp)
     while (psource_frame != NULL && pdest_frame != NULL &&
             ret == OMX_ErrorNone) {
         struct pmem Input_pmem_info;
-        encoder_media_buffer_type *media_buffer;
+        LEGACY_CAM_METADATA_TYPE *media_buffer;
         index = pdest_frame - m_inp_mem_ptr;
         if (index >= m_sInPortDef.nBufferCountActual) {
             DEBUG_PRINT_ERROR("Output buffer index is wrong %u act count %lu",
@@ -4780,9 +4801,9 @@ OMX_ERRORTYPE omx_video::push_input_buffer(OMX_HANDLETYPE hComp)
         if (psource_frame->nFilledLen == 0 && (psource_frame->nFlags & OMX_BUFFERFLAG_EOS)) {
             return push_empty_eos_buffer(hComp, psource_frame);
         }
-        media_buffer = (encoder_media_buffer_type *)psource_frame->pBuffer;
+        media_buffer = (LEGACY_CAM_METADATA_TYPE *)psource_frame->pBuffer;
         /*Will enable to verify camcorder in current TIPS can be removed*/
-        if (media_buffer->buffer_type == kMetadataBufferTypeCameraSource) {
+        if (media_buffer->buffer_type == LEGACY_CAM_SOURCE) {
             Input_pmem_info.buffer = media_buffer;
             Input_pmem_info.fd = media_buffer->meta_handle->data[0];
             Input_pmem_info.offset = media_buffer->meta_handle->data[1];
@@ -4792,7 +4813,8 @@ OMX_ERRORTYPE omx_video::push_input_buffer(OMX_HANDLETYPE hComp)
                     Input_pmem_info.size);
             ret = queue_meta_buffer(hComp,Input_pmem_info);
         } else {
-            private_handle_t *handle = (private_handle_t *)media_buffer->meta_handle;
+            VideoGrallocMetadata *media_buffer = (VideoGrallocMetadata *)psource_frame->pBuffer;
+            private_handle_t *handle = (private_handle_t *)media_buffer->pHandle;
             Input_pmem_info.buffer = media_buffer;
             Input_pmem_info.fd = handle->fd;
             Input_pmem_info.offset = 0;
diff --git a/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp b/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
index 67e9913f..6334bfbb 100644
--- a/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
+++ b/mm-video-v4l2/vidc/venc/src/video_encoder_device_v4l2.cpp
@@ -2436,7 +2436,7 @@ bool venc_dev::venc_empty_buf(void *buffer, void *pmem_data_buf, unsigned index,
     struct v4l2_plane plane;
     int rc=0;
     struct OMX_BUFFERHEADERTYPE *bufhdr;
-    encoder_media_buffer_type * meta_buf = NULL;
+    LEGACY_CAM_METADATA_TYPE * meta_buf = NULL;
     temp_buffer = (struct pmem *)buffer;
 
     memset (&buf, 0, sizeof(buf));
@@ -2468,7 +2468,7 @@ bool venc_dev::venc_empty_buf(void *buffer, void *pmem_data_buf, unsigned index,
         // ---------------------------------------------------------------------------------------
         if (metadatamode) {
             plane.m.userptr = index;
-            meta_buf = (encoder_media_buffer_type *)bufhdr->pBuffer;
+            meta_buf = (LEGACY_CAM_METADATA_TYPE *)bufhdr->pBuffer;
 
             if (!meta_buf) {
                 //empty EOS buffer
@@ -2481,14 +2481,15 @@ bool venc_dev::venc_empty_buf(void *buffer, void *pmem_data_buf, unsigned index,
                     return false;
                 }
             } else if (!color_format) {
-                if (meta_buf->buffer_type == kMetadataBufferTypeCameraSource) {
+                if (meta_buf->buffer_type == LEGACY_CAM_SOURCE) {
                     plane.data_offset = meta_buf->meta_handle->data[1];
                     plane.length = meta_buf->meta_handle->data[2];
                     plane.bytesused = meta_buf->meta_handle->data[2];
                     DEBUG_PRINT_LOW("venc_empty_buf: camera buf: fd = %d filled %d of %d",
                             fd, plane.bytesused, plane.length);
                 } else if (meta_buf->buffer_type == kMetadataBufferTypeGrallocSource) {
-                    private_handle_t *handle = (private_handle_t *)meta_buf->meta_handle;
+                    VideoGrallocMetadata *meta_buf = (VideoGrallocMetadata *)bufhdr->pBuffer;
+                    private_handle_t *handle = (private_handle_t *)meta_buf->pHandle;
                     fd = handle->fd;
                     plane.data_offset = 0;
                     plane.length = handle->size;