inputselector: Forward LATENCY query to all sinkpads
[platform/upstream/gstreamer.git] / plugins / elements / gstfilesrc.c
1 /* GStreamer
2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3  *               2000,2005 Wim Taymans <wim@fluendo.com>
4  *
5  * gstfilesrc.c:
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Library General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Library General Public License for more details.
16  *
17  * You should have received a copy of the GNU Library General Public
18  * License along with this library; if not, write to the
19  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20  * Boston, MA 02110-1301, USA.
21  */
22 /**
23  * SECTION:element-filesrc
24  * @title: filesrc
25  * @see_also: #GstFileSrc
26  *
27  * Read data from a file in the local file system.
28  *
29  * ## Example launch line
30  * |[
31  * gst-launch-1.0 filesrc location=song.ogg ! decodebin ! audioconvert ! audioresample ! autoaudiosink
32  * ]| Play song.ogg audio file which must be in the current working directory.
33  *
34  */
35
36 #ifdef HAVE_CONFIG_H
37 #  include "config.h"
38 #endif
39
40 #include <gst/gst.h>
41 #include "gstfilesrc.h"
42
43 #include <stdio.h>
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 #ifdef G_OS_WIN32
47 #include <io.h>                 /* lseek, open, close, read */
48 /* On win32, stat* default to 32 bit; we need the 64-bit
49  * variants, so explicitly define it that way. */
50 #undef stat
51 #define stat __stat64
52 #undef fstat
53 #define fstat _fstat64
54 #undef lseek
55 #define lseek _lseeki64
56 #undef off_t
57 #define off_t guint64
58 /* Prevent stat.h from defining the stat* functions as
59  * _stat*, since we're explicitly overriding that */
60 #undef _INC_STAT_INL
61 #endif
62 #include <fcntl.h>
63
64 #ifdef HAVE_UNISTD_H
65 #  include <unistd.h>
66 #endif
67
68 #ifdef __BIONIC__               /* Android */
69 #if defined(__ANDROID_API__) && __ANDROID_API__ >= 21
70 #undef fstat
71 #define fstat fstat64
72 #endif
73 #endif
74
75 #include <errno.h>
76 #include <string.h>
77
78 #include "../../gst/gst-i18n-lib.h"
79
80 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
81     GST_PAD_SRC,
82     GST_PAD_ALWAYS,
83     GST_STATIC_CAPS_ANY);
84
85 #ifndef S_ISREG
86 #define S_ISREG(mode) ((mode)&_S_IFREG)
87 #endif
88 #ifndef S_ISDIR
89 #define S_ISDIR(mode) ((mode)&_S_IFDIR)
90 #endif
91 #ifndef S_ISSOCK
92 #define S_ISSOCK(x) (0)
93 #endif
94 #ifndef O_BINARY
95 #define O_BINARY (0)
96 #endif
97
98 /* Copy of glib's g_open due to win32 libc/cross-DLL brokenness: we can't
99  * use the 'file descriptor' opened in glib (and returned from this function)
100  * in this library, as they may have unrelated C runtimes. */
101 static int
102 gst_open (const gchar * filename, int flags, int mode)
103 {
104 #ifdef G_OS_WIN32
105   wchar_t *wfilename = g_utf8_to_utf16 (filename, -1, NULL, NULL, NULL);
106   int retval;
107   int save_errno;
108
109   if (wfilename == NULL) {
110     errno = EINVAL;
111     return -1;
112   }
113
114   retval = _wopen (wfilename, flags, mode);
115   save_errno = errno;
116
117   g_free (wfilename);
118
119   errno = save_errno;
120   return retval;
121 #elif defined (__BIONIC__)
122   return open (filename, flags | O_LARGEFILE, mode);
123 #else
124   return open (filename, flags, mode);
125 #endif
126 }
127
128 GST_DEBUG_CATEGORY_STATIC (gst_file_src_debug);
129 #define GST_CAT_DEFAULT gst_file_src_debug
130
131 /* FileSrc signals and args */
132 enum
133 {
134   /* FILL ME */
135   LAST_SIGNAL
136 };
137
138 #define DEFAULT_BLOCKSIZE       4*1024
139
140 enum
141 {
142   PROP_0,
143   PROP_LOCATION
144 };
145
146 static void gst_file_src_finalize (GObject * object);
147
148 static void gst_file_src_set_property (GObject * object, guint prop_id,
149     const GValue * value, GParamSpec * pspec);
150 static void gst_file_src_get_property (GObject * object, guint prop_id,
151     GValue * value, GParamSpec * pspec);
152
153 static gboolean gst_file_src_start (GstBaseSrc * basesrc);
154 static gboolean gst_file_src_stop (GstBaseSrc * basesrc);
155
156 static gboolean gst_file_src_is_seekable (GstBaseSrc * src);
157 static gboolean gst_file_src_get_size (GstBaseSrc * src, guint64 * size);
158 static GstFlowReturn gst_file_src_fill (GstBaseSrc * src, guint64 offset,
159     guint length, GstBuffer * buf);
160
161 static void gst_file_src_uri_handler_init (gpointer g_iface,
162     gpointer iface_data);
163
164 #define _do_init \
165   G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, gst_file_src_uri_handler_init); \
166   GST_DEBUG_CATEGORY_INIT (gst_file_src_debug, "filesrc", 0, "filesrc element");
167 #define gst_file_src_parent_class parent_class
168 G_DEFINE_TYPE_WITH_CODE (GstFileSrc, gst_file_src, GST_TYPE_BASE_SRC, _do_init);
169
170 static void
171 gst_file_src_class_init (GstFileSrcClass * klass)
172 {
173   GObjectClass *gobject_class;
174   GstElementClass *gstelement_class;
175   GstBaseSrcClass *gstbasesrc_class;
176
177   gobject_class = G_OBJECT_CLASS (klass);
178   gstelement_class = GST_ELEMENT_CLASS (klass);
179   gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
180
181   gobject_class->set_property = gst_file_src_set_property;
182   gobject_class->get_property = gst_file_src_get_property;
183
184   g_object_class_install_property (gobject_class, PROP_LOCATION,
185       g_param_spec_string ("location", "File Location",
186           "Location of the file to read", NULL,
187           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS |
188           GST_PARAM_MUTABLE_READY));
189
190   gobject_class->finalize = gst_file_src_finalize;
191
192   gst_element_class_set_static_metadata (gstelement_class,
193       "File Source",
194       "Source/File",
195       "Read from arbitrary point in a file",
196       "Erik Walthinsen <omega@cse.ogi.edu>");
197   gst_element_class_add_static_pad_template (gstelement_class, &srctemplate);
198
199   gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_file_src_start);
200   gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_file_src_stop);
201   gstbasesrc_class->is_seekable = GST_DEBUG_FUNCPTR (gst_file_src_is_seekable);
202   gstbasesrc_class->get_size = GST_DEBUG_FUNCPTR (gst_file_src_get_size);
203   gstbasesrc_class->fill = GST_DEBUG_FUNCPTR (gst_file_src_fill);
204
205   if (sizeof (off_t) < 8) {
206     GST_LOG ("No large file support, sizeof (off_t) = %" G_GSIZE_FORMAT "!",
207         sizeof (off_t));
208   }
209 }
210
211 static void
212 gst_file_src_init (GstFileSrc * src)
213 {
214   src->filename = NULL;
215   src->fd = 0;
216   src->uri = NULL;
217
218   src->is_regular = FALSE;
219
220   gst_base_src_set_blocksize (GST_BASE_SRC (src), DEFAULT_BLOCKSIZE);
221 }
222
223 static void
224 gst_file_src_finalize (GObject * object)
225 {
226   GstFileSrc *src;
227
228   src = GST_FILE_SRC (object);
229
230   g_free (src->filename);
231   g_free (src->uri);
232
233   G_OBJECT_CLASS (parent_class)->finalize (object);
234 }
235
236 static gboolean
237 gst_file_src_set_location (GstFileSrc * src, const gchar * location,
238     GError ** err)
239 {
240   GstState state;
241
242   /* the element must be stopped in order to do this */
243   GST_OBJECT_LOCK (src);
244   state = GST_STATE (src);
245   if (state != GST_STATE_READY && state != GST_STATE_NULL)
246     goto wrong_state;
247   GST_OBJECT_UNLOCK (src);
248
249   g_free (src->filename);
250   g_free (src->uri);
251
252   /* clear the filename if we get a NULL */
253   if (location == NULL) {
254     src->filename = NULL;
255     src->uri = NULL;
256   } else {
257     /* we store the filename as received by the application. On Windows this
258      * should be UTF8 */
259     src->filename = g_strdup (location);
260     src->uri = gst_filename_to_uri (location, NULL);
261     GST_INFO ("filename : %s", src->filename);
262     GST_INFO ("uri      : %s", src->uri);
263   }
264   g_object_notify (G_OBJECT (src), "location");
265   /* FIXME 2.0: notify "uri" property once there is one */
266
267   return TRUE;
268
269   /* ERROR */
270 wrong_state:
271   {
272     g_warning ("Changing the `location' property on filesrc when a file is "
273         "open is not supported.");
274     if (err)
275       g_set_error (err, GST_URI_ERROR, GST_URI_ERROR_BAD_STATE,
276           "Changing the `location' property on filesrc when a file is "
277           "open is not supported.");
278     GST_OBJECT_UNLOCK (src);
279     return FALSE;
280   }
281 }
282
283 static void
284 gst_file_src_set_property (GObject * object, guint prop_id,
285     const GValue * value, GParamSpec * pspec)
286 {
287   GstFileSrc *src;
288
289   g_return_if_fail (GST_IS_FILE_SRC (object));
290
291   src = GST_FILE_SRC (object);
292
293   switch (prop_id) {
294     case PROP_LOCATION:
295       gst_file_src_set_location (src, g_value_get_string (value), NULL);
296       break;
297     default:
298       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
299       break;
300   }
301 }
302
303 static void
304 gst_file_src_get_property (GObject * object, guint prop_id, GValue * value,
305     GParamSpec * pspec)
306 {
307   GstFileSrc *src;
308
309   g_return_if_fail (GST_IS_FILE_SRC (object));
310
311   src = GST_FILE_SRC (object);
312
313   switch (prop_id) {
314     case PROP_LOCATION:
315       g_value_set_string (value, src->filename);
316       break;
317     default:
318       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
319       break;
320   }
321 }
322
323 /***
324  * read code below
325  * that is to say, you shouldn't read the code below, but the code that reads
326  * stuff is below.  Well, you shouldn't not read the code below, feel free
327  * to read it of course.  It's just that "read code below" is a pretty crappy
328  * documentation string because it sounds like we're expecting you to read
329  * the code to understand what it does, which, while true, is really not
330  * the sort of attitude we want to be advertising.  No sir.
331  *
332  */
333 static GstFlowReturn
334 gst_file_src_fill (GstBaseSrc * basesrc, guint64 offset, guint length,
335     GstBuffer * buf)
336 {
337   GstFileSrc *src;
338   guint to_read, bytes_read;
339   int ret;
340   GstMapInfo info;
341   guint8 *data;
342
343   src = GST_FILE_SRC_CAST (basesrc);
344
345   if (G_UNLIKELY (offset != -1 && src->read_position != offset)) {
346     off_t res;
347
348     res = lseek (src->fd, offset, SEEK_SET);
349     if (G_UNLIKELY (res < 0 || res != offset))
350       goto seek_failed;
351
352     src->read_position = offset;
353   }
354
355   if (!gst_buffer_map (buf, &info, GST_MAP_WRITE))
356     goto buffer_write_fail;
357   data = info.data;
358
359   bytes_read = 0;
360   to_read = length;
361   while (to_read > 0) {
362     GST_LOG_OBJECT (src, "Reading %d bytes at offset 0x%" G_GINT64_MODIFIER "x",
363         to_read, offset + bytes_read);
364     errno = 0;
365     ret = read (src->fd, data + bytes_read, to_read);
366     if (G_UNLIKELY (ret < 0)) {
367       if (errno == EAGAIN || errno == EINTR)
368         continue;
369       goto could_not_read;
370     }
371
372     /* files should eos if they read 0 and more was requested */
373     if (G_UNLIKELY (ret == 0)) {
374       /* .. but first we should return any remaining data */
375       if (bytes_read > 0)
376         break;
377       goto eos;
378     }
379
380     to_read -= ret;
381     bytes_read += ret;
382
383     src->read_position += ret;
384   }
385
386   gst_buffer_unmap (buf, &info);
387   if (bytes_read != length)
388     gst_buffer_resize (buf, 0, bytes_read);
389
390   GST_BUFFER_OFFSET (buf) = offset;
391   GST_BUFFER_OFFSET_END (buf) = offset + bytes_read;
392
393   return GST_FLOW_OK;
394
395   /* ERROR */
396 seek_failed:
397   {
398     GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
399     return GST_FLOW_ERROR;
400   }
401 could_not_read:
402   {
403     GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL), GST_ERROR_SYSTEM);
404     gst_buffer_unmap (buf, &info);
405     gst_buffer_resize (buf, 0, 0);
406     return GST_FLOW_ERROR;
407   }
408 eos:
409   {
410     GST_DEBUG ("EOS");
411     gst_buffer_unmap (buf, &info);
412     gst_buffer_resize (buf, 0, 0);
413     return GST_FLOW_EOS;
414   }
415 buffer_write_fail:
416   {
417     GST_ELEMENT_ERROR (src, RESOURCE, WRITE, (NULL), ("Can't write to buffer"));
418     return GST_FLOW_ERROR;
419   }
420 }
421
422 static gboolean
423 gst_file_src_is_seekable (GstBaseSrc * basesrc)
424 {
425   GstFileSrc *src = GST_FILE_SRC (basesrc);
426
427   return src->seekable;
428 }
429
430 static gboolean
431 gst_file_src_get_size (GstBaseSrc * basesrc, guint64 * size)
432 {
433   struct stat stat_results;
434   GstFileSrc *src;
435
436   src = GST_FILE_SRC (basesrc);
437
438   if (!src->seekable) {
439     /* If it isn't seekable, we won't know the length (but fstat will still
440      * succeed, and wrongly say our length is zero. */
441     return FALSE;
442   }
443
444   if (fstat (src->fd, &stat_results) < 0)
445     goto could_not_stat;
446
447   *size = stat_results.st_size;
448
449   return TRUE;
450
451   /* ERROR */
452 could_not_stat:
453   {
454     return FALSE;
455   }
456 }
457
458 /* open the file, necessary to go to READY state */
459 static gboolean
460 gst_file_src_start (GstBaseSrc * basesrc)
461 {
462   GstFileSrc *src = GST_FILE_SRC (basesrc);
463   struct stat stat_results;
464
465   if (src->filename == NULL || src->filename[0] == '\0')
466     goto no_filename;
467
468   GST_INFO_OBJECT (src, "opening file %s", src->filename);
469
470   /* open the file */
471   src->fd = gst_open (src->filename, O_RDONLY | O_BINARY, 0);
472
473   if (src->fd < 0)
474     goto open_failed;
475
476   /* check if it is a regular file, otherwise bail out */
477   if (fstat (src->fd, &stat_results) < 0)
478     goto no_stat;
479
480   if (S_ISDIR (stat_results.st_mode))
481     goto was_directory;
482
483   if (S_ISSOCK (stat_results.st_mode))
484     goto was_socket;
485
486   src->read_position = 0;
487
488   /* record if it's a regular (hence seekable and lengthable) file */
489   if (S_ISREG (stat_results.st_mode))
490     src->is_regular = TRUE;
491
492   /* We need to check if the underlying file is seekable. */
493   {
494     off_t res = lseek (src->fd, 0, SEEK_END);
495
496     if (res < 0) {
497       GST_LOG_OBJECT (src, "disabling seeking, lseek failed: %s",
498           g_strerror (errno));
499       src->seekable = FALSE;
500     } else {
501       res = lseek (src->fd, 0, SEEK_SET);
502
503       if (res < 0) {
504         /* We really don't like not being able to go back to 0 */
505         src->seekable = FALSE;
506         goto lseek_wonky;
507       }
508
509       src->seekable = TRUE;
510     }
511   }
512
513   /* We can only really do seeking on regular files - for other file types, we
514    * don't know their length, so seeking isn't useful/meaningful */
515   src->seekable = src->seekable && src->is_regular;
516
517   gst_base_src_set_dynamic_size (basesrc, src->seekable);
518
519   return TRUE;
520
521   /* ERROR */
522 no_filename:
523   {
524     GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND,
525         (_("No file name specified for reading.")), (NULL));
526     goto error_exit;
527   }
528 open_failed:
529   {
530     switch (errno) {
531       case ENOENT:
532         GST_ELEMENT_ERROR (src, RESOURCE, NOT_FOUND, (NULL),
533             ("No such file \"%s\"", src->filename));
534         break;
535       default:
536         GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
537             (_("Could not open file \"%s\" for reading."), src->filename),
538             GST_ERROR_SYSTEM);
539         break;
540     }
541     goto error_exit;
542   }
543 no_stat:
544   {
545     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
546         (_("Could not get info on \"%s\"."), src->filename), (NULL));
547     goto error_close;
548   }
549 was_directory:
550   {
551     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
552         (_("\"%s\" is a directory."), src->filename), (NULL));
553     goto error_close;
554   }
555 was_socket:
556   {
557     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ,
558         (_("File \"%s\" is a socket."), src->filename), (NULL));
559     goto error_close;
560   }
561 lseek_wonky:
562   {
563     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ, (NULL),
564         ("Could not seek back to zero after seek test in file \"%s\"",
565             src->filename));
566     goto error_close;
567   }
568 error_close:
569   close (src->fd);
570 error_exit:
571   return FALSE;
572 }
573
574 /* unmap and close the file */
575 static gboolean
576 gst_file_src_stop (GstBaseSrc * basesrc)
577 {
578   GstFileSrc *src = GST_FILE_SRC (basesrc);
579
580   /* close the file */
581   close (src->fd);
582
583   /* zero out a lot of our state */
584   src->fd = 0;
585   src->is_regular = FALSE;
586
587   return TRUE;
588 }
589
590 /*** GSTURIHANDLER INTERFACE *************************************************/
591
592 static GstURIType
593 gst_file_src_uri_get_type (GType type)
594 {
595   return GST_URI_SRC;
596 }
597
598 static const gchar *const *
599 gst_file_src_uri_get_protocols (GType type)
600 {
601   static const gchar *protocols[] = { "file", NULL };
602
603   return protocols;
604 }
605
606 static gchar *
607 gst_file_src_uri_get_uri (GstURIHandler * handler)
608 {
609   GstFileSrc *src = GST_FILE_SRC (handler);
610
611   /* FIXME: make thread-safe */
612   return g_strdup (src->uri);
613 }
614
615 static gboolean
616 gst_file_src_uri_set_uri (GstURIHandler * handler, const gchar * uri,
617     GError ** err)
618 {
619   gchar *location, *hostname = NULL;
620   gboolean ret = FALSE;
621   GstFileSrc *src = GST_FILE_SRC (handler);
622
623   if (strcmp (uri, "file://") == 0) {
624     /* Special case for "file://" as this is used by some applications
625      *  to test with gst_element_make_from_uri if there's an element
626      *  that supports the URI protocol. */
627     gst_file_src_set_location (src, NULL, NULL);
628     return TRUE;
629   }
630
631   location = g_filename_from_uri (uri, &hostname, err);
632
633   if (!location || (err != NULL && *err != NULL)) {
634     GST_WARNING_OBJECT (src, "Invalid URI '%s' for filesrc: %s", uri,
635         (err != NULL && *err != NULL) ? (*err)->message : "unknown error");
636     goto beach;
637   }
638
639   if ((hostname) && (strcmp (hostname, "localhost"))) {
640     /* Only 'localhost' is permitted */
641     GST_WARNING_OBJECT (src, "Invalid hostname '%s' for filesrc", hostname);
642     g_set_error (err, GST_URI_ERROR, GST_URI_ERROR_BAD_URI,
643         "File URI with invalid hostname '%s'", hostname);
644     goto beach;
645   }
646 #ifdef G_OS_WIN32
647   /* Unfortunately, g_filename_from_uri() doesn't handle some UNC paths
648    * correctly on windows, it leaves them with an extra backslash
649    * at the start if they're of the mozilla-style file://///host/path/file
650    * form. Correct this.
651    */
652   if (location[0] == '\\' && location[1] == '\\' && location[2] == '\\')
653     memmove (location, location + 1, strlen (location + 1) + 1);
654 #endif
655
656   ret = gst_file_src_set_location (src, location, err);
657
658 beach:
659   if (location)
660     g_free (location);
661   if (hostname)
662     g_free (hostname);
663
664   return ret;
665 }
666
667 static void
668 gst_file_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
669 {
670   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
671
672   iface->get_type = gst_file_src_uri_get_type;
673   iface->get_protocols = gst_file_src_uri_get_protocols;
674   iface->get_uri = gst_file_src_uri_get_uri;
675   iface->set_uri = gst_file_src_uri_set_uri;
676 }