gstswitchsink.c 8.35 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/* GStreamer
 * (c) 2005 Ronald S. Bultje <rbultje@ronald.bitfreak.net>
 * (c) 2006 Jürg Billeter <j@bitron.ch>
 * (c) 2007 Jan Schmidt <thaytan@noraisin.net>
 *
 * 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.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <string.h>

#include "gstswitchsink.h"

GST_DEBUG_CATEGORY_STATIC (switch_debug);
#define GST_CAT_DEFAULT switch_debug

static void gst_switch_sink_dispose (GObject * object);
static GstStateChangeReturn
gst_switch_sink_change_state (GstElement * element, GstStateChange transition);

enum
{
  PROP_0
};

GST_BOILERPLATE (GstSwitchSink, gst_switch_sink, GstBin, GST_TYPE_BIN);

static void
gst_switch_sink_base_init (gpointer klass)
{
  GST_DEBUG_CATEGORY_INIT (switch_debug, "switchsink", 0, "switchsink element");
}

static void
gst_switch_sink_class_init (GstSwitchSinkClass * klass)
{
  GObjectClass *oklass = G_OBJECT_CLASS (klass);
  GstElementClass *eklass = GST_ELEMENT_CLASS (klass);
55
  static GstStaticPadTemplate sink_template = GST_STATIC_PAD_TEMPLATE ("sink",
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
      GST_PAD_SINK,
      GST_PAD_ALWAYS,
      GST_STATIC_CAPS_ANY);
  GstPadTemplate *child_pad_templ;

  oklass->dispose = gst_switch_sink_dispose;
  eklass->change_state = gst_switch_sink_change_state;

  /* Provide a default pad template if the child didn't */
  child_pad_templ = gst_element_class_get_pad_template (eklass, "sink");
  if (child_pad_templ == NULL) {
    gst_element_class_add_pad_template (eklass,
        gst_static_pad_template_get (&sink_template));
  }
}

72
static gboolean
73
74
gst_switch_sink_reset (GstSwitchSink * sink)
{
75
76
77
  /* this will install fakesink if no other child has been set,
   * otherwise we rely on the subclass to know when to unset its
   * custom kid */
78
  if (sink->kid == NULL) {
79
    return gst_switch_sink_set_child (sink, NULL);
80
  }
81
82

  return TRUE;
83
84
85
86
87
88
89
90
91
}

static void
gst_switch_sink_init (GstSwitchSink * sink, GstSwitchSinkClass * g_class)
{
  sink->pad = gst_ghost_pad_new_no_target ("sink", GST_PAD_SINK);
  gst_element_add_pad (GST_ELEMENT (sink), sink->pad);

  gst_switch_sink_reset (sink);
92
93

  GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_IS_SINK);
94
95
96
97
98
99
}

static void
gst_switch_sink_dispose (GObject * object)
{
  GstSwitchSink *sink = GST_SWITCH_SINK (object);
100
  GstObject *new_kid, *kid;
101

102
  GST_OBJECT_LOCK (sink);
103
104
  new_kid = GST_OBJECT_CAST (sink->new_kid);
  sink->new_kid = NULL;
105

106
107
  kid = GST_OBJECT_CAST (sink->kid);
  sink->kid = NULL;
108
109
  GST_OBJECT_UNLOCK (sink);

110
111
112
  gst_object_replace (&new_kid, NULL);
  gst_object_replace (&kid, NULL);

113
114
115
  GST_CALL_PARENT (G_OBJECT_CLASS, dispose, (object));
}

116
static gboolean
117
118
119
gst_switch_commit_new_kid (GstSwitchSink * sink)
{
  GstPad *targetpad;
120
  GstState kid_state;
121
122
  GstElement *new_kid, *old_kid;
  gboolean is_fakesink = FALSE;
123
  GstBus *bus;
124
125
126

  /* need locking around member accesses */
  GST_OBJECT_LOCK (sink);
127
128
129
130
131
132
133
134
  /* If we're currently changing state, set the child to the next state
   * we're transitioning too, rather than our current state which is 
   * about to change */
  if (GST_STATE_NEXT (sink) != GST_STATE_VOID_PENDING)
    kid_state = GST_STATE_NEXT (sink);
  else
    kid_state = GST_STATE (sink);

135
136
137
138
139
140
141
142
  new_kid = sink->new_kid;
  sink->new_kid = NULL;
  GST_OBJECT_UNLOCK (sink);

  /* Fakesink by default if NULL is passed as the new child */
  if (new_kid == NULL) {
    GST_DEBUG_OBJECT (sink, "Replacing kid with fakesink");
    new_kid = gst_element_factory_make ("fakesink", "testsink");
143
144
145
146
    if (new_kid == NULL) {
      GST_ERROR_OBJECT (sink, "Failed to create fakesink");
      return FALSE;
    }
147
148
    /* Add a reference, as it would if the element came from sink->new_kid */
    gst_object_ref (new_kid);
149
150
151
152
153
154
    g_object_set (new_kid, "sync", TRUE, NULL);
    is_fakesink = TRUE;
  } else {
    GST_DEBUG_OBJECT (sink, "Setting new kid");
  }

155
156
157
158
159
160
161
162
  /* set temporary bus of our own to catch error messages from the child
   * (could we just set our own bus on it, or would the state change messages
   * from the not-yet-added element confuse the state change algorithm? Let's
   * play it safe for now) */
  bus = gst_bus_new ();
  gst_element_set_bus (new_kid, bus);
  gst_object_unref (bus);

163
  if (gst_element_set_state (new_kid, kid_state) == GST_STATE_CHANGE_FAILURE) {
164
165
166
167
168
    GstMessage *msg;

    /* check if child posted an error message and if so re-post it on our bus
     * so that the application gets to see a decent error and not our generic
     * fallback error message which is completely indecipherable to the user */
169
170
171
172
    msg = gst_bus_pop_filtered (GST_ELEMENT_BUS (new_kid), GST_MESSAGE_ERROR);
    if (msg) {
      GST_INFO_OBJECT (sink, "Forwarding kid error: %" GST_PTR_FORMAT, msg);
      gst_element_post_message (GST_ELEMENT (sink), msg);
173
174
175
    }
    /* FIXME: need a translated error message that tells the user to check
     * her GConf audio/video settings */
176
177
    GST_ELEMENT_ERROR (sink, CORE, STATE_CHANGE, (NULL),
        ("Failed to set state on new child."));
178
    gst_element_set_bus (new_kid, NULL);
179
180
181
    gst_object_unref (new_kid);
    return FALSE;
  }
182
  gst_element_set_bus (new_kid, NULL);
183
184
185
186
187
188
  gst_bin_add (GST_BIN (sink), new_kid);

  /* Now, replace the existing child */
  GST_OBJECT_LOCK (sink);
  old_kid = sink->kid;
  sink->kid = new_kid;
189
190
  /* Mark whether a custom kid or fakesink has been installed */
  sink->have_kid = !is_fakesink;
191
192
193
194
195
196
197
  GST_OBJECT_UNLOCK (sink);

  /* kill old element */
  if (old_kid) {
    GST_DEBUG_OBJECT (sink, "Removing old kid %" GST_PTR_FORMAT, old_kid);
    gst_element_set_state (old_kid, GST_STATE_NULL);
    gst_bin_remove (GST_BIN (sink), old_kid);
198
    gst_object_unref (old_kid);
199
200
    /* Don't lose the SINK flag */
    GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_IS_SINK);
201
202
203
204
  }

  /* re-attach ghostpad */
  GST_DEBUG_OBJECT (sink, "Creating new ghostpad");
205
  targetpad = gst_element_get_static_pad (sink->kid, "sink");
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
  gst_ghost_pad_set_target (GST_GHOST_PAD (sink->pad), targetpad);
  gst_object_unref (targetpad);
  GST_DEBUG_OBJECT (sink, "done changing child of switchsink");

  /* FIXME: Push new-segment info and pre-roll buffer(s) into the kid */

  /* Unblock the target pad if necessary */
  if (sink->awaiting_block) {
    gst_pad_set_blocked (sink->pad, FALSE);
    sink->awaiting_block = FALSE;
  }

  return TRUE;
}

gboolean
gst_switch_sink_set_child (GstSwitchSink * sink, GstElement * new_kid)
{
  GstState cur, next;
  GstElement **p_kid;

227
228
  /* Nothing to do if clearing the child and we've already installed fakesink */
  if (new_kid == NULL && sink->kid != NULL && sink->have_kid == FALSE)
229
230
    return TRUE;

231
  /* Store the new kid to be committed later */
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
  GST_OBJECT_LOCK (sink);
  cur = GST_STATE (sink);
  next = GST_STATE_NEXT (sink);
  p_kid = &sink->new_kid;
  gst_object_replace ((GstObject **) p_kid, (GstObject *) new_kid);
  GST_OBJECT_UNLOCK (sink);

  /* Sometime, it would be lovely to allow sink changes even when
   * already running, but this involves sending an appropriate new-segment
   * and possibly prerolling etc */
  /* FIXME: Block the pad and replace the kid when it completes */
  if (cur > GST_STATE_READY || next == GST_STATE_PAUSED) {
    GST_DEBUG_OBJECT (sink,
        "Switch-sink is already running. Ignoring change of child.");
    gst_object_unref (new_kid);
    return TRUE;
  }

  return gst_switch_commit_new_kid (sink);
}

static GstStateChangeReturn
gst_switch_sink_change_state (GstElement * element, GstStateChange transition)
{
  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;
  GstSwitchSink *sink = GST_SWITCH_SINK (element);

  ret = GST_CALL_PARENT_WITH_DEFAULT (GST_ELEMENT_CLASS, change_state,
      (element, transition), GST_STATE_CHANGE_SUCCESS);

  switch (transition) {
    case GST_STATE_CHANGE_READY_TO_NULL:
264
265
      if (!gst_switch_sink_reset (sink))
        ret = GST_STATE_CHANGE_FAILURE;
266
267
268
269
270
271
272
      break;
    default:
      break;
  }

  return ret;
}