Merge remote-tracking branch 'goog/qcom/release/LA.UM.7.8.9.C1.08.00.00.516.007'

 Conflicts:
	mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h

Bug: 121228685
Change-Id: I38dfda186f1d12cd2732808d1d8ebbda90946db4

12 files changed, 102 insertions, 50 deletions

diff --git a/libplatformconfig/ConfigParser.cpp b/libplatformconfig/ConfigParser.cpp
index ef07d7c5..785c9533 100644
--- a/libplatformconfig/ConfigParser.cpp
+++ b/libplatformconfig/ConfigParser.cpp
@@ -32,7 +32,6 @@
 #include <errno.h>
 #include <utils/Log.h>
 #include <sys/mman.h>
-#include "vidc_debug.h"
 #include "PlatformConfig.h"
 #include "ConfigParser.h"
 
@@ -42,14 +41,14 @@ namespace Platform {
 
 void ConfigParser::processProperty(const XML_Char **attr, ConfigMap &configMap) {
     if (strcmp(attr[0], "name") != 0) {
-        DEBUG_PRINT_HIGH("%s: Element 'name' not found!", __func__);
+        VIDC_PLAT_LOGH("%s: Element 'name' not found!", __func__);
         return;
     }
 
     std::string propName(attr[1]);
 
     if (strcmp(attr[2], "value") != 0) {
-        DEBUG_PRINT_HIGH("%s: Element 'value' not found for %s!", __func__, propName.c_str());
+        VIDC_PLAT_LOGH("%s: Element 'value' not found for %s!", __func__, propName.c_str());
         return;
     }
 
@@ -78,7 +77,7 @@ int ConfigParser::initAndParse(std::string configFile, ConfigMap &configMap) {
     FILE *file;
     file = fopen(configFile.c_str(), "r");
     if (!file) {
-        DEBUG_PRINT_HIGH("%s: Error: %d (%s). Using defaults!",
+        VIDC_PLAT_LOGH("%s: Error: %d (%s). Using defaults!",
             __func__, errno, strerror(errno));
         return err;
     }
@@ -86,7 +85,7 @@ int ConfigParser::initAndParse(std::string configFile, ConfigMap &configMap) {
     // Create Parser
     parser = XML_ParserCreate(NULL);
     if (!parser) {
-        DEBUG_PRINT_HIGH("%s: Failed to create XML parser!", __func__);
+        VIDC_PLAT_LOGH("%s: Failed to create XML parser!", __func__);
         err = -ENODEV;
         goto fileError;
     }
@@ -101,21 +100,21 @@ int ConfigParser::initAndParse(std::string configFile, ConfigMap &configMap) {
     while (1) {
         buf = XML_GetBuffer(parser, BUF_SIZE);
         if (buf == NULL) {
-            DEBUG_PRINT_HIGH("%s: XML_GetBuffer failed", __func__);
+            VIDC_PLAT_LOGH("%s: XML_GetBuffer failed", __func__);
             err = -ENOMEM;
             goto parserError;
         }
 
         bytesRead = fread(buf, 1, BUF_SIZE, file);
         if (bytesRead < 0) {
-            DEBUG_PRINT_HIGH("%s: fread failed, bytes read = %d", __func__, bytesRead);
+            VIDC_PLAT_LOGH("%s: fread failed, bytes read = %d", __func__, bytesRead);
             err = bytesRead;
             goto parserError;
         }
 
         if (XML_ParseBuffer(parser, bytesRead,
                 bytesRead == 0) == XML_STATUS_ERROR) {
-            DEBUG_PRINT_HIGH("%s: XML_ParseBuffer failed, for %s",
+            VIDC_PLAT_LOGH("%s: XML_ParseBuffer failed, for %s",
                     __func__, configFile.c_str());
             err = -EINVAL;
             goto parserError;
diff --git a/libplatformconfig/ConfigParser.h b/libplatformconfig/ConfigParser.h
index 1170b7ec..7aadc8f2 100644
--- a/libplatformconfig/ConfigParser.h
+++ b/libplatformconfig/ConfigParser.h
@@ -46,6 +46,10 @@
     extern "C" {
 #endif
 
+#define VIDC_PLAT_LOGH(fmt, args...) ({ \
+          ALOGD(fmt,##args); \
+      })
+
 namespace Platform {
 
 class ConfigParser {
diff --git a/libplatformconfig/PlatformConfig.cpp b/libplatformconfig/PlatformConfig.cpp
index df52fef6..35237e8f 100644
--- a/libplatformconfig/PlatformConfig.cpp
+++ b/libplatformconfig/PlatformConfig.cpp
@@ -32,7 +32,6 @@
 #include <errno.h>
 #include <utils/Log.h>
 #include <sys/mman.h>
-#include "vidc_debug.h"
 #include "PlatformConfig.h"
 #include "ConfigParser.h"
 
@@ -47,7 +46,7 @@ Config::Config() {
 }
 
 Config* Config::getInstance() {
-    DEBUG_PRINT_LOW("%s: Enter", __func__);
+    VIDC_PLAT_LOGH("%s: Enter", __func__);
     if (!mInstance) {
         mInstance = new Config();
     }
@@ -62,12 +61,12 @@ ConfigError_t Config::getInt32(Config_t config, int32_t *value,
         return FAIL;
     }
     if (conf->mConfigMap.find(configStrMap[config].name) == conf->mConfigMap.end()) {
-        DEBUG_PRINT_HIGH("%s: Returning default", __func__);
+        VIDC_PLAT_LOGH("%s: Returning default", __func__);
         *value = defaultValue;
         return FAIL;
     }
     *value = (int32_t) atoi(conf->mConfigMap[configStrMap[config].name].c_str());
-    DEBUG_PRINT_LOW("%s Config name: %s value: %d",
+    VIDC_PLAT_LOGH("%s Config name: %s value: %d",
             __func__, configStrMap[config].name, *value);
     return OK;
 }
diff --git a/mm-core/inc/OMX_QCOMExtns.h b/mm-core/inc/OMX_QCOMExtns.h
index a7571a74..47b87af3 100755
--- a/mm-core/inc/OMX_QCOMExtns.h
+++ b/mm-core/inc/OMX_QCOMExtns.h
@@ -46,6 +46,7 @@ extern "C" {
 #include "OMX_Core.h"
 #include "OMX_Video.h"
 #include "string.h"
+#include "OMX_VideoExt.h"
 
 #define OMX_VIDEO_MAX_HP_LAYERS 6
 
@@ -1513,10 +1514,10 @@ typedef enum QOMX_VIDEO_AVCPROFILETYPE {
     QOMX_VIDEO_AVCProfileHigh10        = OMX_VIDEO_AVCProfileHigh10,
     QOMX_VIDEO_AVCProfileHigh422       = OMX_VIDEO_AVCProfileHigh422,
     QOMX_VIDEO_AVCProfileHigh444       = OMX_VIDEO_AVCProfileHigh444,
+    QOMX_VIDEO_AVCProfileConstrainedBaseline = OMX_VIDEO_AVCProfileConstrainedBaseline,
+    QOMX_VIDEO_AVCProfileConstrainedHigh     = OMX_VIDEO_AVCProfileConstrainedHigh,
     /* QCom specific profile indexes */
-    QOMX_VIDEO_AVCProfileConstrained           = OMX_VIDEO_AVCProfileVendorStartUnused,
-    QOMX_VIDEO_AVCProfileConstrainedBaseline,
-    QOMX_VIDEO_AVCProfileConstrainedHigh,
+    QOMX_VIDEO_AVCProfileConstrained         = OMX_VIDEO_AVCProfileVendorStartUnused
 } QOMX_VIDEO_AVCPROFILETYPE;
 
 
diff --git a/mm-core/inc/OMX_Video.h b/mm-core/inc/OMX_Video.h
index a5568fe3..4ac60716 100644
--- a/mm-core/inc/OMX_Video.h
+++ b/mm-core/inc/OMX_Video.h
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2008, 2018 The Khronos Group Inc.
+ * Copyright (c) 2008 The Khronos Group Inc.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -71,7 +71,7 @@ typedef enum OMX_VIDEO_CODINGTYPE {
     OMX_VIDEO_CodingVP8,        /**< Google VP8, formerly known as On2 VP8 */
     OMX_VIDEO_CodingVP9,        /**< Google VP9 */
     OMX_VIDEO_CodingHEVC,       /**< HEVC */
-    OMX_VIDEO_CodingHEIC = 13,  /**< HEIC */
+    OMX_VIDEO_CodingImageHEIC = 13,  /**< HEIC */
     OMX_VIDEO_CodingKhronosExtensions = 0x6F000000, /**< Reserved region for introducing Khronos Standard Extensions */ 
     OMX_VIDEO_CodingVendorStartUnused = 0x7F000000, /**< Reserved region for introducing Vendor Extensions */
     OMX_VIDEO_CodingMax = 0x7FFFFFFF
diff --git a/mm-core/inc/OMX_VideoExt.h b/mm-core/inc/OMX_VideoExt.h
index 758b8be7..b77c6b39 100644
--- a/mm-core/inc/OMX_VideoExt.h
+++ b/mm-core/inc/OMX_VideoExt.h
@@ -58,6 +58,12 @@ typedef struct OMX_NALSTREAMFORMATTYPE{
     OMX_NALUFORMATSTYPE eNaluFormat;
 } OMX_NALSTREAMFORMATTYPE;
 
+/** AVC additional profiles */
+typedef enum OMX_VIDEO_AVCPROFILEEXTTYPE {
+    OMX_VIDEO_AVCProfileConstrainedBaseline = 0x10000,   /**< Constrained baseline profile */
+    OMX_VIDEO_AVCProfileConstrainedHigh     = 0x80000,   /**< Constrained high profile */
+} OMX_VIDEO_AVCPROFILEEXTTYPE;
+
 /** VP8 profiles */
 typedef enum OMX_VIDEO_VP8PROFILETYPE {
     OMX_VIDEO_VP8ProfileMain = 0x01,
diff --git a/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h b/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h
index 876119ab..40937e9f 100644
--- a/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h
+++ b/mm-video-v4l2/vidc/vdec/inc/omx_vdec.h
@@ -1359,6 +1359,7 @@ class omx_vdec: public qc_omx_component
 public:
         bool is_down_scalar_enabled;
         bool m_is_split_mode;
+        bool m_buffer_error;
 };
 
 enum instance_state {
diff --git a/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp b/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp
index a4f91ece..a0a6255d 100644
--- a/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp
+++ b/mm-video-v4l2/vidc/vdec/src/omx_vdec_v4l2.cpp
@@ -730,7 +730,8 @@ omx_vdec::omx_vdec(): m_error_propogated(false),
     secure_scaling_to_non_secure_opb(false),
     m_force_compressed_for_dpb(true),
     m_is_display_session(false),
-    m_is_split_mode(false)
+    m_is_split_mode(false),
+    m_buffer_error(false)
 {
     m_poll_efd = -1;
     drv_ctx.video_driver_fd = -1;
@@ -3206,7 +3207,7 @@ bool omx_vdec::execute_output_flush()
     while (m_ftb_q.m_size) {
         m_ftb_q.pop_entry(&p1,&p2,&ident);
         if (ident == m_fill_output_msg ) {
-            print_omx_buffer("Flush FBD", (OMX_BUFFERHEADERTYPE *)&p2);
+            print_omx_buffer("Flush FBD", (OMX_BUFFERHEADERTYPE *)p2);
             m_cb.FillBufferDone(&m_cmp, m_app_data, (OMX_BUFFERHEADERTYPE *)(intptr_t)p2);
         } else if (ident == OMX_COMPONENT_GENERATE_FBD) {
             fill_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)(intptr_t)p1);
@@ -3247,15 +3248,15 @@ bool omx_vdec::execute_input_flush()
         m_etb_q.pop_entry(&p1,&p2,&ident);
 
         if (ident == OMX_COMPONENT_GENERATE_ETB_ARBITRARY) {
-            print_omx_buffer("Flush ETB_ARBITRARY", (OMX_BUFFERHEADERTYPE *)&p2);
+            print_omx_buffer("Flush ETB_ARBITRARY", (OMX_BUFFERHEADERTYPE *)p2);
             m_cb.EmptyBufferDone(&m_cmp ,m_app_data, (OMX_BUFFERHEADERTYPE *)p2);
         } else if (ident == OMX_COMPONENT_GENERATE_ETB) {
             pending_input_buffers++;
             VIDC_TRACE_INT_LOW("ETB-pending", pending_input_buffers);
-            print_omx_buffer("Flush ETB", (OMX_BUFFERHEADERTYPE *)&p2);
+            print_omx_buffer("Flush ETB", (OMX_BUFFERHEADERTYPE *)p2);
             empty_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p2);
         } else if (ident == OMX_COMPONENT_GENERATE_EBD) {
-            print_omx_buffer("Flush EBD", (OMX_BUFFERHEADERTYPE *)&p1);
+            print_omx_buffer("Flush EBD", (OMX_BUFFERHEADERTYPE *)p1);
             empty_buffer_done(&m_cmp,(OMX_BUFFERHEADERTYPE *)p1);
         }
     }
@@ -5566,6 +5567,7 @@ OMX_ERRORTYPE  omx_vdec::use_output_buffer(
         eRet = allocate_output_headers();
         if (eRet == OMX_ErrorNone)
             eRet = allocate_extradata();
+        output_use_buffer = true;
     }
 
     if (eRet == OMX_ErrorNone) {
@@ -6030,7 +6032,6 @@ OMX_ERRORTYPE omx_vdec::free_input_buffer(OMX_BUFFERHEADERTYPE *bufferHdr)
     index = bufferHdr - m_inp_mem_ptr;
     DEBUG_PRINT_LOW("Free Input Buffer index = %d",index);
 
-    auto_lock l(buf_lock);
     bufferHdr->pInputPortPrivate = NULL;
 
     if (index < drv_ctx.ip_buf.actualcount && drv_ctx.ptr_inputbuffer) {
@@ -6159,6 +6160,7 @@ OMX_ERRORTYPE  omx_vdec::allocate_input_buffer(
     unsigned   i = 0;
     unsigned char *buf_addr = NULL;
     int pmem_fd = -1, ret = 0;
+    unsigned int align_size = 0;
 
     (void) hComp;
     (void) port;
@@ -6236,8 +6238,10 @@ OMX_ERRORTYPE  omx_vdec::allocate_input_buffer(
         int rc;
         DEBUG_PRINT_LOW("Allocate input Buffer");
 #ifdef USE_ION
+        align_size = drv_ctx.ip_buf.buffer_size + 512;
+        align_size = (align_size + drv_ctx.ip_buf.alignment - 1)&(~(drv_ctx.ip_buf.alignment - 1));
         drv_ctx.ip_buf_ion_info[i].ion_device_fd = alloc_map_ion_memory(
-                drv_ctx.ip_buf.buffer_size,drv_ctx.op_buf.alignment,
+                align_size, drv_ctx.op_buf.alignment,
                 &drv_ctx.ip_buf_ion_info[i].ion_alloc_data,
                 &drv_ctx.ip_buf_ion_info[i].fd_ion_data, secure_mode ?
                 SECURE_FLAGS_INPUT_BUFFER : 0);
@@ -6644,6 +6648,10 @@ OMX_ERRORTYPE  omx_vdec::allocate_buffer(OMX_IN OMX_HANDLETYPE                hC
         }
         eRet = allocate_input_buffer(hComp,bufferHdr,port,appData,bytes);
     } else if (port == OMX_CORE_OUTPUT_PORT_INDEX) {
+        if (output_use_buffer) {
+            DEBUG_PRINT_ERROR("Allocate output buffer not allowed after use buffer");
+            return OMX_ErrorBadParameter;
+        }
         eRet = client_buffers.allocate_buffers_color_convert(hComp,bufferHdr,port,
                 appData,bytes);
     } else {
@@ -6702,6 +6710,7 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
     unsigned int nPortIndex;
     (void) hComp;
 
+    auto_lock l(buf_lock);
     if (m_state == OMX_StateIdle &&
             (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING))) {
         DEBUG_PRINT_LOW(" free buffer while Component in Loading pending");
@@ -6718,7 +6727,7 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
         post_event(OMX_EventError,
                 OMX_ErrorPortUnpopulated,
                 OMX_COMPONENT_GENERATE_EVENT);
-
+        m_buffer_error = true;
         return OMX_ErrorIncorrectStateOperation;
     } else if (m_state != OMX_StateInvalid) {
         DEBUG_PRINT_ERROR("Invalid state to free buffer,port lost Buffers");
@@ -6826,6 +6835,7 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
             BITMASK_CLEAR((&m_flags),OMX_COMPONENT_LOADING_PENDING);
             post_event(OMX_CommandStateSet, OMX_StateLoaded,
                     OMX_COMPONENT_GENERATE_EVENT);
+            m_buffer_error = false;
         }
     }
     return eRet;
@@ -6996,6 +7006,11 @@ OMX_ERRORTYPE  omx_vdec::empty_this_buffer_proxy(OMX_IN OMX_HANDLETYPE  hComp,
         return OMX_ErrorBadParameter;
     }
 
+    if (BITMASK_ABSENT(&m_inp_bm_count, nPortIndex) || m_buffer_error) {
+        DEBUG_PRINT_ERROR("ETBProxy: ERROR: invalid buffer, nPortIndex %u", nPortIndex);
+        return OMX_ErrorBadParameter;
+    }
+
     VIDC_TRACE_INT_LOW("ETB-TS", buffer->nTimeStamp / 1000);
     VIDC_TRACE_INT_LOW("ETB-size", buffer->nFilledLen);
     /*for use buffer we need to memcpy the data*/
@@ -7277,6 +7292,7 @@ OMX_ERRORTYPE  omx_vdec::fill_this_buffer_proxy(
     struct vdec_bufferpayload     *ptr_outputbuffer = NULL;
     struct vdec_output_frameinfo  *ptr_respbuffer = NULL;
 
+    auto_lock l(buf_lock);
     nPortIndex = buffer-((OMX_BUFFERHEADERTYPE *)client_buffers.get_il_buf_hdr());
 
     if (bufferAdd == NULL || nPortIndex >= drv_ctx.op_buf.actualcount) {
@@ -7285,6 +7301,11 @@ OMX_ERRORTYPE  omx_vdec::fill_this_buffer_proxy(
         return OMX_ErrorBadParameter;
     }
 
+    if (BITMASK_ABSENT(&m_out_bm_count, nPortIndex) || m_buffer_error) {
+        DEBUG_PRINT_ERROR("FTBProxy: ERROR: invalid buffer, nPortIndex %u", nPortIndex);
+        return OMX_ErrorBadParameter;
+    }
+
     /*Return back the output buffer to client*/
     if (m_out_bEnabled != OMX_TRUE || output_flush_progress == true || in_reconfig) {
         DEBUG_PRINT_LOW("Output Buffers return flush/disable condition");
@@ -8538,7 +8559,7 @@ int omx_vdec::async_message_process (void *context, void* message)
                    if (omxhdr->nFilledLen)
                        omx->prev_n_filled_len = omxhdr->nFilledLen;
 
-                   if (omx->output_use_buffer && omxhdr->pBuffer &&
+                   if (!omx->m_enable_android_native_buffers && omx->output_use_buffer && omxhdr->pBuffer &&
                        vdec_msg->msgdata.output_frame.bufferaddr)
                        memcpy ( omxhdr->pBuffer, (void *)
                                ((unsigned long)vdec_msg->msgdata.output_frame.bufferaddr +
@@ -11736,7 +11757,7 @@ OMX_ERRORTYPE omx_vdec::describeColorFormat(OMX_PTR pParam) {
 
     MediaImage *img = &(params->sMediaImage);
     switch(params->eColorFormat) {
-        case QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m:
+        case static_cast <OMX_COLOR_FORMATTYPE> (QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m):
         {
             img->mType = MediaImage::MEDIA_IMAGE_TYPE_YUV;
             img->mNumPlanes = 3;
diff --git a/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h b/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h
index acb09d4d..0c7ee4f8 100644
--- a/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h
+++ b/mm-video-v4l2/vidc/venc/inc/video_encoder_device_v4l2.h
@@ -405,6 +405,7 @@ class venc_dev
             struct ion_fd_data ion_alloc_fd;
 #endif
         };
+
         int nPframes_cache;
         int stopped;
         int resume_in_stopped;
@@ -591,6 +592,8 @@ class venc_dev
         BatchInfo mBatchInfo;
         bool mUseAVTimerTimestamps;
         bool venc_set_hdr_info(const MasteringDisplay&, const ContentLightLevel&);
+        bool mIsGridset;
+        OMX_U32 mTileDimension;
 };
 
 enum instance_state {
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 ca03063a..e10da109 100644
--- a/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
+++ b/mm-video-v4l2/vidc/venc/src/omx_video_base.cpp
@@ -1586,7 +1586,7 @@ OMX_ERRORTYPE  omx_video::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
                     // At the same time, FWK needs original WxH for various purposes
                     // Sending input WxH as output port def WxH to FWK
                     if (m_sOutPortDef.format.video.eCompressionFormat ==
-                            OMX_VIDEO_CodingHEIC) {
+                            OMX_VIDEO_CodingImageHEIC) {
                         portDefn->format.video.nFrameWidth =
                             m_sInPortDef.format.video.nFrameWidth;
                         portDefn->format.video.nFrameHeight =
diff --git a/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp b/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
index 8181347c..cd85448e 100644
--- a/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
+++ b/mm-video-v4l2/vidc/venc/src/omx_video_encoder.cpp
@@ -127,7 +127,7 @@ OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
     } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.heic",    \
                 OMX_MAX_STRINGNAME_SIZE)) {
         strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
-        codec_type = OMX_VIDEO_CodingHEIC;
+        codec_type = OMX_VIDEO_CodingImageHEIC;
     } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc.secure",    \
                 OMX_MAX_STRINGNAME_SIZE)) {
         strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
@@ -268,7 +268,7 @@ OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
     } else if (codec_type == OMX_VIDEO_CodingHEVC) {
         m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_HEVCProfileMain;
         m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_HEVCMainTierLevel1;
-    } else if (codec_type == OMX_VIDEO_CodingHEIC) {
+    } else if (codec_type == OMX_VIDEO_CodingImageHEIC) {
         m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_HEVCProfileMainStill;
         m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_HEVCMainTierLevel1;
     }
@@ -320,8 +320,8 @@ OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
         m_sOutPortDef.format.video.eCompressionFormat =  OMX_VIDEO_CodingVP8;
     } else if (codec_type == OMX_VIDEO_CodingHEVC) {
         m_sOutPortDef.format.video.eCompressionFormat =  OMX_VIDEO_CodingHEVC;
-    } else if (codec_type == OMX_VIDEO_CodingHEIC) {
-        m_sOutPortDef.format.video.eCompressionFormat =  OMX_VIDEO_CodingHEIC;
+    } else if (codec_type == OMX_VIDEO_CodingImageHEIC) {
+        m_sOutPortDef.format.video.eCompressionFormat =  OMX_VIDEO_CodingImageHEIC;
     } else if (codec_type == (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME) {
         m_sOutPortDef.format.video.eCompressionFormat =  (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME;
     }
@@ -353,8 +353,8 @@ OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
         m_sOutPortFormat.eCompressionFormat =  OMX_VIDEO_CodingVP8;
     } else if (codec_type == OMX_VIDEO_CodingHEVC) {
         m_sOutPortFormat.eCompressionFormat =  OMX_VIDEO_CodingHEVC;
-    } else if (codec_type == OMX_VIDEO_CodingHEIC) {
-        m_sOutPortFormat.eCompressionFormat =  OMX_VIDEO_CodingHEIC;
+    } else if (codec_type == OMX_VIDEO_CodingImageHEIC) {
+        m_sOutPortFormat.eCompressionFormat =  OMX_VIDEO_CodingImageHEIC;
     } else if (codec_type == (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME) {
         m_sOutPortFormat.eCompressionFormat =  (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME;
     }
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 36d5baa7..0f15a1ed 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
@@ -191,6 +191,8 @@ venc_dev::venc_dev(class omx_venc *venc_class)
          strlcpy(m_debug.log_loc, property_value, PROPERTY_VALUE_MAX);
 
     mUseAVTimerTimestamps = false;
+    mIsGridset = false;
+    mTileDimension = 0;
 
     profile_level_converter::init();
 }
@@ -1409,12 +1411,12 @@ bool venc_dev::venc_open(OMX_U32 codec)
         profile_level.level = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0;
         minqp = 0;
         maxqp = 127;
-    } else if (codec == OMX_VIDEO_CodingHEVC || codec == OMX_VIDEO_CodingHEIC) {
+    } else if (codec == OMX_VIDEO_CodingHEVC || codec == OMX_VIDEO_CodingImageHEIC) {
         m_sVenc_cfg.codectype = V4L2_PIX_FMT_HEVC;
         idrperiod.idrperiod = 1;
         minqp = 0;
         maxqp = 51;
-        if (codec == OMX_VIDEO_CodingHEIC)
+        if (codec == OMX_VIDEO_CodingImageHEIC)
             codec_profile.profile = V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN_STILL_PIC;
         else
             codec_profile.profile = V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN;
@@ -2013,13 +2015,6 @@ bool venc_dev::venc_set_param(void *paramData, OMX_INDEXTYPE index)
                 } else if (portDefn->nPortIndex == PORT_INDEX_OUT) {
                     unsigned long codectype = venc_get_codectype(portDefn->format.video.eCompressionFormat);
 
-                    if (portDefn->format.video.eCompressionFormat == OMX_VIDEO_CodingHEIC) {
-                        portDefn->format.video.nFrameWidth = DEFAULT_TILE_DIMENSION;
-                        portDefn->format.video.nFrameHeight = DEFAULT_TILE_DIMENSION;
-                        DEBUG_PRINT_HIGH("set_parameter: OMX_IndexParamPortDefinition: port %d, wxh (for HEIC coding type) %dx%d",
-                            portDefn->nPortIndex, portDefn->format.video.nFrameWidth,
-                            portDefn->format.video.nFrameHeight);
-                    }
                     //Don't worry about width/height if downscalar is enabled.
                     if (((m_sVenc_cfg.dvs_height != portDefn->format.video.nFrameHeight ||
                             m_sVenc_cfg.dvs_width != portDefn->format.video.nFrameWidth) && !downscalar_enabled) ||
@@ -2258,9 +2253,9 @@ bool venc_dev::venc_set_param(void *paramData, OMX_INDEXTYPE index)
                 OMX_VIDEO_PARAM_ANDROID_IMAGEGRIDTYPE* pParam =
                        (OMX_VIDEO_PARAM_ANDROID_IMAGEGRIDTYPE*)paramData;
 
-                if (m_codec != OMX_VIDEO_CodingHEIC) {
-                    DEBUG_PRINT_ERROR("OMX_IndexParamVideoAndroidImageGrid is only supported for HEIC");
-                    return false;
+                if (m_codec != OMX_VIDEO_CodingImageHEIC) {
+                    DEBUG_PRINT_ERROR("OMX_IndexParamVideoAndroidImageGrid is only set for HEIC Encode (HW tiling)");
+                    return true;
                 }
 
                 if (!venc_set_tile_dimension(pParam->nTileWidth)) {
@@ -3446,6 +3441,27 @@ unsigned venc_dev::venc_start(void)
         return 1;
     }
 
+    if(m_codec == OMX_VIDEO_CodingImageHEIC && mIsGridset) {
+        struct v4l2_format fmt;
+        memset(&fmt, 0, sizeof(fmt));
+        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+        fmt.fmt.pix_mp.height = mTileDimension;
+        fmt.fmt.pix_mp.width = mTileDimension;
+        fmt.fmt.pix_mp.pixelformat = m_sVenc_cfg.codectype;
+        DEBUG_PRINT_INFO("set format type %d, wxh %dx%d, pixelformat %#x",
+                 fmt.type, fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
+                 fmt.fmt.pix_mp.pixelformat);
+        if (ioctl(m_nDriver_fd, VIDIOC_S_FMT, &fmt)) {
+            DEBUG_PRINT_ERROR("set format failed, type %d, wxh %dx%d, pixelformat %#x",
+                 fmt.type, fmt.fmt.pix_mp.width, fmt.fmt.pix_mp.height,
+                 fmt.fmt.pix_mp.pixelformat);
+            hw_overload = errno == EBUSY;
+            return false;
+        }
+
+
+    }
+
     buf_type=V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Executing");
     ret=ioctl(m_nDriver_fd, VIDIOC_STREAMON,&buf_type);
@@ -4254,7 +4270,7 @@ bool venc_dev::venc_empty_buf(void *buffer, void *pmem_data_buf, unsigned index,
             }
 
             // Tiling in HEIC requires output WxH to be Tile size; difference is permitted
-            if (!(m_codec == OMX_VIDEO_CodingHEIC) &&
+            if (!(m_codec == OMX_VIDEO_CodingImageHEIC) &&
                 inp_width * inp_height != out_width * out_height) {
                 DEBUG_PRINT_ERROR("Downscalar is disabled and input/output dimenstions don't match");
                 DEBUG_PRINT_ERROR("Input WxH : %dx%d Output WxH : %dx%d",inp_width, inp_height, out_width, out_height);
@@ -5035,7 +5051,7 @@ bool venc_dev::venc_reconfigure_intra_period()
         ((codec_profile.profile == V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN) ||
          (codec_profile.profile == V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN10) ||
          (codec_profile.profile == V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN_STILL_PIC)) &&
-         (m_codec != OMX_VIDEO_CodingHEIC)) {
+         (m_codec != OMX_VIDEO_CodingImageHEIC)) {
         isValidCodec = true;
     }
 
@@ -5152,6 +5168,8 @@ bool venc_dev::venc_set_tile_dimension(OMX_U32 nTileDimension)
     }
 
     DEBUG_PRINT_LOW("Success IOCTL set control for id=%d, value=%d", control.id, control.value);
+    mIsGridset = true;
+    mTileDimension = nTileDimension;
 
     return true;
 }
@@ -5175,7 +5193,7 @@ bool venc_dev::_venc_set_intra_period(OMX_U32 nPFrames, OMX_U32 nBFrames)
 
     if (m_sVenc_cfg.codectype != V4L2_PIX_FMT_H264 &&
         m_sVenc_cfg.codectype != V4L2_PIX_FMT_HEVC &&
-        m_codec == OMX_VIDEO_CodingHEIC) {
+        m_codec == OMX_VIDEO_CodingImageHEIC) {
         nBFrames = 0;
     }
 
@@ -5638,7 +5656,7 @@ unsigned long venc_dev::venc_get_codectype(OMX_VIDEO_CODINGTYPE eCompressionForm
     case OMX_VIDEO_CodingVP9:
         codectype = V4L2_PIX_FMT_VP9;
         break;
-    case OMX_VIDEO_CodingHEIC:
+    case OMX_VIDEO_CodingImageHEIC:
     case OMX_VIDEO_CodingHEVC:
         codectype = V4L2_PIX_FMT_HEVC;
         break;