static GstClock *
gst_pipeline_provide_clock_func (GstElement * element)
{
GstClock *clock = NULL;
GstPipeline *pipeline = GST_PIPELINE (element);
/* if we have a fixed clock, use that one */
GST_OBJECT_LOCK (pipeline);
if (GST_OBJECT_FLAG_IS_SET (pipeline, GST_PIPELINE_FLAG_FIXED_CLOCK)) {
clock = pipeline->fixed_clock;
if (clock)
gst_object_ref (clock);
GST_OBJECT_UNLOCK (pipeline);
GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline using fixed clock %p (%s)",
clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-");
} else {
GST_OBJECT_UNLOCK (pipeline);
/* let the parent bin select a clock */
clock =
GST_ELEMENT_CLASS (parent_class)->provide_clock (GST_ELEMENT
(pipeline));
/* no clock, use a system clock */
if (!clock) {
clock = gst_system_clock_obtain ();
GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline obtained system clock: %p (%s)",
clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-");
} else {
GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline obtained clock: %p (%s)",
clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-");
}
}
return clock;
}
static void httpserver_init (HTTPServer *http_server)
{
gint i;
RequestData *request_data;
http_server->listen_thread = NULL;
http_server->thread_pool = NULL;
g_mutex_init (&(http_server->request_data_queue_mutex));
http_server->request_data_queue = g_queue_new ();
for (i=0; i<kMaxRequests; i++) {
request_data = (RequestData *)g_malloc (sizeof (RequestData));
g_mutex_init (&(request_data->events_mutex));
request_data->id = i;
request_data->num_headers = 0;
http_server->request_data_pointers[i] = request_data;
g_queue_push_head (http_server->request_data_queue, &http_server->request_data_pointers[i]);
}
g_mutex_init (&(http_server->idle_queue_mutex));
g_cond_init (&(http_server->idle_queue_cond));
http_server->idle_queue = g_tree_new ((GCompareFunc)compare_func);
g_mutex_init (&(http_server->block_queue_mutex));
g_cond_init (&(http_server->block_queue_cond));
http_server->block_queue = g_queue_new ();
http_server->total_click = 0;
http_server->encoder_click = 0;
http_server->system_clock = gst_system_clock_obtain ();
g_object_set (http_server->system_clock, "clock-type", GST_CLOCK_TYPE_REALTIME, NULL);
}
static void
gst_rdt_manager_init (GstRDTManager * rdtmanager)
{
rdtmanager->provided_clock = gst_system_clock_obtain ();
rdtmanager->latency = DEFAULT_LATENCY_MS;
GST_OBJECT_FLAG_SET (rdtmanager, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
}
static void job_init (Job *job)
{
job->system_clock = gst_system_clock_obtain ();
g_object_set (job->system_clock, "clock-type", GST_CLOCK_TYPE_REALTIME, NULL);
job->encoder_array = g_array_new (FALSE, FALSE, sizeof (gpointer));
g_mutex_init (&(job->access_mutex));
}
void test_refcounts()
{
GstNetTimeProvider *ntp;
GstClock *clock;
xmlfile = "test_refcounts";
std_log(LOG_FILENAME_LINE, "Test Started test_refcounts");
clock = gst_system_clock_obtain ();
fail_unless (clock != NULL, "failed to get system clock");
/* one for gstreamer, one for us */
ASSERT_OBJECT_REFCOUNT (clock, "system clock", 2);
ntp = gst_net_time_provider_new (clock, NULL, 0);
fail_unless (ntp != NULL, "failed to create net time provider");
/* one for ntp, one for gstreamer, one for us */
ASSERT_OBJECT_REFCOUNT (clock, "system clock", 3);
/* one for us */
ASSERT_OBJECT_REFCOUNT (ntp, "net time provider", 1);
gst_object_unref (ntp);
ASSERT_OBJECT_REFCOUNT (clock, "net time provider", 2);
gst_object_unref (clock);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
static void
gst_rtp_dec_init (GstRTPDec * rtpdec)
{
rtpdec->provided_clock = gst_system_clock_obtain ();
rtpdec->latency = DEFAULT_LATENCY_MS;
GST_OBJECT_FLAG_SET (rtpdec, GST_ELEMENT_FLAG_PROVIDE_CLOCK);
}
static GstFlowReturn
gst_markin_transform_ip (GstBaseTransform * trans, GstBuffer * in)
{
GstMetaMarking* meta = GST_META_MARKING_ADD(in);
GstClock* clock = gst_system_clock_obtain ();
meta->in_timestamp = gst_clock_get_time(clock);
gst_object_unref(clock);
return GST_FLOW_OK;
}
gint
main (gint argc, gchar * argv[])
{
GThread *threads[MAX_THREADS];
gint num_threads;
gint t;
GstClock *sysclock;
gst_init (&argc, &argv);
if (argc != 2) {
g_print ("usage: %s <num_threads>\n", argv[0]);
exit (-1);
}
num_threads = atoi (argv[1]);
if (num_threads <= 0 || num_threads > MAX_THREADS) {
g_print ("number of threads must be between 0 and %d\n", MAX_THREADS);
exit (-2);
}
sysclock = gst_system_clock_obtain ();
for (t = 0; t < num_threads; t++) {
GError *error = NULL;
threads[t] = g_thread_try_new ("clockstresstest", run_test,
sysclock, &error);
if (error) {
printf ("ERROR: g_thread_try_new() %s\n", error->message);
exit (-1);
}
}
printf ("main(): Created %d threads.\n", t);
/* run for 5 seconds */
g_usleep (G_USEC_PER_SEC * 5);
printf ("main(): Stopping threads...\n");
running = FALSE;
for (t = 0; t < num_threads; t++) {
g_thread_join (threads[t]);
}
g_print ("performed %d get_time operations\n", count);
gst_object_unref (sysclock);
return 0;
}
static GstNetTimeProvider *
create_net_clock ()
{
GstClock *clock;
GstNetTimeProvider *net_time;
clock = gst_system_clock_obtain ();
net_time = gst_net_time_provider_new (clock, NULL, 0);
gst_object_unref (clock);
return net_time;
}
static GstNetTimeProvider *
create_net_clock (guint16 *port)
{
GstClock *clock;
GstNetTimeProvider *net_time;
clock = gst_system_clock_obtain ();
net_time = gst_net_time_provider_new (clock, NULL, 0);
g_object_get (net_time, "port", port, NULL);
gst_object_unref (clock);
return net_time;
}
static void gstreamill_init (Gstreamill *gstreamill)
{
GstDateTime *start_time;
gstreamill->stop = FALSE;
gstreamill->system_clock = gst_system_clock_obtain ();
g_object_set (gstreamill->system_clock, "clock-type", GST_CLOCK_TYPE_REALTIME, NULL);
start_time = gst_date_time_new_now_local_time ();
gstreamill->start_time = gst_date_time_to_iso8601_string (start_time);
gst_date_time_unref (start_time);
g_mutex_init (&(gstreamill->job_list_mutex));
gstreamill->job_list = NULL;
}
static void
shell_recorder_src_init (ShellRecorderSrc *src)
{
gst_base_src_set_format (GST_BASE_SRC (src), GST_FORMAT_TIME);
gst_base_src_set_live (GST_BASE_SRC (src), TRUE);
src->clock = gst_system_clock_obtain ();
src->last_frame_time = 0;
src->queue = g_async_queue_new ();
src->mutex = &src->mutex_data;
g_mutex_init (src->mutex);
}
static void
gst_cpu_throttling_clock_init (GstCpuThrottlingClock * self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
GST_TYPE_CPU_THROTTLING_CLOCK, GstCpuThrottlingClockPrivate);
self->priv->current_wait_time = GST_MSECOND;
self->priv->wanted_cpu_usage = 100;
self->priv->timer = gst_poll_new_timer ();
self->priv->time_between_evals = GST_SECOND / 4;
self->priv->sclock = GST_CLOCK (gst_system_clock_obtain ());
getrusage (RUSAGE_SELF, &self->priv->last_usage);
}
static void
gst_dtls_connection_check_timeout_locked (GstDtlsConnection * self)
{
GstDtlsConnectionPrivate *priv;
struct timeval timeout;
gint64 end_time, wait_time;
g_return_if_fail (GST_IS_DTLS_CONNECTION (self));
priv = self->priv;
if (DTLSv1_get_timeout (priv->ssl, &timeout)) {
wait_time = timeout.tv_sec * G_USEC_PER_SEC + timeout.tv_usec;
GST_DEBUG_OBJECT (self, "waiting for %" G_GINT64_FORMAT " usec", wait_time);
if (wait_time) {
GstClock *system_clock = gst_system_clock_obtain ();
GstClockID clock_id;
#ifndef G_DISABLE_ASSERT
GstClockReturn clock_return;
#endif
end_time = gst_clock_get_time (system_clock) + wait_time * GST_USECOND;
clock_id = gst_clock_new_single_shot_id (system_clock, end_time);
#ifndef G_DISABLE_ASSERT
clock_return =
#else
(void)
#endif
gst_clock_id_wait_async (clock_id, schedule_timeout_handling,
g_object_ref (self), (GDestroyNotify) g_object_unref);
g_assert (clock_return == GST_CLOCK_OK);
gst_clock_id_unref (clock_id);
gst_object_unref (system_clock);
} else {
if (self->priv->is_alive && !self->priv->timeout_pending) {
self->priv->timeout_pending = TRUE;
GST_TRACE_OBJECT (self, "Schedule timeout now");
g_thread_pool_push (self->priv->thread_pool, GINT_TO_POINTER (0xc0ffee),
NULL);
}
}
} else {
GST_DEBUG_OBJECT (self, "no timeout set");
}
}
extern EXPORT_API gboolean gst_dvb_css_wc_start(const gchar *address, gint port, gboolean followup, guint32 max_freq_error_ppm, gboolean isDebug) {
GST_DEBUG("dvb_css_wc_start\n");
G_LOCK(mutex);
sServer = server_new();
if (sServer == NULL) {
goto server_struct_not_initialized;
}
gst_init(NULL, NULL);
sServer->loop = g_main_loop_new(NULL, FALSE);
sServer->clock = gst_system_clock_obtain();
if(isDebug == FALSE){
sServer->gstdvbcsswcserver = gst_dvb_css_wc_server_new(sServer->clock, address, port, followup, max_freq_error_ppm);
}
else{
sServer->gstdvbcsswcserver = gst_net_time_provider_new(sServer->clock, address, port);
}
if (sServer->gstdvbcsswcserver == NULL) {
GST_ERROR("Dvb_css_wc server not created\n");
goto cleanup;
}
g_object_get(sServer->gstdvbcsswcserver, "port", &port, NULL);
GST_DEBUG("Published network clock on port %u\n", port);
sServer->thread = g_thread_try_new("dvb_css_wc_thread", (GThreadFunc) g_main_loop_run, sServer->loop, NULL);
if (sServer->thread == NULL) {
GST_ERROR("Thread for dvb_css_wc server not created\n");
goto cleanup;
}
GST_DEBUG("Dvb_css_wc server started\n");
G_UNLOCK(mutex);
return TRUE;
/* ERRORS */
server_struct_not_initialized:{
GST_ERROR("Dvb_css_wc server struct not initialized\n");
G_UNLOCK(mutex);
return FALSE;
}
cleanup:{
server_free(&sServer);
G_UNLOCK(mutex);
return FALSE;
}
}
/* initialize the new element
* instantiate pads and add them to element
* set functions
* initialize structure
*/
static void
gst_directsound_src_init (GstDirectSoundSrc * src)
{
GST_DEBUG_OBJECT (src, "initializing directsoundsrc");
g_mutex_init (&src->dsound_lock);
src->system_clock = gst_system_clock_obtain ();
src->read_wait_clock_id = NULL;
src->reset_while_sleeping = FALSE;
src->device_guid = NULL;
src->device_id = NULL;
src->device_name = NULL;
src->mixer = NULL;
src->control_id_mute = -1;
src->control_id_volume = -1;
src->volume = 100;
src->mute = FALSE;
}
static void
gst_net_client_clock_finalize (GObject * object)
{
GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);
GList *l;
if (self->priv->synced_id)
g_signal_handler_disconnect (self->priv->internal_clock,
self->priv->synced_id);
self->priv->synced_id = 0;
G_LOCK (clocks_lock);
for (l = clocks; l; l = l->next) {
ClockCache *cache = l->data;
if (cache->clock == self->priv->internal_clock) {
cache->clocks = g_list_remove (cache->clocks, self);
if (cache->clocks) {
update_clock_cache (cache);
} else {
GstClock *sysclock = gst_system_clock_obtain ();
GstClockTime time = gst_clock_get_time (sysclock) + 60 * GST_SECOND;
cache->remove_id = gst_clock_new_single_shot_id (sysclock, time);
gst_clock_id_wait_async (cache->remove_id, remove_clock_cache, cache,
NULL);
gst_object_unref (sysclock);
}
break;
}
}
G_UNLOCK (clocks_lock);
g_free (self->priv->address);
self->priv->address = NULL;
if (self->priv->bus != NULL) {
gst_object_unref (self->priv->bus);
self->priv->bus = NULL;
}
G_OBJECT_CLASS (gst_net_client_clock_parent_class)->finalize (object);
}
static gpointer
no_rtcp_timeout_func (gpointer user_data)
{
FsRtpSubStream *self = FS_RTP_SUB_STREAM (user_data);
GstClock *sysclock = NULL;
GstClockID id;
gboolean emit = TRUE;
sysclock = gst_system_clock_obtain ();
if (sysclock == NULL)
goto no_sysclock;
FS_RTP_SUB_STREAM_LOCK(self);
id = self->priv->no_rtcp_timeout_id = gst_clock_new_single_shot_id (sysclock,
self->priv->next_no_rtcp_timeout);
FS_RTP_SUB_STREAM_UNLOCK(self);
gst_clock_id_wait (id, NULL);
FS_RTP_SUB_STREAM_LOCK(self);
gst_clock_id_unref (id);
self->priv->no_rtcp_timeout_id = NULL;
if (self->priv->next_no_rtcp_timeout == 0)
emit = FALSE;
FS_RTP_SUB_STREAM_UNLOCK(self);
gst_object_unref (sysclock);
if (emit)
g_signal_emit (self, signals[NO_RTCP_TIMEDOUT], 0);
return NULL;
no_sysclock:
{
fs_rtp_sub_stream_emit_error (self, FS_ERROR_INTERNAL,
"Could not get system clock",
"Could not get system clock");
return NULL;
}
}
static void
gst_aggregator_init (GstAggregator * self, GstAggregatorClass * klass)
{
GstPadTemplate *pad_template;
GstAggregatorPrivate *priv;
g_return_if_fail (klass->aggregate != NULL);
self->priv =
G_TYPE_INSTANCE_GET_PRIVATE (self, GST_TYPE_AGGREGATOR,
GstAggregatorPrivate);
priv = self->priv;
pad_template =
gst_element_class_get_pad_template (GST_ELEMENT_CLASS (klass), "src");
g_return_if_fail (pad_template != NULL);
priv->padcount = -1;
priv->tags_changed = FALSE;
self->priv->latency_live = FALSE;
self->priv->latency_min = 0;
self->priv->latency_max = GST_CLOCK_TIME_NONE;
_reset_flow_values (self);
AGGREGATOR_QUEUE (self) = g_async_queue_new ();
self->srcpad = gst_pad_new_from_template (pad_template, "src");
gst_pad_set_event_function (self->srcpad,
GST_DEBUG_FUNCPTR ((GstPadEventFunction) src_event_func));
gst_pad_set_query_function (self->srcpad,
GST_DEBUG_FUNCPTR ((GstPadQueryFunction) src_query_func));
gst_pad_set_activatemode_function (self->srcpad,
GST_DEBUG_FUNCPTR ((GstPadActivateModeFunction) src_activate_mode));
gst_element_add_pad (GST_ELEMENT (self), self->srcpad);
self->clock = gst_system_clock_obtain ();
self->timeout = -1;
g_mutex_init (&self->priv->setcaps_lock);
}
MediaPipelineImpl::MediaPipelineImpl (const boost::property_tree::ptree &config)
: MediaObjectImpl (config)
{
GstClock *clock;
pipeline = gst_pipeline_new (NULL);
if (pipeline == NULL) {
throw KurentoException (MEDIA_OBJECT_NOT_AVAILABLE,
"Cannot create gstreamer pipeline");
}
clock = gst_system_clock_obtain ();
gst_pipeline_use_clock (GST_PIPELINE (pipeline), clock);
g_object_unref (clock);
gst_element_set_state (pipeline, GST_STATE_PLAYING);
busMessageHandler = 0;
}
static gboolean
fs_rtp_sub_stream_start_no_rtcp_timeout_thread (FsRtpSubStream *self,
GError **error)
{
gboolean res = TRUE;
GstClock *sysclock = NULL;
sysclock = gst_system_clock_obtain ();
if (sysclock == NULL)
{
g_set_error (error, FS_ERROR, FS_ERROR_INTERNAL,
"Could not obtain gst system clock");
return FALSE;
}
FS_RTP_SESSION_LOCK (self->priv->session);
FS_RTP_SUB_STREAM_LOCK(self);
self->priv->next_no_rtcp_timeout = gst_clock_get_time (sysclock) +
(self->no_rtcp_timeout * GST_MSECOND);
gst_object_unref (sysclock);
if (self->priv->no_rtcp_timeout_thread == NULL) {
/* only create a new thread if the old one was stopped. Otherwise we can
* just reuse the currently running one. */
self->priv->no_rtcp_timeout_thread =
g_thread_create (no_rtcp_timeout_func, self, TRUE, error);
}
res = (self->priv->no_rtcp_timeout_thread != NULL);
if (res == FALSE && error && *error == NULL)
g_set_error (error, FS_ERROR, FS_ERROR_INTERNAL, "Unknown error creating"
" thread");
FS_RTP_SUB_STREAM_UNLOCK(self);
FS_RTP_SESSION_UNLOCK (self->priv->session);
return res;
}
static void
fs_rtp_tfrc_init (FsRtpTfrc *self)
{
GST_DEBUG_CATEGORY_INIT (fsrtpconference_tfrc,
"fsrtpconference_tfrc", 0,
"Farstream RTP Conference Element Rate Control logic");
/* member init */
self->tfrc_sources = g_hash_table_new_full (g_direct_hash,
g_direct_equal, NULL, (GDestroyNotify) tracked_src_free);
fs_rtp_tfrc_clear_sender (self);
self->send_bitrate = tfrc_sender_get_send_rate (NULL) * 8;
self->extension_type = EXTENSION_NONE;
self->extension_id = 0;
memset (self->pts, 0, 128);
self->systemclock = gst_system_clock_obtain ();
}
static void
gst_net_client_clock_init (GstNetClientClock * self)
{
GstNetClientClockPrivate *priv;
GstClock *clock;
self->priv = priv = GST_NET_CLIENT_CLOCK_GET_PRIVATE (self);
GST_OBJECT_FLAG_SET (self, GST_CLOCK_FLAG_CAN_SET_MASTER);
GST_OBJECT_FLAG_SET (self, GST_CLOCK_FLAG_NEEDS_STARTUP_SYNC);
priv->port = DEFAULT_PORT;
priv->address = g_strdup (DEFAULT_ADDRESS);
priv->roundtrip_limit = DEFAULT_ROUNDTRIP_LIMIT;
priv->minimum_update_interval = DEFAULT_MINIMUM_UPDATE_INTERVAL;
clock = gst_system_clock_obtain ();
priv->base_time = DEFAULT_BASE_TIME;
priv->internal_base_time = gst_clock_get_time (clock);
gst_object_unref (clock);
}
/**
* gst_switch_server_init:
*
* Initialize the GstSwitchServer instance.
*/
static void
gst_switch_server_init (GstSwitchServer * srv)
{
INFO ("gst_switch_server init %p", srv);
srv->host = g_strdup (GST_SWITCH_SERVER_DEFAULT_HOST);
srv->cancellable = g_cancellable_new ();
srv->video_acceptor_port = opts.video_input_port;
srv->video_acceptor_socket = NULL;
srv->video_acceptor = NULL;
srv->audio_acceptor_port = opts.audio_input_port;
srv->audio_acceptor_socket = NULL;
srv->audio_acceptor = NULL;
srv->controller_port = opts.control_port;
srv->controller_socket = NULL;
srv->controller_thread = NULL;
srv->controller = NULL;
srv->main_loop = NULL;
srv->cases = NULL;
srv->composite = NULL;
srv->alloc_port_count = 0;
srv->pip_x = 0;
srv->pip_y = 0;
srv->pip_w = 0;
srv->pip_h = 0;
srv->clock = gst_system_clock_obtain ();
g_mutex_init (&srv->main_loop_lock);
g_mutex_init (&srv->video_acceptor_lock);
g_mutex_init (&srv->audio_acceptor_lock);
g_mutex_init (&srv->controller_lock);
g_mutex_init (&srv->cases_lock);
g_mutex_init (&srv->alloc_port_lock);
g_mutex_init (&srv->pip_lock);
g_mutex_init (&srv->recorder_lock);
g_mutex_init (&srv->clock_lock);
}
static void owr_media_renderer_init(OwrMediaRenderer *renderer)
{
OwrMediaRendererPrivate *priv;
GstBus *bus;
GSource *bus_source;
gchar *bin_name;
renderer->priv = priv = OWR_MEDIA_RENDERER_GET_PRIVATE(renderer);
priv->media_type = DEFAULT_MEDIA_TYPE;
priv->source = DEFAULT_SOURCE;
priv->disabled = DEFAULT_DISABLED;
priv->message_origin_bus_set = owr_message_origin_bus_set_new();
bin_name = g_strdup_printf("media-renderer-%u", g_atomic_int_add(&unique_bin_id, 1));
priv->pipeline = gst_pipeline_new(bin_name);
gst_pipeline_use_clock(GST_PIPELINE(priv->pipeline), gst_system_clock_obtain());
gst_element_set_base_time(priv->pipeline, _owr_get_base_time());
gst_element_set_start_time(priv->pipeline, GST_CLOCK_TIME_NONE);
g_free(bin_name);
#ifdef OWR_DEBUG
g_signal_connect(priv->pipeline, "deep-notify", G_CALLBACK(_owr_deep_notify), NULL);
#endif
priv->sink = NULL;
priv->src = NULL;
bus = gst_pipeline_get_bus(GST_PIPELINE(priv->pipeline));
bus_source = gst_bus_create_watch(bus);
g_source_set_callback(bus_source, (GSourceFunc) bus_call, priv->pipeline, NULL);
g_source_attach(bus_source, _owr_get_main_context());
g_source_unref(bus_source);
g_mutex_init(&priv->media_renderer_lock);
}
static void encoder_init (Encoder *encoder)
{
encoder->system_clock = gst_system_clock_obtain ();
g_object_set (encoder->system_clock, "clock-type", GST_CLOCK_TYPE_REALTIME, NULL);
encoder->streams = g_array_new (FALSE, FALSE, sizeof (gpointer));
}
static void gst_imx_v4l2src_af_check_status(GstImxV4l2VideoSrc *v4l2src)
{
int status;
gboolean send_message;
GstPhotographyFocusStatus message_status;
gboolean schedule_recheck;
if (v4l2_g_ctrl(v4l2src, V4L2_CID_AUTO_FOCUS_STATUS, &status) < 0)
goto none;
switch (status)
{
case V4L2_AUTO_FOCUS_STATUS_IDLE:
default:
none:
send_message = TRUE;
message_status = GST_PHOTOGRAPHY_FOCUS_STATUS_NONE;
schedule_recheck = FALSE;
break;
case V4L2_AUTO_FOCUS_STATUS_BUSY:
send_message = FALSE;
schedule_recheck = TRUE;
break;
case V4L2_AUTO_FOCUS_STATUS_REACHED:
send_message = TRUE;
message_status = GST_PHOTOGRAPHY_FOCUS_STATUS_SUCCESS;
schedule_recheck = FALSE;
break;
case V4L2_AUTO_FOCUS_STATUS_FAILED:
send_message = TRUE;
message_status = GST_PHOTOGRAPHY_FOCUS_STATUS_FAIL;
schedule_recheck = FALSE;
break;
}
if (send_message)
{
GstStructure *s;
GstMessage *m;
s = gst_structure_new(GST_PHOTOGRAPHY_AUTOFOCUS_DONE,
"status", G_TYPE_INT, message_status,
NULL);
m = gst_message_new_custom(GST_MESSAGE_ELEMENT,
GST_OBJECT(v4l2src), s);
if (!gst_element_post_message(GST_ELEMENT(v4l2src), m))
GST_ERROR_OBJECT(v4l2src, "failed to post message");
}
if (schedule_recheck)
{
GstClock *c;
GstClockTime t;
c = gst_system_clock_obtain();
t = gst_clock_get_time(c) + 50 * GST_MSECOND;
v4l2src->af_clock_id = gst_clock_new_single_shot_id(c, t);
gst_object_unref(c);
if (gst_clock_id_wait_async(v4l2src->af_clock_id,
gst_imx_v4l2src_af_status_cb,
v4l2src, NULL) != GST_CLOCK_OK)
GST_ERROR_OBJECT(v4l2src, "failed to schedule recheck");
}
}
void test_functioning()
{
GstNetTimeProvider *ntp;
GstNetTimePacket *packet;
GstClock *clock;
GstClockTime local;
struct sockaddr_in servaddr;
gint port = -1, sockfd, ret;
socklen_t len;
xmlfile = "test_functioning";
std_log(LOG_FILENAME_LINE, "Test Started test_functioning");
clock = gst_system_clock_obtain ();
fail_unless (clock != NULL, "failed to get system clock");
ntp = gst_net_time_provider_new (clock, "127.0.0.1", 0);
fail_unless (ntp != NULL, "failed to create net time provider");
g_object_get (ntp, "port", &port, NULL);
fail_unless (port > 0);
sockfd = socket (AF_INET, SOCK_DGRAM, 0);
fail_if (sockfd < 0, "socket failed");
memset (&servaddr, 0, sizeof (servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons (port);
inet_aton ("127.0.0.1", &servaddr.sin_addr);
packet = gst_net_time_packet_new (NULL);
fail_unless (packet != NULL, "failed to create packet");
packet->local_time = local = gst_clock_get_time (clock);
len = sizeof (servaddr);
ret = gst_net_time_packet_send (packet, sockfd,
(struct sockaddr *) &servaddr, len);
fail_unless (ret == GST_NET_TIME_PACKET_SIZE, "failed to send packet");
g_free (packet);
packet = gst_net_time_packet_receive (sockfd, (struct sockaddr *) &servaddr,
&len);
fail_unless (packet != NULL, "failed to receive packet");
// fail_unless (packet->local_time == local, "local time is not the same"); //local time has changed
fail_unless (packet->remote_time > local, "remote time not after local time");
fail_unless (packet->remote_time < gst_clock_get_time (clock),
"remote time in the future");
g_free (packet);
close (sockfd);
//gst_object_unref (ntp); //thread is blocking
gst_object_unref (clock);
std_log(LOG_FILENAME_LINE, "Test Successful");
create_xml(0);
}
GST_END_TEST
GST_START_TEST (test_functioning)
{
GstDvbCssWcServer *wc;
GstDvbCssWcPacket *packet;
GstClock *clock;
guint32 local_secs, local_nanos;
GSocketAddress *server_addr;
GInetAddress *addr;
GSocket *socket;
gint port = -1;
GstClockTime prev_receive_timevalue, prev_transmit_timevalue;
clock = gst_system_clock_obtain ();
fail_unless (clock != NULL, "failed to get system clock");
wc = gst_dvb_css_wc_server_new (clock, "127.0.0.1", 37034, TRUE, 500);
fail_unless (wc != NULL, "failed to create dvb css wc server");
g_object_get (wc, "port", &port, NULL);
fail_unless (port > 0);
socket = g_socket_new (G_SOCKET_FAMILY_IPV4, G_SOCKET_TYPE_DATAGRAM,
G_SOCKET_PROTOCOL_UDP, NULL);
fail_unless (socket != NULL, "could not create socket");
addr = g_inet_address_new_from_string ("127.0.0.1");
server_addr = g_inet_socket_address_new (addr, port);
g_object_unref (addr);
packet = gst_dvb_css_wc_packet_new (NULL);
fail_unless (packet != NULL, "failed to create packet");
packet->message_type = GST_DVB_CSS_WC_MSG_REQUEST;
packet->originate_timevalue_secs = local_secs = 123;
packet->originate_timevalue_nanos = local_nanos = 456;
fail_unless (gst_dvb_css_wc_packet_send (packet, socket, server_addr, NULL));
g_free (packet);
packet = gst_dvb_css_wc_packet_receive (socket, NULL, NULL);
fail_unless (packet != NULL, "failed to receive packet");
fail_unless (packet->message_type == GST_DVB_CSS_WC_MSG_RESPONSE_WITH_FOLLOWUP, "wrong msg type");
fail_unless (packet->originate_timevalue_secs == local_secs, "originate_timevalue_secs is not the same");
fail_unless (packet->originate_timevalue_nanos == local_nanos, "originate_timevalue_nanos is not the same");
fail_unless (packet->receive_timevalue < packet->transmit_timevalue, "remote time not after local time");
fail_unless (packet->transmit_timevalue < gst_clock_get_time (clock), "remote time in the future");
prev_receive_timevalue = packet->receive_timevalue;
prev_transmit_timevalue = packet->transmit_timevalue;
g_free (packet);
packet = gst_dvb_css_wc_packet_receive (socket, NULL, NULL);
fail_unless (packet != NULL, "failed to receive packet");
fail_unless (packet->message_type == GST_DVB_CSS_WC_MSG_FOLLOWUP, "wrong msg type");
fail_unless (packet->originate_timevalue_secs == local_secs, "originate_timevalue_secs is not the same");
fail_unless (packet->originate_timevalue_nanos == local_nanos, "originate_timevalue_nanos is not the same");
fail_unless (packet->receive_timevalue < packet->transmit_timevalue, "remote time not after local time");
fail_unless (packet->transmit_timevalue < gst_clock_get_time (clock), "remote time in the future");
fail_unless (prev_receive_timevalue == packet->receive_timevalue, "remote time not after local time");
fail_unless (prev_transmit_timevalue < packet->transmit_timevalue, "remote time not after local time");
g_free (packet);
packet = gst_dvb_css_wc_packet_new (NULL);
fail_unless (packet != NULL, "failed to create packet");
packet->message_type = GST_DVB_CSS_WC_MSG_REQUEST;
fail_unless (gst_dvb_css_wc_packet_send (packet, socket, server_addr, NULL));
g_free (packet);
packet = gst_dvb_css_wc_packet_new (NULL);
fail_unless (packet != NULL, "failed to create packet");
packet->message_type = GST_DVB_CSS_WC_MSG_RESPONSE; //wrong msg ignored by server
fail_unless (gst_dvb_css_wc_packet_send (packet, socket, server_addr, NULL));
g_free (packet);
packet = gst_dvb_css_wc_packet_receive (socket, NULL, NULL);
fail_unless (packet != NULL, "failed to receive packet");
fail_unless (packet->message_type == GST_DVB_CSS_WC_MSG_RESPONSE_WITH_FOLLOWUP, "wrong msg type");
g_free (packet);
g_object_unref (socket);
g_object_unref (server_addr);
gst_object_unref (wc);
gst_object_unref (clock);
}
/*
* owr_local_media_source_get_pad
*
* The beginning of a media source chain in the pipeline looks like this:
* +------------+
* /---+ inter*sink |
* +--------+ +--------+ +------------+ +-----+ / +------------+
* | source +----+ scale? +---+ capsfilter +---+ tee +---/
* +--------+ +--------+ +------------+ +-----+ \
* \ +------------+
* \---+ inter*sink |
* +------------+
*
* For each newly requested pad a new inter*sink is added to the tee.
* Note that this is a completely independent pipeline, and the complete
* pipeline is only created once for a specific media source.
*
* Then for each newly requested pad another bin with a inter*src is
* created, which is then going to be part of the transport agent
* pipeline. The ghostpad of it is what we return here.
*
* +-----------+ +-------------------------------+ +----------+
* | inter*src +---+ converters/queues/capsfilters +---+ ghostpad |
* +-----------+ +-------------------------------+ +----------+
*
*/
static GstElement *owr_local_media_source_request_source(OwrMediaSource *media_source, GstCaps *caps)
{
OwrLocalMediaSource *local_source;
OwrLocalMediaSourcePrivate *priv;
GstElement *source_element = NULL;
GstElement *source_pipeline;
GHashTable *event_data;
GValue *value;
#if defined(__linux__) && !defined(__ANDROID__)
gchar *tmp;
#endif
g_assert(media_source);
local_source = OWR_LOCAL_MEDIA_SOURCE(media_source);
priv = local_source->priv;
/* only create the source bin for this media source once */
if ((source_pipeline = _owr_media_source_get_source_bin(media_source)))
GST_DEBUG_OBJECT(media_source, "Re-using existing source element/bin");
else {
OwrMediaType media_type = OWR_MEDIA_TYPE_UNKNOWN;
OwrSourceType source_type = OWR_SOURCE_TYPE_UNKNOWN;
GstElement *source, *source_process = NULL, *capsfilter = NULL, *tee;
GstPad *sinkpad, *source_pad;
GEnumClass *media_enum_class, *source_enum_class;
GEnumValue *media_enum_value, *source_enum_value;
gchar *bin_name;
GstCaps *source_caps;
GstBus *bus;
GSource *bus_source;
event_data = _owr_value_table_new();
value = _owr_value_table_add(event_data, "start_time", G_TYPE_INT64);
g_value_set_int64(value, g_get_monotonic_time());
g_object_get(media_source, "media-type", &media_type, "type", &source_type, NULL);
media_enum_class = G_ENUM_CLASS(g_type_class_ref(OWR_TYPE_MEDIA_TYPE));
source_enum_class = G_ENUM_CLASS(g_type_class_ref(OWR_TYPE_SOURCE_TYPE));
media_enum_value = g_enum_get_value(media_enum_class, media_type);
source_enum_value = g_enum_get_value(source_enum_class, source_type);
bin_name = g_strdup_printf("local-%s-%s-source-bin-%u",
media_enum_value ? media_enum_value->value_nick : "unknown",
source_enum_value ? source_enum_value->value_nick : "unknown",
g_atomic_int_add(&unique_bin_id, 1));
g_type_class_unref(media_enum_class);
g_type_class_unref(source_enum_class);
source_pipeline = gst_pipeline_new(bin_name);
gst_pipeline_use_clock(GST_PIPELINE(source_pipeline), gst_system_clock_obtain());
gst_element_set_base_time(source_pipeline, _owr_get_base_time());
gst_element_set_start_time(source_pipeline, GST_CLOCK_TIME_NONE);
g_free(bin_name);
bin_name = NULL;
#ifdef OWR_DEBUG
g_signal_connect(source_pipeline, "deep-notify", G_CALLBACK(_owr_deep_notify), NULL);
#endif
bus = gst_pipeline_get_bus(GST_PIPELINE(source_pipeline));
bus_source = gst_bus_create_watch(bus);
g_source_set_callback(bus_source, (GSourceFunc) bus_call, media_source, NULL);
g_source_attach(bus_source, _owr_get_main_context());
g_source_unref(bus_source);
GST_DEBUG_OBJECT(local_source, "media_type: %d, type: %d", media_type, source_type);
if (media_type == OWR_MEDIA_TYPE_UNKNOWN || source_type == OWR_SOURCE_TYPE_UNKNOWN) {
GST_ERROR_OBJECT(local_source,
"Cannot connect source with unknown type or media type to other component");
goto done;
}
switch (media_type) {
case OWR_MEDIA_TYPE_AUDIO:
{
switch (source_type) {
case OWR_SOURCE_TYPE_CAPTURE:
CREATE_ELEMENT(source, AUDIO_SRC, "audio-source");
#if !defined(__APPLE__) || !TARGET_IPHONE_SIMULATOR
/*
Default values for buffer-time and latency-time on android are 200ms and 20ms.
The minimum latency-time that can be used on Android is 20ms, and using
a 40ms buffer-time with a 20ms latency-time causes crackling audio.
So let's just stick with the defaults.
*/
#if !defined(__ANDROID__)
g_object_set(source, "buffer-time", G_GINT64_CONSTANT(40000),
"latency-time", G_GINT64_CONSTANT(10000), NULL);
#endif
if (priv->device_index > -1) {
#ifdef __APPLE__
g_object_set(source, "device", priv->device_index, NULL);
#elif defined(__linux__) && !defined(__ANDROID__)
tmp = g_strdup_printf("%d", priv->device_index);
g_object_set(source, "device", tmp, NULL);
g_free(tmp);
#endif
}
#endif
break;
case OWR_SOURCE_TYPE_TEST:
CREATE_ELEMENT(source, "audiotestsrc", "audio-source");
g_object_set(source, "is-live", TRUE, NULL);
break;
case OWR_SOURCE_TYPE_UNKNOWN:
default:
g_assert_not_reached();
goto done;
}
break;
}
case OWR_MEDIA_TYPE_VIDEO:
{
GstPad *srcpad;
GstCaps *device_caps;
switch (source_type) {
case OWR_SOURCE_TYPE_CAPTURE:
CREATE_ELEMENT(source, VIDEO_SRC, "video-source");
if (priv->device_index > -1) {
#if defined(__APPLE__) && !TARGET_IPHONE_SIMULATOR
g_object_set(source, "device-index", priv->device_index, NULL);
#elif defined(__ANDROID__)
g_object_set(source, "cam-index", priv->device_index, NULL);
#elif defined(__linux__)
tmp = g_strdup_printf("/dev/video%d", priv->device_index);
g_object_set(source, "device", tmp, NULL);
g_free(tmp);
#endif
}
break;
case OWR_SOURCE_TYPE_TEST: {
GstElement *src, *time;
GstPad *srcpad;
source = gst_bin_new("video-source");
CREATE_ELEMENT(src, "videotestsrc", "videotestsrc");
g_object_set(src, "is-live", TRUE, NULL);
gst_bin_add(GST_BIN(source), src);
time = gst_element_factory_make("timeoverlay", "timeoverlay");
if (time) {
g_object_set(time, "font-desc", "Sans 60", NULL);
gst_bin_add(GST_BIN(source), time);
gst_element_link(src, time);
srcpad = gst_element_get_static_pad(time, "src");
} else
srcpad = gst_element_get_static_pad(src, "src");
gst_element_add_pad(source, gst_ghost_pad_new("src", srcpad));
gst_object_unref(srcpad);
break;
}
case OWR_SOURCE_TYPE_UNKNOWN:
default:
g_assert_not_reached();
goto done;
}
/* First try to see if we can just get the format we want directly */
source_caps = gst_caps_new_empty();
#if GST_CHECK_VERSION(1, 5, 0)
gst_caps_foreach(caps, fix_video_caps_framerate, source_caps);
#else
_owr_gst_caps_foreach(caps, fix_video_caps_framerate, source_caps);
#endif
/* Now see what the device can really produce */
srcpad = gst_element_get_static_pad(source, "src");
gst_element_set_state(source, GST_STATE_READY);
device_caps = gst_pad_query_caps(srcpad, source_caps);
if (gst_caps_is_empty(device_caps)) {
/* Let's see if it works when we drop format constraints (which can be dealt with downsteram) */
GstCaps *tmp = source_caps;
source_caps = gst_caps_new_empty();
#if GST_CHECK_VERSION(1, 5, 0)
gst_caps_foreach(tmp, fix_video_caps_format, source_caps);
#else
_owr_gst_caps_foreach(tmp, fix_video_caps_format, source_caps);
#endif
gst_caps_unref(tmp);
gst_caps_unref(device_caps);
device_caps = gst_pad_query_caps(srcpad, source_caps);
if (gst_caps_is_empty(device_caps)) {
/* Accepting any format didn't work, we're going to hope that scaling fixes it */
CREATE_ELEMENT(source_process, "videoscale", "video-source-scale");
gst_bin_add(GST_BIN(source_pipeline), source_process);
}
}
gst_caps_unref(device_caps);
gst_object_unref(srcpad);
#if defined(__APPLE__) && TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
/* Force NV12 on iOS else the source can negotiate BGRA
* ercolorspace can do NV12 -> BGRA and NV12 -> I420 which is what
* is needed for Bowser */
gst_caps_set_simple(source_caps, "format", G_TYPE_STRING, "NV12", NULL);
#endif
CREATE_ELEMENT(capsfilter, "capsfilter", "video-source-capsfilter");
g_object_set(capsfilter, "caps", source_caps, NULL);
gst_caps_unref(source_caps);
gst_bin_add(GST_BIN(source_pipeline), capsfilter);
break;
}
case OWR_MEDIA_TYPE_UNKNOWN:
default:
g_assert_not_reached();
goto done;
}
g_assert(source);
source_pad = gst_element_get_static_pad(source, "src");
g_signal_connect(source_pad, "notify::caps", G_CALLBACK(on_caps), media_source);
gst_object_unref(source_pad);
CREATE_ELEMENT(tee, "tee", "source-tee");
g_object_set(tee, "allow-not-linked", TRUE, NULL);
gst_bin_add_many(GST_BIN(source_pipeline), source, tee, NULL);
/* Many sources don't like reconfiguration and it's pointless
* here anyway right now. No need to reconfigure whenever something
* is added to the tee or removed.
* We will have to implement reconfiguration differently later by
* selecting the best caps based on all consumers.
*/
sinkpad = gst_element_get_static_pad(tee, "sink");
gst_pad_add_probe(sinkpad, GST_PAD_PROBE_TYPE_EVENT_UPSTREAM, drop_reconfigure_event, NULL, NULL);
gst_object_unref(sinkpad);
if (!source)
GST_ERROR_OBJECT(media_source, "Failed to create source element!");
if (capsfilter) {
LINK_ELEMENTS(capsfilter, tee);
if (source_process) {
LINK_ELEMENTS(source_process, capsfilter);
LINK_ELEMENTS(source, source_process);
} else
LINK_ELEMENTS(source, capsfilter);
} else if (source_process) {
LINK_ELEMENTS(source_process, tee);
LINK_ELEMENTS(source, source_process);
} else
LINK_ELEMENTS(source, tee);
gst_element_sync_state_with_parent(tee);
if (capsfilter)
gst_element_sync_state_with_parent(capsfilter);
if (source_process)
gst_element_sync_state_with_parent(source_process);
gst_element_sync_state_with_parent(source);
_owr_media_source_set_source_bin(media_source, source_pipeline);
_owr_media_source_set_source_tee(media_source, tee);
if (gst_element_set_state(source_pipeline, GST_STATE_PLAYING) == GST_STATE_CHANGE_FAILURE) {
GST_ERROR("Failed to set local source pipeline %s to playing", GST_OBJECT_NAME(source_pipeline));
/* FIXME: We should handle this and don't expose the source */
}
value = _owr_value_table_add(event_data, "end_time", G_TYPE_INT64);
g_value_set_int64(value, g_get_monotonic_time());
OWR_POST_EVENT(media_source, LOCAL_SOURCE_STARTED, event_data);
g_signal_connect(tee, "pad-removed", G_CALLBACK(tee_pad_removed_cb), media_source);
}
gst_object_unref(source_pipeline);
source_element = OWR_MEDIA_SOURCE_CLASS(owr_local_media_source_parent_class)->request_source(media_source, caps);
done:
return source_element;
}
