electronicarts: K&R formatting cosmetics
authorDiego Biurrun <diego@biurrun.de>
Wed, 14 Aug 2013 14:45:06 +0000 (16:45 +0200)
committerDiego Biurrun <diego@biurrun.de>
Thu, 15 Aug 2013 10:24:42 +0000 (12:24 +0200)
libavformat/electronicarts.c

index 8f595df..c2f4dba 100644 (file)
 #include "internal.h"
 
 #define SCHl_TAG MKTAG('S', 'C', 'H', 'l')
 #include "internal.h"
 
 #define SCHl_TAG MKTAG('S', 'C', 'H', 'l')
-#define SEAD_TAG MKTAG('S', 'E', 'A', 'D')    /* Sxxx header */
-#define SNDC_TAG MKTAG('S', 'N', 'D', 'C')    /* Sxxx data */
-#define SEND_TAG MKTAG('S', 'E', 'N', 'D')    /* Sxxx end */
-#define SHEN_TAG MKTAG('S', 'H', 'E', 'N')    /* SxEN header */
-#define SDEN_TAG MKTAG('S', 'D', 'E', 'N')    /* SxEN data */
-#define SEEN_TAG MKTAG('S', 'E', 'E', 'N')    /* SxEN end */
-#define ISNh_TAG MKTAG('1', 'S', 'N', 'h')    /* 1SNx header */
+#define SEAD_TAG MKTAG('S', 'E', 'A', 'D')  /* Sxxx header */
+#define SNDC_TAG MKTAG('S', 'N', 'D', 'C')  /* Sxxx data */
+#define SEND_TAG MKTAG('S', 'E', 'N', 'D')  /* Sxxx end */
+#define SHEN_TAG MKTAG('S', 'H', 'E', 'N')  /* SxEN header */
+#define SDEN_TAG MKTAG('S', 'D', 'E', 'N')  /* SxEN data */
+#define SEEN_TAG MKTAG('S', 'E', 'E', 'N')  /* SxEN end */
+#define ISNh_TAG MKTAG('1', 'S', 'N', 'h')  /* 1SNx header */
 #define EACS_TAG MKTAG('E', 'A', 'C', 'S')
 #define EACS_TAG MKTAG('E', 'A', 'C', 'S')
-#define ISNd_TAG MKTAG('1', 'S', 'N', 'd')    /* 1SNx data */
-#define ISNe_TAG MKTAG('1', 'S', 'N', 'e')    /* 1SNx end */
+#define ISNd_TAG MKTAG('1', 'S', 'N', 'd')  /* 1SNx data */
+#define ISNe_TAG MKTAG('1', 'S', 'N', 'e')  /* 1SNx end */
 #define PT00_TAG MKTAG('P', 'T', 0x0, 0x0)
 #define GSTR_TAG MKTAG('G', 'S', 'T', 'R')
 #define SCDl_TAG MKTAG('S', 'C', 'D', 'l')
 #define SCEl_TAG MKTAG('S', 'C', 'E', 'l')
 #define PT00_TAG MKTAG('P', 'T', 0x0, 0x0)
 #define GSTR_TAG MKTAG('G', 'S', 'T', 'R')
 #define SCDl_TAG MKTAG('S', 'C', 'D', 'l')
 #define SCEl_TAG MKTAG('S', 'C', 'E', 'l')
-#define kVGT_TAG MKTAG('k', 'V', 'G', 'T')    /* TGV i-frame */
-#define fVGT_TAG MKTAG('f', 'V', 'G', 'T')    /* TGV p-frame */
-#define mTCD_TAG MKTAG('m', 'T', 'C', 'D')    /* MDEC */
-#define MADk_TAG MKTAG('M', 'A', 'D', 'k')    /* MAD i-frame */
-#define MADm_TAG MKTAG('M', 'A', 'D', 'm')    /* MAD p-frame */
-#define MADe_TAG MKTAG('M', 'A', 'D', 'e')    /* MAD lqp-frame */
-#define MPCh_TAG MKTAG('M', 'P', 'C', 'h')    /* MPEG2 */
-#define TGQs_TAG MKTAG('T', 'G', 'Q', 's')    /* TGQ i-frame (appears in .TGQ files) */
-#define pQGT_TAG MKTAG('p', 'Q', 'G', 'T')    /* TGQ i-frame (appears in .UV files) */
-#define pIQT_TAG MKTAG('p', 'I', 'Q', 'T')    /* TQI/UV2 i-frame (.UV2/.WVE) */
+#define kVGT_TAG MKTAG('k', 'V', 'G', 'T')  /* TGV i-frame */
+#define fVGT_TAG MKTAG('f', 'V', 'G', 'T')  /* TGV p-frame */
+#define mTCD_TAG MKTAG('m', 'T', 'C', 'D')  /* MDEC */
+#define MADk_TAG MKTAG('M', 'A', 'D', 'k')  /* MAD i-frame */
+#define MADm_TAG MKTAG('M', 'A', 'D', 'm')  /* MAD p-frame */
+#define MADe_TAG MKTAG('M', 'A', 'D', 'e')  /* MAD lqp-frame */
+#define MPCh_TAG MKTAG('M', 'P', 'C', 'h')  /* MPEG2 */
+#define TGQs_TAG MKTAG('T', 'G', 'Q', 's')  /* TGQ i-frame (appears in .TGQ files) */
+#define pQGT_TAG MKTAG('p', 'Q', 'G', 'T')  /* TGQ i-frame (appears in .UV files) */
+#define pIQT_TAG MKTAG('p', 'I', 'Q', 'T')  /* TQI/UV2 i-frame (.UV2/.WVE) */
 #define MVhd_TAG MKTAG('M', 'V', 'h', 'd')
 #define MV0K_TAG MKTAG('M', 'V', '0', 'K')
 #define MV0F_TAG MKTAG('M', 'V', '0', 'F')
 #define MVhd_TAG MKTAG('M', 'V', 'h', 'd')
 #define MV0K_TAG MKTAG('M', 'V', '0', 'K')
 #define MV0F_TAG MKTAG('M', 'V', '0', 'F')
-#define MVIh_TAG MKTAG('M', 'V', 'I', 'h')    /* CMV header */
-#define MVIf_TAG MKTAG('M', 'V', 'I', 'f')    /* CMV i-frame */
+#define MVIh_TAG MKTAG('M', 'V', 'I', 'h')  /* CMV header */
+#define MVIf_TAG MKTAG('M', 'V', 'I', 'f')  /* CMV i-frame */
 
 typedef struct EaDemuxContext {
     int big_endian;
 
 typedef struct EaDemuxContext {
     int big_endian;
@@ -77,7 +77,8 @@ typedef struct EaDemuxContext {
     int num_samples;
 } EaDemuxContext;
 
     int num_samples;
 } EaDemuxContext;
 
-static uint32_t read_arbitary(AVIOContext *pb) {
+static uint32_t read_arbitary(AVIOContext *pb)
+{
     uint8_t size, byte;
     int i;
     uint32_t word;
     uint8_t size, byte;
     int i;
     uint32_t word;
@@ -86,9 +87,9 @@ static uint32_t read_arbitary(AVIOContext *pb) {
 
     word = 0;
     for (i = 0; i < size; i++) {
 
     word = 0;
     for (i = 0; i < size; i++) {
-        byte = avio_r8(pb);
+        byte   = avio_r8(pb);
         word <<= 8;
         word <<= 8;
-        word |= byte;
+        word  |= byte;
     }
 
     return word;
     }
 
     return word;
@@ -100,13 +101,13 @@ static uint32_t read_arbitary(AVIOContext *pb) {
  */
 static int process_audio_header_elements(AVFormatContext *s)
 {
  */
 static int process_audio_header_elements(AVFormatContext *s)
 {
-    int inHeader = 1;
     EaDemuxContext *ea = s->priv_data;
     EaDemuxContext *ea = s->priv_data;
-    AVIOContext *pb = s->pb;
+    AVIOContext    *pb = s->pb;
+    int inHeader = 1;
     int compression_type = -1, revision = -1, revision2 = -1;
 
     int compression_type = -1, revision = -1, revision2 = -1;
 
-    ea->bytes = 2;
-    ea->sample_rate = -1;
+    ea->bytes        = 2;
+    ea->sample_rate  = -1;
     ea->num_channels = 1;
 
     while (!pb->eof_reached && inHeader) {
     ea->num_channels = 1;
 
     while (!pb->eof_reached && inHeader) {
@@ -116,7 +117,7 @@ static int process_audio_header_elements(AVFormatContext *s)
 
         switch (byte) {
         case 0xFD:
 
         switch (byte) {
         case 0xFD:
-            av_log (s, AV_LOG_DEBUG, "entered audio subheader\n");
+            av_log(s, AV_LOG_DEBUG, "entered audio subheader\n");
             inSubheader = 1;
             while (!pb->eof_reached && inSubheader) {
                 uint8_t subbyte;
             inSubheader = 1;
             while (!pb->eof_reached && inSubheader) {
                 uint8_t subbyte;
@@ -125,85 +126,125 @@ static int process_audio_header_elements(AVFormatContext *s)
                 switch (subbyte) {
                 case 0x80:
                     revision = read_arbitary(pb);
                 switch (subbyte) {
                 case 0x80:
                     revision = read_arbitary(pb);
-                    av_log (s, AV_LOG_DEBUG, "revision (element 0x80) set to 0x%08x\n", revision);
+                    av_log(s, AV_LOG_DEBUG,
+                           "revision (element 0x80) set to 0x%08x\n", revision);
                     break;
                 case 0x82:
                     ea->num_channels = read_arbitary(pb);
                     break;
                 case 0x82:
                     ea->num_channels = read_arbitary(pb);
-                    av_log (s, AV_LOG_DEBUG, "num_channels (element 0x82) set to 0x%08x\n", ea->num_channels);
+                    av_log(s, AV_LOG_DEBUG,
+                           "num_channels (element 0x82) set to 0x%08x\n",
+                           ea->num_channels);
                     break;
                 case 0x83:
                     compression_type = read_arbitary(pb);
                     break;
                 case 0x83:
                     compression_type = read_arbitary(pb);
-                    av_log (s, AV_LOG_DEBUG, "compression_type (element 0x83) set to 0x%08x\n", compression_type);
+                    av_log(s, AV_LOG_DEBUG,
+                           "compression_type (element 0x83) set to 0x%08x\n",
+                           compression_type);
                     break;
                 case 0x84:
                     ea->sample_rate = read_arbitary(pb);
                     break;
                 case 0x84:
                     ea->sample_rate = read_arbitary(pb);
-                    av_log (s, AV_LOG_DEBUG, "sample_rate (element 0x84) set to %i\n", ea->sample_rate);
+                    av_log(s, AV_LOG_DEBUG,
+                           "sample_rate (element 0x84) set to %i\n",
+                           ea->sample_rate);
                     break;
                 case 0x85:
                     ea->num_samples = read_arbitary(pb);
                     break;
                 case 0x85:
                     ea->num_samples = read_arbitary(pb);
-                    av_log (s, AV_LOG_DEBUG, "num_samples (element 0x85) set to 0x%08x\n", ea->num_samples);
+                    av_log(s, AV_LOG_DEBUG,
+                           "num_samples (element 0x85) set to 0x%08x\n",
+                           ea->num_samples);
                     break;
                 case 0x8A:
                     break;
                 case 0x8A:
-                    av_log (s, AV_LOG_DEBUG, "element 0x%02x set to 0x%08x\n", subbyte, read_arbitary(pb));
-                    av_log (s, AV_LOG_DEBUG, "exited audio subheader\n");
+                    av_log(s, AV_LOG_DEBUG,
+                           "element 0x%02x set to 0x%08x\n",
+                           subbyte, read_arbitary(pb));
+                    av_log(s, AV_LOG_DEBUG, "exited audio subheader\n");
                     inSubheader = 0;
                     break;
                 case 0xA0:
                     revision2 = read_arbitary(pb);
                     inSubheader = 0;
                     break;
                 case 0xA0:
                     revision2 = read_arbitary(pb);
-                    av_log (s, AV_LOG_DEBUG, "revision2 (element 0xA0) set to 0x%08x\n", revision2);
+                    av_log(s, AV_LOG_DEBUG,
+                           "revision2 (element 0xA0) set to 0x%08x\n",
+                           revision2);
                     break;
                 case 0xFF:
                     break;
                 case 0xFF:
-                    av_log (s, AV_LOG_DEBUG, "end of header block reached (within audio subheader)\n");
+                    av_log(s, AV_LOG_DEBUG,
+                           "end of header block reached (within audio subheader)\n");
                     inSubheader = 0;
                     inSubheader = 0;
-                    inHeader = 0;
+                    inHeader    = 0;
                     break;
                 default:
                     break;
                 default:
-                    av_log (s, AV_LOG_DEBUG, "element 0x%02x set to 0x%08x\n", subbyte, read_arbitary(pb));
+                    av_log(s, AV_LOG_DEBUG,
+                           "element 0x%02x set to 0x%08x\n",
+                           subbyte, read_arbitary(pb));
                     break;
                 }
             }
             break;
         case 0xFF:
                     break;
                 }
             }
             break;
         case 0xFF:
-            av_log (s, AV_LOG_DEBUG, "end of header block reached\n");
+            av_log(s, AV_LOG_DEBUG, "end of header block reached\n");
             inHeader = 0;
             break;
         default:
             inHeader = 0;
             break;
         default:
-            av_log (s, AV_LOG_DEBUG, "header element 0x%02x set to 0x%08x\n", byte, read_arbitary(pb));
+            av_log(s, AV_LOG_DEBUG,
+                   "header element 0x%02x set to 0x%08x\n",
+                   byte, read_arbitary(pb));
             break;
         }
     }
 
     switch (compression_type) {
             break;
         }
     }
 
     switch (compression_type) {
-    case  0: ea->audio_codec = AV_CODEC_ID_PCM_S16LE; break;
-    case  7: ea->audio_codec = AV_CODEC_ID_ADPCM_EA; break;
+    case  0:
+        ea->audio_codec = AV_CODEC_ID_PCM_S16LE;
+        break;
+    case  7:
+        ea->audio_codec = AV_CODEC_ID_ADPCM_EA;
+        break;
     case -1:
         switch (revision) {
     case -1:
         switch (revision) {
-        case  1: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1; break;
-        case  2: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;
-        case  3: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3; break;
-        case -1: break;
+        case  1:
+            ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R1;
+            break;
+        case  2:
+            ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2;
+            break;
+        case  3:
+            ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R3;
+            break;
+        case -1:
+            break;
         default:
         default:
-            av_log(s, AV_LOG_ERROR, "unsupported stream type; revision=%i\n", revision);
+            av_log(s, AV_LOG_ERROR,
+                   "unsupported stream type; revision=%i\n", revision);
             return 0;
         }
         switch (revision2) {
             return 0;
         }
         switch (revision2) {
-        case  8: ea->audio_codec = AV_CODEC_ID_PCM_S16LE_PLANAR; break;
-        case 10: ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2; break;
-        case 16: ea->audio_codec = AV_CODEC_ID_MP3; break;
-        case -1: break;
+        case  8:
+            ea->audio_codec = AV_CODEC_ID_PCM_S16LE_PLANAR;
+            break;
+        case 10:
+            ea->audio_codec = AV_CODEC_ID_ADPCM_EA_R2;
+            break;
+        case 16:
+            ea->audio_codec = AV_CODEC_ID_MP3;
+            break;
+        case -1:
+            break;
         default:
             ea->audio_codec = AV_CODEC_ID_NONE;
         default:
             ea->audio_codec = AV_CODEC_ID_NONE;
-            av_log(s, AV_LOG_ERROR, "unsupported stream type; revision2=%i\n", revision2);
+            av_log(s, AV_LOG_ERROR,
+                   "unsupported stream type; revision2=%i\n", revision2);
             return 0;
         }
         break;
     default:
             return 0;
         }
         break;
     default:
-        av_log(s, AV_LOG_ERROR, "unsupported stream type; compression_type=%i\n", compression_type);
+        av_log(s, AV_LOG_ERROR,
+               "unsupported stream type; compression_type=%i\n",
+               compression_type);
         return 0;
     }
 
     if (ea->sample_rate == -1)
         return 0;
     }
 
     if (ea->sample_rate == -1)
-        ea->sample_rate = revision==3 ? 48000 : 22050;
+        ea->sample_rate = revision == 3 ? 48000 : 22050;
 
     return 1;
 }
 
     return 1;
 }
@@ -215,7 +256,7 @@ static int process_audio_header_elements(AVFormatContext *s)
 static int process_audio_header_eacs(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
 static int process_audio_header_eacs(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
-    AVIOContext *pb = s->pb;
+    AVIOContext *pb    = s->pb;
     int compression_type;
 
     ea->sample_rate  = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
     int compression_type;
 
     ea->sample_rate  = ea->big_endian ? avio_rb32(pb) : avio_rl32(pb);
@@ -227,14 +268,25 @@ static int process_audio_header_eacs(AVFormatContext *s)
     switch (compression_type) {
     case 0:
         switch (ea->bytes) {
     switch (compression_type) {
     case 0:
         switch (ea->bytes) {
-        case 1: ea->audio_codec = AV_CODEC_ID_PCM_S8;    break;
-        case 2: ea->audio_codec = AV_CODEC_ID_PCM_S16LE; break;
+        case 1:
+            ea->audio_codec = AV_CODEC_ID_PCM_S8;
+            break;
+        case 2:
+            ea->audio_codec = AV_CODEC_ID_PCM_S16LE;
+            break;
         }
         break;
         }
         break;
-    case 1: ea->audio_codec = AV_CODEC_ID_PCM_MULAW; ea->bytes = 1; break;
-    case 2: ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS; break;
+    case 1:
+        ea->audio_codec = AV_CODEC_ID_PCM_MULAW;
+        ea->bytes       = 1;
+        break;
+    case 2:
+        ea->audio_codec = AV_CODEC_ID_ADPCM_IMA_EA_EACS;
+        break;
     default:
     default:
-        av_log (s, AV_LOG_ERROR, "unsupported stream type; audio compression_type=%i\n", compression_type);
+        av_log(s, AV_LOG_ERROR,
+               "unsupported stream type; audio compression_type=%i\n",
+               compression_type);
     }
 
     return 1;
     }
 
     return 1;
@@ -247,7 +299,7 @@ static int process_audio_header_eacs(AVFormatContext *s)
 static int process_audio_header_sead(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
 static int process_audio_header_sead(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
-    AVIOContext *pb = s->pb;
+    AVIOContext *pb    = s->pb;
 
     ea->sample_rate  = avio_rl32(pb);
     ea->bytes        = avio_rl32(pb);  /* 1=8-bit, 2=16-bit */
 
     ea->sample_rate  = avio_rl32(pb);
     ea->bytes        = avio_rl32(pb);  /* 1=8-bit, 2=16-bit */
@@ -260,24 +312,25 @@ static int process_audio_header_sead(AVFormatContext *s)
 static int process_video_header_mdec(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
 static int process_video_header_mdec(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
-    AVIOContext *pb = s->pb;
+    AVIOContext *pb    = s->pb;
     avio_skip(pb, 4);
     avio_skip(pb, 4);
-    ea->width  = avio_rl16(pb);
-    ea->height = avio_rl16(pb);
-    ea->time_base = (AVRational){1,15};
+    ea->width       = avio_rl16(pb);
+    ea->height      = avio_rl16(pb);
+    ea->time_base   = (AVRational) { 1, 15 };
     ea->video_codec = AV_CODEC_ID_MDEC;
     ea->video_codec = AV_CODEC_ID_MDEC;
+
     return 1;
 }
 
 static int process_video_header_vp6(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
     return 1;
 }
 
 static int process_video_header_vp6(AVFormatContext *s)
 {
     EaDemuxContext *ea = s->priv_data;
-    AVIOContext *pb = s->pb;
+    AVIOContext *pb    = s->pb;
 
     avio_skip(pb, 16);
     ea->time_base.den = avio_rl32(pb);
     ea->time_base.num = avio_rl32(pb);
 
     avio_skip(pb, 16);
     ea->time_base.den = avio_rl32(pb);
     ea->time_base.num = avio_rl32(pb);
-    ea->video_codec = AV_CODEC_ID_VP6;
+    ea->video_codec   = AV_CODEC_ID_VP6;
 
     return 1;
 }
 
     return 1;
 }
@@ -290,7 +343,7 @@ static int process_video_header_cmv(AVFormatContext *s)
     avio_skip(s->pb, 10);
     fps = avio_rl16(s->pb);
     if (fps)
     avio_skip(s->pb, 10);
     fps = avio_rl16(s->pb);
     if (fps)
-        ea->time_base = (AVRational){1, fps};
+        ea->time_base = (AVRational) { 1, fps };
     ea->video_codec = AV_CODEC_ID_CMV;
 
     return 0;
     ea->video_codec = AV_CODEC_ID_CMV;
 
     return 0;
@@ -300,81 +353,82 @@ static int process_video_header_cmv(AVFormatContext *s)
  * Process EA file header
  * Returns 1 if the EA file is valid and successfully opened, 0 otherwise
  */
  * Process EA file header
  * Returns 1 if the EA file is valid and successfully opened, 0 otherwise
  */
-static int process_ea_header(AVFormatContext *s) {
+static int process_ea_header(AVFormatContext *s)
+{
     uint32_t blockid, size = 0;
     EaDemuxContext *ea = s->priv_data;
     uint32_t blockid, size = 0;
     EaDemuxContext *ea = s->priv_data;
-    AVIOContext *pb = s->pb;
+    AVIOContext *pb    = s->pb;
     int i;
 
     int i;
 
-    for (i=0; i<5 && (!ea->audio_codec || !ea->video_codec); i++) {
+    for (i = 0; i < 5 && (!ea->audio_codec || !ea->video_codec); i++) {
         unsigned int startpos = avio_tell(pb);
         unsigned int startpos = avio_tell(pb);
-        int err = 0;
+        int err               = 0;
 
         blockid = avio_rl32(pb);
 
         blockid = avio_rl32(pb);
-        size = avio_rl32(pb);
+        size    = avio_rl32(pb);
         if (i == 0)
             ea->big_endian = size > 0x000FFFFF;
         if (ea->big_endian)
             size = av_bswap32(size);
 
         switch (blockid) {
         if (i == 0)
             ea->big_endian = size > 0x000FFFFF;
         if (ea->big_endian)
             size = av_bswap32(size);
 
         switch (blockid) {
-            case ISNh_TAG:
-                if (avio_rl32(pb) != EACS_TAG) {
-                    av_log (s, AV_LOG_ERROR, "unknown 1SNh headerid\n");
-                    return 0;
-                }
-                err = process_audio_header_eacs(s);
-                break;
+        case ISNh_TAG:
+            if (avio_rl32(pb) != EACS_TAG) {
+                av_log(s, AV_LOG_ERROR, "unknown 1SNh headerid\n");
+                return 0;
+            }
+            err = process_audio_header_eacs(s);
+            break;
 
 
-            case SCHl_TAG :
-            case SHEN_TAG :
-                blockid = avio_rl32(pb);
-                if (blockid == GSTR_TAG) {
-                    avio_skip(pb, 4);
-                } else if ((blockid & 0xFFFF)!=PT00_TAG) {
-                    av_log (s, AV_LOG_ERROR, "unknown SCHl headerid\n");
-                    return 0;
-                }
-                err = process_audio_header_elements(s);
-                break;
+        case SCHl_TAG:
+        case SHEN_TAG:
+            blockid = avio_rl32(pb);
+            if (blockid == GSTR_TAG) {
+                avio_skip(pb, 4);
+            } else if ((blockid & 0xFFFF) != PT00_TAG) {
+                av_log(s, AV_LOG_ERROR, "unknown SCHl headerid\n");
+                return 0;
+            }
+            err = process_audio_header_elements(s);
+            break;
 
 
-            case SEAD_TAG:
-                err = process_audio_header_sead(s);
-                break;
+        case SEAD_TAG:
+            err = process_audio_header_sead(s);
+            break;
 
 
-            case MVIh_TAG :
-                err = process_video_header_cmv(s);
-                break;
+        case MVIh_TAG:
+            err = process_video_header_cmv(s);
+            break;
 
 
-            case kVGT_TAG:
-                ea->video_codec = AV_CODEC_ID_TGV;
-                ea->time_base = (AVRational){1, 15};
-                break;
+        case kVGT_TAG:
+            ea->video_codec = AV_CODEC_ID_TGV;
+            ea->time_base   = (AVRational) { 1, 15 };
+            break;
 
 
-            case mTCD_TAG :
-                err = process_video_header_mdec(s);
-                break;
+        case mTCD_TAG:
+            err = process_video_header_mdec(s);
+            break;
 
 
-            case MPCh_TAG:
-                ea->video_codec = AV_CODEC_ID_MPEG2VIDEO;
-                break;
+        case MPCh_TAG:
+            ea->video_codec = AV_CODEC_ID_MPEG2VIDEO;
+            break;
 
 
-            case pQGT_TAG:
-            case TGQs_TAG:
-                ea->video_codec = AV_CODEC_ID_TGQ;
-                break;
+        case pQGT_TAG:
+        case TGQs_TAG:
+            ea->video_codec = AV_CODEC_ID_TGQ;
+            break;
 
 
-            case pIQT_TAG:
-                ea->video_codec = AV_CODEC_ID_TQI;
-                break;
+        case pIQT_TAG:
+            ea->video_codec = AV_CODEC_ID_TQI;
+            break;
 
 
-            case MADk_TAG :
-                ea->video_codec = AV_CODEC_ID_MAD;
-                break;
+        case MADk_TAG:
+            ea->video_codec = AV_CODEC_ID_MAD;
+            break;
 
 
-            case MVhd_TAG :
-                err = process_video_header_vp6(s);
-                break;
+        case MVhd_TAG:
+            err = process_video_header_vp6(s);
+            break;
         }
 
         if (err < 0) {
         }
 
         if (err < 0) {
@@ -390,7 +444,6 @@ static int process_ea_header(AVFormatContext *s) {
     return 1;
 }
 
     return 1;
 }
 
-
 static int ea_probe(AVProbeData *p)
 {
     switch (AV_RL32(&p->buf[0])) {
 static int ea_probe(AVProbeData *p)
 {
     switch (AV_RL32(&p->buf[0])) {
@@ -409,6 +462,7 @@ static int ea_probe(AVProbeData *p)
     }
     if (AV_RL32(&p->buf[4]) > 0xfffff && AV_RB32(&p->buf[4]) > 0xfffff)
         return 0;
     }
     if (AV_RL32(&p->buf[4]) > 0xfffff && AV_RB32(&p->buf[4]) > 0xfffff)
         return 0;
+
     return AVPROBE_SCORE_MAX;
 }
 
     return AVPROBE_SCORE_MAX;
 }
 
@@ -426,28 +480,32 @@ static int ea_read_header(AVFormatContext *s)
         if (!st)
             return AVERROR(ENOMEM);
         ea->video_stream_index = st->index;
         if (!st)
             return AVERROR(ENOMEM);
         ea->video_stream_index = st->index;
-        st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
-        st->codec->codec_id = ea->video_codec;
-        st->codec->codec_tag = 0;  /* no fourcc */
-        st->codec->width = ea->width;
-        st->codec->height = ea->height;
+        st->codec->codec_type  = AVMEDIA_TYPE_VIDEO;
+        st->codec->codec_id    = ea->video_codec;
+        st->codec->codec_tag   = 0; /* no fourcc */
+        st->codec->width       = ea->width;
+        st->codec->height      = ea->height;
         avpriv_set_pts_info(st, 33, ea->time_base.num, ea->time_base.den);
         avpriv_set_pts_info(st, 33, ea->time_base.num, ea->time_base.den);
-        st->avg_frame_rate = (AVRational){ea->time_base.den, ea->time_base.num};
+        st->avg_frame_rate     = (AVRational) { ea->time_base.den,
+                                                ea->time_base.num };
     }
 
     if (ea->audio_codec) {
         if (ea->num_channels <= 0) {
     }
 
     if (ea->audio_codec) {
         if (ea->num_channels <= 0) {
-            av_log(s, AV_LOG_WARNING, "Unsupported number of channels: %d\n", ea->num_channels);
+            av_log(s, AV_LOG_WARNING,
+                   "Unsupported number of channels: %d\n", ea->num_channels);
             ea->audio_codec = 0;
             return 1;
         }
         if (ea->sample_rate <= 0) {
             ea->audio_codec = 0;
             return 1;
         }
         if (ea->sample_rate <= 0) {
-            av_log(s, AV_LOG_ERROR, "Unsupported sample rate: %d\n", ea->sample_rate);
+            av_log(s, AV_LOG_ERROR,
+                   "Unsupported sample rate: %d\n", ea->sample_rate);
             ea->audio_codec = 0;
             return 1;
         }
         if (ea->bytes <= 0) {
             ea->audio_codec = 0;
             return 1;
         }
         if (ea->bytes <= 0) {
-            av_log(s, AV_LOG_ERROR, "Invalid number of bytes per sample: %d\n", ea->bytes);
+            av_log(s, AV_LOG_ERROR,
+                   "Invalid number of bytes per sample: %d\n", ea->bytes);
             ea->audio_codec = AV_CODEC_ID_NONE;
             return 1;
         }
             ea->audio_codec = AV_CODEC_ID_NONE;
             return 1;
         }
@@ -457,31 +515,30 @@ static int ea_read_header(AVFormatContext *s)
         if (!st)
             return AVERROR(ENOMEM);
         avpriv_set_pts_info(st, 33, 1, ea->sample_rate);
         if (!st)
             return AVERROR(ENOMEM);
         avpriv_set_pts_info(st, 33, 1, ea->sample_rate);
-        st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
-        st->codec->codec_id = ea->audio_codec;
-        st->codec->codec_tag = 0;  /* no tag */
-        st->codec->channels = ea->num_channels;
-        st->codec->sample_rate = ea->sample_rate;
+        st->codec->codec_type            = AVMEDIA_TYPE_AUDIO;
+        st->codec->codec_id              = ea->audio_codec;
+        st->codec->codec_tag             = 0;   /* no tag */
+        st->codec->channels              = ea->num_channels;
+        st->codec->sample_rate           = ea->sample_rate;
         st->codec->bits_per_coded_sample = ea->bytes * 8;
         st->codec->bits_per_coded_sample = ea->bytes * 8;
-        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
-            st->codec->bits_per_coded_sample / 4;
-        st->codec->block_align = st->codec->channels*st->codec->bits_per_coded_sample;
-        ea->audio_stream_index = st->index;
-        st->start_time = 0;
+        st->codec->bit_rate              = st->codec->channels *
+                                           st->codec->sample_rate *
+                                           st->codec->bits_per_coded_sample / 4;
+        st->codec->block_align           = st->codec->channels *
+                                           st->codec->bits_per_coded_sample;
+        ea->audio_stream_index           = st->index;
+        st->start_time                   = 0;
     }
 
     return 1;
 }
 
     }
 
     return 1;
 }
 
-static int ea_read_packet(AVFormatContext *s,
-                          AVPacket *pkt)
+static int ea_read_packet(AVFormatContext *s, AVPacket *pkt)
 {
     EaDemuxContext *ea = s->priv_data;
 {
     EaDemuxContext *ea = s->priv_data;
-    AVIOContext *pb = s->pb;
-    int ret = 0;
-    int packet_read = 0;
+    AVIOContext *pb    = s->pb;
     unsigned int chunk_type, chunk_size;
     unsigned int chunk_type, chunk_size;
-    int key = 0;
+    int ret = 0, packet_read = 0, key = 0;
     int av_uninit(num_samples);
 
     while (!packet_read) {
     int av_uninit(num_samples);
 
     while (!packet_read) {
@@ -494,7 +551,7 @@ static int ea_read_packet(AVFormatContext *s,
         switch (chunk_type) {
         /* audio data */
         case ISNh_TAG:
         switch (chunk_type) {
         /* audio data */
         case ISNh_TAG:
-            /* header chunk also contains data; skip over the header portion*/
+            /* header chunk also contains data; skip over the header portion */
             if (chunk_size < 32)
                 return AVERROR_INVALIDDATA;
             avio_skip(pb, 32);
             if (chunk_size < 32)
                 return AVERROR_INVALIDDATA;
             avio_skip(pb, 32);
@@ -547,7 +604,7 @@ static int ea_read_packet(AVFormatContext *s,
         case SCEl_TAG:
         case SEND_TAG:
         case SEEN_TAG:
         case SCEl_TAG:
         case SEND_TAG:
         case SEEN_TAG:
-            ret = AVERROR(EIO);
+            ret         = AVERROR(EIO);
             packet_read = 1;
             break;
 
             packet_read = 1;
             break;
 
@@ -561,12 +618,12 @@ static int ea_read_packet(AVFormatContext *s,
         case fVGT_TAG:
         case MADm_TAG:
         case MADe_TAG:
         case fVGT_TAG:
         case MADm_TAG:
         case MADe_TAG:
-            avio_seek(pb, -8, SEEK_CUR);     // include chunk preamble
+            avio_seek(pb, -8, SEEK_CUR);    // include chunk preamble
             chunk_size += 8;
             goto get_video_packet;
 
         case mTCD_TAG:
             chunk_size += 8;
             goto get_video_packet;
 
         case mTCD_TAG:
-            avio_skip(pb, 8);  // skip ea dct header
+            avio_skip(pb, 8);               // skip ea dct header
             chunk_size -= 8;
             goto get_video_packet;
 
             chunk_size -= 8;
             goto get_video_packet;
 
@@ -580,8 +637,8 @@ get_video_packet:
             if (ret < 0)
                 return ret;
             pkt->stream_index = ea->video_stream_index;
             if (ret < 0)
                 return ret;
             pkt->stream_index = ea->video_stream_index;
-            pkt->flags |= key;
-            packet_read = 1;
+            pkt->flags       |= key;
+            packet_read       = 1;
             break;
 
         default:
             break;
 
         default: