void test_value_collection() { GstBuffer *buf = NULL; MyFoo *foo; xmlfile = "gstminiobject_test_value_collection"; std_log(LOG_FILENAME_LINE, "Test Started test_value_collection"); foo = (MyFoo *) g_object_new (my_foo_get_type (), NULL); /* test g_object_get() refcounting */ g_object_get (foo, "buffer", &buf, NULL); g_assert (GST_IS_BUFFER (buf)); g_assert (GST_MINI_OBJECT_REFCOUNT_VALUE (GST_MINI_OBJECT_CAST (buf)) == 1); gst_buffer_unref (buf); /* test g_object_set() refcounting */ buf = gst_buffer_new_and_alloc (1024); g_object_set (foo, "buffer", buf, NULL); g_assert (GST_MINI_OBJECT_REFCOUNT_VALUE (GST_MINI_OBJECT_CAST (buf)) == 1); gst_buffer_unref (buf); g_object_unref (foo); std_log(LOG_FILENAME_LINE, "Test Successful"); create_xml(0); }
static MXFMetadataFileDescriptor * mxf_up_get_rgba_descriptor (GstPadTemplate * tmpl, GstCaps * caps, MXFEssenceElementWriteFunc * handler, gpointer * mapping_data) { MXFMetadataRGBAPictureEssenceDescriptor *ret; guint i; GstCaps *tmp, *intersection; MXFUPMappingData *md = g_new0 (MXFUPMappingData, 1); *mapping_data = md; ret = (MXFMetadataRGBAPictureEssenceDescriptor *) gst_mini_object_new (MXF_TYPE_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR); for (i = 0; i < G_N_ELEMENTS (_rgba_mapping_table); i++) { tmp = gst_caps_from_string (_rgba_mapping_table[i].caps); intersection = gst_caps_intersect (caps, tmp); gst_caps_unref (tmp); if (!gst_caps_is_empty (intersection)) { gst_caps_unref (intersection); ret->n_pixel_layout = _rgba_mapping_table[i].n_pixel_layout; ret->pixel_layout = g_new0 (guint8, ret->n_pixel_layout * 2); md->fourcc = _rgba_mapping_table[i].fourcc; md->bpp = _rgba_mapping_table[i].n_pixel_layout; memcpy (ret->pixel_layout, _rgba_mapping_table[i].pixel_layout, ret->n_pixel_layout * 2); break; } gst_caps_unref (intersection); } if (md->fourcc == 0) { GST_ERROR ("Invalid caps %" GST_PTR_FORMAT, caps); gst_mini_object_unref (GST_MINI_OBJECT_CAST (ret)); return NULL; } memcpy (&ret->parent.parent.essence_container, &up_essence_container_ul, 16); if (!mxf_metadata_generic_picture_essence_descriptor_from_caps (&ret->parent, caps)) { gst_mini_object_unref (GST_MINI_OBJECT_CAST (ret)); return NULL; } md->width = ret->parent.stored_width; md->height = ret->parent.stored_height; *handler = mxf_up_write_func; return (MXFMetadataFileDescriptor *) ret; }
static void print_buffer_metadata(WebKitVideoSink* sink, GstBuffer* buffer) { gchar dts_str[64], pts_str[64], dur_str[64]; gchar flag_str[100]; if (GST_BUFFER_DTS (buffer) != GST_CLOCK_TIME_NONE) { g_snprintf (dts_str, sizeof (dts_str), "%" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DTS (buffer))); } else { g_strlcpy (dts_str, "none", sizeof (dts_str)); } if (GST_BUFFER_PTS (buffer) != GST_CLOCK_TIME_NONE) { g_snprintf (pts_str, sizeof (pts_str), "%" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_PTS (buffer))); } else { g_strlcpy (pts_str, "none", sizeof (pts_str)); } if (GST_BUFFER_DURATION (buffer) != GST_CLOCK_TIME_NONE) { g_snprintf (dur_str, sizeof (dur_str), "%" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DURATION (buffer))); } else { g_strlcpy (dur_str, "none", sizeof (dur_str)); } { const char *flag_list[15] = { "", "", "", "", "live", "decode-only", "discont", "resync", "corrupted", "marker", "header", "gap", "droppable", "delta-unit", "in-caps" }; guint i; char *end = flag_str; end[0] = '\0'; for (i = 0; i < G_N_ELEMENTS (flag_list); i++) { if (GST_MINI_OBJECT_CAST (buffer)->flags & (1 << i)) { strcpy (end, flag_list[i]); end += strlen (end); end[0] = ' '; end[1] = '\0'; end++; } } } g_printerr ("chain ******* (%s:%s) (%u bytes, dts: %s, pts: %s" ", duration: %s, offset: %" G_GINT64_FORMAT ", offset_end: %" G_GINT64_FORMAT ", flags: %08x %s) %p\n", GST_DEBUG_PAD_NAME (GST_BASE_SINK_CAST (sink)->sinkpad), (guint) gst_buffer_get_size (buffer), dts_str, pts_str, dur_str, GST_BUFFER_OFFSET (buffer), GST_BUFFER_OFFSET_END (buffer), GST_MINI_OBJECT_CAST (buffer)->flags, flag_str, buffer); }
static GstPadProbeReturn events_cb (GstPad * pad, GstPadProbeInfo * probe_info, gpointer user_data) { APP_STATE_T *state = (APP_STATE_T *) user_data; GstEvent *event = GST_PAD_PROBE_INFO_EVENT (probe_info); switch (GST_EVENT_TYPE (event)) { case GST_EVENT_CAPS: { if (state->caps) { gst_caps_unref (state->caps); state->caps = NULL; } gst_event_parse_caps (event, &state->caps); if (state->caps) gst_caps_ref (state->caps); break; } case GST_EVENT_FLUSH_START: flush_start (state); break; case GST_EVENT_FLUSH_STOP: flush_stop (state); break; case GST_EVENT_EOS: queue_object (state, GST_MINI_OBJECT_CAST (gst_event_ref (event)), FALSE); break; default: break; } return GST_PAD_PROBE_OK; }
static void gst_value_mini_object_free (GValue * value) { if (value->data[0].v_pointer) { gst_mini_object_unref (GST_MINI_OBJECT_CAST (value->data[0].v_pointer)); } }
static void gst_mini_object_init (GTypeInstance * instance, gpointer klass) { GstMiniObject *mini_object = GST_MINI_OBJECT_CAST (instance); mini_object->refcount = 1; }
static GstFlowReturn gst_fake_sink_render (GstBaseSink * bsink, GstBuffer * buf) { GstFakeSink *sink = GST_FAKE_SINK_CAST (bsink); if (sink->num_buffers_left == 0) goto eos; if (sink->num_buffers_left != -1) sink->num_buffers_left--; if (!sink->silent) { gchar ts_str[64], dur_str[64]; GST_OBJECT_LOCK (sink); g_free (sink->last_message); if (GST_BUFFER_TIMESTAMP (buf) != GST_CLOCK_TIME_NONE) { g_snprintf (ts_str, sizeof (ts_str), "%" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf))); } else { g_strlcpy (ts_str, "none", sizeof (ts_str)); } if (GST_BUFFER_DURATION (buf) != GST_CLOCK_TIME_NONE) { g_snprintf (dur_str, sizeof (dur_str), "%" GST_TIME_FORMAT, GST_TIME_ARGS (GST_BUFFER_DURATION (buf))); } else { g_strlcpy (dur_str, "none", sizeof (dur_str)); } sink->last_message = g_strdup_printf ("chain ******* < (%5d bytes, timestamp: %s" ", duration: %s, offset: %" G_GINT64_FORMAT ", offset_end: %" G_GINT64_FORMAT ", flags: %d) %p", GST_BUFFER_SIZE (buf), ts_str, dur_str, GST_BUFFER_OFFSET (buf), GST_BUFFER_OFFSET_END (buf), GST_MINI_OBJECT_CAST (buf)->flags, buf); GST_OBJECT_UNLOCK (sink); gst_fake_sink_notify_last_message (sink); } if (sink->signal_handoffs) g_signal_emit (sink, gst_fake_sink_signals[SIGNAL_HANDOFF], 0, buf, bsink->sinkpad); if (sink->dump) { gst_util_dump_mem (GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf)); } if (sink->num_buffers_left == 0) goto eos; return GST_FLOW_OK; /* ERRORS */ eos: { GST_DEBUG_OBJECT (sink, "we are EOS"); return GST_FLOW_UNEXPECTED; } }
GstEGLImage * gst_egl_image_new_wrapped (GstGLContext * context, EGLImageKHR image, GstVideoGLTextureType type, GstVideoGLTextureOrientation orientation, gpointer user_data, GstEGLImageDestroyNotify user_data_destroy) { GstEGLImage *img = NULL; g_return_val_if_fail (context != NULL, NULL); g_return_val_if_fail (GST_IS_GL_CONTEXT_EGL (context), NULL); g_return_val_if_fail (image != EGL_NO_IMAGE_KHR, NULL); img = g_new0 (GstEGLImage, 1); gst_mini_object_init (GST_MINI_OBJECT_CAST (img), 0, GST_TYPE_EGL_IMAGE, (GstMiniObjectCopyFunction) _gst_egl_image_copy, NULL, (GstMiniObjectFreeFunction) _gst_egl_image_free); img->context = gst_object_ref (context); img->image = image; img->type = type; img->orientation = orientation; img->destroy_data = user_data; img->destroy_notify = user_data_destroy; return img; }
/* Returns a newly allocated string describing the flags on this buffer */ char * gst_buffer_get_flags_string (GstBuffer * buffer) { static const char flag_strings[] = "\000\000\000\000live\000decode-only\000discont\000resync\000corrupted\000" "marker\000header\000gap\000droppable\000delta-unit\000tag-memory\000" "FIXME"; static const guint8 flag_idx[] = { 0, 1, 2, 3, 4, 9, 21, 29, 36, 46, 53, 60, 64, 74, 85, 96 }; int i, max_bytes; char *flag_str, *end; /* max size is all flag strings plus a space or terminator after each one */ max_bytes = sizeof (flag_strings); flag_str = g_malloc (max_bytes); end = flag_str; end[0] = '\0'; for (i = BUFFER_FLAG_SHIFT; i < G_N_ELEMENTS (flag_idx); i++) { if (GST_MINI_OBJECT_CAST (buffer)->flags & (1 << i)) { strcpy (end, flag_strings + flag_idx[i]); end += strlen (end); end[0] = ' '; end[1] = '\0'; end++; } } return flag_str; }
static void gst_context_init (GstContext * context) { gst_mini_object_init (GST_MINI_OBJECT_CAST (context), 0, _gst_context_type, (GstMiniObjectCopyFunction) _gst_context_copy, NULL, (GstMiniObjectFreeFunction) _gst_context_free); }
/** * gst_memory_init: (skip) * @mem: a #GstMemory * @flags: #GstMemoryFlags * @allocator: the #GstAllocator * @parent: the parent of @mem * @maxsize: the total size of the memory * @align: the alignment of the memory * @offset: The offset in the memory * @size: the size of valid data in the memory * Initializes a newly allocated @mem with the given parameters. This function * will call gst_mini_object_init() with the default memory parameters. */ void gst_memory_init (GstMemory * mem, GstMemoryFlags flags, GstAllocator * allocator, GstMemory * parent, gsize maxsize, gsize align, gsize offset, gsize size) { gst_mini_object_init (GST_MINI_OBJECT_CAST (mem), flags | GST_MINI_OBJECT_FLAG_LOCKABLE, GST_TYPE_MEMORY, (GstMiniObjectCopyFunction) _gst_memory_copy, NULL, (GstMiniObjectFreeFunction) _gst_memory_free); mem->allocator = gst_object_ref (allocator); if (parent) { gst_memory_lock (parent, GST_LOCK_FLAG_EXCLUSIVE); gst_memory_ref (parent); } mem->parent = parent; mem->maxsize = maxsize; mem->align = align; mem->offset = offset; mem->size = size; GST_CAT_DEBUG (GST_CAT_MEMORY, "new memory %p, maxsize:%" G_GSIZE_FORMAT " offset:%" G_GSIZE_FORMAT " size:%" G_GSIZE_FORMAT, mem, maxsize, offset, size); }
static void preroll_cb (GstElement * fakesink, GstBuffer * buffer, GstPad * pad, gpointer user_data) { APP_STATE_T *state = (APP_STATE_T *) user_data; queue_object (state, GST_MINI_OBJECT_CAST (gst_buffer_ref (buffer)), FALSE); }
/** * gst_toc_append_entry: * @toc: A #GstToc instance * @entry: (transfer full): A #GstTocEntry * * Appends the #GstTocEntry @entry to @toc. */ void gst_toc_append_entry (GstToc * toc, GstTocEntry * entry) { g_return_if_fail (toc != NULL); g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (toc))); g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (entry))); g_return_if_fail (entry->toc == NULL); g_return_if_fail (entry->parent == NULL); toc->entries = g_list_append (toc->entries, entry); entry->toc = toc; GST_LOG ("appended %s entry with uid %s to toc %p", gst_toc_entry_type_get_nick (entry->type), entry->uid, toc); gst_toc_dump (toc); }
static void gst_subbuffer_finalize (GstSubBuffer * buffer) { gst_buffer_unref (buffer->parent); GST_MINI_OBJECT_CLASS (sub_parent_class)-> finalize (GST_MINI_OBJECT_CAST (buffer)); }
static GstFlowReturn gst_funnel_sink_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer) { GstFunnel *funnel = GST_FUNNEL (parent); return gst_funnel_sink_chain_object (pad, funnel, FALSE, GST_MINI_OBJECT_CAST (buffer)); }
/** * gst_rtsp_token_writable_structure: * @token: The #GstRTSPToken. * * Get a writable version of the structure. * * Returns: (transfer none): The structure of the token. The structure is still * owned by the token, which means that you should not free it and that the * pointer becomes invalid when you free the token. This function checks if * @token is writable and will never return %NULL. * * MT safe. */ GstStructure * gst_rtsp_token_writable_structure (GstRTSPToken * token) { g_return_val_if_fail (GST_IS_RTSP_TOKEN (token), NULL); g_return_val_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (token)), NULL); return GST_RTSP_TOKEN_STRUCTURE (token); }
/** * gst_toc_entry_append_sub_entry: * @entry: A #GstTocEntry instance * @subentry: (transfer full): A #GstTocEntry * * Appends the #GstTocEntry @subentry to @entry. */ void gst_toc_entry_append_sub_entry (GstTocEntry * entry, GstTocEntry * subentry) { g_return_if_fail (entry != NULL); g_return_if_fail (subentry != NULL); g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (entry))); g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (subentry))); g_return_if_fail (subentry->toc == NULL); g_return_if_fail (subentry->parent == NULL); entry->subentries = g_list_append (entry->subentries, subentry); subentry->toc = entry->toc; subentry->parent = entry; GST_LOG ("appended %s subentry with uid %s to entry %s", gst_toc_entry_type_get_nick (subentry->type), subentry->uid, entry->uid); }
static GstFlowReturn gst_funnel_sink_chain_list (GstPad * pad, GstObject * parent, GstBufferList * list) { GstFunnel *funnel = GST_FUNNEL (parent); return gst_funnel_sink_chain_object (pad, funnel, TRUE, GST_MINI_OBJECT_CAST (list)); }
/** * gst_toc_entry_set_tags: * @entry: A #GstTocEntry instance * @tags: (allow-none) (transfer full): A #GstTagList or %NULL * * Set a #GstTagList with tags for the complete @entry. */ void gst_toc_entry_set_tags (GstTocEntry * entry, GstTagList * tags) { g_return_if_fail (entry != NULL); g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (entry))); if (entry->tags) gst_tag_list_unref (entry->tags); entry->tags = tags; }
/** * gst_toc_set_tags: * @toc: A #GstToc instance * @tags: (allow-none) (transfer full): A #GstTagList or %NULL * * Set a #GstTagList with tags for the complete @toc. */ void gst_toc_set_tags (GstToc * toc, GstTagList * tags) { g_return_if_fail (toc != NULL); g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (toc))); if (toc->tags) gst_tag_list_unref (toc->tags); toc->tags = tags; }
static MXFMetadataFileDescriptor * mxf_jpeg2000_get_descriptor (GstPadTemplate * tmpl, GstCaps * caps, MXFEssenceElementWriteFunc * handler, gpointer * mapping_data) { MXFMetadataRGBAPictureEssenceDescriptor *ret; GstStructure *s; guint32 fourcc; s = gst_caps_get_structure (caps, 0); if (strcmp (gst_structure_get_name (s), "image/x-jpc") != 0 || !gst_structure_get_fourcc (s, "fourcc", &fourcc)) { GST_ERROR ("Invalid caps %" GST_PTR_FORMAT, caps); return NULL; } ret = (MXFMetadataRGBAPictureEssenceDescriptor *) gst_mini_object_new (MXF_TYPE_METADATA_RGBA_PICTURE_ESSENCE_DESCRIPTOR); memcpy (&ret->parent.parent.essence_container, &jpeg2000_essence_container_ul, 16); memcpy (&ret->parent.picture_essence_coding, &jpeg2000_picture_essence_coding, 16); if (fourcc == GST_MAKE_FOURCC ('s', 'R', 'G', 'B')) { ret->n_pixel_layout = 3; ret->pixel_layout = g_new0 (guint8, 6); ret->pixel_layout[0] = 'R'; ret->pixel_layout[1] = 8; ret->pixel_layout[2] = 'G'; ret->pixel_layout[3] = 8; ret->pixel_layout[4] = 'B'; ret->pixel_layout[5] = 8; } else if (fourcc == GST_MAKE_FOURCC ('s', 'Y', 'U', 'V')) { ret->n_pixel_layout = 3; ret->pixel_layout = g_new0 (guint8, 6); ret->pixel_layout[0] = 'Y'; ret->pixel_layout[1] = 8; ret->pixel_layout[2] = 'U'; ret->pixel_layout[3] = 8; ret->pixel_layout[4] = 'V'; ret->pixel_layout[5] = 8; } else { g_assert_not_reached (); } if (!mxf_metadata_generic_picture_essence_descriptor_from_caps (&ret->parent, caps)) { gst_mini_object_unref (GST_MINI_OBJECT_CAST (ret)); return NULL; } *handler = mxf_jpeg2000_write_func; return (MXFMetadataFileDescriptor *) ret; }
static void gst_event_init (GstEventImpl * event, GstEventType type) { gst_mini_object_init (GST_MINI_OBJECT_CAST (event), 0, _gst_event_type, (GstMiniObjectCopyFunction) _gst_event_copy, NULL, (GstMiniObjectFreeFunction) _gst_event_free); GST_EVENT_TYPE (event) = type; GST_EVENT_TIMESTAMP (event) = GST_CLOCK_TIME_NONE; GST_EVENT_SEQNUM (event) = gst_util_seqnum_next (); }
KmsSCTPResult kms_sctp_connection_accept (KmsSCTPConnection * conn, GCancellable * cancellable, KmsSCTPConnection ** client, GError ** err) { KmsSCTPConnection *ccon; GSocket *socket; g_return_val_if_fail (conn != NULL, KMS_SCTP_ERROR); g_return_val_if_fail (conn->socket != NULL, KMS_SCTP_ERROR); socket = g_socket_accept (conn->socket, cancellable, err); if (socket == NULL) return KMS_SCTP_ERROR; ccon = g_slice_new0 (KmsSCTPConnection); gst_mini_object_init (GST_MINI_OBJECT_CAST (ccon), 0, _kms_sctp_connection_type, NULL, NULL, (GstMiniObjectFreeFunction) _kms_sctp_connection_free); ccon->socket = socket; if (!kms_sctp_connection_set_event_subscribe (ccon, KMS_SCTP_DATA_IO_EVENT, err)) { kms_sctp_connection_unref (ccon); return KMS_SCTP_ERROR; } if (G_UNLIKELY (GST_LEVEL_DEBUG <= _gst_debug_min)) #if defined (SCTP_INITMSG) { struct sctp_initmsg initmsg; socklen_t optlen; if (getsockopt (g_socket_get_fd (socket), IPPROTO_SCTP, SCTP_INITMSG, &initmsg, &optlen) < 0) { GST_WARNING ("Could not get SCTP configuration: %s (%d)", g_strerror (errno), errno); } else { GST_DEBUG ("SCTP client socket: ostreams %u, instreams %u", initmsg.sinit_num_ostreams, initmsg.sinit_num_ostreams); } } #else { GST_WARNING ("don't know how to get the configuration of the " "SCTP initiation structure on this OS."); } #endif *client = ccon; return KMS_SCTP_OK; }
static void gst_value_mini_object_copy (const GValue * src_value, GValue * dest_value) { if (src_value->data[0].v_pointer) { dest_value->data[0].v_pointer = gst_mini_object_ref (GST_MINI_OBJECT_CAST (src_value->data[0]. v_pointer)); } else { dest_value->data[0].v_pointer = NULL; } }
static void gst_rtsp_token_init (GstRTSPTokenImpl * token, GstStructure * structure) { gst_mini_object_init (GST_MINI_OBJECT_CAST (token), 0, GST_TYPE_RTSP_TOKEN, (GstMiniObjectCopyFunction) _gst_rtsp_token_copy, NULL, (GstMiniObjectFreeFunction) _gst_rtsp_token_free); token->structure = structure; gst_structure_set_parent_refcount (token->structure, &token->token.mini_object.refcount); }
void QGstXvImageBufferPool::doAlloc() { //should be always called from the main thread with m_poolMutex locked //Q_ASSERT(QThread::currentThread() == thread()); XSync(QX11Info::display(), false); QGstXvImageBuffer *xvBuffer = (QGstXvImageBuffer *)gst_mini_object_new(QGstXvImageBuffer::get_type()); quint64 portId = m_format.property("portId").toULongLong(); int xvFormatId = m_format.property("xvFormatId").toInt(); xvBuffer->xvImage = XvShmCreateImage( QX11Info::display(), portId, xvFormatId, 0, m_format.frameWidth(), m_format.frameHeight(), &xvBuffer->shmInfo ); if (!xvBuffer->xvImage) { qWarning() << "QGstXvImageBufferPool: XvShmCreateImage failed"; return; } XSync(QX11Info::display(), false); xvBuffer->shmInfo.shmid = shmget(IPC_PRIVATE, xvBuffer->xvImage->data_size, IPC_CREAT | 0777); xvBuffer->shmInfo.shmaddr = xvBuffer->xvImage->data = (char*)shmat(xvBuffer->shmInfo.shmid, 0, 0); xvBuffer->shmInfo.readOnly = False; if (!XShmAttach(QX11Info::display(), &xvBuffer->shmInfo)) { qWarning() << "QGstXvImageBufferPool: XShmAttach failed"; return; } XSync(QX11Info::display(), false); shmctl (xvBuffer->shmInfo.shmid, IPC_RMID, NULL); xvBuffer->pool = this; GST_MINI_OBJECT_CAST(xvBuffer)->flags = 0; gst_buffer_set_caps(GST_BUFFER_CAST(xvBuffer), m_caps); GST_BUFFER_DATA(xvBuffer) = (uchar*)xvBuffer->xvImage->data; GST_BUFFER_SIZE(xvBuffer) = xvBuffer->xvImage->data_size; m_allBuffers.append(xvBuffer); m_pool.append(xvBuffer); XSync(QX11Info::display(), false); }
static void gst_fd_object_init(GstImxFDObject *obj, int fd) { gst_mini_object_init( GST_MINI_OBJECT_CAST(obj), 0, gst_imx_fd_object_api_get_type(), NULL, NULL, (GstMiniObjectFreeFunction)gst_fd_object_free ); obj->fd = fd; }
static void flush_stop (APP_STATE_T * state) { GstMiniObject *object = NULL; g_mutex_lock (state->queue_lock); while ((object = GST_MINI_OBJECT_CAST (g_async_queue_try_pop (state->queue)))) { gst_mini_object_unref (object); } flush_internal (state); state->popped_obj = NULL; state->flushing = FALSE; g_mutex_unlock (state->queue_lock); }
/** * gst_toc_merge_tags: * @toc: A #GstToc instance * @tags: (allow-none): A #GstTagList or %NULL * @mode: A #GstTagMergeMode * * Merge @tags into the existing tags of @toc using @mode. */ void gst_toc_merge_tags (GstToc * toc, GstTagList * tags, GstTagMergeMode mode) { g_return_if_fail (toc != NULL); g_return_if_fail (gst_mini_object_is_writable (GST_MINI_OBJECT_CAST (toc))); if (!toc->tags) { toc->tags = gst_tag_list_ref (tags); } else { GstTagList *tmp = gst_tag_list_merge (toc->tags, tags, mode); gst_tag_list_unref (toc->tags); toc->tags = tmp; } }
static void gst_buffer_list_init (GstBufferList * list, guint n_allocated, gsize slice_size) { gst_mini_object_init (GST_MINI_OBJECT_CAST (list), 0, _gst_buffer_list_type, (GstMiniObjectCopyFunction) _gst_buffer_list_copy, NULL, (GstMiniObjectFreeFunction) _gst_buffer_list_free); list->buffers = &list->arr[0]; list->n_buffers = 0; list->n_allocated = n_allocated; list->slice_size = slice_size; GST_LOG ("init %p", list); }