1 files changed, 482 insertions, 396 deletions

diff --git a/src/plugins/old/flv_extractor.c b/src/plugins/old/flv_extractor.c
index f7d762d..2104d79 100644
--- a/src/plugins/old/flv_extractor.c
+++ b/src/plugins/old/flv_extractor.c
@@ -55,16 +55,18 @@
 #define ASTYPE_TYPEDOBJECT  0x10
 #define ASTYPE_AMF3DATA     0x11
 
-typedef struct {
-  void * userdata;
-  void (*as_begin_callback)(unsigned char type, void * userdata);
-  void (*as_key_callback)(char * key, void * userdata);
-  void (*as_end_callback)(unsigned char type, void * value, void * userdata);
+typedef struct
+{
+  void *userdata;
+  void (*as_begin_callback)(unsigned char type, void *userdata);
+  void (*as_key_callback)(char *key, void *userdata);
+  void (*as_end_callback)(unsigned char type, void *value, void *userdata);
 } AMFParserHandler;
 
 /* core datatypes */
 
-static uint32_t readInt32(const unsigned char **data)
+static uint32_t
+readInt32 (const unsigned char **data)
 {
   const unsigned char *ptr = *data;
   uint32_t val;
@@ -75,7 +77,9 @@ static uint32_t readInt32(const unsigned char **data)
   return val;
 }
 
-static uint32_t readInt24(const unsigned char **data)
+
+static uint32_t
+readInt24 (const unsigned char **data)
 {
   const unsigned char *ptr = *data;
   uint32_t val;
@@ -86,7 +90,9 @@ static uint32_t readInt24(const unsigned char **data)
   return val;
 }
 
-static uint16_t readInt16(const unsigned char **data)
+
+static uint16_t
+readInt16 (const unsigned char **data)
 {
   const unsigned char *ptr = *data;
   uint16_t val;
@@ -97,14 +103,17 @@ static uint16_t readInt16(const unsigned char **data)
   return val;
 }
 
-static double readDouble(const unsigned char **data)
+
+static double
+readDouble (const unsigned char **data)
 {
   const unsigned char *ptr = *data;
   double val;
 
-  EXTRACTOR_common_floatformat_to_double(&EXTRACTOR_floatformat_ieee_double_big,
-                        (const void *)ptr,
-                        &val);
+  EXTRACTOR_common_floatformat_to_double (
+    &EXTRACTOR_floatformat_ieee_double_big,
+    (const void *) ptr,
+    &val);
   ptr += 8;
   *data = ptr;
   return val;
@@ -113,9 +122,10 @@ static double readDouble(const unsigned char **data)
 
 /* actionscript types */
 
-static int readASNumber(const unsigned char **data,
-                               size_t *len,
-                               double *retval)
+static int
+readASNumber (const unsigned char **data,
+              size_t *len,
+              double *retval)
 {
   const unsigned char *ptr = *data;
   double val;
@@ -123,7 +133,7 @@ static int readASNumber(const unsigned char **data,
   if (*len < 8)
     return -1;
 
-  val = readDouble(&ptr);
+  val = readDouble (&ptr);
   *len -= 8;
 
   *retval = val;
@@ -131,9 +141,11 @@ static int readASNumber(const unsigned char **data,
   return 0;
 }
 
-static int readASBoolean(const unsigned char **data,
-                                size_t *len,
-                                int *retval)
+
+static int
+readASBoolean (const unsigned char **data,
+               size_t *len,
+               int *retval)
 {
   const unsigned char *ptr = *data;
   int val;
@@ -150,29 +162,33 @@ static int readASBoolean(const unsigned char **data,
   return 0;
 }
 
-static int readASDate(const unsigned char **data,
-                             size_t *len,
-                             double *millis,
-                             short *zone)
+
+static int
+readASDate (const unsigned char **data,
+            size_t *len,
+            double *millis,
+            short *zone)
 {
   const unsigned char *ptr = *data;
 
   if (*len < 10)
     return -1;
 
-  *millis = readDouble(&ptr);
+  *millis = readDouble (&ptr);
   *len -= 8;
 
-  *zone = readInt16(&ptr);
+  *zone = readInt16 (&ptr);
   *len -= 2;
 
   *data = ptr;
   return 0;
 }
 
-static int readASString(const unsigned char **data,
-                               size_t *len,
-                               char **retval)
+
+static int
+readASString (const unsigned char **data,
+              size_t *len,
+              char **retval)
 {
   const unsigned char *ptr = *data;
   char *ret;
@@ -181,15 +197,15 @@ static int readASString(const unsigned char **data,
   if (*len < 2)
     return -1;
 
-  slen = readInt16(&ptr);
+  slen = readInt16 (&ptr);
 
   if (*len < (2 + slen))
     return -1;
 
-  ret = malloc(slen+1);
+  ret = malloc (slen + 1);
   if (ret == NULL)
     return -1;
-  memcpy(ret, ptr, slen);
+  memcpy (ret, ptr, slen);
   ret[slen] = '\0';
   ptr += slen;
   *len -= (2 + slen);
@@ -199,9 +215,11 @@ static int readASString(const unsigned char **data,
   return 0;
 }
 
-static int parse_amf(const unsigned char **data,
-              size_t *len,
-              AMFParserHandler *handler)
+
+static int
+parse_amf (const unsigned char **data,
+           size_t *len,
+           AMFParserHandler *handler)
 {
   const unsigned char *ptr = *data;
   unsigned char astype;
@@ -210,45 +228,47 @@ static int parse_amf(const unsigned char **data,
   ret = 0;
   astype = *ptr++;
   (*(handler->as_begin_callback))(astype, handler->userdata);
-  switch (astype) {
-    case ASTYPE_NUMBER:
+  switch (astype)
+  {
+  case ASTYPE_NUMBER:
     {
       double val;
-      ret = readASNumber(&ptr, len, &val);
+      ret = readASNumber (&ptr, len, &val);
       if (ret == 0)
         (*(handler->as_end_callback))(astype,
                                       &val,
                                       handler->userdata);
       break;
     }
-    case ASTYPE_BOOLEAN:
+  case ASTYPE_BOOLEAN:
     {
       int val;
-      ret = readASBoolean(&ptr, len, &val);
+      ret = readASBoolean (&ptr, len, &val);
       if (ret == 0)
         (*(handler->as_end_callback))(astype,
                                       &val,
                                       handler->userdata);
       break;
     }
-    case ASTYPE_STRING:
+  case ASTYPE_STRING:
     {
       char *val;
-      ret = readASString(&ptr, len, &val);
-      if (ret == 0) {
+      ret = readASString (&ptr, len, &val);
+      if (ret == 0)
+      {
         (*(handler->as_end_callback))(astype,
                                       val,
                                       handler->userdata);
-        free(val);
+        free (val);
       }
       break;
     }
-    case ASTYPE_DATE:
+  case ASTYPE_DATE:
     {
       void *tmp[2];
       double millis;
       short tz;
-      ret = readASDate(&ptr, len, &millis, &tz);
+      ret = readASDate (&ptr, len, &millis, &tz);
       tmp[0] = &millis;
       tmp[1] = &tz;
       if (ret == 0)
@@ -257,53 +277,56 @@ static int parse_amf(const unsigned char **data,
                                       handler->userdata);
       break;
     }
-    case ASTYPE_NULL:
-    case ASTYPE_UNDEFINED:
-    case ASTYPE_UNSUPPORTED:
-    case ASTYPE_ENDOFOBJECT:
-      (*(handler->as_end_callback))(astype, NULL, handler->userdata);
-      break;
-    case ASTYPE_ARRAY:
+  case ASTYPE_NULL:
+  case ASTYPE_UNDEFINED:
+  case ASTYPE_UNSUPPORTED:
+  case ASTYPE_ENDOFOBJECT:
+    (*(handler->as_end_callback))(astype, NULL, handler->userdata);
+    break;
+  case ASTYPE_ARRAY:
     {
       long i, alen;
-      if (*len < 4) {
+      if (*len < 4)
+      {
         ret = -1;
         break;
       }
-      alen = readInt32(&ptr);
+      alen = readInt32 (&ptr);
       *len -= 4;
-      for (i = 0; i < alen; i++) {
-        ret = parse_amf(&ptr, len, handler);
+      for (i = 0; i < alen; i++)
+      {
+        ret = parse_amf (&ptr, len, handler);
         if (ret == -1)
-          break;
+          break;
       }
       (*(handler->as_end_callback))(ASTYPE_ARRAY,
                                     NULL,
                                     handler->userdata);
       break;
     }
-    case ASTYPE_OBJECT:
+  case ASTYPE_OBJECT:
     {
       char *key;
       unsigned char type;
 
-      ret = readASString(&ptr, len, &key);
+      ret = readASString (&ptr, len, &key);
       if (ret == -1)
         break;
       (*(handler->as_key_callback))(key,
                                     handler->userdata);
-      free(key);
+      free (key);
       type = *ptr;
-      while (type != ASTYPE_ENDOFOBJECT) {
-        ret = parse_amf(&ptr, len, handler);
+      while (type != ASTYPE_ENDOFOBJECT)
+      {
+        ret = parse_amf (&ptr, len, handler);
         if (ret == -1)
           break;
-        ret = readASString(&ptr, len, &key);
+        ret = readASString (&ptr, len, &key);
         if (ret == -1)
           break;
         (*(handler->as_key_callback))(key,
                                       handler->userdata);
-        free(key);
+        free (key);
         type = *ptr;
       }
       if (ret == 0)
@@ -312,34 +335,36 @@ static int parse_amf(const unsigned char **data,
                                       handler->userdata);
       break;
     }
-    case ASTYPE_MIXEDARRAY:
+  case ASTYPE_MIXEDARRAY:
     {
       char *key;
       unsigned char type;
-      
-      if (*len < 4) {
+
+      if (*len < 4)
+      {
         ret = -1;
         break;
       }
-      /* max_index */ readInt32(&ptr);
+      /* max_index */ readInt32 (&ptr);
       *len -= 4;
-      ret = readASString(&ptr, len, &key);
+      ret = readASString (&ptr, len, &key);
       if (ret == -1)
         break;
       (*(handler->as_key_callback))(key,
                                     handler->userdata);
-      free(key);
+      free (key);
       type = *ptr;
-      while (type != ASTYPE_ENDOFOBJECT) {
-        ret = parse_amf(&ptr, len, handler);
+      while (type != ASTYPE_ENDOFOBJECT)
+      {
+        ret = parse_amf (&ptr, len, handler);
         if (ret == -1)
           break;
-        ret = readASString(&ptr, len, &key);
+        ret = readASString (&ptr, len, &key);
         if (ret == -1)
           break;
         (*(handler->as_key_callback))(key,
                                       handler->userdata);
-        free(key);
+        free (key);
         type = *ptr;
       }
       if (ret == 0)
@@ -348,21 +373,22 @@ static int parse_amf(const unsigned char **data,
                                       handler->userdata);
       break;
     }
-    default:
-      ret = -1;
-      (*(handler->as_end_callback))(astype,
-                                    NULL,
-                                    handler->userdata);
+  default:
+    ret = -1;
+    (*(handler->as_end_callback))(astype,
+                                  NULL,
+                                  handler->userdata);
 #if DEBUG
-      printf("parse_amf: Unknown type %02x", astype);
+    printf ("parse_amf: Unknown type %02x", astype);
 #endif
-      break;
+    break;
   }
 
   *data = ptr;
   return ret;
 }
 
+
 /*
  * FLV parser
  */
@@ -379,8 +405,9 @@ flv_to_iso_date (double timeval, short timezone,
    * shift epoch to proleptic times
    * to make subsequent modulo operations safer.
    */
-  long long my_timeval = (timeval/1000)
-    + ((long long) ((1970 * 365) + 478) * (long long) 86400);
+  long long my_timeval = (timeval / 1000)
+                         + ((long long) ((1970 * 365) + 478) * (long
+                                                                long) 86400);
 
   unsigned int seconds = (unsigned int) (my_timeval % 60);
   unsigned int minutes = (unsigned int) ((my_timeval / 60) % 60);
@@ -396,7 +423,7 @@ flv_to_iso_date (double timeval, short timezone,
   unsigned int days = (unsigned int) (my_timeval / (24 * 3600));
 
   unsigned int days_in_month[] =
-    { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+  { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
   unsigned int diff = 0;
 
   if ((long long) 0 > my_timeval)
@@ -413,15 +440,15 @@ flv_to_iso_date (double timeval, short timezone,
    */
   diff = (days / ((365 * 100) + 24));
   if (4 <= diff)
-    {
-      year += 399;
-      days = 364;
-    }
+  {
+    year += 399;
+    days = 364;
+  }
   else
-    {
-      year += (100 * diff);
-      days %= ((365 * 100) + 24);
-    }
+  {
+    year += (100 * diff);
+    days %= ((365 * 100) + 24);
+  }
 
   /*
    * remaining leap years
@@ -430,32 +457,32 @@ flv_to_iso_date (double timeval, short timezone,
   days %= ((365 * 4) + 1);
 
   while (1)
+  {
+    if ((0 == (year % 400)) || ((0 == (year % 4)) && (0 != (year % 100))))
     {
-      if ((0 == (year % 400)) || ((0 == (year % 4)) && (0 != (year % 100))))
-        {
-          if (366 > days)
-            {
-              break;
-            }
-          else
-            {
-              days -= 366;
-              year++;
-            }
-        }
+      if (366 > days)
+      {
+        break;
+      }
       else
-        {
-          if (365 > days)
-            {
-              break;
-            }
-          else
-            {
-              days -= 365;
-              year++;
-            }
-        }
+      {
+        days -= 366;
+        year++;
+      }
+    }
+    else
+    {
+      if (365 > days)
+      {
+        break;
+      }
+      else
+      {
+        days -= 365;
+        year++;
+      }
     }
+  }
 
   if ((0 == (year % 400)) || ((0 == (year % 4)) && (0 != (year % 100))))
     days_in_month[1] = 29;
@@ -465,12 +492,12 @@ flv_to_iso_date (double timeval, short timezone,
 
   zone_sign = 0;
   if (timezone < 0)
-    {
-      zone_sign = -1;
-      timezone = -timezone;
-    }
-  zone_hours = timezone/60;
-  zone_minutes = timezone - zone_hours*60;
+  {
+    zone_sign = -1;
+    timezone = -timezone;
+  }
+  zone_hours = timezone / 60;
+  zone_minutes = timezone - zone_hours * 60;
 
   retval = snprintf (rtime, rsize, "%04u-%02u-%02uT%02u:%02u:%02u%c%02d:%02u",
                      year, month + 1, days + 1, hours, minutes, seconds,
@@ -479,6 +506,7 @@ flv_to_iso_date (double timeval, short timezone,
   return (retval < rsize) ? 0 : EOVERFLOW;
 }
 
+
 typedef struct
 {
   char signature[3];
@@ -503,20 +531,21 @@ typedef struct
 
 #define FLV_TAG_HEADER_SIZE 11
 
-static int readFLVHeader(const unsigned char **data,
-                         const unsigned char *end,
-                         FLVHeader *hdr)
+static int
+readFLVHeader (const unsigned char **data,
+               const unsigned char *end,
+               FLVHeader *hdr)
 {
   const unsigned char *ptr = *data;
 
   if ((ptr + FLV_HEADER_SIZE) > end)
     return -1;
 
-  memcpy(hdr->signature, ptr, 3);
+  memcpy (hdr->signature, ptr, 3);
   ptr += 3;
   hdr->version = *ptr++;
   hdr->flags = *ptr++;
-  hdr->offset = readInt32(&ptr);
+  hdr->offset = readInt32 (&ptr);
   if (hdr->offset != FLV_HEADER_SIZE)
     return -1;
 
@@ -524,24 +553,28 @@ static int readFLVHeader(const unsigned char **data,
   return 0;
 }
 
-static int readPreviousTagSize(const unsigned char **data,
-                                const unsigned char *end,
-                                unsigned long *prev_size)
+
+static int
+readPreviousTagSize (const unsigned char **data,
+                     const unsigned char *end,
+                     unsigned long *prev_size)
 {
   const unsigned char *ptr = *data;
 
   if ((ptr + 4) > end)
     return -1;
 
-  *prev_size = readInt32(&ptr);
+  *prev_size = readInt32 (&ptr);
 
   *data = ptr;
   return 0;
 }
 
-static int readFLVTagHeader(const unsigned char **data,
-                          const unsigned char *end,
-                          FLVTagHeader *hdr)
+
+static int
+readFLVTagHeader (const unsigned char **data,
+                  const unsigned char *end,
+                  FLVTagHeader *hdr)
 {
   const unsigned char *ptr = *data;
 
@@ -549,15 +582,17 @@ static int readFLVTagHeader(const unsigned char **data,
     return -1;
 
   hdr->type = *ptr++;
-  hdr->bodyLength = readInt24(&ptr);
-  hdr->timestamp = readInt32(&ptr);
-  hdr->streamId = readInt24(&ptr);
+  hdr->bodyLength = readInt24 (&ptr);
+  hdr->timestamp = readInt32 (&ptr);
+  hdr->streamId = readInt24 (&ptr);
 
   *data = ptr;
   return 0;
 }
 
-typedef struct {
+
+typedef struct
+{
   int videoCodec;
   char *videoCodecStr;
   int videoWidth;
@@ -573,7 +608,8 @@ typedef struct {
   int audioRate;
 } FLVStreamInfo;
 
-typedef enum {
+typedef enum
+{
   FLV_NONE = 0,
   FLV_WIDTH,
   FLV_HEIGHT,
@@ -586,7 +622,8 @@ typedef enum {
   FLV_ACODECID
 } FLVStreamAttribute;
 
-typedef struct {
+typedef struct
+{
   const char *key;
   FLVStreamAttribute attribute;
 } MetaKeyToStreamAttribute;
@@ -605,7 +642,8 @@ static MetaKeyToStreamAttribute key_to_attribute_map[] = {
   { NULL, FLV_NONE }
 };
 
-typedef struct {
+typedef struct
+{
   const char *key;
   enum EXTRACTOR_MetaType type;
 } MetaKeyToExtractorItem;
@@ -619,7 +657,8 @@ static MetaKeyToExtractorItem key_to_extractor_map[] = {
   { NULL, EXTRACTOR_METATYPE_RESERVED }
 };
 
-typedef struct {
+typedef struct
+{
   int onMetaData;
   int parsingDepth;
   int ret;
@@ -632,22 +671,25 @@ typedef struct {
   FLVStreamInfo *streamInfo;
 } FLVMetaParserState;
 
-static void handleASBegin(unsigned char type, void * userdata)
+static void
+handleASBegin (unsigned char type, void *userdata)
 {
-  FLVMetaParserState *state = (FLVMetaParserState *)userdata;
+  FLVMetaParserState *state = (FLVMetaParserState *) userdata;
 
-  if (state->onMetaData && state->parsingDepth == 0 &&
-      type != ASTYPE_MIXEDARRAY)
+  if (state->onMetaData && (state->parsingDepth == 0) &&
+      (type != ASTYPE_MIXEDARRAY) )
     state->onMetaData = 0;
 
-  if (type == ASTYPE_ARRAY || type == ASTYPE_MIXEDARRAY ||
-      type == ASTYPE_OBJECT)
+  if ((type == ASTYPE_ARRAY) || (type == ASTYPE_MIXEDARRAY) ||
+      (type == ASTYPE_OBJECT) )
     state->parsingDepth++;
 }
 
-static void handleASKey(char * key, void * userdata)
+
+static void
+handleASKey (char *key, void *userdata)
 {
-  FLVMetaParserState *state = (FLVMetaParserState *)userdata;
+  FLVMetaParserState *state = (FLVMetaParserState *) userdata;
   int i;
 
   if (key == NULL)
@@ -655,26 +697,29 @@ static void handleASKey(char * key, void * userdata)
 
   i = 0;
   while ((key_to_extractor_map[i].key != NULL) &&
-         (strcasecmp(key, key_to_extractor_map[i].key) != 0))
+         (strcasecmp (key, key_to_extractor_map[i].key) != 0))
     i++;
   state->currentKeyType = key_to_extractor_map[i].type;
 
   i = 0;
   while ((key_to_attribute_map[i].key != NULL) &&
-         (strcasecmp(key, key_to_attribute_map[i].key) != 0))
+         (strcasecmp (key, key_to_attribute_map[i].key) != 0))
     i++;
   state->currentAttribute = key_to_attribute_map[i].attribute;
 }
 
-static void handleASEnd(unsigned char type, void * value, void * userdata)
+
+static void
+handleASEnd (unsigned char type, void *value, void *userdata)
 {
-  FLVMetaParserState *state = (FLVMetaParserState *)userdata;
+  FLVMetaParserState *state = (FLVMetaParserState *) userdata;
   const char *s;
   char tmpstr[30];
 
-  if ((state->parsingDepth == 0) && (type == ASTYPE_STRING)) {
-    s = (const char *)value;
-    if (!strcmp(s, "onMetaData"))
+  if ((state->parsingDepth == 0) && (type == ASTYPE_STRING))
+  {
+    s = (const char *) value;
+    if (! strcmp (s, "onMetaData"))
       state->onMetaData = 1;
   }
 
@@ -686,50 +731,53 @@ static void handleASEnd(unsigned char type, void * value, void * userdata)
       (state->currentAttribute != FLV_NONE) &&
       (type == ASTYPE_NUMBER))
   {
-    double n = *((double *)value);
-    switch (state->currentAttribute) {
-      case FLV_NONE: /* make gcc happy */
-        break;
-      case FLV_STEREO:
-        break;
-      case FLV_ACHANNELS:
-        state->streamInfo->audioChannels = n;
-        break;
-      case FLV_WIDTH:
-        if (state->streamInfo->videoWidth == -1)
-          state->streamInfo->videoWidth = n;
-        break;
-      case FLV_HEIGHT:
-        if (state->streamInfo->videoHeight == -1)
-          state->streamInfo->videoHeight = n;
-        break;
-      case FLV_FRAMERATE:
-        state->streamInfo->videoFrameRate = n;
-        break;
-      case FLV_VDATARATE:
-        state->streamInfo->videoDataRate = n;
-        break;
-      case FLV_ADATARATE:
-        state->streamInfo->audioDataRate = n;
-        break;
-      case FLV_VCODECID:
-        if (state->streamInfo->videoCodec == -1)
-          state->streamInfo->videoCodec = n;
-        /* prefer codec ids to fourcc codes */
-        if (state->streamInfo->videoCodecStr != NULL) {
-          free(state->streamInfo->videoCodecStr);
-          state->streamInfo->videoCodecStr = NULL;
-        }
-        break;
-      case FLV_ACODECID:
-        if (state->streamInfo->audioCodec == -1)
-          state->streamInfo->audioCodec = n;
-        /* prefer codec ids to fourcc codes */
-        if (state->streamInfo->audioCodecStr != NULL) {
-          free(state->streamInfo->audioCodecStr);
-          state->streamInfo->audioCodecStr = NULL;
-        }
-        break;
+    double n = *((double *) value);
+    switch (state->currentAttribute)
+    {
+    case FLV_NONE:   /* make gcc happy */
+      break;
+    case FLV_STEREO:
+      break;
+    case FLV_ACHANNELS:
+      state->streamInfo->audioChannels = n;
+      break;
+    case FLV_WIDTH:
+      if (state->streamInfo->videoWidth == -1)
+        state->streamInfo->videoWidth = n;
+      break;
+    case FLV_HEIGHT:
+      if (state->streamInfo->videoHeight == -1)
+        state->streamInfo->videoHeight = n;
+      break;
+    case FLV_FRAMERATE:
+      state->streamInfo->videoFrameRate = n;
+      break;
+    case FLV_VDATARATE:
+      state->streamInfo->videoDataRate = n;
+      break;
+    case FLV_ADATARATE:
+      state->streamInfo->audioDataRate = n;
+      break;
+    case FLV_VCODECID:
+      if (state->streamInfo->videoCodec == -1)
+        state->streamInfo->videoCodec = n;
+      /* prefer codec ids to fourcc codes */
+      if (state->streamInfo->videoCodecStr != NULL)
+      {
+        free (state->streamInfo->videoCodecStr);
+        state->streamInfo->videoCodecStr = NULL;
+      }
+      break;
+    case FLV_ACODECID:
+      if (state->streamInfo->audioCodec == -1)
+        state->streamInfo->audioCodec = n;
+      /* prefer codec ids to fourcc codes */
+      if (state->streamInfo->audioCodecStr != NULL)
+      {
+        free (state->streamInfo->audioCodecStr);
+        state->streamInfo->audioCodecStr = NULL;
+      }
+      break;
     }
   }
 
@@ -738,20 +786,21 @@ static void handleASEnd(unsigned char type, void * value, void * userdata)
       (state->currentAttribute != FLV_NONE) &&
       (type == ASTYPE_STRING))
   {
-    s = (const char *)value;
-    switch (state->currentAttribute) {
-      case FLV_VCODECID:
-        if (s != NULL && state->streamInfo->videoCodecStr == NULL &&
-            state->streamInfo->videoCodec == -1)
-          state->streamInfo->videoCodecStr = strdup(s);
-        break;
-      case FLV_ACODECID:
-        if (s != NULL && state->streamInfo->audioCodecStr == NULL &&
-            state->streamInfo->audioCodec == -1)
-          state->streamInfo->audioCodecStr = strdup(s);
-        break;
-      default:
-        break;
+    s = (const char *) value;
+    switch (state->currentAttribute)
+    {
+    case FLV_VCODECID:
+      if ((s != NULL) && (state->streamInfo->videoCodecStr == NULL) &&
+          (state->streamInfo->videoCodec == -1) )
+        state->streamInfo->videoCodecStr = strdup (s);
+      break;
+    case FLV_ACODECID:
+      if ((s != NULL) && (state->streamInfo->audioCodecStr == NULL) &&
+          (state->streamInfo->audioCodec == -1) )
+        state->streamInfo->audioCodecStr = strdup (s);
+      break;
+    default:
+      break;
     }
   }
 
@@ -759,7 +808,7 @@ static void handleASEnd(unsigned char type, void * value, void * userdata)
       (state->currentAttribute == FLV_STEREO) &&
       (type == ASTYPE_BOOLEAN))
   {
-    int n = *((int *)value);
+    int n = *((int *) value);
     if (state->streamInfo->audioChannels == -1)
       state->streamInfo->audioChannels = (n == 0) ? 1 : 2;
   }
@@ -769,57 +818,59 @@ static void handleASEnd(unsigned char type, void * value, void * userdata)
       (state->currentKeyType != EXTRACTOR_METATYPE_RESERVED))
   {
     s = NULL;
-    switch (type) {
-      case ASTYPE_NUMBER:
+    switch (type)
+    {
+    case ASTYPE_NUMBER:
       {
-        double n = *((double *)value);
+        double n = *((double *) value);
         s = tmpstr;
-        if (state->currentKeyType == EXTRACTOR_METATYPE_DURATION)
-          snprintf(tmpstr, sizeof(tmpstr), "%.2f s", n);
-        else
-          snprintf(tmpstr, sizeof(tmpstr), "%f", n);
-        break;
+        if (state->currentKeyType == EXTRACTOR_METATYPE_DURATION)
+          snprintf (tmpstr, sizeof(tmpstr), "%.2f s", n);
+        else
+          snprintf (tmpstr, sizeof(tmpstr), "%f", n);
+        break;
       }
-      case ASTYPE_STRING:
+    case ASTYPE_STRING:
       {
-        s = (char *)value;
+        s = (char *) value;
         break;
       }
-      case ASTYPE_DATE:
+    case ASTYPE_DATE:
       {
-        void **tmp = (void **)value;
-        double *millis;
-        short *tz;
-        millis = (double *)tmp[0];
-        tz = (short *)tmp[1];
-        if (0 == flv_to_iso_date(*millis, *tz, tmpstr, sizeof(tmpstr)))
-          s = tmpstr;
+        void **tmp = (void **) value;
+        double *millis;
+        short *tz;
+        millis = (double *) tmp[0];
+        tz = (short *) tmp[1];
+        if (0 == flv_to_iso_date (*millis, *tz, tmpstr, sizeof(tmpstr)))
+          s = tmpstr;
         break;
       }
     }
     if ( (s != NULL) &&
-         (state->ret == 0) )
+         (state->ret == 0) )
       state->ret = state->proc (state->proc_cls,
-                                "flv",
-                                state->currentKeyType,
-                                EXTRACTOR_METAFORMAT_UTF8,
-                                "text/plain",
-                                s,
-                                strlen (s) + 1);
+                                "flv",
+                                state->currentKeyType,
+                                EXTRACTOR_METAFORMAT_UTF8,
+                                "text/plain",
+                                s,
+                                strlen (s) + 1);
   }
   state->currentKeyType = EXTRACTOR_METATYPE_RESERVED;
   state->currentAttribute = FLV_NONE;
 
-  if (type == ASTYPE_ARRAY || type == ASTYPE_MIXEDARRAY ||
-      type == ASTYPE_OBJECT)
+  if ((type == ASTYPE_ARRAY) || (type == ASTYPE_MIXEDARRAY) ||
+      (type == ASTYPE_OBJECT) )
     state->parsingDepth--;
 }
 
+
 static int
-handleMetaBody(const unsigned char *data, size_t len,
-               FLVStreamInfo *stinfo,
-               EXTRACTOR_MetaDataProcessor proc,
-               void *proc_cls)
+handleMetaBody (const unsigned char *data, size_t len,
+                FLVStreamInfo *stinfo,
+                EXTRACTOR_MetaDataProcessor proc,
+                void *proc_cls)
 {
   AMFParserHandler handler;
   FLVMetaParserState pstate;
@@ -836,12 +887,14 @@ handleMetaBody(const unsigned char *data, size_t len,
   handler.as_key_callback = &handleASKey;
   handler.as_end_callback = &handleASEnd;
 
-  while (len > 0 && parse_amf(&data, &len, &handler) == 0);
+  while (len > 0 && parse_amf (&data, &len, &handler) == 0)
+    ;
   if (pstate.ret != 0)
     return 1;
   return 0;
 }
 
+
 static char *FLVAudioCodecs[] = {
   "Uncompressed",
   "ADPCM",
@@ -875,19 +928,21 @@ static char *FLVAudioSampleRates[] = {
 };
 
 static void
-handleAudioBody(const unsigned char *data, size_t len,
-                FLVStreamInfo *stinfo)
+handleAudioBody (const unsigned char *data, size_t len,
+                 FLVStreamInfo *stinfo)
 {
   stinfo->audioChannels = (*data & 0x01) + 1;
   stinfo->audioSampleBits = (*data & 0x02) >> 1;
   stinfo->audioRate = (*data & 0x0C) >> 2;
   stinfo->audioCodec = (*data & 0xF0) >> 4;
-  if (stinfo->audioCodecStr != NULL) {
-    free(stinfo->audioCodecStr);
+  if (stinfo->audioCodecStr != NULL)
+  {
+    free (stinfo->audioCodecStr);
     stinfo->audioCodecStr = NULL;
   }
 }
 
+
 static char *FLVVideoCodecs[] = {
   NULL,
   NULL,
@@ -911,8 +966,8 @@ static int sorenson_predefined_res[][2] = {
 };
 
 static void
-handleVideoBody(const unsigned char *data, size_t len,
-                FLVStreamInfo *stinfo)
+handleVideoBody (const unsigned char *data, size_t len,
+                 FLVStreamInfo *stinfo)
 {
   int codecId, frameType;
 
@@ -921,84 +976,94 @@ handleVideoBody(const unsigned char *data, size_t len,
   data++;
 
   /* try to get video dimensions */
-  switch (codecId) {
-    case 0x02: /* Sorenson */
-      if (len < 9)
-        break;
-      if (frameType == 1) {
-        int start_code = (data[0] << 9) | (data[1] << 1) | ((data[2] >> 7)&0x1);
-        int version = (data[2] & 0x7C) >> 2;
-        int frame_size = ((data[3] & 0x03) << 1) | (data[4] >> 7);
-        if (start_code != 0x00000001)
-          break;
-        if (!(version == 0 || version == 1))
-          break;
-        if (frame_size == 0) {
-          stinfo->videoWidth = ((data[4] & 0x7F) >> 1) | (data[5] >> 7);
-          stinfo->videoHeight = ((data[5] & 0x7F) >> 1) | (data[6] >> 7);
-        }
-        else if (frame_size == 1) {
-          stinfo->videoWidth = ((data[4] & 0x7F) << 9) | (data[5] << 1) |
-                               (data[6] >> 7);
-          stinfo->videoHeight = ((data[6] & 0x7F) << 9) | (data[7] << 1) |
-                                (data[8] >> 7);
-        }
-        else {
-          stinfo->videoWidth = sorenson_predefined_res[frame_size][0];
-          stinfo->videoHeight = sorenson_predefined_res[frame_size][1];
-        }
-      }
+  switch (codecId)
+  {
+  case 0x02:   /* Sorenson */
+    if (len < 9)
       break;
-    case 0x03: /* ScreenVideo */
-      if (len < 5)
+    if (frameType == 1)
+    {
+      int start_code = (data[0] << 9) | (data[1] << 1) | ((data[2] >> 7) & 0x1);
+      int version = (data[2] & 0x7C) >> 2;
+      int frame_size = ((data[3] & 0x03) << 1) | (data[4] >> 7);
+      if (start_code != 0x00000001)
         break;
-      stinfo->videoWidth = readInt16(&data) & 0x0FFF;
-      stinfo->videoHeight = readInt16(&data) & 0x0FFF;
+      if (! ((version == 0) || (version == 1) ))
+        break;
+      if (frame_size == 0)
+      {
+        stinfo->videoWidth = ((data[4] & 0x7F) >> 1) | (data[5] >> 7);
+        stinfo->videoHeight = ((data[5] & 0x7F) >> 1) | (data[6] >> 7);
+      }
+      else if (frame_size == 1)
+      {
+        stinfo->videoWidth = ((data[4] & 0x7F) << 9) | (data[5] << 1)
+                             | (data[6] >> 7);
+        stinfo->videoHeight = ((data[6] & 0x7F) << 9) | (data[7] << 1)
+                              | (data[8] >> 7);
+      }
+      else
+      {
+        stinfo->videoWidth = sorenson_predefined_res[frame_size][0];
+        stinfo->videoHeight = sorenson_predefined_res[frame_size][1];
+      }
+    }
+    break;
+  case 0x03:   /* ScreenVideo */
+    if (len < 5)
       break;
-    case 0x04: /* On2 VP6 */
-    case 0x05:
+    stinfo->videoWidth = readInt16 (&data) & 0x0FFF;
+    stinfo->videoHeight = readInt16 (&data) & 0x0FFF;
+    break;
+  case 0x04:   /* On2 VP6 */
+  case 0x05:
     {
       unsigned char dim_adj;
       if (len < 10)
         break;
       dim_adj = *data++;
-      if ((frameType == 1) && ((data[0] & 0x80) == 0)) {
+      if ((frameType == 1) && ((data[0] & 0x80) == 0))
+      {
         /* see ffmpeg vp6 decoder */
         int separated_coeff = data[0] & 0x01;
         int filter_header = data[1] & 0x06;
         /*int interlaced = data[1] & 0x01; TODO: used in flv ever? */
-        if (separated_coeff || !filter_header) {
+        if (separated_coeff || ! filter_header)
+        {
           data += 2;
         }
         /* XXX encoded/displayed dimensions might vary, but which are the
          * right ones? */
-        stinfo->videoWidth = (data[3]*16) - (dim_adj>>4);
-        stinfo->videoHeight = (data[2]*16) - (dim_adj&0x0F);
+        stinfo->videoWidth = (data[3] * 16) - (dim_adj >> 4);
+        stinfo->videoHeight = (data[2] * 16) - (dim_adj & 0x0F);
       }
       break;
     }
-    default:
-      break;
+  default:
+    break;
   }
 
   stinfo->videoCodec = codecId;
-  if (stinfo->videoCodecStr != NULL) {
-    free(stinfo->videoCodecStr);
+  if (stinfo->videoCodecStr != NULL)
+  {
+    free (stinfo->videoCodecStr);
     stinfo->videoCodecStr = NULL;
   }
 }
 
-static int readFLVTag(const unsigned char **data,
-                      const unsigned char *end,
-                      FLVStreamInfo *stinfo,
-                      EXTRACTOR_MetaDataProcessor proc,
-                      void *proc_cls)
+
+static int
+readFLVTag (const unsigned char **data,
+            const unsigned char *end,
+            FLVStreamInfo *stinfo,
+            EXTRACTOR_MetaDataProcessor proc,
+            void *proc_cls)
 {
   const unsigned char *ptr = *data;
   FLVTagHeader header;
   int ret = 0;
 
-  if (readFLVTagHeader(&ptr, end, &header) == -1)
+  if (readFLVTagHeader (&ptr, end, &header) == -1)
     return -1;
 
   if ((ptr + header.bodyLength) > end)
@@ -1006,17 +1071,17 @@ static int readFLVTag(const unsigned char **data,
 
   switch (header.type)
   {
-    case FLV_TAG_TYPE_AUDIO:
-      handleAudioBody(ptr, header.bodyLength, stinfo);
-      break;
-    case FLV_TAG_TYPE_VIDEO:
-      handleVideoBody(ptr, header.bodyLength, stinfo);
-      break;
-    case FLV_TAG_TYPE_META:
-      ret = handleMetaBody(ptr, header.bodyLength, stinfo, proc, proc_cls);
-      break;
-    default:
-      break;
+  case FLV_TAG_TYPE_AUDIO:
+    handleAudioBody (ptr, header.bodyLength, stinfo);
+    break;
+  case FLV_TAG_TYPE_VIDEO:
+    handleVideoBody (ptr, header.bodyLength, stinfo);
+    break;
+  case FLV_TAG_TYPE_META:
+    ret = handleMetaBody (ptr, header.bodyLength, stinfo, proc, proc_cls);
+    break;
+  default:
+    break;
   }
 
   ptr += header.bodyLength;
@@ -1024,129 +1089,149 @@ static int readFLVTag(const unsigned char **data,
   return ret;
 }
 
+
 #define MAX_FLV_FORMAT_LINE 80
-static char * printVideoFormat(FLVStreamInfo *stinfo)
+static char *
+printVideoFormat (FLVStreamInfo *stinfo)
 {
-  char s[MAX_FLV_FORMAT_LINE+1];
+  char s[MAX_FLV_FORMAT_LINE + 1];
   int n;
   size_t len = MAX_FLV_FORMAT_LINE;
 
   n = 0;
   /* some files seem to specify only the width or the height, print '?' for
    * the unknown dimension */
-  if (stinfo->videoWidth != -1 || stinfo->videoHeight != -1) {
-    if (n < len) {
+  if ((stinfo->videoWidth != -1) || (stinfo->videoHeight != -1))
+  {
+    if (n < len)
+    {
       if (stinfo->videoWidth != -1)
-        n += snprintf(s+n, len-n, "%d", stinfo->videoWidth);
+        n += snprintf (s + n, len - n, "%d", stinfo->videoWidth);
       else
-        n += snprintf(s+n, len-n, "?");
+        n += snprintf (s + n, len - n, "?");
     }
 
-    if (n < len) {
+    if (n < len)
+    {
       if (stinfo->videoHeight != -1)
-        n += snprintf(s+n, len-n, "x%d", stinfo->videoHeight);
+        n += snprintf (s + n, len - n, "x%d", stinfo->videoHeight);
       else
-        n += snprintf(s+n, len-n, "x?");
+        n += snprintf (s + n, len - n, "x?");
     }
   }
 
-  if (stinfo->videoFrameRate != 0.0 && n < len) {
+  if ((stinfo->videoFrameRate != 0.0) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%0.2f fps", stinfo->videoFrameRate);
+      n += snprintf (s + n, len - n, "%0.2f fps", stinfo->videoFrameRate);
   }
 
-  if (stinfo->videoCodec > -1 && stinfo->videoCodec < 8 &&
-      FLVVideoCodecs[stinfo->videoCodec] != NULL && n < len) {
+  if ((stinfo->videoCodec > -1) && (stinfo->videoCodec < 8) &&
+      (FLVVideoCodecs[stinfo->videoCodec] != NULL) && (n < len) )
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%s", FLVVideoCodecs[stinfo->videoCodec]);
+      n += snprintf (s + n, len - n, "%s", FLVVideoCodecs[stinfo->videoCodec]);
   }
-  else if (stinfo->videoCodecStr != NULL && n < len) {
+  else if ((stinfo->videoCodecStr != NULL) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%s", stinfo->videoCodecStr);    
+      n += snprintf (s + n, len - n, "%s", stinfo->videoCodecStr);
   }
 
-  if (stinfo->videoDataRate != 0.0 && n < len) {
+  if ((stinfo->videoDataRate != 0.0) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%.4f kbps", stinfo->videoDataRate);
+      n += snprintf (s + n, len - n, "%.4f kbps", stinfo->videoDataRate);
   }
 
   if (n == 0)
     return NULL;
-  return strdup(s);
+  return strdup (s);
 }
 
-static char * printAudioFormat(FLVStreamInfo *stinfo)
+
+static char *
+printAudioFormat (FLVStreamInfo *stinfo)
 {
-  char s[MAX_FLV_FORMAT_LINE+1];
+  char s[MAX_FLV_FORMAT_LINE + 1];
   int n;
   size_t len = MAX_FLV_FORMAT_LINE;
 
   n = 0;
-  if ( (stinfo->audioRate != -1) && (n < len)) {
-      n += snprintf(s+n, len-n, "%s Hz", FLVAudioSampleRates[stinfo->audioRate]);
+  if ( (stinfo->audioRate != -1) && (n < len))
+  {
+    n += snprintf (s + n, len - n, "%s Hz",
+                   FLVAudioSampleRates[stinfo->audioRate]);
   }
 
-  if ((stinfo->audioSampleBits != -1) && (n < len)) {
+  if ((stinfo->audioSampleBits != -1) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%s",
-                    FLVAudioSampleSizes[stinfo->audioSampleBits]);
+      n += snprintf (s + n, len - n, "%s",
+                     FLVAudioSampleSizes[stinfo->audioSampleBits]);
   }
 
-  if ((stinfo->audioChannels != -1) && (n < len)) {
+  if ((stinfo->audioChannels != -1) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
-    if (n < len) {
-      if (stinfo->audioChannels >= 1 && stinfo->audioChannels <= 2)
-        n += snprintf(s+n, len-n, "%s",
-                      FLVAudioChannels[stinfo->audioChannels-1]);
+      n += snprintf (s + n, len - n, ", ");
+    if (n < len)
+    {
+      if ((stinfo->audioChannels >= 1) && (stinfo->audioChannels <= 2))
+        n += snprintf (s + n, len - n, "%s",
+                       FLVAudioChannels[stinfo->audioChannels - 1]);
       else
-        n += snprintf(s+n, len-n, "%d",
-                      stinfo->audioChannels);
+        n += snprintf (s + n, len - n, "%d",
+                       stinfo->audioChannels);
     }
   }
 
   if ((stinfo->audioCodec > -1) && (stinfo->audioCodec < 12) &&
-      (FLVAudioCodecs[stinfo->audioCodec] != NULL) && (n < len)) {
+      (FLVAudioCodecs[stinfo->audioCodec] != NULL) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%s", FLVAudioCodecs[stinfo->audioCodec]);
+      n += snprintf (s + n, len - n, "%s", FLVAudioCodecs[stinfo->audioCodec]);
   }
-  else if ((stinfo->audioCodecStr != NULL) && (n < len)) {
+  else if ((stinfo->audioCodecStr != NULL) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%s", stinfo->audioCodecStr);    
+      n += snprintf (s + n, len - n, "%s", stinfo->audioCodecStr);
   }
 
-  if ((stinfo->audioDataRate != 0.0) && (n < len)) {
+  if ((stinfo->audioDataRate != 0.0) && (n < len))
+  {
     if (n > 0)
-      n += snprintf(s+n, len-n, ", ");
+      n += snprintf (s + n, len - n, ", ");
     if (n < len)
-      n += snprintf(s+n, len-n, "%.4f kbps", stinfo->audioDataRate);
+      n += snprintf (s + n, len - n, "%.4f kbps", stinfo->audioDataRate);
   }
 
   if (n == 0)
     return NULL;
-  return strdup(s);
+  return strdup (s);
 }
 
-int 
+
+int
 EXTRACTOR_flv_extract (const unsigned char *data,
-                       size_t size,
-                       EXTRACTOR_MetaDataProcessor proc,
-                       void *proc_cls,
-                       const char *options)
+                       size_t size,
+                       EXTRACTOR_MetaDataProcessor proc,
+                       void *proc_cls,
+                       const char *options)
 {
   const unsigned char *ptr;
   const unsigned char *end;
@@ -1159,19 +1244,19 @@ EXTRACTOR_flv_extract (const unsigned char *data,
   ptr = data;
   end = ptr + size;
 
-  if (readFLVHeader(&ptr, end, &header) == -1)
+  if (readFLVHeader (&ptr, end, &header) == -1)
     return 0;
 
-  if (memcmp(header.signature, FLV_SIGNATURE, 3) != 0)
+  if (memcmp (header.signature, FLV_SIGNATURE, 3) != 0)
     return 0;
 
   if (0 != proc (proc_cls,
-                 "flv",
-                 EXTRACTOR_METATYPE_MIMETYPE, 
-                 EXTRACTOR_METAFORMAT_UTF8,
-                 "text/plain",
-                 "video/x-flv",
-                 strlen ("video/x-flv") + 1))
+                 "flv",
+                 EXTRACTOR_METATYPE_MIMETYPE,
+                 EXTRACTOR_METAFORMAT_UTF8,
+                 "text/plain",
+                 "video/x-flv",
+                 strlen ("video/x-flv") + 1))
     return 0;
   if (header.version != 1)
     return 0;
@@ -1191,7 +1276,8 @@ EXTRACTOR_flv_extract (const unsigned char *data,
   stinfo.audioChannels = -1;
   stinfo.audioDataRate = 0.0;
   ret = 0;
-  while (ptr < end) {
+  while (ptr < end)
+  {
     if (-1 == (ret = readFLVTag (&ptr, end, &stinfo, proc, proc_cls)))
       break;
     if (readPreviousTagSize (&ptr, end, &prev_tag_size) == -1)
@@ -1201,35 +1287,35 @@ EXTRACTOR_flv_extract (const unsigned char *data,
     return 1;
   s = printVideoFormat (&stinfo);
   if (s != NULL)
+  {
+    if (0 != proc (proc_cls,
+                   "flv",
+                   EXTRACTOR_METATYPE_RESOURCE_TYPE,
+                   EXTRACTOR_METAFORMAT_UTF8,
+                   "text/plain",
+                   s,
+                   strlen (s) + 1))
     {
-      if (0 != proc (proc_cls, 
-                     "flv",
-                     EXTRACTOR_METATYPE_RESOURCE_TYPE,
-                     EXTRACTOR_METAFORMAT_UTF8,
-                     "text/plain",
-                     s,
-                     strlen (s)+1))
-        {
-          free (s);
-          return 1;
-        }
       free (s);
+      return 1;
     }
+    free (s);
+  }
   s = printAudioFormat (&stinfo);
   if (s != NULL)
+  {
+    if (0 != proc (proc_cls,
+                   "flv",
+                   EXTRACTOR_METATYPE_RESOURCE_TYPE,
+                   EXTRACTOR_METAFORMAT_UTF8,
+                   "text/plain",
+                   s,
+                   strlen (s) + 1))
     {
-      if (0 != proc (proc_cls, 
-                     "flv",
-                     EXTRACTOR_METATYPE_RESOURCE_TYPE,
-                     EXTRACTOR_METAFORMAT_UTF8,
-                     "text/plain",
-                     s,
-                     strlen (s)+1))
-        {
-          free (s);
-          return 1;
-        }
       free (s);
+      return 1;
     }
+    free (s);
+  }
   return 0;
 }