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

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 GstPadProbeReturnevents_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 voidgst_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 voidgst_mini_object_init (GTypeInstance * instance, gpointer klass){  GstMiniObject *mini_object = GST_MINI_OBJECT_CAST (instance);  mini_object->refcount = 1;}

static GstFlowReturngst_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 voidgst_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. */voidgst_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 voidpreroll_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. */voidgst_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 voidgst_subbuffer_finalize (GstSubBuffer * buffer){  gst_buffer_unref (buffer->parent);  GST_MINI_OBJECT_CLASS (sub_parent_class)->      finalize (GST_MINI_OBJECT_CAST (buffer));}

static GstFlowReturngst_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. */voidgst_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 GstFlowReturngst_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. */voidgst_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. */voidgst_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 voidgst_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 ();}

KmsSCTPResultkms_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 voidgst_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 voidgst_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 voidflush_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. */voidgst_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 voidgst_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);}