diff --git a/decoder/impeg2d_api.h b/decoder/impeg2d_api.h
index 3fa098b..f239637 100644
--- a/decoder/impeg2d_api.h
+++ b/decoder/impeg2d_api.h
@@ -50,7 +50,7 @@
 
 
 
-#define NUM_MEM_RECORDS                 4 * MAX_THREADS + NUM_INT_FRAME_BUFFERS + 5 + 2
+#define NUM_MEM_RECORDS                 4 * MAX_THREADS + NUM_INT_FRAME_BUFFERS + 5 + 2 + 1
 
 
 #define SETBIT(a,i)   ((a) |= (1 << i))
diff --git a/decoder/impeg2d_api_main.c b/decoder/impeg2d_api_main.c
index 606a5dc..cc85eff 100644
--- a/decoder/impeg2d_api_main.c
+++ b/decoder/impeg2d_api_main.c
@@ -125,6 +125,7 @@
 
 void impeg2d_init_arch(void *pv_codec);
 void impeg2d_init_function_ptr(void *pv_codec);
+UWORD32 impeg2d_get_outbuf_size(WORD32 pic_wd,UWORD32 pic_ht, WORD32 u1_chroma_format,UWORD32 *p_buf_size);
 
 /*****************************************************************************/
 /*                                                                           */
@@ -211,6 +212,8 @@
     dec_state_t *ps_dec_state;
     dec_state_multi_core_t *ps_dec_state_multi_core;
     UWORD32 u4_num_disp_bufs;
+    UWORD32 u4_disp_buf_size[3];
+    UWORD32 num_bufs;
 
 
     dec_disp_ip = (ivd_set_display_frame_ip_t  *)pv_api_ip;
@@ -224,12 +227,41 @@
     ps_dec_state_multi_core = (dec_state_multi_core_t *) (ps_dechdl->pv_codec_handle);
     ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
 
+    num_bufs = dec_disp_ip->s_disp_buffer[0].u4_num_bufs;
+
     if(ps_dec_state->u4_share_disp_buf)
     {
         pic_buf_t *ps_pic_buf;
         ps_pic_buf = (pic_buf_t *)ps_dec_state->pv_pic_buf_base;
+
+        /* Get the sizes of the first buffer structure. Compare this with the
+         * rest to make sure all the buffers are of the same size.
+         */
+        u4_disp_buf_size[0] =
+            dec_disp_ip->s_disp_buffer[0].u4_min_out_buf_size[0];
+        u4_disp_buf_size[1] =
+            dec_disp_ip->s_disp_buffer[0].u4_min_out_buf_size[1];
+        u4_disp_buf_size[2] =
+            dec_disp_ip->s_disp_buffer[0].u4_min_out_buf_size[2];
         for(i = 0; i < u4_num_disp_bufs; i++)
         {
+            /* Verify all buffer structures have the same sized buffers as the
+             * first buffer structure*/
+            if ((dec_disp_ip->s_disp_buffer[i].u4_min_out_buf_size[0]
+                 != u4_disp_buf_size[0])
+                 || (dec_disp_ip->s_disp_buffer[i].u4_min_out_buf_size[1]
+                     != u4_disp_buf_size[1])
+                 || (dec_disp_ip->s_disp_buffer[i].u4_min_out_buf_size[2]
+                     != u4_disp_buf_size[2]))
+            {
+              return IV_FAIL;
+            }
+            /* Verify all buffer structures have the same number of
+             * buffers (e.g. y, u, v) */
+            if (dec_disp_ip->s_disp_buffer[i].u4_num_bufs != num_bufs)
+            {
+                return IV_FAIL;
+            }
 
             ps_pic_buf->pu1_y = dec_disp_ip->s_disp_buffer[i].pu1_bufs[0];
             if(IV_YUV_420P == ps_dec_state->i4_chromaFormat)
@@ -615,7 +647,11 @@
         }
     }
 
-
+    ps_mem_rec->u4_mem_alignment = 128;
+    ps_mem_rec->e_mem_type       = IV_EXTERNAL_CACHEABLE_PERSISTENT_MEM;
+    ps_mem_rec->u4_mem_size      = MAX_BITSTREAM_BUFFER_SIZE + MIN_BUFFER_BYTES_AT_EOS;
+    ps_mem_rec++;
+    u1_no_rec++;
 
     {
         WORD32 i4_job_queue_size;
@@ -661,6 +697,7 @@
     ps_mem_rec->u4_mem_size      = sizeof(iv_mem_rec_t) * (NUM_MEM_RECORDS);
     ps_mem_rec++;
     u1_no_rec++;
+
     ps_op->s_ivd_fill_mem_rec_op_t.u4_num_mem_rec_filled = u1_no_rec;
     ps_op->s_ivd_fill_mem_rec_op_t.u4_error_code = 0;
 }
@@ -764,35 +801,6 @@
     ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_in_bufs = 1;
     ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs = 1;
 
-    if(ps_dec_state->i4_chromaFormat == IV_YUV_420P)
-    {
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs =
-                        MIN_OUT_BUFS_420;
-    }
-    else if((ps_dec_state->i4_chromaFormat == IV_YUV_420SP_UV)
-                    || (ps_dec_state->i4_chromaFormat == IV_YUV_420SP_VU))
-    {
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs =
-                        MIN_OUT_BUFS_420SP;
-    }
-    else if(ps_dec_state->i4_chromaFormat == IV_YUV_422ILE)
-    {
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs =
-                        MIN_OUT_BUFS_422ILE;
-    }
-    else if(ps_dec_state->i4_chromaFormat == IV_RGB_565)
-    {
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs =
-                        MIN_OUT_BUFS_RGB565;
-    }
-    else
-    {
-        //Invalid chroma format; Error code may be updated, verify in testing if needed
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code =
-                        IVD_INIT_DEC_COL_FMT_NOT_SUPPORTED;
-        return IV_FAIL;
-    }
-
     for(u4_i = 0; u4_i < IVD_VIDDEC_MAX_IO_BUFFERS; u4_i++)
     {
         ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_in_buf_size[u4_i] =
@@ -824,33 +832,22 @@
     {
         u4_stride = ps_dec_state->u4_frm_buf_stride;
     }
-    u4_height = ((ps_dec_state->u2_frame_height + 15) >> 4) << 4;
+    u4_stride = ALIGN16(u4_stride);
+    u4_height = ALIGN32(ps_dec_state->u2_frame_height) + 9;
 
-    if(ps_dec_state->i4_chromaFormat == IV_YUV_420P)
+    ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs =
+                    impeg2d_get_outbuf_size(
+                                    u4_stride,
+                                    u4_height,
+                                    ps_dec_state->i4_chromaFormat,
+                                    &ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[0]);
+
+    if (0 == ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_num_out_bufs)
     {
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[0] =
-                        (u4_stride * u4_height);
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[1] =
-                        (u4_stride * u4_height) >> 2;
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[2] =
-                        (u4_stride * u4_height) >> 2;
-    }
-    else if((ps_dec_state->i4_chromaFormat == IV_YUV_420SP_UV)
-                    || (ps_dec_state->i4_chromaFormat == IV_YUV_420SP_VU))
-    {
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[0] =
-                        (u4_stride * u4_height);
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[1] =
-                        (u4_stride * u4_height) >> 1;
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[2] = 0;
-    }
-    else if(ps_dec_state->i4_chromaFormat == IV_YUV_422ILE)
-    {
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[0] =
-                        (u4_stride * u4_height) * 2;
-        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[1] =
-                        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_min_out_buf_size[2] =
-                                        0;
+        //Invalid chroma format; Error code may be updated, verify in testing if needed
+        ps_ctl_bufinfo_op->s_ivd_ctl_getbufinfo_op_t.u4_error_code =
+                        IVD_INIT_DEC_COL_FMT_NOT_SUPPORTED;
+        return IV_FAIL;
     }
 
     /* Adding initialization for 2 uninitialized values */
@@ -1513,6 +1510,100 @@
 
 }
 
+UWORD32 impeg2d_get_outbuf_size(WORD32 pic_wd,UWORD32 pic_ht, WORD32 u1_chroma_format,UWORD32 *p_buf_size)
+{
+    UWORD32 u4_min_num_out_bufs = 0;
+    if(u1_chroma_format == IV_YUV_420P)
+        u4_min_num_out_bufs = MIN_OUT_BUFS_420;
+    else if(u1_chroma_format == IV_YUV_422ILE)
+        u4_min_num_out_bufs = MIN_OUT_BUFS_422ILE;
+    else if(u1_chroma_format == IV_RGB_565)
+        u4_min_num_out_bufs = MIN_OUT_BUFS_RGB565;
+    else if((u1_chroma_format == IV_YUV_420SP_UV)
+                    || (u1_chroma_format == IV_YUV_420SP_VU))
+        u4_min_num_out_bufs = MIN_OUT_BUFS_420SP;
+
+    if(u1_chroma_format == IV_YUV_420P)
+    {
+        p_buf_size[0] = (pic_wd * pic_ht);
+        p_buf_size[1] = (pic_wd * pic_ht)
+                        >> 2;
+        p_buf_size[2] = (pic_wd * pic_ht)
+                        >> 2;
+    }
+    else if(u1_chroma_format == IV_YUV_422ILE)
+    {
+        p_buf_size[0] = (pic_wd * pic_ht)
+                        * 2;
+        p_buf_size[1] =
+                        p_buf_size[2] = 0;
+    }
+    else if(u1_chroma_format == IV_RGB_565)
+    {
+        p_buf_size[0] = (pic_wd * pic_ht)
+                        * 2;
+        p_buf_size[1] =
+                        p_buf_size[2] = 0;
+    }
+    else if((u1_chroma_format == IV_YUV_420SP_UV)
+                    || (u1_chroma_format == IV_YUV_420SP_VU))
+    {
+        p_buf_size[0] = (pic_wd * pic_ht);
+        p_buf_size[1] = (pic_wd * pic_ht)
+                        >> 1;
+        p_buf_size[2] = 0;
+    }
+
+    return u4_min_num_out_bufs;
+}
+
+WORD32 check_app_out_buf_size(dec_state_t *ps_dec)
+{
+    UWORD32 au4_min_out_buf_size[IVD_VIDDEC_MAX_IO_BUFFERS];
+    UWORD32 u4_min_num_out_bufs, i;
+    UWORD32 pic_wd, pic_ht;
+
+    pic_wd = ps_dec->u2_horizontal_size;
+    pic_ht = ps_dec->u2_vertical_size;
+
+    if(ps_dec->u4_frm_buf_stride > pic_wd)
+        pic_wd = ps_dec->u4_frm_buf_stride;
+
+    u4_min_num_out_bufs = impeg2d_get_outbuf_size(pic_wd, pic_ht, ps_dec->i4_chromaFormat, &au4_min_out_buf_size[0]);
+
+    if (0 == ps_dec->u4_share_disp_buf)
+    {
+        if(ps_dec->ps_out_buf->u4_num_bufs < u4_min_num_out_bufs)
+        {
+            return IV_FAIL;
+        }
+
+        for (i = 0 ; i < u4_min_num_out_bufs; i++)
+        {
+            if(ps_dec->ps_out_buf->u4_min_out_buf_size[i] < au4_min_out_buf_size[i])
+                return (IV_FAIL);
+        }
+    }
+    else
+    {
+        if(ps_dec->as_disp_buffers[0].u4_num_bufs < u4_min_num_out_bufs)
+            return IV_FAIL;
+
+        for (i = 0 ; i < u4_min_num_out_bufs; i++)
+        {
+            /* We need to check only with the disp_buffer[0], because we have
+            * already ensured that all the buffers are of the same size in
+            * impeg2d_api_set_display_frame.
+            */
+            if(ps_dec->as_disp_buffers[0].u4_min_out_buf_size[i] <
+                   au4_min_out_buf_size[i])
+                return (IV_FAIL);
+        }
+    }
+
+    return(IV_SUCCESS);
+}
+
 
 
 /*****************************************************************************/
@@ -1796,7 +1887,6 @@
         }
     }
 
-
     ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
 
     if((ps_dec_state->i4_chromaFormat  == IV_YUV_422ILE)
@@ -1878,6 +1968,9 @@
 
     ps_dec_state = ps_dec_state_multi_core->ps_dec_state[0];
 
+    ps_dec_state->pu1_input_buffer = ps_mem_rec->pv_base;
+    u4_num_mem_rec++;
+    ps_mem_rec++;
 
     ps_dec_state->pv_jobq_buf = ps_mem_rec->pv_base;
     ps_dec_state->i4_jobq_buf_size = ps_mem_rec->u4_mem_size;
@@ -3381,6 +3474,13 @@
             {
                 ps_dec_state->u1_flushcnt    = 0;
 
+                ps_dec_state->ps_out_buf = &ps_dec_ip->s_ivd_video_decode_ip_t.s_out_buffer;
+                if (IV_SUCCESS != check_app_out_buf_size(ps_dec_state))
+                {
+                    ps_dec_op->s_ivd_video_decode_op_t.u4_error_code = IVD_DISP_FRM_ZERO_OP_BUF_SIZE;
+                    return IV_FAIL;
+                }
+
                 /*************************************************************************/
                 /*                              Frame Decode                             */
                 /*************************************************************************/
diff --git a/decoder/impeg2d_dec_hdr.c b/decoder/impeg2d_dec_hdr.c
index aa3c70f..e899347 100644
--- a/decoder/impeg2d_dec_hdr.c
+++ b/decoder/impeg2d_dec_hdr.c
@@ -712,6 +712,11 @@
 
     if(ps_dec->u2_is_mpeg2 == 0)
     {
+        if (ps_dec->u2_forw_f_code < 1 || ps_dec->u2_forw_f_code > 7 ||
+                        ps_dec->u2_back_f_code < 1 || ps_dec->u2_back_f_code > 7)
+        {
+            return IMPEG2D_UNKNOWN_ERROR;
+        }
         ps_dec->au2_f_code[0][0] = ps_dec->au2_f_code[0][1] = ps_dec->u2_forw_f_code;
         ps_dec->au2_f_code[1][0] = ps_dec->au2_f_code[1][1] = ps_dec->u2_back_f_code;
     }
@@ -1013,23 +1018,30 @@
 
             if(i4_continue_decode)
             {
-                /* If the slice is from the same row, then continue decoding without dequeue */
-                if((temp - 1) == i4_cur_row)
+                if (0 != ps_dec->u2_num_mbs_left)
                 {
-                    i4_dequeue_job = 0;
-                    break;
-                }
-
-                if(temp < ps_dec->i4_end_mb_y)
-                {
-                    i4_cur_row = ps_dec->u2_mb_y;
+                    /* If the slice is from the same row, then continue decoding without dequeue */
+                    if((temp - 1) == i4_cur_row)
+                    {
+                        i4_dequeue_job = 0;
+                    }
+                    else
+                    {
+                        if(temp < ps_dec->i4_end_mb_y)
+                        {
+                            i4_cur_row = ps_dec->u2_mb_y;
+                        }
+                        else
+                        {
+                            i4_dequeue_job = 1;
+                        }
+                    }
                 }
                 else
                 {
                     i4_dequeue_job = 1;
                 }
                 break;
-
             }
             else
                 break;
@@ -1863,7 +1875,11 @@
                     return e_error;
                 }
                 impeg2d_flush_ext_and_user_data(ps_dec);
-                impeg2d_pre_pic_dec_proc(ps_dec);
+                e_error = impeg2d_pre_pic_dec_proc(ps_dec);
+                if ((IMPEG2D_ERROR_CODES_T)IVD_ERROR_NONE != e_error)
+                {
+                    return e_error;
+                }
                 impeg2d_dec_pic_data(ps_dec);
                 impeg2d_post_pic_dec_proc(ps_dec);
                 u4_start_code_found = 1;
diff --git a/decoder/impeg2d_decoder.c b/decoder/impeg2d_decoder.c
index e4ff79c..bff8c21 100644
--- a/decoder/impeg2d_decoder.c
+++ b/decoder/impeg2d_decoder.c
@@ -102,12 +102,14 @@
 
     ps_dec = (dec_state_t *)pv_dec;
     ps_op->s_ivd_video_decode_op_t.u4_error_code = 0;
-    if (u4_size >= MAX_BITSTREAM_BUFFER_SIZE)
+    if (u4_size > MAX_BITSTREAM_BUFFER_SIZE)
     {
-        u4_size = MAX_BITSTREAM_BUFFER_SIZE - MIN_BUFFER_BYTES_AT_EOS;
+        u4_size = MAX_BITSTREAM_BUFFER_SIZE;
     }
 
-    impeg2d_bit_stream_init(&(ps_dec->s_bit_stream),ps_ip->s_ivd_video_decode_ip_t.pv_stream_buffer,
+    memcpy(ps_dec->pu1_input_buffer, ps_ip->s_ivd_video_decode_ip_t.pv_stream_buffer, u4_size);
+
+    impeg2d_bit_stream_init(&(ps_dec->s_bit_stream), ps_dec->pu1_input_buffer,
         u4_size);
 
     {
@@ -194,16 +196,19 @@
     ps_op->s_ivd_video_decode_op_t.u4_num_bytes_consumed = 0;
 
     IMPEG2D_FRM_NUM_SET();
-    if (u4_size >= MAX_BITSTREAM_BUFFER_SIZE)
+    if (u4_size > MAX_BITSTREAM_BUFFER_SIZE)
     {
-        u4_size = MAX_BITSTREAM_BUFFER_SIZE - MIN_BUFFER_BYTES_AT_EOS;
+        u4_size = MAX_BITSTREAM_BUFFER_SIZE;
     }
 
-    ps_dec->pu1_inp_bits_buf = ps_ip->s_ivd_video_decode_ip_t.pv_stream_buffer;
+    memcpy(ps_dec->pu1_input_buffer, ps_ip->s_ivd_video_decode_ip_t.pv_stream_buffer, u4_size);
+
+    ps_dec->pu1_inp_bits_buf = ps_dec->pu1_input_buffer;
+
     ps_dec->u4_num_inp_bytes = u4_size;
     ps_stream  = &ps_dec->s_bit_stream;
 
-    impeg2d_bit_stream_init(ps_stream,ps_ip->s_ivd_video_decode_ip_t.pv_stream_buffer,u4_size);
+    impeg2d_bit_stream_init(ps_stream, ps_dec->pu1_input_buffer, u4_size);
 
     /* @ */ /* Updating the bufferID */
 
diff --git a/decoder/impeg2d_pic_proc.c b/decoder/impeg2d_pic_proc.c
index fbbbf79..6826def 100644
--- a/decoder/impeg2d_pic_proc.c
+++ b/decoder/impeg2d_pic_proc.c
@@ -271,6 +271,8 @@
         ps_dec->u2_progressive_frame            = 1;
         ps_dec->u2_frame_rate_extension_n       = 0;
         ps_dec->u2_frame_rate_extension_d       = 0;
+        ps_dec->u2_forw_f_code                  = 7;
+        ps_dec->u2_back_f_code                  = 7;
 
         ps_dec->pf_vld_inv_quant                  = impeg2d_vld_inv_quant_mpeg1;
         /*-------------------------------------------------------------------*/
diff --git a/decoder/impeg2d_pnb_pic.c b/decoder/impeg2d_pnb_pic.c
index a3ae436..f7937a8 100644
--- a/decoder/impeg2d_pnb_pic.c
+++ b/decoder/impeg2d_pnb_pic.c
@@ -299,6 +299,11 @@
     {
         u2_mb_addr_incr = impeg2d_get_mb_addr_incr(ps_stream);
 
+        if(0 == u2_mb_addr_incr)
+        {
+            return IV_FAIL;
+        }
+
         if(ps_dec->u2_first_mb)
         {
             /****************************************************************/
diff --git a/decoder/impeg2d_structs.h b/decoder/impeg2d_structs.h
index 46538bf..48fdd13 100644
--- a/decoder/impeg2d_structs.h
+++ b/decoder/impeg2d_structs.h
@@ -342,6 +342,9 @@
     WORD32          i4_start_mb_y;
     WORD32          i4_end_mb_y;
 
+    /* Buffer to store the input stream */
+    UWORD8 *pu1_input_buffer;
+
     /**
      * Job queue buffer base
      */
@@ -363,6 +366,8 @@
     /* Number of bytes in the input bitstream */
     UWORD32         u4_num_inp_bytes;
 
+    ivd_out_bufdesc_t *ps_out_buf;
+
     /* Bytes consumed */
     WORD32          i4_bytes_consumed;
 
diff --git a/test/decoder/main.c b/test/decoder/main.c
index cfce433..9502dec 100644
--- a/test/decoder/main.c
+++ b/test/decoder/main.c
@@ -2246,6 +2246,7 @@
                             u4_ip_buf_len);
                     codec_exit(ac_error_str);
                 }
+
                 s_app_ctx.num_disp_buf = s_ctl_op.u4_num_disp_bufs;
                 /* Allocate output buffer only if display buffers are not shared */
                 /* Or if shared and output is 420P */
@@ -3016,6 +3017,12 @@
 
                     break;
                 }
+                else if (IVD_DISP_FRM_ZERO_OP_BUF_SIZE ==
+                                (IMPEG2D_ERROR_CODES_T)s_video_decode_op.u4_error_code)
+                {
+                    printf("Output buffer is not large enough!\n");
+                    break;
+                }
             }
 
             if((1 == s_app_ctx.display) &&