Merge "mm-video: Fix coverity errors"

5 files changed, 165 insertions, 161 deletions

diff --git a/mm-video/vidc/vdec/inc/omx_vdec.h b/mm-video/vidc/vdec/inc/omx_vdec.h
index 7f7b5d20..e1fd663c 100644
--- a/mm-video/vidc/vdec/inc/omx_vdec.h
+++ b/mm-video/vidc/vdec/inc/omx_vdec.h
@@ -161,6 +161,13 @@ extern "C" {
 #define BITMASK_ABSENT(mArray,mIndex) (((mArray)[BITMASK_OFFSET(mIndex)] \
         & BITMASK_FLAG(mIndex)) == 0x0)
 
+//BitMask Management logic for U32
+#define BITMASK_CLEAR_U32(mArray,mIndex) ((mArray) & (~(BITMASK_FLAG(mIndex))))
+#define BITMASK_SET_U32(mArray,mIndex)  ((mArray) | BITMASK_FLAG(mIndex))
+#define BITMASK_PRESENT_U32(mArray,mIndex) ((mArray) & BITMASK_FLAG(mIndex))
+#define BITMASK_ABSENT_U32(mArray,mIndex) (((mArray) & BITMASK_FLAG(mIndex)) == 0x0)
+
+
 #define OMX_CORE_CONTROL_CMDQ_SIZE   100
 #define OMX_CORE_QCIF_HEIGHT         144
 #define OMX_CORE_QCIF_WIDTH          176
diff --git a/mm-video/vidc/vdec/src/omx_vdec.cpp b/mm-video/vidc/vdec/src/omx_vdec.cpp
index 8885ae88..2c038762 100644
--- a/mm-video/vidc/vdec/src/omx_vdec.cpp
+++ b/mm-video/vidc/vdec/src/omx_vdec.cpp
@@ -764,10 +764,10 @@ void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
 
               case OMX_CommandPortDisable:
                 DEBUG_PRINT_HIGH("\n OMX_CommandPortDisable complete for port [%d]", p2);
-                if (BITMASK_PRESENT(&pThis->m_flags,
+                if (BITMASK_PRESENT_U32(pThis->m_flags,
                     OMX_COMPONENT_OUTPUT_FLUSH_IN_DISABLE_PENDING))
                 {
-                  BITMASK_SET(&pThis->m_flags, OMX_COMPONENT_DISABLE_OUTPUT_DEFERRED);
+                  pThis->m_flags = BITMASK_SET_U32(pThis->m_flags, OMX_COMPONENT_DISABLE_OUTPUT_DEFERRED);
                   break;
                 }
                 if (p2 == OMX_CORE_OUTPUT_PORT_INDEX && pThis->in_reconfig)
@@ -913,16 +913,16 @@ void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
               else
               {
                 /*Check if we need generate event for Flush done*/
-                if(BITMASK_PRESENT(&pThis->m_flags,
+                if(BITMASK_PRESENT_U32(pThis->m_flags,
                                    OMX_COMPONENT_INPUT_FLUSH_PENDING))
                 {
-                  BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_INPUT_FLUSH_PENDING);
+                  pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_INPUT_FLUSH_PENDING);
                   DEBUG_PRINT_LOW("\n Input Flush completed - Notify Client");
                   pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                            OMX_EventCmdComplete,OMX_CommandFlush,
                                            OMX_CORE_INPUT_PORT_INDEX,NULL );
                 }
-                if (BITMASK_PRESENT(&pThis->m_flags,
+                if (BITMASK_PRESENT_U32(pThis->m_flags,
                                          OMX_COMPONENT_IDLE_PENDING))
                 {
                   if (!pThis->output_flush_progress)
@@ -964,34 +964,34 @@ void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
               else
               {
                 /*Check if we need generate event for Flush done*/
-                if(BITMASK_PRESENT(&pThis->m_flags,
+                if(BITMASK_PRESENT_U32(pThis->m_flags,
                                    OMX_COMPONENT_OUTPUT_FLUSH_PENDING))
                 {
                   DEBUG_PRINT_LOW("\n Notify Output Flush done");
-                  BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
+                  pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
                   pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                            OMX_EventCmdComplete,OMX_CommandFlush,
                                            OMX_CORE_OUTPUT_PORT_INDEX,NULL );
                 }
-                if(BITMASK_PRESENT(&pThis->m_flags,
+                if(BITMASK_PRESENT_U32(pThis->m_flags,
                        OMX_COMPONENT_OUTPUT_FLUSH_IN_DISABLE_PENDING))
                 {
                   DEBUG_PRINT_LOW("\n Internal flush complete");
-                  BITMASK_CLEAR (&pThis->m_flags,
+                  pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,
                                  OMX_COMPONENT_OUTPUT_FLUSH_IN_DISABLE_PENDING);
-                  if (BITMASK_PRESENT(&pThis->m_flags,
+                  if (BITMASK_PRESENT_U32(pThis->m_flags,
                           OMX_COMPONENT_DISABLE_OUTPUT_DEFERRED))
                   {
                     pThis->post_event(OMX_CommandPortDisable,
                                OMX_CORE_OUTPUT_PORT_INDEX,
                                OMX_COMPONENT_GENERATE_EVENT);
-                    BITMASK_CLEAR (&pThis->m_flags,
+                    pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,
                                    OMX_COMPONENT_DISABLE_OUTPUT_DEFERRED);
 
                   }
                 }
 
-                if (BITMASK_PRESENT(&pThis->m_flags ,OMX_COMPONENT_IDLE_PENDING))
+                if (BITMASK_PRESENT_U32(pThis->m_flags ,OMX_COMPONENT_IDLE_PENDING))
                 {
                   if (!pThis->input_flush_progress)
                   {
@@ -1026,17 +1026,17 @@ void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
             else
             {
               DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_START_DONE Success");
-              if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
+              if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
               {
                 DEBUG_PRINT_LOW("\n Move to executing");
                 // Send the callback now
-                BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
+                pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING);
                 pThis->m_state = OMX_StateExecuting;
                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                        OMX_EventCmdComplete,OMX_CommandStateSet,
                                        OMX_StateExecuting, NULL);
               }
-              else if (BITMASK_PRESENT(&pThis->m_flags,
+              else if (BITMASK_PRESENT_U32(pThis->m_flags,
                                        OMX_COMPONENT_PAUSE_PENDING))
               {
                 if (ioctl (pThis->drv_ctx.video_driver_fd,
@@ -1066,11 +1066,11 @@ void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
             else
             {
               pThis->complete_pending_buffer_done_cbs();
-              if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING))
+              if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING))
               {
                 DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_PAUSE_DONE nofity");
                 //Send the callback now
-                BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_PAUSE_PENDING);
+                pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING);
                 pThis->m_state = OMX_StatePause;
                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                        OMX_EventCmdComplete,OMX_CommandStateSet,
@@ -1096,11 +1096,11 @@ void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
             }
             else
             {
-              if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
+              if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
               {
                 DEBUG_PRINT_LOW("\n Moving the decoder to execute state");
                 // Send the callback now
-                BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
+                pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING);
                 pThis->m_state = OMX_StateExecuting;
                 pThis->m_cb.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                        OMX_EventCmdComplete,OMX_CommandStateSet,
@@ -1127,11 +1127,11 @@ void omx_vdec::process_event_cb(void *ctxt, unsigned char id)
             else
             {
               pThis->complete_pending_buffer_done_cbs();
-              if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_IDLE_PENDING))
+              if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_IDLE_PENDING))
               {
                 DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_STOP_DONE Success");
                 // Send the callback now
-                BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_IDLE_PENDING);
+                pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_IDLE_PENDING);
                 pThis->m_state = OMX_StateIdle;
                 DEBUG_PRINT_LOW("\n Move to Idle State");
                 pThis->m_cb.EventHandler(&pThis->m_cmp,pThis->m_app_data,
@@ -1849,7 +1849,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         else
         {
           DEBUG_PRINT_LOW("send_command_proxy(): Loaded-->Idle-Pending\n");
-          BITMASK_SET(&m_flags, OMX_COMPONENT_IDLE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_IDLE_PENDING);
           // Skip the event notification
           bFlag = 0;
         }
@@ -1918,7 +1918,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         else
         {
           DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Loaded-Pending\n");
-          BITMASK_SET(&m_flags, OMX_COMPONENT_LOADING_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_LOADING_PENDING);
           // Skip the event notification
           bFlag = 0;
         }
@@ -1927,7 +1927,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
       else if(eState == OMX_StateExecuting)
       {
         DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Executing\n");
-        BITMASK_SET(&m_flags, OMX_COMPONENT_EXECUTE_PENDING);
+        m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_EXECUTE_PENDING);
         bFlag = 0;
         if (ioctl (drv_ctx.video_driver_fd,VDEC_IOCTL_CMD_START,
                     NULL) < 0)
@@ -1966,7 +1966,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
          }
          else
          {
-           BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
+           m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_PAUSE_PENDING);
            DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Pause\n");
            bFlag = 0;
          }
@@ -1998,7 +1998,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
          at the end of this function definition
          */
          DEBUG_PRINT_LOW("\n send_command_proxy(): Executing --> Idle \n");
-         BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
+         m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
          if(!sem_posted)
          {
            sem_posted = 1;
@@ -2021,7 +2021,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
          }
          else
          {
-           BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
+           m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_PAUSE_PENDING);
            DEBUG_PRINT_LOW("send_command_proxy(): Executing-->Pause\n");
            bFlag = 0;
          }
@@ -2082,7 +2082,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         }
         else
         {
-          BITMASK_SET(&m_flags,OMX_COMPONENT_EXECUTE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_EXECUTE_PENDING);
           DEBUG_PRINT_LOW("send_command_proxy(): Idle-->Executing\n");
           post_event (NULL,VDEC_S_SUCCESS,\
                       OMX_COMPONENT_GENERATE_RESUME_DONE);
@@ -2095,7 +2095,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         /* Since error is None , we will post an event
         at the end of this function definition */
         DEBUG_PRINT_LOW("\n Pause --> Idle \n");
-         BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
+         m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
          if(!sem_posted)
          {
            sem_posted = 1;
@@ -2216,11 +2216,11 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         "with param1: %d", param1);
     if(OMX_CORE_INPUT_PORT_INDEX == param1 || OMX_ALL == param1)
     {
-      BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_FLUSH_PENDING);
+      m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_INPUT_FLUSH_PENDING);
     }
     if(OMX_CORE_OUTPUT_PORT_INDEX == param1 || OMX_ALL == param1)
     {
-      BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
+      m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
     }
     if (!sem_posted){
       sem_posted = 1;
@@ -2239,7 +2239,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         m_inp_bEnabled = OMX_TRUE;
 
         if( (m_state == OMX_StateLoaded &&
-             !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+             !BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
             || allocate_input_done())
         {
           post_event(OMX_CommandPortEnable,OMX_CORE_INPUT_PORT_INDEX,
@@ -2248,7 +2248,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         else
         {
           DEBUG_PRINT_LOW("send_command_proxy(): Disabled-->Enabled Pending\n");
-          BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING);
           // Skip the event notification
           bFlag = 0;
         }
@@ -2259,7 +2259,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
           m_out_bEnabled = OMX_TRUE;
 
           if( (m_state == OMX_StateLoaded &&
-              !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+              !BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
               || (allocate_output_done()))
           {
              post_event(OMX_CommandPortEnable,OMX_CORE_OUTPUT_PORT_INDEX,
@@ -2269,7 +2269,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
           else
           {
               DEBUG_PRINT_LOW("send_command_proxy(): Disabled-->Enabled Pending\n");
-              BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+              m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
               // Skip the event notification
               bFlag = 0;
           }
@@ -2290,7 +2290,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
           }
           else
           {
-             BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_DISABLE_PENDING);
+             m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_INPUT_DISABLE_PENDING);
              if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
              {
                if(!sem_posted)
@@ -2317,7 +2317,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
           }
           else
          {
-            BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
+            m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
             if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
             {
               if (!sem_posted)
@@ -2325,7 +2325,7 @@ OMX_ERRORTYPE  omx_vdec::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
                 sem_posted = 1;
                 sem_post (&m_cmd_lock);
               }
-                BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_FLUSH_IN_DISABLE_PENDING);
+                m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_OUTPUT_FLUSH_IN_DISABLE_PENDING);
                 execute_omx_flush(OMX_CORE_OUTPUT_PORT_INDEX);
             }
             // Skip the event notification
@@ -3116,9 +3116,9 @@ OMX_ERRORTYPE  omx_vdec::set_parameter(OMX_IN OMX_HANDLETYPE     hComp,
          return OMX_ErrorBadParameter;
     }
     if((m_state != OMX_StateLoaded) &&
-          BITMASK_ABSENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING) &&
+          BITMASK_ABSENT_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING) &&
           (m_out_bEnabled == OMX_TRUE) &&
-          BITMASK_ABSENT(&m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING) &&
+          BITMASK_ABSENT_U32(m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING) &&
           (m_inp_bEnabled == OMX_TRUE)) {
         DEBUG_PRINT_ERROR("Set Param in Invalid State \n");
         return OMX_ErrorIncorrectStateOperation;
@@ -3353,7 +3353,7 @@ OMX_ERRORTYPE  omx_vdec::set_parameter(OMX_IN OMX_HANDLETYPE     hComp,
                        comp_role->cRole);
 
           if((m_state == OMX_StateLoaded)&&
-              !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+              !BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
           {
            DEBUG_PRINT_LOW("Set Parameter called in valid state");
           }
@@ -4190,7 +4190,7 @@ OMX_ERRORTYPE  omx_vdec::use_output_buffer(
 
   if (eRet == OMX_ErrorNone) {
     for(i=0; i< drv_ctx.op_buf.actualcount; i++) {
-      if(BITMASK_ABSENT(&m_out_bm_count,i))
+      if(BITMASK_ABSENT_U32(m_out_bm_count,i))
       {
         break;
       }
@@ -4367,7 +4367,7 @@ OMX_ERRORTYPE  omx_vdec::use_output_buffer(
        (*bufferHdr)->pBuffer = buff;
      }
      (*bufferHdr)->pAppPrivate = privateAppData;
-     BITMASK_SET(&m_out_bm_count,i);
+     m_out_bm_count = BITMASK_SET_U32(m_out_bm_count,i);
   }
   return eRet;
 }
@@ -4490,25 +4490,25 @@ OMX_ERRORTYPE  omx_vdec::use_buffer(
   DEBUG_PRINT_LOW("Use Buffer: port %u, buffer %p, eRet %d", port, *bufferHdr, error);
   if(error == OMX_ErrorNone)
   {
-    if(allocate_done() && BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+    if(allocate_done() && BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
     {
       // Send the callback now
-      BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
+      m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
       post_event(OMX_CommandStateSet,OMX_StateIdle,
                          OMX_COMPONENT_GENERATE_EVENT);
     }
     if(port == OMX_CORE_INPUT_PORT_INDEX && m_inp_bPopulated &&
-       BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
+       BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
     {
-      BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
+      m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING);
       post_event(OMX_CommandPortEnable,
           OMX_CORE_INPUT_PORT_INDEX,
           OMX_COMPONENT_GENERATE_EVENT);
     }
     else if(port == OMX_CORE_OUTPUT_PORT_INDEX && m_out_bPopulated &&
-            BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
+            BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
     {
-      BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+      m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
       post_event(OMX_CommandPortEnable,
                  OMX_CORE_OUTPUT_PORT_INDEX,
                  OMX_COMPONENT_GENERATE_EVENT);
@@ -4709,7 +4709,7 @@ OMX_ERRORTYPE omx_vdec::allocate_input_heap_buffer(OMX_HANDLETYPE       hComp,
   /*Find a Free index*/
   for(i=0; i< drv_ctx.ip_buf.actualcount; i++)
   {
-    if(BITMASK_ABSENT(&m_heap_inp_bm_count,i))
+    if(BITMASK_ABSENT_U32(m_heap_inp_bm_count,i))
     {
       DEBUG_PRINT_LOW("\n Free Input Buffer Index %d",i);
       break;
@@ -4727,7 +4727,7 @@ OMX_ERRORTYPE omx_vdec::allocate_input_heap_buffer(OMX_HANDLETYPE       hComp,
 
     *bufferHdr = (m_inp_heap_ptr + i);
     input = *bufferHdr;
-    BITMASK_SET(&m_heap_inp_bm_count,i);
+    m_heap_inp_bm_count = BITMASK_SET_U32(m_heap_inp_bm_count,i);
 
     input->pBuffer           = (OMX_U8 *)buf_addr;
     input->nSize             = sizeof(OMX_BUFFERHEADERTYPE);
@@ -4834,7 +4834,7 @@ OMX_ERRORTYPE  omx_vdec::allocate_input_buffer(
 
   for(i=0; i< drv_ctx.ip_buf.actualcount; i++)
   {
-    if(BITMASK_ABSENT(&m_inp_bm_count,i))
+    if(BITMASK_ABSENT_U32(m_inp_bm_count,i))
     {
       DEBUG_PRINT_LOW("\n Free Input Buffer Index %d",i);
       break;
@@ -4921,7 +4921,7 @@ OMX_ERRORTYPE  omx_vdec::allocate_input_buffer(
     }
 
     input = *bufferHdr;
-    BITMASK_SET(&m_inp_bm_count,i);
+    m_inp_bm_count = BITMASK_SET_U32(m_inp_bm_count,i);
     DEBUG_PRINT_LOW("\n Buffer address %p of pmem",*bufferHdr);
     if (secure_mode)
          input->pBuffer = (OMX_U8 *)drv_ctx.ptr_inputbuffer [i].pmem_fd;
@@ -5162,7 +5162,7 @@ OMX_ERRORTYPE  omx_vdec::allocate_output_buffer(
 
   for (i=0; i< drv_ctx.op_buf.actualcount; i++)
   {
-    if(BITMASK_ABSENT(&m_out_bm_count,i))
+    if(BITMASK_ABSENT_U32(m_out_bm_count,i))
     {
       DEBUG_PRINT_LOW("\n Found a Free Output Buffer Index %d",i);
       break;
@@ -5279,7 +5279,7 @@ OMX_ERRORTYPE  omx_vdec::allocate_output_buffer(
     (*bufferHdr)->nAllocLen = drv_ctx.op_buf.buffer_size;
     (*bufferHdr)->pBuffer = (OMX_U8*)drv_ctx.ptr_outputbuffer[i].bufferaddr;
     (*bufferHdr)->pAppPrivate = appData;
-    BITMASK_SET(&m_out_bm_count,i);
+    m_out_bm_count = BITMASK_SET_U32(m_out_bm_count,i);
 
   }
   else
@@ -5347,19 +5347,19 @@ OMX_ERRORTYPE  omx_vdec::allocate_buffer(OMX_IN OMX_HANDLETYPE                hC
     if(eRet == OMX_ErrorNone)
     {
         if(allocate_done()){
-            if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+            if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
             {
                 // Send the callback now
-                BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
+                m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
                 post_event(OMX_CommandStateSet,OMX_StateIdle,
                                    OMX_COMPONENT_GENERATE_EVENT);
             }
         }
         if(port == OMX_CORE_INPUT_PORT_INDEX && m_inp_bPopulated)
         {
-          if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
+          if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
           {
-             BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
+             m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING);
              post_event(OMX_CommandPortEnable,
                         OMX_CORE_INPUT_PORT_INDEX,
                         OMX_COMPONENT_GENERATE_EVENT);
@@ -5367,9 +5367,9 @@ OMX_ERRORTYPE  omx_vdec::allocate_buffer(OMX_IN OMX_HANDLETYPE                hC
         }
         if(port == OMX_CORE_OUTPUT_PORT_INDEX && m_out_bPopulated)
             {
-          if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
+          if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
           {
-             BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+             m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
                 post_event(OMX_CommandPortEnable,
                            OMX_CORE_OUTPUT_PORT_INDEX,
                            OMX_COMPONENT_GENERATE_EVENT);
@@ -5404,7 +5404,7 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
     DEBUG_PRINT_LOW("In for decoder free_buffer \n");
 
     if(m_state == OMX_StateIdle &&
-       (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
+       (BITMASK_PRESENT_U32(m_flags ,OMX_COMPONENT_LOADING_PENDING)))
     {
         DEBUG_PRINT_LOW(" free buffer while Component in Loading pending\n");
     }
@@ -5442,8 +5442,8 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
         if(nPortIndex < drv_ctx.ip_buf.actualcount)
         {
          // Clear the bit associated with it.
-         BITMASK_CLEAR(&m_inp_bm_count,nPortIndex);
-         BITMASK_CLEAR(&m_heap_inp_bm_count,nPortIndex);
+         m_inp_bm_count = BITMASK_CLEAR_U32(m_inp_bm_count,nPortIndex);
+         m_heap_inp_bm_count = BITMASK_CLEAR_U32(m_heap_inp_bm_count,nPortIndex);
          if (input_use_buffer == true)
          {
 
@@ -5477,11 +5477,11 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
             eRet = OMX_ErrorBadPortIndex;
         }
 
-        if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING)
+        if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_INPUT_DISABLE_PENDING)
            && release_input_done())
         {
             DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
-            BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING);
+            m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_INPUT_DISABLE_PENDING);
             post_event(OMX_CommandPortDisable,
                        OMX_CORE_INPUT_PORT_INDEX,
                        OMX_COMPONENT_GENERATE_EVENT);
@@ -5495,7 +5495,7 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
         {
             DEBUG_PRINT_LOW("free_buffer on o/p port - Port idx %d \n", nPortIndex);
             // Clear the bit associated with it.
-            BITMASK_CLEAR(&m_out_bm_count,nPortIndex);
+            m_out_bm_count = BITMASK_CLEAR_U32(m_out_bm_count,nPortIndex);
             m_out_bPopulated = OMX_FALSE;
             client_buffers.free_output_buffer (buffer);
 
@@ -5509,13 +5509,13 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
             DEBUG_PRINT_ERROR("Error: free_buffer , Port Index Invalid\n");
             eRet = OMX_ErrorBadPortIndex;
         }
-        if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING)
+        if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_OUTPUT_DISABLE_PENDING)
            && release_output_done())
         {
             DEBUG_PRINT_LOW("FreeBuffer : If any Disable event pending,post it\n");
 
                 DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
-                BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
+                m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
 #ifdef _ANDROID_ICS_
                 if (m_enable_android_native_buffers)
                 {
@@ -5534,12 +5534,12 @@ OMX_ERRORTYPE  omx_vdec::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
         eRet = OMX_ErrorBadPortIndex;
     }
     if((eRet == OMX_ErrorNone) &&
-       (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
+       (BITMASK_PRESENT_U32(m_flags ,OMX_COMPONENT_LOADING_PENDING)))
     {
         if(release_done())
         {
             // Send the callback now
-            BITMASK_CLEAR((&m_flags),OMX_COMPONENT_LOADING_PENDING);
+            m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_LOADING_PENDING);
             post_event(OMX_CommandStateSet, OMX_StateLoaded,
                                       OMX_COMPONENT_GENERATE_EVENT);
         }
@@ -6455,7 +6455,7 @@ bool omx_vdec::allocate_input_done(void)
   {
     for(;i<drv_ctx.ip_buf.actualcount;i++)
     {
-      if(BITMASK_ABSENT(&m_inp_bm_count,i))
+      if(BITMASK_ABSENT_U32(m_inp_bm_count,i))
       {
         break;
       }
@@ -6500,7 +6500,7 @@ bool omx_vdec::allocate_output_done(void)
   {
     for(;j < drv_ctx.op_buf.actualcount;j++)
     {
-      if(BITMASK_ABSENT(&m_out_bm_count,j))
+      if(BITMASK_ABSENT_U32(m_out_bm_count,j))
       {
         break;
       }
@@ -6571,7 +6571,7 @@ bool omx_vdec::release_output_done(void)
   {
       for(;j < drv_ctx.op_buf.actualcount ; j++)
       {
-        if(BITMASK_PRESENT(&m_out_bm_count,j))
+        if(BITMASK_PRESENT_U32(m_out_bm_count,j))
         {
           break;
         }
@@ -6613,7 +6613,7 @@ bool omx_vdec::release_input_done(void)
   {
       for(;j<drv_ctx.ip_buf.actualcount;j++)
       {
-        if( BITMASK_PRESENT(&m_inp_bm_count,j))
+        if( BITMASK_PRESENT_U32(m_inp_bm_count,j))
         {
           break;
         }
diff --git a/mm-video/vidc/venc/inc/omx_video_base.h b/mm-video/vidc/venc/inc/omx_video_base.h
index cf2b5b08..dfcef88f 100644
--- a/mm-video/vidc/venc/inc/omx_video_base.h
+++ b/mm-video/vidc/venc/inc/omx_video_base.h
@@ -115,18 +115,15 @@ static const char* MEM_DEVICE = "/dev/pmem_smipool";
 #define BITMASK_SIZE(mIndex) (((mIndex) + BITS_PER_BYTE - 1)/BITS_PER_BYTE)
 #define BITMASK_OFFSET(mIndex) ((mIndex)/BITS_PER_BYTE)
 #define BITMASK_FLAG(mIndex) (1 << ((mIndex) % BITS_PER_BYTE))
-#define BITMASK_CLEAR(mArray,mIndex) (mArray)[BITMASK_OFFSET(mIndex)] \
-        &=  ~(BITMASK_FLAG(mIndex))
-#define BITMASK_SET(mArray,mIndex)  (mArray)[BITMASK_OFFSET(mIndex)] \
-        |=  BITMASK_FLAG(mIndex)
-#define BITMASK_PRESENT(mArray,mIndex) ((mArray)[BITMASK_OFFSET(mIndex)] \
-        & BITMASK_FLAG(mIndex))
-#define BITMASK_ABSENT(mArray,mIndex) (((mArray)[BITMASK_OFFSET(mIndex)] \
-        & BITMASK_FLAG(mIndex)) == 0x0)
-#define BITMASK_PRESENT(mArray,mIndex) ((mArray)[BITMASK_OFFSET(mIndex)] \
-        & BITMASK_FLAG(mIndex))
-#define BITMASK_ABSENT(mArray,mIndex) (((mArray)[BITMASK_OFFSET(mIndex)] \
-        & BITMASK_FLAG(mIndex)) == 0x0)
+
+//BitMask Management logic for U32
+#define BITMASK_CLEAR_U32(mArray,mIndex) ((mArray) & (~(BITMASK_FLAG(mIndex))))
+#define BITMASK_SET_U32(mArray,mIndex)  ((mArray) | BITMASK_FLAG(mIndex))
+#define BITMASK_PRESENT_U32(mArray,mIndex) ((mArray) & BITMASK_FLAG(mIndex))
+#define BITMASK_ABSENT_U32(mArray,mIndex) (((mArray) & BITMASK_FLAG(mIndex)) == 0x0)
+
+
+
 #ifdef _ANDROID_ICS_
 #define MAX_NUM_INPUT_BUFFERS 32
 #endif
diff --git a/mm-video/vidc/venc/src/omx_video_base.cpp b/mm-video/vidc/venc/src/omx_video_base.cpp
index d4118bce..cbf0ce63 100644
--- a/mm-video/vidc/venc/src/omx_video_base.cpp
+++ b/mm-video/vidc/venc/src/omx_video_base.cpp
@@ -472,15 +472,15 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
         if(pThis->m_pCallbacks.EventHandler)
         {
           /*Check if we need generate event for Flush done*/
-          if(BITMASK_PRESENT(&pThis->m_flags,
+          if(BITMASK_PRESENT_U32(pThis->m_flags,
                              OMX_COMPONENT_INPUT_FLUSH_PENDING))
           {
-            BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_INPUT_FLUSH_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_INPUT_FLUSH_PENDING);
             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                              OMX_EventCmdComplete,OMX_CommandFlush,
                                              PORT_INDEX_IN,NULL );
           }
-          else if(BITMASK_PRESENT(&pThis->m_flags,
+          else if(BITMASK_PRESENT_U32(pThis->m_flags,
                                   OMX_COMPONENT_IDLE_PENDING))
           {
             if(!pThis->output_flush_progress)
@@ -505,16 +505,16 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
         if(pThis->m_pCallbacks.EventHandler)
         {
           /*Check if we need generate event for Flush done*/
-          if(BITMASK_PRESENT(&pThis->m_flags,
+          if(BITMASK_PRESENT_U32(pThis->m_flags,
                              OMX_COMPONENT_OUTPUT_FLUSH_PENDING))
           {
-            BITMASK_CLEAR (&pThis->m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
 
             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                              OMX_EventCmdComplete,OMX_CommandFlush,
                                              PORT_INDEX_OUT,NULL );
           }
-          else if(BITMASK_PRESENT(&pThis->m_flags ,OMX_COMPONENT_IDLE_PENDING))
+          else if(BITMASK_PRESENT_U32(pThis->m_flags ,OMX_COMPONENT_IDLE_PENDING))
           {
             DEBUG_PRINT_LOW("\n dev_stop called after Output flush complete\n");
             if(!pThis->input_flush_progress)
@@ -535,18 +535,18 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
         if(pThis->m_pCallbacks.EventHandler)
         {
           DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_START_DONE Success");
-          if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
+          if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
           {
             DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_START_DONE Move to \
                              executing");
             // Send the callback now
-            BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING);
             pThis->m_state = OMX_StateExecuting;
             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                              OMX_EventCmdComplete,OMX_CommandStateSet,
                                              OMX_StateExecuting, NULL);
           }
-          else if(BITMASK_PRESENT(&pThis->m_flags,
+          else if(BITMASK_PRESENT_U32(pThis->m_flags,
                                   OMX_COMPONENT_PAUSE_PENDING))
           {
             if(dev_pause())
@@ -555,7 +555,7 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
               pThis->omx_report_error ();
             }
           }
-          else if (BITMASK_PRESENT(&pThis->m_flags,
+          else if (BITMASK_PRESENT_U32(pThis->m_flags,
                                    OMX_COMPONENT_LOADED_START_PENDING))
           {
             if(dev_loaded_start_done())
@@ -567,7 +567,7 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
               DEBUG_PRINT_ERROR("ERROR: failed in loaded Start Done!");
               pThis->omx_report_error ();
             }
-            BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_LOADED_START_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_LOADED_START_PENDING);
           }
           else
           {
@@ -584,12 +584,12 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
         DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_PAUSE_DONE msg");
         if(pThis->m_pCallbacks.EventHandler)
         {
-          if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING))
+          if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING))
           {
             //Send the callback now
             pThis->complete_pending_buffer_done_cbs();
             DEBUG_PRINT_LOW("omx_video::process_event_cb() Sending PAUSE complete after all pending EBD/FBD\n");
-            BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_PAUSE_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_PAUSE_PENDING);
             pThis->m_state = OMX_StatePause;
             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                              OMX_EventCmdComplete,OMX_CommandStateSet,
@@ -603,10 +603,10 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
         DEBUG_PRINT_LOW("\n OMX_COMPONENT_GENERATE_RESUME_DONE msg");
         if(pThis->m_pCallbacks.EventHandler)
         {
-          if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
+          if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING))
           {
             // Send the callback now
-            BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_EXECUTE_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_EXECUTE_PENDING);
             pThis->m_state = OMX_StateExecuting;
             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp, pThis->m_app_data,
                                              OMX_EventCmdComplete,OMX_CommandStateSet,
@@ -621,16 +621,16 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
         if(pThis->m_pCallbacks.EventHandler)
         {
           pThis->complete_pending_buffer_done_cbs();
-          if(BITMASK_PRESENT(&pThis->m_flags,OMX_COMPONENT_IDLE_PENDING))
+          if(BITMASK_PRESENT_U32(pThis->m_flags,OMX_COMPONENT_IDLE_PENDING))
           {
             // Send the callback now
-            BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_IDLE_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_IDLE_PENDING);
             pThis->m_state = OMX_StateIdle;
             pThis->m_pCallbacks.EventHandler(&pThis->m_cmp,pThis->m_app_data,
                                              OMX_EventCmdComplete,OMX_CommandStateSet,
                                              OMX_StateIdle,NULL);
           }
-          else if (BITMASK_PRESENT(&pThis->m_flags,
+          else if (BITMASK_PRESENT_U32(pThis->m_flags,
                                    OMX_COMPONENT_LOADED_STOP_PENDING))
           {
             if(dev_loaded_stop_done())
@@ -642,7 +642,7 @@ void omx_video::process_event_cb(void *ctxt, unsigned char id)
               DEBUG_PRINT_ERROR("ERROR: failed in loaded Stop Done!");
               pThis->omx_report_error ();
             }
-            BITMASK_CLEAR((&pThis->m_flags),OMX_COMPONENT_LOADED_STOP_PENDING);
+            pThis->m_flags = BITMASK_CLEAR_U32(pThis->m_flags,OMX_COMPONENT_LOADED_STOP_PENDING);
           }
           else
           {
@@ -808,7 +808,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         else
         {
           DEBUG_PRINT_LOW("OMXCORE-SM: Loaded-->Idle-Pending\n");
-          BITMASK_SET(&m_flags, OMX_COMPONENT_IDLE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_IDLE_PENDING);
           // Skip the event notification
           bFlag = 0;
         }
@@ -882,7 +882,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         else
         {
           DEBUG_PRINT_LOW("OMXCORE-SM: Idle-->Loaded-Pending\n");
-          BITMASK_SET(&m_flags, OMX_COMPONENT_LOADING_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_LOADING_PENDING);
           // Skip the event notification
           bFlag = 0;
         }
@@ -898,7 +898,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         }
         else
         {
-          BITMASK_SET(&m_flags,OMX_COMPONENT_EXECUTE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_EXECUTE_PENDING);
           DEBUG_PRINT_LOW("OMXCORE-SM: Idle-->Executing\n");
           bFlag = 0;
         }
@@ -933,7 +933,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         }
         else
         {
-          BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_PAUSE_PENDING);
           DEBUG_PRINT_LOW("OMXCORE-SM: Idle-->Pause\n");
           bFlag = 0;
         }
@@ -965,7 +965,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         */
         DEBUG_PRINT_LOW("\n OMXCORE-SM: Executing --> Idle \n");
         //here this should be Pause-Idle pending and should be cleared when flush is complete and change the state to Idle
-        BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
+        m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
         execute_omx_flush(OMX_ALL);
         bFlag = 0;
 	dev_stop_done();
@@ -983,7 +983,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         }
         else
         {
-          BITMASK_SET(&m_flags,OMX_COMPONENT_PAUSE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_PAUSE_PENDING);
           DEBUG_PRINT_LOW("OMXCORE-SM: Executing-->Pause\n");
           bFlag = 0;
         }
@@ -1042,7 +1042,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         }
         else
         {
-          BITMASK_SET(&m_flags,OMX_COMPONENT_EXECUTE_PENDING);
+          m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_EXECUTE_PENDING);
           DEBUG_PRINT_LOW("OMXCORE-SM: Pause-->Executing\n");
           post_event (NULL, NULL, OMX_COMPONENT_GENERATE_RESUME_DONE);
           bFlag = 0;
@@ -1054,7 +1054,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
         /* Since error is None , we will post an event
         at the end of this function definition */
         DEBUG_PRINT_LOW("\n Pause --> Idle \n");
-        BITMASK_SET(&m_flags,OMX_COMPONENT_IDLE_PENDING);
+        m_flags = BITMASK_SET_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
         execute_omx_flush(OMX_ALL);
         bFlag = 0;
       }
@@ -1168,12 +1168,12 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
   {
     if(0 == param1 || OMX_ALL == param1)
     {
-      BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_FLUSH_PENDING);
+      m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_INPUT_FLUSH_PENDING);
     }
     if(1 == param1 || OMX_ALL == param1)
     {
       //generate output flush event only.
-      BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
+      m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_OUTPUT_FLUSH_PENDING);
     }
 
     execute_omx_flush(param1);
@@ -1186,7 +1186,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
       m_sInPortDef.bEnabled = OMX_TRUE;
 
       if( (m_state == OMX_StateLoaded &&
-           !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+           !BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
           || allocate_input_done())
       {
         post_event(OMX_CommandPortEnable,PORT_INDEX_IN,
@@ -1195,7 +1195,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
       else
       {
         DEBUG_PRINT_LOW("OMXCORE-SM: Disabled-->Enabled Pending\n");
-        BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING);
+        m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_INPUT_ENABLE_PENDING);
         // Skip the event notification
         bFlag = 0;
       }
@@ -1205,7 +1205,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
       m_sOutPortDef.bEnabled = OMX_TRUE;
 
       if( (m_state == OMX_StateLoaded &&
-           !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+           !BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
           || (allocate_output_done()))
       {
         post_event(OMX_CommandPortEnable,PORT_INDEX_OUT,
@@ -1215,7 +1215,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
       else
       {
         DEBUG_PRINT_LOW("OMXCORE-SM: Disabled-->Enabled Pending\n");
-        BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+        m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
         // Skip the event notification
         bFlag = 0;
       }
@@ -1234,7 +1234,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
       }
       else
       {
-        BITMASK_SET(&m_flags, OMX_COMPONENT_INPUT_DISABLE_PENDING);
+        m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_INPUT_DISABLE_PENDING);
         if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
         {
           execute_omx_flush(PORT_INDEX_IN);
@@ -1256,7 +1256,7 @@ OMX_ERRORTYPE  omx_video::send_command_proxy(OMX_IN OMX_HANDLETYPE hComp,
       }
       else
       {
-        BITMASK_SET(&m_flags, OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
+        m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
         if(m_state == OMX_StatePause ||m_state == OMX_StateExecuting)
         {
           execute_omx_flush(PORT_INDEX_OUT);
@@ -1817,7 +1817,7 @@ OMX_ERRORTYPE  omx_video::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
        DEBUG_PRINT_HIGH("QOMX_IndexParamVideoSyntaxHdr");
        QOMX_EXTNINDEX_PARAMTYPE* pParam =
           reinterpret_cast<QOMX_EXTNINDEX_PARAMTYPE*>(paramData);
-       BITMASK_SET(&m_flags, OMX_COMPONENT_LOADED_START_PENDING);
+       m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_LOADED_START_PENDING);
        if(dev_loaded_start())
        {
          DEBUG_PRINT_LOW("device start successful");
@@ -1825,7 +1825,7 @@ OMX_ERRORTYPE  omx_video::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
        else
        {
          DEBUG_PRINT_ERROR("device start failed");
-         BITMASK_CLEAR(&m_flags, OMX_COMPONENT_LOADED_START_PENDING);
+         m_flags = BITMASK_CLEAR_U32(m_flags, OMX_COMPONENT_LOADED_START_PENDING);
          return OMX_ErrorHardware;
        }
        if(dev_get_seq_hdr(pParam->pData,
@@ -1843,7 +1843,7 @@ OMX_ERRORTYPE  omx_video::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
          DEBUG_PRINT_ERROR("Error returned from GetSyntaxHeader()");
          eRet = OMX_ErrorHardware;
        }
-       BITMASK_SET(&m_flags, OMX_COMPONENT_LOADED_STOP_PENDING);
+       m_flags = BITMASK_SET_U32(m_flags, OMX_COMPONENT_LOADED_STOP_PENDING);
        if(dev_loaded_stop())
        {
          DEBUG_PRINT_LOW("device stop successful");
@@ -1851,7 +1851,7 @@ OMX_ERRORTYPE  omx_video::get_parameter(OMX_IN OMX_HANDLETYPE     hComp,
        else
        {
          DEBUG_PRINT_ERROR("device stop failed");
-         BITMASK_CLEAR(&m_flags, OMX_COMPONENT_LOADED_STOP_PENDING);
+         m_flags = BITMASK_CLEAR_U32(m_flags, OMX_COMPONENT_LOADED_STOP_PENDING);
          eRet = OMX_ErrorHardware;
        }
        break;
@@ -2111,7 +2111,7 @@ OMX_ERRORTYPE  omx_video::use_input_buffer(
 
   for(i=0; i< m_sInPortDef.nBufferCountActual; i++)
   {
-    if(BITMASK_ABSENT(&m_inp_bm_count,i))
+    if(BITMASK_ABSENT_U32(m_inp_bm_count,i))
     {
       break;
     }
@@ -2121,7 +2121,7 @@ OMX_ERRORTYPE  omx_video::use_input_buffer(
   {
 
     *bufferHdr = (m_inp_mem_ptr + i);
-    BITMASK_SET(&m_inp_bm_count,i);
+    m_inp_bm_count = BITMASK_SET_U32(m_inp_bm_count,i);
 
     (*bufferHdr)->pBuffer           = (OMX_U8 *)buffer;
     (*bufferHdr)->nSize             = sizeof(OMX_BUFFERHEADERTYPE);
@@ -2313,7 +2313,7 @@ OMX_ERRORTYPE  omx_video::use_output_buffer(
 
   for(i=0; i< m_sOutPortDef.nBufferCountActual; i++)
   {
-    if(BITMASK_ABSENT(&m_out_bm_count,i))
+    if(BITMASK_ABSENT_U32(m_out_bm_count,i))
     {
       break;
     }
@@ -2326,7 +2326,7 @@ OMX_ERRORTYPE  omx_video::use_output_buffer(
       *bufferHdr = (m_out_mem_ptr + i );
       (*bufferHdr)->pBuffer = (OMX_U8 *)buffer;
 	  (*bufferHdr)->pAppPrivate = appData;
-      BITMASK_SET(&m_out_bm_count,i);
+      m_out_bm_count = BITMASK_SET_U32(m_out_bm_count,i);
 
       if(!m_use_output_pmem)
       {
@@ -2454,19 +2454,19 @@ OMX_ERRORTYPE  omx_video::use_buffer(
   {
     if(allocate_done())
     {
-      if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+      if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
       {
         // Send the callback now
-        BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
+        m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
         post_event(OMX_CommandStateSet,OMX_StateIdle,
                    OMX_COMPONENT_GENERATE_EVENT);
       }
     }
     if(port == PORT_INDEX_IN && m_sInPortDef.bPopulated)
     {
-      if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
+      if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
       {
-        BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
+        m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING);
         post_event(OMX_CommandPortEnable,
                    PORT_INDEX_IN,
                    OMX_COMPONENT_GENERATE_EVENT);
@@ -2475,9 +2475,9 @@ OMX_ERRORTYPE  omx_video::use_buffer(
     }
     else if(port == PORT_INDEX_OUT && m_sOutPortDef.bPopulated)
     {
-      if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
+      if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
       {
-        BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+        m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
         post_event(OMX_CommandPortEnable,
                    PORT_INDEX_OUT,
                    OMX_COMPONENT_GENERATE_EVENT);
@@ -2644,7 +2644,7 @@ OMX_ERRORTYPE omx_video::allocate_input_meta_buffer(
       return OMX_ErrorBadParameter;
     }
   }
-  BITMASK_SET(&m_inp_bm_count,index);
+  m_inp_bm_count = BITMASK_SET_U32(m_inp_bm_count,index);
   *bufferHdr = &meta_buffer_hdr[index];
   memset(&meta_buffer_hdr[index], 0, sizeof(meta_buffer_hdr[index]));
   meta_buffer_hdr[index].nSize = sizeof(meta_buffer_hdr[index]);
@@ -2733,7 +2733,7 @@ OMX_ERRORTYPE  omx_video::allocate_input_buffer(
 
   for(i=0; i< m_sInPortDef.nBufferCountActual; i++)
   {
-    if(BITMASK_ABSENT(&m_inp_bm_count,i))
+    if(BITMASK_ABSENT_U32(m_inp_bm_count,i))
     {
       break;
     }
@@ -2789,7 +2789,7 @@ OMX_ERRORTYPE  omx_video::allocate_input_buffer(
 
     (*bufferHdr)->pBuffer           = (OMX_U8 *)m_pInput_pmem[i].buffer;
     DEBUG_PRINT_LOW("\n Virtual address in allocate buffer is %p", m_pInput_pmem[i].buffer);
-    BITMASK_SET(&m_inp_bm_count,i);
+    m_inp_bm_count = BITMASK_SET_U32(m_inp_bm_count,i);
     //here change the I/P param here from buf_adr to pmem
     if(!mUseProxyColorFormat && (dev_use_buf(&m_pInput_pmem[i],PORT_INDEX_IN,i) != true))
     {
@@ -2897,7 +2897,7 @@ OMX_ERRORTYPE  omx_video::allocate_output_buffer(
   DEBUG_PRINT_HIGH("\n actual cnt = %u", m_sOutPortDef.nBufferCountActual);
   for(i=0; i< m_sOutPortDef.nBufferCountActual; i++)
   {
-    if(BITMASK_ABSENT(&m_out_bm_count,i))
+    if(BITMASK_ABSENT_U32(m_out_bm_count,i))
     {
       DEBUG_PRINT_LOW("\n Found a Free Output Buffer %d",i);
       break;
@@ -2954,7 +2954,7 @@ OMX_ERRORTYPE  omx_video::allocate_output_buffer(
       }
       (*bufferHdr)->pAppPrivate = appData;
 
-      BITMASK_SET(&m_out_bm_count,i);
+      m_out_bm_count = BITMASK_SET_U32(m_out_bm_count,i);
 
       if(dev_use_buf(&m_pOutput_pmem[i],PORT_INDEX_OUT,i) != true)
       {
@@ -3028,19 +3028,19 @@ OMX_ERRORTYPE  omx_video::allocate_buffer(OMX_IN OMX_HANDLETYPE                h
   {
     if(allocate_done())
     {
-      if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+      if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
       {
         // Send the callback now
-        BITMASK_CLEAR((&m_flags),OMX_COMPONENT_IDLE_PENDING);
+        m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_IDLE_PENDING);
         post_event(OMX_CommandStateSet,OMX_StateIdle,
                    OMX_COMPONENT_GENERATE_EVENT);
       }
     }
     if(port == PORT_INDEX_IN && m_sInPortDef.bPopulated)
     {
-      if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
+      if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING))
       {
-        BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_ENABLE_PENDING);
+        m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_INPUT_ENABLE_PENDING);
         post_event(OMX_CommandPortEnable,
                    PORT_INDEX_IN,
                    OMX_COMPONENT_GENERATE_EVENT);
@@ -3048,9 +3048,9 @@ OMX_ERRORTYPE  omx_video::allocate_buffer(OMX_IN OMX_HANDLETYPE                h
     }
     if(port == PORT_INDEX_OUT && m_sOutPortDef.bPopulated)
     {
-      if(BITMASK_PRESENT(&m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
+      if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING))
       {
-        BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
+        m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_OUTPUT_ENABLE_PENDING);
         post_event(OMX_CommandPortEnable,
                    PORT_INDEX_OUT,
                    OMX_COMPONENT_GENERATE_EVENT);
@@ -3087,7 +3087,7 @@ OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
   DEBUG_PRINT_LOW("In for decoder free_buffer \n");
 
   if(m_state == OMX_StateIdle &&
-     (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
+     (BITMASK_PRESENT_U32(m_flags ,OMX_COMPONENT_LOADING_PENDING)))
   {
     DEBUG_PRINT_LOW(" free buffer while Component in Loading pending\n");
   }
@@ -3123,7 +3123,7 @@ OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
     if(nPortIndex < m_sInPortDef.nBufferCountActual)
     {
       // Clear the bit associated with it.
-      BITMASK_CLEAR(&m_inp_bm_count,nPortIndex);
+      m_inp_bm_count = BITMASK_CLEAR_U32(m_inp_bm_count,nPortIndex);
       free_input_buffer (buffer);
       m_sInPortDef.bPopulated = OMX_FALSE;
 
@@ -3163,11 +3163,11 @@ OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
       eRet = OMX_ErrorBadPortIndex;
     }
 
-    if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING)
+    if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_INPUT_DISABLE_PENDING)
        && release_input_done())
     {
       DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
-      BITMASK_CLEAR((&m_flags),OMX_COMPONENT_INPUT_DISABLE_PENDING);
+      m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_INPUT_DISABLE_PENDING);
       post_event(OMX_CommandPortDisable,
                  PORT_INDEX_IN,
                  OMX_COMPONENT_GENERATE_EVENT);
@@ -3183,7 +3183,7 @@ OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
     if(nPortIndex < m_sOutPortDef.nBufferCountActual)
     {
       // Clear the bit associated with it.
-      BITMASK_CLEAR(&m_out_bm_count,nPortIndex);
+      m_out_bm_count = BITMASK_CLEAR_U32(m_out_bm_count,nPortIndex);
       m_sOutPortDef.bPopulated = OMX_FALSE;
       free_output_buffer (buffer);
 
@@ -3217,13 +3217,13 @@ OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
       DEBUG_PRINT_ERROR("ERROR: free_buffer , Port Index Invalid\n");
       eRet = OMX_ErrorBadPortIndex;
     }
-    if(BITMASK_PRESENT((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING)
+    if(BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_OUTPUT_DISABLE_PENDING)
        && release_output_done() )
     {
       DEBUG_PRINT_LOW("FreeBuffer : If any Disable event pending,post it\n");
 
       DEBUG_PRINT_LOW("MOVING TO DISABLED STATE \n");
-      BITMASK_CLEAR((&m_flags),OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
+      m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_OUTPUT_DISABLE_PENDING);
       post_event(OMX_CommandPortDisable,
                  PORT_INDEX_OUT,
                  OMX_COMPONENT_GENERATE_EVENT);
@@ -3235,7 +3235,7 @@ OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
     eRet = OMX_ErrorBadPortIndex;
   }
   if((eRet == OMX_ErrorNone) &&
-     (BITMASK_PRESENT(&m_flags ,OMX_COMPONENT_LOADING_PENDING)))
+     (BITMASK_PRESENT_U32(m_flags ,OMX_COMPONENT_LOADING_PENDING)))
   {
     if(release_done())
     {
@@ -3245,7 +3245,7 @@ OMX_ERRORTYPE  omx_video::free_buffer(OMX_IN OMX_HANDLETYPE         hComp,
         eRet = OMX_ErrorHardware;
       }
       // Send the callback now
-      BITMASK_CLEAR((&m_flags),OMX_COMPONENT_LOADING_PENDING);
+      m_flags = BITMASK_CLEAR_U32(m_flags,OMX_COMPONENT_LOADING_PENDING);
       post_event(OMX_CommandStateSet, OMX_StateLoaded,
                  OMX_COMPONENT_GENERATE_EVENT);
     }
@@ -3798,7 +3798,7 @@ bool omx_video::allocate_input_done(void)
   {
     for(;i<m_sInPortDef.nBufferCountActual;i++)
     {
-      if(BITMASK_ABSENT(&m_inp_bm_count,i))
+      if(BITMASK_ABSENT_U32(m_inp_bm_count,i))
       {
         break;
       }
@@ -3842,7 +3842,7 @@ bool omx_video::allocate_output_done(void)
   {
     for(;j<m_sOutPortDef.nBufferCountActual;j++)
     {
-      if(BITMASK_ABSENT(&m_out_bm_count,j))
+      if(BITMASK_ABSENT_U32(m_out_bm_count,j))
       {
         break;
       }
@@ -3914,7 +3914,7 @@ bool omx_video::release_output_done(void)
   {
     for(;j<m_sOutPortDef.nBufferCountActual;j++)
     {
-      if(BITMASK_PRESENT(&m_out_bm_count,j))
+      if(BITMASK_PRESENT_U32(m_out_bm_count,j))
       {
         break;
       }
@@ -3954,7 +3954,7 @@ bool omx_video::release_input_done(void)
   {
     for(;j<m_sInPortDef.nBufferCountActual;j++)
     {
-      if( BITMASK_PRESENT(&m_inp_bm_count,j))
+      if( BITMASK_PRESENT_U32(m_inp_bm_count,j))
       {
         break;
       }
diff --git a/mm-video/vidc/venc/src/omx_video_encoder.cpp b/mm-video/vidc/venc/src/omx_video_encoder.cpp
index a899b801..d9fd6fdc 100644
--- a/mm-video/vidc/venc/src/omx_video_encoder.cpp
+++ b/mm-video/vidc/venc/src/omx_video_encoder.cpp
@@ -800,7 +800,7 @@ OMX_ERRORTYPE  omx_venc::set_parameter(OMX_IN OMX_HANDLETYPE     hComp,
                   comp_role->cRole);
 
       if((m_state == OMX_StateLoaded)&&
-          !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING))
+          !BITMASK_PRESENT_U32(m_flags,OMX_COMPONENT_IDLE_PENDING))
       {
          DEBUG_PRINT_LOW("Set Parameter called in valid state");
       }