diff --git a/decoder/ih264d_parse_slice.c b/decoder/ih264d_parse_slice.c
index 8d50f9a..198ef63 100644
--- a/decoder/ih264d_parse_slice.c
+++ b/decoder/ih264d_parse_slice.c
@@ -1307,7 +1307,12 @@
 
     if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream)
     {
-        if(u2_frame_num != ps_dec->u2_prv_frame_num
+        /* If the current slice is not a field or frame number of the current
+         * slice doesn't match with previous slice, and decoder is expecting
+         * to decode a field i.e. ps_dec->u1_top_bottom_decoded is not 0 and
+         * is not (TOP_FIELD_ONLY | BOT_FIELD_ONLY), treat it as a dangling
+         * field */
+        if((u1_field_pic_flag == 0 || u2_frame_num != ps_dec->u2_prv_frame_num)
                && ps_dec->u1_top_bottom_decoded != 0
                    && ps_dec->u1_top_bottom_decoded
                        != (TOP_FIELD_ONLY | BOT_FIELD_ONLY))
