Enable native buffer mode in omx components,

clean buffer id mode code

BZ: 18370

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

Change-Id: I001542351b44ad0c3bb21df53717b259edbad830
Reviewed-on: http://android.intel.com:8080/27893
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>

13 files changed, 360 insertions, 93 deletions

diff --git a/videocodec/OMXComponentCodecBase.h b/videocodec/OMXComponentCodecBase.h
index 7d9e0e8..81b7daf 100644
--- a/videocodec/OMXComponentCodecBase.h
+++ b/videocodec/OMXComponentCodecBase.h
@@ -30,6 +30,8 @@
 
 #include <componentbase.h>
 #include "OMXComponentDefines.h"
+#include <media/stagefright/HardwareAPI.h>
+
 
 
 
diff --git a/videocodec/OMXVideoDecoderAVC.cpp b/videocodec/OMXVideoDecoderAVC.cpp
index 7bec5af..7f22974 100644
--- a/videocodec/OMXVideoDecoderAVC.cpp
+++ b/videocodec/OMXVideoDecoderAVC.cpp
@@ -20,6 +20,7 @@
 #include <utils/Log.h>
 #include "OMXVideoDecoderAVC.h"
 
+
 // Be sure to have an equal string in VideoDecoderHost.cpp (libmix)
 static const char* AVC_MIME_TYPE = "video/h264";
 #define INVALID_PTS (OMX_S64)-1
@@ -89,11 +90,11 @@ OMX_ERRORTYPE OMXVideoDecoderAVC::ProcessorFlush(OMX_U32 portIndex) {
 }
 
 OMX_ERRORTYPE OMXVideoDecoderAVC::ProcessorProcess(
-        OMX_BUFFERHEADERTYPE **buffers,
+        OMX_BUFFERHEADERTYPE ***pBuffers,
         buffer_retain_t *retains,
         OMX_U32 numberBuffers) {
 
-    return OMXVideoDecoderBase::ProcessorProcess(buffers, retains, numberBuffers);
+    return OMXVideoDecoderBase::ProcessorProcess(pBuffers, retains, numberBuffers);
 }
 
 OMX_ERRORTYPE OMXVideoDecoderAVC::PrepareConfigBuffer(VideoConfigBuffer *p) {
@@ -112,8 +113,12 @@ OMX_ERRORTYPE OMXVideoDecoderAVC::PrepareConfigBuffer(VideoConfigBuffer *p) {
     p->width = mDecodeSettings.nMaxWidth;
     p->height = mDecodeSettings.nMaxHeight;
     p->profile = VAProfileH264ConstrainedBaseline;
-    p->surfaceNumber = mDecodeSettings.nMaxNumberOfReferenceFrame + EXTRA_REFERENCE_FRAME;
-    p->flag = WANT_ERROR_CONCEALMENT | WANT_LOW_DELAY | HAS_SURFACE_NUMBER | HAS_VA_PROFILE;
+    if(!(p->flag & USE_NATIVE_GRAPHIC_BUFFER)) {
+        p->surfaceNumber = mDecodeSettings.nMaxNumberOfReferenceFrame + EXTRA_REFERENCE_FRAME;
+        p->flag = WANT_ERROR_CONCEALMENT | WANT_LOW_DELAY | HAS_SURFACE_NUMBER | HAS_VA_PROFILE;
+    } else {
+        p->flag |= WANT_ERROR_CONCEALMENT | WANT_LOW_DELAY | HAS_SURFACE_NUMBER | HAS_VA_PROFILE;
+    }
 
     return OMX_ErrorNone;
 }
@@ -218,6 +223,7 @@ OMX_ERRORTYPE OMXVideoDecoderAVC::BuildHandlerList(void) {
     OMXVideoDecoderBase::BuildHandlerList();
     AddHandler(OMX_IndexParamVideoAvc, GetParamVideoAvc, SetParamVideoAvc);
     AddHandler((OMX_INDEXTYPE)OMX_IndexParamIntelAVCDecodeSettings, GetParamIntelAVCDecodeSettings, SetParamIntelAVCDecodeSettings);
+    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexExtEnableNativeBuffer),GetNativeBufferMode,SetNativeBufferMode);
     return OMX_ErrorNone;
 }
 
@@ -268,5 +274,31 @@ OMX_ERRORTYPE OMXVideoDecoderAVC::SetParamIntelAVCDecodeSettings(OMX_PTR pStruct
     return OMX_ErrorNone;
 }
 
+OMX_ERRORTYPE OMXVideoDecoderAVC::GetNativeBufferMode(OMX_PTR pStructure) {
+     OMX_ERRORTYPE ret;
+     return OMX_ErrorNone; //would not be here
+}
+
+#define MAX_OUTPUT_BUFFER_COUNT_FOR_AVC  16+1+6
+OMX_ERRORTYPE OMXVideoDecoderAVC::SetNativeBufferMode(OMX_PTR pStructure) {
+     OMX_ERRORTYPE ret;
+
+     //CHECK_TYPE_HEADER(param);
+     CHECK_SET_PARAM_STATE();
+     mNativeBufferMode = true;
+     PortVideo *port = NULL;
+     port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
+
+     OMX_PARAM_PORTDEFINITIONTYPE port_def;
+     memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
+     port_def.nBufferCountMin = 1;
+     port_def.nBufferCountActual = MAX_OUTPUT_BUFFER_COUNT_FOR_AVC;
+     port_def.format.video.cMIMEType = (OMX_STRING)VA_VED_RAW_MIME_TYPE;
+     port_def.format.video.eColorFormat = static_cast<OMX_COLOR_FORMATTYPE>(VA_VED_COLOR_FORMAT);
+     port->SetPortDefinition(&port_def,true);
+
+     return OMX_ErrorNone;
+}
+
 
 DECLARE_OMX_COMPONENT("OMX.Intel.VideoDecoder.AVC", "video_decoder.avc", OMXVideoDecoderAVC);
diff --git a/videocodec/OMXVideoDecoderAVC.h b/videocodec/OMXVideoDecoderAVC.h
index 832449c..90d5f93 100644
--- a/videocodec/OMXVideoDecoderAVC.h
+++ b/videocodec/OMXVideoDecoderAVC.h
@@ -31,7 +31,7 @@ protected:
     virtual OMX_ERRORTYPE ProcessorDeinit(void);
     virtual OMX_ERRORTYPE ProcessorFlush(OMX_U32 portIndex);
     virtual OMX_ERRORTYPE ProcessorProcess(
-            OMX_BUFFERHEADERTYPE **buffers,
+            OMX_BUFFERHEADERTYPE ***pBuffers,
             buffer_retain_t *retains,
             OMX_U32 numberBuffers);
 
@@ -41,6 +41,7 @@ protected:
    virtual OMX_ERRORTYPE BuildHandlerList(void);
    DECLARE_HANDLER(OMXVideoDecoderAVC, ParamVideoAvc);
    DECLARE_HANDLER(OMXVideoDecoderAVC, ParamIntelAVCDecodeSettings);
+   DECLARE_HANDLER(OMXVideoDecoderAVC,NativeBufferMode);
 
 private:
     inline OMX_ERRORTYPE AccumulateBuffer(OMX_BUFFERHEADERTYPE *buffer);
diff --git a/videocodec/OMXVideoDecoderBase.cpp b/videocodec/OMXVideoDecoderBase.cpp
index 0023766..a38d886 100644
--- a/videocodec/OMXVideoDecoderBase.cpp
+++ b/videocodec/OMXVideoDecoderBase.cpp
@@ -14,25 +14,26 @@
 * limitations under the License.
 */
 
-#define LOG_NDEBUG 0
+//#define LOG_NDEBUG 0
 #define LOG_TAG "OMXVideoDecoderBase"
 #include <utils/Log.h>
 #include "OMXVideoDecoderBase.h"
-#include <va/va.h>
 #include <va/va_android.h>
-#include <va/vabuffer.h>
+
 
 static const char* VA_RAW_MIME_TYPE = "video/x-raw-va";
 static const uint32_t VA_COLOR_FORMAT = 0x7FA00E00;
 
 OMXVideoDecoderBase::OMXVideoDecoderBase()
     : mVideoDecoder(NULL),
-      mBufferIDMode(false) {
+      mNativeBufferMode(false),
+      mOMXBufferHeaderTypePtrNum(0),
+      mGraphicBuffercolorformat(0),
+      mGraphicBufferStride(0){
 }
 
 OMXVideoDecoderBase::~OMXVideoDecoderBase() {
     releaseVideoDecoder(mVideoDecoder);
-
     if (this->ports) {
         if (this->ports[INPORT_INDEX]) {
             delete this->ports[INPORT_INDEX];
@@ -184,6 +185,7 @@ OMX_ERRORTYPE OMXVideoDecoderBase::ProcessorInit(void) {
     Decode_Status status = mVideoDecoder->start(&configBuffer);
     //pthread_mutex_unlock(&mSerializationLock);
 
+
     if (status != DECODE_SUCCESS) {
         return TranslateDecodeStatus(status);
     }
@@ -230,16 +232,81 @@ OMX_ERRORTYPE OMXVideoDecoderBase::ProcessorFlush(OMX_U32 portIndex) {
     return OMX_ErrorNone;
 }
 
+ OMX_ERRORTYPE OMXVideoDecoderBase::PreProcessBuffer(OMX_BUFFERHEADERTYPE* buffer){
+
+    if(mNativeBufferMode && buffer->nOutputPortIndex == OUTPORT_INDEX){
+        Decode_Status status;
+        if(mVideoDecoder == NULL){
+            LOGE("PreProcessBuffer: Video decoder is not created");
+            return OMX_ErrorDynamicResourcesUnavailable;
+        }
+        status = mVideoDecoder->SignalRenderDoneFlag(buffer->pBuffer);
+
+        if (status != DECODE_SUCCESS) {
+            return TranslateDecodeStatus(status);
+        }
+    }
+    return OMX_ErrorNone;
+}
+
+
+ OMX_ERRORTYPE OMXVideoDecoderBase::PreProcessBufferQueue_Locked(void) {
+    if(!mNativeBufferMode )
+       return OMX_ErrorNone;
+    Decode_Status status = DECODE_SUCCESS;
+    PortBase *port_out = this->ports[OUTPORT_INDEX];
+
+    OMX_BUFFERHEADERTYPE *buffer = NULL;
+    OMX_BUFFERHEADERTYPE *buffer_head = NULL;
+    bool used = false;
+
+    OMX_U32 len = port_out->BufferQueueLength();
+    //check the buffer from buffer queue. used means cannot be used to decode
+    for( OMX_U32 i=0; i <len; i++){
+       buffer = port_out->PopBuffer();
+       if(buffer == NULL)
+          break;
+       status = mVideoDecoder->GetNativeBufferStatus(buffer->pBuffer,&used);
+       if(status != DECODE_SUCCESS){
+          LOGW("GetNativeBufferStatus returned status =%d",status);
+       }
+       if(used){
+          port_out->MixPushThisBuffer(buffer);
+       }
+       else{
+          port_out->PushThisBuffer(buffer);
+        }
+    }
+    //check the buffer from mix buffer queue,
+    len = port_out->MixBufferQueueLength();
+    for( OMX_U32 i=0; i <len; i++){
+       buffer = port_out->MixPopBuffer();
+       if(buffer == NULL)
+          break;
+       mVideoDecoder->GetNativeBufferStatus(buffer->pBuffer,&used);
+        if(status != DECODE_SUCCESS){
+          LOGW("GetNativeBufferStatus returned status =%d",status);
+       }
+       if(used){
+          port_out->MixPushThisBuffer(buffer);
+       }
+       else{
+          port_out->PushThisBuffer(buffer);
+       }
+   }
+
+    return OMX_ErrorNone;
+}
+
 OMX_ERRORTYPE OMXVideoDecoderBase::ProcessorProcess(
-    OMX_BUFFERHEADERTYPE **buffers,
+    OMX_BUFFERHEADERTYPE ***pBuffers,
     buffer_retain_t *retains,
     OMX_U32 numberBuffers) {
 
     OMX_ERRORTYPE ret;
     Decode_Status status;
-
     // fill render buffer without draining decoder output queue
-    ret = FillRenderBuffer(buffers[OUTPORT_INDEX], 0);
+    ret = FillRenderBuffer(pBuffers[OUTPORT_INDEX], 0);
     if (ret == OMX_ErrorNone) {
         retains[INPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
         // TODO: continue decoding
@@ -250,7 +317,7 @@ OMX_ERRORTYPE OMXVideoDecoderBase::ProcessorProcess(
 
     VideoDecodeBuffer decodeBuffer;
     // PrepareDecodeBuffer will set retain to either BUFFER_RETAIN_GETAGAIN or BUFFER_RETAIN_NOT_RETAIN
-    ret = PrepareDecodeBuffer(buffers[INPORT_INDEX], &retains[INPORT_INDEX], &decodeBuffer);
+    ret = PrepareDecodeBuffer(*pBuffers[INPORT_INDEX], &retains[INPORT_INDEX], &decodeBuffer);
     if (ret == OMX_ErrorNotReady) {
         retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
         return OMX_ErrorNone;
@@ -266,7 +333,7 @@ OMX_ERRORTYPE OMXVideoDecoderBase::ProcessorProcess(
         if (status == DECODE_FORMAT_CHANGE) {
             ret = HandleFormatChange();
             CHECK_RETURN_VALUE("HandleFormatChange");
-            buffers[OUTPORT_INDEX]->nFilledLen = 0;
+            ((*pBuffers[OUTPORT_INDEX]))->nFilledLen = 0;
             // don't use the output buffer if format is changed.
             return OMX_ErrorNone;
         } else if (status == DECODE_NO_CONFIG) {
@@ -285,17 +352,19 @@ OMX_ERRORTYPE OMXVideoDecoderBase::ProcessorProcess(
                 // For decoder errors that could be omitted,  not throw error and continue to decode.
                 TranslateDecodeStatus(status);
 
-                buffers[OUTPORT_INDEX]->nFilledLen = 0;
+                ((*pBuffers[OUTPORT_INDEX]))->nFilledLen = 0;
                 return OMX_ErrorNone;
             }
         }
     }
     // drain the decoder output queue when in EOS state and fill the render buffer
-    ret = FillRenderBuffer(buffers[OUTPORT_INDEX], buffers[INPORT_INDEX]->nFlags);
+    ret = FillRenderBuffer(pBuffers[OUTPORT_INDEX], ((*pBuffers[INPORT_INDEX]))->nFlags);
+
     if (ret == OMX_ErrorNotReady) {
         retains[OUTPORT_INDEX] = BUFFER_RETAIN_GETAGAIN;
         ret = OMX_ErrorNone;
     }
+
     return ret;
 }
 
@@ -308,12 +377,23 @@ OMX_ERRORTYPE OMXVideoDecoderBase::PrepareConfigBuffer(VideoConfigBuffer *p) {
         return OMX_ErrorBadParameter;
     }
 
-    if (!mBufferIDMode) {
-        LOGD("intel omx video decoder working in raw nv12 mode");
-    } else {
-        LOGD("intel omx video decoder working in buffer index mode");
+    if ( mNativeBufferMode) {
+        LOGD("intel omx video decoder working in native buffer mode");
+    }else{
+        LOGD("intel omx video decoder working in raw nv12 mode ");
     }
 
+    if( mNativeBufferMode){
+        p->surfaceNumber = mOMXBufferHeaderTypePtrNum;
+        for( int i=0; i < mOMXBufferHeaderTypePtrNum;i++){
+            OMX_BUFFERHEADERTYPE *buffer_hdr = mOMXBufferHeaderTypePtrArray[i];
+            p->graphicBufferHandler[i] = buffer_hdr->pBuffer;
+            LOGV("PrepareConfigBuffer bufferid=%p,handle =%p",buffer_hdr,buffer_hdr->pBuffer);
+        }
+        p->flag |= USE_NATIVE_GRAPHIC_BUFFER;
+        p->graphicBufferStride = mGraphicBufferStride;
+        p->graphicBufferColorFormat = mGraphicBuffercolorformat;
+    }
     p->width = paramPortDefinitionInput->format.video.nFrameWidth;
     p->height = paramPortDefinitionInput->format.video.nFrameHeight;
     return OMX_ErrorNone;
@@ -354,8 +434,12 @@ OMX_ERRORTYPE OMXVideoDecoderBase::PrepareDecodeBuffer(OMX_BUFFERHEADERTYPE *buf
     return OMX_ErrorNone;
 }
 
-OMX_ERRORTYPE OMXVideoDecoderBase::FillRenderBuffer(OMX_BUFFERHEADERTYPE *buffer, OMX_U32 inportBufferFlags) {
-    if (buffer->pPlatformPrivate) {
+OMX_ERRORTYPE OMXVideoDecoderBase::FillRenderBuffer(OMX_BUFFERHEADERTYPE **pBuffer, OMX_U32 inportBufferFlags) {
+
+    OMX_BUFFERHEADERTYPE *buffer = *pBuffer;
+    OMX_BUFFERHEADERTYPE *buffer_orign = buffer;
+
+    if (!mNativeBufferMode && buffer->pPlatformPrivate) {
         VideoRenderBuffer *p = (VideoRenderBuffer *)buffer->pPlatformPrivate;
         p->renderDone = true;
         buffer->pPlatformPrivate = NULL;
@@ -375,40 +459,58 @@ OMX_ERRORTYPE OMXVideoDecoderBase::FillRenderBuffer(OMX_BUFFERHEADERTYPE *buffer
         return OMX_ErrorNotReady;
     }
 
+    if(mNativeBufferMode) {
+        buffer = *pBuffer = mOMXBufferHeaderTypePtrArray[renderBuffer->acquirePos];
+     }
+
     buffer->nFlags = OMX_BUFFERFLAG_ENDOFFRAME;
     buffer->nTimeStamp = renderBuffer->timeStamp;
 
-    if (!mBufferIDMode) {
-        MapRawNV12(renderBuffer, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
+    if (mNativeBufferMode) {
+
+        PortBase *port_out = this->ports[OUTPORT_INDEX];
+        //check orign buffer
+        if(buffer_orign != buffer){
+
+            bool used = false;
+            mVideoDecoder->GetNativeBufferStatus(buffer_orign->pBuffer,&used);
+            if(used){
+                port_out->MixPushThisBuffer(buffer_orign);
+            }else{
+                port_out->PushThisBuffer(buffer_orign);
+            }
+
+            //need pop  the returing buffer from mix used buffer queue
+            OMX_U32 len = port_out->MixBufferQueueLength();
+            OMX_BUFFERHEADERTYPE *temp = NULL;
+            for(OMX_U32 i =0 ; i < len; i++){
+                temp = port_out->MixPopBuffer();
+                if(temp == NULL)
+                   break;
+                if(temp == buffer){
+                   LOGV("FillRenderBuffer Poped buffer = %p from mix queue",temp);
+                   break;
+                }
+                else{
+                   port_out->MixPushThisBuffer(temp);
+                }
+            }
+        }
+
+       buffer->nFilledLen = sizeof(OMX_U8*);
+
     } else {
-#if 0
-        buffer->nFilledLen = sizeof(VABuffer);
-        VABuffer *p = (VABuffer *)(buffer->pBuffer + buffer->nOffset);
-
-        // TODO: pass cropping data to VABuffer
-        p->surface = renderBuffer->surface;
-        p->display = renderBuffer->display;
-        p->frame_structure = renderBuffer->scanFormat;
-#else
-        buffer->nFilledLen = sizeof(VABufferIDPackage);
-        VABufferIDPackage *p = (VABufferIDPackage *)(buffer->pBuffer + buffer->nOffset);
-
-        vaGetBufferID(renderBuffer->display, renderBuffer->surface, &p->devid, &p->bufid);
-        p->width = this->ports[OUTPORT_INDEX]->GetPortDefinition()->format.video.nFrameWidth;
-        p->height = this->ports[OUTPORT_INDEX]->GetPortDefinition()->format.video.nFrameHeight;
-#endif
+        MapRawNV12(renderBuffer, buffer->pBuffer + buffer->nOffset, buffer->nFilledLen);
+        buffer->pPlatformPrivate = (void *)renderBuffer;
     }
 
-    // TODO:  set "RenderDone" in next "FillRenderBuffer" with the same OMX buffer header.
-    // this indicates surface is "rendered" and can be reused for decoding.
-    //renderBuffer->renderDone = true;
-
-    buffer->pPlatformPrivate = (void *)renderBuffer;
     return OMX_ErrorNone;
 }
 
 OMX_ERRORTYPE OMXVideoDecoderBase::HandleFormatChange(void) {
     LOGW("Video format is changed.");
+    if(mNativeBufferMode)
+        return OMX_ErrorNone;
     //pthread_mutex_lock(&mSerializationLock);
     const VideoFormatInfo *formatInfo = mVideoDecoder->getFormatInfo();
     //pthread_mutex_unlock(&mSerializationLock);
@@ -516,8 +618,9 @@ OMX_ERRORTYPE OMXVideoDecoderBase::TranslateDecodeStatus(Decode_Status status) {
 OMX_ERRORTYPE OMXVideoDecoderBase::BuildHandlerList(void) {
     OMXComponentCodecBase::BuildHandlerList();
     AddHandler(OMX_IndexParamVideoPortFormat, GetParamVideoPortFormat, SetParamVideoPortFormat);
-    //AddHandler(PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX, GetCapabilityFlags, SetCapabilityFlags);
-    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexBufferIDMode), GetBufferIDMode, SetBufferIDMode);
+    //AddHandler(PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX, GetCapabilityFlags, SetCapabilityFlags); 
+    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexExtGetNativeBufferUsage),GetNativeBufferUsage,SetNativeBufferUsage);
+    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexExtUseNativeBuffer),GetNativeBuffer,SetNativeBuffer);
 
     return OMX_ErrorNone;
 }
@@ -551,39 +654,46 @@ OMX_ERRORTYPE OMXVideoDecoderBase::SetParamVideoPortFormat(OMX_PTR pStructure) {
     return OMX_ErrorNone;
 }
 
-
-OMX_ERRORTYPE OMXVideoDecoderBase::GetBufferIDMode(OMX_PTR pStructure) {
+OMX_ERRORTYPE OMXVideoDecoderBase::GetNativeBufferUsage(OMX_PTR pStructure) {
+     OMX_ERRORTYPE ret;
+     GetAndroidNativeBufferUsageParams *param = (GetAndroidNativeBufferUsageParams*)pStructure;
+     CHECK_TYPE_HEADER(param);
+     param->nUsage |= GRALLOC_USAGE_SW_WRITE_OFTEN;
+     param->nUsage |= GRALLOC_USAGE_HW_TEXTURE;
+     return OMX_ErrorNone;
+}
+OMX_ERRORTYPE OMXVideoDecoderBase::SetNativeBufferUsage(OMX_PTR pStructure) {
     OMX_ERRORTYPE ret;
-
-    *(static_cast<bool*>(pStructure)) = mBufferIDMode;
-    return OMX_ErrorNone;
+    CHECK_SET_PARAM_STATE();
+    return OMX_ErrorBadParameter;
 }
 
-OMX_ERRORTYPE OMXVideoDecoderBase::SetBufferIDMode(OMX_PTR pStructure) {
+OMX_ERRORTYPE OMXVideoDecoderBase::GetNativeBuffer(OMX_PTR pStructure) {
+    OMX_ERRORTYPE ret;
+    return OMX_ErrorBadParameter;
+}
+OMX_ERRORTYPE OMXVideoDecoderBase::SetNativeBuffer(OMX_PTR pStructure) {
     OMX_ERRORTYPE ret;
-  
     CHECK_SET_PARAM_STATE();
-
-    OMX_PARAM_PORTDEFINITIONTYPE port_def;
-    PortVideo *port;
-
-    mBufferIDMode = *(static_cast<bool*>(pStructure));
-
-    port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
-    memcpy(&port_def, port->GetPortDefinition(), sizeof(port_def));
-
-    if (!mBufferIDMode) {
-        port_def.nBufferSize = OUTPORT_BUFFER_SIZE;
-        port_def.format.video.cMIMEType = (OMX_STRING)"video/raw";
-        port_def.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar;
-    } else {
-        port_def.nBufferSize = sizeof(VideoRenderBuffer);
-        port_def.format.video.cMIMEType = (OMX_STRING)VA_RAW_MIME_TYPE;
-        port_def.format.video.eColorFormat = static_cast<OMX_COLOR_FORMATTYPE>(VA_COLOR_FORMAT);
+    UseAndroidNativeBufferParams *param = (UseAndroidNativeBufferParams*)pStructure;
+    CHECK_TYPE_HEADER(param);
+    if(param->nPortIndex != OUTPORT_INDEX)
+        return OMX_ErrorBadParameter;
+    OMX_BUFFERHEADERTYPE *buf_hdr = NULL;
+    ret = this->ports[OUTPORT_INDEX]->UseBuffer(&buf_hdr,OUTPORT_INDEX,param->pAppPrivate,sizeof(OMX_U8*),
+                                      const_cast<OMX_U8*>(reinterpret_cast<const OMX_U8*>(param->nativeBuffer->handle)));
+    if(ret != OMX_ErrorNone)
+        return ret;
+    if (mOMXBufferHeaderTypePtrNum >= MAX_GRAPHIC_NUM)
+        return OMX_ErrorOverflow;
+    mOMXBufferHeaderTypePtrArray[mOMXBufferHeaderTypePtrNum++] = buf_hdr;
+    *(param->bufferHeader) = buf_hdr;
+    if(!mGraphicBuffercolorformat) {
+         mGraphicBuffercolorformat = param->nativeBuffer->format;
+    }
+    if(!mGraphicBufferStride) {
+         mGraphicBufferStride = param->nativeBuffer->stride;
     }
-
-    port->SetPortDefinition(&port_def, true);
-
     return OMX_ErrorNone;
 }
 
@@ -596,7 +706,7 @@ OMX_ERRORTYPE OMXVideoDecoderBase::MapRawNV12(const VideoRenderBuffer* renderBuf
     int32_t height = this->ports[OUTPORT_INDEX]->GetPortDefinition()->format.video.nFrameHeight;
 
     size = width * height * 3 / 2;
-    
+
     vaStatus = vaSyncSurface(renderBuffer->display, renderBuffer->surface);
     if (vaStatus != VA_STATUS_SUCCESS) {
         return OMX_ErrorUndefined;
@@ -635,7 +745,7 @@ OMX_ERRORTYPE OMXVideoDecoderBase::MapRawNV12(const VideoRenderBuffer* renderBuf
     if (vaStatus != VA_STATUS_SUCCESS) {
         return OMX_ErrorUndefined;
     }
-    
+
     if (size == (int32_t)vaImage.data_size) {
         memcpy(rawData, pBuf, size);
     } else {
diff --git a/videocodec/OMXVideoDecoderBase.h b/videocodec/OMXVideoDecoderBase.h
index 7c5db5e..2262220 100644
--- a/videocodec/OMXVideoDecoderBase.h
+++ b/videocodec/OMXVideoDecoderBase.h
@@ -23,6 +23,10 @@
 #include "VideoDecoderInterface.h"
 #include "VideoDecoderHost.h"
 
+static const char* VA_VED_RAW_MIME_TYPE = "video/x-raw-vaved";
+static const uint32_t VA_VED_COLOR_FORMAT = 0x20;
+
+
 class OMXVideoDecoderBase : public OMXComponentCodecBase {
 public:
     OMXVideoDecoderBase();
@@ -42,13 +46,16 @@ protected:
     //virtual OMX_ERRORTYPE ProcessorResume(void);
     virtual OMX_ERRORTYPE ProcessorFlush(OMX_U32 portIndex);
     virtual OMX_ERRORTYPE ProcessorProcess(
-            OMX_BUFFERHEADERTYPE **buffers,
+            OMX_BUFFERHEADERTYPE ***pBuffers,
             buffer_retain_t *retains,
             OMX_U32 numberBuffers);
 
+    virtual OMX_ERRORTYPE PreProcessBuffer(OMX_BUFFERHEADERTYPE* buffer);
+    virtual OMX_ERRORTYPE PreProcessBufferQueue_Locked();
+
     virtual OMX_ERRORTYPE PrepareConfigBuffer(VideoConfigBuffer *p);
     virtual OMX_ERRORTYPE PrepareDecodeBuffer(OMX_BUFFERHEADERTYPE *buffer, buffer_retain_t *retain, VideoDecodeBuffer *p);
-    virtual OMX_ERRORTYPE FillRenderBuffer(OMX_BUFFERHEADERTYPE *buffer, OMX_U32 inportBufferFlags);
+    virtual OMX_ERRORTYPE FillRenderBuffer(OMX_BUFFERHEADERTYPE **pBuffer, OMX_U32 inportBufferFlags);
     virtual OMX_ERRORTYPE HandleFormatChange(void);
     virtual OMX_ERRORTYPE TranslateDecodeStatus(Decode_Status status);
     virtual OMX_ERRORTYPE MapRawNV12(const VideoRenderBuffer* renderBuffer, OMX_U8 *rawData, OMX_U32& size);
@@ -56,7 +63,8 @@ protected:
     virtual OMX_ERRORTYPE BuildHandlerList(void);
     DECLARE_HANDLER(OMXVideoDecoderBase, ParamVideoPortFormat);
     DECLARE_HANDLER(OMXVideoDecoderBase, CapabilityFlags);
-    DECLARE_HANDLER(OMXVideoDecoderBase, BufferIDMode);
+    DECLARE_HANDLER(OMXVideoDecoderBase, NativeBufferUsage);
+    DECLARE_HANDLER(OMXVideoDecoderBase, NativeBuffer);
 
 private:
     enum {
@@ -70,10 +78,14 @@ private:
         OUTPORT_ACTUAL_BUFFER_COUNT = 4,
         OUTPORT_BUFFER_SIZE = 1382400,
     };
+    uint32_t mOMXBufferHeaderTypePtrNum;
+    OMX_BUFFERHEADERTYPE *mOMXBufferHeaderTypePtrArray[MAX_GRAPHIC_NUM];
+    uint32_t mGraphicBufferStride;
+    uint32_t mGraphicBuffercolorformat;
 
 protected:
     IVideoDecoder *mVideoDecoder;
-    bool mBufferIDMode;
+    bool mNativeBufferMode;
 };
 
 #endif /* OMX_VIDEO_DECODER_BASE_H_ */
diff --git a/videocodec/OMXVideoDecoderH263.cpp b/videocodec/OMXVideoDecoderH263.cpp
index ce5434c..5cf1d45 100644
--- a/videocodec/OMXVideoDecoderH263.cpp
+++ b/videocodec/OMXVideoDecoderH263.cpp
@@ -64,11 +64,11 @@ OMX_ERRORTYPE OMXVideoDecoderH263::ProcessorDeinit(void) {
 }
 
 OMX_ERRORTYPE OMXVideoDecoderH263::ProcessorProcess(
-        OMX_BUFFERHEADERTYPE **buffers,
+        OMX_BUFFERHEADERTYPE ***pBuffers,
         buffer_retain_t *retains,
         OMX_U32 numberBuffers) {
 
-    return OMXVideoDecoderBase::ProcessorProcess(buffers, retains, numberBuffers);
+    return OMXVideoDecoderBase::ProcessorProcess(pBuffers, retains, numberBuffers);
 }
 
 OMX_ERRORTYPE OMXVideoDecoderH263::PrepareConfigBuffer(VideoConfigBuffer *p) {
@@ -82,6 +82,7 @@ OMX_ERRORTYPE OMXVideoDecoderH263::PrepareDecodeBuffer(OMX_BUFFERHEADERTYPE *buf
 OMX_ERRORTYPE OMXVideoDecoderH263::BuildHandlerList(void) {
     OMXVideoDecoderBase::BuildHandlerList();
     AddHandler(OMX_IndexParamVideoH263, GetParamVideoH263, SetParamVideoH263);
+    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexExtEnableNativeBuffer),GetNativeBufferMode,SetNativeBufferMode);
     return OMX_ErrorNone;
 }
 
@@ -108,6 +109,31 @@ OMX_ERRORTYPE OMXVideoDecoderH263::SetParamVideoH263(OMX_PTR pStructure) {
     return OMX_ErrorNone;
 }
 
+OMX_ERRORTYPE OMXVideoDecoderH263::GetNativeBufferMode(OMX_PTR pStructure) {
+     OMX_ERRORTYPE ret;
+     return OMX_ErrorNone; //would not be here
+}
+
+#define MAX_OUTPUT_BUFFER_COUNT_FOR_H263 10
+
+OMX_ERRORTYPE OMXVideoDecoderH263::SetNativeBufferMode(OMX_PTR pStructure) {
+    OMX_ERRORTYPE ret;
+    CHECK_SET_PARAM_STATE();
+    //EnableAndroidNativeBuffersParams *param = (EnableAndroidNativeBuffersParams*)pStructure;
+    //CHECK_TYPE_HEADER(param);
+    mNativeBufferMode = true;
+    PortVideo *port = NULL;
+    port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
+    OMX_PARAM_PORTDEFINITIONTYPE port_def;
+    memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
+    port_def.nBufferCountMin = 1;
+    port_def.nBufferCountActual = MAX_OUTPUT_BUFFER_COUNT_FOR_H263;
+    port_def.format.video.cMIMEType = (OMX_STRING)VA_VED_RAW_MIME_TYPE;
+    port_def.format.video.eColorFormat =static_cast<OMX_COLOR_FORMATTYPE>(VA_VED_COLOR_FORMAT) ;//
+    port->SetPortDefinition(&port_def,true);
+    return OMX_ErrorNone;
+}
+
 
 DECLARE_OMX_COMPONENT("OMX.Intel.VideoDecoder.H263", "video_decoder.h263", OMXVideoDecoderH263);
 
diff --git a/videocodec/OMXVideoDecoderH263.h b/videocodec/OMXVideoDecoderH263.h
index cfedb78..2cf80af 100644
--- a/videocodec/OMXVideoDecoderH263.h
+++ b/videocodec/OMXVideoDecoderH263.h
@@ -31,7 +31,7 @@ protected:
     virtual OMX_ERRORTYPE ProcessorInit(void);
     virtual OMX_ERRORTYPE ProcessorDeinit(void);
     virtual OMX_ERRORTYPE ProcessorProcess(
-            OMX_BUFFERHEADERTYPE **buffers,
+            OMX_BUFFERHEADERTYPE ***pBuffers,
             buffer_retain_t *retains,
             OMX_U32 numberBuffers);
 
@@ -40,6 +40,7 @@ protected:
 
    virtual OMX_ERRORTYPE BuildHandlerList(void);
    DECLARE_HANDLER(OMXVideoDecoderH263, ParamVideoH263);
+   DECLARE_HANDLER(OMXVideoDecoderH263,NativeBufferMode);
 
 private:
     enum {
diff --git a/videocodec/OMXVideoDecoderMPEG4.cpp b/videocodec/OMXVideoDecoderMPEG4.cpp
index 850899a..be19d13 100644
--- a/videocodec/OMXVideoDecoderMPEG4.cpp
+++ b/videocodec/OMXVideoDecoderMPEG4.cpp
@@ -64,11 +64,11 @@ OMX_ERRORTYPE OMXVideoDecoderMPEG4::ProcessorDeinit(void) {
 }
 
 OMX_ERRORTYPE OMXVideoDecoderMPEG4::ProcessorProcess(
-        OMX_BUFFERHEADERTYPE **buffers,
+        OMX_BUFFERHEADERTYPE ***pBuffers,
         buffer_retain_t *retains,
         OMX_U32 numberBuffers) {
 
-    return OMXVideoDecoderBase::ProcessorProcess(buffers, retains, numberBuffers);
+    return OMXVideoDecoderBase::ProcessorProcess(pBuffers, retains, numberBuffers);
 }
 
 OMX_ERRORTYPE OMXVideoDecoderMPEG4::PrepareConfigBuffer(VideoConfigBuffer *p) {
@@ -82,6 +82,7 @@ OMX_ERRORTYPE OMXVideoDecoderMPEG4::PrepareDecodeBuffer(OMX_BUFFERHEADERTYPE *bu
 OMX_ERRORTYPE OMXVideoDecoderMPEG4::BuildHandlerList(void) {
     OMXVideoDecoderBase::BuildHandlerList();
     AddHandler(OMX_IndexParamVideoMpeg4, GetParamVideoMpeg4, SetParamVideoMpeg4);
+    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexExtEnableNativeBuffer),GetNativeBufferMode,SetNativeBufferMode);
     return OMX_ErrorNone;
 }
 
@@ -107,6 +108,30 @@ OMX_ERRORTYPE OMXVideoDecoderMPEG4::SetParamVideoMpeg4(OMX_PTR pStructure) {
     memcpy(&mParamMpeg4, p, sizeof(mParamMpeg4));
     return OMX_ErrorNone;
 }
+OMX_ERRORTYPE OMXVideoDecoderMPEG4::GetNativeBufferMode(OMX_PTR pStructure) {
+     OMX_ERRORTYPE ret;
+     return OMX_ErrorNone; //would not be here
+}
+
+
+#define MAX_OUTPUT_BUFFER_COUNT_FOR_MPEG4 10
+OMX_ERRORTYPE OMXVideoDecoderMPEG4::SetNativeBufferMode(OMX_PTR pStructure) {
+    OMX_ERRORTYPE ret;
+    //EnableAndroidNativeBuffersParams *param = (EnableAndroidNativeBuffersParams*)pStructure;
+    //CHECK_TYPE_HEADER(param);
+    CHECK_SET_PARAM_STATE();
+    mNativeBufferMode = true;
+    PortVideo *port = NULL;
+    port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
+    OMX_PARAM_PORTDEFINITIONTYPE port_def;
+    memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
+    port_def.nBufferCountMin = 1;
+    port_def.nBufferCountActual = MAX_OUTPUT_BUFFER_COUNT_FOR_MPEG4;
+    port_def.format.video.cMIMEType = (OMX_STRING)VA_VED_RAW_MIME_TYPE;
+    port_def.format.video.eColorFormat =static_cast<OMX_COLOR_FORMATTYPE>(VA_VED_COLOR_FORMAT);
+    port->SetPortDefinition(&port_def,true);
+    return OMX_ErrorNone;
+}
 
 
 DECLARE_OMX_COMPONENT("OMX.Intel.VideoDecoder.MPEG4", "video_decoder.mpeg4", OMXVideoDecoderMPEG4);
diff --git a/videocodec/OMXVideoDecoderMPEG4.h b/videocodec/OMXVideoDecoderMPEG4.h
index 43fab7b..c3e5773 100644
--- a/videocodec/OMXVideoDecoderMPEG4.h
+++ b/videocodec/OMXVideoDecoderMPEG4.h
@@ -32,7 +32,7 @@ protected:
     virtual OMX_ERRORTYPE ProcessorInit(void);
     virtual OMX_ERRORTYPE ProcessorDeinit(void);
     virtual OMX_ERRORTYPE ProcessorProcess(
-            OMX_BUFFERHEADERTYPE **buffers,
+            OMX_BUFFERHEADERTYPE ***pBuffers,
             buffer_retain_t *retains,
             OMX_U32 numberBuffers);
 
@@ -41,6 +41,7 @@ protected:
 
    virtual OMX_ERRORTYPE BuildHandlerList(void);
    DECLARE_HANDLER(OMXVideoDecoderMPEG4, ParamVideoMpeg4);
+   DECLARE_HANDLER(OMXVideoDecoderMPEG4,NativeBufferMode);
 
 private:
     enum {
diff --git a/videocodec/OMXVideoDecoderPAVC.cpp b/videocodec/OMXVideoDecoderPAVC.cpp
index 30ec9ca..d9f01b2 100644
--- a/videocodec/OMXVideoDecoderPAVC.cpp
+++ b/videocodec/OMXVideoDecoderPAVC.cpp
@@ -74,11 +74,11 @@ OMX_ERRORTYPE OMXVideoDecoderPAVC::ProcessorFlush(OMX_U32 portIndex) {
 }
 
 OMX_ERRORTYPE OMXVideoDecoderPAVC::ProcessorProcess(
-        OMX_BUFFERHEADERTYPE **buffers,
+        OMX_BUFFERHEADERTYPE ***pBuffers,
         buffer_retain_t *retains,
         OMX_U32 numberBuffers) {
 
-    return OMXVideoDecoderBase::ProcessorProcess(buffers, retains, numberBuffers);
+    return OMXVideoDecoderBase::ProcessorProcess(pBuffers, retains, numberBuffers);
 }
 
 OMX_ERRORTYPE OMXVideoDecoderPAVC::PrepareConfigBuffer(VideoConfigBuffer *p) {
@@ -115,6 +115,7 @@ OMX_ERRORTYPE OMXVideoDecoderPAVC::BuildHandlerList(void) {
     AddHandler(OMX_IndexParamVideoAvc, GetParamVideoAvc, SetParamVideoAvc);
     AddHandler(OMX_IndexParamVideoProfileLevelQuerySupported, GetVideoProfileLevelQuerySupported, SetVideoProfileLevelQuerySupported);
     AddHandler(OMX_IndexParamVideoProfileLevelCurrent, GetVideoProfileLevelCurrent, SetVideoProfileLevelCurrent);
+    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexExtEnableNativeBuffer),GetNativeBufferMode,SetNativeBufferMode);
 
     return OMX_ErrorNone;
 }
@@ -201,5 +202,31 @@ OMX_ERRORTYPE OMXVideoDecoderPAVC::SetVideoProfileLevelCurrent(OMX_PTR pStructur
 }
 
 
+OMX_ERRORTYPE OMXVideoDecoderPAVC::GetNativeBufferMode(OMX_PTR pStructure) {
+     OMX_ERRORTYPE ret;
+     return OMX_ErrorNone; //would not be here
+}
+
+#define MAX_OUTPUT_BUFFER_COUNT_FOR_PAVC 10
+OMX_ERRORTYPE OMXVideoDecoderPAVC::SetNativeBufferMode(OMX_PTR pStructure) {
+   // OMX_ERRORTYPE ret;
+    //EnableAndroidNativeBuffersParams *param = (EnableAndroidNativeBuffersParams*)pStructure;
+    //CHECK_TYPE_HEADER(param);
+    CHECK_SET_PARAM_STATE();
+    mNativeBufferMode = true;
+    PortVideo *port = NULL;
+    port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
+    OMX_PARAM_PORTDEFINITIONTYPE port_def;
+    memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
+    port_def.nBufferCountMin = 1;
+    port_def.nBufferCountActual = MAX_OUTPUT_BUFFER_COUNT_FOR_PAVC;
+    port_def.format.video.cMIMEType = (OMX_STRING)"video/raw_ve";
+    port_def.format.video.eColorFormat =static_cast<OMX_COLOR_FORMATTYPE>(0x7FA00EFF) ;//
+    port->SetPortDefinition(&port_def,true);
+    return OMX_ErrorNone;
+}
+
+
+
 DECLARE_OMX_COMPONENT("OMX.Intel.VideoDecoder.PAVC", "video_decoder.pavc", OMXVideoDecoderPAVC);
 
diff --git a/videocodec/OMXVideoDecoderPAVC.h b/videocodec/OMXVideoDecoderPAVC.h
index 5428aae..128f47c 100644
--- a/videocodec/OMXVideoDecoderPAVC.h
+++ b/videocodec/OMXVideoDecoderPAVC.h
@@ -31,7 +31,7 @@ protected:
     virtual OMX_ERRORTYPE ProcessorDeinit(void);
     virtual OMX_ERRORTYPE ProcessorFlush(OMX_U32 portIndex);
     virtual OMX_ERRORTYPE ProcessorProcess(
-            OMX_BUFFERHEADERTYPE **buffers,
+            OMX_BUFFERHEADERTYPE ***pBuffers,
             buffer_retain_t *retains,
             OMX_U32 numberBuffers);
 
@@ -42,6 +42,7 @@ protected:
    DECLARE_HANDLER(OMXVideoDecoderPAVC, ParamVideoAvc);
    DECLARE_HANDLER(OMXVideoDecoderPAVC, VideoProfileLevelQuerySupported);
    DECLARE_HANDLER(OMXVideoDecoderPAVC, VideoProfileLevelCurrent);
+   DECLARE_HANDLER(OMXVideoDecoderPAVC, NativeBufferMode);
 
 
 private:
diff --git a/videocodec/OMXVideoDecoderWMV.cpp b/videocodec/OMXVideoDecoderWMV.cpp
index e97c693..659616a 100644
--- a/videocodec/OMXVideoDecoderWMV.cpp
+++ b/videocodec/OMXVideoDecoderWMV.cpp
@@ -62,11 +62,11 @@ OMX_ERRORTYPE OMXVideoDecoderWMV::ProcessorDeinit(void) {
 }
 
 OMX_ERRORTYPE OMXVideoDecoderWMV::ProcessorProcess(
-        OMX_BUFFERHEADERTYPE **buffers,
+        OMX_BUFFERHEADERTYPE ***pBuffers,
         buffer_retain_t *retains,
         OMX_U32 numberBuffers) {
 
-    return OMXVideoDecoderBase::ProcessorProcess(buffers, retains, numberBuffers);
+    return OMXVideoDecoderBase::ProcessorProcess(pBuffers, retains, numberBuffers);
 }
 
 OMX_ERRORTYPE OMXVideoDecoderWMV::PrepareConfigBuffer(VideoConfigBuffer *p) {
@@ -80,6 +80,7 @@ OMX_ERRORTYPE OMXVideoDecoderWMV::PrepareDecodeBuffer(OMX_BUFFERHEADERTYPE *buff
 OMX_ERRORTYPE OMXVideoDecoderWMV::BuildHandlerList(void) {
     OMXVideoDecoderBase::BuildHandlerList();
     AddHandler(OMX_IndexParamVideoWmv, GetParamVideoWmv, SetParamVideoWmv);
+    AddHandler(static_cast<OMX_INDEXTYPE>(OMX_IndexExtEnableNativeBuffer),GetNativeBufferMode,SetNativeBufferMode);
     return OMX_ErrorNone;
 }
 
@@ -106,6 +107,33 @@ OMX_ERRORTYPE OMXVideoDecoderWMV::SetParamVideoWmv(OMX_PTR pStructure) {
 }
 
 
+
+OMX_ERRORTYPE OMXVideoDecoderWMV::GetNativeBufferMode(OMX_PTR pStructure) {
+    OMX_ERRORTYPE ret;
+    return OMX_ErrorNone; //would not be here
+}
+
+#define MAX_OUTPUT_BUFFER_COUNT_FOR_WMV 10
+OMX_ERRORTYPE OMXVideoDecoderWMV::SetNativeBufferMode(OMX_PTR pStructure) {
+    //OMX_ERRORTYPE ret;
+    //EnableAndroidNativeBuffersParams *param = (EnableAndroidNativeBuffersParams*)pStructure;
+    //CHECK_TYPE_HEADER(param);
+    CHECK_SET_PARAM_STATE();
+    mNativeBufferMode = true;
+    PortVideo *port = NULL;
+    port = static_cast<PortVideo *>(this->ports[OUTPORT_INDEX]);
+    OMX_PARAM_PORTDEFINITIONTYPE port_def;
+    memcpy(&port_def,port->GetPortDefinition(),sizeof(port_def));
+    port_def.nBufferCountMin = 1;
+    port_def.nBufferCountActual = MAX_OUTPUT_BUFFER_COUNT_FOR_WMV;
+    port_def.format.video.cMIMEType = (OMX_STRING)"video/raw_ve";
+    port_def.format.video.eColorFormat =static_cast<OMX_COLOR_FORMATTYPE>(0x7FA00EFF) ;//
+    port->SetPortDefinition(&port_def,true);
+    return OMX_ErrorNone;
+}
+
+
+
 DECLARE_OMX_COMPONENT("OMX.Intel.VideoDecoder.WMV", "video_decoder.wmv", OMXVideoDecoderWMV);
 
 
diff --git a/videocodec/OMXVideoDecoderWMV.h b/videocodec/OMXVideoDecoderWMV.h
index 963d9ab..b9702cd 100644
--- a/videocodec/OMXVideoDecoderWMV.h
+++ b/videocodec/OMXVideoDecoderWMV.h
@@ -32,7 +32,7 @@ protected:
     virtual OMX_ERRORTYPE ProcessorInit(void);
     virtual OMX_ERRORTYPE ProcessorDeinit(void);
     virtual OMX_ERRORTYPE ProcessorProcess(
-            OMX_BUFFERHEADERTYPE **buffers,
+            OMX_BUFFERHEADERTYPE ***pBuffers,
             buffer_retain_t *retains,
             OMX_U32 numberBuffers);
 
@@ -41,6 +41,7 @@ protected:
 
    virtual OMX_ERRORTYPE BuildHandlerList(void);
    DECLARE_HANDLER(OMXVideoDecoderWMV, ParamVideoWmv);
+   DECLARE_HANDLER(OMXVideoDecoderWMV, NativeBufferMode);
 
 private:
     enum {