/* GStreamer * Copyright (C) 1999,2000 Erik Walthinsen * 2000 Wim Taymans * * gstpipefilter.c: * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include //#define DEBUG_ENABLED #include "gstpipefilter.h" GstElementDetails gst_pipefilter_details = { "Pipefilter", "Filter", "Pass data without modification", VERSION, "Erik Walthinsen \n" "Wim Taymans ", "(C) 1999", }; /* Pipefilter signals and args */ enum { /* FILL ME */ LAST_SIGNAL }; enum { ARG_0, ARG_COMMAND }; static void gst_pipefilter_class_init (GstPipefilterClass *klass); static void gst_pipefilter_init (GstPipefilter *pipefilter); static void gst_pipefilter_set_arg (GtkObject *object, GtkArg *arg, guint id); static void gst_pipefilter_get_arg (GtkObject *object, GtkArg *arg, guint id); static GstBuffer* gst_pipefilter_get (GstPad *pad); static void gst_pipefilter_chain (GstPad *pad, GstBuffer *buf); static gboolean gst_pipefilter_handle_eos (GstPad *pad); static GstElementStateReturn gst_pipefilter_change_state (GstElement *element); static GstElementClass *parent_class = NULL; //static guint gst_pipefilter_signals[LAST_SIGNAL] = { 0 }; GtkType gst_pipefilter_get_type (void) { static GtkType pipefilter_type = 0; if (!pipefilter_type) { static const GtkTypeInfo pipefilter_info = { "GstPipefilter", sizeof(GstPipefilter), sizeof(GstPipefilterClass), (GtkClassInitFunc)gst_pipefilter_class_init, (GtkObjectInitFunc)gst_pipefilter_init, (GtkArgSetFunc)gst_pipefilter_set_arg, (GtkArgGetFunc)gst_pipefilter_get_arg, (GtkClassInitFunc)NULL, }; pipefilter_type = gtk_type_unique(GST_TYPE_ELEMENT,&pipefilter_info); } return pipefilter_type; } static void gst_pipefilter_class_init (GstPipefilterClass *klass) { GtkObjectClass *gtkobject_class; GstElementClass *gstelement_class; gtkobject_class = (GtkObjectClass*)klass; gstelement_class = (GstElementClass*)klass; parent_class = gtk_type_class(GST_TYPE_ELEMENT); gstelement_class->change_state = gst_pipefilter_change_state; gtk_object_add_arg_type("GstPipefilter::command", GTK_TYPE_STRING, GTK_ARG_READWRITE, ARG_COMMAND); gtkobject_class->set_arg = gst_pipefilter_set_arg; gtkobject_class->get_arg = gst_pipefilter_get_arg; } static void gst_pipefilter_init (GstPipefilter *pipefilter) { GST_FLAG_SET (pipefilter, GST_ELEMENT_DECOUPLED); pipefilter->sinkpad = gst_pad_new ("sink", GST_PAD_SINK); gst_element_add_pad (GST_ELEMENT (pipefilter), pipefilter->sinkpad); gst_pad_set_chain_function (pipefilter->sinkpad, gst_pipefilter_chain); gst_pad_set_eos_function (pipefilter->sinkpad, gst_pipefilter_handle_eos); pipefilter->srcpad = gst_pad_new ("src", GST_PAD_SRC); gst_element_add_pad (GST_ELEMENT (pipefilter), pipefilter->srcpad); gst_pad_set_get_function (pipefilter->srcpad, gst_pipefilter_get); pipefilter->command = NULL; pipefilter->curoffset = 0; pipefilter->bytes_per_read = 4096; pipefilter->seq = 0; } static gboolean gst_pipefilter_handle_eos (GstPad *pad) { GstPipefilter *pipefilter; pipefilter = GST_PIPEFILTER (gst_pad_get_parent (pad)); GST_DEBUG (0,"pipefilter: %s received eos\n", GST_ELEMENT_NAME (pipefilter)); if (close (pipefilter->fdin[1]) < 0) perror("close"); if (close (pipefilter->fdout[0]) < 0) perror("close"); GST_FLAG_SET (pad, GST_PAD_EOS); return TRUE; } static GstBuffer* gst_pipefilter_get (GstPad *pad) { GstPipefilter *pipefilter; GstBuffer *newbuf; glong readbytes; pipefilter = GST_PIPEFILTER (gst_pad_get_parent (pad)); /* create the buffer */ // FIXME: should eventually use a bufferpool for this newbuf = gst_buffer_new(); g_return_val_if_fail(newbuf, NULL); /* allocate the space for the buffer data */ GST_BUFFER_DATA(newbuf) = g_malloc(pipefilter->bytes_per_read); g_return_val_if_fail(GST_BUFFER_DATA(newbuf) != NULL, NULL); /* read it in from the file */ GST_DEBUG (0,"attemting to read %ld bytes\n", pipefilter->bytes_per_read); readbytes = read(pipefilter->fdout[0], GST_BUFFER_DATA(newbuf), pipefilter->bytes_per_read); GST_DEBUG (0,"read %ld bytes\n", readbytes); if (readbytes < 0) { perror("read"); gst_element_error(GST_ELEMENT(pipefilter),"reading"); return NULL; } /* if we didn't get as many bytes as we asked for, we're at EOF */ if (readbytes == 0) { gst_pad_set_eos (pad); return NULL; } GST_BUFFER_OFFSET(newbuf) = pipefilter->curoffset; GST_BUFFER_SIZE(newbuf) = readbytes; pipefilter->curoffset += readbytes; return newbuf; } static void gst_pipefilter_chain (GstPad *pad,GstBuffer *buf) { GstPipefilter *pipefilter; glong writebytes; guchar *data; gulong size; g_return_if_fail(pad != NULL); g_return_if_fail(GST_IS_PAD(pad)); g_return_if_fail(buf != NULL); pipefilter = GST_PIPEFILTER (gst_pad_get_parent (pad)); data = GST_BUFFER_DATA(buf); size = GST_BUFFER_SIZE(buf); GST_DEBUG (0,"attemting to write %ld bytes\n", size); writebytes = write(pipefilter->fdin[1],data,size); GST_DEBUG (0,"written %ld bytes\n", writebytes); if (writebytes < 0) { perror("write"); gst_element_error(GST_ELEMENT(pipefilter),"writing"); return; } gst_buffer_unref(buf); } static void gst_pipefilter_set_arg (GtkObject *object,GtkArg *arg,guint id) { GstPipefilter *pipefilter; /* it's not null if we got it, but it might not be ours */ g_return_if_fail(GST_IS_PIPEFILTER(object)); pipefilter = GST_PIPEFILTER(object); switch(id) { case ARG_COMMAND: pipefilter->orig_command = g_strdup(GTK_VALUE_STRING(*arg)); pipefilter->command = g_strsplit(GTK_VALUE_STRING(*arg), " ", 0); break; default: break; } } static void gst_pipefilter_get_arg (GtkObject *object,GtkArg *arg,guint id) { GstPipefilter *pipefilter; /* it's not null if we got it, but it might not be ours */ g_return_if_fail(GST_IS_PIPEFILTER(object)); pipefilter = GST_PIPEFILTER(object); switch (id) { case ARG_COMMAND: GTK_VALUE_STRING(*arg) = pipefilter->orig_command; break; default: arg->type = GTK_TYPE_INVALID; break; } } /* open the file, necessary to go to RUNNING state */ static gboolean gst_pipefilter_open_file (GstPipefilter *src) { g_return_val_if_fail(!GST_FLAG_IS_SET(src,GST_PIPEFILTER_OPEN), FALSE); pipe(src->fdin); pipe(src->fdout); if((src->childpid = fork()) == -1) { perror("fork"); gst_element_error(GST_ELEMENT(src),"forking"); return FALSE; } if(src->childpid == 0) { close(src->fdin[1]); close(src->fdout[0]); // child dup2(src->fdin[0], STDIN_FILENO); /* set the childs input stream */ dup2(src->fdout[1], STDOUT_FILENO); /* set the childs output stream */ execvp(src->command[0], &src->command[0]); // will only reach if error perror("exec"); gst_element_error(GST_ELEMENT(src),"starting child process"); return FALSE; } else { close(src->fdin[0]); close(src->fdout[1]); } GST_FLAG_SET(src,GST_PIPEFILTER_OPEN); return TRUE; } /* close the file */ static void gst_pipefilter_close_file (GstPipefilter *src) { g_return_if_fail(GST_FLAG_IS_SET(src,GST_PIPEFILTER_OPEN)); /* close the file */ close(src->fdout[0]); close(src->fdout[1]); close(src->fdin[0]); close(src->fdin[1]); /* zero out a lot of our state */ src->curoffset = 0; src->seq = 0; GST_FLAG_UNSET(src,GST_PIPEFILTER_OPEN); } static GstElementStateReturn gst_pipefilter_change_state (GstElement *element) { g_return_val_if_fail(GST_IS_PIPEFILTER(element), FALSE); /* if going down into NULL state, close the file if it's open */ if (GST_STATE_PENDING(element) == GST_STATE_NULL) { if (GST_FLAG_IS_SET(element,GST_PIPEFILTER_OPEN)) gst_pipefilter_close_file(GST_PIPEFILTER(element)); /* otherwise (READY or higher) we need to open the file */ } else { if (!GST_FLAG_IS_SET(element,GST_PIPEFILTER_OPEN)) { if (!gst_pipefilter_open_file(GST_PIPEFILTER(element))) return GST_STATE_FAILURE; } } if (GST_ELEMENT_CLASS(parent_class)->change_state) return GST_ELEMENT_CLASS(parent_class)->change_state(element); return GST_STATE_SUCCESS; }