diff --git a/decoder/ih264d_api.c b/decoder/ih264d_api.c
index 5d367ed..f7beeef 100644
--- a/decoder/ih264d_api.c
+++ b/decoder/ih264d_api.c
@@ -1265,7 +1265,7 @@ void ih264d_init_decoder(void * ps_dec_params)
     ps_dec->u1_pr_sl_type = 0xFF;
     ps_dec->u2_mbx = 0xffff;
     ps_dec->u2_mby = 0;
-    ps_dec->u2_total_mbs_coded = 0;
+    ps_dec->u4_total_mbs_coded = 0;
 
     /* POC initializations */
     ps_prev_poc = &ps_dec->s_prev_pic_poc;
@@ -1291,7 +1291,7 @@ void ih264d_init_decoder(void * ps_dec_params)
 
     ps_dec->i4_max_poc = 0;
     ps_dec->i4_prev_max_display_seq = 0;
-    ps_dec->u1_recon_mb_grp = 4;
+    ps_dec->u4_recon_mb_grp = 4;
     ps_dec->i4_reorder_depth = -1;
 
     /* Field PIC initializations */
@@ -2490,8 +2490,8 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
         ih264d_init_decoder(ps_dec);
     }
 
-    ps_dec->u2_cur_mb_addr = 0;
-    ps_dec->u2_total_mbs_coded = 0;
+    ps_dec->u4_cur_mb_addr = 0;
+    ps_dec->u4_total_mbs_coded = 0;
     ps_dec->u2_cur_slice_num = 0;
     ps_dec->cur_dec_mb_num = 0;
     ps_dec->cur_recon_mb_num = 0;
@@ -2663,7 +2663,7 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
 
     if((ps_dec->u4_pic_buf_got == 1)
             && (ret != IVD_MEM_ALLOC_FAILED)
-            && ps_dec->u2_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
+            && ps_dec->u4_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
     {
         // last slice - missing/corruption
         WORD32 num_mb_skipped;
@@ -2673,14 +2673,14 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
         WORD32 ht_in_mbs;
         ht_in_mbs = ps_dec->u2_pic_ht >> (4 + ps_dec->ps_cur_slice->u1_field_pic_flag);
         num_mb_skipped = (ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
-                            - ps_dec->u2_total_mbs_coded;
+                            - ps_dec->u4_total_mbs_coded;
 
         if(ps_dec->u4_first_slice_in_pic && (ps_dec->u4_pic_buf_got == 0))
             prev_slice_err = 1;
         else
             prev_slice_err = 2;
 
-        if(ps_dec->u4_first_slice_in_pic && (ps_dec->u2_total_mbs_coded == 0))
+        if(ps_dec->u4_first_slice_in_pic && (ps_dec->u4_total_mbs_coded == 0))
             prev_slice_err = 1;
 
         ret1 = ih264d_mark_err_slice_skip(ps_dec, num_mb_skipped, ps_dec->u1_nal_unit_type == IDR_SLICE_NAL, ps_dec->ps_cur_slice->u2_frame_num,
@@ -2819,7 +2819,7 @@ WORD32 ih264d_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
         /*set to complete ,as we dont support partial frame decode*/
         if(ps_dec->i4_header_decoded == 3)
         {
-            ps_dec->u2_total_mbs_coded = ps_dec->ps_cur_sps->u2_max_mb_addr + 1;
+            ps_dec->u4_total_mbs_coded = ps_dec->ps_cur_sps->u4_max_mb_addr + 1;
         }
 
         /*Update the i4_frametype at the end of picture*/
diff --git a/decoder/ih264d_defs.h b/decoder/ih264d_defs.h
index 894fc78..d6c72e6 100644
--- a/decoder/ih264d_defs.h
+++ b/decoder/ih264d_defs.h
@@ -36,9 +36,9 @@
  */
 #include <stdint.h>
 
-#define H264_MAX_FRAME_WIDTH                4080
-#define H264_MAX_FRAME_HEIGHT               4080
-#define H264_MAX_FRAME_SIZE                 (4096 * 2048)
+#define H264_MAX_FRAME_WIDTH                4096
+#define H264_MAX_FRAME_HEIGHT               4096
+#define H264_MAX_FRAME_SIZE                 (4096 * 4096)
 
 #define H264_MIN_FRAME_WIDTH                16
 #define H264_MIN_FRAME_HEIGHT               16
diff --git a/decoder/ih264d_mb_utils.c b/decoder/ih264d_mb_utils.c
index 213fbc8..f1df3fa 100644
--- a/decoder/ih264d_mb_utils.c
+++ b/decoder/ih264d_mb_utils.c
@@ -97,7 +97,7 @@ UWORD32 ih264d_get_mb_info_cavlc_nonmbaff(dec_struct_t *ps_dec,
     mb_x = (WORD16)ps_dec->u2_mbx;
     mb_y = (WORD16)ps_dec->u2_mby;
 
-    ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
+    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
 
     mb_x++;
 
@@ -230,7 +230,7 @@ UWORD32 ih264d_get_mb_info_cavlc_mbaff(dec_struct_t *ps_dec,
     u2_mb_x = ps_dec->u2_mbx;
     u2_mb_y = ps_dec->u2_mby;
 
-    ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
+    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
 
 
     if(u1_top_mb)
@@ -381,7 +381,7 @@ UWORD32 ih264d_get_mb_info_cabac_nonmbaff(dec_struct_t *ps_dec,
     mb_x = (WORD16)ps_dec->u2_mbx;
     mb_y = (WORD16)ps_dec->u2_mby;
 
-    ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
+    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
 
     mb_x++;
     if((UWORD32)mb_x == u2_frm_width_in_mb)
@@ -569,7 +569,7 @@ UWORD32 ih264d_get_mb_info_cabac_mbaff(dec_struct_t *ps_dec,
     mb_x = (WORD16)ps_dec->u2_mbx;
     mb_y = (WORD16)ps_dec->u2_mby;
 
-    ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
+    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
 
     ps_top_ctxt = ps_left_ctxt = p_ctx_inc_mb_map - 1;
 
@@ -1389,9 +1389,9 @@ void ih264d_get_mbaff_neighbours(dec_struct_t * ps_dec,
  **************************************************************************
  */
 void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
-                                   const UWORD8 u1_num_mbs,
-                                   const UWORD8 u1_end_of_row, /* Cur n-Mb End of Row Flag */
-                                   const UWORD8 u1_end_of_row_next /* Next n-Mb End of Row Flag */
+                                   const UWORD32 u4_num_mbs,
+                                   const UWORD32 u4_end_of_row, /* Cur n-Mb End of Row Flag */
+                                   const UWORD32 u4_end_of_row_next /* Next n-Mb End of Row Flag */
                                    )
 {
     dec_mb_info_t *ps_cur_mb_info = ps_dec->ps_nmb_info;
@@ -1401,14 +1401,14 @@ void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
     UWORD32 u4_frame_stride;
     mb_neigbour_params_t *ps_temp;
     const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
-    UNUSED(u1_end_of_row_next);
+    UNUSED(u4_end_of_row_next);
 
-    ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u1_end_of_row];
-    ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u1_end_of_row];
-    ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u1_end_of_row];
+    ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u4_end_of_row];
+    ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u4_end_of_row];
+    ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u4_end_of_row];
 
     /* Swap top and current pointers */
-    if(u1_end_of_row)
+    if(u4_end_of_row)
     {
 
         if(ps_dec->u1_separate_parse)
@@ -1443,12 +1443,12 @@ void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
     /*
      * The Slice boundary is also a valid condition to transfer. So recalculate
      * the Left increment, in case the number of MBs is lesser than the
-     * N MB value. u1_num_mbs will be equal to N of N MB if the entire N Mb is
+     * N MB value. u4_num_mbs will be equal to N of N MB if the entire N Mb is
      * decoded.
      */
-    ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u1_num_mbs >> u1_mbaff) - 1)
+    ps_dec->s_tran_addrecon.u2_mv_left_inc = ((WORD16)(u4_num_mbs >> u1_mbaff) - 1)
                     << (4 + u1_mbaff);
-    ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u1_num_mbs << 2) - 1
+    ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (WORD16)(u4_num_mbs << 2) - 1
                     - (u1_mbaff << 2);
 
     if(ps_dec->u1_separate_parse == 0)
@@ -1457,14 +1457,14 @@ void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
         ps_dec->ps_mv_left = ps_dec->ps_mv_cur
                         + ps_dec->s_tran_addrecon.u2_mv_left_inc;
 
-        ps_dec->ps_mv_cur += (u1_num_mbs << 4);
+        ps_dec->ps_mv_cur += (u4_num_mbs << 4);
     }
 
     /* Increment deblock parameters pointer in external memory */
 
     if(ps_dec->u1_separate_parse == 0)
     {
-        ps_dec->ps_deblk_mbn += u1_num_mbs;
+        ps_dec->ps_deblk_mbn += u4_num_mbs;
     }
 
 }
diff --git a/decoder/ih264d_mb_utils.h b/decoder/ih264d_mb_utils.h
index 25011f5..e922a44 100644
--- a/decoder/ih264d_mb_utils.h
+++ b/decoder/ih264d_mb_utils.h
@@ -283,9 +283,9 @@ void ih264d_get_mbaff_neighbours(dec_struct_t * ps_dec,
 void ih264d_update_mbaff_left_nnz(dec_struct_t * ps_dec,
                                   dec_mb_info_t * ps_cur_mb_info);
 void ih264d_transfer_mb_group_data(dec_struct_t * ps_dec,
-                                   const UWORD8 u1_num_mbs,
-                                   const UWORD8 u1_end_of_row, /* Cur n-Mb End of Row Flag */
-                                   const UWORD8 u1_end_of_row_next /* Next n-Mb End of Row Flag */
+                                   const UWORD32 u4_num_mbs,
+                                   const UWORD32 u4_end_of_row, /* Cur n-Mb End of Row Flag */
+                                   const UWORD32 u4_end_of_row_next /* Next n-Mb End of Row Flag */
                                    );
 
 void ih264d_populate_mb_info_map(dec_struct_t *ps_dec,
diff --git a/decoder/ih264d_mvpred.c b/decoder/ih264d_mvpred.c
index fb4932f..d0b2892 100644
--- a/decoder/ih264d_mvpred.c
+++ b/decoder/ih264d_mvpred.c
@@ -142,7 +142,7 @@ void ih264d_get_motion_vector_predictor(mv_pred_t * ps_result,
  */
 
 void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
-                          UWORD8 u1_sub_mb_num,
+                          UWORD32 u4_sub_mb_num,
                           mv_pred_t *ps_mv_nmb,
                           mv_pred_t *ps_mv_ntop,
                           dec_struct_t *ps_dec,
@@ -152,7 +152,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
 {
     UWORD16 u2_a_in = 0, u2_b_in = 0, u2_c_in = 0, u2_d_in = 0;
     mv_pred_t *ps_mvpred_l, *ps_mvpred_tmp;
-    UWORD8 u1_sub_mb_x = (u1_sub_mb_num & 3), uc_sub_mb_y = (u1_sub_mb_num >> 2);
+    UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_sub_mb_num >> 2);
     UWORD8 u1_is_cur_mb_fld, u1_is_left_mb_fld, u1_is_top_mb_fld;
     UWORD8 u1_is_cur_mb_top;
 
@@ -169,7 +169,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
     ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred);
 
     /* Check if the left subMb is available */
-    if(u1_sub_mb_x)
+    if(u4_sub_mb_x)
     {
         u2_a_in = 1;
         ps_mv_pred[LEFT] = (ps_mv_nmb - 1);
@@ -239,12 +239,12 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
      TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2
      */
     u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask,
-                        (u1_sub_mb_num + uc_mb_part_width - 1));
+                        (u4_sub_mb_num + uc_mb_part_width - 1));
     if(u2_c_in)
     {
         ps_mv_pred[TOP_R] = ps_mv_pred[TOP] + uc_mb_part_width;
         pu0_scale[TOP_R] = pu0_scale[TOP];
-        if((uc_sub_mb_y == 0) && ((u1_sub_mb_x + uc_mb_part_width) > 3))
+        if((uc_sub_mb_y == 0) && ((u4_sub_mb_x + uc_mb_part_width) > 3))
         {
             UWORD8 uc_isTopRtMbFld;
             uc_isTopRtMbFld = ps_cur_mb_info->ps_top_right_mb->u1_mb_fld;
@@ -259,7 +259,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
     }
     else
     {
-        u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u1_sub_mb_num);
+        u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num);
 
         /* Check if the the top left subMB is available */
         if(u2_d_in)
@@ -269,7 +269,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
             ps_mv_pred[TOP_R] = ps_mv_pred[TOP] - 1;
             pu0_scale[TOP_R] = pu0_scale[TOP];
 
-            if(u1_sub_mb_x == 0)
+            if(u4_sub_mb_x == 0)
             {
                 if((uc_sub_mb_y > 0) || ((u1_is_cur_mb_top | u1_is_cur_mb_fld) == 0))
                 {
@@ -333,7 +333,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
  */
 #if(!MVPRED_NONMBAFF)
 void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
-                              UWORD8 u1_sub_mb_num,
+                              UWORD32 u4_sub_mb_num,
                               mv_pred_t *ps_mv_nmb,
                               mv_pred_t *ps_mv_ntop,
                               dec_struct_t *ps_dec,
@@ -341,7 +341,7 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
                               dec_mb_info_t *ps_cur_mb_info)
 {
     UWORD16 u2_b_in = 0, u2_c_in = 0, u2_d_in = 0;
-    UWORD8 u1_sub_mb_x = (u1_sub_mb_num & 3), uc_sub_mb_y = (u1_sub_mb_num >> 2);
+    UWORD32 u4_sub_mb_x = (u4_sub_mb_num & 3), uc_sub_mb_y = (u4_sub_mb_num >> 2);
 
     /* Checking in the subMB exists, calculating their motion vectors to be
      used as predictors and the reference frames of those subMBs */
@@ -351,7 +351,7 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
     ps_mv_pred[TOP_R] = &(ps_dec->s_default_mv_pred);
     /* Check if the left subMb is available */
 
-    if(u1_sub_mb_x)
+    if(u4_sub_mb_x)
     {
         ps_mv_pred[LEFT] = (ps_mv_nmb - 1);
     }
@@ -387,7 +387,7 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
      TopRightSubMbIndx = TopLeftSubMbIndx + (WidthOfMbPartition - 6) / 2
      */
     u2_c_in = CHECKBIT(ps_cur_mb_info->u2_top_right_avail_mask,
-                        (u1_sub_mb_num + uc_mb_part_width - 1));
+                        (u4_sub_mb_num + uc_mb_part_width - 1));
     if(u2_c_in)
     {
         ps_mv_pred[TOP_R] = (ps_mv_ntop + uc_mb_part_width);
@@ -395,19 +395,19 @@ void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
         if(uc_sub_mb_y == 0)
         {
             /* CHANGED CODE */
-            if((u1_sub_mb_x + uc_mb_part_width) > 3)
+            if((u4_sub_mb_x + uc_mb_part_width) > 3)
                 ps_mv_pred[TOP_R] += 12;
         }
     }
     else
     {
-        u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u1_sub_mb_num);
+        u2_d_in = CHECKBIT(ps_cur_mb_info->u2_top_left_avail_mask, u4_sub_mb_num);
         /* Check if the the top left subMB is available */
         if(u2_d_in)
         {
             /* CHANGED CODE */
             ps_mv_pred[TOP_R] = (ps_mv_ntop - 1);
-            if(u1_sub_mb_x == 0)
+            if(u4_sub_mb_x == 0)
             {
                 if(uc_sub_mb_y)
                 {
@@ -460,7 +460,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
                                mv_pred_t *ps_mv_nmb,
                                mv_pred_t *ps_mv_ntop,
                                mv_pred_t *ps_mv_final_pred,
-                               UWORD8 u1_sub_mb_num,
+                               UWORD32 u4_sub_mb_num,
                                UWORD8 uc_mb_part_width,
                                UWORD8 u1_lx_start,
                                UWORD8 u1_lxend,
@@ -471,7 +471,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
     UWORD8 uc_B2, uc_lx, u1_ref_idx;
     UWORD8 u1_direct_zero_pred_flag = 0;
 
-    ih264d_non_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
+    ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
                              ps_dec, uc_mb_part_width, ps_cur_mb_info);
 
     for(uc_lx = u1_lx_start; uc_lx < u1_lxend; uc_lx++)
@@ -482,7 +482,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
         {
             case PRED_16x8:
                 /* Directional prediction for a 16x8 MB partition */
-                if(u1_sub_mb_num == 0)
+                if(u4_sub_mb_num == 0)
                 {
                     /* Calculating the MV pred for the top 16x8 block */
                     if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx)
@@ -536,7 +536,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
                 break;
             case PRED_8x16:
                 /* Directional prediction for a 8x16 MB partition */
-                if(u1_sub_mb_num == 0)
+                if(u4_sub_mb_num == 0)
                 {
                     if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
                     {
@@ -695,7 +695,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
                               mv_pred_t *ps_mv_nmb,
                               mv_pred_t *ps_mv_ntop,
                               mv_pred_t *ps_mv_final_pred,
-                              UWORD8 u1_sub_mb_num,
+                              UWORD32 u4_sub_mb_num,
                               UWORD8 uc_mb_part_width,
                               UWORD8 u1_lx_start,
                               UWORD8 u1_lxend,
@@ -707,7 +707,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
     UWORD8 u1_direct_zero_pred_flag = 0;
     UNUSED(u1_lx_start);
     UNUSED(u1_lxend);
-    ih264d_non_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
+    ih264d_non_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop,
                              ps_dec, uc_mb_part_width, ps_cur_mb_info);
 
     u1_ref_idx = ps_mv_final_pred->i1_ref_frame[0];
@@ -716,7 +716,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
     {
         case PRED_16x8:
             /* Directional prediction for a 16x8 MB partition */
-            if(u1_sub_mb_num == 0)
+            if(u4_sub_mb_num == 0)
             {
                 /* Calculating the MV pred for the top 16x8 block */
                 if(ps_mv_pred[TOP]->i1_ref_frame[0] == u1_ref_idx)
@@ -768,7 +768,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
             break;
         case PRED_8x16:
             /* Directional prediction for a 8x16 MB partition */
-            if(u1_sub_mb_num == 0)
+            if(u4_sub_mb_num == 0)
             {
                 if(ps_mv_pred[LEFT]->i1_ref_frame[0] == u1_ref_idx)
                 {
@@ -925,7 +925,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
                            mv_pred_t *ps_mv_nmb,
                            mv_pred_t *ps_mv_ntop,
                            mv_pred_t *ps_mv_final_pred,
-                           UWORD8 u1_sub_mb_num,
+                           UWORD32 u4_sub_mb_num,
                            UWORD8 uc_mb_part_width,
                            UWORD8 u1_lx_start,
                            UWORD8 u1_lxend,
@@ -937,7 +937,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
     UWORD8 u1_direct_zero_pred_flag = 0;
 
     pu0_scale[0] = pu0_scale[1] = pu0_scale[2] = 0;
-    ih264d_mbaff_mv_pred(ps_mv_pred, u1_sub_mb_num, ps_mv_nmb, ps_mv_ntop, ps_dec,
+    ih264d_mbaff_mv_pred(ps_mv_pred, u4_sub_mb_num, ps_mv_nmb, ps_mv_ntop, ps_dec,
                          uc_mb_part_width, ps_cur_mb_info, pu0_scale);
     for(i = 0; i < 3; i++)
     {
@@ -970,7 +970,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
         {
             case PRED_16x8:
                 /* Directional prediction for a 16x8 MB partition */
-                if(u1_sub_mb_num == 0)
+                if(u4_sub_mb_num == 0)
                 {
                     /* Calculating the MV pred for the top 16x8 block */
                     if(ps_mv_pred[TOP]->i1_ref_frame[uc_lx] == u1_ref_idx)
@@ -1024,7 +1024,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
                 break;
             case PRED_8x16:
                 /* Directional prediction for a 8x16 MB partition */
-                if(u1_sub_mb_num == 0)
+                if(u4_sub_mb_num == 0)
                 {
                     if(ps_mv_pred[LEFT]->i1_ref_frame[uc_lx] == u1_ref_idx)
                     {
@@ -1168,7 +1168,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
 void ih264d_rep_mv_colz(dec_struct_t *ps_dec,
                         mv_pred_t *ps_mv_pred_src,
                         mv_pred_t *ps_mv_pred_dst,
-                        UWORD8 u1_sub_mb_num,
+                        UWORD32 u4_sub_mb_num,
                         UWORD8 u1_colz,
                         UWORD8 u1_ht,
                         UWORD8 u1_wd)
@@ -1176,7 +1176,7 @@ void ih264d_rep_mv_colz(dec_struct_t *ps_dec,
 
     UWORD8 k, m;
     UWORD8 *pu1_colz = ps_dec->pu1_col_zero_flag + ps_dec->i4_submb_ofst
-                    + u1_sub_mb_num;
+                    + u4_sub_mb_num;
 
     for(k = 0; k < u1_ht; k++)
     {
diff --git a/decoder/ih264d_mvpred.h b/decoder/ih264d_mvpred.h
index 66366ca..34a8966 100644
--- a/decoder/ih264d_mvpred.h
+++ b/decoder/ih264d_mvpred.h
@@ -95,7 +95,7 @@ void ih264d_get_motion_vector_predictor(mv_pred_t * ps_result,
                                         UWORD8 u1_B,
                                         const UWORD8 *pu1_mv_pred_condition);
 void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
-                          UWORD8 u1_sub_mb_num,
+                          UWORD32 u4_sub_mb_num,
                           mv_pred_t *ps_mv_nmb,
                           mv_pred_t *ps_mv_ntop,
                           dec_struct_t *ps_dec,
@@ -103,7 +103,7 @@ void ih264d_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
                           dec_mb_info_t *ps_cur_mb_info,
                           UWORD8* pu0_scale);
 void ih264d_non_mbaff_mv_pred(mv_pred_t **ps_mv_pred,
-                              UWORD8 u1_sub_mb_num,
+                              UWORD32 u4_sub_mb_num,
                               mv_pred_t *ps_mv_nmb,
                               mv_pred_t *ps_mv_ntop,
                               dec_struct_t *ps_dec,
@@ -114,7 +114,7 @@ UWORD8 ih264d_mvpred_nonmbaff(dec_struct_t *ps_dec,
                               mv_pred_t *ps_mv_nmb,
                               mv_pred_t *ps_mv_ntop,
                               mv_pred_t *ps_mv_final_pred,
-                              UWORD8 u1_sub_mb_num,
+                              UWORD32 u4_sub_mb_num,
                               UWORD8 uc_mb_part_width,
                               UWORD8 u1_lx_start,
                               UWORD8 u1_lxend,
@@ -125,7 +125,7 @@ UWORD8 ih264d_mvpred_nonmbaffB(dec_struct_t *ps_dec,
                                mv_pred_t *ps_mv_nmb,
                                mv_pred_t *ps_mv_ntop,
                                mv_pred_t *ps_mv_final_pred,
-                               UWORD8 u1_sub_mb_num,
+                               UWORD32 u4_sub_mb_num,
                                UWORD8 uc_mb_part_width,
                                UWORD8 u1_lx_start,
                                UWORD8 u1_lxend,
@@ -136,7 +136,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
                            mv_pred_t *ps_mv_nmb,
                            mv_pred_t *ps_mv_ntop,
                            mv_pred_t *ps_mv_final_pred,
-                           UWORD8 u1_sub_mb_num,
+                           UWORD32 u4_sub_mb_num,
                            UWORD8 uc_mb_part_width,
                            UWORD8 u1_lx_start,
                            UWORD8 u1_lxend,
@@ -145,7 +145,7 @@ UWORD8 ih264d_mvpred_mbaff(dec_struct_t *ps_dec,
 void ih264d_rep_mv_colz(dec_struct_t *ps_dec,
                         mv_pred_t *ps_mv_pred_src,
                         mv_pred_t *ps_mv_pred_dst,
-                        UWORD8 u1_sub_mb_num,
+                        UWORD32 u4_sub_mb_num,
                         UWORD8 u1_colz,
                         UWORD8 u1_ht,
                         UWORD8 u1_wd);
diff --git a/decoder/ih264d_parse_bslice.c b/decoder/ih264d_parse_bslice.c
index 27f0197..fb6078d 100644
--- a/decoder/ih264d_parse_bslice.c
+++ b/decoder/ih264d_parse_bslice.c
@@ -74,8 +74,8 @@ void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
  */
 WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
                                        dec_mb_info_t * ps_cur_mb_info,
-                                       UWORD8 u1_mb_num,
-                                       UWORD8 u1_num_mbsNby2)
+                                       UWORD32 u4_mb_num,
+                                       UWORD32 u4_num_mbsNby2)
 {
     dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
     UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
@@ -88,7 +88,7 @@ WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
                     + 4;
 
     parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
-                    + u1_num_mbsNby2;
+                    + u4_num_mbsNby2;
     UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info;
     WORD8 (*pi1_ref_idx)[MAX_REFIDX_INFO_PER_MB] = ps_parse_mb_data->i1_ref_idx;
     UWORD8 u1_mb_type = ps_cur_mb_info->u1_mb_type;
@@ -241,7 +241,7 @@ WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
         const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
         UWORD8 u1_p_idx = 0, u1_num_submb_part, uc_lx;
         parse_part_params_t * ps_part;
-        mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
+        mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
         UWORD8 u1_mb_part_wd, u1_mb_part_ht;
 
         /* Initialisations */
@@ -397,15 +397,15 @@ WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
 
 WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
                                        dec_mb_info_t * ps_cur_mb_info,
-                                       UWORD8 u1_mb_num,
-                                       UWORD8 u1_num_mbsNby2)
+                                       UWORD32 u4_mb_num,
+                                       UWORD32 u4_num_mbsNby2)
 {
     /* Loads from ps_dec */
     decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env;
     dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm;
     ctxt_inc_mb_info_t *p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info;
     parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
-                    + u1_num_mbsNby2;
+                    + u4_num_mbsNby2;
 
     /* table pointer loads */
     const UWORD8 * pu1_sub_mb_pred_modes = (UWORD8 *)(gau1_ih264d_submb_pred_modes)
@@ -539,7 +539,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
         UWORD8 u1_num_submb_part;
         parse_part_params_t *ps_part;
         /* Initialisations */
-        mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
+        mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
         ps_part = ps_dec->ps_part;
 
         /* Default initialization for non subMb case */
@@ -550,7 +550,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
         /* Decoding the MV for the subMB */
         for(uc_lx = 0; uc_lx < 2; uc_lx++)
         {
-            UWORD8 u1_sub_mb_num = 0;
+            UWORD32 u4_sub_mb_num = 0;
             UWORD32 u4_mb_pred_mode_tmp = u4_mb_pred_mode;
             UWORD32 u4_mb_mc_mode_tmp = u4_mb_mc_mode;
             UWORD8 u1_mb_mc_mode_1, u1_pred_mode, uc_i;
@@ -572,7 +572,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
                 {
                     u1_mb_part_wd = pu1_sub_mb_partw[u1_mb_mc_mode_1];
                     u1_mb_part_ht = pu1_sub_mb_parth[u1_mb_mc_mode_1];
-                    u1_sub_mb_num = u2_sub_mb_num >> 12;
+                    u4_sub_mb_num = u2_sub_mb_num >> 12;
                     pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_mc_mode_1 << 1);
                     u1_num_submb_part = pu1_num_sub_mb_part[u1_mb_mc_mode_1];
                     u2_sub_mb_num = u2_sub_mb_num << 4;
@@ -582,15 +582,15 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
                                 uc_j++, pu1_top_left_sub_mb_indx++)
                 {
                     mv_pred_t *ps_mv;
-                    u1_sub_mb_num = u1_sub_mb_num + *pu1_top_left_sub_mb_indx;
-                    ps_mv = ps_mv_start + u1_sub_mb_num;
+                    u4_sub_mb_num = u4_sub_mb_num + *pu1_top_left_sub_mb_indx;
+                    ps_mv = ps_mv_start + u4_sub_mb_num;
 
                     /* Storing Info for partitions, writing only once */
                     if(uc_lx)
                     {
                         ps_part->u1_is_direct = (!i1_pred);
                         ps_part->u1_pred_mode = i1_pred;
-                        ps_part->u1_sub_mb_num = u1_sub_mb_num;
+                        ps_part->u1_sub_mb_num = u4_sub_mb_num;
                         ps_part->u1_partheight = u1_mb_part_ht;
                         ps_part->u1_partwidth = u1_mb_part_wd;
 
@@ -599,7 +599,7 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
                         ps_part++;
                     }
 
-                    ih264d_get_mvd_cabac(u1_sub_mb_num, u1_b2, u1_mb_part_wd,
+                    ih264d_get_mvd_cabac(u4_sub_mb_num, u1_b2, u1_mb_part_wd,
                                          u1_mb_part_ht,
                                          (UWORD8)(i1_pred & u1_pred_mode), ps_dec,
                                          ps_mv);
@@ -629,11 +629,11 @@ WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
  */
 WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2)
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2)
 {
     UWORD8 u1_cbp;
-    deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_mb_num;
+    deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_mb_num;
     const UWORD8 *puc_mb_mc_mode = (const UWORD8 *)gau1_ih264d_mb_mc_mode;
     UWORD8 u1_mb_type = ps_cur_mb_info->u1_mb_type;
     ctxt_inc_mb_info_t *p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info;
@@ -649,8 +649,8 @@ WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
     ps_cur_deblk_mb->u1_mb_type |= D_B_SLICE;
     if(u1_mb_type != B_DIRECT)
     {
-        ret = ih264d_parse_bmb_non_direct_cabac(ps_dec, ps_cur_mb_info, u1_mb_num,
-                                          u1_num_mbsNby2);
+        ret = ih264d_parse_bmb_non_direct_cabac(ps_dec, ps_cur_mb_info, u4_mb_num,
+                                          u4_num_mbsNby2);
         if(ret != OK)
             return ret;
     }
@@ -744,11 +744,11 @@ WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
  */
 WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2)
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2)
 {
     UWORD32 u4_cbp;
-    deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_mb_num;
+    deblk_mb_t * ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_mb_num;
     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
     UWORD32 * pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
@@ -768,8 +768,8 @@ WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
     ps_cur_deblk_mb->u1_mb_type |= D_B_SLICE;
     if(u1_mb_type != B_DIRECT)
     {
-        ret = ih264d_parse_bmb_non_direct_cavlc(ps_dec, ps_cur_mb_info, u1_mb_num,
-                                          u1_num_mbsNby2);
+        ret = ih264d_parse_bmb_non_direct_cavlc(ps_dec, ps_cur_mb_info, u4_mb_num,
+                                          u4_num_mbsNby2);
         if(ret != OK)
             return ret;
     }
@@ -883,26 +883,27 @@ WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
 }
 
 WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
-                                     UWORD8 u1_mb_idx,
-                                     UWORD8 u1_num_mbs)
+                                     UWORD32 u4_mb_idx,
+                                     UWORD32 u4_num_mbs)
 {
     parse_pmbarams_t * ps_mb_part_info;
     parse_part_params_t * ps_part;
     mv_pred_t *ps_mv_nmb, *ps_mv_nmb_start, *ps_mv_ntop, *ps_mv_ntop_start;
     pic_buffer_t * ps_ref_frame;
     UWORD8 u1_direct_mode_width;
-    UWORD8 i, j;
+    UWORD32 i;
+    UWORD8 j;
     dec_mb_info_t * ps_cur_mb_info;
     const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     UWORD8 u1_field;
     WORD32 ret = 0;
 
-    ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
+    ps_dec->i4_submb_ofst -= (WORD32)(u4_num_mbs - u4_mb_idx) << 4;
     ps_mb_part_info = ps_dec->ps_parse_mb_data;
     ps_part = ps_dec->ps_parse_part_params;
 
     /* N/2 Mb MvPred and Transfer Setup Loop */
-    for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
+    for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
     {
         UWORD8 u1_colz = 0;
         ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
@@ -919,7 +920,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
         ps_dec->u2_mv_2mb[i & 0x1] = 0;
 
         /* Look for MV Prediction and Reference Transfer in Non-I Mbs */
-        if(!ps_mb_part_info->u1_isI_mb)
+        if(!ps_mb_part_info->u4_isI_mb)
         {
             UWORD8 u1_blk_no;
             WORD16 i1_ref_idx, i1_ref_idx1;
@@ -938,7 +939,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
 
             /* MB Level initialisations */
             ps_dec->u4_num_pmbair = i >> u1_mbaff;
-            ps_dec->u1_mb_idx_mv = i;
+            ps_dec->u4_mb_idx_mv = i;
 
             /* CHANGED CODE */
             ps_mv_ntop_start = ps_mv_nmb_start
diff --git a/decoder/ih264d_parse_headers.c b/decoder/ih264d_parse_headers.c
index b013104..b9cf3ce 100644
--- a/decoder/ih264d_parse_headers.c
+++ b/decoder/ih264d_parse_headers.c
@@ -903,13 +903,13 @@ WORD32 ih264d_parse_sps(dec_struct_t *ps_dec, dec_bit_stream_t *ps_bitstrm)
     /*--------------------------------------------------------------------*/
     /* Get the value of MaxMbAddress and Number of bits needed for it     */
     /*--------------------------------------------------------------------*/
-    ps_seq->u2_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs
-                    * ps_seq->u2_frm_ht_in_mbs) - 1;
+    ps_seq->u4_max_mb_addr = ((UWORD32)ps_seq->u2_frm_wd_in_mbs
+                    * (UWORD32)ps_seq->u2_frm_ht_in_mbs) - 1;
 
-    ps_seq->u2_total_num_of_mbs = ps_seq->u2_max_mb_addr + 1;
+    ps_seq->u4_total_num_of_mbs = ps_seq->u4_max_mb_addr + 1;
 
     ps_seq->u1_level_idc = ih264d_correct_level_idc(
-                    u1_level_idc, ps_seq->u2_total_num_of_mbs);
+                    u1_level_idc, ps_seq->u4_total_num_of_mbs);
 
     u1_frm = ih264d_get_bit_h264(ps_bitstrm);
     if((ps_dec->i4_header_decoded & 1) && (ps_seq->u1_frame_mbs_only_flag != u1_frm))
@@ -1154,7 +1154,7 @@ WORD32 ih264d_parse_sps(dec_struct_t *ps_dec, dec_bit_stream_t *ps_bitstrm)
 
     ps_dec->u2_pic_wd = u2_pic_wd;
     ps_dec->u2_pic_ht = u2_pic_ht;
-    ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
+    ps_dec->u4_total_mbs = ps_seq->u4_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
 
     /* Determining the Width and Height of Frame from that of Picture */
     ps_dec->u2_frm_wd_y = u2_frm_wd_y;
diff --git a/decoder/ih264d_parse_islice.c b/decoder/ih264d_parse_islice.c
index 21e3798..dbeedd1 100644
--- a/decoder/ih264d_parse_islice.c
+++ b/decoder/ih264d_parse_islice.c
@@ -87,7 +87,7 @@ void ih264d_itrans_recon_luma_dc(dec_struct_t *ps_dec,
  */
 WORD32 ih264d_parse_imb_cavlc(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
+                              UWORD32 u4_mb_num,
                               UWORD8 u1_mb_type)
 {
     WORD32 i4_delta_qp;
@@ -101,7 +101,7 @@ WORD32 ih264d_parse_imb_cavlc(dec_struct_t * ps_dec,
 
     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
-    UNUSED(u1_mb_num);
+    UNUSED(u4_mb_num);
     ps_cur_mb_info->u1_tran_form8x8 = 0;
     ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0;
 
@@ -756,16 +756,16 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
                                       UWORD16 u2_first_mb_in_slice)
 {
     UWORD8 uc_more_data_flag;
-    UWORD8 u1_num_mbs, u1_mb_idx;
+    UWORD32 u4_num_mbs, u4_mb_idx;
     dec_mb_info_t *ps_cur_mb_info;
     deblk_mb_t *ps_cur_deblk_mb;
     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
     UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer;
     UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
-    WORD16 i2_cur_mb_addr;
+    WORD32 i4_cur_mb_addr;
     UWORD8 u1_mbaff;
-    UWORD8 u1_num_mbs_next, u1_end_of_row, u1_tfr_n_mb;
+    UWORD32 u4_num_mbs_next, u4_end_of_row, u4_tfr_n_mb;
     WORD32 ret = OK;
 
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
@@ -773,11 +773,11 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
 
     /* initializations */
-    u1_mb_idx = ps_dec->u1_mb_idx;
-    u1_num_mbs = u1_mb_idx;
+    u4_mb_idx = ps_dec->u4_mb_idx;
+    u4_num_mbs = u4_mb_idx;
 
     uc_more_data_flag = 1;
-    i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
+    i4_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
 
     do
     {
@@ -785,14 +785,14 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
 
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i4_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
 
-        ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
-        ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
-        ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
+        ps_cur_mb_info = ps_dec->ps_nmb_info + u4_num_mbs;
+        ps_dec->u4_num_mbs_cur_nmb = u4_num_mbs;
+        ps_dec->u4_num_pmbair = (u4_num_mbs >> u1_mbaff);
 
         ps_cur_mb_info->u1_end_of_slice = 0;
 
@@ -800,12 +800,12 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
         /* Get the required information for decoding of MB             */
         /* mb_x, mb_y , neighbour availablity,                         */
         /***************************************************************/
-        ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 0);
+        ps_dec->pf_get_mb_info(ps_dec, i4_cur_mb_addr, ps_cur_mb_info, 0);
 
         /***************************************************************/
         /* Set the deblocking parameters for this MB                   */
         /***************************************************************/
-        ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
+        ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_num_mbs;
 
         if(ps_dec->u4_app_disable_deblk_frm == 0)
             ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice,
@@ -852,14 +852,14 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
         {
             /* I_PCM_MB */
             ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
-            ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
+            ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u4_num_mbs);
             if(ret != OK)
                 return ret;
             ps_cur_deblk_mb->u1_mb_qp = 0;
         }
         else
         {
-            ret = ih264d_parse_imb_cavlc(ps_dec, ps_cur_mb_info, u1_num_mbs, u1_mb_type);
+            ret = ih264d_parse_imb_cavlc(ps_dec, ps_cur_mb_info, u4_num_mbs, u1_mb_type);
             if(ret != OK)
                 return ret;
             ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp;
@@ -876,7 +876,7 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
         if(u1_mbaff)
         {
             ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info);
-            if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
+            if(!uc_more_data_flag && (0 == (i4_cur_mb_addr & 1)))
             {
                 return ERROR_EOB_FLUSHBITS_T;
             }
@@ -885,12 +885,12 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
         /* Get next Macroblock address                                */
         /**************************************************************/
 
-        i2_cur_mb_addr++;
+        i4_cur_mb_addr++;
 
 
         /* Store the colocated information */
         {
-            mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_num_mbs << 4);
+            mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u4_num_mbs << 4);
 
             mv_pred_t s_mvPred =
                 {
@@ -906,50 +906,50 @@ WORD32 ih264d_parse_islice_data_cavlc(dec_struct_t * ps_dec,
         {
             if(ps_dec->u4_app_disable_deblk_frm == 0)
                 ps_dec->pf_compute_bs(ps_dec, ps_cur_mb_info,
-                                     (UWORD16)(u1_num_mbs >> u1_mbaff));
+                                     (UWORD16)(u4_num_mbs >> u1_mbaff));
         }
-        u1_num_mbs++;
+        u4_num_mbs++;
 
         /****************************************************************/
         /* Check for End Of Row                                         */
         /****************************************************************/
-        u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
-        u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
+        u4_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
+        u4_end_of_row = (!u4_num_mbs_next) && (!(u1_mbaff && (u4_num_mbs & 0x01)));
+        u4_tfr_n_mb = (u4_num_mbs == ps_dec->u4_recon_mb_grp) || u4_end_of_row
                         || (!uc_more_data_flag);
         ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
 
         /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d",
          ps_slice->i4_poc >> ps_slice->u1_field_pic_flag,
          ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb));
-         H264_DEC_DEBUG_PRINT("u1_tfr_n_mb || (!uc_more_data_flag): %d", u1_tfr_n_mb || (!uc_more_data_flag));*/
-        if(u1_tfr_n_mb || (!uc_more_data_flag))
+         H264_DEC_DEBUG_PRINT("u4_tfr_n_mb || (!uc_more_data_flag): %d", u4_tfr_n_mb || (!uc_more_data_flag));*/
+        if(u4_tfr_n_mb || (!uc_more_data_flag))
         {
 
             if(ps_dec->u1_separate_parse)
             {
-                ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
-                                     u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
-                ps_dec->ps_nmb_info +=  u1_num_mbs;
+                ih264d_parse_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
+                                     u4_num_mbs_next, u4_tfr_n_mb, u4_end_of_row);
+                ps_dec->ps_nmb_info +=  u4_num_mbs;
             }
             else
             {
-                ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
-                                            u1_num_mbs_next, u1_tfr_n_mb,
-                                            u1_end_of_row);
+                ih264d_decode_recon_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
+                                            u4_num_mbs_next, u4_tfr_n_mb,
+                                            u4_end_of_row);
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
-            if(u1_tfr_n_mb)
-                u1_num_mbs = 0;
-            u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u4_num_mbs;
+            if(u4_tfr_n_mb)
+                u4_num_mbs = 0;
+            u4_mb_idx = u4_num_mbs;
+            ps_dec->u4_mb_idx = u4_num_mbs;
 
         }
     }
     while(uc_more_data_flag);
 
     ps_dec->u4_num_mbs_cur_nmb = 0;
-    ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
+    ps_dec->ps_cur_slice->u4_mbs_in_slice = i4_cur_mb_addr
 
                         - (u2_first_mb_in_slice << u1_mbaff);
 
@@ -985,15 +985,15 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
                                       UWORD16 u2_first_mb_in_slice)
 {
     UWORD8 uc_more_data_flag;
-    UWORD8 u1_num_mbs, u1_mb_idx;
+    UWORD32 u4_num_mbs, u4_mb_idx;
     dec_mb_info_t *ps_cur_mb_info;
     deblk_mb_t *ps_cur_deblk_mb;
 
     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
     UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
-    WORD16 i2_cur_mb_addr;
+    WORD32 i4_cur_mb_addr;
     UWORD8 u1_mbaff;
-    UWORD8 u1_num_mbs_next, u1_end_of_row, u1_tfr_n_mb;
+    UWORD32 u4_num_mbs_next, u4_end_of_row, u4_tfr_n_mb;
     WORD32 ret = OK;
 
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
@@ -1013,18 +1013,18 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
     ps_dec->i1_prev_mb_qp_delta = 0;
 
     /* initializations */
-    u1_mb_idx = ps_dec->u1_mb_idx;
-    u1_num_mbs = u1_mb_idx;
+    u4_mb_idx = ps_dec->u4_mb_idx;
+    u4_num_mbs = u4_mb_idx;
 
     uc_more_data_flag = 1;
-    i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
+    i4_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
     do
     {
         UWORD16 u2_mbx;
 
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i4_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -1032,9 +1032,9 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
         {
             UWORD8 u1_mb_type;
 
-            ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
-            ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs;
-            ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff);
+            ps_cur_mb_info = ps_dec->ps_nmb_info + u4_num_mbs;
+            ps_dec->u4_num_mbs_cur_nmb = u4_num_mbs;
+            ps_dec->u4_num_pmbair = (u4_num_mbs >> u1_mbaff);
 
             ps_cur_mb_info->u1_end_of_slice = 0;
 
@@ -1042,7 +1042,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
             /* Get the required information for decoding of MB                  */
             /* mb_x, mb_y , neighbour availablity,                              */
             /***************************************************************/
-            ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 0);
+            ps_dec->pf_get_mb_info(ps_dec, i4_cur_mb_addr, ps_cur_mb_info, 0);
             u2_mbx = ps_dec->u2_mbx;
 
             /*********************************************************************/
@@ -1054,7 +1054,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
             /***************************************************************/
             /* Set the deblocking parameters for this MB                   */
             /***************************************************************/
-            ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs;
+            ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u4_num_mbs;
             if(ps_dec->u4_app_disable_deblk_frm == 0)
                 ih264d_set_deblocking_parameters(
                                 ps_cur_deblk_mb, ps_slice,
@@ -1077,7 +1077,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
             {
                 /* I_PCM_MB */
                 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB;
-                ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs);
+                ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u4_num_mbs);
                 if(ret != OK)
                     return ret;
                 ps_cur_deblk_mb->u1_mb_qp = 0;
@@ -1114,17 +1114,17 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
 
             if(u1_mbaff)
             {
-                if(!uc_more_data_flag && (0 == (i2_cur_mb_addr & 1)))
+                if(!uc_more_data_flag && (0 == (i4_cur_mb_addr & 1)))
                 {
                     return ERROR_EOB_FLUSHBITS_T;
                 }
             }
             /* Next macroblock information */
-            i2_cur_mb_addr++;
+            i4_cur_mb_addr++;
             /* Store the colocated information */
             {
 
-                mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_num_mbs << 4);
+                mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u4_num_mbs << 4);
                 mv_pred_t s_mvPred =
                     {
                         { 0, 0, 0, 0 },
@@ -1139,49 +1139,49 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
             {
                 if(ps_dec->u4_app_disable_deblk_frm == 0)
                     ps_dec->pf_compute_bs(ps_dec, ps_cur_mb_info,
-                                         (UWORD16)(u1_num_mbs >> u1_mbaff));
+                                         (UWORD16)(u4_num_mbs >> u1_mbaff));
             }
-            u1_num_mbs++;
+            u4_num_mbs++;
 
         }
 
         /****************************************************************/
         /* Check for End Of Row                                         */
         /****************************************************************/
-        u1_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
-        u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
+        u4_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
+        u4_end_of_row = (!u4_num_mbs_next) && (!(u1_mbaff && (u4_num_mbs & 0x01)));
+        u4_tfr_n_mb = (u4_num_mbs == ps_dec->u4_recon_mb_grp) || u4_end_of_row
                         || (!uc_more_data_flag);
         ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
 
-        if(u1_tfr_n_mb || (!uc_more_data_flag))
+        if(u4_tfr_n_mb || (!uc_more_data_flag))
         {
 
 
             if(ps_dec->u1_separate_parse)
             {
-                ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
-                                     u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
-                ps_dec->ps_nmb_info +=  u1_num_mbs;
+                ih264d_parse_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
+                                     u4_num_mbs_next, u4_tfr_n_mb, u4_end_of_row);
+                ps_dec->ps_nmb_info +=  u4_num_mbs;
             }
             else
             {
-                ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
-                                            u1_num_mbs_next, u1_tfr_n_mb,
-                                            u1_end_of_row);
+                ih264d_decode_recon_tfr_nmb(ps_dec, u4_mb_idx, u4_num_mbs,
+                                            u4_num_mbs_next, u4_tfr_n_mb,
+                                            u4_end_of_row);
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
-            if(u1_tfr_n_mb)
-                u1_num_mbs = 0;
-            u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u4_num_mbs;
+            if(u4_tfr_n_mb)
+                u4_num_mbs = 0;
+            u4_mb_idx = u4_num_mbs;
+            ps_dec->u4_mb_idx = u4_num_mbs;
 
         }
     }
     while(uc_more_data_flag);
 
     ps_dec->u4_num_mbs_cur_nmb = 0;
-    ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr
+    ps_dec->ps_cur_slice->u4_mbs_in_slice = i4_cur_mb_addr
 
                         - (u2_first_mb_in_slice << u1_mbaff);
 
@@ -1211,7 +1211,7 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
 
 WORD32 ih264d_parse_ipcm_mb(dec_struct_t * ps_dec,
                           dec_mb_info_t *ps_cur_mb_info,
-                          UWORD8 u1_mbNum)
+                          UWORD32 u4_mbNum)
 {
     dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm;
     UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
@@ -1263,7 +1263,7 @@ WORD32 ih264d_parse_ipcm_mb(dec_struct_t * ps_dec,
 
     ps_dec->i1_prev_mb_qp_delta = 0;
     /* Get neighbour MB's */
-    u1_num_mb_pair = (u1_mbNum >> u1_mbaff);
+    u1_num_mb_pair = (u4_mbNum >> u1_mbaff);
 
     /*****************************************************************************/
     /* calculate the RECON buffer YUV pointers for the PCM data                  */
diff --git a/decoder/ih264d_parse_islice.h b/decoder/ih264d_parse_islice.h
index 6a43d7b..5edad5b 100644
--- a/decoder/ih264d_parse_islice.h
+++ b/decoder/ih264d_parse_islice.h
@@ -50,7 +50,7 @@ WORD32 ih264d_parse_residual4x4_cabac(dec_struct_t * ps_dec,
                                       UWORD8 u1_offset);
 WORD32 ih264d_parse_imb_cavlc(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
+                              UWORD32 u4_mb_num,
                               UWORD8 u1_mb_type);
 WORD32 ih264d_parse_imb_cabac(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
@@ -64,32 +64,32 @@ WORD32 ih264d_parse_islice_data_cabac(dec_struct_t * ps_dec,
                                       UWORD16 u2_first_mb_in_slice);
 WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2);
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2);
 WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2);
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2);
 
 WORD32 ih264d_parse_bmb_non_direct_cavlc(dec_struct_t * ps_dec,
                                        dec_mb_info_t * ps_cur_mb_info,
-                                       UWORD8 u1_mb_num,
-                                       UWORD8 u1_mbNumModNBy2);
+                                       UWORD32 u4_mb_num,
+                                       UWORD32 u4_mbNumModNBy2);
 
 WORD32 ih264d_parse_bmb_non_direct_cabac(dec_struct_t * ps_dec,
                                        dec_mb_info_t * ps_cur_mb_info,
-                                       UWORD8 u1_mb_num,
-                                       UWORD8 u1_mbNumModNBy2);
+                                       UWORD32 u4_mb_num,
+                                       UWORD32 u4_mbNumModNBy2);
 
 WORD32 ih264d_parse_bmb_cavlc(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2);
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2);
 
 WORD32 ih264d_parse_bmb_cabac(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2);
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2);
 
 WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
                                            dec_slice_params_t * ps_slice,
@@ -101,12 +101,12 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
 
 WORD32 ParseBMb(dec_struct_t * ps_dec,
                 dec_mb_info_t * ps_cur_mb_info,
-                UWORD8 u1_mb_num,
-                UWORD8 u1_num_mbsNby2);
+                UWORD32 u4_mb_num,
+                UWORD32 u4_num_mbsNby2);
 
 WORD32 ih264d_parse_ipcm_mb(dec_struct_t * ps_dec,
                             dec_mb_info_t *ps_cur_mb_info,
-                            UWORD8 u1_mbNum);
+                            UWORD32 u4_mbNum);
 WORD32 ih264d_parse_islice(dec_struct_t *ps_dec,
                             UWORD16 u2_first_mb_in_slice);
 
diff --git a/decoder/ih264d_parse_mb_header.c b/decoder/ih264d_parse_mb_header.c
index 9a6a1f9..95a212e 100644
--- a/decoder/ih264d_parse_mb_header.c
+++ b/decoder/ih264d_parse_mb_header.c
@@ -1308,7 +1308,7 @@ WORD16 ih264d_parse_mvd_cabac(dec_bit_stream_t * ps_bitstrm,
     {
         /* Read Suffix */
         k = ih264d_decode_bypass_bins_unary(ps_cab_env, ps_bitstrm);
-        i2_suf = (1 << k) - 1;
+        i2_suf = (k > 15) ? INT16_MAX : ((1 << k) - 1);
         k = k + 3;
         i2_suf = (i2_suf << 3);
         i2_mvd += i2_suf;
diff --git a/decoder/ih264d_parse_pslice.c b/decoder/ih264d_parse_pslice.c
index e97d09b..fa6c76b 100644
--- a/decoder/ih264d_parse_pslice.c
+++ b/decoder/ih264d_parse_pslice.c
@@ -82,8 +82,8 @@ void ih264d_deblock_mb_level(dec_struct_t *ps_dec,
  */
 WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2)
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2)
 {
     UWORD32 u1_num_mb_part;
     UWORD32 uc_sub_mb;
@@ -92,7 +92,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
     UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst;
 
     parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
-                    + u1_num_mbsNby2;
+                    + u4_num_mbsNby2;
     WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
     const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
@@ -202,7 +202,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
         else
         {
             /* When there exists only a single frame to predict from */
-            UWORD8 uc_i;
+            UWORD32 uc_i;
             for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++)
                 /* Storing Reference Idx Information */
                 pi1_ref_idx[uc_i] = 0;
@@ -210,12 +210,13 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
     }
 
     {
-        UWORD8 u1_p_idx, uc_i;
+        UWORD8 u1_p_idx;
+        UWORD32 uc_i;
         parse_part_params_t * ps_part = ps_dec->ps_part;
         UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
-        UWORD8 u1_sub_mb_num;
+        UWORD32 u4_sub_mb_num;
         const UWORD8 * pu1_top_left_sub_mb_indx;
-        mv_pred_t * ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
+        mv_pred_t * ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
         /* Loading the table pointers */
         const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw;
         const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth;
@@ -238,7 +239,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
         u1_mb_part_width = pu1_mb_partw[u1_mb_type];
         u1_mb_part_height = pu1_mb_parth[u1_mb_type];
         pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
-        u1_sub_mb_num = 0;
+        u4_sub_mb_num = 0;
 
         /* Loop on number of partitions */
         for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
@@ -251,7 +252,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
                 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
                 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
                 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
-                u1_sub_mb_num = u2_sub_mb_num >> 12;
+                u4_sub_mb_num = u2_sub_mb_num >> 12;
                 u4_sum_mb_mode_pack <<= 8;
                 u2_sub_mb_num <<= 4;
             }
@@ -260,8 +261,8 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
             for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++)
             {
                 WORD16 i2_mvx, i2_mvy;
-                u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
-                ps_mv = ps_mv_start + u1_sub_mb_num;
+                u4_sub_mb_num += *pu1_top_left_sub_mb_indx;
+                ps_mv = ps_mv_start + u4_sub_mb_num;
 
                 /* Reading the differential Mv from the bitstream */
                 //i2_mvx = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf);
@@ -302,7 +303,7 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
 
                 /* Storing Info for partitions */
                 ps_part->u1_is_direct = PART_NOT_DIRECT;
-                ps_part->u1_sub_mb_num = u1_sub_mb_num;
+                ps_part->u1_sub_mb_num = u4_sub_mb_num;
                 ps_part->u1_partheight = u1_mb_part_height;
                 ps_part->u1_partwidth = u1_mb_part_width;
 
@@ -430,13 +431,13 @@ WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec,
  */
 WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
                               dec_mb_info_t * ps_cur_mb_info,
-                              UWORD8 u1_mb_num,
-                              UWORD8 u1_num_mbsNby2)
+                              UWORD32 u4_mb_num,
+                              UWORD32 u4_num_mbsNby2)
 {
     UWORD32 u1_num_mb_part;
     UWORD32 uc_sub_mb;
     parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data
-                    + u1_num_mbsNby2;
+                    + u4_num_mbsNby2;
     WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0];
     const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part;
     const UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type;
@@ -584,12 +585,13 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
     }
 
     {
-        UWORD8 u1_p_idx, uc_i;
+        UWORD8 u1_p_idx;
+        UWORD32 uc_i;
         parse_part_params_t * ps_part = ps_dec->ps_part;
         UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height;
-        UWORD8 u1_sub_mb_num;
+        UWORD32 u4_sub_mb_num;
         const UWORD8 * pu1_top_left_sub_mb_indx;
-        mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
+        mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
         UWORD16 u2_sub_mb_num_pack = 0x028A;
 
         /* Loading the table pointers */
@@ -612,7 +614,7 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
         u1_mb_part_width = pu1_mb_partw[u1_mb_type];
         u1_mb_part_height = pu1_mb_parth[u1_mb_type];
         pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1);
-        u1_sub_mb_num = 0;
+        u4_sub_mb_num = 0;
 
         /* Loop on number of partitions */
         for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++)
@@ -625,7 +627,7 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
                 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode];
                 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode];
                 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1);
-                u1_sub_mb_num = u2_sub_mb_num_pack >> 12;
+                u4_sub_mb_num = u2_sub_mb_num_pack >> 12;
                 u4_sub_mb_pack <<= 8;
                 u2_sub_mb_num_pack <<= 4;
             }
@@ -634,12 +636,12 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
             {
                 mv_pred_t * ps_mv;
 
-                u1_sub_mb_num += *pu1_top_left_sub_mb_indx;
-                ps_mv = ps_mv_start + u1_sub_mb_num;
+                u4_sub_mb_num += *pu1_top_left_sub_mb_indx;
+                ps_mv = ps_mv_start + u4_sub_mb_num;
 
                 /* Storing Info for partitions */
                 ps_part->u1_is_direct = PART_NOT_DIRECT;
-                ps_part->u1_sub_mb_num = u1_sub_mb_num;
+                ps_part->u1_sub_mb_num = u4_sub_mb_num;
                 ps_part->u1_partheight = u1_mb_part_height;
                 ps_part->u1_partwidth = u1_mb_part_width;
 
@@ -647,7 +649,7 @@ WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec,
                 u1_p_idx++;
                 ps_part++;
 
-                ih264d_get_mvd_cabac(u1_sub_mb_num, 0, u1_mb_part_width,
+                ih264d_get_mvd_cabac(u4_sub_mb_num, 0, u1_mb_part_width,
                                      u1_mb_part_height, 1, ps_dec, ps_mv);
             }
         }
@@ -848,7 +850,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
     i2_cur_mb_addr = u2_first_mb_in_slice;
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
     u1_num_mbsNby2 = 0;
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@@ -875,7 +877,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
 
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -891,7 +893,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         /***************************************************************/
         /* Get the required information for decoding of MB             */
@@ -972,7 +974,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
             {
                 /* Storing Intra partition info */
                 ps_parse_mb_data->u1_num_part = 0;
-                ps_parse_mb_data->u1_isI_mb = 1;
+                ps_parse_mb_data->u4_isI_mb = 1;
 
                 if((25 + u1_mb_threshold) == u1_mb_type)
                 {
@@ -1046,7 +1048,7 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = !uc_more_data_flag;
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row
                         || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@@ -1085,11 +1087,11 @@ WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec,
                                             u1_num_mbs_next, u1_tfr_n_mb,
                                             u1_end_of_row);
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb)
                 u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
 
         }
     }
@@ -1178,7 +1180,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
     /******************************************************/
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
 
     u1_num_mbsNby2 = 0;
@@ -1194,7 +1196,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
 
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -1211,7 +1213,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         if((!i2_mb_skip_run) && (!u1_read_mb_type))
         {
@@ -1334,7 +1336,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
             {
                 /* Storing Intra partition info */
                 ps_parse_mb_data->u1_num_part = 0;
-                ps_parse_mb_data->u1_isI_mb = 1;
+                ps_parse_mb_data->u4_isI_mb = 1;
 
                 if((25 + u1_mb_threshold) == u1_mb_type)
                 {
@@ -1391,7 +1393,7 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row
                         || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@@ -1432,11 +1434,11 @@ WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec,
                                             u1_num_mbs_next, u1_tfr_n_mb,
                                             u1_end_of_row);
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb)
                 u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
 
         }
 //ps_dec->ps_pred++;
@@ -1459,7 +1461,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
 {
     WORD32 i2_cur_mb_addr;
     UWORD32 u1_num_mbs, u1_num_mbsNby2;
-    UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
+    UWORD32 u1_mb_idx = ps_dec->u4_mb_idx;
     UWORD32 i2_mb_skip_run;
 
     UWORD32 u1_num_mbs_next, u1_end_of_row;
@@ -1634,7 +1636,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
             if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
             {
                 ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
-                ps_dec->u2_cur_mb_addr--;
+                ps_dec->u4_cur_mb_addr--;
             }
 
             u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
@@ -1665,7 +1667,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
             {
                 // Going back 1 mb
                 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
-                ps_dec->u2_cur_mb_addr--;
+                ps_dec->u4_cur_mb_addr--;
                 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
 
                 // Parse/decode N-MB left unparsed
@@ -1694,12 +1696,12 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
                     ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs,
                             u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row);
                 }
-                ps_dec->u2_total_mbs_coded += u1_num_mbs;
-                ps_dec->u1_mb_idx = 0;
+                ps_dec->u4_total_mbs_coded += u1_num_mbs;
+                ps_dec->u4_mb_idx = 0;
                 ps_dec->u4_num_mbs_cur_nmb = 0;
             }
 
-            if(ps_dec->u2_total_mbs_coded
+            if(ps_dec->u4_total_mbs_coded
                     >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
             {
                 ps_dec->u1_pic_decode_done = 1;
@@ -1708,7 +1710,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
 
             /* Inserting new slice only if the current slice has atleast 1 MB*/
             if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
-                    (UWORD32)(ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
+                    (UWORD32)(ps_dec->u4_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
             {
                 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
                 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
@@ -1750,14 +1752,14 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
         ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf;
     }
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
-    ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
+    ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
     ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
     ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
 
     if(ps_dec->ps_cur_slice->u1_field_pic_flag)
         ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
 
-    ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
+    ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
     ps_dec->ps_parse_cur_slice->u2_log2Y_crwd =    ps_dec->ps_cur_slice->u2_log2Y_crwd;
 
 
@@ -1792,7 +1794,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
     ps_dec->u1_slice_header_done = 2;
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     ps_parse_mb_data = ps_dec->ps_parse_mb_data;
     u1_num_mbs = u1_mb_idx;
 
@@ -1800,14 +1802,14 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
     u1_tfr_n_mb = 0;
     u1_decode_nmb = 0;
     u1_num_mbsNby2 = 0;
-    i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
+    i2_cur_mb_addr = ps_dec->u4_total_mbs_coded;
     i2_mb_skip_run = num_mb_skip;
 
     while(!u1_slice_end)
     {
         UWORD8 u1_mb_type;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
             break;
 
         ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
@@ -1821,7 +1823,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         /**************************************************************/
         /* Get the required information for decoding of MB            */
@@ -1885,7 +1887,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = !i2_mb_skip_run;
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row
                         || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
@@ -1909,11 +1911,11 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
                 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
                                             u1_tfr_n_mb, u1_end_of_row);
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb)
                 u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     }
 
@@ -1934,7 +1936,7 @@ WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec,
     ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
     ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
 
-    if(ps_dec->u2_total_mbs_coded
+    if(ps_dec->u4_total_mbs_coded
             >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
     {
         ps_dec->u1_pic_decode_done = 1;
diff --git a/decoder/ih264d_parse_slice.c b/decoder/ih264d_parse_slice.c
index 5fe1b4e..ae7e711 100644
--- a/decoder/ih264d_parse_slice.c
+++ b/decoder/ih264d_parse_slice.c
@@ -566,10 +566,10 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
     ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
     /* CHANGED CODE */
     ps_dec->u1_mv_top_p = 0;
-    ps_dec->u1_mb_idx = 0;
+    ps_dec->u4_mb_idx = 0;
     /* CHANGED CODE */
     ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
-    ps_dec->u2_total_mbs_coded = 0;
+    ps_dec->u4_total_mbs_coded = 0;
     ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE);
     ps_dec->u4_pred_info_idx = 0;
     ps_dec->u4_pred_info_pkd_idx = 0;
@@ -627,13 +627,13 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
 
         UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag;
 
-        UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4)
-                        % (ps_dec->u1_recon_mb_grp >> u1_mbaff));
+        UWORD16 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4)
+                        % (ps_dec->u4_recon_mb_grp >> u1_mbaff));
         UWORD16 ui16_lastmbs_widthY =
-                        (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp
+                        (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u4_recon_mb_grp
                                         >> u1_mbaff) << 4));
         UWORD16 ui16_lastmbs_widthUV =
-                        uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp
+                        uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u4_recon_mb_grp
                                         >> u1_mbaff) << 3);
 
         ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@@ -652,9 +652,9 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
         }
 
         /* Normal Increment of Pointer */
-        ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4)
+        ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u4_recon_mb_grp << 4)
                         >> u1_mbaff);
-        ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4)
+        ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u4_recon_mb_grp << 4)
                         >> u1_mbaff);
 
         /* End of Row Increment */
@@ -670,9 +670,9 @@ WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec,
         /* Assign picture numbers to each frame/field  */
         /* only once per picture.                      */
         ih264d_assign_pic_num(ps_dec);
-        ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (ps_dec->u1_recon_mb_grp
+        ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (ps_dec->u4_recon_mb_grp
                         << 2) - 1 - (u1_mbaff << 2);
-        ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp
+        ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u4_recon_mb_grp
                         >> u1_mbaff) - 1) << (4 + u1_mbaff);
     }
     /**********************************************************************/
@@ -765,8 +765,8 @@ WORD32 ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec)
                             || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL))
             {
                 ps_dec->ps_cur_pic->i4_poc = 0;
-                if(ps_dec->u2_total_mbs_coded
-                                == (ps_dec->ps_cur_sps->u2_max_mb_addr + 1))
+                if(ps_dec->u4_total_mbs_coded
+                                == (ps_dec->ps_cur_sps->u4_max_mb_addr + 1))
                     ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr);
                 ih264d_release_display_bufs(ps_dec);
             }
@@ -1081,7 +1081,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
 
     WORD32 ret, end_of_frame;
     WORD32 prev_slice_err, num_mb_skipped;
-    UWORD8 u1_mbaff;
+    UWORD32 u4_mbaff;
     pocstruct_t *ps_cur_poc;
 
     UWORD32 u4_temp;
@@ -1101,7 +1101,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
 
     /*we currently don not support ASO*/
     if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag)
-                    <= ps_dec->u2_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0))
+                    <= ps_dec->u4_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0))
     {
         return ERROR_CORRUPTED_SLICE;
     }
@@ -1184,7 +1184,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
             ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
         }
 
-        ps_dec->u2_total_mbs_coded = 0;
+        ps_dec->u4_total_mbs_coded = 0;
     }
     /* Get the field related flags  */
     if(!ps_seq->u1_frame_mbs_only_flag)
@@ -1305,7 +1305,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
     /* Check for error in slice and parse the missing/corrupted MB's      */
     /* as skip-MB's in an inserted P-slice                                */
     /*--------------------------------------------------------------------*/
-    u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
+    u4_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag);
     prev_slice_err = 0;
 
     if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
@@ -1338,7 +1338,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
                 ps_cur_slice->u1_bottom_field_flag = 0;
 
             num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
-                    - ps_dec->u2_total_mbs_coded;
+                    - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &ps_dec->s_cur_pic_poc;
 
             u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
@@ -1349,7 +1349,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
             {
                 // first slice - missing/header corruption
                 prev_slice_err = 1;
-                num_mb_skipped = u2_first_mb_in_slice << u1_mbaff;
+                num_mb_skipped = u2_first_mb_in_slice << u4_mbaff;
                 ps_cur_poc = &s_tmp_poc;
 
                 // initializing slice parameters
@@ -1373,21 +1373,21 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
             prev_slice_err = 2;
             num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs
                             * ps_dec->u2_frm_wd_in_mbs)
-                            - ps_dec->u2_total_mbs_coded;
+                            - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &s_tmp_poc;
         }
     }
     else
     {
-        if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
+        if((u2_first_mb_in_slice << u4_mbaff) > ps_dec->u4_total_mbs_coded)
         {
             // previous slice - missing/corruption
             prev_slice_err = 2;
-            num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff)
-                    - ps_dec->u2_total_mbs_coded;
+            num_mb_skipped = (u2_first_mb_in_slice << u4_mbaff)
+                    - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &s_tmp_poc;
         }
-        else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
+        else if((u2_first_mb_in_slice << u4_mbaff) < ps_dec->u4_total_mbs_coded)
         {
             return ERROR_CORRUPTED_SLICE;
         }
@@ -1411,7 +1411,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
             return ERROR_INCOMPLETE_FRAME;
         }
 
-        if(ps_dec->u2_total_mbs_coded
+        if(ps_dec->u4_total_mbs_coded
                 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
         {
             /* return if all MBs in frame are parsed*/
@@ -1501,7 +1501,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
     /* Increment only if the current slice has atleast 1 more MB */
     if (ps_dec->u4_first_slice_in_pic == 0 &&
         (ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
-        (UWORD32)(ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
+        (UWORD32)(ps_dec->u4_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
     {
         ps_dec->ps_parse_cur_slice++;
         ps_dec->u2_cur_slice_num++;
@@ -1791,7 +1791,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
                                         + (u2_first_mb_in_slice << u1_mb_aff);
                 }
 
-                ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
+                ps_dec->u4_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
 
                 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv
                                 + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
@@ -1813,7 +1813,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
             u2_mb_x = 0xffff;
             u2_mb_y = 0;
             // assign the deblock structure pointers to start of slice
-            ps_dec->u2_cur_mb_addr = 0;
+            ps_dec->u4_cur_mb_addr = 0;
             ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
             ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
             ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@@ -1938,7 +1938,7 @@ WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice,
 
     /* End of Picture detection */
 
-    if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
+    if(ps_dec->u4_total_mbs_coded >= (ps_seq->u4_max_mb_addr + 1))
     {
         ps_dec->u1_pic_decode_done = 1;
 
diff --git a/decoder/ih264d_process_bslice.c b/decoder/ih264d_process_bslice.c
index fffa586..de9e156 100644
--- a/decoder/ih264d_process_bslice.c
+++ b/decoder/ih264d_process_bslice.c
@@ -71,13 +71,14 @@ void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec);
 WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                                     UWORD8 u1_wd_x,
                                     dec_mb_info_t * ps_cur_mb_info,
-                                    UWORD8 u1_mb_num)
+                                    UWORD32 u4_mb_num)
 {
     mv_pred_t s_mv_pred, *ps_mv;
-    UWORD8 u1_col_zero_flag, u1_sub_mb_num, u1_direct_zero_pred_flag = 0;
+    UWORD32 u4_sub_mb_num;
+    UWORD8 u1_col_zero_flag, u1_direct_zero_pred_flag = 0;
     UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     mv_pred_t *ps_mv_ntop_start;
-    mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u1_mb_num << 4);
+    mv_pred_t *ps_mv_nmb_start = ps_dec->ps_mv_cur + (u4_mb_num << 4);
     UWORD8 partition_size, sub_partition, u1_mb_partw, u1_mb_parth;
     UWORD8 i;
     WORD8 i1_pred, i1_ref_frame0, i1_ref_frame1;
@@ -104,7 +105,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
     WORD32 ret = 0;
 
     /* CHANGED CODE */
-    ps_mv_ntop_start = ps_dec->ps_mv_cur + (u1_mb_num << 4)
+    ps_mv_ntop_start = ps_dec->ps_mv_cur + (u4_mb_num << 4)
                     - (ps_dec->u2_frm_wd_in_mbs << (4 + u1_mbaff)) + 12;
 
     /* assign default values for MotionVector as zero */
@@ -251,7 +252,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
             i2_mvY1 = i2_spat_pred_mv[3];
         }
 
-        u1_sub_mb_num = ps_dec->u1_sub_mb_num;
+        u4_sub_mb_num = ps_dec->u1_sub_mb_num;
         u1_mb_partw = (u1_wd_x >> 2);
 
 
@@ -266,7 +267,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                i2_mv[1] = i2_mv_y;
 
                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
-            ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u1_sub_mb_num,i1_pred,
+            ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u4_sub_mb_num,i1_pred,
                             ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
                             ps_pic_buff0->u1_pic_type);
             ps_dec->u4_pred_info_pkd_idx++;
@@ -288,7 +289,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                i2_mv[1] = i2_mvY1;
 
                ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
-            ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u1_sub_mb_num,i1_pred,
+            ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_partw,u4_sub_mb_num,i1_pred,
                             ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
                             ps_pic_buff1->u1_pic_type);
             ps_dec->u4_pred_info_pkd_idx++;
@@ -331,8 +332,8 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                                             && (ABS(i2_mv_y) <= 1));
             u1_colz |= (u1_packed_mb_sub_mb_mode << 6);
         }
-        ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
-        ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz,
+        ps_mv = ps_mv_nmb_start + u4_sub_mb_num;
+        ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num, u1_colz,
                            u1_mb_partw, u1_mb_partw);
         if(u1_wd_x == MB_SIZE)
             ps_dec->u1_currB_type = 0;
@@ -434,7 +435,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
     for(i = 0; i < s_mvdirect.i1_num_partitions; i++)
     {
         partition_size = s_mvdirect.i1_partitionsize[i];
-        u1_sub_mb_num = s_mvdirect.i1_submb_num[i];
+        u4_sub_mb_num = s_mvdirect.i1_submb_num[i];
 
         sub_partition = partition_size >> 2;
         partition_size &= 0x3;
@@ -458,7 +459,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
         if(u1_zero_pred_cond_f || ((i1_ref_frame0 == 0) && (u1_col_zero_flag == 1)))
         {
             pi2_final_mv0 = &i2_def_mv[0];
-            ui2_mask_fwd |= (u2_mask << u1_sub_mb_num);
+            ui2_mask_fwd |= (u2_mask << u4_sub_mb_num);
         }
         else
             pi2_final_mv0 = &i2_spat_pred_mv[0];
@@ -466,15 +467,15 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
         if(u1_zero_pred_cond_b || ((i1_ref_frame1 == 0) && (u1_col_zero_flag == 1)))
         {
             pi2_final_mv1 = &i2_def_mv[0];
-            ui2_mask_bwd |= (u2_mask << u1_sub_mb_num);
+            ui2_mask_bwd |= (u2_mask << u4_sub_mb_num);
         }
         else
             pi2_final_mv1 = &i2_spat_pred_mv[2];
 
         if(ps_cur_mb_info->u1_Mux != 1)
         {
-            /*u1_sub_mb_x = u1_sub_mb_num & 0x03;
-             uc_sub_mb_y = (u1_sub_mb_num >> 2);*/
+            /*u1_sub_mb_x = u4_sub_mb_num & 0x03;
+             uc_sub_mb_y = (u4_sub_mb_num >> 2);*/
             if(i1_ref_frame0 >= 0)
             {
 
@@ -483,7 +484,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                    WORD8 i1_ref_idx= 0;
 
                    ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
-                ih264d_fill_pred_info(pi2_final_mv0,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,i1_pred,
+                ih264d_fill_pred_info(pi2_final_mv0,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,i1_pred,
                                 ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
                                 ps_pic_buff0->u1_pic_type);
                 ps_dec->u4_pred_info_pkd_idx++;
@@ -501,7 +502,7 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                    WORD8 i1_ref_idx= 0;
 
                    ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
-                ih264d_fill_pred_info(pi2_final_mv1,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,i1_pred,
+                ih264d_fill_pred_info(pi2_final_mv1,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,i1_pred,
                                 ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
                                 ps_pic_buff1->u1_pic_type);
                 ps_dec->u4_pred_info_pkd_idx++;
@@ -549,8 +550,8 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                                             && (ABS(i2_mv_y) <= 1));
             u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
         }
-        ps_mv = ps_mv_nmb_start + u1_sub_mb_num;
-        ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num, u1_colz,
+        ps_mv = ps_mv_nmb_start + u4_sub_mb_num;
+        ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num, u1_colz,
                            u1_mb_parth, u1_mb_partw);
     }
     i = 0;
@@ -582,11 +583,11 @@ WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
 WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
                                      UWORD8 u1_wd_x,
                                      dec_mb_info_t * ps_cur_mb_info,
-                                     UWORD8 u1_mb_num)
+                                     UWORD32 u4_mb_num)
 {
     struct pic_buffer_t *ps_pic_buff0, *ps_pic_buff1, *ps_col_pic;
     mv_pred_t *ps_mv, s_temp_mv_pred;
-    UWORD8 u1_sub_mb_num;
+    UWORD32 u4_sub_mb_num;
     UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     WORD16 i2_mv_x0, i2_mv_y0, i2_mv_x1, i2_mv_y1;
     UWORD8 u1_mb_partw, u1_mb_parth;
@@ -615,7 +616,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
     {
         UWORD8 u1_colz;
         partition_size = s_mvdirect.i1_partitionsize[i];
-        u1_sub_mb_num = s_mvdirect.i1_submb_num[i];
+        u4_sub_mb_num = s_mvdirect.i1_submb_num[i];
         ps_mv = ps_col_pic->ps_mv + s_mvdirect.i4_mv_indices[i];
 
         /* This should be removed to catch unitialized memory read */
@@ -810,8 +811,8 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
             {
                 mv_pred_t *ps_mv;
 
-                /*u1_sub_mb_x = u1_sub_mb_num & 0x03;
-                 uc_sub_mb_y = u1_sub_mb_num >> 2;*/
+                /*u1_sub_mb_x = u4_sub_mb_num & 0x03;
+                 uc_sub_mb_y = u4_sub_mb_num >> 2;*/
                 if(ps_dec->ps_cur_pps->u1_wted_bipred_idc)
                 {
                     UWORD8 u1_idx =
@@ -851,7 +852,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
                    i2_mv[1] = i2_mv_y0;
 
                    ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
-                ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,PRED_L0 | PRED_L1,
+                ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,PRED_L0 | PRED_L1,
                                 ps_pred_pkd,ps_pic_buff0->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
                                 ps_pic_buff0->u1_pic_type);
                 ps_dec->u4_pred_info_pkd_idx++;
@@ -868,7 +869,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
                    i2_mv[1] = i2_mv_y1;
 
                    ps_pred_pkd = ps_dec->ps_pred_pkd + ps_dec->u4_pred_info_pkd_idx;
-                ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u1_sub_mb_num,PRED_L0 | PRED_L1,
+                ih264d_fill_pred_info(i2_mv,u1_mb_partw,u1_mb_parth,u4_sub_mb_num,PRED_L0 | PRED_L1,
                                 ps_pred_pkd,ps_pic_buff1->u1_pic_buf_id,i1_ref_idx,pui32_weight_ofsts,
                                 ps_pic_buff1->u1_pic_type);
                 ps_dec->u4_pred_info_pkd_idx++;
@@ -886,7 +887,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
                 s_temp_mv_pred.i1_ref_frame[1] = 0;
                 s_temp_mv_pred.u1_col_ref_pic_idx = ps_pic_buff0->u1_mv_buf_id;
                 s_temp_mv_pred.u1_pic_type = ps_pic_buff0->u1_pic_type;
-                ps_mv = ps_dec->ps_mv_cur + (u1_mb_num << 4) + u1_sub_mb_num;
+                ps_mv = ps_dec->ps_mv_cur + (u4_mb_num << 4) + u4_sub_mb_num;
 
                 {
                     WORD16 i2_mv_x = 0, i2_mv_y = 0;
@@ -914,7 +915,7 @@ WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
                                                                                     <= 1));
                     u1_colz |= (u1_packed_mb_sub_mb_mode << 4);
                 }
-                ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u1_sub_mb_num,
+                ih264d_rep_mv_colz(ps_dec, &s_temp_mv_pred, ps_mv, u4_sub_mb_num,
                                    u1_colz, u1_mb_parth, u1_mb_partw);
             }
         }
diff --git a/decoder/ih264d_process_bslice.h b/decoder/ih264d_process_bslice.h
index 5aa76e3..58c70aa 100644
--- a/decoder/ih264d_process_bslice.h
+++ b/decoder/ih264d_process_bslice.h
@@ -43,11 +43,11 @@ WORD32 ih264d_parse_bslice(dec_struct_t * ps_dec,
 WORD32 ih264d_decode_spatial_direct(dec_struct_t * ps_dec,
                                     UWORD8 u1_wd_x,
                                     dec_mb_info_t * ps_cur_mb_info,
-                                    UWORD8 u1_mb_num);
+                                    UWORD32 u4_mb_num);
 WORD32 ih264d_decode_temporal_direct(dec_struct_t * ps_dec,
                                      UWORD8 u1_wd_x,
                                      dec_mb_info_t * ps_cur_mb_info,
-                                     UWORD8 u1_mb_num);
+                                     UWORD32 u4_mb_num);
 WORD32 parseBSliceData(dec_struct_t * ps_dec,
                        dec_slice_params_t * ps_slice,
                        UWORD16 u2_first_mb_in_slice);
@@ -102,7 +102,7 @@ void ih264d_fld_to_mbaff(dec_struct_t *ps_dec,
 WORD32 ih264d_cal_col_pic(dec_struct_t *ps_dec);
 
 WORD32 ih264d_mv_pred_ref_tfr_nby2_bmb(dec_struct_t * ps_dec,
-                                     UWORD8 u1_num_mbs,
-                                     UWORD8 u1_num_mbsNby2);
+                                     UWORD32 u4_num_mbs,
+                                     UWORD32 u4_num_mbsNby2);
 
 #endif /* _IH264D_PARSE_BSLICE_H_ */
diff --git a/decoder/ih264d_process_intra_mb.c b/decoder/ih264d_process_intra_mb.c
index 2d4d006..aa30f55 100644
--- a/decoder/ih264d_process_intra_mb.c
+++ b/decoder/ih264d_process_intra_mb.c
@@ -715,7 +715,7 @@ UWORD32 ih264d_unpack_luma_coeff8x8_mb(dec_struct_t * ps_dec,
  */
 WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
                                dec_mb_info_t * ps_cur_mb_info,
-                               UWORD8 u1_mb_num)
+                               UWORD32 u4_mb_num)
 {
     UWORD8 u1_mb_type = ps_cur_mb_info->u1_mb_type;
     UWORD8 uc_temp = ps_cur_mb_info->u1_mb_ngbr_availablity;
@@ -758,7 +758,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
     UWORD8 *pu1_prev_intra4x4_pred_mode_data = (UWORD8 *)ps_dec->pv_proc_tu_coeff_data;                 //Pointer to keep track of intra4x4_pred_mode data in pv_proc_tu_coeff_data buffer
     u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     u1_topmb = ps_cur_mb_info->u1_topmb;
-    u4_num_pmbair = (u1_mb_num >> u1_mbaff);
+    u4_num_pmbair = (u4_mb_num >> u1_mbaff);
 
 
     /*--------------------------------------------------------------------*/
@@ -1353,7 +1353,8 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
     else if((u1_mb_type == I_4x4_MB) && (ps_cur_mb_info->u1_tran_form8x8 == 1))
     {
         UWORD8 u1_is_left_sub_block, u1_is_top_sub_block = uc_useTopMB;
-        UWORD8 u1_sub_blk_x, u1_sub_blk_y, u1_sub_mb_num;
+        UWORD8 u1_sub_blk_x, u1_sub_blk_y;
+        UWORD32 u4_sub_mb_num;
         WORD8 i1_top_pred_mode;
         WORD8 i1_left_pred_mode;
         UWORD8 *pu1_top, *pu1_left, *pu1_top_left;
@@ -1565,20 +1566,20 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
         }
 
         /* Scan the sub-blocks in Raster Scan Order */
-        for(u1_sub_mb_num = 0; u1_sub_mb_num < 4; u1_sub_mb_num++)
+        for(u4_sub_mb_num = 0; u4_sub_mb_num < 4; u4_sub_mb_num++)
         {
-            u1_sub_blk_x = (u1_sub_mb_num & 0x1);
-            u1_sub_blk_y = (u1_sub_mb_num >> 1);
+            u1_sub_blk_x = (u4_sub_mb_num & 0x1);
+            u1_sub_blk_y = (u4_sub_mb_num >> 1);
             i1_top_pred_mode = pi1_cur_pred_mode[u1_sub_blk_x << 1];
             i1_left_pred_mode = pi1_left_pred_mode[u1_sub_blk_y << 1];
 
-            if(2 == u1_sub_mb_num)
+            if(2 == u4_sub_mb_num)
             {
                 i1_left_pred_mode = pi1_left_pred_mode[(u1_sub_blk_y << 1)
                                 + u4_4x4_left_offset];
             }
 
-            u1_use_top_right_mb = (!!CHECKBIT(ui2_top_rt_mask, u1_sub_mb_num));
+            u1_use_top_right_mb = (!!CHECKBIT(ui2_top_rt_mask, u4_sub_mb_num));
 
             /*********** left subblock availability**********/
             if(u1_sub_blk_x)
@@ -1621,7 +1622,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
             }
 
             /***************** Top Left *********************/
-            if(u1_sub_mb_num)
+            if(u4_sub_mb_num)
             {
                 pu1_top_left = (u1_sub_blk_x) ?
                                 pu1_top - 1 : pu1_left - ui_rec_width;
@@ -1649,10 +1650,10 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
                 /* for a MB with 8x8 intrapredicition                               */
                 /********************************************************************/
                 PROFILE_DISABLE_INTRA_PRED()
-                if(!pu1_prev_intra4x4_pred_mode_flag[u1_sub_mb_num])
+                if(!pu1_prev_intra4x4_pred_mode_flag[u4_sub_mb_num])
                 {
-                    i1_intra_pred = pu1_rem_intra4x4_pred_mode[u1_sub_mb_num]
-                                    + (pu1_rem_intra4x4_pred_mode[u1_sub_mb_num]
+                    i1_intra_pred = pu1_rem_intra4x4_pred_mode[u4_sub_mb_num]
+                                    + (pu1_rem_intra4x4_pred_mode[u4_sub_mb_num]
                                                     >= i1_intra_pred);
                 }
                 i1_intra_pred = CLIP3(0, 8, i1_intra_pred);
@@ -1694,7 +1695,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
             }
 
             /* Inverse Transform and Reconstruction */
-            if(CHECKBIT(ps_cur_mb_info->u1_cbp, u1_sub_mb_num))
+            if(CHECKBIT(ps_cur_mb_info->u1_cbp, u4_sub_mb_num))
             {
                 WORD16 *pi2_scale_matrix_ptr;
                 WORD16 ai2_tmp[64];
@@ -1703,7 +1704,7 @@ WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
                                 ps_dec->s_high_profile.i2_scalinglist8x8[0];
                 PROFILE_DISABLE_IQ_IT_RECON()
                 {
-                    if(CHECKBIT(u4_luma_dc_only_cbp, u1_sub_mb_num))
+                    if(CHECKBIT(u4_luma_dc_only_cbp, u4_sub_mb_num))
                     {
                         ps_dec->pf_iquant_itrans_recon_luma_8x8_dc(
                                         pi2_y_coeff1,
diff --git a/decoder/ih264d_process_intra_mb.h b/decoder/ih264d_process_intra_mb.h
index 30d7819..fb608e9 100644
--- a/decoder/ih264d_process_intra_mb.h
+++ b/decoder/ih264d_process_intra_mb.h
@@ -59,7 +59,7 @@ WORD32 ih264d_read_intra_pred_modes(dec_struct_t *ps_dec,
 
 WORD32 ih264d_process_intra_mb(dec_struct_t * ps_dec,
                                dec_mb_info_t * ps_cur_mb_info,
-                               UWORD8 u1_mb_num);
+                               UWORD32 u4_mb_num);
 
 #endif  /* _IH264D_PROCESS_INTRA_MB_H_ */
 
diff --git a/decoder/ih264d_process_pslice.c b/decoder/ih264d_process_pslice.c
index c29063a..74f0878 100644
--- a/decoder/ih264d_process_pslice.c
+++ b/decoder/ih264d_process_pslice.c
@@ -68,8 +68,8 @@ void ih264d_insert_pic_in_ref_pic_listx(struct pic_buffer_t *ps_ref_pic_buf_lx,
 }
 
 WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
-                                     UWORD8 u1_mb_idx,
-                                     UWORD8 u1_num_mbs)
+                                     UWORD32 u4_mb_idx,
+                                     UWORD32 u4_num_mbs)
 {
     parse_pmbarams_t * ps_mb_part_info;
     parse_part_params_t * ps_part;
@@ -80,12 +80,12 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
     WORD32 i2_mv_x, i2_mv_y;
     WORD32 ret;
 
-    ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
-    ps_mb_part_info = ps_dec->ps_parse_mb_data; // + u1_mb_idx;
-    ps_part = ps_dec->ps_parse_part_params; // + u1_mb_idx;
+    ps_dec->i4_submb_ofst -= (WORD32)(u4_num_mbs - u4_mb_idx) << 4;
+    ps_mb_part_info = ps_dec->ps_parse_mb_data; // + u4_mb_idx;
+    ps_part = ps_dec->ps_parse_part_params; // + u4_mb_idx;
 
     /* N/2 Mb MvPred and Transfer Setup Loop */
-    for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
+    for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
     {
         UWORD32 u1_colz;
         UWORD32 u1_field;
@@ -110,7 +110,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
         ps_dec->u2_mv_2mb[i & 0x1] = 0;
 
         /* Look for MV Prediction and Reference Transfer in Non-I Mbs */
-        if(!ps_mb_part_info->u1_isI_mb)
+        if(!ps_mb_part_info->u4_isI_mb)
         {
             UWORD32 u1_blk_no;
             WORD32 i1_ref_idx, i1_ref_idx1;
@@ -124,7 +124,7 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
 
             /* MB Level initialisations */
             ps_dec->u4_num_pmbair = i >> u1_mbaff;
-            ps_dec->u1_mb_idx_mv = i;
+            ps_dec->u4_mb_idx_mv = i;
             ppu4_wt_ofst = ps_mb_part_info->pu4_wt_offst;
             pps_ref_frame = ps_dec->ps_ref_pic_buf_lx[0];
             /* CHANGED CODE */
@@ -330,11 +330,11 @@ WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
 
 
 WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
-                                   UWORD8 u1_mb_idx,
-                                   UWORD8 u1_num_mbs,
-                                   UWORD8 u1_num_mbs_next,
-                                   UWORD8 u1_tfr_n_mb,
-                                   UWORD8 u1_end_of_row)
+                                   UWORD32 u4_mb_idx,
+                                   UWORD32 u4_num_mbs,
+                                   UWORD32 u4_num_mbs_next,
+                                   UWORD32 u4_tfr_n_mb,
+                                   UWORD32 u4_end_of_row)
 {
     WORD32 i,j;
     UWORD32 u1_end_of_row_next;
@@ -354,7 +354,7 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
 
 
     /* N Mb MC Loop */
-    for(i = u1_mb_idx; i < u1_num_mbs; i++)
+    for(i = u4_mb_idx; i < u4_num_mbs; i++)
     {
         ps_cur_mb_info = ps_dec->ps_nmb_info + i;
         ps_dec->u4_dma_buf_idx = 0;
@@ -418,7 +418,7 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
 
 
     /* N Mb IQ IT RECON  Loop */
-    for(j = u1_mb_idx; j < i; j++)
+    for(j = u4_mb_idx; j < i; j++)
     {
         ps_cur_mb_info = ps_dec->ps_nmb_info + j;
 
@@ -462,12 +462,12 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
         u4_wd_uv = ps_dec->u2_frm_wd_uv << u1_field_pic_flag;
 
 
-        ps_cur_mb_info = ps_dec->ps_nmb_info + u1_mb_idx;
+        ps_cur_mb_info = ps_dec->ps_nmb_info + u4_mb_idx;
 
         ps_dec->u4_deblk_mb_x = ps_cur_mb_info->u2_mbx;
         ps_dec->u4_deblk_mb_y = ps_cur_mb_info->u2_mby;
 
-        for(j = u1_mb_idx; j < i; j++)
+        for(j = u4_mb_idx; j < i; j++)
         {
 
             ih264d_deblock_mb_nonmbaff(ps_dec, ps_tfr_cxt,
@@ -483,15 +483,15 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
 
 
 
-    if(u1_tfr_n_mb)
+    if(u4_tfr_n_mb)
     {
         /****************************************************************/
         /* Check for End Of Row in Next iteration                       */
         /****************************************************************/
         u1_end_of_row_next =
-                        u1_num_mbs_next
-                                        && (u1_num_mbs_next
-                                                        <= (ps_dec->u1_recon_mb_grp
+                        u4_num_mbs_next
+                                        && (u4_num_mbs_next
+                                                        <= (ps_dec->u4_recon_mb_grp
                                                                         >> u1_mbaff));
 
         /****************************************************************/
@@ -502,9 +502,9 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
         /* N-Mb MV Data             ( To Ext MV Buffer )                */
         /* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers)    */
         /****************************************************************/
-        ih264d_transfer_mb_group_data(ps_dec, u1_num_mbs, u1_end_of_row,
+        ih264d_transfer_mb_group_data(ps_dec, u4_num_mbs, u4_end_of_row,
                                       u1_end_of_row_next);
-        ps_dec->u4_num_mbs_prev_nmb = u1_num_mbs;
+        ps_dec->u4_num_mbs_prev_nmb = u4_num_mbs;
 
         ps_dec->u4_pred_info_idx = 0;
         ps_dec->u4_dma_buf_idx = 0;
@@ -528,7 +528,7 @@ WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
  */
 WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
                                dec_mb_info_t * ps_cur_mb_info,
-                               UWORD8 u1_mb_num)
+                               UWORD32 u4_mb_num)
 {
     /* CHANGED CODE */
     UWORD8 *pu1_rec_y, *pu1_rec_u, *pu1_rec_v;
@@ -547,7 +547,7 @@ WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
     /* CHANGED CODE */
 
     uc_botMb = 1 - ps_cur_mb_info->u1_topmb;
-    u4_num_pmbair = (u1_mb_num >> u1_mbaff);
+    u4_num_pmbair = (u4_mb_num >> u1_mbaff);
     u1_mb_field_decoding_flag = ps_cur_mb_info->u1_mb_field_decodingflag;
 
 
diff --git a/decoder/ih264d_process_pslice.h b/decoder/ih264d_process_pslice.h
index 8740eb4..63e3a32 100644
--- a/decoder/ih264d_process_pslice.h
+++ b/decoder/ih264d_process_pslice.h
@@ -49,20 +49,20 @@ WORD32 parsePSliceData(dec_struct_t * ps_dec,
 
 WORD32 ih264d_process_inter_mb(dec_struct_t * ps_dec,
                                dec_mb_info_t * ps_cur_mb_info,
-                               UWORD8 u1_mb_num);
+                               UWORD32 u4_mb_num);
 
 void ih264d_init_ref_idx_lx_p(dec_struct_t *ps_dec);
 
 WORD32 ih264d_mv_pred_ref_tfr_nby2_pmb(dec_struct_t * ps_dec,
-                                     UWORD8 u1_num_mbs,
-                                     UWORD8 u1_num_mbsNby2);
+                                     UWORD32 u4_num_mbs,
+                                     UWORD32 u4_num_mbsNby2);
 
 WORD32 ih264d_decode_recon_tfr_nmb(dec_struct_t * ps_dec,
-                                 UWORD8 u1_mb_idx,
-                                 UWORD8 u1_num_mbs,
-                                 UWORD8 u1_num_mbs_next,
-                                 UWORD8 u1_tfr_n_mb,
-                                 UWORD8 u1_end_of_row);
+                                 UWORD32 u4_mb_idx,
+                                 UWORD32 u4_num_mbs,
+                                 UWORD32 u4_num_mbs_next,
+                                 UWORD32 u4_tfr_n_mb,
+                                 UWORD32 u4_end_of_row);
 
 void ih264d_insert_pic_in_ref_pic_listx(struct pic_buffer_t *ps_ref_pic_buf_lx,
                                         struct pic_buffer_t *ps_pic);
diff --git a/decoder/ih264d_structs.h b/decoder/ih264d_structs.h
index 8c10aa9..d904caf 100644
--- a/decoder/ih264d_structs.h
+++ b/decoder/ih264d_structs.h
@@ -318,8 +318,8 @@ typedef struct
 
     /* Following are derived from the above two */
     UWORD16 u2_fld_ht_in_mbs; /** Field height expressed in MB units */
-    UWORD16 u2_max_mb_addr; /** Total number of macroblocks in a coded picture */
-    UWORD16 u2_total_num_of_mbs; /** Total number of macroblocks in a coded picture */
+    UWORD32 u4_max_mb_addr; /** Total number of macroblocks in a coded picture */
+    UWORD32 u4_total_num_of_mbs; /** Total number of macroblocks in a coded picture */
     UWORD32 u4_fld_ht; /** field height */
     UWORD32 u4_cwidth; /** chroma width */
     UWORD32 u4_chr_frm_ht; /** chroma height */
@@ -517,7 +517,7 @@ typedef struct
     WORD32 (*pf_decodeDirect)(struct _DecStruct *ps_dec,
                               UWORD8 u1_wd_x,
                               dec_mb_info_t *ps_cur_mb_info,
-                              UWORD8 u1_mb_num);
+                              UWORD32 u4_mb_num);
     UWORD8 u1_redundant_pic_cnt;
     WORD8 i1_slice_qs_delta;
     UWORD8 u1_nal_ref_idc; /** NAL ref idc of the Slice NAL unit */
@@ -581,7 +581,7 @@ typedef struct
 
 typedef struct
 {
-    UWORD8 u1_isI_mb;
+    UWORD32 u4_isI_mb;
     UWORD8 u1_num_part;
     UWORD32 *pu4_wt_offst[MAX_REFIDX_INFO_PER_MB];
     WORD8 i1_ref_idx[2][MAX_REFIDX_INFO_PER_MB];
@@ -795,8 +795,8 @@ typedef struct _DecStruct
     /************************************************************/
     /* MB_GROUP should be a multiple of 2                       */
     /************************************************************/
-    UWORD8 u1_recon_mb_grp;
-    UWORD8 u1_recon_mb_grp_pair;
+    UWORD32 u4_recon_mb_grp;
+    UWORD32 u4_recon_mb_grp_pair;
     /* Variables to handle Cabac */
     decoding_envirnoment_t s_cab_dec_env; /* < Structure for decoding_envirnoment_t */
     /* These things need to be updated at each MbLevel */
@@ -988,11 +988,11 @@ typedef struct _DecStruct
     /* Function pointers to read Params common to CAVLC and CABAC */
     WORD32 (*pf_parse_inter_mb)(struct _DecStruct * ps_dec,
                                 dec_mb_info_t * ps_cur_mb_info,
-                                UWORD8 u1_mb_num,
-                                UWORD8 u1_num_mbsNby2);
+                                UWORD32 u4_mb_num,
+                                UWORD32 u4_num_mbsNby2);
     WORD32 (*pf_mvpred_ref_tfr_nby2mb)(struct _DecStruct * ps_dec,
-                                     UWORD8 u1_num_mbs,
-                                     UWORD8 u1_num_mbsNby2);
+                                     UWORD32 u4_num_mbs,
+                                     UWORD32 u4_num_mbsNby2);
 
     WORD32 (*pf_parse_inter_slice)(struct _DecStruct * ps_dec,
                                    dec_slice_params_t * ps_slice,
@@ -1061,7 +1061,7 @@ typedef struct _DecStruct
     /* Variables used for gaps in frame number */
     UWORD16 u2_prev_ref_frame_num;
 
-    UWORD8 u1_mb_idx;
+    UWORD32 u4_mb_idx;
     struct pic_buffer_t *ps_col_pic;
     void (*pf_parse_mvdirect)(struct _DecStruct*,
                            struct pic_buffer_t*,
@@ -1087,7 +1087,7 @@ typedef struct _DecStruct
                         mv_pred_t *ps_mv_pred,
                         mv_pred_t *ps_mv_nmb,
                         mv_pred_t *ps_mv_ntop,
-                        UWORD8 u1_sub_mb_num,
+                        UWORD32 u4_sub_mb_num,
                         UWORD8 uc_mb_part_width,
                         UWORD8 uc_lxstart,
                         UWORD8 uc_lxend,
@@ -1113,12 +1113,12 @@ typedef struct _DecStruct
     by declaring this after a pointer or an integer */
     WORD8 pi1_left_pred_mode[8];
 
-    UWORD8 u1_mb_idx_mv;
+    UWORD32 u4_mb_idx_mv;
     UWORD16 u2_mv_2mb[2];
     UWORD32 u4_skip_frm_mask;
 
     /* variable for finding the no.of mbs decoded in the current picture */
-    UWORD16 u2_total_mbs_coded;
+    UWORD32 u4_total_mbs_coded;
     /* member added for supporting fragmented annex - B */
 //  frg_annex_read_t s_frag_annex_read;
     /* added for vui_t, sei support*/
@@ -1305,9 +1305,9 @@ typedef struct _DecStruct
     ivd_get_display_frame_op_t s_disp_op;
     UWORD32 u4_output_present;
 
-    volatile UWORD16 cur_dec_mb_num;
-    volatile UWORD16 cur_recon_mb_num;
-    volatile UWORD16 u2_cur_mb_addr;
+    volatile UWORD32 cur_dec_mb_num;
+    volatile UWORD32 cur_recon_mb_num;
+    volatile UWORD32 u4_cur_mb_addr;
     WORD16 i2_dec_thread_mb_y;
     WORD16 i2_recon_thread_mb_y;
 
diff --git a/decoder/ih264d_thread_compute_bs.c b/decoder/ih264d_thread_compute_bs.c
index 961b1a6..6080e8c 100644
--- a/decoder/ih264d_thread_compute_bs.c
+++ b/decoder/ih264d_thread_compute_bs.c
@@ -385,7 +385,7 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
     UWORD32 u4_mb_num;
     UWORD16 u2_first_mb_in_slice;
     UWORD32 i2_pic_wdin_mbs;
-    UWORD8 u1_num_mbsleft, u1_end_of_row;
+    UWORD32 u4_num_mbsleft, u4_end_of_row;
     UWORD8 u1_mbaff;
     UWORD16 i16_mb_x, i16_mb_y;
     WORD32 j;
@@ -445,7 +445,7 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
         }
     }
 
-    u4_max_addr = ps_dec->ps_cur_sps->u2_max_mb_addr;
+    u4_max_addr = ps_dec->ps_cur_sps->u4_max_mb_addr;
     u1_mb_aff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     u2_first_mb_in_slice = ps_dec->ps_computebs_cur_slice->u4_first_mb_in_slice;
     i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
@@ -513,17 +513,17 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
     {
         WORD32 recon_mb_grp,bs_mb_grp;
         WORD32 nop_cnt = 8*128;
-        u1_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
-        if(u1_num_mbsleft <= ps_dec->u1_recon_mb_grp)
+        u4_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
+        if(u4_num_mbsleft <= ps_dec->u4_recon_mb_grp)
         {
-            recon_mb_grp = u1_num_mbsleft;
-            u1_end_of_row = 1;
+            recon_mb_grp = u4_num_mbsleft;
+            u4_end_of_row = 1;
             i16_mb_x = 0;
         }
         else
         {
-            recon_mb_grp = ps_dec->u1_recon_mb_grp;
-            u1_end_of_row = 0;
+            recon_mb_grp = ps_dec->u4_recon_mb_grp;
+            u4_end_of_row = 0;
             i16_mb_x += (recon_mb_grp >> u1_mbaff);
         }
 
@@ -609,18 +609,18 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
 
         if(j != recon_mb_grp)
         {
-            u1_end_of_row = 0;
+            u4_end_of_row = 0;
         }
 
         {
             tfr_ctxt_t *ps_trns_addr = &ps_dec->s_tran_iprecon;
             UWORD16 u2_mb_y;
 
-            ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u1_end_of_row];
-            ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u1_end_of_row];
-            ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u1_end_of_row];
+            ps_trns_addr->pu1_dest_y += ps_trns_addr->u4_inc_y[u4_end_of_row];
+            ps_trns_addr->pu1_dest_u += ps_trns_addr->u4_inc_uv[u4_end_of_row];
+            ps_trns_addr->pu1_dest_v += ps_trns_addr->u4_inc_uv[u4_end_of_row];
 
-            if(u1_end_of_row)
+            if(u4_end_of_row)
             {
                 ps_dec->i2_recon_thread_mb_y += (1 << u1_mbaff);
                 u2_mb_y = ps_dec->i2_recon_thread_mb_y;
@@ -665,7 +665,7 @@ void ih264d_recon_deblk_slice(dec_struct_t *ps_dec, tfr_ctxt_t *ps_tfr_cxt)
 
             if(ps_dec->u4_cur_bs_mb_num > ps_dec->u4_cur_deblk_mb_num)
             {
-                if(u1_end_of_row)
+                if(u4_end_of_row)
                 {
                     u4_num_mbs = ps_dec->u4_cur_bs_mb_num
                                     - ps_dec->u4_cur_deblk_mb_num;
@@ -724,7 +724,7 @@ void ih264d_recon_deblk_thread(dec_struct_t *ps_dec)
 
             DEBUG_THREADS_PRINTF(" Exit  compute bs slice \n");
 
-            if(ps_dec->cur_recon_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
+            if(ps_dec->cur_recon_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
             {
                     break;
             }
diff --git a/decoder/ih264d_thread_parse_decode.c b/decoder/ih264d_thread_parse_decode.c
index 7d56d16..5aabe1a 100644
--- a/decoder/ih264d_thread_parse_decode.c
+++ b/decoder/ih264d_thread_parse_decode.c
@@ -60,31 +60,31 @@ void ih264d_copy_intra_pred_line(dec_struct_t *ps_dec,
                                  UWORD32 nmb_index);
 
 void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
-                          UWORD8 u1_mb_idx,
-                          UWORD8 u1_num_mbs,
-                          UWORD8 u1_num_mbs_next,
-                          UWORD8 u1_tfr_n_mb,
-                          UWORD8 u1_end_of_row)
+                          UWORD32 u4_mb_idx,
+                          UWORD32 u4_num_mbs,
+                          UWORD32 u4_num_mbs_next,
+                          UWORD32 u4_tfr_n_mb,
+                          UWORD32 u4_end_of_row)
 {
     WORD32 i, u4_mb_num;
 
     const UWORD32 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
     UWORD32 u4_n_mb_start;
 
-    UNUSED(u1_mb_idx);
-    UNUSED(u1_num_mbs_next);
-    if(u1_tfr_n_mb)
+    UNUSED(u4_mb_idx);
+    UNUSED(u4_num_mbs_next);
+    if(u4_tfr_n_mb)
     {
 
 
-        u4_n_mb_start = (ps_dec->u2_cur_mb_addr + 1) - u1_num_mbs;
+        u4_n_mb_start = (ps_dec->u4_cur_mb_addr + 1) - u4_num_mbs;
 
         // copy into s_frmMbInfo
 
         u4_mb_num = u4_n_mb_start;
-        u4_mb_num = (ps_dec->u2_cur_mb_addr + 1) - u1_num_mbs;
+        u4_mb_num = (ps_dec->u4_cur_mb_addr + 1) - u4_num_mbs;
 
-        for(i = 0; i < u1_num_mbs; i++)
+        for(i = 0; i < u4_num_mbs; i++)
         {
             UPDATE_SLICE_NUM_MAP(ps_dec->pu2_slice_num_map, u4_mb_num,
                                  ps_dec->u2_cur_slice_num);
@@ -110,13 +110,13 @@ void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
         /* Swap top and current pointers */
 
         ps_dec->s_tran_addrecon_parse.pu1_dest_y +=
-                        ps_dec->s_tran_addrecon_parse.u4_inc_y[u1_end_of_row];
+                        ps_dec->s_tran_addrecon_parse.u4_inc_y[u4_end_of_row];
         ps_dec->s_tran_addrecon_parse.pu1_dest_u +=
-                        ps_dec->s_tran_addrecon_parse.u4_inc_uv[u1_end_of_row];
+                        ps_dec->s_tran_addrecon_parse.u4_inc_uv[u4_end_of_row];
         ps_dec->s_tran_addrecon_parse.pu1_dest_v +=
-                        ps_dec->s_tran_addrecon_parse.u4_inc_uv[u1_end_of_row];
+                        ps_dec->s_tran_addrecon_parse.u4_inc_uv[u4_end_of_row];
 
-        if(u1_end_of_row)
+        if(u4_end_of_row)
         {
             UWORD16 u2_mb_y;
             UWORD32 u4_frame_stride, y_offset;
@@ -141,7 +141,7 @@ void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
 
         }
 
-        ps_dec->ps_deblk_mbn += u1_num_mbs;
+        ps_dec->ps_deblk_mbn += u4_num_mbs;
 
         /*
          * The Slice boundary is also a valid condition to transfer. So recalculate
@@ -149,25 +149,25 @@ void ih264d_parse_tfr_nmb(dec_struct_t * ps_dec,
          * N MB value. c_numMbs will be equal to N of N MB if the entire N Mb is
          * decoded.
          */
-        ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u1_num_mbs >> u1_mbaff) - 1)
+        ps_dec->s_tran_addrecon.u2_mv_left_inc = ((u4_num_mbs >> u1_mbaff) - 1)
                         << (4 + u1_mbaff);
-        ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u1_num_mbs << 2) - 1
+        ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (u4_num_mbs << 2) - 1
                         - (u1_mbaff << 2);
 
         /* reassign left MV and cur MV pointers */
         ps_dec->ps_mv_left = ps_dec->ps_mv_cur
                         + ps_dec->s_tran_addrecon.u2_mv_left_inc;
 
-        ps_dec->ps_mv_cur += (u1_num_mbs << 4);
-        ps_dec->u4_num_mbs_prev_nmb = u1_num_mbs;
+        ps_dec->ps_mv_cur += (u4_num_mbs << 4);
+        ps_dec->u4_num_mbs_prev_nmb = u4_num_mbs;
 
     }
 }
 
 void ih264d_decode_tfr_nmb(dec_struct_t * ps_dec,
-                           UWORD8 u1_num_mbs,
-                           UWORD8 u1_num_mbs_next,
-                           UWORD8 u1_end_of_row)
+                           UWORD32 u4_num_mbs,
+                           UWORD32 u4_num_mbs_next,
+                           UWORD32 u4_end_of_row)
 {
 
     UWORD32 u1_end_of_row_next;
@@ -177,8 +177,8 @@ void ih264d_decode_tfr_nmb(dec_struct_t * ps_dec,
     /****************************************************************/
     /* Check for End Of Row in Next iteration                       */
     /****************************************************************/
-    u1_end_of_row_next = u1_num_mbs_next &&
-                        ((u1_num_mbs_next) <= (ps_dec->u1_recon_mb_grp >> u1_mbaff));
+    u1_end_of_row_next = u4_num_mbs_next &&
+                        ((u4_num_mbs_next) <= (ps_dec->u4_recon_mb_grp >> u1_mbaff));
 
     /****************************************************************/
     /* Transfer the Following things                                */
@@ -188,19 +188,19 @@ void ih264d_decode_tfr_nmb(dec_struct_t * ps_dec,
     /* N-Mb MV Data             ( To Ext MV Buffer )                */
     /* N-Mb MVTop/TopRight Data ( To Int MV Top Scratch Buffers)    */
     /****************************************************************/
-    if(u1_end_of_row)
+    if(u4_end_of_row)
     {
         ps_dec->i2_dec_thread_mb_y += (1 << u1_mbaff);
     }
-    ih264d_transfer_mb_group_data(ps_dec, u1_num_mbs, u1_end_of_row,
+    ih264d_transfer_mb_group_data(ps_dec, u4_num_mbs, u4_end_of_row,
                                   u1_end_of_row_next);
 
 }
 
 WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
-                                          UWORD8 u1_num_mbs,
-                                          UWORD8 u1_num_mbs_next,
-                                          UWORD8 u1_end_of_row)
+                                          UWORD32 u4_num_mbs,
+                                          UWORD32 u4_num_mbs_next,
+                                          UWORD32 u4_end_of_row)
 {
     WORD32 i,j;
     dec_mb_info_t * ps_cur_mb_info;
@@ -231,7 +231,7 @@ WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
         UWORD32 u4_max_mb = (UWORD32)(ps_dec->i2_dec_thread_mb_y + (1 << u1_mbaff)) * ps_dec->u2_frm_wd_in_mbs - 1;
         u4_mb_num = u2_cur_dec_mb_num;
         /*introducing 1 MB delay*/
-        u4_mb_num = MIN(u4_mb_num + u1_num_mbs + 1, u4_max_mb);
+        u4_mb_num = MIN(u4_mb_num + u4_num_mbs + 1, u4_max_mb);
 
         CHECK_MB_MAP_BYTE(u4_mb_num, ps_dec->pu1_dec_mb_map, u4_cond);
         if(u4_cond)
@@ -268,7 +268,7 @@ WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
         }
     }
     /* N Mb MC Loop */
-    for(i = 0; i < u1_num_mbs; i++)
+    for(i = 0; i < u4_num_mbs; i++)
     {
         u4_mb_num = u2_cur_dec_mb_num;
 
@@ -420,26 +420,26 @@ WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
     }
 
     /*handle the last mb in picture case*/
-    if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
+    if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
         ps_dec->u4_cur_slice_decode_done = 1;
 
-    if(i != u1_num_mbs)
+    if(i != u4_num_mbs)
     {
-        u1_end_of_row = 0;
+        u4_end_of_row = 0;
         /*Number of MB's left in row*/
-        u1_num_mbs_next = u1_num_mbs_next + ((u1_num_mbs - i) >> u1_mbaff);
+        u4_num_mbs_next = u4_num_mbs_next + ((u4_num_mbs - i) >> u1_mbaff);
     }
 
-    ih264d_decode_tfr_nmb(ps_dec, (i), u1_num_mbs_next, u1_end_of_row);
+    ih264d_decode_tfr_nmb(ps_dec, (i), u4_num_mbs_next, u4_end_of_row);
 
     return OK;
 }
 
 WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec)
 {
-    UWORD8 u1_num_mbs_next, u1_num_mbsleft, u1_end_of_row = 0;
+    UWORD32 u4_num_mbs_next, u4_num_mbsleft, u4_end_of_row = 0;
     const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
-    UWORD8 u1_mbaff, u1_num_mbs;
+    UWORD32 u4_mbaff, u4_num_mbs;
 
     UWORD16 u2_first_mb_in_slice;
     UWORD16 i16_mb_x, i16_mb_y;
@@ -484,25 +484,25 @@ WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec)
                 nop_cnt = 8*128;
                 ithread_yield();
             }
-            DEBUG_THREADS_PRINTF("waiting for mb mapcur_dec_mb_num = %d,ps_dec->u2_cur_mb_addr  = %d\n",u2_cur_dec_mb_num,
-                            ps_dec->u2_cur_mb_addr);
+            DEBUG_THREADS_PRINTF("waiting for mb mapcur_dec_mb_num = %d,ps_dec->u4_cur_mb_addr  = %d\n",u2_cur_dec_mb_num,
+                            ps_dec->u4_cur_mb_addr);
 
         }
     }
 
 
 
-    u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
+    u4_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag;
 
     u2_first_mb_in_slice = ps_dec->ps_decode_cur_slice->u4_first_mb_in_slice;
 
     i16_mb_x = MOD(u2_first_mb_in_slice, i2_pic_wdin_mbs);
     i16_mb_y = DIV(u2_first_mb_in_slice, i2_pic_wdin_mbs);
-    i16_mb_y <<= u1_mbaff;
+    i16_mb_y <<= u4_mbaff;
     ps_dec->i2_dec_thread_mb_y = i16_mb_y;
 
 
-    ps_dec->cur_dec_mb_num = u2_first_mb_in_slice << u1_mbaff;
+    ps_dec->cur_dec_mb_num = u2_first_mb_in_slice << u4_mbaff;
 
     if((ps_dec->u4_num_cores == 2) || !ps_dec->i1_recon_in_thread3_flag)
     {
@@ -560,30 +560,30 @@ WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec)
     while(ps_dec->u4_cur_slice_decode_done != 1)
     {
 
-        u1_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
+        u4_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u4_mbaff);
 
-        if(u1_num_mbsleft <= ps_dec->u1_recon_mb_grp)
+        if(u4_num_mbsleft <= ps_dec->u4_recon_mb_grp)
         {
-            u1_num_mbs = u1_num_mbsleft;
+            u4_num_mbs = u4_num_mbsleft;
 
             /*Indicate number of mb's left in a row*/
-            u1_num_mbs_next = 0;
-            u1_end_of_row = 1;
+            u4_num_mbs_next = 0;
+            u4_end_of_row = 1;
             i16_mb_x = 0;
         }
         else
         {
-            u1_num_mbs = ps_dec->u1_recon_mb_grp;
+            u4_num_mbs = ps_dec->u4_recon_mb_grp;
 
             /*Indicate number of mb's left in a row*/
-            u1_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x
-                            - (ps_dec->u1_recon_mb_grp >> u1_mbaff);
-            i16_mb_x += (u1_num_mbs >> u1_mbaff);
-            u1_end_of_row = 0;
+            u4_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x
+                            - (ps_dec->u4_recon_mb_grp >> u4_mbaff);
+            i16_mb_x += (u4_num_mbs >> u4_mbaff);
+            u4_end_of_row = 0;
 
         }
-        ret = ih264d_decode_recon_tfr_nmb_thread(ps_dec, u1_num_mbs, u1_num_mbs_next,
-                                           u1_end_of_row);
+        ret = ih264d_decode_recon_tfr_nmb_thread(ps_dec, u4_num_mbs, u4_num_mbs_next,
+                                           u4_end_of_row);
         if(ret != OK)
             return ret;
     }
@@ -625,7 +625,7 @@ void ih264d_decode_picture_thread(dec_struct_t *ps_dec )
 
 
             if(ps_dec->cur_dec_mb_num
-                            > ps_dec->ps_cur_sps->u2_max_mb_addr)
+                            > ps_dec->ps_cur_sps->u4_max_mb_addr)
             {
                 /*Last slice in frame*/
                 break;
diff --git a/decoder/ih264d_thread_parse_decode.h b/decoder/ih264d_thread_parse_decode.h
index 5c2c762..978beb0 100644
--- a/decoder/ih264d_thread_parse_decode.h
+++ b/decoder/ih264d_thread_parse_decode.h
@@ -27,19 +27,19 @@
 #ifndef _IH264D_THREAD_PARSE_DECPDE_H_
 #define _IH264D_THREAD_PARSE_DECPDE_H_
 void ih264d_parse_tfr_nmb(dec_struct_t *ps_dec,
-                          UWORD8 u1_mb_idx,
-                          UWORD8 u1_num_mbs,
-                          UWORD8 u1_num_mbs_next,
-                          UWORD8 u1_tfr_n_mb,
-                          UWORD8 u1_end_of_row);
+                          UWORD32 u4_mb_idx,
+                          UWORD32 u4_num_mbs,
+                          UWORD32 u4_num_mbs_next,
+                          UWORD32 u4_tfr_n_mb,
+                          UWORD32 u4_end_of_row);
 void ih264d_decode_tfr_nmb(dec_struct_t *ps_dec,
-                           UWORD8 u1_num_mbs,
-                           UWORD8 u1_num_mbs_next,
-                           UWORD8 u1_end_of_row);
+                           UWORD32 u4_num_mbs,
+                           UWORD32 u4_num_mbs_next,
+                           UWORD32 u4_end_of_row);
 WORD32 ih264d_decode_recon_tfr_nmb_thread(dec_struct_t * ps_dec,
-                                          UWORD8 u1_num_mbs,
-                                          UWORD8 u1_num_mbs_next,
-                                          UWORD8 u1_end_of_row);
+                                          UWORD32 u4_num_mbs,
+                                          UWORD32 u4_num_mbs_next,
+                                          UWORD32 u4_end_of_row);
 void ih264d_decode_picture_thread(dec_struct_t *ps_dec);
 WORD32 ih264d_decode_slice_thread(dec_struct_t *ps_dec);
 
diff --git a/decoder/ih264d_utils.c b/decoder/ih264d_utils.c
index a6eea60..1f0e13f 100644
--- a/decoder/ih264d_utils.c
+++ b/decoder/ih264d_utils.c
@@ -725,8 +725,8 @@ WORD32 ih264d_get_dpb_size(dec_seq_params_t *ps_seq)
 }
 
 /**************************************************************************/
-/* This function initialises the value of ps_dec->u1_recon_mb_grp         */
-/* ps_dec->u1_recon_mb_grp must satisfy the following criteria            */
+/* This function initialises the value of ps_dec->u4_recon_mb_grp         */
+/* ps_dec->u4_recon_mb_grp must satisfy the following criteria            */
 /*  - multiple of 2 (required for N/2 parse-mvpred design)                */
 /*  - multiple of 4 (if it is not a frame_mbs_only sequence),             */
 /*         in this case N/2 itself needs to be even for mbpair processing */
@@ -738,16 +738,16 @@ WORD32 ih264d_init_dec_mb_grp(dec_struct_t *ps_dec)
     dec_seq_params_t *ps_seq = ps_dec->ps_cur_sps;
     UWORD8 u1_frm = ps_seq->u1_frame_mbs_only_flag;
 
-    ps_dec->u1_recon_mb_grp = ps_dec->u2_frm_wd_in_mbs << ps_seq->u1_mb_aff_flag;
+    ps_dec->u4_recon_mb_grp = ps_dec->u2_frm_wd_in_mbs << ps_seq->u1_mb_aff_flag;
 
-    ps_dec->u1_recon_mb_grp_pair = ps_dec->u1_recon_mb_grp >> 1;
+    ps_dec->u4_recon_mb_grp_pair = ps_dec->u4_recon_mb_grp >> 1;
 
-    if(!ps_dec->u1_recon_mb_grp)
+    if(!ps_dec->u4_recon_mb_grp)
     {
         return ERROR_MB_GROUP_ASSGN_T;
     }
 
-    ps_dec->u4_num_mbs_prev_nmb = ps_dec->u1_recon_mb_grp;
+    ps_dec->u4_num_mbs_prev_nmb = ps_dec->u4_recon_mb_grp;
 
     return OK;
 }
@@ -796,9 +796,9 @@ WORD32 ih264d_init_pic(dec_struct_t *ps_dec,
     /*--------------------------------------------------------------------*/
     /* Get the value of MaxMbAddress and frmheight in Mbs                 */
     /*--------------------------------------------------------------------*/
-    ps_seq->u2_max_mb_addr =
-                    (ps_seq->u2_frm_wd_in_mbs
-                                    * (ps_dec->u2_pic_ht
+    ps_seq->u4_max_mb_addr =
+                    ((UWORD32)ps_seq->u2_frm_wd_in_mbs
+                                    * ((UWORD32)ps_dec->u2_pic_ht
                                                     >> (4
                                                                     + ps_dec->ps_cur_slice->u1_field_pic_flag)))
                                     - 1;
@@ -1917,7 +1917,7 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
     UWORD16 u4_chroma_wd = ps_dec->u2_frm_wd_uv;
     WORD8 c_i = 0;
     dec_seq_params_t *ps_sps = ps_dec->ps_cur_sps;
-    UWORD32 u4_total_mbs = ps_sps->u2_total_num_of_mbs << uc_frmOrFld;
+    UWORD32 u4_total_mbs = ps_sps->u4_total_num_of_mbs << uc_frmOrFld;
     UWORD32 u4_wd_mbs = ps_dec->u2_frm_wd_in_mbs;
     UWORD32 u4_ht_mbs = ps_dec->u2_frm_ht_in_mbs;
     UWORD32 u4_blk_wd;
@@ -1958,14 +1958,14 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
 
     ps_dec->ps_pred_start = ps_dec->ps_pred;
 
-    size = sizeof(parse_pmbarams_t) * (ps_dec->u1_recon_mb_grp);
+    size = sizeof(parse_pmbarams_t) * (ps_dec->u4_recon_mb_grp);
     pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
     memset(pv_buf, 0, size);
     ps_dec->ps_parse_mb_data = pv_buf;
 
     size = sizeof(parse_part_params_t)
-                        * ((ps_dec->u1_recon_mb_grp) << 4);
+                        * ((ps_dec->u4_recon_mb_grp) << 4);
     pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
     memset(pv_buf, 0, size);
@@ -1988,14 +1988,14 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
      for CABAC context representing MB not available */
     ps_dec->p_ctxt_inc_mb_map += 1;
 
-    size = (sizeof(mv_pred_t) * ps_dec->u1_recon_mb_grp
+    size = (sizeof(mv_pred_t) * ps_dec->u4_recon_mb_grp
                         * 16);
     pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
     memset(pv_buf, 0, size);
     ps_dec->ps_mv_p[0] = pv_buf;
 
-    size = (sizeof(mv_pred_t) * ps_dec->u1_recon_mb_grp
+    size = (sizeof(mv_pred_t) * ps_dec->u4_recon_mb_grp
                         * 16);
     pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
@@ -2007,7 +2007,7 @@ WORD16 ih264d_allocate_dynamic_bufs(dec_struct_t * ps_dec)
         for(i = 0; i < MV_SCRATCH_BUFS; i++)
         {
             size = (sizeof(mv_pred_t)
-                            * ps_dec->u1_recon_mb_grp * 4);
+                            * ps_dec->u4_recon_mb_grp * 4);
             pv_buf = ps_dec->pf_aligned_alloc(pv_mem_ctxt, 128, size);
             RETURN_IF((NULL == pv_buf), IV_FAIL);
             memset(pv_buf, 0, size);
diff --git a/decoder/mvc/imvcd_api.c b/decoder/mvc/imvcd_api.c
index b193503..6fb4856 100644
--- a/decoder/mvc/imvcd_api.c
+++ b/decoder/mvc/imvcd_api.c
@@ -345,7 +345,7 @@ static IV_API_CALL_STATUS_T imvcd_view_ctxt_init(imvcd_create_ip_t *ps_ip,
     ps_view_ctxt->u1_pr_sl_type = 0xFF;
     ps_view_ctxt->u2_mbx = 0xffff;
     ps_view_ctxt->u2_mby = 0;
-    ps_view_ctxt->u2_total_mbs_coded = 0;
+    ps_view_ctxt->u4_total_mbs_coded = 0;
 
     ps_prev_poc = &ps_view_ctxt->s_prev_pic_poc;
     ps_cur_poc = &ps_view_ctxt->s_cur_pic_poc;
@@ -363,7 +363,7 @@ static IV_API_CALL_STATUS_T imvcd_view_ctxt_init(imvcd_create_ip_t *ps_ip,
 
     ps_view_ctxt->i4_max_poc = 0;
     ps_view_ctxt->i4_prev_max_display_seq = 0;
-    ps_view_ctxt->u1_recon_mb_grp = 4;
+    ps_view_ctxt->u4_recon_mb_grp = 4;
     ps_view_ctxt->i4_reorder_depth = -1;
     ps_view_ctxt->u1_second_field = 0;
     ps_view_ctxt->s_prev_seq_params.u1_eoseq_pending = 0;
@@ -1042,7 +1042,7 @@ static IV_API_CALL_STATUS_T imvcd_finish_au_decode(mvc_dec_ctxt_t *ps_mvcd_ctxt,
         ps_cur_au->i4_poc = 0;
         ps_cur_au->i4_avg_poc = 0;
 
-        if(ps_view_ctxt->u2_total_mbs_coded == (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
+        if(ps_view_ctxt->u4_total_mbs_coded == (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
         {
             imvcd_reset_dpb(ps_dpb_mgr);
         }
diff --git a/decoder/mvc/imvcd_api_utils.c b/decoder/mvc/imvcd_api_utils.c
index 3a40d3b..bde5ac0 100644
--- a/decoder/mvc/imvcd_api_utils.c
+++ b/decoder/mvc/imvcd_api_utils.c
@@ -350,8 +350,8 @@ void imvcd_view_init(mvc_dec_ctxt_t *ps_mvcd_ctxt)
 
     ps_view_ctxt->u4_num_fld_in_frm = 0;
     ps_view_ctxt->u4_slice_start_code_found = 0;
-    ps_view_ctxt->u2_cur_mb_addr = 0;
-    ps_view_ctxt->u2_total_mbs_coded = 0;
+    ps_view_ctxt->u4_cur_mb_addr = 0;
+    ps_view_ctxt->u4_total_mbs_coded = 0;
     ps_view_ctxt->u2_cur_slice_num = 0;
     ps_view_ctxt->cur_dec_mb_num = 0;
     ps_view_ctxt->cur_recon_mb_num = 0;
diff --git a/decoder/mvc/imvcd_error_handler.c b/decoder/mvc/imvcd_error_handler.c
index 4cf4010..d3e777a 100644
--- a/decoder/mvc/imvcd_error_handler.c
+++ b/decoder/mvc/imvcd_error_handler.c
@@ -105,14 +105,14 @@ static IV_API_CALL_STATUS_T imvcd_check_sps_and_subset_sps(mvc_dec_ctxt_t *ps_mv
 
             if(i4_max_mb_addr == INT32_MIN)
             {
-                i4_max_mb_addr = ps_view_ctxt->ps_sps[i].u2_max_mb_addr;
+                i4_max_mb_addr = ps_view_ctxt->ps_sps[i].u4_max_mb_addr;
             }
-            else if(i4_max_mb_addr != ps_view_ctxt->ps_sps[i].u2_max_mb_addr)
+            else if(i4_max_mb_addr != ps_view_ctxt->ps_sps[i].u4_max_mb_addr)
             {
                 return IV_FAIL;
             }
 
-            if(ps_view_ctxt->ps_sps[i].u2_max_mb_addr >
+            if(ps_view_ctxt->ps_sps[i].u4_max_mb_addr >
                imvcd_get_num_mbs_in_level(ps_view_ctxt->ps_sps[i].u1_level_idc))
             {
                 return IV_FAIL;
@@ -148,14 +148,14 @@ static IV_API_CALL_STATUS_T imvcd_check_sps_and_subset_sps(mvc_dec_ctxt_t *ps_mv
 
             if(i4_max_mb_addr == INT32_MIN)
             {
-                i4_max_mb_addr = ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u2_max_mb_addr;
+                i4_max_mb_addr = ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u4_max_mb_addr;
             }
-            else if(i4_max_mb_addr != ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u2_max_mb_addr)
+            else if(i4_max_mb_addr != ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u4_max_mb_addr)
             {
                 return IV_FAIL;
             }
 
-            if(ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u2_max_mb_addr >
+            if(ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u4_max_mb_addr >
                imvcd_get_num_mbs_in_level(ps_mvcd_ctxt->as_subset_sps[i].s_sps_data.u1_level_idc))
             {
                 return IV_FAIL;
diff --git a/decoder/mvc/imvcd_nalu_parser.c b/decoder/mvc/imvcd_nalu_parser.c
index db09138..8d0da51 100644
--- a/decoder/mvc/imvcd_nalu_parser.c
+++ b/decoder/mvc/imvcd_nalu_parser.c
@@ -281,10 +281,10 @@ static WORD32 imvcd_parse_subset_sps(mvc_dec_ctxt_t *ps_mvcd_ctxt, dec_bit_strea
         return IVD_STREAM_WIDTH_HEIGHT_NOT_SUPPORTED;
     }
 
-    ps_subset_sps->s_sps_data.u2_max_mb_addr =
+    ps_subset_sps->s_sps_data.u4_max_mb_addr =
         ps_subset_sps->s_sps_data.u2_frm_wd_in_mbs * ps_subset_sps->s_sps_data.u2_frm_ht_in_mbs - 1;
 
-    ps_subset_sps->s_sps_data.u2_total_num_of_mbs = ps_subset_sps->s_sps_data.u2_max_mb_addr + 1;
+    ps_subset_sps->s_sps_data.u4_total_num_of_mbs = ps_subset_sps->s_sps_data.u4_max_mb_addr + 1;
 
     ps_subset_sps->s_sps_data.u1_frame_mbs_only_flag = ih264d_get_bit_h264(ps_bitstrm);
 
diff --git a/decoder/mvc/imvcd_slice_functions.c b/decoder/mvc/imvcd_slice_functions.c
index 4308f4d..cffc2f4 100644
--- a/decoder/mvc/imvcd_slice_functions.c
+++ b/decoder/mvc/imvcd_slice_functions.c
@@ -69,7 +69,7 @@ static WORD32 imvcd_set_first_mb_in_slice(dec_struct_t *ps_view_ctxt)
     }
 
     if(((ps_cur_slice->u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <=
-        ps_view_ctxt->u2_cur_mb_addr) &&
+        ps_view_ctxt->u4_cur_mb_addr) &&
        (ps_view_ctxt->u4_first_slice_in_pic == 0))
     {
         return ERROR_CORRUPTED_SLICE;
@@ -832,7 +832,7 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
     ps_view_ctxt->i4_frametype = IV_NA_FRAME;
     ps_view_ctxt->i4_content_type = IV_CONTENTTYPE_NA;
 
-    ps_sps->u2_max_mb_addr = ps_sps->u2_frm_wd_in_mbs * ps_sps->u2_frm_ht_in_mbs - 1;
+    ps_sps->u4_max_mb_addr = ps_sps->u2_frm_wd_in_mbs * ps_sps->u2_frm_ht_in_mbs - 1;
     ps_view_ctxt->u2_frm_ht_in_mbs = ps_sps->u2_frm_ht_in_mbs;
 
     if(!ps_view_ctxt->u1_init_dec_flag)
@@ -957,7 +957,7 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
     {
         UWORD32 num_mbs;
 
-        num_mbs = ps_view_ctxt->ps_cur_sps->u2_total_num_of_mbs;
+        num_mbs = ps_view_ctxt->ps_cur_sps->u4_total_num_of_mbs;
 
         if(ps_view_ctxt->pu1_dec_mb_map)
         {
@@ -1095,8 +1095,8 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
     // Increment by 2 ,so that left mb (mbaff decrements by 2)  will always be
     // valid
     ps_view_ctxt->ps_top_mb_row += 2;
-    ps_view_ctxt->u1_mb_idx = 0;
-    ps_view_ctxt->u2_total_mbs_coded = 0;
+    ps_view_ctxt->u4_mb_idx = 0;
+    ps_view_ctxt->u4_total_mbs_coded = 0;
     ps_view_ctxt->i4_submb_ofst = -(SUB_BLK_SIZE);
     ps_view_ctxt->i2_prev_slice_mbx = -1;
     ps_view_ctxt->i2_prev_slice_mby = 0;
@@ -1148,8 +1148,8 @@ static WORD32 imvcd_pic_init(mvc_dec_ctxt_t *ps_mvcd_ctxt, pocstruct_t *ps_cur_p
                              ps_mvcd_ctxt->ps_cur_au->i4_frame_num,
                              ps_sps->u1_gaps_in_frame_num_value_allowed_flag);
 
-        ps_view_ctxt->s_tran_addrecon.u2_mv_top_left_inc = (ps_view_ctxt->u1_recon_mb_grp << 2) - 1;
-        ps_view_ctxt->s_tran_addrecon.u2_mv_left_inc = (ps_view_ctxt->u1_recon_mb_grp - 1) << 4;
+        ps_view_ctxt->s_tran_addrecon.u2_mv_top_left_inc = (ps_view_ctxt->u4_recon_mb_grp << 2) - 1;
+        ps_view_ctxt->s_tran_addrecon.u2_mv_left_inc = (ps_view_ctxt->u4_recon_mb_grp - 1) << 4;
     }
 
     if((ps_sps->u1_profile_idc == HIGH_PROFILE_IDC) ||
@@ -1242,9 +1242,9 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
     nalu_mvc_ext_t *ps_cur_nalu_mvc_ext = imvcd_get_cur_nalu_mvc_ext(ps_mvcd_ctxt);
 
     UWORD32 u4_num_mbs = 0;
-    UWORD32 u4_mb_idx = ps_view_ctxt->u1_mb_idx;
+    UWORD32 u4_mb_idx = ps_view_ctxt->u4_mb_idx;
     UWORD32 u4_remaining_mbs =
-        (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1) - ps_view_ctxt->u2_total_mbs_coded;
+        (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1) - ps_view_ctxt->u4_total_mbs_coded;
 
     if(ps_view_ctxt->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC)
     {
@@ -1255,7 +1255,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
         return OK;
     }
 
-    if((ISLICE == ps_slice->u1_slice_type) || (0 == ps_view_ctxt->u2_total_mbs_coded))
+    if((ISLICE == ps_slice->u1_slice_type) || (0 == ps_view_ctxt->u4_total_mbs_coded))
     {
         yuv_buf_props_t *ps_view_buf =
             &ps_mvcd_ctxt->ps_cur_au->as_view_buffers[ps_cur_nalu_mvc_ext->u2_view_id];
@@ -1290,34 +1290,34 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
 
     ps_view_ctxt->ps_dpb_cmds->u1_long_term_reference_flag = 0;
 
-    if(ps_view_ctxt->u2_total_mbs_coded > 0)
+    if(ps_view_ctxt->u4_total_mbs_coded > 0)
     {
-        ps_view_ctxt->u2_total_mbs_coded -=
-            ps_view_ctxt->u2_total_mbs_coded % ps_view_ctxt->ps_cur_sps->u2_frm_wd_in_mbs;
+        ps_view_ctxt->u4_total_mbs_coded -=
+            ps_view_ctxt->u4_total_mbs_coded % ps_view_ctxt->ps_cur_sps->u2_frm_wd_in_mbs;
         u4_remaining_mbs =
-            (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1) - ps_view_ctxt->u2_total_mbs_coded;
+            (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1) - ps_view_ctxt->u4_total_mbs_coded;
 
         while(ps_view_ctxt->u4_dec_thread_created &&
-              (ps_view_ctxt->cur_dec_mb_num < ps_view_ctxt->u2_total_mbs_coded))
+              (ps_view_ctxt->cur_dec_mb_num < ps_view_ctxt->u4_total_mbs_coded))
         {
             NOP(1 << 10);
         }
 
         while(ps_view_ctxt->u4_bs_deblk_thread_created &&
-              (ps_view_ctxt->cur_recon_mb_num < ps_view_ctxt->u2_total_mbs_coded))
+              (ps_view_ctxt->cur_recon_mb_num < ps_view_ctxt->u4_total_mbs_coded))
         {
             NOP(1 << 10);
         }
 
         while(ps_view_ctxt->u4_bs_deblk_thread_created &&
-              (ps_view_ctxt->u4_cur_deblk_mb_num < ps_view_ctxt->u2_total_mbs_coded))
+              (ps_view_ctxt->u4_cur_deblk_mb_num < ps_view_ctxt->u4_total_mbs_coded))
         {
             NOP(1 << 10);
         }
 
-        ps_view_ctxt->ps_nmb_info = ps_view_ctxt->ps_frm_mb_info + ps_view_ctxt->u2_total_mbs_coded;
+        ps_view_ctxt->ps_nmb_info = ps_view_ctxt->ps_frm_mb_info + ps_view_ctxt->u4_total_mbs_coded;
         ps_view_ctxt->ps_deblk_mbn = ps_view_ctxt->ps_cur_deblk_mb =
-            ps_view_ctxt->ps_deblk_pic + ps_view_ctxt->u2_total_mbs_coded;
+            ps_view_ctxt->ps_deblk_pic + ps_view_ctxt->u4_total_mbs_coded;
     }
 
     u4_num_mbs = ps_view_ctxt->u4_num_mbs_cur_nmb = 0;
@@ -1336,7 +1336,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
 
     ps_view_ctxt->u1_mb_ngbr_availablity = ps_cur_mb_info->u1_mb_ngbr_availablity;
 
-    if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
+    if(ps_view_ctxt->u4_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
     {
         ps_view_ctxt->u1_pic_decode_done = 1;
 
@@ -1350,8 +1350,8 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
         (volatile void **) ps_view_ctxt->pv_map_ref_idx_to_poc_buf;
     ps_slice->i1_slice_alpha_c0_offset = 0;
     ps_slice->i1_slice_beta_offset = 0;
-    ps_slice->u2_first_mb_in_slice = ps_view_ctxt->u2_total_mbs_coded;
-    ps_view_ctxt->ps_parse_cur_slice->u4_first_mb_in_slice = ps_view_ctxt->u2_total_mbs_coded;
+    ps_slice->u2_first_mb_in_slice = ps_view_ctxt->u4_total_mbs_coded;
+    ps_view_ctxt->ps_parse_cur_slice->u4_first_mb_in_slice = ps_view_ctxt->u4_total_mbs_coded;
     ps_view_ctxt->ps_parse_cur_slice->u2_log2Y_crwd = ps_slice->u2_log2Y_crwd;
 
     if(ps_view_ctxt->u1_separate_parse)
@@ -1375,28 +1375,28 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
     ps_view_ctxt->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb;
     ps_view_ctxt->ps_part = ps_view_ctxt->ps_parse_part_params;
     ps_view_ctxt->u2_mbx =
-        MOD(ps_view_ctxt->u2_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
+        MOD((WORD32)ps_view_ctxt->u4_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
     ps_view_ctxt->u2_mby =
-        DIV(ps_view_ctxt->u2_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
+        DIV((WORD32)ps_view_ctxt->u4_total_mbs_coded - 1, ps_view_ctxt->u2_frm_wd_in_mbs);
 
     /******************************************************/
     /* Parsing / decoding the slice                       */
     /******************************************************/
     ps_view_ctxt->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_view_ctxt, 0);
-    u4_mb_idx = ps_view_ctxt->u1_mb_idx;
+    u4_mb_idx = ps_view_ctxt->u4_mb_idx;
     ps_parse_mb_data = ps_view_ctxt->ps_parse_mb_data;
     u4_num_mbs = u4_mb_idx;
 
     b_is_slice_end = false;
     b_tfr_n_mb = false;
     b_decode_nmb = false;
-    i2_cur_mb_addr = ps_view_ctxt->u2_total_mbs_coded;
+    i2_cur_mb_addr = ps_view_ctxt->u4_total_mbs_coded;
     u4_mb_skip_run = u4_remaining_mbs;
 
     while(!b_is_slice_end)
     {
-        if(i2_cur_mb_addr > ps_view_ctxt->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_view_ctxt->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -1411,7 +1411,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
         ps_cur_deblk_mb = ps_view_ctxt->ps_deblk_mbn + u4_num_mbs;
 
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         /**************************************************************/
         /* Get the required information for decoding of MB            */
@@ -1464,7 +1464,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
         b_is_slice_end = !u4_mb_skip_run;
         ps_cur_mb_info->u1_end_of_slice = !u4_mb_skip_run;
         b_tfr_n_mb =
-            (u4_num_mbs == ps_view_ctxt->u1_recon_mb_grp) || b_is_end_of_row || b_is_slice_end;
+            (u4_num_mbs == ps_view_ctxt->u4_recon_mb_grp) || b_is_end_of_row || b_is_slice_end;
         b_decode_nmb = b_tfr_n_mb || b_is_slice_end;
 
         if(b_decode_nmb)
@@ -1487,7 +1487,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
                                             b_tfr_n_mb, b_is_end_of_row);
             }
 
-            ps_view_ctxt->u2_total_mbs_coded += u4_num_mbs;
+            ps_view_ctxt->u4_total_mbs_coded += u4_num_mbs;
 
             if(b_tfr_n_mb)
             {
@@ -1495,7 +1495,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
             }
 
             u4_mb_idx = u4_num_mbs;
-            ps_view_ctxt->u1_mb_idx = u4_num_mbs;
+            ps_view_ctxt->u4_mb_idx = u4_num_mbs;
         }
     }
 
@@ -1503,7 +1503,7 @@ static WORD32 imvcd_corrupted_slice_handler(mvc_dec_ctxt_t *ps_mvcd_ctxt)
     ps_view_ctxt->i2_prev_slice_mbx = ps_view_ctxt->u2_mbx;
     ps_view_ctxt->i2_prev_slice_mby = ps_view_ctxt->u2_mby;
 
-    if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
+    if(ps_view_ctxt->u4_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
     {
         ps_view_ctxt->u1_pic_decode_done = 1;
     }
@@ -1909,7 +1909,7 @@ static WORD32 imvcd_finish_slice_decode(mvc_dec_ctxt_t *ps_mvcd_ctxt)
     imvcd_dpb_reset_ivp_ctxt(ps_mvcd_ctxt->ps_dpb_mgr);
 
     /* End of Picture detection */
-    if(ps_view_ctxt->u2_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u2_max_mb_addr + 1))
+    if(ps_view_ctxt->u4_total_mbs_coded >= (ps_view_ctxt->ps_cur_sps->u4_max_mb_addr + 1))
     {
         ps_view_ctxt->u1_pic_decode_done = 1;
     }
@@ -2027,7 +2027,7 @@ WORD32 imvcd_parse_decode_slice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
     {
         ps_view_ctxt->u2_mbx = 0xffff;
         ps_view_ctxt->u2_mby = 0;
-        ps_view_ctxt->u2_total_mbs_coded = 0;
+        ps_view_ctxt->u4_total_mbs_coded = 0;
 
         if(0 == u2_view_order_id)
         {
@@ -2287,7 +2287,7 @@ WORD32 imvcd_parse_decode_slice(mvc_dec_ctxt_t *ps_mvcd_ctxt)
 
     ps_view_ctxt->i4_submb_ofst = -SUB_BLK_SIZE;
 
-    ps_view_ctxt->u2_cur_mb_addr = 0;
+    ps_view_ctxt->u4_cur_mb_addr = 0;
     ps_view_ctxt->ps_deblk_mbn = ps_view_ctxt->ps_deblk_pic;
     ps_view_ctxt->ps_mv_cur = ps_mvcd_ctxt->ps_cur_au->ps_au_mv_data->aps_mvs[u2_view_id];
 
diff --git a/decoder/mvc/imvcd_utils.c b/decoder/mvc/imvcd_utils.c
index 5fc1014..0a2cc91 100644
--- a/decoder/mvc/imvcd_utils.c
+++ b/decoder/mvc/imvcd_utils.c
@@ -686,7 +686,7 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
     dec_struct_t *ps_view_ctxt = &ps_mvcd_ctxt->s_view_dec_ctxt;
     dec_seq_params_t *ps_sps = ps_view_ctxt->ps_cur_sps;
 
-    UWORD32 u4_total_mbs = ps_sps->u2_total_num_of_mbs;
+    UWORD32 u4_total_mbs = ps_sps->u4_total_num_of_mbs;
     UWORD32 u4_wd_mbs = ps_view_ctxt->u2_frm_wd_in_mbs;
     UWORD32 u4_ht_mbs = ps_view_ctxt->u2_frm_ht_in_mbs;
     const WORD32 i4_default_alignment = 128;
@@ -726,13 +726,13 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
     ps_view_ctxt->ps_computebs_cur_slice = ps_view_ctxt->ps_dec_slice_buf;
     ps_view_ctxt->ps_pred_start = ps_view_ctxt->ps_pred;
 
-    i4_mem_size = sizeof(parse_pmbarams_t) * (ps_view_ctxt->u1_recon_mb_grp);
+    i4_mem_size = sizeof(parse_pmbarams_t) * (ps_view_ctxt->u4_recon_mb_grp);
     pv_buf = ps_view_ctxt->pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
     memset(pv_buf, 0, i4_mem_size);
     ps_view_ctxt->ps_parse_mb_data = pv_buf;
 
-    i4_mem_size = sizeof(parse_part_params_t) * ((ps_view_ctxt->u1_recon_mb_grp) << 4);
+    i4_mem_size = sizeof(parse_part_params_t) * ((ps_view_ctxt->u4_recon_mb_grp) << 4);
     pv_buf = ps_view_ctxt->pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
     memset(pv_buf, 0, i4_mem_size);
@@ -753,13 +753,13 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
      for CABAC context representing MB not available */
     ps_view_ctxt->p_ctxt_inc_mb_map += 1;
 
-    i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u1_recon_mb_grp * 16;
+    i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u4_recon_mb_grp * 16;
     pv_buf = ps_view_ctxt->pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
     memset(pv_buf, 0, i4_mem_size);
     ps_view_ctxt->ps_mv_p[0] = pv_buf;
 
-    i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u1_recon_mb_grp * 16;
+    i4_mem_size = sizeof(mv_pred_t) * ps_view_ctxt->u4_recon_mb_grp * 16;
     pv_buf = ps_view_ctxt->pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);
     RETURN_IF((NULL == pv_buf), IV_FAIL);
     memset(pv_buf, 0, i4_mem_size);
@@ -767,7 +767,7 @@ WORD32 imvcd_allocate_dynamic_bufs(mvc_dec_ctxt_t *ps_mvcd_ctxt)
 
     for(i = 0; i < MV_SCRATCH_BUFS; i++)
     {
-        i4_mem_size = (sizeof(mv_pred_t) * ps_view_ctxt->u1_recon_mb_grp * 4);
+        i4_mem_size = (sizeof(mv_pred_t) * ps_view_ctxt->u4_recon_mb_grp * 4);
         pv_buf = ps_view_ctxt->pf_aligned_alloc(pv_mem_ctxt, i4_default_alignment, i4_mem_size);
         RETURN_IF((NULL == pv_buf), IV_FAIL);
         memset(pv_buf, 0, i4_mem_size);
diff --git a/decoder/svc/isvcd_api.c b/decoder/svc/isvcd_api.c
index 1d58ab5..b436cb4 100644
--- a/decoder/svc/isvcd_api.c
+++ b/decoder/svc/isvcd_api.c
@@ -1148,7 +1148,7 @@ void isvcd_init_decoder(svc_dec_lyr_struct_t *ps_dec_svc_lyr_params)
     ps_dec->u1_pr_sl_type = 0xFF;
     ps_dec->u2_mbx = 0xffff;
     ps_dec->u2_mby = 0;
-    ps_dec->u2_total_mbs_coded = 0;
+    ps_dec->u4_total_mbs_coded = 0;
 
     /* POC initializations */
     ps_prev_poc = &ps_dec->s_prev_pic_poc;
@@ -1169,7 +1169,7 @@ void isvcd_init_decoder(svc_dec_lyr_struct_t *ps_dec_svc_lyr_params)
 
     ps_dec->i4_max_poc = 0;
     ps_dec->i4_prev_max_display_seq = 0;
-    ps_dec->u1_recon_mb_grp = 4;
+    ps_dec->u4_recon_mb_grp = 4;
     ps_dec->i4_reorder_depth = -1;
 
     /* Field PIC initializations */
@@ -5222,8 +5222,8 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
                 ps_dec->i4_content_type = IV_CONTENTTYPE_NA;
 
                 ps_dec->u4_slice_start_code_found = 0;
-                ps_dec->u2_cur_mb_addr = 0;
-                ps_dec->u2_total_mbs_coded = 0;
+                ps_dec->u4_cur_mb_addr = 0;
+                ps_dec->u4_total_mbs_coded = 0;
                 ps_dec->u2_cur_slice_num = 0;
                 ps_dec->cur_dec_mb_num = 0;
                 ps_dec->cur_recon_mb_num = 0;
@@ -5354,7 +5354,7 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
                 ps_cur_node = ps_cur_node->ps_top_node;
 
                 if((ps_dec->u4_pic_buf_got == 1) && (ret != IVD_MEM_ALLOC_FAILED) &&
-                   ps_dec->u2_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
+                   ps_dec->u4_total_mbs_coded < ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
                 {
                     // last slice - missing/corruption
                     WORD32 num_mb_skipped;
@@ -5364,14 +5364,14 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
                     WORD32 ht_in_mbs;
                     ht_in_mbs = ps_dec->u2_pic_ht >> (4 + ps_dec->ps_cur_slice->u1_field_pic_flag);
                     num_mb_skipped =
-                        (ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
+                        (ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
 
                     if(ps_dec->u4_first_slice_in_pic && (ps_dec->u4_pic_buf_got == 0))
                         prev_slice_err = 1;
                     else
                         prev_slice_err = 2;
 
-                    if(ps_dec->u2_total_mbs_coded == 0)
+                    if(ps_dec->u4_total_mbs_coded == 0)
                     {
                         prev_slice_err = 1;
                     }
@@ -5542,7 +5542,7 @@ WORD32 isvcd_video_decode(iv_obj_t *dec_hdl, void *pv_api_ip, void *pv_api_op)
                     /*set to complete ,as we dont support partial frame decode*/
                     if(ps_dec->i4_header_decoded == 3)
                     {
-                        ps_dec->u2_total_mbs_coded = ps_dec->ps_cur_sps->u2_max_mb_addr + 1;
+                        ps_dec->u4_total_mbs_coded = ps_dec->ps_cur_sps->u4_max_mb_addr + 1;
                     }
 
                     /*Update the i4_frametype at the end of picture*/
diff --git a/decoder/svc/isvcd_defs.h b/decoder/svc/isvcd_defs.h
index 4162713..fa69f54 100644
--- a/decoder/svc/isvcd_defs.h
+++ b/decoder/svc/isvcd_defs.h
@@ -49,9 +49,9 @@ typedef enum
 
 #define FLUSH 2
 
-#define SVCD_MAX_FRAME_WIDTH 4080
-#define SVCD_MAX_FRAME_HEIGHT 4080
-#define SVCD_MAX_FRAME_SIZE (4096 * 2048)
+#define SVCD_MAX_FRAME_WIDTH 4096
+#define SVCD_MAX_FRAME_HEIGHT 4096
+#define SVCD_MAX_FRAME_SIZE (4096 * 4096)
 
 #define SVCD_MIN_FRAME_WIDTH 32
 #define SVCD_MIN_FRAME_HEIGHT 32
diff --git a/decoder/svc/isvcd_mb_utils.c b/decoder/svc/isvcd_mb_utils.c
index 4844be1..083df34 100644
--- a/decoder/svc/isvcd_mb_utils.c
+++ b/decoder/svc/isvcd_mb_utils.c
@@ -104,7 +104,7 @@ UWORD32 isvcd_get_mb_info_cabac_nonmbaff(dec_struct_t *ps_dec, const UWORD16 u2_
     /*--------------------------------------------------------------------*/
     mb_x = (WORD16) ps_dec->u2_mbx;
     mb_y = (WORD16) ps_dec->u2_mby;
-    ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
+    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
 
     mb_x++;
     if((UWORD32) mb_x == u2_frm_width_in_mb)
@@ -283,7 +283,7 @@ UWORD32 isvcd_get_mb_info_cavlc_nonmbaff(dec_struct_t *ps_dec, const UWORD16 u2_
     mb_x = (WORD16) ps_dec->u2_mbx;
     mb_y = (WORD16) ps_dec->u2_mby;
 
-    ps_dec->u2_cur_mb_addr = u2_cur_mb_address;
+    ps_dec->u4_cur_mb_addr = u2_cur_mb_address;
 
     mb_x++;
 
diff --git a/decoder/svc/isvcd_parse_ebslice.c b/decoder/svc/isvcd_parse_ebslice.c
index b1807ea..dfe4d57 100644
--- a/decoder/svc/isvcd_parse_ebslice.c
+++ b/decoder/svc/isvcd_parse_ebslice.c
@@ -231,7 +231,7 @@ WORD32 isvcd_parse_bmb_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_mb_info_t
  *    0 on Success and Error code otherwise
  **************************************************************************
  */
-WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, UWORD8 u1_num_mbs)
+WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD32 u4_mb_idx, UWORD32 u4_num_mbs)
 {
     svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) ps_dec;
     parse_pmbarams_t *ps_mb_part_info;
@@ -247,12 +247,12 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
     WORD32 ret = 0;
     WORD16 i2_mv_x, i2_mv_y;
 
-    ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
+    ps_dec->i4_submb_ofst -= (u4_num_mbs - u4_mb_idx) << 4;
     ps_mb_part_info = ps_dec->ps_parse_mb_data;
     ps_part = ps_dec->ps_parse_part_params;
 
     /* N/2 Mb MvPred and Transfer Setup Loop */
-    for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
+    for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
     {
         UWORD8 u1_colz = 0;
         ps_dec->i4_submb_ofst += SUB_BLK_SIZE;
@@ -267,7 +267,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
         ps_dec->u2_mv_2mb[i & 0x1] = 0;
 
         /* Look for MV Prediction and Reference Transfer in Non-I Mbs */
-        if(!ps_mb_part_info->u1_isI_mb)
+        if(!ps_mb_part_info->u4_isI_mb)
         {
             UWORD8 u1_blk_no;
             WORD16 i1_ref_idx, i1_ref_idx1;
@@ -287,7 +287,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
 
             /* MB Level initialisations */
             ps_dec->u4_num_pmbair = i >> u1_mbaff;
-            ps_dec->u1_mb_idx_mv = i;
+            ps_dec->u4_mb_idx_mv = i;
 
             i4_mb_mode_svc = isvcd_interlyr_motion_mode_pred(
                 ps_svc_lyr_dec, ps_cur_mb_info, ps_svc_cur_mb_info, ps_mb_part_info, ps_part);
diff --git a/decoder/svc/isvcd_parse_eislice.c b/decoder/svc/isvcd_parse_eislice.c
index c412fc5..340ef49 100644
--- a/decoder/svc/isvcd_parse_eislice.c
+++ b/decoder/svc/isvcd_parse_eislice.c
@@ -134,7 +134,7 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     ps_dec->i1_prev_mb_qp_delta = 0;
 
     /* initializations */
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
     uc_more_data_flag = 1;
     i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
@@ -143,7 +143,7 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         UWORD16 u2_mbx;
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -253,7 +253,7 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_tfr_n_mb =
-            (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
+            (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
         ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
 
         if(u1_tfr_n_mb || (!uc_more_data_flag))
@@ -279,10 +279,10 @@ WORD32 isvcd_parse_islice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                         u1_end_of_row);
                 }
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     } while(uc_more_data_flag);
 
@@ -339,7 +339,7 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
 
     /* initializations */
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
 
     uc_more_data_flag = 1;
@@ -348,7 +348,7 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     {
         UWORD8 u1_mb_type;
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -460,7 +460,7 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_tfr_n_mb =
-            (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
+            (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
         ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
 
         if(u1_tfr_n_mb || (!uc_more_data_flag))
@@ -486,10 +486,10 @@ WORD32 isvcd_parse_islice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                         u1_end_of_row);
                 }
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     } while(uc_more_data_flag);
 
@@ -1230,7 +1230,7 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     ps_dec->i1_prev_mb_qp_delta = 0;
     ps_cab_env = &ps_dec->s_cab_dec_env;
     /* initializations */
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
     uc_more_data_flag = 1;
     i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
@@ -1238,7 +1238,7 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     {
         UWORD16 u2_mbx;
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -1402,7 +1402,7 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_tfr_n_mb =
-            (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
+            (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
         ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
 
         if(u1_tfr_n_mb || (!uc_more_data_flag))
@@ -1421,10 +1421,10 @@ WORD32 isvcd_parse_eislice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                               u1_end_of_row);
                 if(ret != OK) return ret;
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     } while(uc_more_data_flag);
 
@@ -1482,7 +1482,7 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     ih264d_update_qp(ps_dec, 0);
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
 
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
     uc_more_data_flag = 1;
     i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff;
@@ -1491,7 +1491,7 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     {
         UWORD8 u1_mb_type;
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -1627,7 +1627,7 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_tfr_n_mb =
-            (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
+            (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || (!uc_more_data_flag);
         ps_cur_mb_info->u1_end_of_slice = (!uc_more_data_flag);
 
         if(u1_tfr_n_mb || (!uc_more_data_flag))
@@ -1646,10 +1646,10 @@ WORD32 isvcd_parse_eislice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                               u1_end_of_row);
                 if(ret != OK) return ret;
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     } while(uc_more_data_flag);
 
diff --git a/decoder/svc/isvcd_parse_epslice.c b/decoder/svc/isvcd_parse_epslice.c
index 36621ba..aab086b 100644
--- a/decoder/svc/isvcd_parse_epslice.c
+++ b/decoder/svc/isvcd_parse_epslice.c
@@ -549,7 +549,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     i2_cur_mb_addr = u2_first_mb_in_slice;
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
     u1_num_mbsNby2 = 0;
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@@ -575,7 +575,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
 
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -590,7 +590,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         /***************************************************************/
         /* Get the required information for decoding of MB             */
@@ -671,7 +671,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
             {
                 /* Storing Intra partition info */
                 ps_parse_mb_data->u1_num_part = 0;
-                ps_parse_mb_data->u1_isI_mb = 1;
+                ps_parse_mb_data->u4_isI_mb = 1;
 
                 if((25 + u1_mb_threshold) == u1_mb_type)
                 {
@@ -737,7 +737,7 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = !uc_more_data_flag;
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
 
@@ -775,10 +775,10 @@ WORD32 isvcd_parse_inter_slice_data_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                         u1_end_of_row);
                 }
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     }
 
@@ -864,7 +864,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     /******************************************************/
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
 
     u1_num_mbsNby2 = 0;
@@ -879,7 +879,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         UWORD8 u1_mb_type;
 
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -894,7 +894,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         if((!i2_mb_skip_run) && (!u1_read_mb_type))
         {
@@ -1019,7 +1019,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
             {
                 /* Storing Intra partition info */
                 ps_parse_mb_data->u1_num_part = 0;
-                ps_parse_mb_data->u1_isI_mb = 1;
+                ps_parse_mb_data->u4_isI_mb = 1;
 
                 if((25 + u1_mb_threshold) == u1_mb_type)
                 {
@@ -1073,7 +1073,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
 
@@ -1109,10 +1109,10 @@ WORD32 isvcd_parse_inter_slice_data_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                         u1_end_of_row);
                 }
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     }
 
@@ -1203,7 +1203,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
     i2_cur_mb_addr = u2_first_mb_in_slice;
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
     u1_num_mbsNby2 = 0;
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@@ -1228,7 +1228,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         UWORD8 u1_mb_type;
         UWORD32 u4_mb_skip;
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -1243,7 +1243,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         /***************************************************************/
         /* Get the required information for decoding of MB             */
@@ -1424,7 +1424,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
             {
                 /* Storing Intra partition info */
                 ps_parse_mb_data->u1_num_part = 0;
-                ps_parse_mb_data->u1_isI_mb = 1;
+                ps_parse_mb_data->u4_isI_mb = 1;
 
                 if((25 + u1_mb_threshold) == u1_mb_type)
                 {
@@ -1451,7 +1451,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                         ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
                     }
                 }
-                ps_parse_mb_data->u1_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
+                ps_parse_mb_data->u4_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
             }
         }
 
@@ -1495,7 +1495,7 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = !uc_more_data_flag;
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
 
@@ -1524,10 +1524,10 @@ isvcd_parse_inter_slice_data_cabac_enh_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                               u1_end_of_row);
                 if(ret != OK) return ret;
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     }
 
@@ -1621,7 +1621,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
     /******************************************************/
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     u1_num_mbs = u1_mb_idx;
     u1_num_mbsNby2 = 0;
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
@@ -1636,7 +1636,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
 
         ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data;
 
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr)
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr)
         {
             break;
         }
@@ -1653,7 +1653,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         if((!i2_mb_skip_run) && (!u1_read_mb_type))
         {
@@ -1859,7 +1859,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
                         ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB;
                     }
                 }
-                ps_parse_mb_data->u1_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
+                ps_parse_mb_data->u4_isI_mb = !ps_svc_cur_mb_info->u1_base_mode_flag;
             }
             uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm);
         }
@@ -1894,7 +1894,7 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run));
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
 
@@ -1923,10 +1923,10 @@ WORD32 isvcd_parse_inter_slice_data_cavlc_enh_lyr(svc_dec_lyr_struct_t *ps_svc_l
                                                               u1_end_of_row);
                 if(ret != OK) return ret;
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     }
 
@@ -2656,7 +2656,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
     dec_struct_t *ps_dec = &ps_svc_lyr_dec->s_dec;
     WORD32 i2_cur_mb_addr;
     UWORD32 u1_num_mbs;
-    UWORD32 u1_mb_idx = ps_dec->u1_mb_idx;
+    UWORD32 u1_mb_idx = ps_dec->u4_mb_idx;
     UWORD32 i2_mb_skip_run;
     UWORD32 u1_num_mbs_next, u1_end_of_row;
     const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs;
@@ -2804,7 +2804,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
             if((ps_dec->ps_cur_slice->u1_mbaff_frame_flag) && (ps_dec->u4_num_mbs_cur_nmb & 1))
             {
                 ps_dec->u4_num_mbs_cur_nmb = ps_dec->u4_num_mbs_cur_nmb - 1;
-                ps_dec->u2_cur_mb_addr--;
+                ps_dec->u4_cur_mb_addr--;
             }
 
             u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb;
@@ -2832,7 +2832,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
             {
                 // Going back 1 mb
                 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data;
-                ps_dec->u2_cur_mb_addr--;
+                ps_dec->u4_cur_mb_addr--;
                 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE;
 
                 // Parse/decode N-MB left unparsed
@@ -2868,12 +2868,12 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
                     ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next,
                                                 u1_tfr_n_mb, u1_end_of_row);
                 }
-                ps_dec->u2_total_mbs_coded += u1_num_mbs;
-                ps_dec->u1_mb_idx = 0;
+                ps_dec->u4_total_mbs_coded += u1_num_mbs;
+                ps_dec->u4_mb_idx = 0;
                 ps_dec->u4_num_mbs_cur_nmb = 0;
             }
 
-            if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
+            if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
             {
                 ps_dec->u1_pic_decode_done = 1;
                 return 0;
@@ -2881,7 +2881,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
 
             /* Inserting new slice only if the current slice has atleast 1 MB*/
             if(ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
-               (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
+               (UWORD32) (ps_dec->u4_total_mbs_coded >> ps_slice->u1_mbaff_frame_flag))
             {
                 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
                 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
@@ -2920,14 +2920,14 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
         ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **) pu1_buf;
     }
     u1_mbaff = ps_slice->u1_mbaff_frame_flag;
-    ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
+    ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
     ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0;
     ps_dec->ps_cur_slice->i1_slice_beta_offset = 0;
 
     if(ps_dec->ps_cur_slice->u1_field_pic_flag)
         ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num;
 
-    ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded >> u1_mbaff;
+    ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u4_total_mbs_coded >> u1_mbaff;
     ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd;
 
     if(ps_dec->u1_separate_parse)
@@ -2964,15 +2964,15 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
 
     ps_dec->u1_qp = ps_slice->u1_slice_qp;
     ih264d_update_qp(ps_dec, 0);
-    u1_mb_idx = ps_dec->u1_mb_idx;
+    u1_mb_idx = ps_dec->u4_mb_idx;
     ps_parse_mb_data = ps_dec->ps_parse_mb_data;
     u1_num_mbs = u1_mb_idx;
     u1_slice_end = 0;
     u1_tfr_n_mb = 0;
     u1_decode_nmb = 0;
-    i2_cur_mb_addr = ps_dec->u2_total_mbs_coded;
+    i2_cur_mb_addr = ps_dec->u4_total_mbs_coded;
     i2_mb_skip_run = num_mb_skip;
-    if(0 == ps_dec->u2_total_mbs_coded)
+    if(0 == ps_dec->u4_total_mbs_coded)
     {
         ps_dec->ps_cur_mb_row = ps_dec->ps_nbr_mb_row;  //[0];
         // Increment by 2 ,so that left mb (mbaff decrements by 2)  will always be valid
@@ -2996,7 +2996,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
     }
     while(!u1_slice_end)
     {
-        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) break;
+        if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u4_max_mb_addr) break;
 
         ps_svc_cur_mb_info = ps_svc_lyr_dec->ps_svc_nmb_info + u1_num_mbs;
         ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs;
@@ -3008,7 +3008,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
 
         /* Storing Default partition info */
         ps_parse_mb_data->u1_num_part = 1;
-        ps_parse_mb_data->u1_isI_mb = 0;
+        ps_parse_mb_data->u4_isI_mb = 0;
 
         /**************************************************************/
         /* Get the required information for decoding of MB            */
@@ -3100,7 +3100,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
         u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1;
         u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01)));
         u1_slice_end = !i2_mb_skip_run;
-        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row || u1_slice_end;
+        u1_tfr_n_mb = (u1_num_mbs == ps_dec->u4_recon_mb_grp) || u1_end_of_row || u1_slice_end;
         u1_decode_nmb = u1_tfr_n_mb || u1_slice_end;
         ps_cur_mb_info->u1_end_of_slice = u1_slice_end;
 
@@ -3136,10 +3136,10 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
                                                         u1_end_of_row);
                 }
             }
-            ps_dec->u2_total_mbs_coded += u1_num_mbs;
+            ps_dec->u4_total_mbs_coded += u1_num_mbs;
             if(u1_tfr_n_mb) u1_num_mbs = 0;
             u1_mb_idx = u1_num_mbs;
-            ps_dec->u1_mb_idx = u1_num_mbs;
+            ps_dec->u4_mb_idx = u1_num_mbs;
         }
     }
 
@@ -3159,7 +3159,7 @@ WORD32 isvcd_mark_err_slice_skip(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 nu
     ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx;
     ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
 
-    if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
+    if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
     {
         ps_dec->u1_pic_decode_done = 1;
     }
diff --git a/decoder/svc/isvcd_parse_headers.c b/decoder/svc/isvcd_parse_headers.c
index d137040..4bc37ec 100644
--- a/decoder/svc/isvcd_parse_headers.c
+++ b/decoder/svc/isvcd_parse_headers.c
@@ -418,11 +418,11 @@ WORD32 isvcd_parse_subset_sps(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_bit_stre
     /*--------------------------------------------------------------------*/
     /* Get the value of MaxMbAddress and Number of bits needed for it     */
     /*--------------------------------------------------------------------*/
-    ps_seq->u2_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
+    ps_seq->u4_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
 
-    ps_seq->u2_total_num_of_mbs = ps_seq->u2_max_mb_addr + 1;
+    ps_seq->u4_total_num_of_mbs = ps_seq->u4_max_mb_addr + 1;
 
-    ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u2_total_num_of_mbs);
+    ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u4_total_num_of_mbs);
 
     u1_frm = ih264d_get_bit_h264(ps_bitstrm);
 
@@ -1379,9 +1379,9 @@ WORD32 isvcd_parse_sps(svc_dec_lyr_struct_t *ps_svc_lyr_dec, dec_bit_stream_t *p
     /*--------------------------------------------------------------------*/
     /* Get the value of MaxMbAddress and Number of bits needed for it     */
     /*--------------------------------------------------------------------*/
-    ps_seq->u2_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
-    ps_seq->u2_total_num_of_mbs = ps_seq->u2_max_mb_addr + 1;
-    ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u2_total_num_of_mbs);
+    ps_seq->u4_max_mb_addr = (ps_seq->u2_frm_wd_in_mbs * ps_seq->u2_frm_ht_in_mbs) - 1;
+    ps_seq->u4_total_num_of_mbs = ps_seq->u4_max_mb_addr + 1;
+    ps_seq->u1_level_idc = ih264d_correct_level_idc(u1_level_idc, ps_seq->u4_total_num_of_mbs);
 
     u1_frm = ih264d_get_bit_h264(ps_bitstrm);
     if((ps_dec->i4_header_decoded & 1) &&
diff --git a/decoder/svc/isvcd_parse_slice.c b/decoder/svc/isvcd_parse_slice.c
index 60bed2a..7749663 100644
--- a/decoder/svc/isvcd_parse_slice.c
+++ b/decoder/svc/isvcd_parse_slice.c
@@ -290,7 +290,7 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
     if(ps_dec->u1_separate_parse)
     {
         UWORD32 num_mbs;
-        num_mbs = ps_dec->ps_cur_sps->u2_total_num_of_mbs
+        num_mbs = ps_dec->ps_cur_sps->u4_total_num_of_mbs
                   << (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag);
 
         if(ps_dec->pu1_dec_mb_map)
@@ -472,9 +472,9 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
     ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
     ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0];
     ps_dec->u1_mv_top_p = 0;
-    ps_dec->u1_mb_idx = 0;
+    ps_dec->u4_mb_idx = 0;
     ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv;
-    ps_dec->u2_total_mbs_coded = 0;
+    ps_dec->u4_total_mbs_coded = 0;
     ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE);
     ps_dec->u4_pred_info_idx = 0;
     ps_dec->u4_pred_info_pkd_idx = 0;
@@ -548,11 +548,11 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
     {
         UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag;
         UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag;
-        UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4) % (ps_dec->u1_recon_mb_grp >> u1_mbaff));
+        UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4) % (ps_dec->u4_recon_mb_grp >> u1_mbaff));
         UWORD16 ui16_lastmbs_widthY =
-            (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp >> u1_mbaff) << 4));
+            (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u4_recon_mb_grp >> u1_mbaff) << 4));
         UWORD16 ui16_lastmbs_widthUV =
-            uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp >> u1_mbaff) << 3);
+            uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u4_recon_mb_grp >> u1_mbaff) << 3);
 
         ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
         ps_dec->s_tran_addrecon.pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2;
@@ -568,8 +568,8 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
         }
 
         /* Normal Increment of Pointer */
-        ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4) >> u1_mbaff);
-        ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4) >> u1_mbaff);
+        ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u4_recon_mb_grp << 4) >> u1_mbaff);
+        ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u4_recon_mb_grp << 4) >> u1_mbaff);
 
         /* End of Row Increment */
         ps_dec->s_tran_addrecon.u4_inc_y[1] =
@@ -583,8 +583,8 @@ WORD32 isvcd_start_of_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, WORD32 i4_poc,
         /* only once per picture.                      */
         ih264d_assign_pic_num(ps_dec);
         ps_dec->s_tran_addrecon.u2_mv_top_left_inc =
-            (ps_dec->u1_recon_mb_grp << 2) - 1 - (u1_mbaff << 2);
-        ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp >> u1_mbaff) - 1)
+            (ps_dec->u4_recon_mb_grp << 2) - 1 - (u1_mbaff << 2);
+        ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u4_recon_mb_grp >> u1_mbaff) - 1)
                                                  << (4 + u1_mbaff);
     }
     /**********************************************************************/
@@ -697,7 +697,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
     }
 
     /*we currently don not support ASO*/
-    if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u2_cur_mb_addr) &&
+    if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u4_cur_mb_addr) &&
        (ps_dec->u4_first_slice_in_pic == 0))
     {
         return ERROR_CORRUPTED_SLICE;
@@ -794,7 +794,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
 
     ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
     ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
-    ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
+    ps_dec->u4_total_mbs = ps_seq->u4_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
 
     /* Determining the Width and Height of Frame from that of Picture */
     ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
@@ -847,7 +847,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
             ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
         }
 
-        ps_dec->u2_total_mbs_coded = 0;
+        ps_dec->u4_total_mbs_coded = 0;
     }
     /* Get the field related flags  */
     if(!ps_seq->u1_frame_mbs_only_flag)
@@ -983,7 +983,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
                 ps_cur_slice->u1_bottom_field_flag = 0;
 
             num_mb_skipped =
-                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
+                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &ps_dec->s_cur_pic_poc;
 
             u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
@@ -1015,20 +1015,20 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
              * conceal the current frame completely */
             prev_slice_err = 2;
             num_mb_skipped =
-                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
+                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &s_tmp_poc;
         }
     }
     else
     {
-        if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
+        if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u4_total_mbs_coded)
         {
             // previous slice - missing/corruption
             prev_slice_err = 2;
-            num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
+            num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &s_tmp_poc;
         }
-        else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
+        else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u4_total_mbs_coded)
         {
             return ERROR_CORRUPTED_SLICE;
         }
@@ -1052,7 +1052,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
             return ERROR_INCOMPLETE_FRAME;
         }
 
-        if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
+        if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
         {
             /* return if all MBs in frame are parsed*/
             ps_dec->u1_first_slice_in_stream = 0;
@@ -1129,7 +1129,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
     /* Increment only if the current slice has atleast 1 more MB */
     if(ps_dec->u4_first_slice_in_pic == 0 &&
        (ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
-        (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
+        (UWORD32) (ps_dec->u4_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
     {
         ps_dec->ps_parse_cur_slice++;
         ps_dec->u2_cur_slice_num++;
@@ -1405,7 +1405,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
                         ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
                 }
 
-                ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
+                ps_dec->u4_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
 
                 ps_dec->ps_mv_cur =
                     ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
@@ -1427,7 +1427,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
             u2_mb_x = 0xffff;
             u2_mb_y = 0;
             // assign the deblock structure pointers to start of slice
-            ps_dec->u2_cur_mb_addr = 0;
+            ps_dec->u4_cur_mb_addr = 0;
             ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
             ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
             ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@@ -1548,7 +1548,7 @@ WORD32 isvcd_parse_decode_slice_ext_nal(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_re
     ps_dec->i2_prev_slice_mby = ps_dec->u2_mby;
 
     /* End of Picture detection */
-    if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
+    if(ps_dec->u4_total_mbs_coded >= (ps_seq->u4_max_mb_addr + 1))
     {
         ps_dec->u1_pic_decode_done = 1;
     }
@@ -1947,7 +1947,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
     }
 
     /*we currently don not support ASO*/
-    if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u2_cur_mb_addr) &&
+    if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) <= ps_dec->u4_cur_mb_addr) &&
        (ps_dec->u4_first_slice_in_pic == 0))
     {
         return ERROR_CORRUPTED_SLICE;
@@ -2045,7 +2045,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
 
     ps_dec->u2_pic_wd = ps_subset_seq->u2_pic_wd;
     ps_dec->u2_pic_ht = ps_subset_seq->u2_pic_ht;
-    ps_dec->u4_total_mbs = ps_seq->u2_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
+    ps_dec->u4_total_mbs = ps_seq->u4_total_num_of_mbs << (1 - ps_seq->u1_frame_mbs_only_flag);
 
     /* Determining the Width and Height of Frame from that of Picture */
     ps_dec->u2_frm_wd_y = ps_subset_seq->u2_frm_wd_y;
@@ -2097,7 +2097,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
             ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field;
         }
 
-        ps_dec->u2_total_mbs_coded = 0;
+        ps_dec->u4_total_mbs_coded = 0;
     }
     /* Get the field related flags  */
     if(!ps_seq->u1_frame_mbs_only_flag)
@@ -2232,7 +2232,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
                 ps_cur_slice->u1_bottom_field_flag = 0;
 
             num_mb_skipped =
-                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
+                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &ps_dec->s_cur_pic_poc;
 
             u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL;
@@ -2264,20 +2264,20 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
              * conceal the current frame completely */
             prev_slice_err = 2;
             num_mb_skipped =
-                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u2_total_mbs_coded;
+                (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &s_tmp_poc;
         }
     }
     else
     {
-        if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded)
+        if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u4_total_mbs_coded)
         {
             // previous slice - missing/corruption
             prev_slice_err = 2;
-            num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u2_total_mbs_coded;
+            num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) - ps_dec->u4_total_mbs_coded;
             ps_cur_poc = &s_tmp_poc;
         }
-        else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded)
+        else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u4_total_mbs_coded)
         {
             return ERROR_CORRUPTED_SLICE;
         }
@@ -2301,7 +2301,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
             return ERROR_INCOMPLETE_FRAME;
         }
 
-        if(ps_dec->u2_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
+        if(ps_dec->u4_total_mbs_coded >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)
         {
             /* return if all MBs in frame are parsed*/
             ps_dec->u1_first_slice_in_stream = 0;
@@ -2378,7 +2378,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
     /* Increment only if the current slice has atleast 1 more MB */
     if(ps_dec->u4_first_slice_in_pic == 0 &&
        (ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice <
-        (UWORD32) (ps_dec->u2_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
+        (UWORD32) (ps_dec->u4_total_mbs_coded >> ps_dec->ps_cur_slice->u1_mbaff_frame_flag)))
     {
         ps_dec->ps_parse_cur_slice++;
         ps_dec->u2_cur_slice_num++;
@@ -2660,7 +2660,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
                         ps_dec->ps_deblk_pic + (u2_first_mb_in_slice << u1_mb_aff);
                 }
 
-                ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
+                ps_dec->u4_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff);
 
                 ps_dec->ps_mv_cur =
                     ps_dec->s_cur_pic.ps_mv + ((u2_first_mb_in_slice << u1_mb_aff) << 4);
@@ -2682,7 +2682,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
             u2_mb_x = 0xffff;
             u2_mb_y = 0;
             // assign the deblock structure pointers to start of slice
-            ps_dec->u2_cur_mb_addr = 0;
+            ps_dec->u4_cur_mb_addr = 0;
             ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic;
             ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv;
             ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1;
@@ -2795,7 +2795,7 @@ WORD32 isvcd_parse_decode_slice(UWORD8 u1_is_idr_slice, UWORD8 u1_nal_ref_idc,
 
     /* End of Picture detection */
 
-    if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1))
+    if(ps_dec->u4_total_mbs_coded >= (ps_seq->u4_max_mb_addr + 1))
     {
         ps_dec->u1_pic_decode_done = 1;
     }
diff --git a/decoder/svc/isvcd_process_ebslice.h b/decoder/svc/isvcd_process_ebslice.h
index 501710c..d1dbaa1 100644
--- a/decoder/svc/isvcd_process_ebslice.h
+++ b/decoder/svc/isvcd_process_ebslice.h
@@ -46,8 +46,8 @@ WORD32 isvcd_parse_ebslice(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_firs
 
 WORD32 isvcd_parse_bslice(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_first_mb_in_slice);
 
-WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_svc_lyr_dec, UWORD8 u1_mb_idx,
-                                       UWORD8 u1_num_mbs);
+WORD32 isvcd_mv_pred_ref_tfr_nby2_ebmb(dec_struct_t *ps_svc_lyr_dec, UWORD32 u4_mb_idx,
+                                       UWORD32 u4_num_mbs);
 
 WORD32 isvcd_parse_bmb_non_direct_cabac(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                         dec_mb_info_t *ps_cur_mb_info,
@@ -60,5 +60,5 @@ WORD32 isvcd_parse_bmb_non_direct_cavlc(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                         UWORD8 u1_num_mbsNby2);
 
 WORD32 isvcd_decode_spatial_direct(dec_struct_t *ps_svc_lyr_dec, UWORD8 u1_wd_x,
-                                   dec_mb_info_t *ps_cur_mb_info, UWORD8 u1_mb_num);
+                                   dec_mb_info_t *ps_cur_mb_info, UWORD32 u4_mb_num);
 #endif /* _ISVCD_PROCESS_EBSLICE_H_ */
\ No newline at end of file
diff --git a/decoder/svc/isvcd_process_epslice.c b/decoder/svc/isvcd_process_epslice.c
index b351319..9466601 100644
--- a/decoder/svc/isvcd_process_epslice.c
+++ b/decoder/svc/isvcd_process_epslice.c
@@ -178,7 +178,7 @@ WORD32 isvcd_interlyr_motion_mode_pred(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
  *    0 on Success and Error code otherwise
  **************************************************************************
  */
-WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, UWORD8 u1_num_mbs)
+WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD32 u4_mb_idx, UWORD32 u4_num_mbs)
 {
     svc_dec_lyr_struct_t *ps_svc_lyr_dec = (svc_dec_lyr_struct_t *) ps_dec;
     parse_pmbarams_t *ps_mb_part_info;
@@ -190,12 +190,12 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
     dec_svc_mb_info_t *ps_svc_cur_mb_info;
     WORD32 i2_mv_x, i2_mv_y;
 
-    ps_dec->i4_submb_ofst -= (u1_num_mbs - u1_mb_idx) << 4;
+    ps_dec->i4_submb_ofst -= (u4_num_mbs - u4_mb_idx) << 4;
     ps_mb_part_info = ps_dec->ps_parse_mb_data;
     ps_part = ps_dec->ps_parse_part_params;
 
     /* N/2 Mb MvPred and Transfer Setup Loop */
-    for(i = u1_mb_idx; i < u1_num_mbs; i++, ps_mb_part_info++)
+    for(i = u4_mb_idx; i < u4_num_mbs; i++, ps_mb_part_info++)
     {
         UWORD32 u1_colz;
         UWORD32 u1_field;
@@ -217,7 +217,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
         ps_dec->u2_mv_2mb[i & 0x1] = 0;
 
         /* Look for MV Prediction and Reference Transfer in Non-I Mbs */
-        if(!ps_mb_part_info->u1_isI_mb)
+        if(!ps_mb_part_info->u4_isI_mb)
         {
             UWORD32 u1_blk_no;
             WORD32 i1_ref_idx, i1_ref_idx1;
@@ -233,7 +233,7 @@ WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_mb_idx, U
 
             /* MB Level initialisations */
             ps_dec->u4_num_pmbair = i >> u1_mbaff;
-            ps_dec->u1_mb_idx_mv = i;
+            ps_dec->u4_mb_idx_mv = i;
             ppu4_wt_ofst = ps_mb_part_info->pu4_wt_offst;
             pps_ref_frame = ps_dec->ps_ref_pic_buf_lx[0];
 
@@ -1415,7 +1415,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_non_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_
 
         for(j = u1_mb_idx; j < i; j++)
         {
-            if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
+            if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
             {
                 return NOT_OK;
             }
@@ -1430,7 +1430,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_non_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_
         /* Check for End Of Row in Next iteration                       */
         /****************************************************************/
         u1_end_of_row_next =
-            u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u1_recon_mb_grp >> u1_mbaff));
+            u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u4_recon_mb_grp >> u1_mbaff));
 
         /****************************************************************/
         /* Transfer the Following things                                */
@@ -1600,7 +1600,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                 }
             }
 
-            if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
+            if(ps_dec->u4_cur_deblk_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
             {
                 return NOT_OK;
             }
@@ -1616,7 +1616,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
         /* Check for End Of Row in Next iteration                       */
         /****************************************************************/
         u1_end_of_row_next =
-            u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u1_recon_mb_grp >> u1_mbaff));
+            u1_num_mbs_next && (u1_num_mbs_next <= (ps_dec->u4_recon_mb_grp >> u1_mbaff));
 
         /****************************************************************/
         /* Transfer the Following things                                */
diff --git a/decoder/svc/isvcd_process_epslice.h b/decoder/svc/isvcd_process_epslice.h
index 0330dd1..c7b3df8 100644
--- a/decoder/svc/isvcd_process_epslice.h
+++ b/decoder/svc/isvcd_process_epslice.h
@@ -71,8 +71,8 @@ WORD32 isvcd_process_inter_mb_rsd_pred_target_lyr(svc_dec_lyr_struct_t *ps_svc_l
                                                   UWORD8 u1_inference_mode,
                                                   UWORD16 *pu2_res_luma_csbp);
 
-WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD8 u1_num_mbs,
-                                       UWORD8 u1_num_mbsNby2);
+WORD32 isvcd_mv_pred_ref_tfr_nby2_epmb(dec_struct_t *ps_dec, UWORD32 u4_num_mbs,
+                                       UWORD32 u4_num_mbsNby2);
 
 WORD32 isvcd_decode_recon_tfr_nmb_non_base_lyr(svc_dec_lyr_struct_t *ps_svc_lyr_dec,
                                                UWORD8 u1_mb_idx, UWORD8 u1_num_mbs,
diff --git a/decoder/svc/isvcd_thread_parse_decode.c b/decoder/svc/isvcd_thread_parse_decode.c
index 9df58f0..a795022 100644
--- a/decoder/svc/isvcd_thread_parse_decode.c
+++ b/decoder/svc/isvcd_thread_parse_decode.c
@@ -344,7 +344,7 @@ WORD32 isvcd_decode_recon_tfr_nmb_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec, U
     }
 
     /*handle the last mb in picture case*/
-    if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
+    if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
         ps_dec->u4_cur_slice_decode_done = 1;
 
     if(i != u1_num_mbs)
@@ -496,7 +496,7 @@ WORD32 isvcd_decode_slice_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
     {
         u1_num_mbsleft = ((i2_pic_wdin_mbs - i16_mb_x) << u1_mbaff);
 
-        if(u1_num_mbsleft <= ps_dec->u1_recon_mb_grp)
+        if(u1_num_mbsleft <= ps_dec->u4_recon_mb_grp)
         {
             u1_num_mbs = u1_num_mbsleft;
 
@@ -507,10 +507,10 @@ WORD32 isvcd_decode_slice_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
         }
         else
         {
-            u1_num_mbs = ps_dec->u1_recon_mb_grp;
+            u1_num_mbs = ps_dec->u4_recon_mb_grp;
 
             /*Indicate number of mb's left in a row*/
-            u1_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x - (ps_dec->u1_recon_mb_grp >> u1_mbaff);
+            u1_num_mbs_next = i2_pic_wdin_mbs - i16_mb_x - (ps_dec->u4_recon_mb_grp >> u1_mbaff);
             i16_mb_x += (u1_num_mbs >> u1_mbaff);
             u1_end_of_row = 0;
         }
@@ -572,7 +572,7 @@ void isvcd_decode_picture_thread(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
             if(OK != ret) break;
             DEBUG_THREADS_PRINTF(" Exit  isvcd_decode_slice_thread\n");
 
-            if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u2_max_mb_addr)
+            if(ps_dec->cur_dec_mb_num > ps_dec->ps_cur_sps->u4_max_mb_addr)
             {
                 /*Last slice in frame*/
                 break;
diff --git a/decoder/svc/isvcd_utils.c b/decoder/svc/isvcd_utils.c
index 3220685..98ecf99 100644
--- a/decoder/svc/isvcd_utils.c
+++ b/decoder/svc/isvcd_utils.c
@@ -117,7 +117,7 @@ WORD16 isvcd_allocate_dynamic_bufs(svc_dec_lyr_struct_t *ps_svc_lyr_dec)
     WORD16 i16_status = 0;
     UWORD8 uc_frmOrFld = (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag);
     dec_seq_params_t *ps_sps = ps_dec->ps_cur_sps;
-    UWORD32 u4_total_mbs = ps_sps->u2_total_num_of_mbs << uc_frmOrFld;
+    UWORD32 u4_total_mbs = ps_sps->u4_total_num_of_mbs << uc_frmOrFld;
     WORD32 size;
     void *pv_buf;
     void *pv_mem_ctxt = ps_dec->pv_mem_ctxt;
@@ -773,7 +773,7 @@ WORD32 isvcd_init_pic(svc_dec_lyr_struct_t *ps_svc_lyr_dec, UWORD16 u2_frame_num
     /*--------------------------------------------------------------------*/
     /* Get the value of MaxMbAddress and frmheight in Mbs                 */
     /*--------------------------------------------------------------------*/
-    ps_seq->u2_max_mb_addr =
+    ps_seq->u4_max_mb_addr =
         (ps_seq->u2_frm_wd_in_mbs *
          (ps_dec->u2_pic_ht >> (4 + ps_dec->ps_cur_slice->u1_field_pic_flag))) -
         1;