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