tests/check/elements/filesrc.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2006 Thomas Vander Stichele <thomas at apestaart dot org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <unistd.h>
  22 #include <sys/types.h>
  23 #include <sys/stat.h>
  24 #include <fcntl.h>
  25
  26 #include <gst/check/gstcheck.h>
  27
  28 static gboolean have_eos = FALSE;
  29 static GCond *eos_cond;
  30 static GMutex *event_mutex;
  31
  32 static GstPad *mysinkpad;
  33
  34 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
  35     GST_PAD_SINK,
  36     GST_PAD_ALWAYS,
  37     GST_STATIC_CAPS_ANY);
  38
  39 static gboolean
  40 event_func (GstPad * pad, GstEvent * event)
  41 {
  42   gboolean res = TRUE;
  43
  44   g_mutex_lock (event_mutex);
  45   if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
  46     have_eos = TRUE;
  47     GST_DEBUG ("signal EOS");
  48     g_cond_broadcast (eos_cond);
  49   }
  50   g_mutex_unlock (event_mutex);
  51
  52   gst_event_unref (event);
  53
  54   return res;
  55 }
  56
  57 static void
  58 wait_eos (void)
  59 {
  60   g_mutex_lock (event_mutex);
  61   GST_DEBUG ("waiting for EOS");
  62   while (!have_eos) {
  63     g_cond_wait (eos_cond, event_mutex);
  64   }
  65   GST_DEBUG ("received EOS");
  66   g_mutex_unlock (event_mutex);
  67 }
  68
  69 static GstElement *
  70 setup_filesrc (void)
  71 {
  72   GstElement *filesrc;
  73
  74   GST_DEBUG ("setup_filesrc");
  75   filesrc = gst_check_setup_element ("filesrc");
  76   mysinkpad = gst_check_setup_sink_pad (filesrc, &sinktemplate, NULL);
  77   gst_pad_set_event_function (mysinkpad, event_func);
  78   gst_pad_set_active (mysinkpad, TRUE);
  79
  80   eos_cond = g_cond_new ();
  81   event_mutex = g_mutex_new ();
  82
  83   return filesrc;
  84 }
  85
  86 static void
  87 cleanup_filesrc (GstElement * filesrc)
  88 {
  89   gst_pad_set_active (mysinkpad, FALSE);
  90   gst_check_teardown_sink_pad (filesrc);
  91   gst_check_teardown_element (filesrc);
  92
  93   g_cond_free (eos_cond);
  94   g_mutex_free (event_mutex);
  95 }
  96
  97 GST_START_TEST (test_seeking)
  98 {
  99   GstElement *src;
 100   GstQuery *seeking_query;
 101   gboolean seekable;
 102
 103 #ifndef TESTFILE
 104 #error TESTFILE not defined
 105 #endif
 106   src = setup_filesrc ();
 107
 108   g_object_set (G_OBJECT (src), "location", TESTFILE, NULL);
 109   fail_unless (gst_element_set_state (src,
 110           GST_STATE_PAUSED) == GST_STATE_CHANGE_SUCCESS,
 111       "could not set to paused");
 112
 113   /* Test that filesrc is seekable with a file fd */
 114   fail_unless ((seeking_query = gst_query_new_seeking (GST_FORMAT_BYTES))
 115       != NULL);
 116   fail_unless (gst_element_query (src, seeking_query) == TRUE);
 117   gst_query_parse_seeking (seeking_query, NULL, &seekable, NULL, NULL);
 118   fail_unless (seekable == TRUE);
 119   gst_query_unref (seeking_query);
 120
 121   fail_unless (gst_element_set_state (src,
 122           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 123
 124   /* cleanup */
 125   cleanup_filesrc (src);
 126 }
 127
 128 GST_END_TEST;
 129
 130 GST_START_TEST (test_reverse)
 131 {
 132   GstElement *src;
 133
 134 #ifndef TESTFILE
 135 #error TESTFILE not defined
 136 #endif
 137   src = setup_filesrc ();
 138
 139   g_object_set (G_OBJECT (src), "location", TESTFILE, NULL);
 140   /* we're going to perform the seek in ready */
 141   fail_unless (gst_element_set_state (src,
 142           GST_STATE_READY) == GST_STATE_CHANGE_SUCCESS,
 143       "could not set to ready");
 144
 145   /* reverse seek from end to start */
 146   gst_element_seek (src, -1.0, GST_FORMAT_BYTES, 0, GST_SEEK_TYPE_SET, 100,
 147       GST_SEEK_TYPE_SET, -1);
 148
 149   fail_unless (gst_element_set_state (src,
 150           GST_STATE_PAUSED) == GST_STATE_CHANGE_SUCCESS,
 151       "could not set to paused");
 152
 153   /* wait for EOS */
 154   wait_eos ();
 155
 156   fail_unless (gst_element_set_state (src,
 157           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 158
 159   /* cleanup */
 160   cleanup_filesrc (src);
 161 }
 162
 163 GST_END_TEST;
 164
 165 GST_START_TEST (test_pull)
 166 {
 167   GstElement *src;
 168   GstQuery *seeking_query;
 169   gboolean res, seekable;
 170   gint64 start, stop;
 171   GstPad *pad;
 172   GstFlowReturn ret;
 173   GstBuffer *buffer1, *buffer2;
 174   guint8 *data1, *data2;
 175   gsize size1, size2;
 176
 177   src = setup_filesrc ();
 178
 179   g_object_set (G_OBJECT (src), "location", TESTFILE, NULL);
 180   fail_unless (gst_element_set_state (src,
 181           GST_STATE_READY) == GST_STATE_CHANGE_SUCCESS,
 182       "could not set to ready");
 183
 184   /* get the source pad */
 185   pad = gst_element_get_static_pad (src, "src");
 186   fail_unless (pad != NULL);
 187
 188   /* activate the pad in pull mode */
 189   res = gst_pad_activate_pull (pad, TRUE);
 190   fail_unless (res == TRUE);
 191
 192   /* not start playing */
 193   fail_unless (gst_element_set_state (src,
 194           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 195       "could not set to paused");
 196
 197   /* Test that filesrc is seekable with a file fd */
 198   fail_unless ((seeking_query = gst_query_new_seeking (GST_FORMAT_BYTES))
 199       != NULL);
 200   fail_unless (gst_element_query (src, seeking_query) == TRUE);
 201
 202   /* get the seeking capabilities */
 203   gst_query_parse_seeking (seeking_query, NULL, &seekable, &start, &stop);
 204   fail_unless (seekable == TRUE);
 205   fail_unless (start == 0);
 206   fail_unless (start != -1);
 207   gst_query_unref (seeking_query);
 208
 209   /* do some pulls */
 210   ret = gst_pad_get_range (pad, 0, 100, &buffer1);
 211   fail_unless (ret == GST_FLOW_OK);
 212   fail_unless (buffer1 != NULL);
 213   fail_unless (gst_buffer_get_size (buffer1) == 100);
 214
 215   ret = gst_pad_get_range (pad, 0, 50, &buffer2);
 216   fail_unless (ret == GST_FLOW_OK);
 217   fail_unless (buffer2 != NULL);
 218   fail_unless (gst_buffer_get_size (buffer2) == 50);
 219
 220   /* this should be the same */
 221   data1 = gst_buffer_map (buffer1, &size1, NULL, GST_MAP_READ);
 222   data2 = gst_buffer_map (buffer2, &size2, NULL, GST_MAP_READ);
 223   fail_unless (memcmp (data1, data2, 50) == 0);
 224   gst_buffer_unmap (buffer2, data2, size2);
 225
 226   gst_buffer_unref (buffer2);
 227
 228   /* read next 50 bytes */
 229   ret = gst_pad_get_range (pad, 50, 50, &buffer2);
 230   fail_unless (ret == GST_FLOW_OK);
 231   fail_unless (buffer2 != NULL);
 232   fail_unless (gst_buffer_get_size (buffer2) == 50);
 233
 234   /* compare with previously read data */
 235   data2 = gst_buffer_map (buffer2, &size2, NULL, GST_MAP_READ);
 236   fail_unless (memcmp (data1 + 50, data2, 50) == 0);
 237   gst_buffer_unmap (buffer2, data2, size2);
 238
 239   gst_buffer_unmap (buffer1, data1, size1);
 240   gst_buffer_unref (buffer1);
 241   gst_buffer_unref (buffer2);
 242
 243   /* read 10 bytes at end-10 should give exactly 10 bytes */
 244   ret = gst_pad_get_range (pad, stop - 10, 10, &buffer1);
 245   fail_unless (ret == GST_FLOW_OK);
 246   fail_unless (buffer1 != NULL);
 247   fail_unless (gst_buffer_get_size (buffer1) == 10);
 248   gst_buffer_unref (buffer1);
 249
 250   /* read 20 bytes at end-10 should give exactly 10 bytes */
 251   ret = gst_pad_get_range (pad, stop - 10, 20, &buffer1);
 252   fail_unless (ret == GST_FLOW_OK);
 253   fail_unless (buffer1 != NULL);
 254   fail_unless (gst_buffer_get_size (buffer1) == 10);
 255   gst_buffer_unref (buffer1);
 256
 257   /* read 0 bytes at end-1 should return 0 bytes */
 258   ret = gst_pad_get_range (pad, stop - 1, 0, &buffer1);
 259   fail_unless (ret == GST_FLOW_OK);
 260   fail_unless (buffer1 != NULL);
 261   fail_unless (gst_buffer_get_size (buffer1) == 0);
 262   gst_buffer_unref (buffer1);
 263
 264   /* read 10 bytes at end-1 should return 1 byte */
 265   ret = gst_pad_get_range (pad, stop - 1, 10, &buffer1);
 266   fail_unless (ret == GST_FLOW_OK);
 267   fail_unless (buffer1 != NULL);
 268   fail_unless (gst_buffer_get_size (buffer1) == 1);
 269   gst_buffer_unref (buffer1);
 270
 271   /* read 0 bytes at end should EOS */
 272   ret = gst_pad_get_range (pad, stop, 0, &buffer1);
 273   fail_unless (ret == GST_FLOW_EOS);
 274
 275   /* read 10 bytes before end should EOS */
 276   ret = gst_pad_get_range (pad, stop, 10, &buffer1);
 277   fail_unless (ret == GST_FLOW_EOS);
 278
 279   /* read 0 bytes after end should EOS */
 280   ret = gst_pad_get_range (pad, stop + 10, 0, &buffer1);
 281   fail_unless (ret == GST_FLOW_EOS);
 282
 283   /* read 10 bytes after end should EOS too */
 284   ret = gst_pad_get_range (pad, stop + 10, 10, &buffer1);
 285   fail_unless (ret == GST_FLOW_EOS);
 286
 287   fail_unless (gst_element_set_state (src,
 288           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 289
 290   /* cleanup */
 291   gst_object_unref (pad);
 292   cleanup_filesrc (src);
 293 }
 294
 295 GST_END_TEST;
 296
 297 GST_START_TEST (test_coverage)
 298 {
 299   GstElement *src;
 300   gchar *location;
 301   GstBus *bus;
 302   GstMessage *message;
 303
 304   src = setup_filesrc ();
 305   bus = gst_bus_new ();
 306
 307   gst_element_set_bus (src, bus);
 308
 309   g_object_set (G_OBJECT (src), "location", "/i/do/not/exist", NULL);
 310   g_object_get (G_OBJECT (src), "location", &location, NULL);
 311   fail_unless_equals_string (location, "/i/do/not/exist");
 312   g_free (location);
 313   fail_unless (gst_element_set_state (src,
 314           GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE,
 315       "could set to playing with wrong location");
 316
 317   /* a state change and an error */
 318   fail_if ((message = gst_bus_pop (bus)) == NULL);
 319   gst_message_unref (message);
 320   fail_if ((message = gst_bus_pop (bus)) == NULL);
 321   fail_unless_message_error (message, RESOURCE, NOT_FOUND);
 322   gst_message_unref (message);
 323
 324   g_object_set (G_OBJECT (src), "location", NULL, NULL);
 325   g_object_get (G_OBJECT (src), "location", &location, NULL);
 326   fail_if (location);
 327
 328   /* cleanup */
 329   gst_element_set_bus (src, NULL);
 330   gst_object_unref (GST_OBJECT (bus));
 331   cleanup_filesrc (src);
 332 }
 333
 334 GST_END_TEST;
 335
 336 GST_START_TEST (test_uri_interface)
 337 {
 338   GstElement *src;
 339   gchar *location;
 340   GstBus *bus;
 341
 342   src = setup_filesrc ();
 343   bus = gst_bus_new ();
 344
 345   gst_element_set_bus (src, bus);
 346
 347   g_object_set (G_OBJECT (src), "location", "/i/do/not/exist", NULL);
 348   g_object_get (G_OBJECT (src), "location", &location, NULL);
 349   fail_unless_equals_string (location, "/i/do/not/exist");
 350   g_free (location);
 351
 352   location = gst_uri_handler_get_uri (GST_URI_HANDLER (src));
 353   fail_unless_equals_string (location, "file:///i/do/not/exist");
 354   g_free (location);
 355
 356   /* should accept file:///foo/bar URIs */
 357   fail_unless (gst_uri_handler_set_uri (GST_URI_HANDLER (src),
 358           "file:///foo/bar", NULL));
 359   location = gst_uri_handler_get_uri (GST_URI_HANDLER (src));
 360   fail_unless_equals_string (location, "file:///foo/bar");
 361   g_free (location);
 362   g_object_get (G_OBJECT (src), "location", &location, NULL);
 363   fail_unless_equals_string (location, "/foo/bar");
 364   g_free (location);
 365
 366   /* should accept file://localhost/foo/bar URIs */
 367   fail_unless (gst_uri_handler_set_uri (GST_URI_HANDLER (src),
 368           "file://localhost/foo/baz", NULL));
 369   location = gst_uri_handler_get_uri (GST_URI_HANDLER (src));
 370   fail_unless_equals_string (location, "file:///foo/baz");
 371   g_free (location);
 372   g_object_get (G_OBJECT (src), "location", &location, NULL);
 373   fail_unless_equals_string (location, "/foo/baz");
 374   g_free (location);
 375
 376   /* should escape non-uri characters for the URI but not for the location */
 377   g_object_set (G_OBJECT (src), "location", "/foo/b?r", NULL);
 378   g_object_get (G_OBJECT (src), "location", &location, NULL);
 379   fail_unless_equals_string (location, "/foo/b?r");
 380   g_free (location);
 381   location = gst_uri_handler_get_uri (GST_URI_HANDLER (src));
 382   fail_unless_equals_string (location, "file:///foo/b%3Fr");
 383   g_free (location);
 384
 385   /* should fail with other hostnames */
 386   fail_if (gst_uri_handler_set_uri (GST_URI_HANDLER (src),
 387           "file://hostname/foo/foo", NULL));
 388
 389   /* cleanup */
 390   gst_element_set_bus (src, NULL);
 391   gst_object_unref (GST_OBJECT (bus));
 392   cleanup_filesrc (src);
 393 }
 394
 395 GST_END_TEST;
 396
 397 static void
 398 check_uri_for_uri (GstElement * e, const gchar * in_uri, const gchar * uri)
 399 {
 400   GstQuery *query;
 401   gchar *query_uri = NULL;
 402
 403   gst_uri_handler_set_uri (GST_URI_HANDLER (e), in_uri, NULL);
 404
 405   query = gst_query_new_uri ();
 406   fail_unless (gst_element_query (e, query));
 407   gst_query_parse_uri (query, &query_uri);
 408   gst_query_unref (query);
 409
 410   if (uri != NULL) {
 411     fail_unless_equals_string (query_uri, uri);
 412   } else {
 413     gchar *fn;
 414
 415     fail_unless (gst_uri_is_valid (query_uri));
 416     fn = g_filename_from_uri (query_uri, NULL, NULL);
 417     fail_unless (g_path_is_absolute (fn));
 418     fail_unless (fn != NULL);
 419     g_free (fn);
 420   }
 421
 422   g_free (query_uri);
 423 }
 424
 425 static void
 426 check_uri_for_location (GstElement * e, const gchar * location,
 427     const gchar * uri)
 428 {
 429   GstQuery *query;
 430   gchar *query_uri = NULL;
 431
 432   g_object_set (e, "location", location, NULL);
 433   query = gst_query_new_uri ();
 434   fail_unless (gst_element_query (e, query));
 435   gst_query_parse_uri (query, &query_uri);
 436   gst_query_unref (query);
 437
 438   if (uri != NULL) {
 439     fail_unless_equals_string (query_uri, uri);
 440   } else {
 441     gchar *fn;
 442
 443     fail_unless (gst_uri_is_valid (query_uri));
 444     fn = g_filename_from_uri (query_uri, NULL, NULL);
 445     fail_unless (g_path_is_absolute (fn));
 446     fail_unless (fn != NULL);
 447     g_free (fn);
 448   }
 449
 450   g_free (query_uri);
 451 }
 452
 453 GST_START_TEST (test_uri_query)
 454 {
 455   GstElement *src;
 456
 457   src = setup_filesrc ();
 458
 459 #ifdef G_OS_UNIX
 460   {
 461     GST_INFO ("*nix");
 462     check_uri_for_location (src, "/i/do/not/exist", "file:///i/do/not/exist");
 463     check_uri_for_location (src, "/i/do/not/../exist", "file:///i/do/exist");
 464     check_uri_for_location (src, "/i/do/not/.././exist", "file:///i/do/exist");
 465     check_uri_for_location (src, "/i/./do/not/../exist", "file:///i/do/exist");
 466     check_uri_for_location (src, "/i/do/./not/../exist", "file:///i/do/exist");
 467     check_uri_for_location (src, "/i/do/not/./../exist", "file:///i/do/exist");
 468     check_uri_for_location (src, "/i/./do/./././././exist",
 469         "file:///i/do/exist");
 470     check_uri_for_location (src, "/i/do/not/../../exist", "file:///i/exist");
 471     check_uri_for_location (src, "/i/../not/../exist", "file:///exist");
 472     /* hard to test relative URIs, just make sure it returns an URI of sorts */
 473     check_uri_for_location (src, "foo", NULL);
 474     check_uri_for_location (src, "foo/../bar", NULL);
 475     check_uri_for_location (src, "./foo", NULL);
 476     check_uri_for_location (src, "../foo", NULL);
 477     check_uri_for_location (src, "foo/./bar", NULL);
 478     /* make sure non-ASCII characters are escaped properly (U+00F6 here) */
 479     check_uri_for_location (src, "/i/./d\303\266/not/../exist",
 480         "file:///i/d%C3%B6/exist");
 481     /* let's see what happens if we set a malformed URI with ISO-8859-1 chars,
 482      * i.e. one that the input characters haven't been escaped properly. We
 483      * should get back a properly escaped URI */
 484     check_uri_for_uri (src, "file:///M\366t\366r", "file:///M%F6t%F6r");
 485   }
 486 #endif
 487
 488   cleanup_filesrc (src);
 489 }
 490
 491 GST_END_TEST;
 492
 493 static Suite *
 494 filesrc_suite (void)
 495 {
 496   Suite *s = suite_create ("filesrc");
 497   TCase *tc_chain = tcase_create ("general");
 498
 499   suite_add_tcase (s, tc_chain);
 500   tcase_add_test (tc_chain, test_seeking);
 501   tcase_add_test (tc_chain, test_reverse);
 502   tcase_add_test (tc_chain, test_pull);
 503   tcase_add_test (tc_chain, test_coverage);
 504   tcase_add_test (tc_chain, test_uri_interface);
 505   tcase_add_test (tc_chain, test_uri_query);
 506
 507   return s;
 508 }
 509
 510 GST_CHECK_MAIN (filesrc);