libextractor

mediautil.c (7219B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2026 Vidyut Samanta and Christian Grothoff
 
      libextractor is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
      by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      libextractor is distributed in the hope that it will be useful, but
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      General Public License for more details.
 
      You should have received a copy of the GNU General Public License
      along with libextractor; see the file COPYING.  If not, write to the
      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
      Boston, MA 02110-1301, USA.
  */
 /**
  * @file plugins/mediautil.c
  * @brief helpers shared by the video thumbnail and audio preview plugins
  * @author Christian Grothoff
  */
 #include "platform.h"
 #include "mediautil.h"
 #include <magic.h>
 
 /**
  * How many bytes we give libmagic to make up its mind.
  */
 #define SNIFF_SIZE (16 * 1024)
 
 
 void
 EXTRACTOR_media_options_parse_ (const char *config,
                                 struct EXTRACTOR_MediaOptions *opt)
 {
   const char *pos;
 
   opt->size = 128;
   opt->png = 0;
   opt->offset = 30;
   opt->length = 15;
   opt->bitrate = 24000;
   opt->deadline = 10000;
   if (NULL == config)
     return;
   pos = config;
   while ('\0' != *pos)
   {
     unsigned long long v;
     char *endp;
 
     if (0 == strncmp (pos,
                       "format=",
                       strlen ("format=")))
     {
       pos += strlen ("format=");
       opt->png = (0 == strncmp (pos,
                                 "png",
                                 strlen ("png")));
     }
     else if (0 == strncmp (pos,
                            "size=",
                            strlen ("size=")))
     {
       pos += strlen ("size=");
       v = strtoull (pos, &endp, 10);
       if ( (endp != pos) &&
            (v >= 8) &&
            (v <= 1024) )
         opt->size = (unsigned int) v;
     }
     else if (0 == strncmp (pos,
                            "offset=",
                            strlen ("offset=")))
     {
       pos += strlen ("offset=");
       v = strtoull (pos, &endp, 10);
       if ( (endp != pos) &&
            (v <= 24 * 60 * 60) )
         opt->offset = (unsigned int) v;
     }
     else if (0 == strncmp (pos,
                            "length=",
                            strlen ("length=")))
     {
       pos += strlen ("length=");
       v = strtoull (pos, &endp, 10);
       if ( (endp != pos) &&
            (v >= 1) &&
            (v <= 60) )
         opt->length = (unsigned int) v;
     }
     else if (0 == strncmp (pos,
                            "bitrate=",
                            strlen ("bitrate=")))
     {
       pos += strlen ("bitrate=");
       v = strtoull (pos, &endp, 10);
       if ( (endp != pos) &&
            (v >= 6000) &&
            (v <= 128000) )
         opt->bitrate = (unsigned int) v;
     }
     else if (0 == strncmp (pos,
                            "deadline=",
                            strlen ("deadline=")))
     {
       pos += strlen ("deadline=");
       v = strtoull (pos, &endp, 10);
       if ( (endp != pos) &&
            (v >= 100) &&
            (v <= 120000) )
         opt->deadline = (unsigned int) v;
     }
     /* advance to the next assignment */
     pos = strchr (pos, ',');
     if (NULL == pos)
       break;
     pos++;
   }
 }
 
 
 int
 EXTRACTOR_media_is_media_ (struct EXTRACTOR_ExtractContext *ec,
                            int want_audio)
 {
   magic_t magic;
   void *data;
   ssize_t iret;
   const char *mime;
   int ret;
 
   if (-1 == (iret = ec->read (ec->cls,
                               &data,
                               SNIFF_SIZE)))
     return 0;
   ret = 0;
   if (NULL == (magic = magic_open (MAGIC_MIME_TYPE)))
     return 0;
   if (0 == magic_load (magic, NULL))
   {
     mime = magic_buffer (magic,
                          data,
                          iret);
     if (NULL != mime)
     {
       if (0 == strncmp (mime,
                         "video/",
                         strlen ("video/")))
         ret = 1;
       if ( (0 != want_audio) &&
            (0 == strncmp (mime,
                           "audio/",
                           strlen ("audio/"))) )
         ret = 1;
       /* Ogg and Matroska files carrying video are frequently reported as
          "application/ogg" or "video/x-matroska"; the former would be lost
          here, so let it through and let the demuxer decide. */
       if (0 == strcmp (mime,
                        "application/ogg"))
         ret = 1;
     }
   }
   magic_close (magic);
   if (0 != ec->seek (ec->cls,
                      0,
                      SEEK_SET))
     return 0;
   return ret;
 }
 
 
 /**
  * Current time in milliseconds since an arbitrary epoch.
  *
  * @return the time
  */
 static uint64_t
 now_ms (void)
 {
   struct timespec ts;
 
   if (0 != clock_gettime (CLOCK_MONOTONIC,
                           &ts))
     return 0;
   return ((uint64_t) ts.tv_sec) * 1000ULL
          + ((uint64_t) ts.tv_nsec) / 1000000ULL;
 }
 
 
 void
 EXTRACTOR_media_deadline_start_ (struct EXTRACTOR_MediaDeadline *dl,
                                  unsigned int ms)
 {
   dl->expiration = now_ms () + ms;
 }
 
 
 int
 EXTRACTOR_media_deadline_expired_ (const struct EXTRACTOR_MediaDeadline *dl)
 {
   return now_ms () >= dl->expiration;
 }
 
 
 uint64_t
 EXTRACTOR_media_deadline_remaining_ (const struct EXTRACTOR_MediaDeadline *dl)
 {
   uint64_t now = now_ms ();
 
   if (now >= dl->expiration)
     return 0;
   return dl->expiration - now;
 }
 
 
 int
 EXTRACTOR_media_thumbnail_size_ (unsigned int width,
                                  unsigned int height,
                                  unsigned int box,
                                  unsigned int *rwidth,
                                  unsigned int *rheight)
 {
   uint64_t w = width;
   uint64_t h = height;
 
   if ( (0 == width) ||
        (0 == height) ||
        (width > EXTRACTOR_MEDIA_MAX_DIMENSION) ||
        (height > EXTRACTOR_MEDIA_MAX_DIMENSION) ||
        (((uint64_t) width) * height > EXTRACTOR_MEDIA_MAX_PIXELS) )
     return 0;
   if (h > box)
   {
     w = w * box / h;
     h = box;
   }
   if (w > box)
   {
     h = h * box / w;
     w = box;
   }
   if ( (0 == w) ||
        (0 == h) )
     return 0;
   /* many encoders dislike odd dimensions, and we lose nothing by rounding */
   w &= ~1ULL;
   h &= ~1ULL;
   if ( (0 == w) ||
        (0 == h) )
     return 0;
   *rwidth = (unsigned int) w;
   *rheight = (unsigned int) h;
   return 1;
 }
 
 
 void
 EXTRACTOR_media_fade_s16_ (int16_t *samples,
                            size_t num_samples,
                            size_t fade_samples)
 {
   size_t i;
 
   if (0 == fade_samples)
     return;
   if (fade_samples * 2 > num_samples)
     fade_samples = num_samples / 2;
   for (i = 0; i < fade_samples; i++)
   {
     samples[i] = (int16_t) (((int32_t) samples[i]) * (int32_t) i
                             / (int32_t) fade_samples);
     samples[num_samples - 1 - i] =
       (int16_t) (((int32_t) samples[num_samples - 1 - i]) * (int32_t) i
                  / (int32_t) fade_samples);
   }
 }
 
 
 /* end of mediautil.c */