test/libvlc/media.c

   1 /*
   2  * media_player.c - libvlc smoke test
   3  *
   4  * $Id$
   5  */
   6
   7 /**********************************************************************
   8  *  Copyright (C) 2010 Pierre d'Herbemont.                            *
   9  *  This program is free software; you can redistribute and/or modify *
  10  *  it under the terms of the GNU General Public License as published *
  11  *  by the Free Software Foundation; version 2 of the license, or (at *
  12  *  your option) any later version.                                   *
  13  *                                                                    *
  14  *  This program is distributed in the hope that it will be useful,   *
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of    *
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.              *
  17  *  See the GNU General Public License for more details.              *
  18  *                                                                    *
  19  *  You should have received a copy of the GNU General Public License *
  20  *  along with this program; if not, you can get it from:             *
  21  *  http://www.gnu.org/copyleft/gpl.html                              *
  22  **********************************************************************/
  23
  24 #include "test.h"
  25 #include "../lib/libvlc_internal.h"
  26
  27 #include <sys/types.h>
  28 #include <sys/stat.h>
  29 #include <fcntl.h>
  30
  31 #include <vlc_threads.h>
  32 #include <vlc_fs.h>
  33 #include <vlc_input_item.h>
  34 #include <vlc_events.h>
  35
  36 static void media_parse_ended(const libvlc_event_t *event, void *user_data)
  37 {
  38     (void)event;
  39     vlc_sem_t *sem = user_data;
  40     vlc_sem_post (sem);
  41 }
  42
  43 static void print_media(libvlc_media_t *media)
  44 {
  45     libvlc_media_track_t **pp_tracks;
  46     unsigned i_count = libvlc_media_tracks_get(media, &pp_tracks);
  47     if (i_count > 0)
  48     {
  49         for (unsigned i = 0; i < i_count; ++i)
  50         {
  51             libvlc_media_track_t *p_track = pp_tracks[i];
  52             log("\ttrack(%d/%d): codec: %4.4s/%4.4s, ", i, p_track->i_id,
  53                 (const char *)&p_track->i_codec,
  54                 (const char *)&p_track->i_original_fourcc);
  55             switch (p_track->i_type)
  56             {
  57             case libvlc_track_audio:
  58                 printf("audio: channels: %u, rate: %u\n",
  59                        p_track->audio->i_channels, p_track->audio->i_rate);
  60                 break;
  61             case libvlc_track_video:
  62                 printf("video: %ux%u, sar: %u/%u, fps: %u/%u\n",
  63                        p_track->video->i_width, p_track->video->i_height,
  64                        p_track->video->i_sar_num, p_track->video->i_sar_den,
  65                        p_track->video->i_frame_rate_num, p_track->video->i_frame_rate_den);
  66                 break;
  67             case libvlc_track_text:
  68                 printf("text: %s\n", p_track->subtitle->psz_encoding);
  69                 break;
  70             case libvlc_track_unknown:
  71                 printf("unknown\n");
  72                 break;
  73             default:
  74                 vlc_assert_unreachable();
  75             }
  76         }
  77         libvlc_media_tracks_release(pp_tracks, i_count);
  78     }
  79     else
  80         log("\tmedia doesn't have any tracks\n");
  81
  82     for (enum libvlc_meta_t i = libvlc_meta_Title;
  83          i <= libvlc_meta_DiscTotal; ++i)
  84     {
  85         char *psz_meta = libvlc_media_get_meta(media, i);
  86         if (psz_meta != NULL)
  87             log("\tmeta(%d): '%s'\n", i, psz_meta);
  88         free(psz_meta);
  89     }
  90 }
  91
  92 static void test_media_preparsed(libvlc_instance_t *vlc, const char *path,
  93                                  const char *location,
  94                                  libvlc_media_parse_flag_t parse_flags,
  95                                  libvlc_media_parsed_status_t i_expected_status)
  96 {
  97     log ("test_media_preparsed: %s, expected: %d\n", path ? path : location,
  98          i_expected_status);
  99
 100     libvlc_media_t *media;
 101     if (path != NULL)
 102         media = libvlc_media_new_path (vlc, path);
 103     else
 104         media = libvlc_media_new_location (vlc, location);
 105     assert (media != NULL);
 106
 107     vlc_sem_t sem;
 108     vlc_sem_init (&sem, 0);
 109
 110     // Check to see if we are properly receiving the event.
 111     libvlc_event_manager_t *em = libvlc_media_event_manager (media);
 112     libvlc_event_attach (em, libvlc_MediaParsedChanged, media_parse_ended, &sem);
 113
 114     // Parse the media. This is synchronous.
 115     int i_ret = libvlc_media_parse_with_options(media, parse_flags, -1);
 116     assert(i_ret == 0);
 117
 118     // Wait for preparsed event
 119     vlc_sem_wait (&sem);
 120     vlc_sem_destroy (&sem);
 121
 122     // We are good, now check Elementary Stream info.
 123     assert (libvlc_media_get_parsed_status(media) == i_expected_status);
 124     if (i_expected_status == libvlc_media_parsed_status_done)
 125         print_media(media);
 126
 127     libvlc_media_release (media);
 128 }
 129
 130 static void input_item_preparse_timeout( const vlc_event_t *p_event,
 131                                          void *user_data )
 132 {
 133     vlc_sem_t *p_sem = user_data;
 134
 135     assert( p_event->u.input_item_preparse_ended.new_status == ITEM_PREPARSE_TIMEOUT );
 136     vlc_sem_post(p_sem);
 137 }
 138
 139 static void test_input_metadata_timeout(libvlc_instance_t *vlc, int timeout,
 140                                         int wait_and_cancel)
 141 {
 142     log ("test_input_metadata_timeout: timeout: %d, wait_and_cancel: %d\n",
 143          timeout, wait_and_cancel);
 144
 145     int i_ret, p_pipe[2];
 146     i_ret = vlc_pipe(p_pipe);
 147     assert(i_ret == 0 && p_pipe[1] >= 0);
 148
 149     char psz_fd_uri[strlen("fd://") + 11];
 150     sprintf(psz_fd_uri, "fd://%u", (unsigned) p_pipe[1]);
 151     input_item_t *p_item = input_item_NewFile(psz_fd_uri, "test timeout", 0,
 152                                               ITEM_LOCAL);
 153     assert(p_item != NULL);
 154
 155     vlc_sem_t sem;
 156     vlc_sem_init (&sem, 0);
 157     i_ret = vlc_event_attach(&p_item->event_manager, vlc_InputItemPreparseEnded,
 158                              input_item_preparse_timeout, &sem);
 159     assert(i_ret == 0);
 160     i_ret = libvlc_MetadataRequest(vlc->p_libvlc_int, p_item,
 161                                    META_REQUEST_OPTION_SCOPE_LOCAL, timeout, vlc);
 162     assert(i_ret == 0);
 163
 164     if (wait_and_cancel > 0)
 165     {
 166         msleep(wait_and_cancel * 1000);
 167         libvlc_MetadataCancel(vlc->p_libvlc_int, vlc);
 168
 169     }
 170     vlc_sem_wait(&sem);
 171
 172     input_item_Release(p_item);
 173     vlc_sem_destroy(&sem);
 174     vlc_close(p_pipe[0]);
 175     vlc_close(p_pipe[1]);
 176 }
 177
 178 #define TEST_SUBITEMS_COUNT 6
 179 static struct
 180 {
 181     const char *file;
 182     libvlc_media_type_t type;
 183 } test_media_subitems_list[TEST_SUBITEMS_COUNT] =
 184 {
 185     { "directory", libvlc_media_type_directory, },
 186     { "file.jpg", libvlc_media_type_file },
 187     { "file.mkv", libvlc_media_type_file },
 188     { "file.mp3", libvlc_media_type_file },
 189     { "file.png", libvlc_media_type_file },
 190     { "file.ts", libvlc_media_type_file },
 191 };
 192
 193 static void subitem_parse_ended(const libvlc_event_t *event, void *user_data)
 194 {
 195     (void)event;
 196     vlc_sem_t *sem = user_data;
 197     vlc_sem_post (sem);
 198 }
 199
 200 static void subitem_added(const libvlc_event_t *event, void *user_data)
 201 {
 202 #ifdef _WIN32
 203 #define FILE_SEPARATOR   '\\'
 204 #else
 205 #define FILE_SEPARATOR   '/'
 206 #endif
 207     bool *subitems_found = user_data;
 208     libvlc_media_t *m = event->u.media_subitem_added.new_child;
 209     assert (m);
 210
 211     char *mrl = libvlc_media_get_mrl (m);
 212     assert (mrl);
 213
 214     const char *file = strrchr (mrl, FILE_SEPARATOR);
 215     assert (file);
 216     file++;
 217     log ("subitem_added, file: %s\n", file);
 218
 219     for (unsigned i = 0; i < TEST_SUBITEMS_COUNT; ++i)
 220     {
 221         if (strcmp (test_media_subitems_list[i].file, file) == 0)
 222         {
 223             assert (!subitems_found[i]);
 224             assert (libvlc_media_get_type(m) == test_media_subitems_list[i].type);
 225             subitems_found[i] = true;
 226         }
 227     }
 228     free (mrl);
 229 #undef FILE_SEPARATOR
 230 }
 231
 232 static void test_media_subitems_media(libvlc_media_t *media, bool play,
 233                                       bool b_items_expected)
 234 {
 235     libvlc_media_add_option(media, ":ignore-filetypes= ");
 236
 237     bool subitems_found[TEST_SUBITEMS_COUNT] = { 0 };
 238     vlc_sem_t sem;
 239     vlc_sem_init (&sem, 0);
 240
 241     libvlc_event_manager_t *em = libvlc_media_event_manager (media);
 242     libvlc_event_attach (em, libvlc_MediaSubItemAdded, subitem_added, subitems_found);
 243
 244     if (play)
 245     {
 246         /* XXX: libvlc_media_parse_with_options won't work with fd, since it
 247          * won't be preparsed because fd:// is an unknown type, so play the
 248          * file to force parsing. */
 249         libvlc_event_attach (em, libvlc_MediaSubItemTreeAdded, subitem_parse_ended, &sem);
 250
 251         libvlc_media_player_t *mp = libvlc_media_player_new_from_media (media);
 252         assert (mp);
 253         assert (libvlc_media_player_play (mp) != -1);
 254         vlc_sem_wait (&sem);
 255         libvlc_media_player_release (mp);
 256     }
 257     else
 258     {
 259         libvlc_event_attach (em, libvlc_MediaParsedChanged, subitem_parse_ended, &sem);
 260
 261         int i_ret = libvlc_media_parse_with_options(media, libvlc_media_parse_local, -1);
 262         assert(i_ret == 0);
 263         vlc_sem_wait (&sem);
 264     }
 265
 266     vlc_sem_destroy (&sem);
 267
 268     if (!b_items_expected)
 269         return;
 270
 271     for (unsigned i = 0; i < TEST_SUBITEMS_COUNT; ++i)
 272     {
 273         log ("test if %s was added\n", test_media_subitems_list[i].file);
 274         assert (subitems_found[i]);
 275     }
 276 }
 277
 278 static void test_media_subitems(libvlc_instance_t *vlc)
 279 {
 280     const char *subitems_path = SRCDIR"/samples/subitems";
 281
 282     libvlc_media_t *media;
 283
 284     log ("Testing media_subitems: path: '%s'\n", subitems_path);
 285     media = libvlc_media_new_path (vlc, subitems_path);
 286     assert (media != NULL);
 287     test_media_subitems_media (media, false, true);
 288     libvlc_media_release (media);
 289
 290     #define NB_LOCATIONS 2
 291     char *subitems_realpath = realpath (subitems_path, NULL);
 292     assert (subitems_realpath != NULL);
 293     const char *schemes[NB_LOCATIONS] = { "file://", "dir://" };
 294     for (unsigned i = 0; i < NB_LOCATIONS; ++i)
 295     {
 296         char *location;
 297         assert (asprintf (&location, "%s%s", schemes[i], subitems_realpath) != -1);
 298         log ("Testing media_subitems: location: '%s'\n", location);
 299         media = libvlc_media_new_location (vlc, location);
 300         assert (media != NULL);
 301         test_media_subitems_media (media, false, true);
 302         free (location);
 303         libvlc_media_release (media);
 304     }
 305     free (subitems_realpath);
 306
 307 #ifdef HAVE_OPENAT
 308     /* listing directory via a fd works only if HAVE_OPENAT is defined */
 309     int fd = open (subitems_path, O_RDONLY);
 310     log ("Testing media_subitems: fd: '%d'\n", fd);
 311     assert (fd >= 0);
 312     media = libvlc_media_new_fd (vlc, fd);
 313     assert (media != NULL);
 314     test_media_subitems_media (media, true, true);
 315     libvlc_media_release (media);
 316     vlc_close (fd);
 317 #else
 318 #warning not testing subitems list via a fd location
 319 #endif
 320
 321     log ("Testing media_subitems failure\n");
 322     media = libvlc_media_new_location (vlc, "wrongfile://test");
 323     assert (media != NULL);
 324     test_media_subitems_media (media, false, false);
 325     libvlc_media_release (media);
 326 }
 327
 328 int main(int i_argc, char *ppsz_argv[])
 329 {
 330     test_init();
 331
 332     libvlc_instance_t *vlc = libvlc_new (test_defaults_nargs,
 333                                          test_defaults_args);
 334     assert (vlc != NULL);
 335
 336     char *psz_test_arg = i_argc > 1 ? ppsz_argv[1] : NULL;
 337     if (psz_test_arg != NULL)
 338     {
 339         alarm(0);
 340         const char *psz_test_url;
 341         const char *psz_test_path;
 342         if (strstr(psz_test_arg, "://") != NULL)
 343         {
 344             psz_test_url = psz_test_arg;
 345             psz_test_path = NULL;
 346         }
 347         else
 348         {
 349             psz_test_url = NULL;
 350             psz_test_path = psz_test_arg;
 351         }
 352         test_media_preparsed (vlc, psz_test_path, psz_test_url,
 353                               libvlc_media_parse_network,
 354                               libvlc_media_parsed_status_done);
 355         return 0;
 356     }
 357
 358     test_media_preparsed (vlc, SRCDIR"/samples/image.jpg", NULL,
 359                           libvlc_media_parse_local,
 360                           libvlc_media_parsed_status_done);
 361     test_media_preparsed (vlc, NULL, "http://parsing_should_be_skipped.org/video.mp4",
 362                           libvlc_media_parse_local,
 363                           libvlc_media_parsed_status_skipped);
 364     test_media_preparsed (vlc, NULL, "unknown://parsing_should_be_skipped.org/video.mp4",
 365                           libvlc_media_parse_local,
 366                           libvlc_media_parsed_status_skipped);
 367     test_media_subitems (vlc);
 368
 369     /* Testing libvlc_MetadataRequest timeout and libvlc_MetadataCancel. For
 370      * that, we need to create a local input_item_t based on a pipe. There is
 371      * no way to do that with a libvlc_media_t, that's why we don't use
 372      * libvlc_media_parse*() */
 373
 374     test_input_metadata_timeout (vlc, 100, 0);
 375     test_input_metadata_timeout (vlc, 0, 100);
 376
 377     libvlc_release (vlc);
 378
 379     return 0;
 380 }