1 files changed, 427 insertions, 165 deletions

diff --git a/apps/plugins/mpegplayer/header.c b/apps/plugins/mpegplayer/header.c
index 664be4badb..52a301f8d8 100644
--- a/apps/plugins/mpegplayer/header.c
+++ b/apps/plugins/mpegplayer/header.c
@@ -40,7 +40,8 @@ extern struct plugin_api* rb;
 #define PIC_CODING_EXT 0x100
 
 /* default intra quant matrix, in zig-zag order */
-static const uint8_t default_intra_quantizer_matrix[64] = {
+static const uint8_t default_intra_quantizer_matrix[64] =
+{
     8,
     16, 16,
     19, 16, 19,
@@ -58,20 +59,30 @@ static const uint8_t default_intra_quantizer_matrix[64] = {
     83
 };
 
-const uint8_t default_mpeg2_scan_norm[64] = {
+const uint8_t default_mpeg2_scan_norm[64] =
+{
     /* Zig-Zag scan pattern */
-     0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
-    12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
-    35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
-    58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
+     0,  1,  8, 16,  9,  2,  3, 10,
+    17, 24, 32, 25, 18, 11,  4,  5,
+    12, 19, 26, 33, 40, 48, 41, 34,
+    27, 20, 13,  6,  7, 14, 21, 28,
+    35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51,
+    58, 59, 52, 45, 38, 31, 39, 46,
+    53, 60, 61, 54, 47, 55, 62, 63
 };
 
-const uint8_t default_mpeg2_scan_alt[64] = {
+const uint8_t default_mpeg2_scan_alt[64] =
+{
     /* Alternate scan pattern */
-     0, 8,  16, 24,  1,  9,  2, 10, 17, 25, 32, 40, 48, 56, 57, 49,
-    41, 33, 26, 18,  3, 11,  4, 12, 19, 27, 34, 42, 50, 58, 35, 43,
-    51, 59, 20, 28,  5, 13,  6, 14, 21, 29, 36, 44, 52, 60, 37, 45,
-    53, 61, 22, 30,  7, 15, 23, 31, 38, 46, 54, 62, 39, 47, 55, 63
+     0, 8,  16, 24,  1,  9,  2, 10,
+    17, 25, 32, 40, 48, 56, 57, 49,
+    41, 33, 26, 18,  3, 11,  4, 12,
+    19, 27, 34, 42, 50, 58, 35, 43,
+    51, 59, 20, 28,  5, 13,  6, 14,
+    21, 29, 36, 44, 52, 60, 37, 45,
+    53, 61, 22, 30,  7, 15, 23, 31,
+    38, 46, 54, 62, 39, 47, 55, 63
 };
 
 uint8_t mpeg2_scan_norm[64] IDATA_ATTR;
@@ -79,33 +90,49 @@ uint8_t mpeg2_scan_alt[64] IDATA_ATTR;
 
 void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec)
 {
-    if (mpeg2dec->sequence.width != (unsigned)-1) {
+    if (mpeg2dec->sequence.width != (unsigned)-1)
+    {
         int i;
 
         mpeg2dec->sequence.width = (unsigned)-1;
+
         if (!mpeg2dec->custom_fbuf)
+        {
             for (i = mpeg2dec->alloc_index_user;
-                 i < mpeg2dec->alloc_index; i++) {
-                mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[0]);
-                mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[1]);
-                mpeg2_free (mpeg2dec->fbuf_alloc[i].fbuf.buf[2]);
+                 i < mpeg2dec->alloc_index; i++)
+            {
+                mpeg2_free(mpeg2dec->fbuf_alloc[i].fbuf.buf[0]);
+                mpeg2_free(mpeg2dec->fbuf_alloc[i].fbuf.buf[1]);
+                mpeg2_free(mpeg2dec->fbuf_alloc[i].fbuf.buf[2]);
             }
+        }
+
         if (mpeg2dec->convert_start)
-            for (i = 0; i < 3; i++) {
-                mpeg2_free (mpeg2dec->yuv_buf[i][0]);
-                mpeg2_free (mpeg2dec->yuv_buf[i][1]);
-                mpeg2_free (mpeg2dec->yuv_buf[i][2]);
+        {
+            for (i = 0; i < 3; i++)
+            {
+                mpeg2_free(mpeg2dec->yuv_buf[i][0]);
+                mpeg2_free(mpeg2dec->yuv_buf[i][1]);
+                mpeg2_free(mpeg2dec->yuv_buf[i][2]);
             }
+        }
+
         if (mpeg2dec->decoder.convert_id)
-            mpeg2_free (mpeg2dec->decoder.convert_id);
+        {
+            mpeg2_free(mpeg2dec->decoder.convert_id);
+        }
     }
+
     mpeg2dec->decoder.coding_type = I_TYPE;
     mpeg2dec->decoder.convert = NULL;
     mpeg2dec->decoder.convert_id = NULL;
+
     mpeg2dec->picture = mpeg2dec->pictures;
+
     mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[0].fbuf;
     mpeg2dec->fbuf[1] = &mpeg2dec->fbuf_alloc[1].fbuf;
     mpeg2dec->fbuf[2] = &mpeg2dec->fbuf_alloc[2].fbuf;
+
     mpeg2dec->first = 1;
     mpeg2dec->alloc_index = 0;
     mpeg2dec->alloc_index_user = 0;
@@ -119,14 +146,21 @@ void mpeg2_header_state_init (mpeg2dec_t * mpeg2dec)
 
 void mpeg2_reset_info (mpeg2_info_t * info)
 {
-    info->current_picture = info->current_picture_2nd = NULL;
-    info->display_picture = info->display_picture_2nd = NULL;
-    info->current_fbuf = info->display_fbuf = info->discard_fbuf = NULL;
+    info->current_picture =
+    info->current_picture_2nd = NULL;
+
+    info->display_picture =
+    info->display_picture_2nd = NULL;
+
+    info->current_fbuf =
+    info->display_fbuf =
+    info->discard_fbuf = NULL;
 }
 
 static void info_user_data (mpeg2dec_t * mpeg2dec)
 {
-    if (mpeg2dec->user_data_len) {
+    if (mpeg2dec->user_data_len)
+    {
         mpeg2dec->info.user_data = mpeg2dec->chunk_buffer;
         mpeg2dec->info.user_data_len = mpeg2dec->user_data_len - 3;
     }
@@ -134,60 +168,81 @@ static void info_user_data (mpeg2dec_t * mpeg2dec)
 
 int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec)
 {
-    uint8_t * buffer = mpeg2dec->chunk_start;
-    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
-    static unsigned int frame_period[16] = {
+    static const unsigned int frame_period[16] =
+    {
         0, 1126125, 1125000, 1080000, 900900, 900000, 540000, 450450, 450000,
         /* unofficial: xing 15 fps */
         1800000,
         /* unofficial: libmpeg3 "Unofficial economy rates" 5/10/12/15 fps */
         5400000, 2700000, 2250000, 1800000, 0, 0
     };
+
+    uint8_t * buffer = mpeg2dec->chunk_start;
+    mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence;
     int i;
 
     if ((buffer[6] & 0x20) != 0x20)        /* missing marker_bit */
         return 1;
 
     i = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
-    if (! (sequence->display_width = sequence->picture_width = i >> 12))
+
+    if (!(sequence->display_width = sequence->picture_width = i >> 12))
         return 1;
-    if (! (sequence->display_height = sequence->picture_height = i & 0xfff))
+
+    if (!(sequence->display_height = sequence->picture_height = i & 0xfff))
         return 1;
+
     sequence->width = (sequence->picture_width + 15) & ~15;
     sequence->height = (sequence->picture_height + 15) & ~15;
     sequence->chroma_width = sequence->width >> 1;
     sequence->chroma_height = sequence->height >> 1;
 
-    sequence->flags = (SEQ_FLAG_PROGRESSIVE_SEQUENCE |
-                       SEQ_VIDEO_FORMAT_UNSPECIFIED);
+    sequence->flags = SEQ_FLAG_PROGRESSIVE_SEQUENCE |
+                      SEQ_VIDEO_FORMAT_UNSPECIFIED;
 
     sequence->pixel_width = buffer[3] >> 4;        /* aspect ratio */
     sequence->frame_period = frame_period[buffer[3] & 15];
 
     sequence->byte_rate = (buffer[4]<<10) | (buffer[5]<<2) | (buffer[6]>>6);
 
-    sequence->vbv_buffer_size = ((buffer[6]<<16)|(buffer[7]<<8))&0x1ff800;
+    sequence->vbv_buffer_size = ((buffer[6]<<16) | (buffer[7]<<8)) & 0x1ff800;
 
     if (buffer[7] & 4)
         sequence->flags |= SEQ_FLAG_CONSTRAINED_PARAMETERS;
 
     mpeg2dec->copy_matrix = 3;
-    if (buffer[7] & 2) {
+
+    if (buffer[7] & 2)
+    {
         for (i = 0; i < 64; i++)
+        {
             mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
                 (buffer[i+7] << 7) | (buffer[i+8] >> 1);
+        }
+
         buffer += 64;
-    } else
+    }
+    else
+    {
         for (i = 0; i < 64; i++)
+        {
             mpeg2dec->new_quantizer_matrix[0][mpeg2_scan_norm[i]] =
                 default_intra_quantizer_matrix[i];
+        }
+    }
 
     if (buffer[7] & 1)
+    {
         for (i = 0; i < 64; i++)
+        {
             mpeg2dec->new_quantizer_matrix[1][mpeg2_scan_norm[i]] =
                 buffer[i+8];
+        }
+    }
     else
+    {
         rb->memset (mpeg2dec->new_quantizer_matrix[1], 16, 64);
+    }
 
     sequence->profile_level_id = 0x80;
     sequence->colour_primaries = 0;
@@ -196,7 +251,9 @@ int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec)
 
     mpeg2dec->ext_state = SEQ_EXT;
     mpeg2dec->state = STATE_SEQUENCE;
-    mpeg2dec->display_offset_x = mpeg2dec->display_offset_y = 0;
+
+    mpeg2dec->display_offset_x =
+    mpeg2dec->display_offset_y = 0;
 
     return 0;
 }
@@ -204,7 +261,7 @@ int mpeg2_header_sequence (mpeg2dec_t * mpeg2dec)
 static int sequence_ext (mpeg2dec_t * mpeg2dec)
 {
     uint8_t * buffer = mpeg2dec->chunk_start;
-    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
+    mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence;
     uint32_t flags;
 
     if (!(buffer[3] & 1))
@@ -212,23 +269,32 @@ static int sequence_ext (mpeg2dec_t * mpeg2dec)
 
     sequence->profile_level_id = (buffer[0] << 4) | (buffer[1] >> 4);
 
-    sequence->display_width = sequence->picture_width +=
-        ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
-    sequence->display_height = sequence->picture_height +=
-        (buffer[2] << 7) & 0x3000;
+    sequence->picture_width += ((buffer[1] << 13) | (buffer[2] << 5)) & 0x3000;
+    sequence->display_width = sequence->picture_width;
+
+    sequence->picture_height += (buffer[2] << 7) & 0x3000;
+    sequence->display_height = sequence->picture_height;
+
     sequence->width = (sequence->picture_width + 15) & ~15;
     sequence->height = (sequence->picture_height + 15) & ~15;
+
     flags = sequence->flags | SEQ_FLAG_MPEG2;
-    if (!(buffer[1] & 8)) {
+
+    if (!(buffer[1] & 8))
+    {
         flags &= ~SEQ_FLAG_PROGRESSIVE_SEQUENCE;
         sequence->height = (sequence->height + 31) & ~31;
     }
+
     if (buffer[5] & 0x80)
         flags |= SEQ_FLAG_LOW_DELAY;
+
     sequence->flags = flags;
     sequence->chroma_width = sequence->width;
     sequence->chroma_height = sequence->height;
-    switch (buffer[1] & 6) {
+
+    switch (buffer[1] & 6)
+    {
     case 0:        /* invalid */
         return 1;
     case 2:        /* 4:2:0 */
@@ -252,12 +318,14 @@ static int sequence_ext (mpeg2dec_t * mpeg2dec)
 static int sequence_display_ext (mpeg2dec_t * mpeg2dec)
 {
     uint8_t * buffer = mpeg2dec->chunk_start;
-    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
+    mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence;
     uint32_t flags;
 
-    flags = ((sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
-             ((buffer[0]<<4) & SEQ_MASK_VIDEO_FORMAT));
-    if (buffer[0] & 1) {
+    flags = (sequence->flags & ~SEQ_MASK_VIDEO_FORMAT) |
+             ((buffer[0] << 4) & SEQ_MASK_VIDEO_FORMAT);
+
+    if (buffer[0] & 1)
+    {
         flags |= SEQ_FLAG_COLOUR_DESCRIPTION;
         sequence->colour_primaries = buffer[1];
         sequence->transfer_characteristics = buffer[2];
@@ -268,9 +336,11 @@ static int sequence_display_ext (mpeg2dec_t * mpeg2dec)
     if (!(buffer[2] & 2))        /* missing marker_bit */
         return 1;
 
-    sequence->display_width = (buffer[1] << 6) | (buffer[2] >> 2);
+    sequence->display_width =
+        (buffer[1] << 6) | (buffer[2] >> 2);
+
     sequence->display_height =
-        ((buffer[2]& 1 ) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
+        ((buffer[2] & 1) << 13) | (buffer[3] << 5) | (buffer[4] >> 3);
 
     return 0;
 }
@@ -282,37 +352,63 @@ static inline void finalize_sequence (mpeg2_sequence_t * sequence)
 
     sequence->byte_rate *= 50;
 
-    if (sequence->flags & SEQ_FLAG_MPEG2) {
-        switch (sequence->pixel_width) {
+    if (sequence->flags & SEQ_FLAG_MPEG2)
+    {
+        switch (sequence->pixel_width)
+        {
         case 1:                /* square pixels */
-            sequence->pixel_width = sequence->pixel_height = 1;        return;
+            sequence->pixel_width =
+            sequence->pixel_height = 1;
+            return;
         case 2:                /* 4:3 aspect ratio */
-            width = 4; height = 3;        break;
+            width = 4;
+            height = 3;
+            break;
         case 3:                /* 16:9 aspect ratio */
-            width = 16; height = 9;        break;
+            width = 16;
+            height = 9;
+            break;
         case 4:                /* 2.21:1 aspect ratio */
-            width = 221; height = 100;        break;
+            width = 221;
+            height = 100;
+            break;
         default:        /* illegal */
-            sequence->pixel_width = sequence->pixel_height = 0;        return;
+            sequence->pixel_width =
+            sequence->pixel_height = 0;
+            return;
         }
+
         width *= sequence->display_height;
         height *= sequence->display_width;
-
-    } else {
-        if (sequence->byte_rate == 50 * 0x3ffff) 
-            sequence->byte_rate = 0;        /* mpeg-1 VBR */ 
-
-        switch (sequence->pixel_width) {
-        case 0:        case 15:        /* illegal */
-            sequence->pixel_width = sequence->pixel_height = 0;                return;
+    }
+    else
+    {
+        if (sequence->byte_rate == 50 * 0x3ffff)
+            sequence->byte_rate = 0;        /* mpeg-1 VBR */
+
+        switch (sequence->pixel_width)
+        {
+        case 0:
+        case 15:        /* illegal */
+            sequence->pixel_width =
+            sequence->pixel_height = 0;
+            return;
         case 1:        /* square pixels */
-            sequence->pixel_width = sequence->pixel_height = 1;                return;
+            sequence->pixel_width =
+            sequence->pixel_height = 1;
+            return;
         case 3:        /* 720x576 16:9 */
-            sequence->pixel_width = 64;        sequence->pixel_height = 45;        return;
+            sequence->pixel_width = 64;
+            sequence->pixel_height = 45;
+            return;
         case 6:        /* 720x480 16:9 */
-            sequence->pixel_width = 32;        sequence->pixel_height = 27;        return;
+            sequence->pixel_width = 32;
+            sequence->pixel_height = 27;
+            return;
         case 12:        /* 720*480 4:3 */
-            sequence->pixel_width = 8;        sequence->pixel_height = 9;        return;
+            sequence->pixel_width = 8;
+            sequence->pixel_height = 9;
+            return;
         default:
             height = 88 * sequence->pixel_width + 1171;
             width = 2000;
@@ -321,11 +417,15 @@ static inline void finalize_sequence (mpeg2_sequence_t * sequence)
 
     sequence->pixel_width = width;
     sequence->pixel_height = height;
-    while (width) {        /* find greatest common divisor */
+
+    /* find greatest common divisor */
+    while (width)
+    {
         int tmp = width;
         width = height % tmp;
         height = tmp;
     }
+
     sequence->pixel_width /= height;
     sequence->pixel_height /= height;
 }
@@ -333,59 +433,73 @@ static inline void finalize_sequence (mpeg2_sequence_t * sequence)
 static void copy_matrix (mpeg2dec_t * mpeg2dec, int index)
 {
     if (rb->memcmp (mpeg2dec->quantizer_matrix[index],
-                mpeg2dec->new_quantizer_matrix[index], 64)) {
+                mpeg2dec->new_quantizer_matrix[index], 64))
+    {
         rb->memcpy (mpeg2dec->quantizer_matrix[index],
                 mpeg2dec->new_quantizer_matrix[index], 64);
+
         mpeg2dec->scaled[index] = -1;
     }
 }
 
 static void finalize_matrix (mpeg2dec_t * mpeg2dec)
 {
-    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    mpeg2_decoder_t *decoder = &mpeg2dec->decoder;
     int i;
 
-    for (i = 0; i < 2; i++) {
+    for (i = 0; i < 2; i++)
+    {
         if (mpeg2dec->copy_matrix & (1 << i))
             copy_matrix (mpeg2dec, i);
+
         if ((mpeg2dec->copy_matrix & (4 << i)) &&
-            rb->memcmp (mpeg2dec->quantizer_matrix[i],
-                    mpeg2dec->new_quantizer_matrix[i+2], 64)) {
+            rb->memcmp(mpeg2dec->quantizer_matrix[i],
+                       mpeg2dec->new_quantizer_matrix[i+2], 64))
+        {
             copy_matrix (mpeg2dec, i + 2);
             decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i+2];
-        } else if (mpeg2dec->copy_matrix & (5 << i))
+        }
+        else if (mpeg2dec->copy_matrix & (5 << i))
+        {
             decoder->chroma_quantizer[i] = decoder->quantizer_prescale[i];
+        }
     }
 }
 
 static mpeg2_state_t invalid_end_action (mpeg2dec_t * mpeg2dec)
 {
-    mpeg2_reset_info (&(mpeg2dec->info));
+    mpeg2_reset_info (&mpeg2dec->info);
+
     mpeg2dec->info.gop = NULL;
+
     info_user_data (mpeg2dec);
+
     mpeg2_header_state_init (mpeg2dec);
+
     mpeg2dec->sequence = mpeg2dec->new_sequence;
     mpeg2dec->action = mpeg2_seek_header;
     mpeg2dec->state = STATE_SEQUENCE;
+
     return STATE_SEQUENCE;
 }
 
 void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
 {
-    mpeg2_sequence_t * sequence = &(mpeg2dec->new_sequence);
-    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    mpeg2_sequence_t * sequence = &mpeg2dec->new_sequence;
+    mpeg2_decoder_t * decoder = &mpeg2dec->decoder;
 
-    finalize_sequence (sequence);
-    finalize_matrix (mpeg2dec);
+    finalize_sequence(sequence);
+    finalize_matrix(mpeg2dec);
 
     decoder->mpeg1 = !(sequence->flags & SEQ_FLAG_MPEG2);
     decoder->width = sequence->width;
     decoder->height = sequence->height;
-    decoder->vertical_position_extension = (sequence->picture_height > 2800);
-    decoder->chroma_format = ((sequence->chroma_width == sequence->width) +
-                              (sequence->chroma_height == sequence->height));
+    decoder->vertical_position_extension = sequence->picture_height > 2800;
+    decoder->chroma_format = (sequence->chroma_width == sequence->width) +
+                             (sequence->chroma_height == sequence->height);
 
-    if (mpeg2dec->sequence.width != (unsigned)-1) {
+    if (mpeg2dec->sequence.width != (unsigned)-1)
+    {
         unsigned int new_byte_rate;
 
         /*
@@ -400,38 +514,50 @@ void mpeg2_header_sequence_finalize (mpeg2dec_t * mpeg2dec)
          */
         new_byte_rate = sequence->byte_rate;
         sequence->byte_rate = mpeg2dec->sequence.byte_rate;
-        if (rb->memcmp (&(mpeg2dec->sequence), sequence,
-                    sizeof (mpeg2_sequence_t))) {
+
+        if (rb->memcmp(&mpeg2dec->sequence, sequence,
+                       sizeof (mpeg2_sequence_t)))
+        {
             decoder->stride_frame = sequence->width;
             sequence->byte_rate = new_byte_rate;
+
             mpeg2_header_end (mpeg2dec);
+
             mpeg2dec->action = invalid_end_action;
             mpeg2dec->state = STATE_INVALID_END;
             return;
         }
+
         sequence->byte_rate = new_byte_rate;
         mpeg2dec->state = STATE_SEQUENCE_REPEATED;
-    } else
+    }
+    else
+    {
         decoder->stride_frame = sequence->width;
+    }
+
     mpeg2dec->sequence = *sequence;
-    mpeg2_reset_info (&(mpeg2dec->info));
-    mpeg2dec->info.sequence = &(mpeg2dec->sequence);
+    mpeg2_reset_info(&mpeg2dec->info);
+    mpeg2dec->info.sequence = &mpeg2dec->sequence;
     mpeg2dec->info.gop = NULL;
+
     info_user_data (mpeg2dec);
 }
 
 int mpeg2_header_gop (mpeg2dec_t * mpeg2dec)
 {
     uint8_t * buffer = mpeg2dec->chunk_start;
-    mpeg2_gop_t * gop = &(mpeg2dec->new_gop);
+    mpeg2_gop_t * gop = &mpeg2dec->new_gop;
 
-    if (! (buffer[1] & 8))
+    if (!(buffer[1] & 8))
         return 1;
+
     gop->hours = (buffer[0] >> 2) & 31;
     gop->minutes = ((buffer[0] << 4) | (buffer[1] >> 4)) & 63;
     gop->seconds = ((buffer[1] << 3) | (buffer[2] >> 5)) & 63;
     gop->pictures = ((buffer[2] << 1) | (buffer[3] >> 7)) & 63;
     gop->flags = (buffer[0] >> 7) | ((buffer[3] >> 4) & 6);
+
     mpeg2dec->state = STATE_GOP;
     return 0;
 }
@@ -439,8 +565,8 @@ int mpeg2_header_gop (mpeg2dec_t * mpeg2dec)
 void mpeg2_header_gop_finalize (mpeg2dec_t * mpeg2dec)
 {
     mpeg2dec->gop = mpeg2dec->new_gop;
-    mpeg2_reset_info (&(mpeg2dec->info));
-    mpeg2dec->info.gop = &(mpeg2dec->gop);
+    mpeg2_reset_info (&mpeg2dec->info);
+    mpeg2dec->info.gop = &mpeg2dec->gop;
     info_user_data (mpeg2dec);
 }
 
@@ -449,52 +575,67 @@ void mpeg2_set_fbuf (mpeg2dec_t * mpeg2dec, int b_type)
     int i;
 
     for (i = 0; i < 3; i++)
+    {
         if (mpeg2dec->fbuf[1] != &mpeg2dec->fbuf_alloc[i].fbuf &&
-            mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf) {
+            mpeg2dec->fbuf[2] != &mpeg2dec->fbuf_alloc[i].fbuf)
+        {
             mpeg2dec->fbuf[0] = &mpeg2dec->fbuf_alloc[i].fbuf;
             mpeg2dec->info.current_fbuf = mpeg2dec->fbuf[0];
-            if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) {
+
+            if (b_type || (mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY))
+            {
                 if (b_type || mpeg2dec->convert)
                     mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[0];
+
                 mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[0];
             }
+
             break;
         }
+    }
 }
 
 mpeg2_state_t mpeg2_header_picture_start (mpeg2dec_t * mpeg2dec)
 {
-    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
+    mpeg2_picture_t * picture = &mpeg2dec->new_picture;
 
-    mpeg2dec->state = ((mpeg2dec->state != STATE_SLICE_1ST) ?
-                       STATE_PICTURE : STATE_PICTURE_2ND);
+    mpeg2dec->state = (mpeg2dec->state != STATE_SLICE_1ST) ?
+                       STATE_PICTURE : STATE_PICTURE_2ND;
     picture->flags = 0;
     picture->tag = picture->tag2 = 0;
-    if (mpeg2dec->num_tags) {
-        if (mpeg2dec->bytes_since_tag >= 4) {
+
+    if (mpeg2dec->num_tags)
+    {
+        if (mpeg2dec->bytes_since_tag >= 4)
+        {
             mpeg2dec->num_tags = 0;
             picture->tag = mpeg2dec->tag_current;
             picture->tag2 = mpeg2dec->tag2_current;
             picture->flags = PIC_FLAG_TAGS;
-        } else if (mpeg2dec->num_tags > 1) {
+        }
+        else if (mpeg2dec->num_tags > 1)
+        {
             mpeg2dec->num_tags = 1;
             picture->tag = mpeg2dec->tag_previous;
             picture->tag2 = mpeg2dec->tag2_previous;
             picture->flags = PIC_FLAG_TAGS;
         }
     }
+
     picture->display_offset[0].x = picture->display_offset[1].x =
         picture->display_offset[2].x = mpeg2dec->display_offset_x;
+
     picture->display_offset[0].y = picture->display_offset[1].y =
         picture->display_offset[2].y = mpeg2dec->display_offset_y;
+
     return mpeg2_parse_header (mpeg2dec);
 }
 
 int mpeg2_header_picture (mpeg2dec_t * mpeg2dec)
 {
     uint8_t * buffer = mpeg2dec->chunk_start;
-    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
-    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    mpeg2_picture_t * picture = &mpeg2dec->new_picture;
+    mpeg2_decoder_t * decoder = &mpeg2dec->decoder;
     int type;
 
     type = (buffer [1] >> 3) & 7;
@@ -504,7 +645,8 @@ int mpeg2_header_picture (mpeg2dec_t * mpeg2dec)
 
     picture->flags |= type;
 
-    if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B) {
+    if (type == PIC_FLAG_CODING_TYPE_P || type == PIC_FLAG_CODING_TYPE_B)
+    {
         /* forward_f_code and backward_f_code - used in mpeg1 only */
         decoder->f_motion.f_code[1] = (buffer[3] >> 2) & 1;
         decoder->f_motion.f_code[0] =
@@ -531,8 +673,8 @@ int mpeg2_header_picture (mpeg2dec_t * mpeg2dec)
 static int picture_coding_ext (mpeg2dec_t * mpeg2dec)
 {
     uint8_t * buffer = mpeg2dec->chunk_start;
-    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
-    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    mpeg2_picture_t * picture = &mpeg2dec->new_picture;
+    mpeg2_decoder_t * decoder = &mpeg2dec->decoder;
     uint32_t flags;
 
     /* pre subtract 1 for use later in compute_motion_vector */
@@ -542,24 +684,32 @@ static int picture_coding_ext (mpeg2dec_t * mpeg2dec)
     decoder->b_motion.f_code[1] = (buffer[2] >> 4) - 1;
 
     flags = picture->flags;
+
     decoder->intra_dc_precision = 7 - ((buffer[2] >> 2) & 3);
     decoder->picture_structure = buffer[2] & 3;
-    switch (decoder->picture_structure) {
+
+    switch (decoder->picture_structure)
+    {
     case TOP_FIELD:
         flags |= PIC_FLAG_TOP_FIELD_FIRST;
     case BOTTOM_FIELD:
         picture->nb_fields = 1;
         break;
     case FRAME_PICTURE:
-        if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)) {
+        if (!(mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE))
+        {
             picture->nb_fields = (buffer[3] & 2) ? 3 : 2;
             flags |= (buffer[3] & 128) ? PIC_FLAG_TOP_FIELD_FIRST : 0;
-        } else
+        }
+        else
+        {
             picture->nb_fields = (buffer[3]&2) ? ((buffer[3]&128) ? 6 : 4) : 2;
+        }
         break;
     default:
         return 1;
     }
+
     decoder->top_field_first = buffer[3] >> 7;
     decoder->frame_pred_frame_dct = (buffer[3] >> 6) & 1;
     decoder->concealment_motion_vectors = (buffer[3] >> 5) & 1;
@@ -567,9 +717,13 @@ static int picture_coding_ext (mpeg2dec_t * mpeg2dec)
     decoder->intra_vlc_format = (buffer[3] >> 3) & 1;
     decoder->scan = (buffer[3] & 4) ? mpeg2_scan_alt : mpeg2_scan_norm;
     flags |= (buffer[4] & 0x80) ? PIC_FLAG_PROGRESSIVE_FRAME : 0;
+
     if (buffer[4] & 0x40)
+    {
         flags |= (((buffer[4]<<26) | (buffer[5]<<18) | (buffer[6]<<10)) &
                   PIC_MASK_COMPOSITE_DISPLAY) | PIC_FLAG_COMPOSITE_DISPLAY;
+    }
+
     picture->flags = flags;
 
     mpeg2dec->ext_state = PIC_DISPLAY_EXT | COPYRIGHT_EXT | QUANT_MATRIX_EXT;
@@ -580,124 +734,162 @@ static int picture_coding_ext (mpeg2dec_t * mpeg2dec)
 static int picture_display_ext (mpeg2dec_t * mpeg2dec)
 {
     uint8_t * buffer = mpeg2dec->chunk_start;
-    mpeg2_picture_t * picture = &(mpeg2dec->new_picture);
+    mpeg2_picture_t * picture = &mpeg2dec->new_picture;
     int i, nb_pos;
 
     nb_pos = picture->nb_fields;
+
     if (mpeg2dec->sequence.flags & SEQ_FLAG_PROGRESSIVE_SEQUENCE)
         nb_pos >>= 1;
 
-    for (i = 0; i < nb_pos; i++) {
+    for (i = 0; i < nb_pos; i++)
+    {
         int x, y;
 
         x = ((buffer[4*i] << 24) | (buffer[4*i+1] << 16) |
              (buffer[4*i+2] << 8) | buffer[4*i+3]) >> (11-2*i);
+
         y = ((buffer[4*i+2] << 24) | (buffer[4*i+3] << 16) |
              (buffer[4*i+4] << 8) | buffer[4*i+5]) >> (10-2*i);
+
         if (! (x & y & 1))
             return 1;
+
         picture->display_offset[i].x = mpeg2dec->display_offset_x = x >> 1;
         picture->display_offset[i].y = mpeg2dec->display_offset_y = y >> 1;
     }
-    for (; i < 3; i++) {
+
+    for (; i < 3; i++)
+    {
         picture->display_offset[i].x = mpeg2dec->display_offset_x;
         picture->display_offset[i].y = mpeg2dec->display_offset_y;
     }
+
     return 0;
 }
 
 void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec)
 {
-    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
-    int old_type_b = (decoder->coding_type == B_TYPE);
+    mpeg2_decoder_t * decoder = &mpeg2dec->decoder;
+    int old_type_b = decoder->coding_type == B_TYPE;
     int low_delay = mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY;
 
     finalize_matrix (mpeg2dec);
     decoder->coding_type = mpeg2dec->new_picture.flags & PIC_MASK_CODING_TYPE;
 
-    if (mpeg2dec->state == STATE_PICTURE) {
+    if (mpeg2dec->state == STATE_PICTURE)
+    {
         mpeg2_picture_t * picture;
         mpeg2_picture_t * other;
 
         decoder->second_field = 0;
 
         picture = other = mpeg2dec->pictures;
+
         if (old_type_b ^ (mpeg2dec->picture < mpeg2dec->pictures + 2))
             picture += 2;
         else
             other += 2;
+
         mpeg2dec->picture = picture;
         *picture = mpeg2dec->new_picture;
 
-        if (!old_type_b) {
+        if (!old_type_b)
+        {
             mpeg2dec->fbuf[2] = mpeg2dec->fbuf[1];
             mpeg2dec->fbuf[1] = mpeg2dec->fbuf[0];
         }
+
         mpeg2dec->fbuf[0] = NULL;
-        mpeg2_reset_info (&(mpeg2dec->info));
+        mpeg2_reset_info (&mpeg2dec->info);
         mpeg2dec->info.current_picture = picture;
         mpeg2dec->info.display_picture = picture;
-        if (decoder->coding_type != B_TYPE) {
-            if (!low_delay) {
-                if (mpeg2dec->first) {
+
+        if (decoder->coding_type != B_TYPE)
+        {
+            if (!low_delay)
+            {
+                if (mpeg2dec->first)
+                {
                     mpeg2dec->info.display_picture = NULL;
                     mpeg2dec->first = 0;
-                } else {
+                }
+                else
+                {
                     mpeg2dec->info.display_picture = other;
+
                     if (other->nb_fields == 1)
                         mpeg2dec->info.display_picture_2nd = other + 1;
+
                     mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[1];
                 }
             }
+
             if (!low_delay + !mpeg2dec->convert)
+            {
                 mpeg2dec->info.discard_fbuf =
                     mpeg2dec->fbuf[!low_delay + !mpeg2dec->convert];
+            }
         }
-        if (mpeg2dec->convert) {
+
+        if (mpeg2dec->convert)
+        {
             mpeg2_convert_init_t convert_init;
-            if (!mpeg2dec->convert_start) {
+
+            if (!mpeg2dec->convert_start)
+            {
                 int y_size, uv_size;
 
                 mpeg2dec->decoder.convert_id =
                     mpeg2_malloc (mpeg2dec->convert_id_size,
                                   MPEG2_ALLOC_CONVERT_ID);
+
                 mpeg2dec->convert (MPEG2_CONVERT_START,
                                    mpeg2dec->decoder.convert_id,
-                                   &(mpeg2dec->sequence),
+                                   &mpeg2dec->sequence,
                                    mpeg2dec->convert_stride,
                                    mpeg2dec->convert_arg, &convert_init);
+
                 mpeg2dec->convert_start = convert_init.start;
                 mpeg2dec->decoder.convert = convert_init.copy;
 
                 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
                 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
+
                 mpeg2dec->yuv_buf[0][0] =
-                    (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(y_size, MPEG2_ALLOC_YUV);
                 mpeg2dec->yuv_buf[0][1] =
-                    (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV);
                 mpeg2dec->yuv_buf[0][2] =
-                    (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV);
+
                 mpeg2dec->yuv_buf[1][0] =
-                    (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(y_size, MPEG2_ALLOC_YUV);
                 mpeg2dec->yuv_buf[1][1] =
-                    (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV);
                 mpeg2dec->yuv_buf[1][2] =
-                    (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV);
+
                 y_size = decoder->stride_frame * 32;
                 uv_size = y_size >> (2 - mpeg2dec->decoder.chroma_format);
+
                 mpeg2dec->yuv_buf[2][0] =
-                    (uint8_t *) mpeg2_malloc (y_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(y_size, MPEG2_ALLOC_YUV);
                 mpeg2dec->yuv_buf[2][1] =
-                    (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV);
                 mpeg2dec->yuv_buf[2][2] =
-                    (uint8_t *) mpeg2_malloc (uv_size, MPEG2_ALLOC_YUV);
+                    (uint8_t *) mpeg2_malloc(uv_size, MPEG2_ALLOC_YUV);
             }
-            if (!mpeg2dec->custom_fbuf) {
-                while (mpeg2dec->alloc_index < 3) {
+
+            if (!mpeg2dec->custom_fbuf)
+            {
+                while (mpeg2dec->alloc_index < 3)
+                {
                     mpeg2_fbuf_t * fbuf;
 
                     fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
                     fbuf->id = NULL;
+
                     fbuf->buf[0] =
                         (uint8_t *) mpeg2_malloc (convert_init.buf_size[0],
                                                   MPEG2_ALLOC_CONVERTED);
@@ -710,15 +902,21 @@ void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec)
                 }
                 mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
             }
-        } else if (!mpeg2dec->custom_fbuf) {
-            while (mpeg2dec->alloc_index < 3) {
+        }
+        else if (!mpeg2dec->custom_fbuf)
+        {
+            while (mpeg2dec->alloc_index < 3)
+            {
                 mpeg2_fbuf_t * fbuf;
                 int y_size, uv_size;
 
-                fbuf = &(mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf);
+                fbuf = &mpeg2dec->fbuf_alloc[mpeg2dec->alloc_index++].fbuf;
+
                 fbuf->id = NULL;
+
                 y_size = decoder->stride_frame * mpeg2dec->sequence.height;
                 uv_size = y_size >> (2 - decoder->chroma_format);
+
                 fbuf->buf[0] = (uint8_t *) mpeg2_malloc (y_size,
                                                          MPEG2_ALLOC_YUV);
                 fbuf->buf[1] = (uint8_t *) mpeg2_malloc (uv_size,
@@ -726,13 +924,19 @@ void mpeg2_header_picture_finalize (mpeg2dec_t * mpeg2dec)
                 fbuf->buf[2] = (uint8_t *) mpeg2_malloc (uv_size,
                                                          MPEG2_ALLOC_YUV);
             }
+
             mpeg2_set_fbuf (mpeg2dec, (decoder->coding_type == B_TYPE));
         }
-    } else {
+    }
+    else
+    {
         decoder->second_field = 1;
         mpeg2dec->picture++;        /* second field picture */
+
         *(mpeg2dec->picture) = mpeg2dec->new_picture;
+
         mpeg2dec->info.current_picture_2nd = mpeg2dec->picture;
+
         if (low_delay || decoder->coding_type == B_TYPE)
             mpeg2dec->info.display_picture_2nd = mpeg2dec->picture;
     }
@@ -752,23 +956,38 @@ static int quant_matrix_ext (mpeg2dec_t * mpeg2dec)
     int i, j;
 
     for (i = 0; i < 4; i++)
-        if (buffer[0] & (8 >> i)) {
+    {
+        if (buffer[0] & (8 >> i))
+        {
             for (j = 0; j < 64; j++)
+            {
                 mpeg2dec->new_quantizer_matrix[i][mpeg2_scan_norm[j]] =
                     (buffer[j] << (i+5)) | (buffer[j+1] >> (3-i));
+            }
+
             mpeg2dec->copy_matrix |= 1 << i;
             buffer += 64;
         }
+    }
 
     return 0;
 }
 
 int mpeg2_header_extension (mpeg2dec_t * mpeg2dec)
 {
-    static int (* parser[]) (mpeg2dec_t *) = {
-        0, sequence_ext, sequence_display_ext, quant_matrix_ext,
-        copyright_ext, 0, 0, picture_display_ext, picture_coding_ext
+    static int (* const parser[9]) (mpeg2dec_t *) =
+    {
+        NULL,
+        sequence_ext,
+        sequence_display_ext,
+        quant_matrix_ext,
+        copyright_ext,
+        NULL,
+        NULL,
+        picture_display_ext,
+        picture_coding_ext
     };
+
     int ext, ext_bit;
 
     ext = mpeg2dec->chunk_start[0] >> 4;
@@ -776,7 +995,9 @@ int mpeg2_header_extension (mpeg2dec_t * mpeg2dec)
 
     if (!(mpeg2dec->ext_state & ext_bit))
         return 0;        /* ignore illegal extensions */
+
     mpeg2dec->ext_state &= ~ext_bit;
+
     return parser[ext] (mpeg2dec);
 }
 
@@ -784,89 +1005,119 @@ int mpeg2_header_user_data (mpeg2dec_t * mpeg2dec)
 {
     mpeg2dec->user_data_len += mpeg2dec->chunk_ptr - 1 - mpeg2dec->chunk_start;
     mpeg2dec->chunk_start = mpeg2dec->chunk_ptr - 1;
-    
+
     return 0;
 }
 
 static void prescale (mpeg2dec_t * mpeg2dec, int index)
 {
-    static int non_linear_scale [] = {
+    static const int non_linear_scale[32] =
+    {
          0,  1,  2,  3,  4,  5,   6,   7,
          8, 10, 12, 14, 16, 18,  20,  22,
         24, 28, 32, 36, 40, 44,  48,  52,
         56, 64, 72, 80, 88, 96, 104, 112
     };
+
     int i, j, k;
-    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    mpeg2_decoder_t * decoder = &mpeg2dec->decoder;
 
-    if (mpeg2dec->scaled[index] != mpeg2dec->q_scale_type) {
+    if (mpeg2dec->scaled[index] != mpeg2dec->q_scale_type)
+    {
         mpeg2dec->scaled[index] = mpeg2dec->q_scale_type;
-        for (i = 0; i < 32; i++) {
+
+        for (i = 0; i < 32; i++)
+        {
             k = mpeg2dec->q_scale_type ? non_linear_scale[i] : (i << 1);
+
             for (j = 0; j < 64; j++)
+            {
                 decoder->quantizer_prescale[index][i][j] =
                     k * mpeg2dec->quantizer_matrix[index][j];
+            }
         }
     }
 }
 
 mpeg2_state_t mpeg2_header_slice_start (mpeg2dec_t * mpeg2dec)
 {
-    mpeg2_decoder_t * decoder = &(mpeg2dec->decoder);
+    mpeg2_decoder_t * decoder = &mpeg2dec->decoder;
 
-    mpeg2dec->info.user_data = NULL;        mpeg2dec->info.user_data_len = 0;
-    mpeg2dec->state = ((mpeg2dec->picture->nb_fields > 1 ||
-                        mpeg2dec->state == STATE_PICTURE_2ND) ?
-                       STATE_SLICE : STATE_SLICE_1ST);
+    mpeg2dec->info.user_data = NULL;
+    mpeg2dec->info.user_data_len = 0;
+    mpeg2dec->state = (mpeg2dec->picture->nb_fields > 1 ||
+                       mpeg2dec->state == STATE_PICTURE_2ND) ?
+                            STATE_SLICE : STATE_SLICE_1ST;
 
-    if (mpeg2dec->decoder.coding_type != D_TYPE) {
+    if (mpeg2dec->decoder.coding_type != D_TYPE)
+    {
         prescale (mpeg2dec, 0);
+
         if (decoder->chroma_quantizer[0] == decoder->quantizer_prescale[2])
             prescale (mpeg2dec, 2);
-        if (mpeg2dec->decoder.coding_type != I_TYPE) {
+
+        if (mpeg2dec->decoder.coding_type != I_TYPE)
+        {
             prescale (mpeg2dec, 1);
+
             if (decoder->chroma_quantizer[1] == decoder->quantizer_prescale[3])
                 prescale (mpeg2dec, 3);
         }
     }
 
     if (!(mpeg2dec->nb_decode_slices))
+    {
         mpeg2dec->picture->flags |= PIC_FLAG_SKIP;
-    else if (mpeg2dec->convert_start) {
+    }
+    else if (mpeg2dec->convert_start)
+    {
         mpeg2dec->convert_start (decoder->convert_id, mpeg2dec->fbuf[0],
                                  mpeg2dec->picture, mpeg2dec->info.gop);
 
         if (mpeg2dec->decoder.coding_type == B_TYPE)
-            mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->yuv_buf[2],
+        {
+            mpeg2_init_fbuf (&mpeg2dec->decoder, mpeg2dec->yuv_buf[2],
                              mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
                              mpeg2dec->yuv_buf[mpeg2dec->yuv_index]);
-        else {
-            mpeg2_init_fbuf (&(mpeg2dec->decoder),
+        }
+        else
+        {
+            mpeg2_init_fbuf (&mpeg2dec->decoder,
                              mpeg2dec->yuv_buf[mpeg2dec->yuv_index ^ 1],
                              mpeg2dec->yuv_buf[mpeg2dec->yuv_index],
                              mpeg2dec->yuv_buf[mpeg2dec->yuv_index]);
+
             if (mpeg2dec->state == STATE_SLICE)
                 mpeg2dec->yuv_index ^= 1;
         }
-    } else {
+    }
+    else
+    {
         int b_type;
 
         b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
-        mpeg2_init_fbuf (&(mpeg2dec->decoder), mpeg2dec->fbuf[0]->buf,
+
+        mpeg2_init_fbuf (&mpeg2dec->decoder, mpeg2dec->fbuf[0]->buf,
                          mpeg2dec->fbuf[b_type + 1]->buf,
                          mpeg2dec->fbuf[b_type]->buf);
     }
+
     mpeg2dec->action = NULL;
+
     return (mpeg2_state_t)-1;
 }
 
 static mpeg2_state_t seek_sequence (mpeg2dec_t * mpeg2dec)
 {
-    mpeg2_reset_info (&(mpeg2dec->info));
+    mpeg2_reset_info (&mpeg2dec->info);
+
     mpeg2dec->info.sequence = NULL;
     mpeg2dec->info.gop = NULL;
+
     mpeg2_header_state_init (mpeg2dec);
+
     mpeg2dec->action = mpeg2_seek_header;
+
     return mpeg2_seek_header (mpeg2dec);
 }
 
@@ -877,19 +1128,30 @@ mpeg2_state_t mpeg2_header_end (mpeg2dec_t * mpeg2dec)
 
     b_type = (mpeg2dec->decoder.coding_type == B_TYPE);
     picture = mpeg2dec->pictures;
+
     if ((mpeg2dec->picture >= picture + 2) ^ b_type)
         picture = mpeg2dec->pictures + 2;
 
-    mpeg2_reset_info (&(mpeg2dec->info));
-    if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY)) {
+    mpeg2_reset_info (&mpeg2dec->info);
+
+    if (!(mpeg2dec->sequence.flags & SEQ_FLAG_LOW_DELAY))
+    {
         mpeg2dec->info.display_picture = picture;
+
         if (picture->nb_fields == 1)
             mpeg2dec->info.display_picture_2nd = picture + 1;
+
         mpeg2dec->info.display_fbuf = mpeg2dec->fbuf[b_type];
+
         if (!mpeg2dec->convert)
             mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type + 1];
-    } else if (!mpeg2dec->convert)
+    }
+    else if (!mpeg2dec->convert)
+    {
         mpeg2dec->info.discard_fbuf = mpeg2dec->fbuf[b_type];
+    }
+
     mpeg2dec->action = seek_sequence;
+
     return STATE_END;
 }