void
MediaSinkImpl::unlinkUnchecked (GstPad *sink)
{
GstPad *peer;
GstPad *sinkPad;
if (sink == NULL) {
sinkPad = gst_element_get_static_pad (getGstreamerElement(),
getPadName().c_str() );
} else {
sinkPad = sink;
}
if (sinkPad == NULL) {
return;
}
peer = gst_pad_get_peer (sinkPad);
if (peer != NULL) {
Glib::Threads::Cond cond;
Glib::Threads::Mutex cmutex;
bool blocked = FALSE;
std::function <void (GstPad *, GstPadProbeInfo *) >
blockedLambda = [&] (GstPad * pad, GstPadProbeInfo * info) {
Glib::Threads::Mutex::Lock lock (cmutex);
GST_DEBUG ("Peer pad blocked %" GST_PTR_FORMAT, pad);
if (blocked) {
return;
}
gst_pad_unlink (pad, sinkPad);
blocked = TRUE;
cond.signal();
};
gst_pad_add_probe (peer, (GstPadProbeType) (GST_PAD_PROBE_TYPE_BLOCKING),
pad_blocked_adaptor, &blockedLambda, NULL);
cmutex.lock ();
while (!blocked) {
cond.wait (cmutex);
}
cmutex.unlock ();
g_object_unref (peer);
}
if (sink == NULL) {
gst_element_release_request_pad (getGstreamerElement(), sinkPad);
g_object_unref (sinkPad);
}
}
UriEndpointImpl::UriEndpointImpl (const std::string &uri,
const std::string &factoryName,
std::shared_ptr< MediaObjectImpl > parent) :
EndpointImpl (factoryName, parent)
{
g_object_set (G_OBJECT (getGstreamerElement() ), "uri", uri.c_str(), NULL);
}
PlayerEndpointImpl::PlayerEndpointImpl (const boost::property_tree::ptree &conf,
std::shared_ptr<MediaPipeline>
mediaPipeline, const std::string &uri,
bool useEncodedMedia) : UriEndpointImpl (conf,
std::dynamic_pointer_cast<MediaObjectImpl> (mediaPipeline), FACTORY_NAME, uri)
{
GstElement *element = getGstreamerElement();
g_object_set (G_OBJECT (element), "use-encoded-media", useEncodedMedia, NULL);
}
std::string
UriEndpointImpl::getUri ()
{
char *uri_str;
g_object_get (G_OBJECT (getGstreamerElement() ), "uri", &uri_str, NULL);
std::string uri (uri_str);
g_free (uri_str);
return uri;
}
RecorderEndpointImpl::~RecorderEndpointImpl()
{
gint state = -1;
if (handlerOnStateChanged > 0) {
unregister_signal_handler (element, handlerOnStateChanged);
}
g_object_get (getGstreamerElement(), "state", &state, NULL);
if (state != 0 /* stop */) {
GST_ERROR ("Recorder should be stopped when reaching this point");
}
}
void
RecorderEndpointImpl::release ()
{
gint state = -1;
g_object_get (getGstreamerElement(), "state", &state, NULL);
if (state == 0 /* stop */) {
goto end;
}
stopAndWait();
end:
UriEndpointImpl::release();
}
void
UriEndpointImpl::stop ()
{
g_object_set (G_OBJECT (getGstreamerElement() ), "state",
KMS_URI_END_POINT_STATE_STOP, NULL);
}
RecorderEndpointImpl::RecorderEndpointImpl (const boost::property_tree::ptree
&conf,
std::shared_ptr<MediaPipeline> mediaPipeline, const std::string &uri,
std::shared_ptr<MediaProfileSpecType> mediaProfile,
bool stopOnEndOfStream) : UriEndpointImpl (conf,
std::dynamic_pointer_cast<MediaObjectImpl> (mediaPipeline), FACTORY_NAME, uri)
{
g_object_set (G_OBJECT (getGstreamerElement() ), "accept-eos",
stopOnEndOfStream, NULL);
switch (mediaProfile->getValue() ) {
case MediaProfileSpecType::WEBM:
g_object_set ( G_OBJECT (element), "profile", KMS_RECORDING_PROFILE_WEBM, NULL);
GST_INFO ("Set WEBM profile");
break;
case MediaProfileSpecType::MP4:
g_object_set ( G_OBJECT (element), "profile", KMS_RECORDING_PROFILE_MP4, NULL);
GST_INFO ("Set MP4 profile");
break;
case MediaProfileSpecType::WEBM_VIDEO_ONLY:
g_object_set ( G_OBJECT (element), "profile",
KMS_RECORDING_PROFILE_WEBM_VIDEO_ONLY, NULL);
GST_INFO ("Set WEBM VIDEO ONLY profile");
break;
case MediaProfileSpecType::WEBM_AUDIO_ONLY:
g_object_set ( G_OBJECT (element), "profile",
KMS_RECORDING_PROFILE_WEBM_AUDIO_ONLY, NULL);
GST_INFO ("Set WEBM AUDIO ONLY profile");
break;
case MediaProfileSpecType::MP4_VIDEO_ONLY:
g_object_set ( G_OBJECT (element), "profile",
KMS_RECORDING_PROFILE_MP4_VIDEO_ONLY, NULL);
GST_INFO ("Set MP4 VIDEO ONLY profile");
break;
case MediaProfileSpecType::MP4_AUDIO_ONLY:
g_object_set ( G_OBJECT (element), "profile",
KMS_RECORDING_PROFILE_MP4_AUDIO_ONLY, NULL);
GST_INFO ("Set MP4 AUDIO ONLY profile");
break;
case MediaProfileSpecType::JPEG_VIDEO_ONLY:
g_object_set ( G_OBJECT (element), "profile",
KMS_RECORDING_PROFILE_JPEG_VIDEO_ONLY, NULL);
GST_INFO ("Set JPEG profile");
break;
case MediaProfileSpecType::KURENTO_SPLIT_RECORDER:
if (!RecorderEndpointImpl::support_ksr) {
throw KurentoException (MEDIA_OBJECT_ILLEGAL_PARAM_ERROR,
"Kurento Split Recorder not supported");
}
g_object_set ( G_OBJECT (element), "profile", KMS_RECORDING_PROFILE_KSR, NULL);
GST_INFO ("Set KSR profile");
break;
}
}
bool
MediaSinkImpl::linkPad (std::shared_ptr<MediaSourceImpl> mediaSrc, GstPad *src)
{
RecMutex::Lock lock (mutex);
std::shared_ptr<MediaSourceImpl> connectedSrcLocked;
GstPad *sink;
bool ret = false;
try {
connectedSrcLocked = connectedSrc.lock();
} catch (const std::bad_weak_ptr &e) {
}
if ( (sink = gst_element_get_static_pad (getGstreamerElement(),
getPadName().c_str() ) ) == NULL) {
sink = gst_element_get_request_pad (getGstreamerElement(),
getPadName().c_str() );
}
if (gst_pad_is_linked (sink) ) {
unlink (connectedSrcLocked, sink);
}
if (std::dynamic_pointer_cast<MediaObjectImpl> (mediaSrc)->getParent() ==
getParent() ) {
GstBin *container;
GstElement *filter, *parent;
GstPad *aux_sink, *aux_src;
GST_DEBUG ("Connecting loopback, adding a capsfilter to allow connection");
parent = GST_ELEMENT (GST_OBJECT_PARENT (sink) );
if (parent == NULL) {
goto end;
}
container = GST_BIN (GST_OBJECT_PARENT (parent) );
if (container == NULL) {
goto end;
}
filter = gst_element_factory_make ("capsfilter", NULL);
aux_sink = gst_element_get_static_pad (filter, "sink");
aux_src = gst_element_get_static_pad (filter, "src");
g_signal_connect (G_OBJECT (aux_sink), "unlinked", G_CALLBACK (sink_unlinked),
filter );
g_signal_connect (G_OBJECT (aux_src), "unlinked", G_CALLBACK (src_unlinked),
filter );
gst_bin_add (container, filter);
gst_element_sync_state_with_parent (filter);
if (gst_pad_link_full (aux_src, sink,
GST_PAD_LINK_CHECK_NOTHING) == GST_PAD_LINK_OK) {
if (gst_pad_link_full (src, aux_sink,
GST_PAD_LINK_CHECK_NOTHING) == GST_PAD_LINK_OK) {
ret = true;
} else {
gst_pad_unlink (aux_src, sink);
}
}
g_object_unref (aux_sink);
g_object_unref (aux_src);
gst_debug_bin_to_dot_file_with_ts (GST_BIN (container),
GST_DEBUG_GRAPH_SHOW_ALL, "loopback");
} else {
if (gst_pad_link_full (src, sink,
GST_PAD_LINK_CHECK_NOTHING) == GST_PAD_LINK_OK) {
ret = true;
}
}
if (ret == true) {
connectedSrc = std::weak_ptr<MediaSourceImpl> (mediaSrc);
} else {
gst_element_release_request_pad (getGstreamerElement(), sink);
}
end:
g_object_unref (sink);
return ret;
}
