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);
}