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

/** * gst_buffer_pool_config_add_option: * @config: a #GstBufferPool configuration * @option: an option to add * * Enabled the option in @config. This will instruct the @bufferpool to enable * the specified option on the buffers that it allocates. * * The supported options by @pool can be retrieved with gst_buffer_pool_get_options(). */voidgst_buffer_pool_config_add_option (GstStructure * config, const gchar * option){  const GValue *value;  GValue option_value = { 0, };  guint i, len;  g_return_if_fail (config != NULL);  value = gst_structure_id_get_value (config, GST_QUARK (OPTIONS));  if (value) {    len = gst_value_array_get_size (value);    for (i = 0; i < len; ++i) {      const GValue *nth_val = gst_value_array_get_value (value, i);      if (g_str_equal (option, g_value_get_string (nth_val)))        return;    }  } else {    GValue new_array_val = { 0, };    g_value_init (&new_array_val, GST_TYPE_ARRAY);    gst_structure_id_take_value (config, GST_QUARK (OPTIONS), &new_array_val);    value = gst_structure_id_get_value (config, GST_QUARK (OPTIONS));  }  g_value_init (&option_value, G_TYPE_STRING);  g_value_set_string (&option_value, option);  gst_value_array_append_value ((GValue *) value, &option_value);  g_value_unset (&option_value);}

/** * gst_event_parse_step: * @event: The event to query * @format: (out) (allow-none): a pointer to store the format in * @amount: (out) (allow-none): a pointer to store the amount in * @rate: (out) (allow-none): a pointer to store the rate in * @flush: (out) (allow-none): a pointer to store the flush boolean in * @intermediate: (out) (allow-none): a pointer to store the intermediate *     boolean in * * Parse the step event. */voidgst_event_parse_step (GstEvent * event, GstFormat * format, guint64 * amount,    gdouble * rate, gboolean * flush, gboolean * intermediate){  const GstStructure *structure;  g_return_if_fail (GST_IS_EVENT (event));  g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_STEP);  structure = GST_EVENT_STRUCTURE (event);  if (format)    *format =        (GstFormat) g_value_get_enum (gst_structure_id_get_value (structure,            GST_QUARK (FORMAT)));  if (amount)    *amount = g_value_get_uint64 (gst_structure_id_get_value (structure,            GST_QUARK (AMOUNT)));  if (rate)    *rate = g_value_get_double (gst_structure_id_get_value (structure,            GST_QUARK (RATE)));  if (flush)    *flush = g_value_get_boolean (gst_structure_id_get_value (structure,            GST_QUARK (FLUSH)));  if (intermediate)    *intermediate = g_value_get_boolean (gst_structure_id_get_value (structure,            GST_QUARK (INTERMEDIATE)));}

/** * gst_event_parse_buffer_size: * @event: The event to query * @format: (out): A pointer to store the format in * @minsize: (out): A pointer to store the minsize in * @maxsize: (out): A pointer to store the maxsize in * @async: (out): A pointer to store the async-flag in * * Get the format, minsize, maxsize and async-flag in the buffersize event. */voidgst_event_parse_buffer_size (GstEvent * event, GstFormat * format,    gint64 * minsize, gint64 * maxsize, gboolean * async){  const GstStructure *structure;  g_return_if_fail (GST_IS_EVENT (event));  g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_BUFFERSIZE);  structure = GST_EVENT_STRUCTURE (event);  if (format)    *format = (GstFormat)        g_value_get_enum (gst_structure_id_get_value (structure,            GST_QUARK (FORMAT)));  if (minsize)    *minsize =        g_value_get_int64 (gst_structure_id_get_value (structure,            GST_QUARK (MINSIZE)));  if (maxsize)    *maxsize =        g_value_get_int64 (gst_structure_id_get_value (structure,            GST_QUARK (MAXSIZE)));  if (async)    *async =        g_value_get_boolean (gst_structure_id_get_value (structure,            GST_QUARK (ASYNC)));}

/** * gst_event_parse_qos: * @event: The event to query * @type: (out): A pointer to store the QoS type in * @proportion: (out): A pointer to store the proportion in * @diff: (out): A pointer to store the diff in * @timestamp: (out): A pointer to store the timestamp in * * Get the type, proportion, diff and timestamp in the qos event. See * gst_event_new_qos() for more information about the different QoS values. */voidgst_event_parse_qos (GstEvent * event, GstQOSType * type,    gdouble * proportion, GstClockTimeDiff * diff, GstClockTime * timestamp){  const GstStructure *structure;  g_return_if_fail (GST_IS_EVENT (event));  g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_QOS);  structure = GST_EVENT_STRUCTURE (event);  if (type)    *type = (GstQOSType)        g_value_get_enum (gst_structure_id_get_value (structure,            GST_QUARK (TYPE)));  if (proportion)    *proportion =        g_value_get_double (gst_structure_id_get_value (structure,            GST_QUARK (PROPORTION)));  if (diff)    *diff =        g_value_get_int64 (gst_structure_id_get_value (structure,            GST_QUARK (DIFF)));  if (timestamp)    *timestamp =        g_value_get_uint64 (gst_structure_id_get_value (structure,            GST_QUARK (TIMESTAMP)));}

/** * gst_buffer_pool_config_set_allocator: * @config: a #GstBufferPool configuration * @allocator: a #GstAllocator * @params: #GstAllocationParams * * Set the @allocator and @params on @config. * * One of @allocator and @params can be NULL, but not both. When @allocator * is NULL, the default allocator of the pool will use the values in @param * to perform its allocation. When @param is NULL, the pool will use the * provided allocator with its default #GstAllocationParams. * * A call to gst_buffer_pool_set_config() can update the allocator and params * with the values that it is able to do. Some pools are, for example, not able * to operate with different allocators or cannot allocate with the values * specified in @params. Use gst_buffer_pool_get_config() to get the currently * used values. */voidgst_buffer_pool_config_set_allocator (GstStructure * config,    GstAllocator * allocator, const GstAllocationParams * params){  g_return_if_fail (config != NULL);  g_return_if_fail (allocator != NULL || params != NULL);  gst_structure_id_set (config,      GST_QUARK (ALLOCATOR), GST_TYPE_ALLOCATOR, allocator,      GST_QUARK (PARAMS), GST_TYPE_ALLOCATION_PARAMS, params, NULL);}

/** * gst_event_new_stream_start: * @stream_id: Identifier for this stream * * Create a new STREAM_START event. The stream start event can only * travel downstream synchronized with the buffer flow. It is expected * to be the first event that is sent for a new stream. * * Source elements, demuxers and other elements that create new streams * are supposed to send this event as the first event of a new stream. It * should not be send after a flushing seek or in similar situations * and is used to mark the beginning of a new logical stream. Elements * combining multiple streams must ensure that this event is only forwarded * downstream once and not for every single input stream. * * The @stream_id should be a unique string that consists of the upstream * stream-id, / as separator and a unique stream-id for this specific * stream. A new stream-id should only be created for a stream if the upstream * stream is split into (potentially) multiple new streams, e.g. in a demuxer, * but not for every single element in the pipeline. * gst_pad_create_stream_id() or gst_pad_create_stream_id_printf() can be * used to create a stream-id. * * Returns: (transfer full): the new STREAM_START event. */GstEvent *gst_event_new_stream_start (const gchar * stream_id){  GstStructure *s;  g_return_val_if_fail (stream_id != NULL, NULL);  s = gst_structure_new_id (GST_QUARK (EVENT_STREAM_START),      GST_QUARK (STREAM_ID), G_TYPE_STRING, stream_id, NULL);  return gst_event_new_custom (GST_EVENT_STREAM_START, s);}

/** * gst_event_new_flush_stop: * @reset_time: if time should be reset * * Allocate a new flush stop event. The flush stop event can be sent * upstream and downstream and travels serialized with the dataflow. * It is typically sent after sending a FLUSH_START event to make the * pads accept data again. * * Elements can process this event synchronized with the dataflow since * the preceeding FLUSH_START event stopped the dataflow. * * This event is typically generated to complete a seek and to resume * dataflow. * * Returns: (transfer full): a new flush stop event. */GstEvent *gst_event_new_flush_stop (gboolean reset_time){  GstEvent *event;  GST_CAT_INFO (GST_CAT_EVENT, "creating flush stop %d", reset_time);  event = gst_event_new_custom (GST_EVENT_FLUSH_STOP,      gst_structure_new_id (GST_QUARK (EVENT_FLUSH_STOP),          GST_QUARK (RESET_TIME), G_TYPE_BOOLEAN, reset_time, NULL));  return event;}

/** * gst_event_new_toc_select: * @uid: UID in the TOC to start playback from. * * Generate a TOC select event with the given @uid. The purpose of the * TOC select event is to start playback based on the TOC's entry with the * given @uid. * * Returns: a new #GstEvent. */GstEvent *gst_event_new_toc_select (const gchar * uid){  GstStructure *structure;  g_return_val_if_fail (uid != NULL, NULL);  GST_CAT_INFO (GST_CAT_EVENT, "creating toc select event for UID: %s", uid);  structure = gst_structure_new_id (GST_QUARK (EVENT_TOC_SELECT),      GST_QUARK (UID), G_TYPE_STRING, uid, NULL);  return gst_event_new_custom (GST_EVENT_TOC_SELECT, structure);}

/** * gst_buffer_pool_config_set_params: * @config: a #GstBufferPool configuration * @caps: caps for the buffers * @size: the size of each buffer, not including prefix and padding * @min_buffers: the minimum amount of buffers to allocate. * @max_buffers: the maximum amount of buffers to allocate or 0 for unlimited. * * Configure @config with the given parameters. */voidgst_buffer_pool_config_set_params (GstStructure * config, GstCaps * caps,    guint size, guint min_buffers, guint max_buffers){  g_return_if_fail (config != NULL);  g_return_if_fail (max_buffers == 0 || min_buffers <= max_buffers);  g_return_if_fail (caps == NULL || gst_caps_is_fixed (caps));  gst_structure_id_set (config,      GST_QUARK (CAPS), GST_TYPE_CAPS, caps,      GST_QUARK (SIZE), G_TYPE_UINT, size,      GST_QUARK (MIN_BUFFERS), G_TYPE_UINT, min_buffers,      GST_QUARK (MAX_BUFFERS), G_TYPE_UINT, max_buffers, NULL);}

/** * gst_event_parse_gap: * @event: a #GstEvent of type #GST_EVENT_GAP * @timestamp: (out) (allow-none): location where to store the *     start time (pts) of the gap, or %NULL * @duration: (out) (allow-none): location where to store the duration of *     the gap, or %NULL * * Extract timestamp and duration from a new GAP event. */voidgst_event_parse_gap (GstEvent * event, GstClockTime * timestamp,    GstClockTime * duration){  GstStructure *structure;  g_return_if_fail (GST_IS_EVENT (event));  g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_GAP);  structure = GST_EVENT_STRUCTURE (event);  gst_structure_id_get (structure,      GST_QUARK (TIMESTAMP), GST_TYPE_CLOCK_TIME, timestamp,      GST_QUARK (DURATION), GST_TYPE_CLOCK_TIME, duration, NULL);}

/** * gst_event_parse_toc: * @event: a TOC event. * @toc: (out) (transfer full): pointer to #GstToc structure. * @updated: (out): pointer to store TOC updated flag. * * Parse a TOC @event and store the results in the given @toc and @updated locations. */voidgst_event_parse_toc (GstEvent * event, GstToc ** toc, gboolean * updated){  const GstStructure *structure;  g_return_if_fail (event != NULL);  g_return_if_fail (GST_EVENT_TYPE (event) == GST_EVENT_TOC);  g_return_if_fail (toc != NULL);  structure = gst_event_get_structure (event);  gst_structure_id_get (structure,      GST_QUARK (TOC), GST_TYPE_TOC, toc,      GST_QUARK (UPDATED), G_TYPE_BOOLEAN, updated, NULL);}

/** * gst_event_new_latency: * @latency: the new latency value * * Create a new latency event. The event is sent upstream from the sinks and * notifies elements that they should add an additional @latency to the * running time before synchronising against the clock. * * The latency is mostly used in live sinks and is always expressed in * the time format. * * Returns: (transfer full): a new #GstEvent */GstEvent *gst_event_new_latency (GstClockTime latency){  GstEvent *event;  GstStructure *structure;  GST_CAT_INFO (GST_CAT_EVENT,      "creating latency event %" GST_TIME_FORMAT, GST_TIME_ARGS (latency));  structure = gst_structure_new_id (GST_QUARK (EVENT_LATENCY),      GST_QUARK (LATENCY), G_TYPE_UINT64, latency, NULL);  event = gst_event_new_custom (GST_EVENT_LATENCY, structure);  return event;}

/** * gst_buffer_pool_config_get_params: * @config: (transfer none): a #GstBufferPool configuration * @caps: (out) (transfer none) (allow-none): the caps of buffers * @size: (out) (allow-none): the size of each buffer, not including prefix and padding * @min_buffers: (out) (allow-none): the minimum amount of buffers to allocate. * @max_buffers: (out) (allow-none): the maximum amount of buffers to allocate or 0 for unlimited. * * Get the configuration values from @config. * * Returns: %TRUE if all parameters could be fetched. */gbooleangst_buffer_pool_config_get_params (GstStructure * config, GstCaps ** caps,    guint * size, guint * min_buffers, guint * max_buffers){  g_return_val_if_fail (config != NULL, FALSE);  if (caps) {    *caps = g_value_get_boxed (gst_structure_id_get_value (config,            GST_QUARK (CAPS)));  }  return gst_structure_id_get (config,      GST_QUARK (SIZE), G_TYPE_UINT, size,      GST_QUARK (MIN_BUFFERS), G_TYPE_UINT, min_buffers,      GST_QUARK (MAX_BUFFERS), G_TYPE_UINT, max_buffers, NULL);}

/** * gst_event_new_caps: * @caps: (transfer none): a #GstCaps * * Create a new CAPS event for @caps. The caps event can only travel downstream * synchronized with the buffer flow and contains the format of the buffers * that will follow after the event. * * Returns: (transfer full): the new CAPS event. */GstEvent *gst_event_new_caps (GstCaps * caps){  GstEvent *event;  g_return_val_if_fail (caps != NULL, NULL);  g_return_val_if_fail (gst_caps_is_fixed (caps), NULL);  GST_CAT_INFO (GST_CAT_EVENT, "creating caps event %" GST_PTR_FORMAT, caps);  event = gst_event_new_custom (GST_EVENT_CAPS,      gst_structure_new_id (GST_QUARK (EVENT_CAPS),          GST_QUARK (CAPS), GST_TYPE_CAPS, caps, NULL));  return event;}