FCL/sf/mw/gstreamer: comparison gstreamer

equal deleted inserted replaced

-:567bb019e3e3
+:7e817e7e631c
 #include <sys/poll.h>
 #endif
 #include <sys/time.h>
 #endif
-#include "gst_private.h"
 #include <sys/types.h>
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #include <sys/socket.h>
 #endif
 /* OS/X needs this because of bad headers */
 #include <string.h>
+#include "gst_private.h"
 #include "gstpoll.h"
 #ifdef __SYMBIAN32__
 #include <glib_global.h>
 #endif
 #ifndef G_OS_WIN32
 /* the poll/select call is also performed on a control socket, that way
 * we can send special commands to control it
 */
-/* FIXME: Shouldn't we check or return the return value
+#define SEND_COMMAND(set, command)                   \
-* of write()?
-*/
-#define SEND_COMMAND(set, command, result)           \
 G_STMT_START {                                       \
 unsigned char c = command;                         \
-result = write (set->control_write_fd.fd, &c, 1);  \
+write (set->control_write_fd.fd, &c, 1);           \
-if (result > 0)                                    \
-set->control_pending++;                          \
 } G_STMT_END
-#define READ_COMMAND(set, command, res)                \
+#define READ_COMMAND(set, command, res)              \
-G_STMT_START {                                         \
+G_STMT_START {                                       \
-if (set->control_pending > 0) {                      \
+res = read (set->control_read_fd.fd, &command, 1); \
-res = read (set->control_read_fd.fd, &command, 1); \
-if (res == 1)                                      \
-set->control_pending--;                          \
-} else                                               \
-res = 0;                                           \
 } G_STMT_END
 #define GST_POLL_CMD_WAKEUP  'W'        /* restart the poll/select call */
 #else /* G_OS_WIN32 */
 #ifndef G_OS_WIN32
 GstPollFD control_read_fd;
 GstPollFD control_write_fd;
 #else
 GArray *active_fds_ignored;
 GArray *events;
 GArray *active_events;
 HANDLE wakeup_event;
 #endif
 gboolean controllable;
 gboolean new_controllable;
-guint waiting;
+gboolean waiting;
-guint control_pending;
 gboolean flushing;
-gboolean timer;
 };
 static gint
 find_index (GArray * array, GstPollFD * fd)
 {
 FD_ZERO (readfds);
 FD_ZERO (writefds);
 g_mutex_lock (set->lock);
 for (i = 0; i < set->active_fds->len; i++) {
 #ifndef __SYMBIAN32__
 struct pollfd *pfd = &g_array_index (set->fds, struct pollfd, i);
 #else
 GPollFD *pfd = &g_array_index (set->fds, GPollFD, i);
 if (pfd->fd > max_fd)
 max_fd = pfd->fd;
 }
 }
 g_mutex_unlock (set->lock);
 return max_fd;
 }
 static void
 GstPoll *gst_poll_new (gboolean controllable)
 {
 GstPoll *nset;
-nset = g_slice_new0 (GstPoll);
+nset = g_new0 (GstPoll, 1);
 nset->lock = g_mutex_new ();
 #ifndef G_OS_WIN32
 nset->mode = GST_POLL_MODE_AUTO;
 //rj nset->fds = g_array_new (FALSE, FALSE, sizeof (struct pollfd));
 //rj nset->active_fds = g_array_new (FALSE, FALSE, sizeof (struct pollfd));
 return NULL;
 }
 }
 /**
-* gst_poll_new_timer:
-*
-* Create a new poll object that can be used for scheduling cancellable
-* timeouts.
-*
-* A timeout is performed with gst_poll_wait(). Multiple timeouts can be
-* performed from different threads.
-*
-* Returns: a new #GstPoll, or %NULL in case of an error. Free with
-* gst_poll_free().
-*
-* Since: 0.10.23
-*/
-#ifdef __SYMBIAN32__
-EXPORT_C
-#endif
-GstPoll *
-gst_poll_new_timer (void)
-{
-GstPoll *poll;
-/* make a new controllable poll set */
-if (!(poll = gst_poll_new (TRUE)))
-goto done;
-/* we are a timer */
-poll->timer = TRUE;
-done:
-return poll;
-}
-/**
 * gst_poll_free:
 * @set: a file descriptor set.
 *
 * Free a file descriptor set.
 *
 #endif
 g_array_free (set->active_fds, TRUE);
 g_array_free (set->fds, TRUE);
 g_mutex_free (set->lock);
-g_slice_free (GstPoll, set);
+g_free (set);
 }
 /**
 * gst_poll_fd_init:
 * @fd: a #GstPollFD
 if (active)
 pfd->events |= POLLOUT;
 else
 pfd->events &= ~POLLOUT;
 #else
-gst_poll_update_winsock_event_mask (set, idx, FD_WRITE | FD_CONNECT,
+gst_poll_update_winsock_event_mask (set, idx, FD_WRITE, active);
-active);
 #endif
 }
 g_mutex_unlock (set->lock);
 * Since: 0.10.18
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
+gboolean gst_poll_fd_ctl_read (GstPoll * set, GstPollFD * fd, gboolean active)
-gboolean
-gst_poll_fd_ctl_read (GstPoll * set, GstPollFD * fd, gboolean active)
 {
 gboolean ret;
 g_return_val_if_fail (set != NULL, FALSE);
 g_return_val_if_fail (fd != NULL, FALSE);
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-void
+void gst_poll_fd_ignored (GstPoll * set, GstPollFD * fd)
-gst_poll_fd_ignored (GstPoll * set, GstPollFD * fd)
 {
 #ifdef G_OS_WIN32
 gint idx;
 g_return_if_fail (set != NULL);
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-gboolean
+gboolean gst_poll_fd_has_closed (const GstPoll * set, GstPollFD * fd)
-gst_poll_fd_has_closed (const GstPoll * set, GstPollFD * fd)
 {
 gboolean res = FALSE;
 gint idx;
 g_return_val_if_fail (set != NULL, FALSE);
 WinsockFd *wfd = &g_array_index (set->active_fds, WinsockFd, idx);
 res = (wfd->events.iErrorCode[FD_CLOSE_BIT] != 0) ||
 (wfd->events.iErrorCode[FD_READ_BIT] != 0) ||
 (wfd->events.iErrorCode[FD_WRITE_BIT] != 0) ||
-(wfd->events.iErrorCode[FD_ACCEPT_BIT] != 0) ||
+(wfd->events.iErrorCode[FD_ACCEPT_BIT] != 0);
-(wfd->events.iErrorCode[FD_CONNECT_BIT] != 0);
 #endif
 }
 g_mutex_unlock (set->lock);
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-gboolean
+gboolean gst_poll_fd_can_read (const GstPoll * set, GstPollFD * fd)
-gst_poll_fd_can_read (const GstPoll * set, GstPollFD * fd)
 {
 gboolean res = FALSE;
 g_return_val_if_fail (set != NULL, FALSE);
 g_return_val_if_fail (fd != NULL, FALSE);
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-gboolean
+gboolean gst_poll_fd_can_write (const GstPoll * set, GstPollFD * fd)
-gst_poll_fd_can_write (const GstPoll * set, GstPollFD * fd)
 {
 gboolean res = FALSE;
 gint idx;
 g_return_val_if_fail (set != NULL, FALSE);
 * @timeout: a timeout in nanoseconds.
 *
 * Wait for activity on the file descriptors in @set. This function waits up to
 * the specified @timeout.  A timeout of #GST_CLOCK_TIME_NONE waits forever.
 *
-* For #GstPoll objects created with gst_poll_new(), this function can only be
+* When this function is called from multiple threads, -1 will be returned with
-* called from a single thread at a time.  If called from multiple threads,
+* errno set to EPERM.
-* -1 will be returned with errno set to EPERM.
-*
-* This is not true for timer #GstPoll objects created with
-* gst_poll_new_timer(), where it is allowed to have multiple threads waiting
-* simultaneously.
 *
 * Returns: The number of #GstPollFD in @set that have activity or 0 when no
 * activity was detected after @timeout. If an error occurs, -1 is returned
 * and errno is set.
 *
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-gint
+gint gst_poll_wait (GstPoll * set, GstClockTime timeout)
-gst_poll_wait (GstPoll * set, GstClockTime timeout)
 {
 gboolean restarting;
-int res;
+int res = -1;
 g_return_val_if_fail (set != NULL, -1);
 g_mutex_lock (set->lock);
-/* we cannot wait from multiple threads unless we are a timer */
+/* we cannot wait from multiple threads */
-if (G_UNLIKELY (set->waiting > 0 && !set->timer))
+if (set->waiting)
 goto already_waiting;
 /* flushing, exit immediatly */
-if (G_UNLIKELY (set->flushing))
+if (set->flushing)
 goto flushing;
-/* add one more waiter */
+set->waiting = TRUE;
-set->waiting++;
 do {
 GstPollMode mode;
 res = -1;
 GST_TIME_TO_TIMEVAL (timeout, tv);
 tvptr = &tv;
 } else {
 tvptr = NULL;
 }
+//temporary  fix for multifdsink
 FD_ZERO(&excepfds);
 if( max_fd != -1)
 {
 if( ! FD_ISSET(max_fd,&readfds))
 }
 }
 g_mutex_lock (set->lock);
-if (!set->timer)
+gst_poll_check_ctrl_commands (set, res, &restarting);
-gst_poll_check_ctrl_commands (set, res, &restarting);
 /* update the controllable state if needed */
 set->controllable = set->new_controllable;
-if (G_UNLIKELY (set->flushing)) {
+if (set->flushing) {
 /* we got woken up and we are flushing, we need to stop */
 errno = EBUSY;
 res = -1;
 break;
 }
-} while (G_UNLIKELY (restarting));
+} while (restarting);
-set->waiting--;
+set->waiting = FALSE;
 g_mutex_unlock (set->lock);
 return res;
 return -1;
 }
 #ifdef G_OS_WIN32
 winsock_error:
 {
-set->waiting--;
 g_mutex_unlock (set->lock);
 return -1;
 }
 #endif
 }
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-gboolean
+gboolean gst_poll_set_controllable (GstPoll * set, gboolean controllable)
-gst_poll_set_controllable (GstPoll * set, gboolean controllable)
 {
 g_return_val_if_fail (set != NULL, FALSE);
 g_mutex_lock (set->lock);
 gint control_sock[2];
 /* rj
 if (socketpair (PF_UNIX, SOCK_STREAM, 0, control_sock) < 0)
 goto no_socket_pair;
 */
-pipe(control_sock);
 fcntl (control_sock[0], F_SETFL, O_NONBLOCK);
 fcntl (control_sock[1], F_SETFL, O_NONBLOCK);
 set->control_read_fd.fd = control_sock[0];
 set->control_write_fd.fd = control_sock[1];
 gst_poll_fd_ctl_read_unlocked (set, &set->control_read_fd, controllable);
 #endif
 /* delay the change of the controllable state if we are waiting */
 set->new_controllable = controllable;
-if (set->waiting == 0)
+if (!set->waiting)
 set->controllable = controllable;
 g_mutex_unlock (set->lock);
 return TRUE;
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-void
+void gst_poll_restart (GstPoll * set)
-gst_poll_restart (GstPoll * set)
 {
 g_return_if_fail (set != NULL);
 g_mutex_lock (set->lock);
-if (set->controllable && set->waiting > 0) {
+if (set->controllable && set->waiting) {
 #ifndef G_OS_WIN32
-gint result;
 /* if we are waiting, we can send the command, else we do not have to
 * bother, future calls will automatically pick up the new fdset */
-SEND_COMMAND (set, GST_POLL_CMD_WAKEUP, result);
+SEND_COMMAND (set, GST_POLL_CMD_WAKEUP);
 #else
 SetEvent (set->wakeup_event);
 #endif
 }
 */
 #ifdef __SYMBIAN32__
 EXPORT_C
 #endif
-void
+void gst_poll_set_flushing (GstPoll * set, gboolean flushing)
-gst_poll_set_flushing (GstPoll * set, gboolean flushing)
 {
 g_return_if_fail (set != NULL);
 g_mutex_lock (set->lock);
 /* update the new state first */
 set->flushing = flushing;
-if (flushing && set->controllable && set->waiting > 0) {
+if (flushing && set->controllable && set->waiting) {
 /* we are flushing, controllable and waiting, wake up the waiter. When we
 * stop the flushing operation we don't clear the wakeup fd here, this will
 * happen in the _wait() thread. */
 #ifndef G_OS_WIN32
-gint result;
+SEND_COMMAND (set, GST_POLL_CMD_WAKEUP);
-SEND_COMMAND (set, GST_POLL_CMD_WAKEUP, result);
 #else
 SetEvent (set->wakeup_event);
 #endif
 }
 g_mutex_unlock (set->lock);
 }
-/**
-* gst_poll_write_control:
-* @set: a #GstPoll.
-*
-* Write a byte to the control socket of the controllable @set.
-* This function is mostly useful for timer #GstPoll objects created with
-* gst_poll_new_timer().
-*
-* It will make any current and future gst_poll_wait() function return with
-* 1, meaning the control socket is set. After an equal amount of calls to
-* gst_poll_read_control() have been performed, calls to gst_poll_wait() will
-* block again until their timeout expired.
-*
-* Returns: %TRUE on success. %FALSE when @set is not controllable or when the
-* byte could not be written.
-*
-* Since: 0.10.23
-*/
-#ifdef __SYMBIAN32__
-EXPORT_C
-#endif
-gboolean
-gst_poll_write_control (GstPoll * set)
-{
-gboolean res = FALSE;
-g_return_val_if_fail (set != NULL, FALSE);
-g_mutex_lock (set->lock);
-if (set->controllable) {
-#ifndef G_OS_WIN32
-gint result;
-SEND_COMMAND (set, GST_POLL_CMD_WAKEUP, result);
-res = (result > 0);
-#else
-res = SetEvent (set->wakeup_event);
-#endif
-}
-g_mutex_unlock (set->lock);
-return res;
-}
-/**
-* gst_poll_read_control:
-* @set: a #GstPoll.
-*
-* Read a byte from the control socket of the controllable @set.
-* This function is mostly useful for timer #GstPoll objects created with
-* gst_poll_new_timer().
-*
-* Returns: %TRUE on success. %FALSE when @set is not controllable or when there
-* was no byte to read.
-*
-* Since: 0.10.23
-*/
-#ifdef __SYMBIAN32__
-EXPORT_C
-#endif
-gboolean
-gst_poll_read_control (GstPoll * set)
-{
-gboolean res = FALSE;
-g_return_val_if_fail (set != NULL, FALSE);
-g_mutex_lock (set->lock);
-if (set->controllable) {
-#ifndef G_OS_WIN32
-guchar cmd;
-gint result;
-READ_COMMAND (set, cmd, result);
-res = (result > 0);
-#else
-res = ResetEvent (set->wakeup_event);
-#endif
-}
-g_mutex_unlock (set->lock);
-return res;
-}

branch	RCL_3
changeset 30	7e817e7e631c
parent 29	567bb019e3e3