Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / plugins / elements / gstfdsrc.c
1 /* GStreamer
2  * Copyright (C) 1999,2000 Erik Walthinsen <omega@cse.ogi.edu>
3  *                    2000 Wim Taymans <wtay@chello.be>
4  *                    2005 Philippe Khalaf <burger@speedy.org>
5  *
6  * gstfdsrc.c:
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public
19  * License along with this library; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23 /**
24  * SECTION:element-fdsrc
25  * @see_also: #GstFdSink
26  *
27  * Read data from a unix file descriptor.
28  * 
29  * To generate data, enter some data on the console folowed by enter.
30  * The above mentioned pipeline should dump data packets to the console.
31  * 
32  * If the #GstFdSrc:timeout property is set to a value bigger than 0, fdsrc will
33  * generate an element message named
34  * <classname>&quot;GstFdSrcTimeout&quot;</classname>
35  * if no data was recieved in the given timeout.
36  * The message's structure contains one field:
37  * <itemizedlist>
38  * <listitem>
39  *   <para>
40  *   #guint64
41  *   <classname>&quot;timeout&quot;</classname>: the timeout in microseconds that
42  *   expired when waiting for data.
43  *   </para>
44  * </listitem>
45  * </itemizedlist>
46  * 
47  * <refsect2>
48  * <title>Example launch line</title>
49  * |[
50  * echo "Hello GStreamer" | gst-launch -v fdsrc ! fakesink dump=true
51  * ]| A simple pipeline to read from the standard input and dump the data
52  * with a fakesink as hex ascii block.
53  * </refsect2>
54  * 
55  * Last reviewed on 2008-06-20 (0.10.21)
56  */
57
58 #ifdef HAVE_CONFIG_H
59 #  include "config.h"
60 #endif
61 #include "gst/gst_private.h"
62
63 #include <sys/types.h>
64
65 #ifdef G_OS_WIN32
66 #include <io.h>                 /* lseek, open, close, read */
67 #undef lseek
68 #define lseek _lseeki64
69 #undef off_t
70 #define off_t guint64
71 #endif
72
73 #include <sys/stat.h>
74 #ifdef HAVE_SYS_SOCKET_H
75 #include <sys/socket.h>
76 #endif
77 #include <fcntl.h>
78 #include <stdio.h>
79 #ifdef HAVE_UNISTD_H
80 #include <unistd.h>
81 #endif
82 #ifdef _MSC_VER
83 #undef stat
84 #define stat _stat
85 #define fstat _fstat
86 #define S_ISREG(m)      (((m)&S_IFREG)==S_IFREG)
87 #endif
88 #include <stdlib.h>
89 #include <errno.h>
90
91 #include "gstfdsrc.h"
92
93 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
94     GST_PAD_SRC,
95     GST_PAD_ALWAYS,
96     GST_STATIC_CAPS_ANY);
97
98 GST_DEBUG_CATEGORY_STATIC (gst_fd_src_debug);
99 #define GST_CAT_DEFAULT gst_fd_src_debug
100
101 #define DEFAULT_FD              0
102 #define DEFAULT_TIMEOUT         0
103
104 enum
105 {
106   PROP_0,
107
108   PROP_FD,
109   PROP_TIMEOUT,
110
111   PROP_LAST
112 };
113
114 static void gst_fd_src_uri_handler_init (gpointer g_iface, gpointer iface_data);
115
116 #define _do_init \
117   G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, gst_fd_src_uri_handler_init); \
118   GST_DEBUG_CATEGORY_INIT (gst_fd_src_debug, "fdsrc", 0, "fdsrc element");
119 #define gst_fd_src_parent_class parent_class
120 G_DEFINE_TYPE_WITH_CODE (GstFdSrc, gst_fd_src, GST_TYPE_PUSH_SRC, _do_init);
121
122 static void gst_fd_src_set_property (GObject * object, guint prop_id,
123     const GValue * value, GParamSpec * pspec);
124 static void gst_fd_src_get_property (GObject * object, guint prop_id,
125     GValue * value, GParamSpec * pspec);
126 static void gst_fd_src_dispose (GObject * obj);
127
128 static gboolean gst_fd_src_start (GstBaseSrc * bsrc);
129 static gboolean gst_fd_src_stop (GstBaseSrc * bsrc);
130 static gboolean gst_fd_src_unlock (GstBaseSrc * bsrc);
131 static gboolean gst_fd_src_unlock_stop (GstBaseSrc * bsrc);
132 static gboolean gst_fd_src_is_seekable (GstBaseSrc * bsrc);
133 static gboolean gst_fd_src_get_size (GstBaseSrc * src, guint64 * size);
134 static gboolean gst_fd_src_do_seek (GstBaseSrc * src, GstSegment * segment);
135 static gboolean gst_fd_src_query (GstBaseSrc * src, GstQuery * query);
136
137 static GstFlowReturn gst_fd_src_create (GstPushSrc * psrc, GstBuffer ** outbuf);
138
139 static void
140 gst_fd_src_class_init (GstFdSrcClass * klass)
141 {
142   GObjectClass *gobject_class;
143   GstElementClass *gstelement_class;
144   GstBaseSrcClass *gstbasesrc_class;
145   GstPushSrcClass *gstpush_src_class;
146
147   gobject_class = G_OBJECT_CLASS (klass);
148   gstelement_class = GST_ELEMENT_CLASS (klass);
149   gstbasesrc_class = GST_BASE_SRC_CLASS (klass);
150   gstpush_src_class = GST_PUSH_SRC_CLASS (klass);
151
152   gobject_class->set_property = gst_fd_src_set_property;
153   gobject_class->get_property = gst_fd_src_get_property;
154   gobject_class->dispose = gst_fd_src_dispose;
155
156   g_object_class_install_property (gobject_class, PROP_FD,
157       g_param_spec_int ("fd", "fd", "An open file descriptor to read from",
158           0, G_MAXINT, DEFAULT_FD, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
159   /**
160    * GstFdSrc:timeout
161    *
162    * Post a message after timeout microseconds
163    *
164    * Since: 0.10.21
165    */
166   g_object_class_install_property (G_OBJECT_CLASS (klass), PROP_TIMEOUT,
167       g_param_spec_uint64 ("timeout", "Timeout",
168           "Post a message after timeout microseconds (0 = disabled)", 0,
169           G_MAXUINT64, DEFAULT_TIMEOUT,
170           G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
171
172   gst_element_class_set_details_simple (gstelement_class,
173       "Filedescriptor Source",
174       "Source/File",
175       "Read from a file descriptor", "Erik Walthinsen <omega@cse.ogi.edu>");
176   gst_element_class_add_pad_template (gstelement_class,
177       gst_static_pad_template_get (&srctemplate));
178
179   gstbasesrc_class->start = GST_DEBUG_FUNCPTR (gst_fd_src_start);
180   gstbasesrc_class->stop = GST_DEBUG_FUNCPTR (gst_fd_src_stop);
181   gstbasesrc_class->unlock = GST_DEBUG_FUNCPTR (gst_fd_src_unlock);
182   gstbasesrc_class->unlock_stop = GST_DEBUG_FUNCPTR (gst_fd_src_unlock_stop);
183   gstbasesrc_class->is_seekable = GST_DEBUG_FUNCPTR (gst_fd_src_is_seekable);
184   gstbasesrc_class->get_size = GST_DEBUG_FUNCPTR (gst_fd_src_get_size);
185   gstbasesrc_class->do_seek = GST_DEBUG_FUNCPTR (gst_fd_src_do_seek);
186   gstbasesrc_class->query = GST_DEBUG_FUNCPTR (gst_fd_src_query);
187
188   gstpush_src_class->create = GST_DEBUG_FUNCPTR (gst_fd_src_create);
189 }
190
191 static void
192 gst_fd_src_init (GstFdSrc * fdsrc)
193 {
194   fdsrc->new_fd = DEFAULT_FD;
195   fdsrc->seekable_fd = FALSE;
196   fdsrc->fd = -1;
197   fdsrc->size = -1;
198   fdsrc->timeout = DEFAULT_TIMEOUT;
199   fdsrc->uri = g_strdup_printf ("fd://0");
200   fdsrc->curoffset = 0;
201 }
202
203 static void
204 gst_fd_src_dispose (GObject * obj)
205 {
206   GstFdSrc *src = GST_FD_SRC (obj);
207
208   g_free (src->uri);
209   src->uri = NULL;
210
211   G_OBJECT_CLASS (parent_class)->dispose (obj);
212 }
213
214 static void
215 gst_fd_src_update_fd (GstFdSrc * src, guint64 size)
216 {
217   struct stat stat_results;
218
219   GST_DEBUG_OBJECT (src, "fdset %p, old_fd %d, new_fd %d", src->fdset, src->fd,
220       src->new_fd);
221
222   /* we need to always update the fdset since it may not have existed when
223    * gst_fd_src_update_fd () was called earlier */
224   if (src->fdset != NULL) {
225     GstPollFD fd = GST_POLL_FD_INIT;
226
227     if (src->fd >= 0) {
228       fd.fd = src->fd;
229       /* this will log a harmless warning, if it was never added */
230       gst_poll_remove_fd (src->fdset, &fd);
231     }
232
233     fd.fd = src->new_fd;
234     gst_poll_add_fd (src->fdset, &fd);
235     gst_poll_fd_ctl_read (src->fdset, &fd, TRUE);
236   }
237
238
239   if (src->fd != src->new_fd) {
240     GST_INFO_OBJECT (src, "Updating to fd %d", src->new_fd);
241
242     src->fd = src->new_fd;
243
244     GST_INFO_OBJECT (src, "Setting size to fd %" G_GUINT64_FORMAT, size);
245     src->size = size;
246
247     g_free (src->uri);
248     src->uri = g_strdup_printf ("fd://%d", src->fd);
249
250     if (fstat (src->fd, &stat_results) < 0)
251       goto not_seekable;
252
253     if (!S_ISREG (stat_results.st_mode))
254       goto not_seekable;
255
256     /* Try a seek of 0 bytes offset to check for seekability */
257     if (lseek (src->fd, 0, SEEK_CUR) < 0)
258       goto not_seekable;
259
260     GST_INFO_OBJECT (src, "marking fd %d as seekable", src->fd);
261     src->seekable_fd = TRUE;
262   }
263   return;
264
265 not_seekable:
266   {
267     GST_INFO_OBJECT (src, "marking fd %d as NOT seekable", src->fd);
268     src->seekable_fd = FALSE;
269   }
270 }
271
272 static gboolean
273 gst_fd_src_start (GstBaseSrc * bsrc)
274 {
275   GstFdSrc *src = GST_FD_SRC (bsrc);
276
277   src->curoffset = 0;
278
279   if ((src->fdset = gst_poll_new (TRUE)) == NULL)
280     goto socket_pair;
281
282   gst_fd_src_update_fd (src, -1);
283
284   return TRUE;
285
286   /* ERRORS */
287 socket_pair:
288   {
289     GST_ELEMENT_ERROR (src, RESOURCE, OPEN_READ_WRITE, (NULL),
290         GST_ERROR_SYSTEM);
291     return FALSE;
292   }
293 }
294
295 static gboolean
296 gst_fd_src_stop (GstBaseSrc * bsrc)
297 {
298   GstFdSrc *src = GST_FD_SRC (bsrc);
299
300   if (src->fdset) {
301     gst_poll_free (src->fdset);
302     src->fdset = NULL;
303   }
304
305   return TRUE;
306 }
307
308 static gboolean
309 gst_fd_src_unlock (GstBaseSrc * bsrc)
310 {
311   GstFdSrc *src = GST_FD_SRC (bsrc);
312
313   GST_LOG_OBJECT (src, "Flushing");
314   GST_OBJECT_LOCK (src);
315   gst_poll_set_flushing (src->fdset, TRUE);
316   GST_OBJECT_UNLOCK (src);
317
318   return TRUE;
319 }
320
321 static gboolean
322 gst_fd_src_unlock_stop (GstBaseSrc * bsrc)
323 {
324   GstFdSrc *src = GST_FD_SRC (bsrc);
325
326   GST_LOG_OBJECT (src, "No longer flushing");
327   GST_OBJECT_LOCK (src);
328   gst_poll_set_flushing (src->fdset, FALSE);
329   GST_OBJECT_UNLOCK (src);
330
331   return TRUE;
332 }
333
334 static void
335 gst_fd_src_set_property (GObject * object, guint prop_id, const GValue * value,
336     GParamSpec * pspec)
337 {
338   GstFdSrc *src = GST_FD_SRC (object);
339
340   switch (prop_id) {
341     case PROP_FD:
342       src->new_fd = g_value_get_int (value);
343
344       /* If state is ready or below, update the current fd immediately
345        * so it is reflected in get_properties and uri */
346       GST_OBJECT_LOCK (object);
347       if (GST_STATE (GST_ELEMENT (src)) <= GST_STATE_READY) {
348         GST_DEBUG_OBJECT (src, "state ready or lower, updating to use new fd");
349         gst_fd_src_update_fd (src, -1);
350       } else {
351         GST_DEBUG_OBJECT (src, "state above ready, not updating to new fd yet");
352       }
353       GST_OBJECT_UNLOCK (object);
354       break;
355     case PROP_TIMEOUT:
356       src->timeout = g_value_get_uint64 (value);
357       GST_DEBUG_OBJECT (src, "poll timeout set to %" GST_TIME_FORMAT,
358           GST_TIME_ARGS (src->timeout));
359       break;
360     default:
361       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
362       break;
363   }
364 }
365
366 static void
367 gst_fd_src_get_property (GObject * object, guint prop_id, GValue * value,
368     GParamSpec * pspec)
369 {
370   GstFdSrc *src = GST_FD_SRC (object);
371
372   switch (prop_id) {
373     case PROP_FD:
374       g_value_set_int (value, src->fd);
375       break;
376     case PROP_TIMEOUT:
377       g_value_set_uint64 (value, src->timeout);
378       break;
379     default:
380       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
381       break;
382   }
383 }
384
385 static GstFlowReturn
386 gst_fd_src_create (GstPushSrc * psrc, GstBuffer ** outbuf)
387 {
388   GstFdSrc *src;
389   GstBuffer *buf;
390   gssize readbytes;
391   guint blocksize;
392   GstClockTime timeout;
393   guint8 *data;
394   gsize maxsize;
395
396 #ifndef HAVE_WIN32
397   gboolean try_again;
398   gint retval;
399 #endif
400
401   src = GST_FD_SRC (psrc);
402
403   if (src->timeout > 0) {
404     timeout = src->timeout * GST_USECOND;
405   } else {
406     timeout = GST_CLOCK_TIME_NONE;
407   }
408
409 #ifndef HAVE_WIN32
410   do {
411     try_again = FALSE;
412
413     GST_LOG_OBJECT (src, "doing poll, timeout %" GST_TIME_FORMAT,
414         GST_TIME_ARGS (src->timeout));
415
416     retval = gst_poll_wait (src->fdset, timeout);
417     GST_LOG_OBJECT (src, "poll returned %d", retval);
418
419     if (G_UNLIKELY (retval == -1)) {
420       if (errno == EINTR || errno == EAGAIN) {
421         /* retry if interrupted */
422         try_again = TRUE;
423       } else if (errno == EBUSY) {
424         goto stopped;
425       } else {
426         goto poll_error;
427       }
428     } else if (G_UNLIKELY (retval == 0)) {
429       try_again = TRUE;
430       /* timeout, post element message */
431       gst_element_post_message (GST_ELEMENT_CAST (src),
432           gst_message_new_element (GST_OBJECT_CAST (src),
433               gst_structure_new ("GstFdSrcTimeout",
434                   "timeout", G_TYPE_UINT64, src->timeout, NULL)));
435     }
436   } while (G_UNLIKELY (try_again));     /* retry if interrupted or timeout */
437 #endif
438
439   blocksize = GST_BASE_SRC (src)->blocksize;
440
441   /* create the buffer */
442   buf = gst_buffer_new_and_alloc (blocksize);
443   if (G_UNLIKELY (buf == NULL))
444     goto alloc_failed;
445
446   data = gst_buffer_map (buf, NULL, &maxsize, GST_MAP_WRITE);
447
448   do {
449     readbytes = read (src->fd, data, blocksize);
450     GST_LOG_OBJECT (src, "read %" G_GSSIZE_FORMAT, readbytes);
451   } while (readbytes == -1 && errno == EINTR);  /* retry if interrupted */
452
453   if (readbytes < 0)
454     goto read_error;
455
456   gst_buffer_unmap (buf, data, readbytes);
457
458   if (readbytes == 0)
459     goto eos;
460
461   GST_BUFFER_OFFSET (buf) = src->curoffset;
462   GST_BUFFER_TIMESTAMP (buf) = GST_CLOCK_TIME_NONE;
463   src->curoffset += readbytes;
464
465   GST_LOG_OBJECT (psrc, "Read buffer of size %" G_GSSIZE_FORMAT, readbytes);
466
467   /* we're done, return the buffer */
468   *outbuf = buf;
469
470   return GST_FLOW_OK;
471
472   /* ERRORS */
473 #ifndef HAVE_WIN32
474 poll_error:
475   {
476     GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
477         ("poll on file descriptor: %s.", g_strerror (errno)));
478     GST_DEBUG_OBJECT (psrc, "Error during poll");
479     return GST_FLOW_ERROR;
480   }
481 stopped:
482   {
483     GST_DEBUG_OBJECT (psrc, "Poll stopped");
484     return GST_FLOW_WRONG_STATE;
485   }
486 #endif
487 alloc_failed:
488   {
489     GST_ERROR_OBJECT (src, "Failed to allocate %u bytes", blocksize);
490     return GST_FLOW_ERROR;
491   }
492 eos:
493   {
494     GST_DEBUG_OBJECT (psrc, "Read 0 bytes. EOS.");
495     gst_buffer_unref (buf);
496     return GST_FLOW_UNEXPECTED;
497   }
498 read_error:
499   {
500     GST_ELEMENT_ERROR (src, RESOURCE, READ, (NULL),
501         ("read on file descriptor: %s.", g_strerror (errno)));
502     GST_DEBUG_OBJECT (psrc, "Error reading from fd");
503     gst_buffer_unmap (buf, data, 0);
504     gst_buffer_unref (buf);
505     return GST_FLOW_ERROR;
506   }
507 }
508
509 static gboolean
510 gst_fd_src_query (GstBaseSrc * basesrc, GstQuery * query)
511 {
512   gboolean ret = FALSE;
513   GstFdSrc *src = GST_FD_SRC (basesrc);
514
515   switch (GST_QUERY_TYPE (query)) {
516     case GST_QUERY_URI:
517       gst_query_set_uri (query, src->uri);
518       ret = TRUE;
519       break;
520     default:
521       ret = FALSE;
522       break;
523   }
524
525   if (!ret)
526     ret = GST_BASE_SRC_CLASS (parent_class)->query (basesrc, query);
527
528   return ret;
529 }
530
531 static gboolean
532 gst_fd_src_is_seekable (GstBaseSrc * bsrc)
533 {
534   GstFdSrc *src = GST_FD_SRC (bsrc);
535
536   return src->seekable_fd;
537 }
538
539 static gboolean
540 gst_fd_src_get_size (GstBaseSrc * bsrc, guint64 * size)
541 {
542   GstFdSrc *src = GST_FD_SRC (bsrc);
543   struct stat stat_results;
544
545   if (src->size != -1) {
546     *size = src->size;
547     return TRUE;
548   }
549
550   if (!src->seekable_fd) {
551     /* If it isn't seekable, we won't know the length (but fstat will still
552      * succeed, and wrongly say our length is zero. */
553     return FALSE;
554   }
555
556   if (fstat (src->fd, &stat_results) < 0)
557     goto could_not_stat;
558
559   *size = stat_results.st_size;
560
561   return TRUE;
562
563   /* ERROR */
564 could_not_stat:
565   {
566     return FALSE;
567   }
568 }
569
570 static gboolean
571 gst_fd_src_do_seek (GstBaseSrc * bsrc, GstSegment * segment)
572 {
573   gint res;
574   gint64 offset;
575   GstFdSrc *src = GST_FD_SRC (bsrc);
576
577   offset = segment->start;
578
579   /* No need to seek to the current position */
580   if (offset == src->curoffset)
581     return TRUE;
582
583   res = lseek (src->fd, offset, SEEK_SET);
584   if (G_UNLIKELY (res < 0 || res != offset))
585     goto seek_failed;
586
587   segment->position = segment->start;
588   segment->time = segment->start;
589
590   return TRUE;
591
592 seek_failed:
593   GST_DEBUG_OBJECT (src, "lseek returned %" G_GINT64_FORMAT, offset);
594   return FALSE;
595 }
596
597 /*** GSTURIHANDLER INTERFACE *************************************************/
598
599 static GstURIType
600 gst_fd_src_uri_get_type (void)
601 {
602   return GST_URI_SRC;
603 }
604
605 static gchar **
606 gst_fd_src_uri_get_protocols (void)
607 {
608   static gchar *protocols[] = { (char *) "fd", NULL };
609
610   return protocols;
611 }
612
613 static const gchar *
614 gst_fd_src_uri_get_uri (GstURIHandler * handler)
615 {
616   GstFdSrc *src = GST_FD_SRC (handler);
617
618   return src->uri;
619 }
620
621 static gboolean
622 gst_fd_src_uri_set_uri (GstURIHandler * handler, const gchar * uri)
623 {
624   gchar *protocol, *q;
625   GstFdSrc *src = GST_FD_SRC (handler);
626   gint fd;
627   guint64 size = -1;
628
629   GST_INFO_OBJECT (src, "checking uri %s", uri);
630
631   protocol = gst_uri_get_protocol (uri);
632   if (strcmp (protocol, "fd") != 0) {
633     g_free (protocol);
634     return FALSE;
635   }
636   g_free (protocol);
637
638   if (sscanf (uri, "fd://%d", &fd) != 1 || fd < 0)
639     return FALSE;
640
641   if ((q = g_strstr_len (uri, -1, "?"))) {
642     gchar *sp;
643
644     GST_INFO_OBJECT (src, "found ?");
645
646     if ((sp = g_strstr_len (q, -1, "size="))) {
647       if (sscanf (sp, "size=%" G_GUINT64_FORMAT, &size) != 1) {
648         GST_INFO_OBJECT (src, "parsing size failed");
649         size = -1;
650       } else {
651         GST_INFO_OBJECT (src, "found size %" G_GUINT64_FORMAT, size);
652       }
653     }
654   }
655
656   src->new_fd = fd;
657
658   GST_OBJECT_LOCK (src);
659   if (GST_STATE (GST_ELEMENT (src)) <= GST_STATE_READY) {
660     gst_fd_src_update_fd (src, size);
661   }
662   GST_OBJECT_UNLOCK (src);
663
664   return TRUE;
665 }
666
667 static void
668 gst_fd_src_uri_handler_init (gpointer g_iface, gpointer iface_data)
669 {
670   GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
671
672   iface->get_type = gst_fd_src_uri_get_type;
673   iface->get_protocols = gst_fd_src_uri_get_protocols;
674   iface->get_uri = gst_fd_src_uri_get_uri;
675   iface->set_uri = gst_fd_src_uri_set_uri;
676 }