1 /* GStreamer
2 * Copyright (C) 2008 Jan Schmidt <thaytan@noraisin.net>
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
13 *
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
17 * Boston, MA 02110-1301, USA.
18 */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23
24 #include <string.h>
25
26 #include <gst/gst.h>
27 #include <gst/glib-compat-private.h>
28 #include <gst/pbutils/missing-plugins.h>
29 #include <gst/video/video.h>
30 #include <gst/audio/audio.h>
31
32 #include "resindvdbin.h"
33 #include "resindvdsrc.h"
34 #include "rsninputselector.h"
35 #include "rsndec.h"
36 #include "rsnparsetter.h"
37
38 #include "gstmpegdemux.h"
39
40 #define RSN_TYPE_INPUT_SELECTOR GST_TYPE_INPUT_SELECTOR
41
42 GST_DEBUG_CATEGORY_EXTERN (resindvd_debug);
43 #define GST_CAT_DEFAULT resindvd_debug
44
45 #define DVDBIN_LOCK(d) g_mutex_lock(&(d)->dvd_lock)
46 #define DVDBIN_UNLOCK(d) g_mutex_unlock(&(d)->dvd_lock)
47
48 #define DVDBIN_PREROLL_LOCK(d) g_mutex_lock(&(d)->preroll_lock)
49 #define DVDBIN_PREROLL_UNLOCK(d) g_mutex_unlock(&(d)->preroll_lock)
50
51 #define DEFAULT_DEVICE "/dev/cd0"
52 enum
53 {
54 /* FILL ME */
55 LAST_SIGNAL
56 };
57
58 enum
59 {
60 ARG_0,
61 ARG_DEVICE
62 };
63
64 static GstStaticPadTemplate video_src_template =
65 GST_STATIC_PAD_TEMPLATE ("video",
66 GST_PAD_SRC,
67 GST_PAD_SOMETIMES,
68 GST_STATIC_CAPS (GST_VIDEO_CAPS_MAKE (GST_VIDEO_FORMATS_ALL))
69 );
70
71 static GstStaticPadTemplate audio_src_template =
72 GST_STATIC_PAD_TEMPLATE ("audio",
73 GST_PAD_SRC,
74 GST_PAD_SOMETIMES,
75 GST_STATIC_CAPS (GST_AUDIO_CAPS_MAKE (GST_AUDIO_FORMATS_ALL))
76 );
77
78 static GstStaticPadTemplate subpicture_src_template =
79 GST_STATIC_PAD_TEMPLATE ("subpicture",
80 GST_PAD_SRC,
81 GST_PAD_SOMETIMES,
82 GST_STATIC_CAPS ("subpicture/x-dvd")
83 );
84
85 static void rsn_dvdbin_finalize (GObject * object);
86 static void rsn_dvdbin_uri_handler_init (gpointer g_iface, gpointer iface_data);
87
88 #define rsn_dvdbin_parent_class parent_class
89 G_DEFINE_TYPE_WITH_CODE (RsnDvdBin, rsn_dvdbin, GST_TYPE_BIN,
90 G_IMPLEMENT_INTERFACE (GST_TYPE_URI_HANDLER, rsn_dvdbin_uri_handler_init));
91
92 static void demux_pad_added (GstElement * element, GstPad * pad,
93 RsnDvdBin * dvdbin);
94 static void demux_no_more_pads (GstElement * element, RsnDvdBin * dvdbin);
95 static void rsn_dvdbin_set_property (GObject * object, guint prop_id,
96 const GValue * value, GParamSpec * pspec);
97 static void rsn_dvdbin_get_property (GObject * object, guint prop_id,
98 GValue * value, GParamSpec * pspec);
99 static GstStateChangeReturn rsn_dvdbin_change_state (GstElement * element,
100 GstStateChange transition);
101 static void rsn_dvdbin_no_more_pads (RsnDvdBin * dvdbin);
102
103 static void
rsn_dvdbin_class_init(RsnDvdBinClass * klass)104 rsn_dvdbin_class_init (RsnDvdBinClass * klass)
105 {
106 GObjectClass *gobject_class;
107 GstElementClass *element_class;
108
109 gobject_class = (GObjectClass *) klass;
110 element_class = (GstElementClass *) klass;
111
112 gobject_class->finalize = rsn_dvdbin_finalize;
113 gobject_class->set_property = rsn_dvdbin_set_property;
114 gobject_class->get_property = rsn_dvdbin_get_property;
115
116 g_object_class_install_property (gobject_class, ARG_DEVICE,
117 g_param_spec_string ("device", "Device", "DVD device location",
118 NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
119
120 gst_element_class_add_static_pad_template (element_class,
121 &video_src_template);
122 gst_element_class_add_static_pad_template (element_class,
123 &audio_src_template);
124 gst_element_class_add_static_pad_template (element_class,
125 &subpicture_src_template);
126
127 element_class->change_state = GST_DEBUG_FUNCPTR (rsn_dvdbin_change_state);
128
129 gst_element_class_set_static_metadata (element_class, "rsndvdbin",
130 "Generic/Bin/Player",
131 "DVD playback element", "Jan Schmidt <thaytan@noraisin.net>");
132 }
133
134 static void
rsn_dvdbin_init(RsnDvdBin * dvdbin)135 rsn_dvdbin_init (RsnDvdBin * dvdbin)
136 {
137 g_mutex_init (&dvdbin->dvd_lock);
138 g_mutex_init (&dvdbin->preroll_lock);
139 }
140
141 static void
rsn_dvdbin_finalize(GObject * object)142 rsn_dvdbin_finalize (GObject * object)
143 {
144 RsnDvdBin *dvdbin = RESINDVDBIN (object);
145
146 g_mutex_clear (&dvdbin->dvd_lock);
147 g_mutex_clear (&dvdbin->preroll_lock);
148 g_free (dvdbin->last_uri);
149 g_free (dvdbin->device);
150
151 G_OBJECT_CLASS (parent_class)->finalize (object);
152 }
153
154 /* URI interface */
155 static GstURIType
rsn_dvdbin_uri_get_type(GType type)156 rsn_dvdbin_uri_get_type (GType type)
157 {
158 return GST_URI_SRC;
159 }
160
161 static const gchar *const *
rsn_dvdbin_uri_get_protocols(GType type)162 rsn_dvdbin_uri_get_protocols (GType type)
163 {
164 static const gchar *protocols[] = { "dvd", NULL };
165
166 return protocols;
167 }
168
169 static gchar *
rsn_dvdbin_uri_get_uri(GstURIHandler * handler)170 rsn_dvdbin_uri_get_uri (GstURIHandler * handler)
171 {
172 RsnDvdBin *dvdbin = RESINDVDBIN (handler);
173
174 DVDBIN_LOCK (dvdbin);
175 g_free (dvdbin->last_uri);
176 if (dvdbin->device)
177 dvdbin->last_uri = g_strdup_printf ("dvd://%s", dvdbin->device);
178 else
179 dvdbin->last_uri = g_strdup ("dvd://");
180 DVDBIN_UNLOCK (dvdbin);
181
182 return g_strdup (dvdbin->last_uri);
183 }
184
185 static gboolean
rsn_dvdbin_uri_set_uri(GstURIHandler * handler,const gchar * uri,GError ** error)186 rsn_dvdbin_uri_set_uri (GstURIHandler * handler, const gchar * uri,
187 GError ** error)
188 {
189 RsnDvdBin *dvdbin = RESINDVDBIN (handler);
190 gboolean ret;
191 gchar *protocol, *location;
192
193 protocol = gst_uri_get_protocol (uri);
194
195 ret = (protocol && !strcmp (protocol, "dvd")) ? TRUE : FALSE;
196
197 g_free (protocol);
198 protocol = NULL;
199
200 if (!ret)
201 return ret;
202
203 location = gst_uri_get_location (uri);
204 if (!location)
205 return ret;
206
207 /*
208 * URI structure: dvd:///path/to/device
209 */
210 if (g_str_has_prefix (uri, "dvd://")) {
211 g_free (dvdbin->device);
212 if (strlen (uri) > 6)
213 dvdbin->device = g_strdup (uri + 6);
214 else
215 dvdbin->device = g_strdup (DEFAULT_DEVICE);
216 }
217 #if 0
218 /*
219 * Parse out the new t/c/a and seek to them
220 */
221 {
222 gchar **strs;
223 gchar **strcur;
224 gint pos = 0;
225
226 strcur = strs = g_strsplit (location, ",", 0);
227 while (strcur && *strcur) {
228 gint val;
229
230 if (!sscanf (*strcur, "%d", &val))
231 break;
232
233 switch (pos) {
234 case 0:
235 if (val != dvdbin->uri_title) {
236 dvdbin->uri_title = val;
237 dvdbin->new_seek = TRUE;
238 }
239 break;
240 case 1:
241 if (val != dvdbin->uri_chapter) {
242 dvdbin->uri_chapter = val;
243 dvdbin->new_seek = TRUE;
244 }
245 break;
246 case 2:
247 dvdbin->uri_angle = val;
248 break;
249 }
250
251 strcur++;
252 pos++;
253 }
254
255 g_strfreev (strs);
256 }
257 #endif
258
259 g_free (location);
260
261 return ret;
262 }
263
264 static void
rsn_dvdbin_uri_handler_init(gpointer g_iface,gpointer iface_data)265 rsn_dvdbin_uri_handler_init (gpointer g_iface, gpointer iface_data)
266 {
267 GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface;
268
269 iface->get_type = rsn_dvdbin_uri_get_type;
270 iface->get_protocols = rsn_dvdbin_uri_get_protocols;
271 iface->get_uri = rsn_dvdbin_uri_get_uri;
272 iface->set_uri = rsn_dvdbin_uri_set_uri;
273 }
274
275 static void
rsn_dvdbin_no_more_pads(RsnDvdBin * dvdbin)276 rsn_dvdbin_no_more_pads (RsnDvdBin * dvdbin)
277 {
278 if (dvdbin->did_no_more_pads)
279 return;
280 dvdbin->did_no_more_pads = TRUE;
281
282 GST_DEBUG_OBJECT (dvdbin, "Firing no more pads");
283 /* Shrink subpicture queue to smaller size */
284 g_object_set (dvdbin->pieces[DVD_ELEM_SPUQ],
285 "max-size-time", G_GUINT64_CONSTANT (0), "max-size-bytes", 0,
286 "max-size-buffers", 1, NULL);
287 gst_element_no_more_pads (GST_ELEMENT (dvdbin));
288 }
289
290 static gboolean
try_create_piece(RsnDvdBin * dvdbin,gint index,const gchar * factory,GType type,const gchar * name,const gchar * descr)291 try_create_piece (RsnDvdBin * dvdbin, gint index,
292 const gchar * factory, GType type, const gchar * name, const gchar * descr)
293 {
294 GstElement *e;
295
296 DVDBIN_LOCK (dvdbin);
297 if (dvdbin->pieces[index] != NULL) {
298 DVDBIN_UNLOCK (dvdbin);
299 return TRUE; /* Already exists */
300 }
301 DVDBIN_UNLOCK (dvdbin);
302
303 if (factory != NULL) {
304 e = gst_element_factory_make (factory, name);
305 } else {
306 if (name)
307 e = g_object_new (type, "name", name, NULL);
308 else
309 e = g_object_new (type, NULL);
310 }
311 if (e == NULL)
312 goto create_failed;
313
314 if (!gst_bin_add (GST_BIN (dvdbin), e))
315 goto add_failed;
316
317 GST_DEBUG_OBJECT (dvdbin, "Added %s element: %" GST_PTR_FORMAT, descr, e);
318
319 DVDBIN_LOCK (dvdbin);
320 dvdbin->pieces[index] = e;
321 DVDBIN_UNLOCK (dvdbin);
322
323 return TRUE;
324 create_failed:
325 gst_element_post_message (GST_ELEMENT_CAST (dvdbin),
326 gst_missing_element_message_new (GST_ELEMENT_CAST (dvdbin), factory));
327 GST_ELEMENT_ERROR (dvdbin, CORE, MISSING_PLUGIN, (NULL),
328 ("Could not create %s element '%s'", descr, factory));
329 return FALSE;
330 add_failed:
331 gst_object_unref (e);
332 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
333 ("Could not add %s element to bin", descr));
334 return FALSE;
335 }
336
337 typedef struct
338 {
339 RsnDvdBin *dvdbin;
340 GstPad *pad;
341 gulong pad_block_id;
342 } RsnDvdBinPadBlockCtx;
343
344 static GstPadProbeReturn dvdbin_pad_blocked_cb (GstPad * pad,
345 GstPadProbeInfo * info, RsnDvdBinPadBlockCtx * ctx);
346
347 static void
_pad_block_destroy_notify(RsnDvdBinPadBlockCtx * ctx)348 _pad_block_destroy_notify (RsnDvdBinPadBlockCtx * ctx)
349 {
350 gst_object_unref (ctx->dvdbin);
351 gst_object_unref (ctx->pad);
352 g_slice_free (RsnDvdBinPadBlockCtx, ctx);
353 }
354
355 #if DEBUG_TIMING
356 static GstPadProbeReturn
dvdbin_dump_timing_info(GstPad * opad,GstPadProbeInfo * info,gpointer userdata)357 dvdbin_dump_timing_info (GstPad * opad,
358 GstPadProbeInfo * info, gpointer userdata)
359 {
360 if (GST_PAD_PROBE_INFO_TYPE (info) & (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM |
361 GST_PAD_PROBE_TYPE_EVENT_FLUSH)) {
362 GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info);
363 if (GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT) {
364 const GstSegment *seg;
365
366 gst_event_parse_segment (event, &seg);
367
368 g_print ("%s:%s segment: rate %g format %d, start: %"
369 GST_TIME_FORMAT ", stop: %" GST_TIME_FORMAT ", time: %"
370 GST_TIME_FORMAT " base: %" GST_TIME_FORMAT "\n",
371 GST_DEBUG_PAD_NAME (opad),
372 seg->rate, seg->format, GST_TIME_ARGS (seg->start),
373 GST_TIME_ARGS (seg->stop), GST_TIME_ARGS (seg->time),
374 GST_TIME_ARGS (seg->base));
375 } else if (GST_EVENT_TYPE (event) == GST_EVENT_GAP) {
376 GstClockTime ts, dur, end;
377 gst_event_parse_gap (event, &ts, &dur);
378 end = ts;
379 if (ts != GST_CLOCK_TIME_NONE && dur != GST_CLOCK_TIME_NONE)
380 end += dur;
381 g_print ("%s:%s Gap TS: %" GST_TIME_FORMAT " dur %" GST_TIME_FORMAT
382 " (to %" GST_TIME_FORMAT ")\n", GST_DEBUG_PAD_NAME (opad),
383 GST_TIME_ARGS (ts), GST_TIME_ARGS (dur), GST_TIME_ARGS (end));
384 } else if (GST_EVENT_TYPE (event) == GST_EVENT_FLUSH_STOP) {
385 g_print ("%s:%s FLUSHED\n", GST_DEBUG_PAD_NAME (opad));
386 }
387 }
388 if (GST_PAD_PROBE_INFO_TYPE (info) & GST_PAD_PROBE_TYPE_BUFFER) {
389 GstBuffer *buf = GST_PAD_PROBE_INFO_BUFFER (info);
390 g_print ("%s:%s Buffer PTS %" GST_TIME_FORMAT " duration %" GST_TIME_FORMAT
391 "\n", GST_DEBUG_PAD_NAME (opad), GST_TIME_ARGS (GST_BUFFER_PTS (buf)),
392 GST_TIME_ARGS (GST_BUFFER_DURATION (buf)));
393 }
394 return GST_PAD_PROBE_OK;
395 }
396 #endif
397
398 static gboolean
try_link_pieces(GstElement * e1,const gchar * pad1,GstElement * e2,const gchar * pad2)399 try_link_pieces (GstElement * e1, const gchar * pad1, GstElement * e2,
400 const gchar * pad2)
401 {
402 GstPad *src = gst_element_get_static_pad (e1, pad1);
403 GstPad *sink = gst_element_get_static_pad (e2, pad2);
404 gboolean ret = FALSE;
405
406 if (src == NULL || sink == NULL)
407 goto done;
408
409 if (GST_PAD_LINK_FAILED (gst_pad_link (src, sink)))
410 goto done;
411
412 ret = TRUE;
413 done:
414 if (src)
415 gst_object_unref (src);
416 if (sink)
417 gst_object_unref (sink);
418 return ret;
419 }
420
421 static gboolean
create_elements(RsnDvdBin * dvdbin)422 create_elements (RsnDvdBin * dvdbin)
423 {
424 GstPadTemplate *src_templ = NULL;
425 GstPad *src = NULL;
426 GstPad *sink = NULL;
427 RsnDvdBinPadBlockCtx *bctx = NULL;
428
429 if (!try_create_piece (dvdbin, DVD_ELEM_SOURCE, NULL,
430 RESIN_TYPE_DVDSRC, "dvdsrc", "DVD source")) {
431 return FALSE;
432 }
433
434 /* FIXME: Locking */
435 if (dvdbin->device) {
436 g_object_set (G_OBJECT (dvdbin->pieces[DVD_ELEM_SOURCE]),
437 "device", dvdbin->device, NULL);
438 }
439
440 /* FIXME: Import and use local copy of mpeg PS demuxer */
441 if (!try_create_piece (dvdbin, DVD_ELEM_DEMUX,
442 NULL, GST_TYPE_FLUPS_DEMUX, "dvddemux", "DVD demuxer"))
443 return FALSE;
444
445 if (gst_element_link (dvdbin->pieces[DVD_ELEM_SOURCE],
446 dvdbin->pieces[DVD_ELEM_DEMUX]) == FALSE)
447 goto failed_connect;
448
449 /* Listen for new pads from the demuxer */
450 g_signal_connect (G_OBJECT (dvdbin->pieces[DVD_ELEM_DEMUX]), "pad-added",
451 G_CALLBACK (demux_pad_added), dvdbin);
452
453 g_signal_connect (G_OBJECT (dvdbin->pieces[DVD_ELEM_DEMUX]), "no-more-pads",
454 G_CALLBACK (demux_no_more_pads), dvdbin);
455
456 if (!try_create_piece (dvdbin, DVD_ELEM_MQUEUE, "multiqueue", 0, "rsnmq",
457 "multiqueue"))
458 return FALSE;
459
460 g_object_set (dvdbin->pieces[DVD_ELEM_MQUEUE],
461 "max-size-time", (7 * GST_SECOND / 10), "max-size-bytes", 0,
462 "max-size-buffers", 0, NULL);
463
464 if (!try_create_piece (dvdbin, DVD_ELEM_VIDPARSE, "mpegvideoparse", 0,
465 "rsnvidparse", "video parser"))
466 return FALSE;
467
468 /* Decodebin will throw a missing element message to find an MPEG decoder */
469 if (!try_create_piece (dvdbin, DVD_ELEM_VIDDEC, NULL, RSN_TYPE_VIDEODEC,
470 "rsnviddec", "video decoder"))
471 return FALSE;
472
473 /* FIXME: Replace identity */
474 if (!try_create_piece (dvdbin, DVD_ELEM_PARSET, NULL, RSN_TYPE_RSNPARSETTER,
475 "rsnparsetter", "Aspect ratio adjustment"))
476 return FALSE;
477
478 if (!try_link_pieces (dvdbin->pieces[DVD_ELEM_VIDPARSE], "src",
479 dvdbin->pieces[DVD_ELEM_VIDDEC], "sink"))
480 goto failed_vidparse_connect;
481
482 src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_VIDDEC], "src");
483 sink = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_PARSET], "sink");
484 if (src == NULL || sink == NULL)
485 goto failed_viddec_connect;
486 if (GST_PAD_LINK_FAILED (gst_pad_link (src, sink)))
487 goto failed_viddec_connect;
488 gst_object_unref (src);
489 gst_object_unref (sink);
490 src = sink = NULL;
491
492 src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_PARSET], "src");
493 if (src == NULL)
494 goto failed_video_ghost;
495 src_templ = gst_static_pad_template_get (&video_src_template);
496 dvdbin->video_pad = gst_ghost_pad_new_from_template ("video", src, src_templ);
497 gst_object_unref (src_templ);
498 if (dvdbin->video_pad == NULL)
499 goto failed_video_ghost;
500 gst_pad_set_active (dvdbin->video_pad, TRUE);
501 bctx = g_slice_new (RsnDvdBinPadBlockCtx);
502 bctx->dvdbin = gst_object_ref (dvdbin);
503 bctx->pad = gst_object_ref (dvdbin->video_pad);
504 bctx->pad_block_id =
505 gst_pad_add_probe (src, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
506 (GstPadProbeCallback) dvdbin_pad_blocked_cb, bctx, (GDestroyNotify)
507 _pad_block_destroy_notify);
508 gst_object_unref (src);
509 src = NULL;
510
511 #if DEBUG_TIMING
512 gst_pad_add_probe (dvdbin->video_pad,
513 GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | GST_PAD_PROBE_TYPE_BUFFER |
514 GST_PAD_PROBE_TYPE_EVENT_FLUSH,
515 (GstPadProbeCallback) dvdbin_dump_timing_info, NULL, NULL);
516 #endif
517
518 /* FIXME: Merge stream-selection logic to core and switch back */
519 if (!try_create_piece (dvdbin, DVD_ELEM_SPU_SELECT, NULL,
520 RSN_TYPE_INPUT_SELECTOR, "subpselect", "Subpicture stream selector"))
521 return FALSE;
522
523 g_object_set (G_OBJECT (dvdbin->pieces[DVD_ELEM_SPU_SELECT]),
524 "sync-streams", FALSE, NULL);
525
526 /* Add a single standalone queue to hold a single buffer of SPU data */
527 if (!try_create_piece (dvdbin, DVD_ELEM_SPUQ, "queue", 0, "spu_q",
528 "subpicture decoder buffer"))
529 return FALSE;
530 /* Allow a lot more while pre-rolling */
531 g_object_set (dvdbin->pieces[DVD_ELEM_SPUQ],
532 "max-size-time", G_GUINT64_CONSTANT (0), "max-size-bytes", 0,
533 "max-size-buffers", 100, NULL);
534
535 src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_SPU_SELECT], "src");
536 sink = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_SPUQ], "sink");
537 if (src == NULL || sink == NULL)
538 goto failed_spuq_connect;
539 if (GST_PAD_LINK_FAILED (gst_pad_link (src, sink)))
540 goto failed_spuq_connect;
541 gst_object_unref (src);
542 gst_object_unref (sink);
543 src = sink = NULL;
544
545 src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_SPUQ], "src");
546 if (src == NULL)
547 goto failed_spu_ghost;
548 src_templ = gst_static_pad_template_get (&subpicture_src_template);
549 dvdbin->subpicture_pad =
550 gst_ghost_pad_new_from_template ("subpicture", src, src_templ);
551 gst_object_unref (src_templ);
552 if (dvdbin->subpicture_pad == NULL)
553 goto failed_spu_ghost;
554 gst_pad_set_active (dvdbin->subpicture_pad, TRUE);
555 bctx = g_slice_new (RsnDvdBinPadBlockCtx);
556 bctx->dvdbin = gst_object_ref (dvdbin);
557 bctx->pad = gst_object_ref (dvdbin->subpicture_pad);
558 bctx->pad_block_id =
559 gst_pad_add_probe (src, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
560 (GstPadProbeCallback) dvdbin_pad_blocked_cb, bctx, (GDestroyNotify)
561 _pad_block_destroy_notify);
562 gst_object_unref (src);
563 src = NULL;
564
565 if (!try_create_piece (dvdbin, DVD_ELEM_AUD_SELECT, NULL,
566 RSN_TYPE_INPUT_SELECTOR, "audioselect", "Audio stream selector"))
567 return FALSE;
568 g_object_set (G_OBJECT (dvdbin->pieces[DVD_ELEM_AUD_SELECT]),
569 "sync-streams", FALSE, NULL);
570
571 if (!try_create_piece (dvdbin, DVD_ELEM_AUDDEC, NULL,
572 RSN_TYPE_AUDIODEC, "auddec", "audio decoder"))
573 return FALSE;
574
575 src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_AUD_SELECT], "src");
576 sink = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_AUDDEC], "sink");
577 if (src == NULL || sink == NULL)
578 goto failed_aud_connect;
579 if (GST_PAD_LINK_FAILED (gst_pad_link (src, sink)))
580 goto failed_aud_connect;
581 gst_object_unref (sink);
582 gst_object_unref (src);
583 src = sink = NULL;
584
585 /* ghost audio munge output pad onto bin */
586 src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_AUDDEC], "src");
587 if (src == NULL)
588 goto failed_aud_ghost;
589 src_templ = gst_static_pad_template_get (&audio_src_template);
590 dvdbin->audio_pad = gst_ghost_pad_new_from_template ("audio", src, src_templ);
591 gst_object_unref (src_templ);
592 if (dvdbin->audio_pad == NULL)
593 goto failed_aud_ghost;
594 gst_pad_set_active (dvdbin->audio_pad, TRUE);
595 bctx = g_slice_new (RsnDvdBinPadBlockCtx);
596 bctx->dvdbin = gst_object_ref (dvdbin);
597 bctx->pad = gst_object_ref (dvdbin->audio_pad);
598 bctx->pad_block_id =
599 gst_pad_add_probe (src, GST_PAD_PROBE_TYPE_BLOCK_DOWNSTREAM,
600 (GstPadProbeCallback) dvdbin_pad_blocked_cb, bctx, (GDestroyNotify)
601 _pad_block_destroy_notify);
602 gst_object_unref (src);
603 src = NULL;
604
605 if (dvdbin->video_added && (dvdbin->audio_added || dvdbin->audio_broken)
606 && dvdbin->subpicture_added) {
607 rsn_dvdbin_no_more_pads (dvdbin);
608 }
609
610 return TRUE;
611
612 failed_connect:
613 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
614 ("Could not connect DVD source and demuxer elements"));
615 goto error_out;
616 failed_vidparse_connect:
617 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
618 ("Could not connect DVD video parser and video decoder"));
619 goto error_out;
620 failed_viddec_connect:
621 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
622 ("Could not connect DVD video decoder and aspect ratio adjuster"));
623 goto error_out;
624 failed_video_ghost:
625 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
626 ("Could not ghost video output pad"));
627 goto error_out;
628 failed_spuq_connect:
629 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
630 ("Could not connect DVD subpicture selector and buffer elements"));
631 goto error_out;
632 failed_spu_ghost:
633 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
634 ("Could not ghost SPU output pad"));
635 goto error_out;
636 failed_aud_connect:
637 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
638 ("Could not connect DVD audio decoder"));
639 goto error_out;
640 failed_aud_ghost:
641 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
642 ("Could not ghost audio output pad"));
643 goto error_out;
644 error_out:
645 if (src != NULL)
646 gst_object_unref (src);
647 if (sink != NULL)
648 gst_object_unref (sink);
649 return FALSE;
650 }
651
652 static void
remove_elements(RsnDvdBin * dvdbin)653 remove_elements (RsnDvdBin * dvdbin)
654 {
655 gint i;
656 GList *tmp;
657
658 if (dvdbin->pieces[DVD_ELEM_MQUEUE] != NULL) {
659 for (tmp = dvdbin->mq_req_pads; tmp; tmp = g_list_next (tmp)) {
660 gst_element_release_request_pad (dvdbin->pieces[DVD_ELEM_MQUEUE],
661 GST_PAD (tmp->data));
662 }
663 }
664 g_list_free (dvdbin->mq_req_pads);
665 dvdbin->mq_req_pads = NULL;
666
667 for (i = 0; i < DVD_ELEM_LAST; i++) {
668 DVDBIN_LOCK (dvdbin);
669 if (dvdbin->pieces[i] != NULL) {
670 GstElement *piece = dvdbin->pieces[i];
671
672 dvdbin->pieces[i] = NULL;
673 DVDBIN_UNLOCK (dvdbin);
674
675 gst_element_set_state (piece, GST_STATE_NULL);
676 gst_bin_remove (GST_BIN (dvdbin), piece);
677 } else
678 DVDBIN_UNLOCK (dvdbin);
679 }
680 if (dvdbin->video_pad) {
681 if (dvdbin->video_added)
682 gst_element_remove_pad (GST_ELEMENT (dvdbin), dvdbin->video_pad);
683 else
684 gst_object_unref (dvdbin->video_pad);
685 }
686 if (dvdbin->audio_pad) {
687 if (dvdbin->audio_added)
688 gst_element_remove_pad (GST_ELEMENT (dvdbin), dvdbin->audio_pad);
689 else
690 gst_object_unref (dvdbin->audio_pad);
691 }
692 if (dvdbin->subpicture_pad) {
693 if (dvdbin->subpicture_added)
694 gst_element_remove_pad (GST_ELEMENT (dvdbin), dvdbin->subpicture_pad);
695 else
696 gst_object_unref (dvdbin->subpicture_pad);
697 }
698
699 dvdbin->video_added = dvdbin->audio_added = dvdbin->subpicture_added = FALSE;
700 dvdbin->audio_broken = FALSE;
701 dvdbin->video_pad = dvdbin->audio_pad = dvdbin->subpicture_pad = NULL;
702 dvdbin->did_no_more_pads = FALSE;
703 }
704
705 static GstPad *
connect_thru_mq(RsnDvdBin * dvdbin,GstPad * pad)706 connect_thru_mq (RsnDvdBin * dvdbin, GstPad * pad)
707 {
708 GstPad *mq_sink;
709 GstPad *mq_src;
710 gchar *tmp, *sinkname, *srcname;
711
712 /* Request a pad from multiqueue, then connect this one, then
713 * discover the corresponding output pad and return it */
714 mq_sink = gst_element_get_request_pad (dvdbin->pieces[DVD_ELEM_MQUEUE],
715 "sink_%u");
716 if (mq_sink == NULL)
717 return FALSE;
718 dvdbin->mq_req_pads = g_list_prepend (dvdbin->mq_req_pads, mq_sink);
719
720 if (gst_pad_link (pad, mq_sink) != GST_PAD_LINK_OK)
721 return FALSE;
722
723 sinkname = gst_pad_get_name (mq_sink);
724 tmp = sinkname + 5;
725 srcname = g_strdup_printf ("src_%s", tmp);
726
727 mq_src = gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_MQUEUE],
728 srcname);
729
730 g_free (sinkname);
731 g_free (srcname);
732
733 return mq_src;
734 }
735
736 static gboolean
can_sink_caps(GstElement * e,GstCaps * caps)737 can_sink_caps (GstElement * e, GstCaps * caps)
738 {
739 gboolean res = FALSE;
740 GstPad *sink = gst_element_get_static_pad (e, "sink");
741
742 if (sink) {
743 GstCaps *sink_caps = gst_pad_query_caps (sink, caps);
744 if (sink_caps) {
745 res = !gst_caps_is_empty (sink_caps);
746 gst_caps_unref (sink_caps);
747 }
748 gst_object_unref (sink);
749 }
750
751 return res;
752 }
753
754 static void
demux_pad_added(GstElement * element,GstPad * pad,RsnDvdBin * dvdbin)755 demux_pad_added (GstElement * element, GstPad * pad, RsnDvdBin * dvdbin)
756 {
757 gboolean skip_mq = FALSE;
758 GstPad *mq_pad = NULL;
759 GstPad *dest_pad = NULL;
760 GstCaps *caps;
761 GstStructure *s;
762
763 GST_DEBUG_OBJECT (dvdbin, "New pad: %" GST_PTR_FORMAT, pad);
764
765 caps = gst_pad_query_caps (pad, NULL);
766 if (caps == NULL) {
767 GST_WARNING_OBJECT (dvdbin, "NULL caps from pad %" GST_PTR_FORMAT, pad);
768 return;
769 }
770 if (!gst_caps_is_fixed (caps)) {
771 GST_WARNING_OBJECT (dvdbin, "Unfixed caps %" GST_PTR_FORMAT
772 " on pad %" GST_PTR_FORMAT, caps, pad);
773 gst_caps_unref (caps);
774 return;
775 }
776
777 GST_DEBUG_OBJECT (dvdbin,
778 "Pad %" GST_PTR_FORMAT " has caps: %" GST_PTR_FORMAT, pad, caps);
779
780 s = gst_caps_get_structure (caps, 0);
781 g_return_if_fail (s != NULL);
782
783 if (can_sink_caps (dvdbin->pieces[DVD_ELEM_VIDPARSE], caps)) {
784 GST_LOG_OBJECT (dvdbin, "Found video pad w/ caps %" GST_PTR_FORMAT, caps);
785 dest_pad =
786 gst_element_get_static_pad (dvdbin->pieces[DVD_ELEM_VIDPARSE], "sink");
787 } else if (g_str_equal (gst_structure_get_name (s), "subpicture/x-dvd")) {
788 GST_LOG_OBJECT (dvdbin, "Found subpicture pad w/ caps %" GST_PTR_FORMAT,
789 caps);
790 dest_pad =
791 gst_element_get_request_pad (dvdbin->pieces[DVD_ELEM_SPU_SELECT],
792 "sink_%u");
793 skip_mq = TRUE;
794 } else if (can_sink_caps (dvdbin->pieces[DVD_ELEM_AUDDEC], caps)) {
795 GST_LOG_OBJECT (dvdbin, "Found audio pad w/ caps %" GST_PTR_FORMAT, caps);
796 dest_pad =
797 gst_element_get_request_pad (dvdbin->pieces[DVD_ELEM_AUD_SELECT],
798 "sink_%u");
799 } else {
800 GstStructure *s;
801
802 GST_DEBUG_OBJECT (dvdbin, "Ignoring unusable pad w/ caps %" GST_PTR_FORMAT,
803 caps);
804 gst_element_post_message (GST_ELEMENT_CAST (dvdbin),
805 gst_missing_decoder_message_new (GST_ELEMENT_CAST (dvdbin), caps));
806
807 s = gst_caps_get_structure (caps, 0);
808 if (g_str_has_prefix ("video/", gst_structure_get_name (s))) {
809 GST_ELEMENT_ERROR (dvdbin, STREAM, CODEC_NOT_FOUND, (NULL),
810 ("No MPEG video decoder found"));
811 } else {
812 GST_ELEMENT_WARNING (dvdbin, STREAM, CODEC_NOT_FOUND, (NULL),
813 ("No audio decoder found"));
814 }
815 }
816
817 gst_caps_unref (caps);
818
819 if (dest_pad == NULL) {
820 GST_DEBUG_OBJECT (dvdbin, "Don't know how to handle pad. Ignoring");
821 return;
822 }
823
824 if (skip_mq) {
825 mq_pad = gst_object_ref (pad);
826 } else {
827 mq_pad = connect_thru_mq (dvdbin, pad);
828 if (mq_pad == NULL)
829 goto failed;
830 GST_DEBUG_OBJECT (dvdbin, "Linking new pad %" GST_PTR_FORMAT
831 " through multiqueue to %" GST_PTR_FORMAT, pad, dest_pad);
832 }
833
834 gst_pad_link (mq_pad, dest_pad);
835
836 gst_object_unref (mq_pad);
837 gst_object_unref (dest_pad);
838
839 return;
840 failed:
841 GST_ELEMENT_ERROR (dvdbin, CORE, FAILED, (NULL),
842 ("Failed to handle new demuxer pad %s", GST_PAD_NAME (pad)));
843 if (mq_pad)
844 gst_object_unref (mq_pad);
845 if (dest_pad)
846 gst_object_unref (dest_pad);
847 return;
848 }
849
850 static void
demux_no_more_pads(GstElement * element,RsnDvdBin * dvdbin)851 demux_no_more_pads (GstElement * element, RsnDvdBin * dvdbin)
852 {
853 gboolean no_more_pads = FALSE;
854 guint n_audio_pads = 0;
855
856 GST_DEBUG_OBJECT (dvdbin, "Received no more pads from demuxer");
857 DVDBIN_PREROLL_LOCK (dvdbin);
858
859 g_object_get (dvdbin->pieces[DVD_ELEM_AUD_SELECT], "n-pads", &n_audio_pads,
860 NULL);
861 if (n_audio_pads == 0) {
862 no_more_pads = dvdbin->video_added && dvdbin->subpicture_added;
863 dvdbin->audio_broken = TRUE;
864 }
865
866 DVDBIN_PREROLL_UNLOCK (dvdbin);
867
868 if (no_more_pads) {
869 GST_DEBUG_OBJECT (dvdbin,
870 "Firing no more pads from demuxer no-more-pads cb");
871 rsn_dvdbin_no_more_pads (dvdbin);
872 }
873 }
874
875 static GstPadProbeReturn
dvdbin_pad_blocked_cb(GstPad * opad,GstPadProbeInfo * info,RsnDvdBinPadBlockCtx * ctx)876 dvdbin_pad_blocked_cb (GstPad * opad,
877 GstPadProbeInfo * info, RsnDvdBinPadBlockCtx * ctx)
878 {
879 RsnDvdBin *dvdbin;
880 GstPad *pad;
881 gboolean added_last_pad = FALSE;
882 gboolean added = FALSE;
883 guint pad_block_id = 0;
884
885 dvdbin = ctx->dvdbin;
886 pad = ctx->pad;
887
888 if (pad == dvdbin->subpicture_pad) {
889 GST_DEBUG_OBJECT (opad, "Pad block -> subpicture pad");
890 DVDBIN_PREROLL_LOCK (dvdbin);
891 added = dvdbin->subpicture_added;
892 dvdbin->subpicture_added = TRUE;
893
894 if (!added) {
895 gst_element_add_pad (GST_ELEMENT (dvdbin), dvdbin->subpicture_pad);
896 added_last_pad = ((dvdbin->audio_broken || dvdbin->audio_added)
897 && dvdbin->video_added);
898 }
899 pad_block_id = ctx->pad_block_id;
900 ctx->pad_block_id = 0;
901 DVDBIN_PREROLL_UNLOCK (dvdbin);
902
903 if (pad_block_id)
904 gst_pad_remove_probe (opad, pad_block_id);
905 } else if (pad == dvdbin->audio_pad) {
906 GST_DEBUG_OBJECT (opad, "Pad block -> audio pad");
907 DVDBIN_PREROLL_LOCK (dvdbin);
908 added = dvdbin->audio_added;
909 dvdbin->audio_added = TRUE;
910
911 if (!added) {
912 gst_element_add_pad (GST_ELEMENT (dvdbin), dvdbin->audio_pad);
913 added_last_pad = (dvdbin->subpicture_added && dvdbin->video_added);
914 }
915 pad_block_id = ctx->pad_block_id;
916 ctx->pad_block_id = 0;
917 DVDBIN_PREROLL_UNLOCK (dvdbin);
918
919 if (pad_block_id)
920 gst_pad_remove_probe (opad, pad_block_id);
921 } else if (pad == dvdbin->video_pad) {
922 GST_DEBUG_OBJECT (opad, "Pad block -> video pad");
923
924 DVDBIN_PREROLL_LOCK (dvdbin);
925 added = dvdbin->video_added;
926 dvdbin->video_added = TRUE;
927
928 if (!added) {
929 gst_element_add_pad (GST_ELEMENT (dvdbin), dvdbin->video_pad);
930 added_last_pad = (dvdbin->subpicture_added && (dvdbin->audio_added
931 || dvdbin->audio_broken));
932 }
933 pad_block_id = ctx->pad_block_id;
934 ctx->pad_block_id = 0;
935 DVDBIN_PREROLL_UNLOCK (dvdbin);
936
937 if (pad_block_id)
938 gst_pad_remove_probe (opad, pad_block_id);
939 }
940
941 if (added_last_pad) {
942 GST_DEBUG_OBJECT (dvdbin, "Firing no more pads from pad-blocked cb");
943 rsn_dvdbin_no_more_pads (dvdbin);
944 }
945
946 return GST_PAD_PROBE_OK;
947 }
948
949 static void
rsn_dvdbin_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)950 rsn_dvdbin_set_property (GObject * object, guint prop_id,
951 const GValue * value, GParamSpec * pspec)
952 {
953 RsnDvdBin *dvdbin = RESINDVDBIN (object);
954
955 switch (prop_id) {
956 case ARG_DEVICE:
957 DVDBIN_LOCK (dvdbin);
958 g_free (dvdbin->device);
959 if (g_value_get_string (value) == NULL)
960 dvdbin->device = g_strdup (DEFAULT_DEVICE);
961 else
962 dvdbin->device = g_value_dup_string (value);
963
964 if (dvdbin->pieces[DVD_ELEM_SOURCE]) {
965 g_object_set_property (G_OBJECT (dvdbin->pieces[DVD_ELEM_SOURCE]),
966 "device", value);
967 }
968 DVDBIN_UNLOCK (dvdbin);
969 break;
970 default:
971 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
972 break;
973 }
974 }
975
976 static void
rsn_dvdbin_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)977 rsn_dvdbin_get_property (GObject * object, guint prop_id,
978 GValue * value, GParamSpec * pspec)
979 {
980 RsnDvdBin *dvdbin = RESINDVDBIN (object);
981
982 switch (prop_id) {
983 case ARG_DEVICE:
984 DVDBIN_LOCK (dvdbin);
985 if (dvdbin->device)
986 g_value_set_string (value, dvdbin->device);
987 else if (dvdbin->pieces[DVD_ELEM_SOURCE])
988 g_object_get_property (G_OBJECT (dvdbin->pieces[DVD_ELEM_SOURCE]),
989 "device", value);
990 else
991 g_value_set_string (value, DEFAULT_DEVICE);
992 DVDBIN_UNLOCK (dvdbin);
993 break;
994 default:
995 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
996 break;
997 }
998 }
999
1000 static GstStateChangeReturn
rsn_dvdbin_change_state(GstElement * element,GstStateChange transition)1001 rsn_dvdbin_change_state (GstElement * element, GstStateChange transition)
1002 {
1003 GstStateChangeReturn ret;
1004 RsnDvdBin *dvdbin = RESINDVDBIN (element);
1005
1006 switch (transition) {
1007 case GST_STATE_CHANGE_NULL_TO_READY:
1008 if (!create_elements (dvdbin)) {
1009 remove_elements (dvdbin);
1010 return GST_STATE_CHANGE_FAILURE;
1011 }
1012 break;
1013 default:
1014 break;
1015 }
1016
1017 ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);
1018 if (ret == GST_STATE_CHANGE_FAILURE)
1019 return ret;
1020
1021 switch (transition) {
1022 case GST_STATE_CHANGE_PAUSED_TO_READY:
1023 case GST_STATE_CHANGE_READY_TO_NULL:
1024 remove_elements (dvdbin);
1025 break;
1026 default:
1027 break;
1028 }
1029
1030 return ret;
1031 }
1032