自学教程：C++ GST_OBJECT_FLAG_SET函数代码示例

static GstPad *gst_funnel_request_new_pad (GstElement * element, GstPadTemplate * templ,    const gchar * name, const GstCaps * caps){  GstPad *sinkpad;  GST_DEBUG_OBJECT (element, "requesting pad");  sinkpad = GST_PAD_CAST (g_object_new (GST_TYPE_FUNNEL_PAD,          "name", name, "direction", templ->direction, "template", templ,          NULL));  gst_pad_set_chain_function (sinkpad,      GST_DEBUG_FUNCPTR (gst_funnel_sink_chain));  gst_pad_set_chain_list_function (sinkpad,      GST_DEBUG_FUNCPTR (gst_funnel_sink_chain_list));  gst_pad_set_event_function (sinkpad,      GST_DEBUG_FUNCPTR (gst_funnel_sink_event));  GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_CAPS);  GST_OBJECT_FLAG_SET (sinkpad, GST_PAD_FLAG_PROXY_ALLOCATION);  gst_pad_set_active (sinkpad, TRUE);  gst_element_add_pad (element, sinkpad);  GST_DEBUG_OBJECT (element, "requested pad %s:%s",      GST_DEBUG_PAD_NAME (sinkpad));  return sinkpad;}

static voidgst_flutsindex_init (GstFluTSIndex * index){  index->writers = g_hash_table_new (NULL, NULL);  index->last_id = 0;  index->id = -1;  GST_OBJECT_FLAG_SET (index, GST_FLUTSINDEX_WRITABLE);  GST_OBJECT_FLAG_SET (index, GST_FLUTSINDEX_READABLE);}

static voidgst_timestampoverlay_init (GstTimeStampOverlay *timestampoverlay){  GST_OBJECT_FLAG_SET (timestampoverlay, GST_ELEMENT_FLAG_REQUIRE_CLOCK);  timestampoverlay->latency = GST_CLOCK_TIME_NONE;  timestampoverlay->realtime_clock = g_object_new (GST_TYPE_SYSTEM_CLOCK,      "clock-type", GST_CLOCK_TYPE_REALTIME, NULL);  GST_OBJECT_FLAG_SET (timestampoverlay->realtime_clock,      GST_CLOCK_FLAG_CAN_SET_MASTER);}

static voidgst_pad_template_init (GstPadTemplate * templ){  /* GstPadTemplate objects are usually leaked */  GST_OBJECT_FLAG_SET (templ, GST_OBJECT_FLAG_MAY_BE_LEAKED);  GST_PAD_TEMPLATE_GTYPE (templ) = G_TYPE_NONE;}

static voidgst_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 voidnle_operation_init (NleOperation * operation){  GST_OBJECT_FLAG_SET (operation, NLE_OBJECT_OPERATION);  nle_operation_reset (operation);  operation->element = NULL;}

/** * gst_bus_set_flushing: * @bus: a #GstBus * @flushing: whether or not to flush the bus * * If @flushing, flush out and unref any messages queued in the bus. Releases * references to the message origin objects. Will flush future messages until * gst_bus_set_flushing() sets @flushing to %FALSE. * * MT safe. */voidgst_bus_set_flushing (GstBus * bus, gboolean flushing){  GstMessage *message;  GList *message_list = NULL;  g_return_if_fail (GST_IS_BUS (bus));  GST_OBJECT_LOCK (bus);  if (flushing) {    GST_OBJECT_FLAG_SET (bus, GST_BUS_FLUSHING);    GST_DEBUG_OBJECT (bus, "set bus flushing");    while ((message = gst_bus_pop (bus)))      message_list = g_list_prepend (message_list, message);  } else {    GST_DEBUG_OBJECT (bus, "unset bus flushing");    GST_OBJECT_FLAG_UNSET (bus, GST_BUS_FLUSHING);  }  GST_OBJECT_UNLOCK (bus);  g_list_free_full (message_list, (GDestroyNotify) gst_message_unref);}

     static gboolean gst_artsdsink_open_audio (GstArtsdsink * sink){  const char connname[] = "gstreamer";  int errcode;  /* Name used by aRtsd for this connection. */  if (sink->connect_name != NULL)    connname = sink->connect_name;  /* FIXME: this should only ever happen once per process. */  /* Really, artsc needs to be made thread safe to fix this (and other related */  /* problems). */  errcode = arts_init ();  if (errcode < 0) {    fprintf (stderr, "arts_init error: %s/n", arts_error_text (errcode));    return FALSE;  }  GST_DEBUG ("artsdsink: attempting to open connection to aRtsd server");  sink->stream = arts_play_stream (sink->frequency, sink->depth,      sink->channels, connname);  /* FIXME: check connection */  /*   GST_DEBUG ("artsdsink: can't open connection to aRtsd server"); */  GST_OBJECT_FLAG_SET (sink, GST_ARTSDSINK_OPEN);  sink->connected = TRUE;  return TRUE;}

static void owr_inter_src_init(OwrInterSrc *self){    GstPad *srcpad, *sinkpad;    GST_OBJECT_FLAG_SET(self, GST_ELEMENT_FLAG_SOURCE);    self->queue = gst_element_factory_make("queue", NULL);    gst_bin_add(GST_BIN(self), self->queue);    srcpad = gst_element_get_static_pad(self->queue, "src");    self->srcpad = gst_ghost_pad_new_from_template("src", srcpad, gst_static_pad_template_get(&src_template));    gst_object_unref(srcpad);    gst_element_add_pad(GST_ELEMENT(self), self->srcpad);    /* Just to allow linking... */    self->dummy_sinkpad = gst_pad_new("dummy_sinkpad", GST_PAD_SINK);    gst_object_set_parent(GST_OBJECT(self->dummy_sinkpad), GST_OBJECT(self));    self->internal_srcpad = gst_pad_new("internal_src", GST_PAD_SRC);    gst_object_set_parent(GST_OBJECT(self->internal_srcpad), GST_OBJECT(self->dummy_sinkpad));    gst_pad_set_event_function(self->internal_srcpad, owr_inter_src_internal_src_event);    gst_pad_set_query_function(self->internal_srcpad, owr_inter_src_internal_src_query);    sinkpad = gst_element_get_static_pad(self->queue, "sink");    gst_pad_link(self->internal_srcpad, sinkpad);    gst_object_unref(sinkpad);}

static voidgst_hls_sink_init (GstHlsSink * sink){  GstPadTemplate *templ = gst_static_pad_template_get (&sink_template);  sink->ghostpad = gst_ghost_pad_new_no_target_from_template ("sink", templ);  gst_object_unref (templ);  gst_element_add_pad (GST_ELEMENT_CAST (sink), sink->ghostpad);  gst_pad_add_probe (sink->ghostpad, GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM,      gst_hls_sink_ghost_event_probe, sink, NULL);  gst_pad_add_probe (sink->ghostpad, GST_PAD_PROBE_TYPE_BUFFER,      gst_hls_sink_ghost_buffer_probe, sink, NULL);  gst_pad_set_chain_list_function (sink->ghostpad, gst_hls_sink_chain_list);  sink->location = g_strdup (DEFAULT_LOCATION);  sink->playlist_location = g_strdup (DEFAULT_PLAYLIST_LOCATION);  sink->playlist_root = g_strdup (DEFAULT_PLAYLIST_ROOT);  sink->playlist_length = DEFAULT_PLAYLIST_LENGTH;  sink->max_files = DEFAULT_MAX_FILES;  sink->target_duration = DEFAULT_TARGET_DURATION;  /* haven't added a sink yet, make it is detected as a sink meanwhile */  GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_FLAG_SINK);  gst_hls_sink_reset (sink);}

static voidgst_v4lmjpegsink_init (GstV4lMjpegSink * v4lmjpegsink){  GstElementClass *klass = GST_ELEMENT_GET_CLASS (v4lmjpegsink);  v4lmjpegsink->sinkpad =      gst_pad_new_from_template (gst_element_class_get_pad_template (klass,          "sink"), "sink");  gst_element_add_pad (GST_ELEMENT (v4lmjpegsink), v4lmjpegsink->sinkpad);  gst_pad_set_chain_function (v4lmjpegsink->sinkpad, gst_v4lmjpegsink_chain);  gst_pad_set_link_function (v4lmjpegsink->sinkpad,      gst_v4lmjpegsink_sinkconnect);  v4lmjpegsink->clock = NULL;  v4lmjpegsink->width = -1;  v4lmjpegsink->height = -1;  v4lmjpegsink->x_offset = -1;  v4lmjpegsink->y_offset = -1;  v4lmjpegsink->numbufs = 64;  v4lmjpegsink->bufsize = 256;  GST_OBJECT_FLAG_SET (v4lmjpegsink, GST_ELEMENT_THREAD_SUGGESTED);}

static GstPadProbeReturnkms_agnostic_bin2_src_reconfigure_probe (GstPad * pad, GstPadProbeInfo * info,    gpointer user_data){  KmsAgnosticBin2 *self = KMS_AGNOSTIC_BIN2 (gst_pad_get_parent_element (pad));  GstPadProbeReturn ret = GST_PAD_PROBE_OK;  GstEvent *event;  if (self == NULL) {    return GST_PAD_PROBE_OK;  }  if (GST_PAD_PROBE_INFO_TYPE (info) & GST_PAD_PROBE_TYPE_EVENT_BOTH) {    event = gst_pad_probe_info_get_event (info);    if (GST_EVENT_TYPE (event) == GST_EVENT_RECONFIGURE) {      KmsAgnosticBin2 *self = user_data;      GST_DEBUG_OBJECT (pad, "Received reconfigure event");      KMS_AGNOSTIC_BIN2_LOCK (self);      GST_OBJECT_FLAG_SET (pad, KMS_AGNOSTIC_PAD_STARTED);      kms_agnostic_bin2_process_pad (self, pad);      KMS_AGNOSTIC_BIN2_UNLOCK (self);    }  }  g_object_unref (self);  return ret;}

static voidgst_hls_sink2_init (GstHlsSink2 * sink){  GstElement *mux;  sink->location = g_strdup (DEFAULT_LOCATION);  sink->playlist_location = g_strdup (DEFAULT_PLAYLIST_LOCATION);  sink->playlist_root = g_strdup (DEFAULT_PLAYLIST_ROOT);  sink->playlist_length = DEFAULT_PLAYLIST_LENGTH;  sink->max_files = DEFAULT_MAX_FILES;  sink->target_duration = DEFAULT_TARGET_DURATION;  g_queue_init (&sink->old_locations);  sink->splitmuxsink = gst_element_factory_make ("splitmuxsink", NULL);  gst_bin_add (GST_BIN (sink), sink->splitmuxsink);  mux = gst_element_factory_make ("mpegtsmux", NULL);  g_object_set (sink->splitmuxsink, "location", sink->location, "max-size-time",      ((GstClockTime) sink->target_duration * GST_SECOND),      "send-keyframe-requests", TRUE, "muxer", mux, "reset-muxer", FALSE, NULL);  GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_FLAG_SINK);  gst_hls_sink2_reset (sink);}

static gbooleandxr3videosink_open (Dxr3VideoSink * sink){  g_return_val_if_fail (!GST_OBJECT_FLAG_IS_SET (sink, DXR3VIDEOSINK_OPEN),      FALSE);  /* Compute the name of the video device file. */  sink->video_filename = g_strdup_printf ("/dev/em8300_mv-%d",      sink->card_number);  sink->video_fd = open (sink->video_filename, O_WRONLY);  if (sink->video_fd < 0) {    GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE,        (_("Could not open video device /"%s/" for writing."),            sink->video_filename), GST_ERROR_SYSTEM);    return FALSE;  }  /* Open the control device. */  sink->control_filename = g_strdup_printf ("/dev/em8300-%d",      sink->card_number);  sink->control_fd = open (sink->control_filename, O_WRONLY);  if (sink->control_fd < 0) {    GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE,        (_("Could not open control device /"%s/" for writing."),            sink->control_filename), GST_ERROR_SYSTEM);    return FALSE;  }  GST_OBJECT_FLAG_SET (sink, DXR3VIDEOSINK_OPEN);  return TRUE;}

static voiddxr3videosink_init (Dxr3VideoSink * sink){  GstPad *pad;  pad = gst_pad_new_from_static_template (&dxr3videosink_sink_factory, "sink");  gst_element_add_pad (GST_ELEMENT (sink), pad);  gst_pad_set_chain_function (pad, dxr3videosink_chain);  GST_OBJECT_FLAG_SET (GST_ELEMENT (sink), GST_ELEMENT_EVENT_AWARE);  sink->card_number = 0;  sink->video_filename = NULL;  sink->video_fd = -1;  sink->control_filename = NULL;  sink->control_fd = -1;  sink->clock = NULL;  sink->last_ts = GST_CLOCK_TIME_NONE;  sink->cur_buf = NULL;  dxr3videosink_reset_parser (sink);}

static voidgst_net_client_clock_constructed (GObject * object){  GstNetClientClock *self = GST_NET_CLIENT_CLOCK (object);  GstClock *internal_clock;  GList *l;  ClockCache *cache = NULL;  G_OBJECT_CLASS (gst_net_client_clock_parent_class)->constructed (object);  G_LOCK (clocks_lock);  for (l = clocks; l; l = l->next) {    ClockCache *tmp = l->data;    GstNetClientInternalClock *internal_clock =        GST_NET_CLIENT_INTERNAL_CLOCK (tmp->clock);    if (strcmp (internal_clock->address, self->priv->address) == 0 &&        internal_clock->port == self->priv->port) {      cache = tmp;      if (cache->remove_id) {        gst_clock_id_unschedule (cache->remove_id);        cache->remove_id = NULL;      }      break;    }  }  if (!cache) {    cache = g_new0 (ClockCache, 1);    cache->clock =        g_object_new (GST_TYPE_NET_CLIENT_INTERNAL_CLOCK, "address",        self->priv->address, "port", self->priv->port, "is-ntp",        self->priv->is_ntp, NULL);    clocks = g_list_prepend (clocks, cache);    /* Not actually leaked but is cached for a while before being disposed,     * see gst_net_client_clock_finalize, so pretend it is to not confuse     * tests. */    GST_OBJECT_FLAG_SET (cache->clock, GST_OBJECT_FLAG_MAY_BE_LEAKED);  }  cache->clocks = g_list_prepend (cache->clocks, self);  GST_OBJECT_LOCK (cache->clock);  if (gst_clock_is_synced (cache->clock))    gst_clock_set_synced (GST_CLOCK (self), TRUE);  self->priv->synced_id =      g_signal_connect (cache->clock, "synced",      G_CALLBACK (gst_net_client_clock_synced_cb), self);  GST_OBJECT_UNLOCK (cache->clock);  G_UNLOCK (clocks_lock);  self->priv->internal_clock = internal_clock = cache->clock;  /* all systems go, cap'n */}

static voidgst_net_client_clock_init (GstNetClientClock * self){  GstNetClientClockPrivate *priv;  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;  priv->base_time = DEFAULT_BASE_TIME;}

static voidgst_ios_gl_memory_allocator_init (GstIOSGLMemoryAllocator * allocator){  GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator);  alloc->mem_type = GST_IOS_GL_MEMORY_ALLOCATOR_NAME;  GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);}

static voidgst_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 voidgst_wl_shm_allocator_init (GstWlShmAllocator * self){  self->parent_instance.mem_type = GST_ALLOCATOR_WL_SHM;  self->parent_instance.mem_map = gst_wl_shm_mem_map;  self->parent_instance.mem_unmap = gst_wl_shm_mem_unmap;  GST_OBJECT_FLAG_SET (self, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);}

static voidgst_gl_buffer_allocator_init (GstGLBufferAllocator * allocator){  GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator);  alloc->mem_type = GST_GL_BUFFER_ALLOCATOR_NAME;  GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);}

static voidgst_gl_memory_pbo_allocator_init (GstGLMemoryPBOAllocator * allocator){  GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator);  alloc->mem_type = GST_GL_MEMORY_PBO_ALLOCATOR_NAME;  GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);}

static voidgst_index_init (GstIndex * index){  index->curgroup = gst_index_group_new (0);  index->maxgroup = 0;  index->groups = g_list_prepend (NULL, index->curgroup);  index->writers = g_hash_table_new (NULL, NULL);  index->last_id = 0;  index->method = GST_INDEX_RESOLVER_PATH;  index->resolver = resolvers[index->method].resolver;  index->resolver_user_data = resolvers[index->method].user_data;  GST_OBJECT_FLAG_SET (index, GST_INDEX_WRITABLE);  GST_OBJECT_FLAG_SET (index, GST_INDEX_READABLE);  GST_DEBUG ("created new index");}

static voidgst_msdk_system_allocator_init (GstMsdkSystemAllocator * allocator){  GstAllocator *const base_allocator = GST_ALLOCATOR_CAST (allocator);  base_allocator->mem_type = GST_MSDK_SYSTEM_MEMORY_NAME;  base_allocator->mem_map_full = gst_msdk_system_memory_map_full;  base_allocator->mem_unmap = gst_msdk_system_memory_unmap;  GST_OBJECT_FLAG_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC);}

static voidgst_auto_video_src_clear_kid (GstAutoVideoSrc * src){  if (src->kid) {    gst_element_set_state (src->kid, GST_STATE_NULL);    gst_bin_remove (GST_BIN (src), src->kid);    src->kid = NULL;    /* Don't loose SOURCE flag */    GST_OBJECT_FLAG_SET (src, GST_ELEMENT_FLAG_SOURCE);  }}

static voidgst_auto_video_sink_clear_kid (GstAutoVideoSink * sink){  if (sink->kid) {    gst_element_set_state (sink->kid, GST_STATE_NULL);    gst_bin_remove (GST_BIN (sink), sink->kid);    sink->kid = NULL;    /* Don't lose the SINK flag */    GST_OBJECT_FLAG_SET (sink, GST_ELEMENT_IS_SINK);  }}

static voidnle_source_init (NleSource * source){  GST_OBJECT_FLAG_SET (source, NLE_OBJECT_SOURCE);  source->element = NULL;  source->priv =      G_TYPE_INSTANCE_GET_PRIVATE (source, NLE_TYPE_SOURCE, NleSourcePrivate);  GST_DEBUG_OBJECT (source, "Setting GstBin async-handling to TRUE");  g_object_set (G_OBJECT (source), "async-handling", TRUE, NULL);}

static GstStateChangeReturngst_sdlvideosink_change_state (GstElement * element, GstStateChange transition){  GstSDLVideoSink *sdlvideosink;  GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS;  g_return_val_if_fail (GST_IS_SDLVIDEOSINK (element),      GST_STATE_CHANGE_FAILURE);  sdlvideosink = GST_SDLVIDEOSINK (element);  switch (transition) {    case GST_STATE_CHANGE_NULL_TO_READY:      sdlvideosink->is_xwindows = GST_IS_X_OVERLAY (sdlvideosink);      g_mutex_lock (sdlvideosink->lock);      if (!gst_sdlvideosink_initsdl (sdlvideosink)) {        g_mutex_unlock (sdlvideosink->lock);        goto init_failed;      }      GST_OBJECT_FLAG_SET (sdlvideosink, GST_SDLVIDEOSINK_OPEN);      g_mutex_unlock (sdlvideosink->lock);      break;    default:                   /* do nothing */      break;  }  ret = GST_ELEMENT_CLASS (parent_class)->change_state (element, transition);  switch (transition) {    case GST_STATE_CHANGE_PAUSED_TO_READY:      sdlvideosink->framerate_n = 0;      sdlvideosink->framerate_d = 1;      g_mutex_lock (sdlvideosink->lock);      gst_sdlvideosink_destroy (sdlvideosink);      g_mutex_unlock (sdlvideosink->lock);      break;    case GST_STATE_CHANGE_READY_TO_NULL:      g_mutex_lock (sdlvideosink->lock);      gst_sdlvideosink_deinitsdl (sdlvideosink);      GST_OBJECT_FLAG_UNSET (sdlvideosink, GST_SDLVIDEOSINK_OPEN);      g_mutex_unlock (sdlvideosink->lock);      break;    default:                   /* do nothing */      break;  }  return ret;init_failed:  {    /* method posted detailed error message */    GST_DEBUG_OBJECT (sdlvideosink, "init failed");    return GST_STATE_CHANGE_FAILURE;  }}

static voidgst_splitmux_sink_init (GstSplitMuxSink * splitmux){  g_mutex_init (&splitmux->lock);  g_cond_init (&splitmux->data_cond);  splitmux->mux_overhead = DEFAULT_MUXER_OVERHEAD;  splitmux->threshold_time = DEFAULT_MAX_SIZE_TIME;  splitmux->threshold_bytes = DEFAULT_MAX_SIZE_BYTES;  GST_OBJECT_FLAG_SET (splitmux, GST_ELEMENT_FLAG_SINK);}