Enable native buffer mode for ICS in wrs core

,clean buffer id mode related code

BZ: 18370

Signed-off-by: xiao <fengx.xiao@intel.com>

Change-Id: I657ac61aeaaaffdbacde3afd9743a9ddeed29588
Reviewed-on: http://android.intel.com:8080/27892
Reviewed-by: Ding, Haitao <haitao.ding@intel.com>
Tested-by: Ding, Haitao <haitao.ding@intel.com>
Reviewed-by: buildbot <buildbot@intel.com>
Tested-by: buildbot <buildbot@intel.com>

6 files changed, 210 insertions, 67 deletions

diff --git a/base/inc/componentbase.h b/base/inc/componentbase.h
index 336ef71..9c34cb7 100644
--- a/base/inc/componentbase.h
+++ b/base/inc/componentbase.h
@@ -327,6 +327,9 @@ protected:
     /* ports big lock, must be held when accessing all ports at one time */
     pthread_mutex_t ports_block;
 
+    /*output queue lock for native buffer mode preprocess the buffer queue*/
+    pthread_mutex_t output_queue_lock;
+
 private:
     /* common routines for constructor */
     void __ComponentBase(void);
@@ -397,13 +400,13 @@ private:
     bool IsAllBufferAvailable(void);
 
     /* called in Work() after ProcessorProcess() */
-    void PostProcessBuffers(OMX_BUFFERHEADERTYPE **buffers,
+    void PostProcessBuffers(OMX_BUFFERHEADERTYPE ***buffers,
                             const buffer_retain_t *retain);
-    void SourcePostProcessBuffers(OMX_BUFFERHEADERTYPE **buffers,
+    void SourcePostProcessBuffers(OMX_BUFFERHEADERTYPE ***buffers,
                                   const buffer_retain_t *retain);
-    void FilterPostProcessBuffers(OMX_BUFFERHEADERTYPE **buffers,
+    void FilterPostProcessBuffers(OMX_BUFFERHEADERTYPE ***buffers,
                                   const buffer_retain_t *retain);
-    void SinkPostProcessBuffers(OMX_BUFFERHEADERTYPE **buffers,
+    void SinkPostProcessBuffers(OMX_BUFFERHEADERTYPE ***buffers,
                                 const buffer_retain_t *retain);
 
     /* processor callbacks */
@@ -415,11 +418,15 @@ private:
     virtual OMX_ERRORTYPE ProcessorPause(void); /* Executing to Pause */
     virtual OMX_ERRORTYPE ProcessorResume(void);/* Pause to Executing */
     virtual OMX_ERRORTYPE ProcessorFlush(OMX_U32 port_index); /* Flush */
-
+    virtual OMX_ERRORTYPE PreProcessBuffer(OMX_BUFFERHEADERTYPE* buffer);
+    virtual OMX_ERRORTYPE PreProcessBufferQueue_Locked();
     /* Work */
-    virtual OMX_ERRORTYPE ProcessorProcess(OMX_BUFFERHEADERTYPE **buffers,
+    virtual OMX_ERRORTYPE ProcessorProcess(OMX_BUFFERHEADERTYPE ***pBuffers,
+                                           buffer_retain_t *retain,
+                                           OMX_U32 nr_buffers);
+    virtual OMX_ERRORTYPE ProcessorProcess(OMX_BUFFERHEADERTYPE **pBuffers,
                                            buffer_retain_t *retain,
-                                           OMX_U32 nr_buffers) = 0;
+                                           OMX_U32 nr_buffers);
 
     /* end of component methods & helpers */
 
diff --git a/base/inc/portbase.h b/base/inc/portbase.h
index 50fcf29..c370cac 100644
--- a/base/inc/portbase.h
+++ b/base/inc/portbase.h
@@ -83,7 +83,11 @@ public:
     /* Empty/FillThisBuffer */
     OMX_ERRORTYPE PushThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer);
     OMX_BUFFERHEADERTYPE *PopBuffer(void);
+    OMX_ERRORTYPE MixPushThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer);
+    OMX_BUFFERHEADERTYPE *MixPopBuffer(void);
+    OMX_ERRORTYPE MixPushBufferHead(OMX_BUFFERHEADERTYPE *pBuffer);
     OMX_U32 BufferQueueLength(void);
+    OMX_U32 MixBufferQueueLength(void);
 
     /* Empty/FillBufferDone */
     OMX_ERRORTYPE ReturnThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer);
@@ -143,6 +147,10 @@ private:
     struct queue bufferq;
     pthread_mutex_t bufferq_lock;
 
+    struct queue mixbufferq;
+    pthread_mutex_t mixbufferq_lock;
+
+
     /* retained buffers (only accumulated buffer) */
     struct queue retainedbufferq;
     pthread_mutex_t retainedbufferq_lock;
diff --git a/base/src/componentbase.cpp b/base/src/componentbase.cpp
index 13429cd..ba10383 100644
--- a/base/src/componentbase.cpp
+++ b/base/src/componentbase.cpp
@@ -23,12 +23,12 @@
 
 #include <OMX_Core.h>
 #include <OMX_Component.h>
-#include <OMX_IndexExt.h>
 
 #include <componentbase.h>
 
 #include <queue.h>
 #include <workqueue.h>
+#include <OMX_IndexExt.h>
 
 //#define LOG_NDEBUG 0
 
@@ -136,6 +136,7 @@ void ComponentBase::__ComponentBase(void)
     bufferwork = NULL;
 
     pthread_mutex_init(&ports_block, NULL);
+    pthread_mutex_init(&output_queue_lock, NULL);
 }
 
 ComponentBase::ComponentBase()
@@ -152,6 +153,7 @@ ComponentBase::ComponentBase(const OMX_STRING name)
 ComponentBase::~ComponentBase()
 {
     pthread_mutex_destroy(&ports_block);
+    pthread_mutex_destroy(&output_queue_lock);
 
     if (roles) {
         if (roles[0])
@@ -543,6 +545,7 @@ OMX_ERRORTYPE ComponentBase::CBaseGetParameter(
 
         ret = OMX_ErrorUnsupportedIndex;
         break;
+
     default:
         ret = ComponentGetParameter(nParamIndex, pComponentParameterStructure);
     } /* switch */
@@ -643,6 +646,7 @@ OMX_ERRORTYPE ComponentBase::CBaseSetParameter(
         }
         break;
     }
+
     default:
         ret = ComponentSetParameter(nIndex, pComponentParameterStructure);
     } /* switch */
@@ -748,13 +752,12 @@ OMX_ERRORTYPE ComponentBase::CBaseGetExtensionIndex(
     OMX_IN  OMX_STRING cParameterName,
     OMX_OUT OMX_INDEXTYPE* pIndexType)
 {
+    /*
+     * Todo
+     */
     if (hComponent != handle) {
-        return OMX_ErrorBadParameter;
-    };
 
-    if (!strcmp(cParameterName, "OMX.Intel.Index.BufferIDMode")) {
-        *pIndexType = static_cast<OMX_INDEXTYPE>(OMX_IndexBufferIDMode);
-        return OMX_ErrorNone;
+        return OMX_ErrorBadParameter;
     }
 
     if (!strcmp(cParameterName, "OMX.google.android.index.storeMetaDataInBuffers")) {
@@ -762,6 +765,21 @@ OMX_ERRORTYPE ComponentBase::CBaseGetExtensionIndex(
         return OMX_ErrorNone;
     }
 
+    if(!strcmp(cParameterName, "OMX.google.android.index.enableAndroidNativeBuffers")) {
+        *pIndexType = static_cast<OMX_INDEXTYPE>(OMX_IndexExtEnableNativeBuffer);
+        return OMX_ErrorNone;
+    }
+
+    if(!strcmp(cParameterName, "OMX.google.android.index.getAndroidNativeBufferUsage")) {
+        *pIndexType = static_cast<OMX_INDEXTYPE>(OMX_IndexExtGetNativeBufferUsage);
+        return OMX_ErrorNone;
+    }
+
+    if(!strcmp(cParameterName, "OMX.google.android.index.useAndroidNativeBuffer")) {
+        *pIndexType = static_cast<OMX_INDEXTYPE>(OMX_IndexExtUseNativeBuffer);
+        return OMX_ErrorNone;
+    }
+
     return OMX_ErrorUnsupportedIndex;
 }
 
@@ -1105,7 +1123,13 @@ OMX_ERRORTYPE ComponentBase::CBaseFillThisBuffer(
             return OMX_ErrorIncorrectStateOperation;
     }
 
+    ret = PreProcessBuffer(pBuffer);
+    if (ret != OMX_ErrorNone)
+       return ret;
+
+    pthread_mutex_lock(&output_queue_lock);
     ret = port->PushThisBuffer(pBuffer);
+    pthread_mutex_unlock(&output_queue_lock);
     if (ret == OMX_ErrorNone)
         bufferwork->ScheduleWork(this);
 
@@ -1866,7 +1890,8 @@ OMX_ERRORTYPE ComponentBase::FreePorts(void)
 /* implement WorkableInterface */
 void ComponentBase::Work(void)
 {
-    OMX_BUFFERHEADERTYPE *buffers[nr_ports];
+    OMX_BUFFERHEADERTYPE **buffers[nr_ports];
+    OMX_BUFFERHEADERTYPE *buffers_hdr[nr_ports];
     buffer_retain_t retain[nr_ports];
     OMX_U32 i;
     OMX_ERRORTYPE ret;
@@ -1876,22 +1901,28 @@ void ComponentBase::Work(void)
     while(IsAllBufferAvailable())
     {
         for (i = 0; i < nr_ports; i++) {
-            buffers[i] = ports[i]->PopBuffer();
+            buffers_hdr[i] = ports[i]->PopBuffer();
+            buffers[i] = &buffers_hdr[i];
             retain[i] = BUFFER_RETAIN_NOT_RETAIN;
         }
 
-        ret = ProcessorProcess(buffers, &retain[0], nr_ports);
+        if (!strncmp((char*)working_role, "video_decoder", 13)){
+            ret = ProcessorProcess(buffers, &retain[0], nr_ports);
+        }else{
+            ret = ProcessorProcess(buffers_hdr, &retain[0], nr_ports);
+        }
 
         if (ret == OMX_ErrorNone) {
             PostProcessBuffers(buffers, &retain[0]);
 
             for (i = 0; i < nr_ports; i++) {
-                if (retain[i] == BUFFER_RETAIN_GETAGAIN)
-                    ports[i]->RetainThisBuffer(buffers[i], false);
+
+                if(retain[i] == BUFFER_RETAIN_GETAGAIN)
+                    ports[i]->RetainThisBuffer(*buffers[i], false);
                 else if (retain[i] == BUFFER_RETAIN_ACCUMULATE)
-                    ports[i]->RetainThisBuffer(buffers[i], true);
+                    ports[i]->RetainThisBuffer(*buffers[i], true);
                 else
-                    ports[i]->ReturnThisBuffer(buffers[i]);
+                    ports[i]->ReturnThisBuffer(*buffers[i]);
             }
         }
         else {
@@ -1900,7 +1931,7 @@ void ComponentBase::Work(void)
 
             for (i = 0; i < nr_ports; i++) {
                 /* return buffers by hands, these buffers're not in queue */
-                ports[i]->ReturnThisBuffer(buffers[i]);
+                ports[i]->ReturnThisBuffer(*buffers[i]);
                 /* flush ports */
                 ports[i]->FlushPort();
             }
@@ -1912,6 +1943,10 @@ void ComponentBase::Work(void)
 
 bool ComponentBase::IsAllBufferAvailable(void)
 {
+
+    pthread_mutex_lock(&output_queue_lock);
+    PreProcessBufferQueue_Locked();
+
     OMX_U32 i;
     OMX_U32 nr_avail = 0;
 
@@ -1924,6 +1959,7 @@ bool ComponentBase::IsAllBufferAvailable(void)
         if (length)
             nr_avail++;
     }
+    pthread_mutex_unlock(&output_queue_lock);
 
     if (nr_avail == nr_ports)
         return true;
@@ -1932,7 +1968,7 @@ bool ComponentBase::IsAllBufferAvailable(void)
 }
 
 inline void ComponentBase::SourcePostProcessBuffers(
-    OMX_BUFFERHEADERTYPE **buffers,
+    OMX_BUFFERHEADERTYPE ***buffers,
     const buffer_retain_t *retain)
 {
     OMX_U32 i;
@@ -1942,14 +1978,13 @@ inline void ComponentBase::SourcePostProcessBuffers(
          * in case of source component, buffers're marked when they come
          * from the ouput ports
          */
-        if (!buffers[i]->hMarkTargetComponent) {
+        if (!(*buffers[i])->hMarkTargetComponent) {
             OMX_MARKTYPE *mark;
 
             mark = ports[i]->PopMark();
             if (mark) {
-                buffers[i]->hMarkTargetComponent =
-                    mark->hMarkTargetComponent;
-                buffers[i]->pMarkData = mark->pMarkData;
+                (*buffers[i])->hMarkTargetComponent = mark->hMarkTargetComponent;
+                (*buffers[i])->pMarkData = mark->pMarkData;
                 free(mark);
             }
         }
@@ -1957,7 +1992,7 @@ inline void ComponentBase::SourcePostProcessBuffers(
 }
 
 inline void ComponentBase::FilterPostProcessBuffers(
-    OMX_BUFFERHEADERTYPE **buffers,
+    OMX_BUFFERHEADERTYPE ***buffers,
     const buffer_retain_t *retain)
 {
     OMX_MARKTYPE *mark;
@@ -1972,8 +2007,8 @@ inline void ComponentBase::FilterPostProcessBuffers(
                 /* propagates EOS flag */
                 /* clear input EOS at the end of this loop */
                 if (retain[i] != BUFFER_RETAIN_GETAGAIN) {
-                    if (buffers[i]->nFlags & OMX_BUFFERFLAG_EOS)
-                        buffers[j]->nFlags |= OMX_BUFFERFLAG_EOS;
+                    if ((*buffers[i])->nFlags & OMX_BUFFERFLAG_EOS)
+                        (*buffers[j])->nFlags |= OMX_BUFFERFLAG_EOS;
                 }
 
                 /* propagates marks */
@@ -1981,64 +2016,64 @@ inline void ComponentBase::FilterPostProcessBuffers(
                  * if hMarkTargetComponent == handle then the mark's not
                  * propagated
                  */
-                if (buffers[i]->hMarkTargetComponent &&
-                    (buffers[i]->hMarkTargetComponent != handle)) {
-                    if (buffers[j]->hMarkTargetComponent) {
+                if ((*buffers[i])->hMarkTargetComponent &&
+                    ((*buffers[i])->hMarkTargetComponent != handle)) {
+                    if ((*buffers[j])->hMarkTargetComponent) {
                         mark = (OMX_MARKTYPE *)malloc(sizeof(*mark));
                         if (mark) {
                             mark->hMarkTargetComponent =
-                                buffers[i]->hMarkTargetComponent;
-                            mark->pMarkData = buffers[i]->pMarkData;
+                                (*buffers[i])->hMarkTargetComponent;
+                            mark->pMarkData = (*buffers[i])->pMarkData;
                             ports[j]->PushMark(mark);
                             mark = NULL;
-                            buffers[i]->hMarkTargetComponent = NULL;
-                            buffers[i]->pMarkData = NULL;
+                            (*buffers[i])->hMarkTargetComponent = NULL;
+                            (*buffers[i])->pMarkData = NULL;
                         }
                     }
                     else {
                         mark = ports[j]->PopMark();
                         if (mark) {
-                            buffers[j]->hMarkTargetComponent =
+                            (*buffers[j])->hMarkTargetComponent =
                                 mark->hMarkTargetComponent;
-                            buffers[j]->pMarkData = mark->pMarkData;
+                            (*buffers[j])->pMarkData = mark->pMarkData;
                             free(mark);
 
                             mark = (OMX_MARKTYPE *)malloc(sizeof(*mark));
                             if (mark) {
                                 mark->hMarkTargetComponent =
-                                    buffers[i]->hMarkTargetComponent;
-                                mark->pMarkData = buffers[i]->pMarkData;
+                                    (*buffers[i])->hMarkTargetComponent;
+                                mark->pMarkData = (*buffers[i])->pMarkData;
                                 ports[j]->PushMark(mark);
                                 mark = NULL;
-                                buffers[i]->hMarkTargetComponent = NULL;
-                                buffers[i]->pMarkData = NULL;
+                                (*buffers[i])->hMarkTargetComponent = NULL;
+                                (*buffers[i])->pMarkData = NULL;
                             }
                         }
                         else {
-                            buffers[j]->hMarkTargetComponent =
-                                buffers[i]->hMarkTargetComponent;
-                            buffers[j]->pMarkData = buffers[i]->pMarkData;
-                            buffers[i]->hMarkTargetComponent = NULL;
-                            buffers[i]->pMarkData = NULL;
+                            (*buffers[j])->hMarkTargetComponent =
+                                (*buffers[i])->hMarkTargetComponent;
+                            (*buffers[j])->pMarkData = (*buffers[i])->pMarkData;
+                            (*buffers[i])->hMarkTargetComponent = NULL;
+                            (*buffers[i])->pMarkData = NULL;
                         }
                     }
                 }
             }
             /* clear input buffer's EOS */
             if (retain[i] != BUFFER_RETAIN_GETAGAIN)
-                buffers[i]->nFlags &= ~OMX_BUFFERFLAG_EOS;
+                (*buffers[i])->nFlags &= ~OMX_BUFFERFLAG_EOS;
         }
     }
 }
 
 inline void ComponentBase::SinkPostProcessBuffers(
-    OMX_BUFFERHEADERTYPE **buffers,
+    OMX_BUFFERHEADERTYPE ***buffers,
     const buffer_retain_t *retain)
 {
     return;
 }
 
-void ComponentBase::PostProcessBuffers(OMX_BUFFERHEADERTYPE **buffers,
+void ComponentBase::PostProcessBuffers(OMX_BUFFERHEADERTYPE ***buffers,
                                        const buffer_retain_t *retain)
 {
 
@@ -2090,6 +2125,31 @@ OMX_ERRORTYPE ComponentBase::ProcessorFlush(OMX_U32 port_index)
     return OMX_ErrorNone;
 }
 
+OMX_ERRORTYPE ComponentBase::PreProcessBuffer(OMX_BUFFERHEADERTYPE* buffer)
+{
+    return OMX_ErrorNone;
+}
+
+OMX_ERRORTYPE ComponentBase::PreProcessBufferQueue_Locked()
+{
+    return OMX_ErrorNone;
+}
+OMX_ERRORTYPE ComponentBase::ProcessorProcess(OMX_BUFFERHEADERTYPE **pBuffers,
+                                           buffer_retain_t *retain,
+                                           OMX_U32 nr_buffers)
+{
+    LOGE("ProcessorProcess not be implemented");
+    return OMX_ErrorNotImplemented;
+}
+OMX_ERRORTYPE ComponentBase::ProcessorProcess(OMX_BUFFERHEADERTYPE ***pBuffers,
+                                           buffer_retain_t *retain,
+                                           OMX_U32 nr_buffers)
+{
+    LOGE("ProcessorProcess not be implemented");
+    return OMX_ErrorNotImplemented;
+}
+
+
 /* end of processor callbacks */
 
 /* helper for derived class */
diff --git a/base/src/portbase.cpp b/base/src/portbase.cpp
index c9a57d4..fbeda6f 100644
--- a/base/src/portbase.cpp
+++ b/base/src/portbase.cpp
@@ -45,6 +45,9 @@ void PortBase::__PortBase(void)
     __queue_init(&bufferq);
     pthread_mutex_init(&bufferq_lock, NULL);
 
+    __queue_init(&mixbufferq);
+    pthread_mutex_init(&mixbufferq_lock, NULL);
+
     __queue_init(&retainedbufferq);
     pthread_mutex_init(&retainedbufferq_lock, NULL);
 
@@ -98,6 +101,9 @@ PortBase::~PortBase()
     queue_free_all(&bufferq);
     pthread_mutex_destroy(&bufferq_lock);
 
+    queue_free_all(&mixbufferq);
+    pthread_mutex_destroy(&mixbufferq_lock);
+
     /* should've been already freed at buffer processing */
     queue_free_all(&retainedbufferq);
     pthread_mutex_destroy(&retainedbufferq_lock);
@@ -567,6 +573,57 @@ OMX_BUFFERHEADERTYPE *PortBase::PopBuffer(void)
     return buffer;
 }
 
+OMX_ERRORTYPE PortBase::MixPushThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    int ret;
+
+    LOGV_IF(pBuffer != NULL, "%s(): %s:%s:PortIndex %lu:pBuffer %p:\n",
+            __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
+            portdefinition.nPortIndex, pBuffer);
+
+    pthread_mutex_lock(&mixbufferq_lock);
+    ret = queue_push_tail(&mixbufferq, pBuffer);
+    pthread_mutex_unlock(&mixbufferq_lock);
+
+    if (ret)
+        return OMX_ErrorInsufficientResources;
+
+    return OMX_ErrorNone;
+}
+
+OMX_BUFFERHEADERTYPE *PortBase::MixPopBuffer(void)
+{
+    OMX_BUFFERHEADERTYPE *buffer;
+
+    pthread_mutex_lock(&mixbufferq_lock);
+    buffer = (OMX_BUFFERHEADERTYPE *)queue_pop_head(&mixbufferq);
+    pthread_mutex_unlock(&mixbufferq_lock);
+
+    LOGV_IF(buffer != NULL, "%s(): %s:%s:PortIndex %lu:pBuffer %p:\n",
+            __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
+            portdefinition.nPortIndex, buffer);
+
+    return buffer;
+}
+
+OMX_ERRORTYPE PortBase::MixPushBufferHead(OMX_BUFFERHEADERTYPE *pBuffer)
+{
+    int ret;
+
+    LOGV_IF(pBuffer != NULL, "%s(): %s:%s:PortIndex %lu:pBuffer %p:\n",
+            __FUNCTION__, cbase->GetName(), cbase->GetWorkingRole(),
+            portdefinition.nPortIndex, pBuffer);
+
+    pthread_mutex_lock(&mixbufferq_lock);
+    ret = queue_push_head(&mixbufferq,pBuffer);
+    pthread_mutex_unlock(&mixbufferq_lock);
+
+    if (ret)
+        return OMX_ErrorInsufficientResources;
+
+    return OMX_ErrorNone;
+}
+
 OMX_U32 PortBase::BufferQueueLength(void)
 {
     OMX_U32 length;
@@ -578,6 +635,18 @@ OMX_U32 PortBase::BufferQueueLength(void)
     return length;
 }
 
+OMX_U32 PortBase::MixBufferQueueLength(void)
+{
+    OMX_U32 length;
+
+    pthread_mutex_lock(&mixbufferq_lock);
+    length = queue_length(&mixbufferq);
+    pthread_mutex_unlock(&mixbufferq_lock);
+
+    return length;
+}
+
+
 OMX_ERRORTYPE PortBase::ReturnThisBuffer(OMX_BUFFERHEADERTYPE *pBuffer)
 {
     OMX_DIRTYPE direction = portdefinition.eDir;
@@ -762,6 +831,9 @@ OMX_ERRORTYPE PortBase::FlushPort(void)
     while ((buffer = PopBuffer()))
         ReturnThisBuffer(buffer);
 
+    while ((buffer = MixPopBuffer()))
+        ReturnThisBuffer(buffer);
+
     LOGV("%s(): %s:%s:PortIndex %lu: exit\n", __FUNCTION__,
          cbase->GetName(), cbase->GetWorkingRole(),
          portdefinition.nPortIndex);
@@ -909,7 +981,7 @@ OMX_ERRORTYPE PortBase::ReportPortSettingsChanged(void)
 
     ret = callbacks->EventHandler(owner, appdata,
                                   OMX_EventPortSettingsChanged,
-                                  portdefinition.nPortIndex, OMX_IndexParamPortDefinition, NULL);
+                                  portdefinition.nPortIndex,OMX_IndexParamPortDefinition, NULL);
 
     FlushPort();
 
diff --git a/core/inc/khronos/openmax/include/OMX_IndexExt.h b/core/inc/khronos/openmax/include/OMX_IndexExt.h
index 7f2383e..ffbfa95 100644
--- a/core/inc/khronos/openmax/include/OMX_IndexExt.h
+++ b/core/inc/khronos/openmax/include/OMX_IndexExt.h
@@ -73,21 +73,25 @@ typedef enum OMX_INDEXEXTTYPE {
     OMX_IndexConfigIntelSliceNumbers,               /**< reference: OMX_VIDEO_CONFIG_INTEL_SLICE_NUMBERS */

     OMX_IndexConfigIntelAIR,                        /**< reference: OMX_VIDEO_CONFIG_INTEL_AIR */

     OMX_IndexParamIntelAVCVUI,                      /**< reference: OMX_VIDEO_PARAM_INTEL_AVCVUI */

-    OMX_IndexParamIntelAdaptiveSliceControl,        /**< reference: OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL */

-    OMX_IndexBufferIDMode,                          /**< reference: boolean value to specify buffer id mode is in effect*/
+    OMX_IndexParamIntelAdaptiveSliceControl,        /**< reference: OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL */
     OMX_IndexStoreMetaDataInBuffers,                /**< reference: StoreMetaDataInBuffersParams*/
 

     /* Image & Video common configurations */

-    OMX_IndexExtCommonStartUnused = OMX_IndexKhronosExtensions + 0x00700000,

+    OMX_IndexExtCommonStartUnused = OMX_IndexKhronosExtensions + 0x00700000,
 

     /* Other configurations */

-    OMX_IndexExtOtherStartUnused = OMX_IndexKhronosExtensions + 0x00800000,

+    OMX_IndexExtOtherStartUnused = OMX_IndexKhronosExtensions + 0x00800000,
 

     /* Time configurations */

-    OMX_IndexExtTimeStartUnused = OMX_IndexKhronosExtensions + 0x00900000,

-

-    OMX_IndexExtMax = 0x7FFFFFFF

-} OMX_INDEXEXTTYPE;

+    OMX_IndexExtTimeStartUnused = OMX_IndexKhronosExtensions + 0x00900000,
+
+    /* NativeWindow configurations */
+    OMX_IndexForNativeWindow = OMX_IndexKhronosExtensions + 0x00a00000,
+    OMX_IndexExtEnableNativeBuffer,                 /**<reference: EnableNativeBuffer */
+    OMX_IndexExtGetNativeBufferUsage,               /**<reference: GetNativeBufferUsage  */
+    OMX_IndexExtUseNativeBuffer,                    /**<reference: UseNativeBuffer  */
+    OMX_IndexExtMax = 0x7FFFFFFF
+} OMX_INDEXEXTTYPE;
 

 #ifdef __cplusplus

 }

diff --git a/core/inc/khronos/openmax/include/OMX_VideoExt.h b/core/inc/khronos/openmax/include/OMX_VideoExt.h
index 7a4a9c0..4e5d6a7 100644
--- a/core/inc/khronos/openmax/include/OMX_VideoExt.h
+++ b/core/inc/khronos/openmax/include/OMX_VideoExt.h
@@ -145,14 +145,6 @@ typedef struct OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL {
      OMX_U32 nSliceSizeSkipThreshold;     // Slice size skip threshold for adaptive slice control to start a new slice
 } OMX_VIDEO_PARAM_INTEL_ADAPTIVE_SLICE_CONTROL;
 
-//align with <media/stagefright/HardwareAPI.h>
-typedef struct StoreMetaDataInBuffersParams {
-    OMX_U32 nSize;                        // Size of the structure
-    OMX_VERSIONTYPE nVersion;             // OMX specification version
-    OMX_U32 nPortIndex;                   // Port that this struct applies to
-    OMX_BOOL bStoreMetaData;              // Enable/disable meta data input
-} StoreMetaDataInBuffersParams;
-
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */