Port changes from 173978 to Moorefield

BZ: 182227

Porting changes for WV Modular DRM to Moorefield

Change-Id: Ieee90c27e71f6f0dd87582052f28fe5fc19c7d11
Signed-off-by: Ryan Saffores <ryan.d.saffores@intel.com>

2 files changed, 189 insertions, 174 deletions

diff --git a/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.cpp b/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.cpp
index 2d1d2a4..c391e42 100644
--- a/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.cpp
+++ b/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.cpp
@@ -23,6 +23,7 @@
 #include <signal.h>
 #include <pthread.h>
 
+
 extern "C" {
 #include <sepdrm.h>
 #include <fcntl.h>
@@ -31,32 +32,37 @@ extern "C" {
 #include "xf86drmMode.h"
 }
 
+#include "VideoFrameInfo.h"
+
 // Be sure to have an equal string in VideoDecoderHost.cpp (libmix)
 static const char* AVC_MIME_TYPE = "video/avc";
 static const char* AVC_SECURE_MIME_TYPE = "video/avc-secure";
 
-#define IMR_INITIAL_OFFSET      0 //1024
-#define IMR_BUFFER_SIZE         (8 * 1024 * 1024)
-#define KEEP_ALIVE_INTERVAL     5 // seconds
-#define DRM_KEEP_ALIVE_TIMER    1000000
-#define WV_SESSION_ID           0x00000011
-#define NALU_BUFFER_SIZE        8192
-#define FLUSH_WAIT_INTERVAL     (30 * 1000) //30 ms
-
-
-#pragma pack(push, 1)
-struct IMRDataBuffer {
-    uint32_t offset;
+#define DATA_BUFFER_INITIAL_OFFSET      0 //1024
+#define DATA_BUFFER_SIZE                (8 * 1024 * 1024)
+#define KEEP_ALIVE_INTERVAL             5 // seconds
+#define DRM_KEEP_ALIVE_TIMER            1000000
+#define WV_SESSION_ID                   0x00000011
+#define NALU_BUFFER_SIZE                8192
+#define NALU_HEADER_LENGTH              1024 // THis should be changed to 4K
+#define FLUSH_WAIT_INTERVAL             (30 * 1000) //30 ms
+
+#define DRM_SCHEME_NONE                 0
+#define DRM_SCHEME_WV_CLASSIC           1
+#define DRM_SCHEME_WV_MODULAR           2
+
+//#pragma pack(push, 1)
+struct DataBuffer {
     uint32_t size;
     uint8_t  *data;
-    uint8_t  clear;  // 0 when IMR offset is valid, 1 when data is valid
+    uint8_t  clear;
+    uint32_t drmScheme;
 };
-#pragma pack(pop)
+//#pragma pack(pop)
 
 OMXVideoDecoderAVCSecure::OMXVideoDecoderAVCSecure()
     : mKeepAliveTimer(0),
-      mSessionPaused(false),
-      mDrmDevFd(-1) {
+      mSessionPaused(false){
     LOGV("OMXVideoDecoderAVCSecure is constructed.");
     mVideoDecoder = createVideoDecoder(AVC_SECURE_MIME_TYPE);
     if (!mVideoDecoder) {
@@ -66,20 +72,11 @@ OMXVideoDecoderAVCSecure::OMXVideoDecoderAVCSecure()
     mNativeBufferCount = OUTPORT_NATIVE_BUFFER_COUNT;
 
     BuildHandlerList();
-
-    mDrmDevFd = open("/dev/card0", O_RDWR, 0);
-    if (mDrmDevFd < 0) {
-        LOGE("Failed to open drm device.");
-    }
 }
 
 OMXVideoDecoderAVCSecure::~OMXVideoDecoderAVCSecure() {
-    LOGV("OMXVideoDecoderAVCSecure is destructed.");
+    LOGI("OMXVideoDecoderAVCSecure is destructed.");
 
-    if (mDrmDevFd) {
-        close(mDrmDevFd);
-        mDrmDevFd = 0;
-    }
 }
 
 OMX_ERRORTYPE OMXVideoDecoderAVCSecure::InitInputPortFormatSpecific(OMX_PARAM_PORTDEFINITIONTYPE *paramPortDefinitionInput) {
@@ -98,11 +95,11 @@ OMX_ERRORTYPE OMXVideoDecoderAVCSecure::InitInputPortFormatSpecific(OMX_PARAM_PO
     mParamAvc.eProfile = OMX_VIDEO_AVCProfileHigh; //OMX_VIDEO_AVCProfileBaseline;
     mParamAvc.eLevel = OMX_VIDEO_AVCLevel41; //OMX_VIDEO_AVCLevel1;
 
-    this->ports[INPORT_INDEX]->SetMemAllocator(MemAllocIMR, MemFreeIMR, this);
+    this->ports[INPORT_INDEX]->SetMemAllocator(MemAllocDataBuffer, MemFreeDataBuffer, this);
 
     for (int i = 0; i < INPORT_ACTUAL_BUFFER_COUNT; i++) {
-        mIMRSlot[i].offset = IMR_INITIAL_OFFSET + i * INPORT_BUFFER_SIZE;
-        mIMRSlot[i].owner = NULL;
+        mDataBufferSlot[i].offset = DATA_BUFFER_INITIAL_OFFSET + i * INPORT_BUFFER_SIZE;
+        mDataBufferSlot[i].owner = NULL;
     }
 
     return OMX_ErrorNone;
@@ -121,53 +118,13 @@ OMX_ERRORTYPE OMXVideoDecoderAVCSecure::ProcessorDeinit(void) {
     if (sepres != 0) {
         LOGW("Drm_DestroySession returns %#x", sepres);
     }
-    EnableIEDSession(false);
-
     return OMXVideoDecoderBase::ProcessorDeinit();
 }
 
 OMX_ERRORTYPE OMXVideoDecoderAVCSecure::ProcessorStart(void) {
     uint32_t imrOffset = 0;
-    uint32_t imrBufferSize = IMR_BUFFER_SIZE;
-    uint32_t sessionID;
+    uint32_t dataBufferSize = DATA_BUFFER_SIZE;
 
-    EnableIEDSession(true);
-    uint32_t sepres = drm_wv_create_session( &sessionID);
-    if (sepres != 0) {
-        LOGW("Drm_WV_CreateSession failed. Result = %#x", sepres);
-        // Returning error will cause OMX client to crash.
-        //return OMX_ErrorHardware;
-    }
-    if (sessionID != WV_SESSION_ID) {
-        LOGE("Invalid session ID %#x created", sessionID);
-        //return OMX_ErrorHardware;
-    }
-    LOGI("drm_wv_create_session: sessionID = %#x", sessionID);
-
-    //drmCommandNone(mDrmDevFd, DRM_PSB_HDCP_DISPLAY_IED_OFF);
-
-    int ret;
-    struct sigevent sev;
-    memset(&sev, 0, sizeof(sev));
-    sev.sigev_notify = SIGEV_THREAD;
-    sev.sigev_value.sival_ptr = this;
-    sev.sigev_notify_function = KeepAliveTimerCallback;
-
-    ret = timer_create(CLOCK_REALTIME, &sev, &mKeepAliveTimer);
-    if (ret != 0) {
-        LOGE("Failed to create timer.");
-    } else {
-        struct itimerspec its;
-        its.it_value.tv_sec = -1; // never expire
-        its.it_value.tv_nsec = 0;
-        its.it_interval.tv_sec = KEEP_ALIVE_INTERVAL;
-        its.it_interval.tv_nsec = 0;
-
-        ret = timer_settime(mKeepAliveTimer, TIMER_ABSTIME, &its, NULL);
-        if (ret != 0) {
-            LOGE("Failed to set timer.");
-        }
-    }
     mSessionPaused = false;
     return OMXVideoDecoderBase::ProcessorStart();
 }
@@ -191,17 +148,44 @@ OMX_ERRORTYPE OMXVideoDecoderAVCSecure::ProcessorProcess(
         buffer_retain_t *retains,
         OMX_U32 numberBuffers) {
 
+    int ret_value;
+
     OMX_BUFFERHEADERTYPE *pInput = *pBuffers[INPORT_INDEX];
-    IMRDataBuffer *imrBuffer = (IMRDataBuffer *)pInput->pBuffer;
-    if (imrBuffer->size == 0) {
+    DataBuffer *dataBuffer = (DataBuffer *)pInput->pBuffer;
+
+    if((dataBuffer->drmScheme == DRM_SCHEME_WV_CLASSIC) && (!mKeepAliveTimer)){
+        struct sigevent sev;
+        memset(&sev, 0, sizeof(sev));
+        sev.sigev_notify = SIGEV_THREAD;
+        sev.sigev_value.sival_ptr = this;
+        sev.sigev_notify_function = KeepAliveTimerCallback;
+
+        ret_value = timer_create(CLOCK_REALTIME, &sev, &mKeepAliveTimer);
+        if (ret_value != 0) {
+            LOGE("Failed to create timer.");
+        } else {
+            struct itimerspec its;
+            its.it_value.tv_sec = -1; // never expire
+            its.it_value.tv_nsec = 0;
+            its.it_interval.tv_sec = KEEP_ALIVE_INTERVAL;
+            its.it_interval.tv_nsec = 0;
+
+            ret_value = timer_settime(mKeepAliveTimer, TIMER_ABSTIME, &its, NULL);
+            if (ret_value != 0) {
+                LOGE("Failed to set timer.");
+            }
+        }
+    }
+
+    if (dataBuffer->size == 0) {
         // error occurs during decryption.
-        LOGW("size of returned IMR buffer is 0, decryption fails.");
+        LOGW("size of returned data buffer is 0, decryption fails.");
         mVideoDecoder->flush();
         usleep(FLUSH_WAIT_INTERVAL);
         OMX_BUFFERHEADERTYPE *pOutput = *pBuffers[OUTPORT_INDEX];
         pOutput->nFilledLen = 0;
-        // reset IMR buffer size
-        imrBuffer->size = INPORT_BUFFER_SIZE;
+        // reset Data buffer size
+        dataBuffer->size = INPORT_BUFFER_SIZE;
         this->ports[INPORT_INDEX]->FlushPort();
         this->ports[OUTPORT_INDEX]->FlushPort();
         return OMX_ErrorNone;
@@ -226,96 +210,133 @@ OMX_ERRORTYPE OMXVideoDecoderAVCSecure::ProcessorProcess(
 }
 
 OMX_ERRORTYPE OMXVideoDecoderAVCSecure::ProcessorPause(void) {
-#if 0
-    uint32_t sepres = Drm_Playback_Pause(WV_SESSION_ID);
-    if (sepres != 0) {
-        LOGE("Drm_Playback_Pause failed. Result = %#x", sepres);
-    }
-#endif
     return OMXVideoDecoderBase::ProcessorPause();
 }
 
 OMX_ERRORTYPE OMXVideoDecoderAVCSecure::ProcessorResume(void) {
-#if 0
-    uint32_t sepres = Drm_Playback_Resume(WV_SESSION_ID);
-    if (sepres != 0) {
-        LOGE("Drm_Playback_Resume failed. Result = %#x", sepres);
-    }
-#endif
     return OMXVideoDecoderBase::ProcessorResume();
 }
 
 OMX_ERRORTYPE OMXVideoDecoderAVCSecure::PrepareConfigBuffer(VideoConfigBuffer *p) {
     OMX_ERRORTYPE ret;
-    ret = OMXVideoDecoderBase::PrepareConfigBuffer(p);
+	ret = OMXVideoDecoderBase::PrepareConfigBuffer(p);
     CHECK_RETURN_VALUE("OMXVideoDecoderBase::PrepareConfigBuffer");
     p->flag |=  WANT_SURFACE_PROTECTION;
     return ret;
 }
 
-OMX_ERRORTYPE OMXVideoDecoderAVCSecure::PrepareDecodeBuffer(OMX_BUFFERHEADERTYPE *buffer, buffer_retain_t *retain, VideoDecodeBuffer *p) {
+OMX_ERRORTYPE OMXVideoDecoderAVCSecure::PrepareClassicWVDecodeBuffer(OMX_BUFFERHEADERTYPE *buffer, buffer_retain_t *retain, VideoDecodeBuffer *p){
     OMX_ERRORTYPE ret;
-    ret = OMXVideoDecoderBase::PrepareDecodeBuffer(buffer, retain, p);
-    CHECK_RETURN_VALUE("OMXVideoDecoderBase::PrepareDecodeBuffer");
 
-    if (buffer->nFilledLen == 0) {
-        return OMX_ErrorNone;
-    }
+    // OMX_BUFFERFLAG_CODECCONFIG is an optional flag
+    // if flag is set, buffer will only contain codec data.
+
+   if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
+       LOGV("Received AVC codec data.");
+       return ret;
+   }
+   p->flag |= HAS_COMPLETE_FRAME;
+
+   if (buffer->nOffset != 0) {
+       LOGW("buffer offset %lu is not zero!!!", buffer->nOffset);
+   }
+
+   DataBuffer *dataBuffer = (DataBuffer *)buffer->pBuffer;
+   if (dataBuffer->clear) {
+       p->data = dataBuffer->data + buffer->nOffset;
+       p->size = buffer->nFilledLen;
+   } else {
+       dataBuffer->size = NALU_BUFFER_SIZE;
+       struct drm_wv_nalu_headers nalu_headers;
+       nalu_headers.p_enc_ciphertext = dataBuffer->data;
+
+       // TODO: NALU Buffer is supposed to be 4k but using 1k, fix it once chaabi fix is there
+
+       nalu_headers.hdrs_buf_len = NALU_HEADER_LENGTH;
+       nalu_headers.frame_size = buffer->nFilledLen;
+       // Make sure that NALU header frame size is 16 bytes aligned
+       nalu_headers.frame_size = (nalu_headers.frame_size + 0xF) & (~0xF);
+       // Use same video buffer to fill NALU headers returned by chaabi,
+       // Adding 4 because the first 4 bytes after databuffer will be used to store length of NALU headers
+       if((nalu_headers.frame_size + NALU_HEADER_LENGTH) > INPORT_BUFFER_SIZE){
+           LOGE("Not enough buffer for NALU headers");
+           return OMX_ErrorOverflow;
+       }
+
+       nalu_headers.p_hdrs_buf = (uint8_t *)(dataBuffer->data + nalu_headers.frame_size + 4);
+       nalu_headers.parse_size = buffer->nFilledLen;
+
+       uint32_t res = drm_wv_return_naluheaders(WV_SESSION_ID, &nalu_headers);
+       if (res == DRM_FAIL_FW_SESSION) {
+           LOGW("Drm_WV_ReturnNALUHeaders failed. Session is disabled.");
+           mSessionPaused = true;
+           ret =  OMX_ErrorNotReady;
+       } else if (res != 0) {
+           mSessionPaused = false;
+           LOGE("Drm_WV_ReturnNALUHeaders failed. Error = %#x, frame_size: %d, len = %lu", res, nalu_headers.frame_size, buffer->nFilledLen);
+           ret = OMX_ErrorHardware;
+       } else {
+           mSessionPaused = false;
+
+           // If chaabi returns 0 NALU headers fill the frame size to zero.
+           if (!nalu_headers.hdrs_buf_len) {
+               p->size = 0;
+               return ret;
+           }
+           else{
+               // NALU headers are appended to encrypted video bitstream
+               // |...encrypted video bitstream (16 bytes aligned)...| 4 bytes of header size |...NALU headers..|
+               uint32_t *ptr = (uint32_t*)(dataBuffer->data + nalu_headers.frame_size);
+               *ptr = nalu_headers.hdrs_buf_len;
+               p->data = dataBuffer->data;
+               p->size = nalu_headers.frame_size;
+               p->flag |= IS_SECURE_DATA;
+           }
+       }
+   }
+
+   // reset Data size
+   dataBuffer->size = NALU_BUFFER_SIZE;
+   return ret;
+}
+OMX_ERRORTYPE OMXVideoDecoderAVCSecure::PrepareModularWVDecodeBuffer(OMX_BUFFERHEADERTYPE *buffer, buffer_retain_t *retain, VideoDecodeBuffer *p){
+    OMX_ERRORTYPE ret = OMX_ErrorNone;
+
     // OMX_BUFFERFLAG_CODECCONFIG is an optional flag
     // if flag is set, buffer will only contain codec data.
     if (buffer->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
-        LOGV("Received AVC codec data.");
-        return ret;
+        LOGI("Received AVC codec data.");
+    //    return ret;
     }
-    p->flag |= HAS_COMPLETE_FRAME;
+    p->flag |= HAS_COMPLETE_FRAME | IS_SUBSAMPLE_ENCRYPTION;
 
     if (buffer->nOffset != 0) {
         LOGW("buffer offset %lu is not zero!!!", buffer->nOffset);
     }
 
-    IMRDataBuffer *imrBuffer = (IMRDataBuffer *)buffer->pBuffer;
-    if (imrBuffer->clear) {
-        p->data = imrBuffer->data + buffer->nOffset;
-        p->size = buffer->nFilledLen;
-    } else {
-        imrBuffer->size = NALU_BUFFER_SIZE;
-        struct drm_wv_nalu_headers nalu_headers;
-        nalu_headers.p_enc_ciphertext = imrBuffer->data;
-
-        // TODO: NALU Buffer is supposed to be 4k but using 1k, fix it once chaabi fix is there
-
-        nalu_headers.hdrs_buf_len = 1024;
-        nalu_headers.frame_size = buffer->nFilledLen;
-        // Make sure that NALU header frame size is 16 bytes aligned
-        nalu_headers.frame_size = (nalu_headers.frame_size + 0xF) & (~0xF);
-        // Use same video buffer to fill NALU headers returned by chaabi,
-        // Adding 4 because the first 4 bytes after databuffer will be used to store length of NALU headers
-        nalu_headers.p_hdrs_buf = (uint8_t *)(imrBuffer->data + nalu_headers.frame_size + 4);
-        nalu_headers.parse_size = buffer->nFilledLen;
-
-        uint32_t res = drm_wv_return_naluheaders(WV_SESSION_ID, &nalu_headers);
-        if (res == DRM_FAIL_FW_SESSION || !nalu_headers.hdrs_buf_len) {
-            LOGW("Drm_WV_ReturnNALUHeaders failed. Session is disabled.");
-            mSessionPaused = true;
-            ret =  OMX_ErrorNotReady;
-        } else if (res != 0) {
-            mSessionPaused = false;
-            LOGE("Drm_WV_ReturnNALUHeaders failed. Error = %#x, frame_size: %d, len = %lu", res, nalu_headers.frame_size, buffer->nFilledLen);
-            ret = OMX_ErrorHardware;
-        } else {
-            mSessionPaused = false;
-            // NALU headers are appended to encrypted video bitstream
-            // |...encrypted video bitstream (16 bytes aligned)...| 4 bytes of header size |...NALU headers..|
-            uint32_t *ptr = (uint32_t*)(imrBuffer->data + nalu_headers.frame_size);
-            *ptr = nalu_headers.hdrs_buf_len;
-            p->data = imrBuffer->data;
-            p->size = nalu_headers.frame_size;
-            p->flag |= IS_SECURE_DATA;
-        }
+    DataBuffer *dataBuffer = (DataBuffer *)buffer->pBuffer;
+    p->data = dataBuffer->data;
+    p->size = sizeof(frame_info_t);
+    p->flag |= IS_SECURE_DATA;
+    return ret;
+}
+
+
+OMX_ERRORTYPE OMXVideoDecoderAVCSecure::PrepareDecodeBuffer(OMX_BUFFERHEADERTYPE *buffer, buffer_retain_t *retain, VideoDecodeBuffer *p) {
+    OMX_ERRORTYPE ret;
+
+    ret = OMXVideoDecoderBase::PrepareDecodeBuffer(buffer, retain, p);
+    CHECK_RETURN_VALUE("OMXVideoDecoderBase::PrepareDecodeBuffer");
+
+    if (buffer->nFilledLen == 0) {
+        return OMX_ErrorNone;
     }
 
-    // reset IMR size
-    imrBuffer->size = NALU_BUFFER_SIZE;
+    DataBuffer *dataBuffer = (DataBuffer *)buffer->pBuffer;
+    if(dataBuffer->drmScheme == DRM_SCHEME_WV_CLASSIC)
+        return PrepareClassicWVDecodeBuffer(buffer, retain, p);
+    else if(dataBuffer->drmScheme == DRM_SCHEME_WV_MODULAR)
+        return PrepareModularWVDecodeBuffer(buffer, retain, p);
     return ret;
 }
 
@@ -368,30 +389,33 @@ OMX_ERRORTYPE OMXVideoDecoderAVCSecure::SetParamVideoAVCProfileLevel(OMX_PTR pSt
     return OMX_ErrorUnsupportedSetting;
 }
 
-OMX_U8* OMXVideoDecoderAVCSecure::MemAllocIMR(OMX_U32 nSizeBytes, OMX_PTR pUserData) {
+OMX_U8* OMXVideoDecoderAVCSecure::MemAllocDataBuffer(OMX_U32 nSizeBytes, OMX_PTR pUserData) {
     OMXVideoDecoderAVCSecure* p = (OMXVideoDecoderAVCSecure *)pUserData;
     if (p) {
-        return p->MemAllocIMR(nSizeBytes);
+        return p->MemAllocDataBuffer(nSizeBytes);
     }
     LOGE("NULL pUserData.");
     return NULL;
 }
 
-void OMXVideoDecoderAVCSecure::MemFreeIMR(OMX_U8 *pBuffer, OMX_PTR pUserData) {
+void OMXVideoDecoderAVCSecure::MemFreeDataBuffer(OMX_U8 *pBuffer, OMX_PTR pUserData) {
     OMXVideoDecoderAVCSecure* p = (OMXVideoDecoderAVCSecure *)pUserData;
     if (p) {
-        p->MemFreeIMR(pBuffer);
+        p->MemFreeDataBuffer(pBuffer);
         return;
     }
     LOGE("NULL pUserData.");
 }
 
-OMX_U8* OMXVideoDecoderAVCSecure::MemAllocIMR(OMX_U32 nSizeBytes) {
-    // Ignore passed nSizeBytes, use INPORT_BUFFER_SIZE instead
-
+OMX_U8* OMXVideoDecoderAVCSecure::MemAllocDataBuffer(OMX_U32 nSizeBytes) {
+    if (nSizeBytes > INPORT_BUFFER_SIZE) {
+        LOGE("Invalid size (%lu) of memory to allocate.", nSizeBytes);
+        return NULL;
+    }
+    LOGW_IF(nSizeBytes != INPORT_BUFFER_SIZE, "Size of memory to allocate is %lu", nSizeBytes);
     for (int i = 0; i < INPORT_ACTUAL_BUFFER_COUNT; i++) {
-        if (mIMRSlot[i].owner == NULL) {
-            IMRDataBuffer *pBuffer = new IMRDataBuffer;
+        if (mDataBufferSlot[i].owner == NULL) {
+            DataBuffer *pBuffer = new DataBuffer;
             if (pBuffer == NULL) {
                 LOGE("Failed to allocate memory.");
                 return NULL;
@@ -404,29 +428,30 @@ OMX_U8* OMXVideoDecoderAVCSecure::MemAllocIMR(OMX_U32 nSizeBytes) {
                 return NULL;
             }
 
-            pBuffer->offset = mIMRSlot[i].offset;
+            // Is this required for classic or not?
+           // pBuffer->offset = mDataBufferSlot[i].offset;
             pBuffer->size = INPORT_BUFFER_SIZE;
-            mIMRSlot[i].owner = (OMX_U8 *)pBuffer;
+            mDataBufferSlot[i].owner = (OMX_U8 *)pBuffer;
 
-            LOGV("Allocating buffer = %#x, IMR offset = %#x, data = %#x",  (uint32_t)pBuffer, mIMRSlot[i].offset, (uint32_t)pBuffer->data);
+            LOGV("Allocating buffer = %#x, Data offset = %#x, data = %#x",  (uint32_t)pBuffer, mDataBufferSlot[i].offset, (uint32_t)pBuffer->data);
             return (OMX_U8 *) pBuffer;
         }
     }
-    LOGE("IMR slot is not available.");
+    LOGE("Data buffer slot is not available.");
     return NULL;
 }
 
-void OMXVideoDecoderAVCSecure::MemFreeIMR(OMX_U8 *pBuffer) {
-    IMRDataBuffer *p = (IMRDataBuffer*) pBuffer;
+void OMXVideoDecoderAVCSecure::MemFreeDataBuffer(OMX_U8 *pBuffer) {
+    DataBuffer *p = (DataBuffer*) pBuffer;
     if (p == NULL) {
         return;
     }
     for (int i = 0; i < INPORT_ACTUAL_BUFFER_COUNT; i++) {
-        if (pBuffer == mIMRSlot[i].owner) {
-            LOGV("Freeing IMR offset = %d, data = %#x", mIMRSlot[i].offset, (uint32_t)p->data);
+        if (pBuffer == mDataBufferSlot[i].owner) {
+            LOGV("Freeing Data buffer offset = %d, data = %#x", mDataBufferSlot[i].offset, (uint32_t)p->data);
             delete [] p->data;
             delete p;
-            mIMRSlot[i].owner = NULL;
+            mDataBufferSlot[i].owner = NULL;
             return;
         }
     }
@@ -448,15 +473,4 @@ void OMXVideoDecoderAVCSecure::KeepAliveTimerCallback() {
     }
 }
 
-
-bool OMXVideoDecoderAVCSecure::EnableIEDSession(bool enable)
-{
-    if (mDrmDevFd < 0) {
-        return false;
-    }
-    int request = enable ?  DRM_PSB_ENABLE_IED_SESSION : DRM_PSB_DISABLE_IED_SESSION;
-    int ret = drmCommandNone(mDrmDevFd, request);
-    return ret == 0;
-}
-
 DECLARE_OMX_COMPONENT("OMX.Intel.VideoDecoder.AVC.secure", "video_decoder.avc", OMXVideoDecoderAVCSecure);
diff --git a/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.h b/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.h
index 733f959..0d8d028 100644
--- a/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.h
+++ b/videocodec/securevideo/moorefield/OMXVideoDecoderAVCSecure.h
@@ -47,13 +47,15 @@ protected:
    DECLARE_HANDLER(OMXVideoDecoderAVCSecure, ParamVideoAVCProfileLevel);
 
 private:
-    static OMX_U8* MemAllocIMR(OMX_U32 nSizeBytes, OMX_PTR pUserData);
-    static void MemFreeIMR(OMX_U8 *pBuffer, OMX_PTR pUserData);
-    OMX_U8* MemAllocIMR(OMX_U32 nSizeBytes);
-    void  MemFreeIMR(OMX_U8 *pBuffer);
+    static OMX_U8* MemAllocDataBuffer(OMX_U32 nSizeBytes, OMX_PTR pUserData);
+    static void MemFreeDataBuffer(OMX_U8 *pBuffer, OMX_PTR pUserData);
+    OMX_U8* MemAllocDataBuffer(OMX_U32 nSizeBytes);
+    void  MemFreeDataBuffer(OMX_U8 *pBuffer);
     static void KeepAliveTimerCallback(sigval v);
     void KeepAliveTimerCallback();
-    bool EnableIEDSession(bool enable);
+    //bool EnableIEDSession(bool enable);
+    OMX_ERRORTYPE PrepareClassicWVDecodeBuffer(OMX_BUFFERHEADERTYPE *buffer, buffer_retain_t *retain, VideoDecodeBuffer *p);
+    OMX_ERRORTYPE PrepareModularWVDecodeBuffer(OMX_BUFFERHEADERTYPE *buffer, buffer_retain_t *retain, VideoDecodeBuffer *p);
 
 private:
     enum {
@@ -75,12 +77,11 @@ private:
     struct IMRSlot {
         uint32_t offset;
         uint8_t *owner;  // pointer to OMX buffer that owns this slot
-    } mIMRSlot[INPORT_ACTUAL_BUFFER_COUNT];
+    } mDataBufferSlot[INPORT_ACTUAL_BUFFER_COUNT];
 
     timer_t mKeepAliveTimer;
 
     bool mSessionPaused;
-    int mDrmDevFd;
 };
 
 #endif /* OMX_VIDEO_DECODER_AVC_SECURE_H_ */