libextractor

test_thumbnailffmpeg.c (21468B)

---

 /*
      This file is part of libextractor.
      Copyright (C) 2013, 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/test_thumbnailffmpeg.c
  * @brief testcase for the thumbnailffmpeg plugin
  * @author Christian Grothoff
  *
  * The encoder's output depends on the FFmpeg version, so the JPEG can
  * only be checked for its magic number.  The PNG round, on the other
  * hand, is decoded: testdata/thumbnail_pattern.ogv is black for the
  * first 20 seconds and red afterwards, so the colour of the thumbnail
  * says whether the plugin really sampled where it claims to.
  *
  * testdata/subtitles.mkv (see contrib/gen_testmedia.sh) exercises the
  * subtitle languages, the "srt:LANG" dump and the "gallery:N" contact
  * sheet.  For those, every item the plugin emits is collected, so that
  * the tests can also check what must NOT be there.
  */
 #include "platform.h"
 #include "test_lib.h"
 #include "test_media_lib.h"
 
 
 /**
  * Check that the thumbnail was taken from the red part of the video.
  *
  * @param data the PNG the plugin produced
  * @param data_len number of bytes in @a data
  * @return non-zero if the thumbnail looks right
  */
 static int
 validate_red (const void *data,
               size_t data_len)
 {
   return TEST_media_png_center_is (data,
                                    data_len,
                                    0xFE,
                                    0x00,
                                    0x00);
 }
 
 
 /**
  * The subtitled test video.
  */
 #define SUBTITLES_MKV "testdata/subtitles.mkv"
 
 /**
  * Upper bound for a gallery, see EXTRACTOR_MEDIA_MAX_GALLERY_BYTES.
  */
 #define MAX_GALLERY_BYTES (4 * 1024 * 1024)
 
 /**
  * Upper bound for the pixels of a gallery sheet (the plugin's
  * GALLERY_MAX_SHEET_PIXELS).
  */
 #define MAX_GALLERY_PIXELS (4 * 1024 * 1024)
 
 /**
  * Most items we collect from one run.
  */
 #define MAX_ITEMS 32
 
 /**
  * Expected SRT dump of the English track.
  */
 static const char srt_en[] =
   "1\n"
   "00:00:01,000 --> 00:00:04,000\n"
   "Hello, world!\n"
   "\n"
   "2\n"
   "00:00:12,500 --> 00:00:15,250\n"
   "This is the second line\n"
   "spanning two rows.\n"
   "\n"
   "3\n"
   "00:00:33,000 --> 00:00:38,000\n"
   "Goodbye.\n"
   "\n";
 
 /**
  * Expected SRT dump of the German track.
  */
 static const char srt_de[] =
   "1\n"
   "00:00:01,000 --> 00:00:04,000\n"
   "Gr\xc3\xbc\xc3\x9f Gott, Welt!\n"
   "\n"
   "2\n"
   "00:00:12,500 --> 00:00:15,250\n"
   "Das ist die zweite Zeile\n"
   "\xc3\xbc" "ber zwei Reihen.\n"
   "\n"
   "3\n"
   "00:00:33,000 --> 00:00:38,000\n"
   "Auf Wiedersehen.\n"
   "\n";
 
 /**
  * Expected SRT dump of the French (ASS) track: override tags and the
  * ASS fields are gone, "\N" became a line break.
  */
 static const char srt_fr[] =
   "1\n"
   "00:00:01,000 --> 00:00:04,000\n"
   "Bonjour, le monde !\n"
   "\n"
   "2\n"
   "00:00:12,500 --> 00:00:15,250\n"
   "Deuxi\xc3\xa8me ligne\n"
   "sur deux rangs.\n"
   "\n";
 
 
 /**
  * One item the plugin emitted.
  */
 struct Item
 {
   /**
    * Type of the item.
    */
   enum EXTRACTOR_MetaType type;
 
   /**
    * Format of the item.
    */
   enum EXTRACTOR_MetaFormat format;
 
   /**
    * Mime type, "" if none.
    */
   char mime[64];
 
   /**
    * Copy of the data.
    */
   char *data;
 
   /**
    * Number of bytes in @e data.
    */
   size_t data_len;
 };
 
 
 /**
  * Everything the plugin emitted for one file.
  */
 struct Items
 {
   /**
    * The items, in the order they were emitted.
    */
   struct Item item[MAX_ITEMS];
 
   /**
    * Number of valid entries in @e item.
    */
   unsigned int count;
 
   /**
    * Set if there were more than #MAX_ITEMS.
    */
   int overflow;
 };
 
 
 /**
  * Collect an item.  Signature of #EXTRACTOR_MetaDataProcessor.
  *
  * @param cls our `struct Items`
  * @param plugin_name name of the plugin
  * @param type type of the item
  * @param format format of the item
  * @param data_mime_type mime type of the item
  * @param data the item
  * @param data_len number of bytes in @a data
  * @return 0 (always continue)
  */
 static int
 collect (void *cls,
          const char *plugin_name,
          enum EXTRACTOR_MetaType type,
          enum EXTRACTOR_MetaFormat format,
          const char *data_mime_type,
          const char *data,
          size_t data_len)
 {
   struct Items *items = cls;
   struct Item *it;
 
   (void) plugin_name;
   if (items->count == MAX_ITEMS)
   {
     items->overflow = 1;
     return 0;
   }
   it = &items->item[items->count];
   it->type = type;
   it->format = format;
   snprintf (it->mime,
             sizeof (it->mime),
             "%s",
             (NULL == data_mime_type) ? "" : data_mime_type);
   if (NULL == (it->data = malloc (data_len + 1)))
     abort ();
   memcpy (it->data,
           data,
           data_len);
   it->data[data_len] = '\0';
   it->data_len = data_len;
   items->count++;
   return 0;
 }
 
 
 /**
  * Release what collect() allocated.
  *
  * @param[in,out] items items to release
  */
 static void
 items_clear (struct Items *items)
 {
   unsigned int i;
 
   for (i = 0; i < items->count; i++)
     free (items->item[i].data);
   memset (items, 0, sizeof (*items));
 }
 
 
 /**
  * Run the plugin with configuration @a config on @a filename and
  * collect everything it emits.
  *
  * @param config the plugin with its options, e.g. "thumbnailffmpeg(srt:de)"
  * @param in_process 1 to run the plugin in-process
  * @param filename file to extract from
  * @param[out] items set to what the plugin emitted
  */
 static void
 run_collect (const char *config,
              int in_process,
              const char *filename,
              struct Items *items)
 {
   struct EXTRACTOR_PluginList *pl;
 
   memset (items, 0, sizeof (*items));
   pl = EXTRACTOR_plugin_add_config (NULL,
                                     config,
                                     in_process
                                     ? EXTRACTOR_OPTION_IN_PROCESS
                                     : EXTRACTOR_OPTION_DEFAULT_POLICY);
   if (NULL == pl)
   {
     fprintf (stderr,
              "Failed to load %s\n",
              config);
     abort ();
   }
   EXTRACTOR_extract (pl,
                      filename,
                      NULL,
                      0,
                      &collect,
                      items);
   EXTRACTOR_plugin_remove_all (pl);
 }
 
 
 /**
  * Count the items of type @a type.
  *
  * @param items items to search
  * @param type type to look for
  * @param[out] last set to the last item of that type, may be NULL
  * @return number of items of type @a type
  */
 static unsigned int
 count_type (const struct Items *items,
             enum EXTRACTOR_MetaType type,
             const struct Item **last)
 {
   unsigned int n = 0;
   unsigned int i;
 
   for (i = 0; i < items->count; i++)
     if (items->item[i].type == type)
     {
       n++;
       if (NULL != last)
         *last = &items->item[i];
     }
   return n;
 }
 
 
 /**
  * Check that the subtitle languages were reported exactly once each,
  * in stream order, and that there is exactly one thumbnail.
  *
  * @param items what the plugin emitted
  * @param what name of the run, for diagnostics
  * @return 0 if everything is as expected
  */
 static int
 check_languages (const struct Items *items,
                  const char *what)
 {
   static const char *const expected[] = { "eng", "ger", "fre" };
   unsigned int n = 0;
   unsigned int i;
 
   for (i = 0; i < items->count; i++)
   {
     const struct Item *it = &items->item[i];
 
     if (EXTRACTOR_METATYPE_SUBTITLE_LANGUAGE != it->type)
       continue;
     if ( (n >= 3) ||
          (EXTRACTOR_METAFORMAT_UTF8 != it->format) ||
          (it->data_len != strlen (expected[n]) + 1) ||
          (0 != strcmp (it->data,
                        expected[n])) )
     {
       fprintf (stderr,
                "%s: unexpected subtitle language #%u `%s'\n",
                what,
                n,
                it->data);
       return 1;
     }
     n++;
   }
   if (3 != n)
   {
     fprintf (stderr,
              "%s: got %u subtitle languages, expected 3\n",
              what,
              n);
     return 1;
   }
   if (1 != count_type (items,
                        EXTRACTOR_METATYPE_THUMBNAIL,
                        NULL))
   {
     fprintf (stderr,
              "%s: expected exactly one thumbnail\n",
              what);
     return 1;
   }
   return 0;
 }
 
 
 /**
  * Check a run with "srt:LANG".
  *
  * @param lang language to request
  * @param in_process 1 to run the plugin in-process
  * @param expected expected SRT file, NULL if none must be emitted
  * @return 0 on success
  */
 static int
 test_srt (const char *lang,
           int in_process,
           const char *expected)
 {
   struct Items items;
   const struct Item *it = NULL;
   char config[64];
   unsigned int n;
   int ret = 0;
 
   snprintf (config,
             sizeof (config),
             "thumbnailffmpeg(srt:%s)",
             lang);
   run_collect (config,
                in_process,
                SUBTITLES_MKV,
                &items);
   ret |= check_languages (&items,
                           config);
   n = count_type (&items,
                   EXTRACTOR_METATYPE_SUBTITLE_TEXT,
                   &it);
   if (NULL == expected)
   {
     if (0 != n)
     {
       fprintf (stderr,
                "%s: got subtitles for a language that is not there\n",
                config);
       ret = 1;
     }
   }
   else if (1 != n)
   {
     fprintf (stderr,
              "%s: got %u subtitle dumps, expected 1\n",
              config,
              n);
     ret = 1;
   }
   else if ( (EXTRACTOR_METAFORMAT_UTF8 != it->format) ||
             (0 != strcmp (it->mime,
                           "application/x-subrip")) ||
             (it->data_len != strlen (expected) + 1) ||
             (0 != memcmp (it->data,
                           expected,
                           it->data_len)) )
   {
     fprintf (stderr,
              "%s: got\n%s\nexpected\n%s\n",
              config,
              it->data,
              expected);
     ret = 1;
   }
   items_clear (&items);
   return ret;
 }
 
 
 /**
  * Read a big endian 32 bit number.
  *
  * @param p bytes to read
  * @return the number
  */
 static uint32_t
 be32 (const uint8_t *p)
 {
   return (((uint32_t) p[0]) << 24)
          | (((uint32_t) p[1]) << 16)
          | (((uint32_t) p[2]) << 8)
          | ((uint32_t) p[3]);
 }
 
 
 /**
  * Get the dimensions of a PNG from its IHDR chunk.
  *
  * @param it the item holding the PNG
  * @param[out] width set to the width
  * @param[out] height set to the height
  * @return 1 if @a it is a PNG
  */
 static int
 png_size (const struct Item *it,
           uint32_t *width,
           uint32_t *height)
 {
   static const uint8_t magic[] = { 137, 'P', 'N', 'G', '\r', '\n', 26, '\n' };
   const uint8_t *d = (const uint8_t *) it->data;
 
   if ( (it->data_len < 8 + 8 + 13) ||
        (0 != memcmp (d, magic, sizeof (magic))) ||
        (0 != memcmp (&d[12], "IHDR", 4)) )
     return 0;
   *width = be32 (&d[16]);
   *height = be32 (&d[20]);
   return 1;
 }
 
 
 /**
  * Rough colour of a tile.
  */
 enum TileColor
 {
   /**
    * Anything goes, as long as the tile is not basically black or white.
    */
   TC_ANY,
 
   /**
    * Mostly red.
    */
   TC_RED,
 
   /**
    * Mostly blue.
    */
   TC_BLUE
 };
 
 
 /**
  * Check one tile of a decoded gallery.
  *
  * @param rgb the decoded sheet
  * @param width width of the sheet
  * @param x0 left edge of the tile
  * @param y0 top edge of the tile
  * @param tw width of the tile
  * @param th height of the tile
  * @param color colour the tile should have
  * @param what name of the run, for diagnostics
  * @param idx index of the tile, for diagnostics
  * @return 0 if the tile looks right
  */
 static int
 check_tile (const uint8_t *rgb,
             uint32_t width,
             uint32_t x0,
             uint32_t y0,
             uint32_t tw,
             uint32_t th,
             enum TileColor color,
             const char *what,
             unsigned int idx)
 {
   uint64_t sum[3] = { 0, 0, 0 };
   uint64_t dark = 0;
   uint64_t light = 0;
   uint64_t n = (uint64_t) tw * th;
   uint32_t x;
   uint32_t y;
   unsigned int c;
 
   for (y = y0; y < y0 + th; y++)
     for (x = x0; x < x0 + tw; x++)
     {
       const uint8_t *p = &rgb[((size_t) y * width + x) * 3];
 
       for (c = 0; c < 3; c++)
         sum[c] += p[c];
       if ( (p[0] < 48) && (p[1] < 48) && (p[2] < 48) )
         dark++;
       if ( (p[0] > 208) && (p[1] > 208) && (p[2] > 208) )
         light++;
     }
   for (c = 0; c < 3; c++)
     sum[c] /= n;
   if ( (dark * 2 > n) ||
        (light * 2 > n) )
   {
     fprintf (stderr,
              "%s: tile %u is mostly %s, the flat frame was not replaced\n",
              what,
              idx,
              (dark * 2 > n) ? "black" : "white");
     return 1;
   }
   if ( ( (TC_RED == color) &&
          ( (sum[0] < sum[1] + 96) || (sum[0] < sum[2] + 96) ) ) ||
        ( (TC_BLUE == color) &&
          ( (sum[2] < sum[0] + 96) || (sum[2] < sum[1] + 96) ) ) )
   {
     fprintf (stderr,
              "%s: tile %u has average rgb(%u,%u,%u), expected %s\n",
              what,
              idx,
              (unsigned int) sum[0],
              (unsigned int) sum[1],
              (unsigned int) sum[2],
              (TC_RED == color) ? "red" : "blue");
     return 1;
   }
   return 0;
 }
 
 
 /**
  * Run the plugin with a gallery configuration and check that it emits
  * exactly one image of an acceptable size and no other thumbnail.
  *
  * @param config the plugin with its options
  * @param png 1 if we asked for a PNG
  * @param[out] items set to what the plugin emitted
  * @param[out] gallery set to the gallery item
  * @return 0 on success
  */
 static int
 run_gallery (const char *config,
              int png,
              struct Items *items,
              const struct Item **gallery)
 {
   static const uint8_t jpeg_magic[] = { 0xFF, 0xD8, 0xFF };
   uint32_t w;
   uint32_t h;
 
   run_collect (config,
                0,
                SUBTITLES_MKV,
                items);
   if (0 != check_languages (items,
                             config))
     return 1;
   if (0 != count_type (items,
                        EXTRACTOR_METATYPE_SUBTITLE_TEXT,
                        NULL))
   {
     fprintf (stderr,
              "%s: got subtitles without asking for them\n",
              config);
     return 1;
   }
   count_type (items,
               EXTRACTOR_METATYPE_THUMBNAIL,
               gallery);
   if ( (EXTRACTOR_METAFORMAT_BINARY != (*gallery)->format) ||
        (0 != strcmp ((*gallery)->mime,
                      png ? "image/png" : "image/jpeg")) ||
        ((*gallery)->data_len > MAX_GALLERY_BYTES) )
   {
     fprintf (stderr,
              "%s: gallery has the wrong type or size (%s, %u bytes)\n",
              config,
              (*gallery)->mime,
              (unsigned int) (*gallery)->data_len);
     return 1;
   }
   if (! png)
   {
     if ( ((*gallery)->data_len < sizeof (jpeg_magic)) ||
          (0 != memcmp ((*gallery)->data,
                        jpeg_magic,
                        sizeof (jpeg_magic))) )
     {
       fprintf (stderr,
                "%s: gallery is not a JPEG\n",
                config);
       return 1;
     }
     return 0;
   }
   if ( (! png_size (*gallery, &w, &h)) ||
        (0 == w) ||
        (0 == h) ||
        ((uint64_t) w * h > MAX_GALLERY_PIXELS) )
   {
     fprintf (stderr,
              "%s: gallery is not a PNG of acceptable size\n",
              config);
     return 1;
   }
   return 0;
 }
 
 
 /**
  * Check "gallery:N" on the subtitled video.
  *
  * @return 0 on success
  */
 static int
 test_gallery (void)
 {
   /* with gallery:4 the tiles are sampled at 5s (black, must be shifted
      into the red part), 15s (red), 25s (white, must be shifted into the
      blue part) and 35s (blue) */
   static const enum TileColor colors4[] = {
     TC_RED, TC_RED, TC_BLUE, TC_BLUE
   };
   struct Items items;
   const struct Item *g = NULL;
   const char *config;
   uint8_t *rgb;
   uint32_t w;
   uint32_t h;
   unsigned int i;
   int ret = 0;
 
   /* 160x90 tiles; the sheet closest to 16:9 for four of them is 2x2 */
   config = "thumbnailffmpeg(gallery:4,format=png,size=160)";
   if (0 != run_gallery (config, 1, &items, &g))
     ret = 1;
   else if ( (! png_size (g, &w, &h)) ||
             (320 != w) ||
             (180 != h) )
   {
     fprintf (stderr,
              "%s: gallery is %ux%u, expected 320x180\n",
              config,
              (unsigned int) w,
              (unsigned int) h);
     ret = 1;
   }
   else if (NULL != (rgb = TEST_media_png_decode (g->data,
                                                  g->data_len,
                                                  &w,
                                                  &h)))
   {
     for (i = 0; i < 4; i++)
       ret |= check_tile (rgb,
                          w,
                          (i % 2) * 160,
                          (i / 2) * 90,
                          160,
                          90,
                          colors4[i],
                          config,
                          i);
     free (rgb);
   }
 #if TEST_MEDIA_HAVE_PNG
   else
   {
     fprintf (stderr,
              "%s: failed to decode the gallery\n",
              config);
     ret = 1;
   }
 #endif
   items_clear (&items);
 
   /* a single tile, sampled at 20s: white, so it must be shifted */
   config = "thumbnailffmpeg(gallery:1,format=png,size=160)";
   if (0 != run_gallery (config, 1, &items, &g))
     ret = 1;
   else if ( (! png_size (g, &w, &h)) ||
             (160 != w) ||
             (90 != h) )
   {
     fprintf (stderr,
              "%s: gallery is %ux%u, expected 160x90\n",
              config,
              (unsigned int) w,
              (unsigned int) h);
     ret = 1;
   }
   else if (NULL != (rgb = TEST_media_png_decode (g->data,
                                                  g->data_len,
                                                  &w,
                                                  &h)))
   {
     ret |= check_tile (rgb, w, 0, 0, 160, 90, TC_ANY, config, 0);
     free (rgb);
   }
   items_clear (&items);
 
   config = "thumbnailffmpeg(gallery:1)";
   ret |= run_gallery (config, 0, &items, &g);
   items_clear (&items);
   config = "thumbnailffmpeg(gallery:100)";
   ret |= run_gallery (config, 0, &items, &g);
   items_clear (&items);
   config = "thumbnailffmpeg(gallery:100,format=png,size=1024)";
   ret |= run_gallery (config, 1, &items, &g);
   items_clear (&items);
   return ret;
 }
 
 
 /**
  * Check the subtitle languages and the absence of optional output in
  * a run without options.
  *
  * @return 0 on success
  */
 static int
 test_default (void)
 {
   struct Items items;
   int ret = 0;
 
   run_collect ("thumbnailffmpeg",
                0,
                SUBTITLES_MKV,
                &items);
   ret |= check_languages (&items,
                           "default");
   if (0 != count_type (&items,
                        EXTRACTOR_METATYPE_SUBTITLE_TEXT,
                        NULL))
   {
     fprintf (stderr,
              "default: got subtitles without asking for them\n");
     ret = 1;
   }
   if (items.count != 4)
   {
     fprintf (stderr,
              "default: got %u items, expected 4\n",
              items.count);
     ret = 1;
   }
   items_clear (&items);
   return ret;
 }
 
 
 /**
  * Main function for the thumbnailffmpeg testcase.
  *
  * @param argc number of arguments (ignored)
  * @param argv arguments (ignored)
  * @return 0 on success
  */
 int
 main (int argc, char *argv[])
 {
   uint8_t jpeg_magic[] = { 0xFF, 0xD8, 0xFF };
   uint8_t png_magic[] = { 137, 'P', 'N', 'G', '\r', '\n', 26, '\n' };
   struct SolutionData thumbnail_jpeg_sol[] = {
     {
       EXTRACTOR_METATYPE_THUMBNAIL,
       EXTRACTOR_METAFORMAT_BINARY,
       "image/jpeg",
       (const char *) jpeg_magic,
       sizeof (jpeg_magic),
       0
     },
     { 0, 0, NULL, NULL, 0, -1 }
   };
   struct SolutionData thumbnail_png_sol[] = {
     {
       EXTRACTOR_METATYPE_THUMBNAIL,
       EXTRACTOR_METAFORMAT_BINARY,
       "image/png",
       (const char *) png_magic,
       sizeof (png_magic),
       0,
       0,
       &validate_red
     },
     { 0, 0, NULL, NULL, 0, -1 }
   };
   struct ProblemSet ps_jpeg[] = {
     { "testdata/thumbnail_pattern.ogv",
       thumbnail_jpeg_sol },
     { NULL, NULL }
   };
   struct ProblemSet ps_png[] = {
     { "testdata/thumbnail_pattern.ogv",
       thumbnail_png_sol },
     { NULL, NULL }
   };
   int ret;
 
   ret = ET_main ("thumbnailffmpeg",
                  ps_jpeg);
   if (0 != ret)
     return ret;
   ret = ET_main ("thumbnailffmpeg(format=png,size=32)",
                  ps_png);
   if (0 != ret)
     return ret;
   if (0 != access (SUBTITLES_MKV,
                    R_OK))
   {
     fprintf (stderr,
              "Failed to access %s, skipping subtitle tests\n",
              SUBTITLES_MKV);
     return 0;
   }
   ret |= test_default ();
   ret |= test_srt ("en", 0, srt_en);
   ret |= test_srt ("eng", 0, srt_en);
   ret |= test_srt ("de", 0, srt_de);
   ret |= test_srt ("de", 1, srt_de);
   ret |= test_srt ("fr", 0, srt_fr);
   ret |= test_srt ("xx", 0, NULL);
   ret |= test_gallery ();
   return ret;
 }
 
 
 /* end of test_thumbnailffmpeg.c */