1 files changed, 353 insertions, 352 deletions

diff --git a/src/plugins/thumbnailffmpeg_extractor.c b/src/plugins/thumbnailffmpeg_extractor.c
index 72af79f..72f0137 100644
--- a/src/plugins/thumbnailffmpeg_extractor.c
+++ b/src/plugins/thumbnailffmpeg_extractor.c
@@ -97,7 +97,7 @@
 /**
  * Maximum size in bytes for the thumbnail.
  */
-#define MAX_THUMB_BYTES (100*1024)
+#define MAX_THUMB_BYTES (100 * 1024)
 
 /**
  * Number of bytes to feed to libav in one go.
@@ -135,8 +135,8 @@ static magic_t magic;
  */
 static int
 read_cb (void *opaque,
-         uint8_t *buf,
-         int buf_size)
+         uint8_t *buf,
+         int buf_size)
 {
   struct EXTRACTOR_ExtractContext *ec = opaque;
   void *data;
@@ -160,8 +160,8 @@ read_cb (void *opaque,
  */
 static int64_t
 seek_cb (void *opaque,
-         int64_t offset,
-         int whence)
+         int64_t offset,
+         int whence)
 {
   struct EXTRACTOR_ExtractContext *ec = opaque;
 
@@ -187,12 +187,12 @@ seek_cb (void *opaque,
  */
 static size_t
 create_thumbnail (AVCodecContext *pCodecCtx, int src_width, int src_height,
-                  int src_stride[],
-                  enum AVPixelFormat src_pixfmt,
-                  const uint8_t * const src_data[],
-                  int dst_width, int dst_height,
-                  uint8_t **output_data,
-                  size_t output_max_size)
+                  int src_stride[],
+                  enum AVPixelFormat src_pixfmt,
+                  const uint8_t *const src_data[],
+                  int dst_width, int dst_height,
+                  uint8_t **output_data,
+                  size_t output_max_size)
 {
   AVCodecContext *encoder_codec_ctx;
   AVDictionary *opts;
@@ -205,73 +205,73 @@ create_thumbnail (AVCodecContext *pCodecCtx, int src_width, int src_height,
   int err;
 
   AVPacket pkt;
-  av_init_packet(&pkt);
+  av_init_packet (&pkt);
   pkt.data = NULL;
   pkt.size = 0;
   int gotPacket;
 #if USE_JPEG
-        #if LIBAVCODEC_BUILD >= AV_VERSION_INT(54,25,0)
-        if (NULL == (encoder_codec = avcodec_find_encoder ( AV_CODEC_ID_MJPEG )))
-        #else
-        if (NULL == (encoder_codec = avcodec_find_encoder ( CODEC_ID_MJPEG )))
-        #endif
+  #if LIBAVCODEC_BUILD >= AV_VERSION_INT (54,25,0)
+  if (NULL == (encoder_codec = avcodec_find_encoder (AV_CODEC_ID_MJPEG)))
+  #else
+  if (NULL == (encoder_codec = avcodec_find_encoder (CODEC_ID_MJPEG)))
+  #endif
  #else
- if (NULL == (encoder_codec = avcodec_find_encoder_by_name ("png")))
+  if (NULL == (encoder_codec = avcodec_find_encoder_by_name ("png")))
  #endif
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Couldn't find a encoder\n");
+    fprintf (stderr,
+             "Couldn't find a encoder\n");
 #endif
-      return 0;
-    }
+    return 0;
+  }
 
   /* NOTE: the scaler will be used even if the src and dst image dimensions
    * match, because the scaler will also perform colour space conversion */
   if (NULL ==
       (scaler_ctx =
-       sws_getContext (src_width, src_height, src_pixfmt,
-                       dst_width, dst_height,
-                       PIX_OUTPUT_FORMAT,
-                       SWS_BILINEAR, NULL, NULL, NULL)))
-    {
+         sws_getContext (src_width, src_height, src_pixfmt,
+                         dst_width, dst_height,
+                         PIX_OUTPUT_FORMAT,
+                         SWS_BILINEAR, NULL, NULL, NULL)))
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to get a scaler context\n");
+    fprintf (stderr,
+             "Failed to get a scaler context\n");
 #endif
-      return 0;
-    }
+    return 0;
+  }
 
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
   dst_frame = av_frame_alloc ();
 #else
-  dst_frame = avcodec_alloc_frame();
+  dst_frame = avcodec_alloc_frame ();
 #endif
   if (NULL == dst_frame)
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to allocate the destination image frame\n");
+    fprintf (stderr,
+             "Failed to allocate the destination image frame\n");
 #endif
-      sws_freeContext (scaler_ctx);
-      return 0;
-    }
+    sws_freeContext (scaler_ctx);
+    return 0;
+  }
   if (NULL == (dst_buffer =
-               av_malloc (avpicture_get_size (PIX_OUTPUT_FORMAT,
-                                              dst_width, dst_height))))
-    {
+                 av_malloc (avpicture_get_size (PIX_OUTPUT_FORMAT,
+                                                dst_width, dst_height))))
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to allocate the destination image buffer\n");
+    fprintf (stderr,
+             "Failed to allocate the destination image buffer\n");
 #endif
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
-      av_frame_free (&dst_frame);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
+    av_frame_free (&dst_frame);
 #else
-      avcodec_free_frame (&dst_frame);
+    avcodec_free_frame (&dst_frame);
 #endif
-      sws_freeContext (scaler_ctx);
-      return 0;
-    }
+    sws_freeContext (scaler_ctx);
+    return 0;
+  }
   avpicture_fill ((AVPicture *) dst_frame, dst_buffer,
                   PIX_OUTPUT_FORMAT,
                   dst_width, dst_height);
@@ -284,47 +284,47 @@ create_thumbnail (AVCodecContext *pCodecCtx, int src_width, int src_height,
 
   encoder_output_buffer_size = output_max_size;
   if (NULL == (encoder_output_buffer = av_malloc (encoder_output_buffer_size)))
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to allocate the encoder output buffer\n");
+    fprintf (stderr,
+             "Failed to allocate the encoder output buffer\n");
 #endif
-      av_free (dst_buffer);
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
-      av_frame_free (&dst_frame);
+    av_free (dst_buffer);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
+    av_frame_free (&dst_frame);
 #else
-      avcodec_free_frame (&dst_frame);
+    avcodec_free_frame (&dst_frame);
 #endif
-      sws_freeContext (scaler_ctx);
-      return 0;
-    }
+    sws_freeContext (scaler_ctx);
+    return 0;
+  }
 
   if (NULL == (encoder_codec_ctx = avcodec_alloc_context3 (encoder_codec)))
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to allocate the encoder codec context\n");
+    fprintf (stderr,
+             "Failed to allocate the encoder codec context\n");
 #endif
-      av_free (encoder_output_buffer);
-      av_free (dst_buffer);
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
-      av_frame_free (&dst_frame);
+    av_free (encoder_output_buffer);
+    av_free (dst_buffer);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
+    av_frame_free (&dst_frame);
 #else
-      avcodec_free_frame (&dst_frame);
+    avcodec_free_frame (&dst_frame);
 #endif
-      sws_freeContext (scaler_ctx);
-      return 0;
-    }
+    sws_freeContext (scaler_ctx);
+    return 0;
+  }
   encoder_codec_ctx->width = dst_width;
   encoder_codec_ctx->height = dst_height;
 #if USE_JPEG
   encoder_codec_ctx->bit_rate      = pCodecCtx->bit_rate;
-#if LIBAVCODEC_BUILD >= AV_VERSION_INT(54,25,0)
+#if LIBAVCODEC_BUILD >= AV_VERSION_INT (54,25,0)
   encoder_codec_ctx->codec_id      = AV_CODEC_ID_MJPEG;
 #else
   encoder_codec_ctx->codec_id      = CODEC_ID_MJPEG;
 #endif
-#if LIBAVCODEC_BUILD >= AV_VERSION_INT(53,35,0)
+#if LIBAVCODEC_BUILD >= AV_VERSION_INT (53,35,0)
   encoder_codec_ctx->codec_type    = AVMEDIA_TYPE_VIDEO;
 #else
   encoder_codec_ctx->codec_type    = CODEC_TYPE_VIDEO;
@@ -338,51 +338,52 @@ create_thumbnail (AVCodecContext *pCodecCtx, int src_width, int src_height,
 
   opts = NULL;
   if (avcodec_open2 (encoder_codec_ctx, encoder_codec, &opts) < 0)
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to open the encoder\n");
-#endif
-      avcodec_free_context (&encoder_codec_ctx);
-      av_free (encoder_output_buffer);
-      av_free (dst_buffer);
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
-      av_frame_free (&dst_frame);
+    fprintf (stderr,
+             "Failed to open the encoder\n");
+#endif
+    avcodec_free_context (&encoder_codec_ctx);
+    av_free (encoder_output_buffer);
+    av_free (dst_buffer);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
+    av_frame_free (&dst_frame);
 #else
-      avcodec_free_frame (&dst_frame);
+    avcodec_free_frame (&dst_frame);
 #endif
-      sws_freeContext  (scaler_ctx);
-      return 0;
-    }
-
+    sws_freeContext  (scaler_ctx);
+    return 0;
+  }
 
 
 #ifdef USE_JPEG
 #if FF_API_MPV_OPT
-   encoder_codec_ctx->mb_lmin        = encoder_codec_ctx->lmin = encoder_codec_ctx->qmin * FF_QP2LAMBDA;
-   encoder_codec_ctx->mb_lmax        = encoder_codec_ctx->lmax = encoder_codec_ctx->qmax * FF_QP2LAMBDA;
+  encoder_codec_ctx->mb_lmin        = encoder_codec_ctx->lmin =
+    encoder_codec_ctx->qmin * FF_QP2LAMBDA;
+  encoder_codec_ctx->mb_lmax        = encoder_codec_ctx->lmax =
+    encoder_codec_ctx->qmax * FF_QP2LAMBDA;
 #else
-   encoder_codec_ctx->mb_lmin = encoder_codec_ctx->qmin * FF_QP2LAMBDA;
-   encoder_codec_ctx->mb_lmax = encoder_codec_ctx->qmax * FF_QP2LAMBDA;
+  encoder_codec_ctx->mb_lmin = encoder_codec_ctx->qmin * FF_QP2LAMBDA;
+  encoder_codec_ctx->mb_lmax = encoder_codec_ctx->qmax * FF_QP2LAMBDA;
 #endif
-   encoder_codec_ctx->flags          = AV_CODEC_FLAG_QSCALE;
-   encoder_codec_ctx->global_quality = encoder_codec_ctx->qmin * FF_QP2LAMBDA;
+  encoder_codec_ctx->flags          = AV_CODEC_FLAG_QSCALE;
+  encoder_codec_ctx->global_quality = encoder_codec_ctx->qmin * FF_QP2LAMBDA;
 
-   dst_frame->pts     = 1;
-   dst_frame->quality = encoder_codec_ctx->global_quality;
+  dst_frame->pts     = 1;
+  dst_frame->quality = encoder_codec_ctx->global_quality;
 #endif
 
-#if LIBAVCODEC_BUILD >= AV_VERSION_INT(54,25,0)
+#if LIBAVCODEC_BUILD >= AV_VERSION_INT (54,25,0)
   err = avcodec_encode_video2 (encoder_codec_ctx,
-                              &pkt,
+                               &pkt,
                                dst_frame, &gotPacket);
 
-  if(err < 0)
-        goto cleanup;
+  if (err < 0)
+    goto cleanup;
   err = pkt.size;
-  memcpy(encoder_output_buffer,pkt.data, pkt.size);
+  memcpy (encoder_output_buffer,pkt.data, pkt.size);
 
-  av_free_packet(&pkt);
+  av_free_packet (&pkt);
 
 
 #else
@@ -396,7 +397,7 @@ cleanup:
   avcodec_close (encoder_codec_ctx);
   avcodec_free_context (&encoder_codec_ctx);
   av_free (dst_buffer);
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
   av_frame_free (&dst_frame);
 #else
   avcodec_free_frame (&dst_frame);
@@ -408,7 +409,6 @@ cleanup:
 }
 
 
-
 /**
  * calculate the thumbnail dimensions, taking pixel aspect into account
  *
@@ -421,30 +421,30 @@ cleanup:
   */
 static void
 calculate_thumbnail_dimensions (int src_width,
-                                int src_height,
-                                int src_sar_num,
-                                int src_sar_den,
-                                int *dst_width,
-                                int *dst_height)
+                                int src_height,
+                                int src_sar_num,
+                                int src_sar_den,
+                                int *dst_width,
+                                int *dst_height)
 {
   if ( (src_sar_num <= 0) || (src_sar_den <= 0) )
-    {
-      src_sar_num = 1;
-      src_sar_den = 1;
-    }
+  {
+    src_sar_num = 1;
+    src_sar_den = 1;
+  }
   if ((src_width * src_sar_num) / src_sar_den > src_height)
-    {
-      *dst_width = MAX_THUMB_DIMENSION;
-      *dst_height = (*dst_width * src_height) /
-                     ((src_width * src_sar_num) / src_sar_den);
-    }
+  {
+    *dst_width = MAX_THUMB_DIMENSION;
+    *dst_height = (*dst_width * src_height)
+                  / ((src_width * src_sar_num) / src_sar_den);
+  }
   else
-    {
-      *dst_height = MAX_THUMB_DIMENSION;
-      *dst_width = (*dst_height *
-                    ((src_width * src_sar_num) / src_sar_den)) /
-                    src_height;
-    }
+  {
+    *dst_height = MAX_THUMB_DIMENSION;
+    *dst_width = (*dst_height
+                  * ((src_width * src_sar_num) / src_sar_den))
+                 / src_height;
+  }
   if (*dst_width < 8)
     *dst_width = 8;
   if (*dst_height < 1)
@@ -456,10 +456,11 @@ calculate_thumbnail_dimensions (int src_width,
 #endif
 }
 
-#if LIBAVCODEC_BUILD >= AV_VERSION_INT(54,25,0)
-        #define ENUM_CODEC_ID enum AVCodecID
+
+#if LIBAVCODEC_BUILD >= AV_VERSION_INT (54,25,0)
+  #define ENUM_CODEC_ID enum AVCodecID
 #else
-         #define ENUM_CODEC_ID enum CodecID
+   #define ENUM_CODEC_ID enum CodecID
 #endif
 
 /**
@@ -487,77 +488,77 @@ extract_image (ENUM_CODEC_ID image_codec_id,
   unsigned char padded_data[PADDED_BUFFER_SIZE];
 
   if (NULL == (codec = avcodec_find_decoder (image_codec_id)))
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "No suitable codec found\n");
+    fprintf (stderr,
+             "No suitable codec found\n");
 #endif
-      return;
-    }
+    return;
+  }
   if (NULL == (codec_ctx = avcodec_alloc_context3 (codec)))
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to allocate codec context\n");
+    fprintf (stderr,
+             "Failed to allocate codec context\n");
 #endif
-      return;
-    }
+    return;
+  }
   opts = NULL;
   if (0 != avcodec_open2 (codec_ctx, codec, &opts))
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to open image codec\n");
+    fprintf (stderr,
+             "Failed to open image codec\n");
 #endif
-      avcodec_free_context (&codec_ctx);
-      return;
-    }
+    avcodec_free_context (&codec_ctx);
+    return;
+  }
   av_dict_free (&opts);
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
   frame = av_frame_alloc ();
 #else
-  frame = avcodec_alloc_frame();
+  frame = avcodec_alloc_frame ();
 #endif
   if (NULL == frame)
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to allocate frame\n");
+    fprintf (stderr,
+             "Failed to allocate frame\n");
 #endif
-      avcodec_close (codec_ctx);
-      avcodec_free_context (&codec_ctx);
-      return;
-    }
+    avcodec_close (codec_ctx);
+    avcodec_free_context (&codec_ctx);
+    return;
+  }
 
   frame_finished = 0;
   while (! frame_finished)
-    {
-      if (0 >= (iret = ec->read (ec->cls,
-                                 &data,
-                                 BUFFER_SIZE)))
-        break;
-      memcpy (padded_data, data, iret);
-      memset (&padded_data[iret], 0, PADDED_BUFFER_SIZE - iret);
-      av_init_packet (&avpkt);
-      avpkt.data = padded_data;
-      avpkt.size = iret;
-      avcodec_decode_video2 (codec_ctx, frame, &frame_finished, &avpkt);
-    }
+  {
+    if (0 >= (iret = ec->read (ec->cls,
+                               &data,
+                               BUFFER_SIZE)))
+      break;
+    memcpy (padded_data, data, iret);
+    memset (&padded_data[iret], 0, PADDED_BUFFER_SIZE - iret);
+    av_init_packet (&avpkt);
+    avpkt.data = padded_data;
+    avpkt.size = iret;
+    avcodec_decode_video2 (codec_ctx, frame, &frame_finished, &avpkt);
+  }
   if (! frame_finished)
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to decode a complete frame\n");
+    fprintf (stderr,
+             "Failed to decode a complete frame\n");
 #endif
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
-      av_frame_free (&frame);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
+    av_frame_free (&frame);
 #else
-      avcodec_free_frame (&frame);
+    avcodec_free_frame (&frame);
 #endif
-      avcodec_close (codec_ctx);
-      avcodec_free_context (&codec_ctx);
-      return;
-    }
+    avcodec_close (codec_ctx);
+    avcodec_free_context (&codec_ctx);
+    return;
+  }
   calculate_thumbnail_dimensions (codec_ctx->width, codec_ctx->height,
                                   codec_ctx->sample_aspect_ratio.num,
                                   codec_ctx->sample_aspect_ratio.den,
@@ -565,40 +566,41 @@ extract_image (ENUM_CODEC_ID image_codec_id,
 
   err = create_thumbnail (codec_ctx, codec_ctx->width, codec_ctx->height,
                           frame->linesize, codec_ctx->pix_fmt,
-                          (const uint8_t * const*) frame->data,
+                          (const uint8_t *const*) frame->data,
                           thumb_width, thumb_height,
                           &encoded_thumbnail, MAX_THUMB_BYTES);
   if (err > 0)
+  {
+    ec->proc (ec->cls,
+              "thumbnailffmpeg",
+              EXTRACTOR_METATYPE_THUMBNAIL,
+              EXTRACTOR_METAFORMAT_BINARY,
+              "image/png",
+              (const char*) encoded_thumbnail,
+              err);
+
+    #if OUTPUT_FILE
+    FILE *f;
+      #ifdef USE_JPEG
+    f = fopen ("thumb.jpg", "wb");
+      #else
+    f = fopen ("thumb.png", "wb");
+      #endif
+    if (! f)
     {
-      ec->proc (ec->cls,
-                "thumbnailffmpeg",
-                EXTRACTOR_METATYPE_THUMBNAIL,
-                EXTRACTOR_METAFORMAT_BINARY,
-                "image/png",
-                (const char*) encoded_thumbnail,
-                err);
-
-                #if OUTPUT_FILE
-                FILE *f;
-                        #ifdef USE_JPEG
-                f = fopen("thumb.jpg", "wb");
-                        #else
-                        f = fopen("thumb.png", "wb");
-                        #endif
-            if (!f) {
-                fprintf(stderr, "Could not open %s\n", "file");
-                exit(1);
-            }
-
-                fwrite(encoded_thumbnail, 1, err, f);
-                fclose(f);
+      fprintf (stderr, "Could not open %s\n", "file");
+      exit (1);
+    }
+
+    fwrite (encoded_thumbnail, 1, err, f);
+    fclose (f);
 
         #endif
 
 
-      av_free (encoded_thumbnail);
-    }
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
+    av_free (encoded_thumbnail);
+  }
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
   av_frame_free (&frame);
 #else
   avcodec_free_frame (&frame);
@@ -637,107 +639,107 @@ extract_video (struct EXTRACTOR_ExtractContext *ec)
     return;
   if (NULL == (io_ctx = avio_alloc_context (iob,
                                             16 * 1024,
-                                            0, ec,
-                                            &read_cb,
-                                            NULL /* no writing */,
-                                            &seek_cb)))
-    {
-      av_free (iob);
-      return;
-    }
+                                            0, ec,
+                                            &read_cb,
+                                            NULL /* no writing */,
+                                            &seek_cb)))
+  {
+    av_free (iob);
+    return;
+  }
   if (NULL == (format_ctx = avformat_alloc_context ()))
-    {
-      av_free (io_ctx);
-      return;
-    }
+  {
+    av_free (io_ctx);
+    return;
+  }
   format_ctx->pb = io_ctx;
   options = NULL;
   if (0 != avformat_open_input (&format_ctx, "<no file>", NULL, &options))
-    {
-      av_free (io_ctx);
-      return;
-    }
+  {
+    av_free (io_ctx);
+    return;
+  }
   av_dict_free (&options);
   if (0 > avformat_find_stream_info (format_ctx, NULL))
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to read stream info\n");
+    fprintf (stderr,
+             "Failed to read stream info\n");
 #endif
-      avformat_close_input (&format_ctx);
-      av_free (io_ctx);
-      return;
-    }
+    avformat_close_input (&format_ctx);
+    av_free (io_ctx);
+    return;
+  }
   codec = NULL;
   codec_ctx = NULL;
   video_stream_index = -1;
-  for (i=0; i<format_ctx->nb_streams; i++)
+  for (i = 0; i<format_ctx->nb_streams; i++)
+  {
+    codec_ctx = format_ctx->streams[i]->codec;
+    if (AVMEDIA_TYPE_VIDEO != codec_ctx->codec_type)
+      continue;
+    if (NULL == (codec = avcodec_find_decoder (codec_ctx->codec_id)))
+      continue;
+    options = NULL;
+    if (0 != (err = avcodec_open2 (codec_ctx, codec, &options)))
     {
-      codec_ctx = format_ctx->streams[i]->codec;
-      if (AVMEDIA_TYPE_VIDEO != codec_ctx->codec_type)
-        continue;
-      if (NULL == (codec = avcodec_find_decoder (codec_ctx->codec_id)))
-        continue;
-      options = NULL;
-      if (0 != (err = avcodec_open2 (codec_ctx, codec, &options)))
-        {
-          codec = NULL;
-          continue;
-        }
-      av_dict_free (&options);
-      video_stream_index = i;
-      break;
+      codec = NULL;
+      continue;
     }
+    av_dict_free (&options);
+    video_stream_index = i;
+    break;
+  }
   if ( (-1 == video_stream_index) ||
        (0 == codec_ctx->width) ||
        (0 == codec_ctx->height) )
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "No video streams or no suitable codec found\n");
+    fprintf (stderr,
+             "No video streams or no suitable codec found\n");
 #endif
-      if (NULL != codec)
-        avcodec_close (codec_ctx);
-      avformat_close_input (&format_ctx);
-      av_free (io_ctx);
-      return;
-    }
+    if (NULL != codec)
+      avcodec_close (codec_ctx);
+    avformat_close_input (&format_ctx);
+    av_free (io_ctx);
+    return;
+  }
 
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
   frame = av_frame_alloc ();
 #else
-  frame = avcodec_alloc_frame();
+  frame = avcodec_alloc_frame ();
 #endif
   if (NULL == frame)
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to allocate frame\n");
+    fprintf (stderr,
+             "Failed to allocate frame\n");
 #endif
-      avcodec_close (codec_ctx);
-      avformat_close_input (&format_ctx);
-      av_free (io_ctx);
-      return;
-    }
+    avcodec_close (codec_ctx);
+    avformat_close_input (&format_ctx);
+    av_free (io_ctx);
+    return;
+  }
 
   if (format_ctx->duration == AV_NOPTS_VALUE)
-    {
-      duration = -1;
+  {
+    duration = -1;
 #if DEBUG
-      fprintf (stderr,
-               "Duration unknown\n");
+    fprintf (stderr,
+             "Duration unknown\n");
 #endif
-    }
+  }
   else
-    {
-      duration = format_ctx->duration;
-    }
+  {
+    duration = format_ctx->duration;
+  }
 
   /* if duration is known, seek to first tried,
    * else use 10 sec into stream */
 
-  if(-1 != duration)
-    err = av_seek_frame (format_ctx, -1, (duration/3), 0);
+  if (-1 != duration)
+    err = av_seek_frame (format_ctx, -1, (duration / 3), 0);
   else
     err = av_seek_frame (format_ctx, -1, 10 * AV_TIME_BASE, 0);
 
@@ -746,41 +748,41 @@ extract_video (struct EXTRACTOR_ExtractContext *ec)
   frame_finished = 0;
 
   while (1)
+  {
+    err = av_read_frame (format_ctx, &packet);
+    if (err < 0)
+      break;
+    if (packet.stream_index == video_stream_index)
     {
-      err = av_read_frame (format_ctx, &packet);
-      if (err < 0)
+      avcodec_decode_video2 (codec_ctx,
+                             frame,
+                             &frame_finished,
+                             &packet);
+      if (frame_finished && frame->key_frame)
+      {
+        av_free_packet (&packet);
         break;
-      if (packet.stream_index == video_stream_index)
-        {
-          avcodec_decode_video2 (codec_ctx,
-                                 frame,
-                                 &frame_finished,
-                                 &packet);
-          if (frame_finished && frame->key_frame)
-            {
-              av_free_packet (&packet);
-              break;
-            }
-        }
-      av_free_packet (&packet);
+      }
     }
+    av_free_packet (&packet);
+  }
 
   if (! frame_finished)
-    {
+  {
 #if DEBUG
-      fprintf (stderr,
-               "Failed to decode a complete frame\n");
+    fprintf (stderr,
+             "Failed to decode a complete frame\n");
 #endif
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
-      av_frame_free (&frame);
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
+    av_frame_free (&frame);
 #else
-      avcodec_free_frame (&frame);
+    avcodec_free_frame (&frame);
 #endif
-      avcodec_close (codec_ctx);
-      avformat_close_input (&format_ctx);
-      av_free (io_ctx);
-      return;
-    }
+    avcodec_close (codec_ctx);
+    avformat_close_input (&format_ctx);
+    av_free (io_ctx);
+    return;
+  }
   calculate_thumbnail_dimensions (codec_ctx->width, codec_ctx->height,
                                   codec_ctx->sample_aspect_ratio.num,
                                   codec_ctx->sample_aspect_ratio.den,
@@ -788,37 +790,37 @@ extract_video (struct EXTRACTOR_ExtractContext *ec)
 
   err = create_thumbnail (codec_ctx, codec_ctx->width, codec_ctx->height,
                           frame->linesize, codec_ctx->pix_fmt,
-                          (const uint8_t* const *) frame->data,
+                          (const uint8_t*const *) frame->data,
                           thumb_width, thumb_height,
                           &encoded_thumbnail, MAX_THUMB_BYTES);
   if (err > 0)
-    {
-      ec->proc (ec->cls,
-                "thumbnailffmpeg",
-                EXTRACTOR_METATYPE_THUMBNAIL,
-                EXTRACTOR_METAFORMAT_BINARY,
-                "image/png",
-                (const char*) encoded_thumbnail,
-                err);
+  {
+    ec->proc (ec->cls,
+              "thumbnailffmpeg",
+              EXTRACTOR_METATYPE_THUMBNAIL,
+              EXTRACTOR_METAFORMAT_BINARY,
+              "image/png",
+              (const char*) encoded_thumbnail,
+              err);
 #if OUTPUT_FILE
-      FILE *f;
+    FILE *f;
 #ifdef USE_JPEG
-      f = fopen("thumb.jpg", "wb");
+    f = fopen ("thumb.jpg", "wb");
 #else
-      f = fopen("thumb.png", "wb");
+    f = fopen ("thumb.png", "wb");
 #endif
-      if (!f)
-        {
-          fprintf(stderr, "Could not open %s\n", "file");
-          exit(1);
-        }
+    if (! f)
+    {
+      fprintf (stderr, "Could not open %s\n", "file");
+      exit (1);
+    }
 
-      fwrite(encoded_thumbnail, 1, err, f);
-      fclose(f);
+    fwrite (encoded_thumbnail, 1, err, f);
+    fclose (f);
 #endif
-      av_free (encoded_thumbnail);
-    }
-#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55,28,1)
+    av_free (encoded_thumbnail);
+  }
+#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT (55,28,1)
   av_frame_free (&frame);
 #else
   avcodec_free_frame (&frame);
@@ -849,28 +851,27 @@ struct MIMEToDecoderMapping
 /**
  * map MIME image types to an ffmpeg decoder
  */
-static const struct MIMEToDecoderMapping m2d_map[] =
-  {
-
-#if LIBAVCODEC_BUILD >= AV_VERSION_INT(54,25,0)
-        { "image/x-bmp", AV_CODEC_ID_BMP },
-    { "image/gif", AV_CODEC_ID_GIF },
-    { "image/jpeg", AV_CODEC_ID_MJPEG },
-    { "image/png", AV_CODEC_ID_PNG },
-    { "image/x-png", AV_CODEC_ID_PNG },
-    { "image/x-portable-pixmap", AV_CODEC_ID_PPM },
-    { NULL, AV_CODEC_ID_NONE }
+static const struct MIMEToDecoderMapping m2d_map[] = {
+
+#if LIBAVCODEC_BUILD >= AV_VERSION_INT (54,25,0)
+  { "image/x-bmp", AV_CODEC_ID_BMP },
+  { "image/gif", AV_CODEC_ID_GIF },
+  { "image/jpeg", AV_CODEC_ID_MJPEG },
+  { "image/png", AV_CODEC_ID_PNG },
+  { "image/x-png", AV_CODEC_ID_PNG },
+  { "image/x-portable-pixmap", AV_CODEC_ID_PPM },
+  { NULL, AV_CODEC_ID_NONE }
 #else
-        { "image/x-bmp", CODEC_ID_BMP },
-    { "image/gif", CODEC_ID_GIF },
-    { "image/jpeg", CODEC_ID_MJPEG },
-    { "image/png", CODEC_ID_PNG },
-    { "image/x-png", CODEC_ID_PNG },
-    { "image/x-portable-pixmap", CODEC_ID_PPM },
-    { NULL, CODEC_ID_NONE }
+  { "image/x-bmp", CODEC_ID_BMP },
+  { "image/gif", CODEC_ID_GIF },
+  { "image/jpeg", CODEC_ID_MJPEG },
+  { "image/png", CODEC_ID_PNG },
+  { "image/x-png", CODEC_ID_PNG },
+  { "image/x-portable-pixmap", CODEC_ID_PPM },
+  { NULL, CODEC_ID_NONE }
 #endif
 
-  };
+};
 
 
 /**
@@ -887,8 +888,8 @@ EXTRACTOR_thumbnailffmpeg_extract_method (struct EXTRACTOR_ExtractContext *ec)
   const char *mime;
 
   if (-1 == (iret = ec->read (ec->cls,
-                              &data,
-                              16 * 1024)))
+                              &data,
+                              16 * 1024)))
     return;
   if (NULL == (mime = magic_buffer (magic, data, iret)))
     return;
@@ -896,10 +897,10 @@ EXTRACTOR_thumbnailffmpeg_extract_method (struct EXTRACTOR_ExtractContext *ec)
     return;
   for (i = 0; NULL != m2d_map[i].mime_type; i++)
     if (0 == strcmp (m2d_map[i].mime_type, mime))
-      {
-        extract_image (m2d_map[i].codec_id, ec);
-        return;
-      }
+    {
+      extract_image (m2d_map[i].codec_id, ec);
+      return;
+    }
   extract_video (ec);
 }
 
@@ -926,13 +927,13 @@ EXTRACTOR_thumbnail_extract_method (struct EXTRACTOR_ExtractContext *ec)
  * @param ap arguments for format
  */
 static void
-thumbnailffmpeg_av_log_callback (void* ptr,
-                                 int level,
-                                 const char *format,
-                                 va_list ap)
+thumbnailffmpeg_av_log_callback (void*ptr,
+                                 int level,
+                                 const char *format,
+                                 va_list ap)
 {
 #if DEBUG
-  vfprintf(stderr, format, ap);
+  vfprintf (stderr, format, ap);
 #endif
 }
 
@@ -947,9 +948,9 @@ thumbnailffmpeg_lib_init (void)
   av_register_all ();
   magic = magic_open (MAGIC_MIME_TYPE);
   if (0 != magic_load (magic, NULL))
-    {
-      /* FIXME: how to deal with errors? */
-    }
+  {
+    /* FIXME: how to deal with errors? */
+  }
 }
 
 
@@ -960,10 +961,10 @@ void __attribute__ ((destructor))
 thumbnailffmpeg_ltdl_fini ()
 {
   if (NULL != magic)
-    {
-      magic_close (magic);
-      magic = NULL;
-    }
+  {
+    magic_close (magic);
+    magic = NULL;
+  }
 }