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

static GstClock *gst_pipeline_provide_clock_func (GstElement * element){  GstClock *clock = NULL;  GstPipeline *pipeline = GST_PIPELINE (element);  /* if we have a fixed clock, use that one */  GST_OBJECT_LOCK (pipeline);  if (GST_OBJECT_FLAG_IS_SET (pipeline, GST_PIPELINE_FLAG_FIXED_CLOCK)) {    clock = pipeline->fixed_clock;    if (clock)      gst_object_ref (clock);    GST_OBJECT_UNLOCK (pipeline);    GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline using fixed clock %p (%s)",        clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-");  } else {    GST_OBJECT_UNLOCK (pipeline);    /* let the parent bin select a clock */    clock =        GST_ELEMENT_CLASS (parent_class)->provide_clock (GST_ELEMENT        (pipeline));    /* no clock, use a system clock */    if (!clock) {      clock = gst_system_clock_obtain ();      GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline obtained system clock: %p (%s)",          clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-");    } else {      GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline obtained clock: %p (%s)",          clock, clock ? GST_STR_NULL (GST_OBJECT_NAME (clock)) : "-");    }  }  return clock;}

/** * gst_meta_api_type_register: * @api: an API to register * @tags: tags for @api * * Register and return a GType for the @api and associate it with * @tags. * * Returns: a unique GType for @api. */GTypegst_meta_api_type_register (const gchar * api, const gchar ** tags){  GType type;  g_return_val_if_fail (api != NULL, 0);  g_return_val_if_fail (tags != NULL, 0);  GST_CAT_DEBUG (GST_CAT_META, "register API /"%s/"", api);  type = g_pointer_type_register_static (api);  if (type != 0) {    gint i;    for (i = 0; tags[i]; i++) {      GST_CAT_DEBUG (GST_CAT_META, "  adding tag /"%s/"", tags[i]);      g_type_set_qdata (type, g_quark_from_string (tags[i]),          GINT_TO_POINTER (TRUE));    }  }  g_type_set_qdata (type, g_quark_from_string ("tags"),      g_strdupv ((gchar **) tags));  return type;}

/** * gst_memory_make_mapped: * @mem: (transfer full): a #GstMemory * @info: (out): pointer for info * @flags: mapping flags * * Create a #GstMemory object that is mapped with @flags. If @mem is mappable * with @flags, this function returns the mapped @mem directly. Otherwise a * mapped copy of @mem is returned. * * This function takes ownership of old @mem and returns a reference to a new * #GstMemory. * * Returns: (transfer full) (nullable): a #GstMemory object mapped * with @flags or %NULL when a mapping is not possible. */GstMemory *gst_memory_make_mapped (GstMemory * mem, GstMapInfo * info, GstMapFlags flags){  GstMemory *result;  if (gst_memory_map (mem, info, flags)) {    result = mem;  } else {    result = gst_memory_copy (mem, 0, -1);    gst_memory_unref (mem);    if (result == NULL)      goto cannot_copy;    if (!gst_memory_map (result, info, flags))      goto cannot_map;  }  return result;  /* ERRORS */cannot_copy:  {    GST_CAT_DEBUG (GST_CAT_MEMORY, "cannot copy memory %p", mem);    return NULL;  }cannot_map:  {    GST_CAT_DEBUG (GST_CAT_MEMORY, "cannot map memory %p with flags %d", mem,        flags);    gst_memory_unref (result);    return NULL;  }}

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

/** * gst_gl_base_memory_memcpy: * @src: the source #GstGLBaseMemory * @dest: the destination #GstGLBaseMemory * @offset: the offset to start at * @size: the number of bytes to copy * * Returns: whether the copy suceeded. */gbooleangst_gl_base_memory_memcpy (GstGLBaseMemory * src, GstGLBaseMemory * dest,    gssize offset, gssize size){  GstMapInfo sinfo, dinfo;  if (!gst_gl_base_memory_alloc_data (GST_GL_BASE_MEMORY_CAST (dest)))    return FALSE;  if (!gst_memory_map ((GstMemory *) src, &sinfo, GST_MAP_READ)) {    GST_CAT_WARNING (GST_CAT_GL_BASE_MEMORY,        "could not read map source memory %p", src);    return FALSE;  }  if (!gst_memory_map ((GstMemory *) dest, &dinfo, GST_MAP_WRITE)) {    GST_CAT_WARNING (GST_CAT_GL_BASE_MEMORY,        "could not write map dest memory %p", dest);    gst_memory_unmap ((GstMemory *) src, &sinfo);    return FALSE;  }  if (size == -1)    size = sinfo.size > offset ? sinfo.size - offset : 0;  GST_CAT_DEBUG (GST_CAT_GL_BASE_MEMORY,      "memcpy %" G_GSSIZE_FORMAT " memory %p -> %p", size, src, dest);  memcpy (dinfo.data, sinfo.data + offset, size);  gst_memory_unmap ((GstMemory *) dest, &dinfo);  gst_memory_unmap ((GstMemory *) src, &sinfo);  return TRUE;}

static GstMemory *_fallback_mem_copy (GstMemory * mem, gssize offset, gssize size){  GstMemory *copy;  GstMapInfo sinfo, dinfo;  GstAllocationParams params = { 0, mem->align, 0, 0, };  GstAllocator *allocator;  if (!gst_memory_map (mem, &sinfo, GST_MAP_READ))    return NULL;  if (size == -1)    size = sinfo.size > offset ? sinfo.size - offset : 0;  /* use the same allocator as the memory we copy  */  allocator = mem->allocator;  if (GST_OBJECT_FLAG_IS_SET (allocator, GST_ALLOCATOR_FLAG_CUSTOM_ALLOC))    allocator = NULL;  copy = gst_allocator_alloc (allocator, size, &params);  if (!gst_memory_map (copy, &dinfo, GST_MAP_WRITE)) {    GST_CAT_WARNING (GST_CAT_MEMORY, "could not write map memory %p", copy);    gst_allocator_free (mem->allocator, copy);    gst_memory_unmap (mem, &sinfo);    return NULL;  }  GST_CAT_DEBUG (GST_CAT_PERFORMANCE,      "memcpy %" G_GSSIZE_FORMAT " memory %p -> %p", size, mem, copy);  memcpy (dinfo.data, sinfo.data + offset, size);  gst_memory_unmap (copy, &dinfo);  gst_memory_unmap (mem, &sinfo);  return copy;}

gbooleangst_gl_base_buffer_memcpy (GstGLBaseBuffer * src, GstGLBaseBuffer * dest,    gssize offset, gssize size){  GstMapInfo sinfo, dinfo;  if (!gst_memory_map ((GstMemory *) src, &sinfo, GST_MAP_READ)) {    GST_CAT_WARNING (GST_CAT_GL_BASE_BUFFER,        "could not read map source memory %p", src);    return FALSE;  }  if (!gst_memory_map ((GstMemory *) dest, &dinfo, GST_MAP_WRITE)) {    GST_CAT_WARNING (GST_CAT_GL_BASE_BUFFER,        "could not write map dest memory %p", dest);    gst_memory_unmap ((GstMemory *) src, &sinfo);    return FALSE;  }  GST_CAT_DEBUG (GST_CAT_GL_BASE_BUFFER,      "memcpy %" G_GSSIZE_FORMAT " memory %p -> %p", size, src, dest);  memcpy (dinfo.data, sinfo.data + offset, size);  gst_memory_unmap ((GstMemory *) dest, &dinfo);  gst_memory_unmap ((GstMemory *) src, &sinfo);  return TRUE;}

const GstMetaInfo *gst_meta_register (GType api, const gchar * impl, gsize size,    GstMetaInitFunction init_func, GstMetaFreeFunction free_func,    GstMetaTransformFunction transform_func){  GstMetaInfo *info;  g_return_val_if_fail (api != 0, NULL);  g_return_val_if_fail (impl != NULL, NULL);  g_return_val_if_fail (size != 0, NULL);  info = g_slice_new (GstMetaInfo);  info->api = api;  info->type = g_pointer_type_register_static (impl);  info->size = size;  info->init_func = init_func;  info->free_func = free_func;  info->transform_func = transform_func;  GST_CAT_DEBUG (GST_CAT_META,      "register /"%s/" implementing /"%s/" of size %" G_GSIZE_FORMAT, impl,      g_type_name (api), size);  g_rw_lock_writer_lock (&lock);  g_hash_table_insert (metainfo, (gpointer) impl, (gpointer) info);  g_rw_lock_writer_unlock (&lock);  return info;}

/** * gst_event_new_custom: * @type: The type of the new event * @structure: (transfer full): the structure for the event. The event will *     take ownership of the structure. * * Create a new custom-typed event. This can be used for anything not * handled by other event-specific functions to pass an event to another * element. * * Make sure to allocate an event type with the #GST_EVENT_MAKE_TYPE macro, * assigning a free number and filling in the correct direction and * serialization flags. * * New custom events can also be created by subclassing the event type if * needed. * * Returns: (transfer full): the new custom event. */GstEvent *gst_event_new_custom (GstEventType type, GstStructure * structure){  GstEventImpl *event;  event = g_slice_new0 (GstEventImpl);  GST_CAT_DEBUG (GST_CAT_EVENT, "creating new event %p %s %d", event,      gst_event_type_get_name (type), type);  if (structure) {    /* structure must not have a parent */    if (!gst_structure_set_parent_refcount (structure,            &event->event.mini_object.refcount))      goto had_parent;  }  gst_event_init (event, type);  GST_EVENT_STRUCTURE (event) = structure;  return GST_EVENT_CAST (event);  /* ERRORS */had_parent:  {    g_slice_free1 (sizeof (GstEventImpl), event);    g_warning ("structure is already owned by another object");    return NULL;  }}

gbooleandshow_adec_register (GstPlugin * plugin){  GTypeInfo info = {    sizeof (GstDshowAudioDecClass),    (GBaseInitFunc) gst_dshowaudiodec_base_init,    NULL,    (GClassInitFunc) gst_dshowaudiodec_class_init,    NULL,    NULL,    sizeof (GstDshowAudioDec),    0,    (GInstanceInitFunc) gst_dshowaudiodec_init,  };  gint i;  HRESULT hr;  GST_DEBUG_CATEGORY_INIT (dshowaudiodec_debug, "dshowaudiodec", 0,      "Directshow filter audio decoder");  hr = CoInitialize(0);  for (i = 0; i < sizeof (audio_dec_codecs) / sizeof (AudioCodecEntry); i++) {    GType type;    CComPtr<IBaseFilter> filter;    GUID insubtype = GUID_MEDIASUBTYPE_FROM_FOURCC (audio_dec_codecs[i].format);    GUID outsubtype = GUID_MEDIASUBTYPE_FROM_FOURCC (WAVE_FORMAT_PCM);    filter = gst_dshow_find_filter (MEDIATYPE_Audio,            insubtype,            MEDIATYPE_Audio,            outsubtype,            audio_dec_codecs[i].preferred_filters);    if (filter)     {      GST_DEBUG ("Registering %s", audio_dec_codecs[i].element_name);      tmp = &audio_dec_codecs[i];      type = g_type_register_static (GST_TYPE_ELEMENT,          audio_dec_codecs[i].element_name, &info, (GTypeFlags)0);      if (!gst_element_register (plugin, audio_dec_codecs[i].element_name,              GST_RANK_SECONDARY, type)) {        return FALSE;      }      GST_CAT_DEBUG (dshowaudiodec_debug, "Registered %s",          audio_dec_codecs[i].element_name);    }    else {      GST_DEBUG ("Element %s not registered "                 "(the format is not supported by the system)",                 audio_dec_codecs[i].element_name);    }  }  if (SUCCEEDED(hr))    CoUninitialize ();  return TRUE;}

/** * gst_mini_object_lock: * @object: the mini-object to lock * @flags: #GstLockFlags * * Lock the mini-object with the specified access mode in @flags. * * Returns: %TRUE if @object could be locked. */gbooleangst_mini_object_lock (GstMiniObject * object, GstLockFlags flags){  gint access_mode, state, newstate;  g_return_val_if_fail (object != NULL, FALSE);  g_return_val_if_fail (GST_MINI_OBJECT_IS_LOCKABLE (object), FALSE);  if (G_UNLIKELY (object->flags & GST_MINI_OBJECT_FLAG_LOCK_READONLY &&          flags & GST_LOCK_FLAG_WRITE))    return FALSE;  do {    access_mode = flags & FLAG_MASK;    newstate = state = g_atomic_int_get (&object->lockstate);    GST_CAT_TRACE (GST_CAT_LOCKING, "lock %p: state %08x, access_mode %d",        object, state, access_mode);    if (access_mode & GST_LOCK_FLAG_EXCLUSIVE) {      /* shared ref */      newstate += SHARE_ONE;      access_mode &= ~GST_LOCK_FLAG_EXCLUSIVE;    }    /* shared counter > 1 and write access is not allowed */    if (((state & GST_LOCK_FLAG_WRITE) != 0            || (access_mode & GST_LOCK_FLAG_WRITE) != 0)        && IS_SHARED (newstate))      goto lock_failed;    if (access_mode) {      if ((state & LOCK_FLAG_MASK) == 0) {        /* nothing mapped, set access_mode */        newstate |= access_mode;      } else {        /* access_mode must match */        if ((state & access_mode) != access_mode)          goto lock_failed;      }      /* increase refcount */      newstate += LOCK_ONE;    }  } while (!g_atomic_int_compare_and_exchange (&object->lockstate, state,          newstate));  return TRUE;lock_failed:  {    GST_CAT_DEBUG (GST_CAT_LOCKING,        "lock failed %p: state %08x, access_mode %d", object, state,        access_mode);    return FALSE;  }}

/** * gst_buffer_span: * @buf1: the first source #GstBuffer to merge. * @offset: the offset in the first buffer from where the new * buffer should start. * @buf2: the second source #GstBuffer to merge. * @len: the total length of the new buffer. * * Creates a new buffer that consists of part of buf1 and buf2. * Logically, buf1 and buf2 are concatenated into a single larger * buffer, and a new buffer is created at the given offset inside * this space, with a given length. * * If the two source buffers are children of the same larger buffer, * and are contiguous, the new buffer will be a child of the shared * parent, and thus no copying is necessary. you can use * gst_buffer_is_span_fast() to determine if a memcpy will be needed. * * MT safe. * Returns: the new #GstBuffer that spans the two source buffers. * Returns NULL if the arguments are invalid. */GstBuffer *gst_buffer_span (GstBuffer * buf1, guint32 offset, GstBuffer * buf2,    guint32 len){  GstBuffer *newbuf;  g_return_val_if_fail (buf1 != NULL && buf2 != NULL, NULL);  g_return_val_if_fail (buf1->mini_object.refcount > 0, NULL);  g_return_val_if_fail (buf2->mini_object.refcount > 0, NULL);  g_return_val_if_fail (len > 0, NULL);  g_return_val_if_fail (len <= buf1->size + buf2->size - offset, NULL);  /* if the two buffers have the same parent and are adjacent */  if (gst_buffer_is_span_fast (buf1, buf2)) {    GstBuffer *parent = GST_SUBBUFFER_CAST (buf1)->parent;    /* we simply create a subbuffer of the common parent */    newbuf = gst_buffer_create_sub (parent,        buf1->data - parent->data + offset, len);  } else {    GST_CAT_DEBUG (GST_CAT_BUFFER,        "slow path taken while spanning buffers %p and %p", buf1, buf2);    /* otherwise we simply have to brute-force copy the buffers */    newbuf = gst_buffer_new_and_alloc (len);    /* copy the first buffer's data across */    memcpy (newbuf->data, buf1->data + offset, buf1->size - offset);    /* copy the second buffer's data across */    memcpy (newbuf->data + (buf1->size - offset), buf2->data,        len - (buf1->size - offset));  }  /* if the offset is 0, the new buffer has the same timestamp as buf1 */  if (offset == 0) {    GST_BUFFER_OFFSET (newbuf) = GST_BUFFER_OFFSET (buf1);    GST_BUFFER_TIMESTAMP (newbuf) = GST_BUFFER_TIMESTAMP (buf1);    /* if we completely merged the two buffers (appended), we can     * calculate the duration too. Also make sure we's not messing with     * invalid DURATIONS */    if (buf1->size + buf2->size == len) {      if (GST_BUFFER_DURATION_IS_VALID (buf1) &&          GST_BUFFER_DURATION_IS_VALID (buf2)) {        /* add duration */        GST_BUFFER_DURATION (newbuf) = GST_BUFFER_DURATION (buf1) +            GST_BUFFER_DURATION (buf2);      }      if (GST_BUFFER_OFFSET_END_IS_VALID (buf2)) {        /* add offset_end */        GST_BUFFER_OFFSET_END (newbuf) = GST_BUFFER_OFFSET_END (buf2);      }    }  }  return newbuf;}

static voidgst_dwl_allocator_init (GstDwlAllocator * allocator){  DWLInitParam_t params;  GST_CAT_DEBUG (GST_CAT_MEMORY, "init allocator %p", allocator);  /* Use H264 as client, not really needed for anything but as a container */  params.clientType = DWL_CLIENT_TYPE_H264_DEC;  allocator->dwl = DWLInit (&params);}

static GList*fs_rtp_special_source_class_add_blueprint (FsRtpSpecialSourceClass *klass,    GList *blueprints){  if (klass->add_blueprint)    return klass->add_blueprint (klass, blueprints);  else    GST_CAT_DEBUG (fsrtpconference_disco,        "Class %s has no add_blueprint function", G_OBJECT_CLASS_NAME(klass));  return blueprints;}

static void_gst_clock_id_free (GstClockID id){  g_return_if_fail (id != NULL);  GST_CAT_DEBUG (GST_CAT_CLOCK, "freed entry %p", id);#ifndef GST_DISABLE_TRACE  gst_alloc_trace_free (_gst_clock_entry_trace, id);#endif  g_slice_free (GstClockEntry, id);}

static void_gst_memory_free (GstMemory * mem){    GST_CAT_DEBUG (GST_CAT_MEMORY, "free memory %p", mem);    if (mem->parent) {        gst_memory_unlock (mem->parent, GST_LOCK_FLAG_EXCLUSIVE);        gst_memory_unref (mem->parent);    }    gst_allocator_free (mem->allocator, mem);}

/** * gst_allocator_register: * @name: the name of the allocator * @allocator: (transfer full): #GstAllocator * * Registers the memory @allocator with @name. This function takes ownership of * @allocator. */voidgst_allocator_register (const gchar * name, GstAllocator * allocator){  g_return_if_fail (name != NULL);  g_return_if_fail (allocator != NULL);  GST_CAT_DEBUG (GST_CAT_MEMORY, "registering allocator %p with name /"%s/"",      allocator, name);  g_rw_lock_writer_lock (&lock);  g_hash_table_insert (allocators, (gpointer) name, (gpointer) allocator);  g_rw_lock_writer_unlock (&lock);}

static gbooleangot_egl_error (const char *wtf){  EGLint error;  if ((error = eglGetError ()) != EGL_SUCCESS) {    GST_CAT_DEBUG (GST_CAT_DEFAULT, "EGL ERROR: %s returned 0x%04x", wtf,        error);    return TRUE;  }  return FALSE;}

static GList*fs_rtp_special_source_class_negotiation_filter (FsRtpSpecialSourceClass *klass,    GList *codec_associations){  if (klass->negotiation_filter)    return klass->negotiation_filter (klass, codec_associations);  else    GST_CAT_DEBUG (fsrtpconference_disco,        "Class %s has no negotiation_filter function",        G_OBJECT_CLASS_NAME(klass));  return codec_associations;}

/** * gst_adapter_peek: * @adapter: a #GstAdapter * @size: the number of bytes to peek * * Gets the first @size bytes stored in the @adapter. The returned pointer is * valid until the next function is called on the adapter. * * Note that setting the returned pointer as the data of a #GstBuffer is * incorrect for general-purpose plugins. The reason is that if a downstream * element stores the buffer so that it has access to it outside of the bounds * of its chain function, the buffer will have an invalid data pointer after * your element flushes the bytes. In that case you should use * gst_adapter_take(), which returns a freshly-allocated buffer that you can set * as #GstBuffer malloc_data or the potentially more performant * gst_adapter_take_buffer(). * * Returns #NULL if @size bytes are not available. * * Returns: a pointer to the first @size bytes of data, or NULL. */const guint8 *gst_adapter_peek (GstAdapter * adapter, guint size){  GstBuffer *cur;  guint skip;  g_return_val_if_fail (GST_IS_ADAPTER (adapter), NULL);  g_return_val_if_fail (size > 0, NULL);  /* we don't have enough data, return NULL. This is unlikely   * as one usually does an _available() first instead of peeking a   * random size. */  if (G_UNLIKELY (size > adapter->size))    return NULL;  /* we have enough assembled data, return it */  if (adapter->assembled_len >= size)    return adapter->assembled_data;  /* our head buffer has enough data left, return it */  cur = adapter->buflist->data;  skip = adapter->skip;  if (GST_BUFFER_SIZE (cur) >= size + skip)    return GST_BUFFER_DATA (cur) + skip;  /* We may be able to efficiently merge buffers in our pool to   * gather a big enough chunk to return it from the head buffer directly */  if (gst_adapter_try_to_merge_up (adapter, size)) {    /* Merged something! Check if there's enough avail now */    cur = adapter->buflist->data;    if (GST_BUFFER_SIZE (cur) >= size + skip)      return GST_BUFFER_DATA (cur) + skip;  }  /* Gonna need to copy stuff out */  if (G_UNLIKELY (adapter->assembled_size < size)) {    adapter->assembled_size = (size / DEFAULT_SIZE + 1) * DEFAULT_SIZE;    GST_DEBUG_OBJECT (adapter, "resizing internal buffer to %u",        adapter->assembled_size);    /* no g_realloc to avoid a memcpy that is not desired here since we are     * going to copy new data into the area below */    g_free (adapter->assembled_data);    adapter->assembled_data = g_malloc (adapter->assembled_size);  }  adapter->assembled_len = size;  GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy data from adapter");  copy_into_unchecked (adapter, adapter->assembled_data, skip, size);  return adapter->assembled_data;}

static voidgst_allocator_sysmem_init (GstAllocatorSysmem * allocator){  GstAllocator *alloc = GST_ALLOCATOR_CAST (allocator);  GST_CAT_DEBUG (GST_CAT_MEMORY, "init allocator %p", allocator);  alloc->mem_type = GST_ALLOCATOR_SYSMEM;  alloc->mem_map = (GstMemoryMapFunction) _sysmem_map;  alloc->mem_unmap = (GstMemoryUnmapFunction) _sysmem_unmap;  alloc->mem_copy = (GstMemoryCopyFunction) _sysmem_copy;  alloc->mem_share = (GstMemoryShareFunction) _sysmem_share;  alloc->mem_is_span = (GstMemoryIsSpanFunction) _sysmem_is_span;}

static void_gl_buffer_init (GstGLBuffer * mem, GstAllocator * allocator,    GstMemory * parent, GstGLContext * context, guint gl_target, guint gl_usage,    GstAllocationParams * params, gsize size){  mem->target = gl_target;  mem->usage_hints = gl_usage;  gst_gl_base_memory_init ((GstGLBaseMemory *) mem, allocator, parent, context,      params, size, NULL, NULL);  GST_CAT_DEBUG (GST_CAT_GL_BUFFER, "new GL buffer memory:%p size:%"      G_GSIZE_FORMAT, mem, mem->mem.mem.maxsize);}

static void_gst_clock_id_free (GstClockID id){  GstClockEntry *entry;  g_return_if_fail (id != NULL);  GST_CAT_DEBUG (GST_CAT_CLOCK, "freed entry %p", id);  entry = (GstClockEntry *) id;  if (entry->destroy_data)    entry->destroy_data (entry->user_data);#ifndef GST_DISABLE_TRACE  _gst_alloc_trace_free (_gst_clock_entry_trace, id);#endif  g_slice_free (GstClockEntry, id);}

static GstEvent *gst_event_new (GstEventType type){  GstEvent *event;  event = (GstEvent *) gst_mini_object_new (GST_TYPE_EVENT);  GST_CAT_DEBUG (GST_CAT_EVENT, "creating new event %p %s %d", event,      gst_event_type_get_name (type), type);  event->type = type;  event->src = NULL;  event->structure = NULL;  GST_EVENT_SEQNUM (event) = gst_util_seqnum_next ();  return event;}

/** * gst_pipeline_auto_clock: * @pipeline: a [GstPipeline]() * * Let _pipeline_ select a clock automatically. This is the default * behaviour. * * Use this function if you previous forced a fixed clock with * [gst_pipeline_use_clock]() and want to restore the default * pipeline clock selection algorithm. * * MT safe. */voidgst_pipeline_auto_clock (GstPipeline * pipeline){  GstClock **clock_p;  g_return_if_fail (pipeline != NULL);  g_return_if_fail (GST_IS_PIPELINE (pipeline));  GST_OBJECT_LOCK (pipeline);  GST_OBJECT_FLAG_UNSET (pipeline, GST_PIPELINE_FLAG_FIXED_CLOCK);  clock_p = &pipeline->fixed_clock;  gst_object_replace ((GstObject **) clock_p, NULL);  GST_OBJECT_UNLOCK (pipeline);  GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline using automatic clock");}

/** * gst_pipeline_use_clock: * @pipeline: a [GstPipeline]() * @clock: (transfer none) (allow-none): the clock to use * * Force _pipeline_ to use the given _clock_. The pipeline will * always use the given clock even if new clock providers are added * to this pipeline. * * If _clock_ is [NULL]() all clocking will be disabled which will make * the pipeline run as fast as possible. * * MT safe. */voidgst_pipeline_use_clock (GstPipeline * pipeline, GstClock * clock){  GstClock **clock_p;  g_return_if_fail (GST_IS_PIPELINE (pipeline));  GST_OBJECT_LOCK (pipeline);  GST_OBJECT_FLAG_SET (pipeline, GST_PIPELINE_FLAG_FIXED_CLOCK);  clock_p = &pipeline->fixed_clock;  gst_object_replace ((GstObject **) clock_p, (GstObject *) clock);  GST_OBJECT_UNLOCK (pipeline);  GST_CAT_DEBUG (GST_CAT_CLOCK, "pipeline using fixed clock %p (%s)", clock,      (clock ? GST_OBJECT_NAME (clock) : "nil"));}

/** * gst_mini_object_make_writable: * @mini_object: (transfer full): the mini-object to make writable * * Checks if a mini-object is writable.  If not, a writable copy is made and * returned.  This gives away the reference to the original mini object, * and returns a reference to the new object. * * MT safe * * Returns: (transfer full): a mini-object (possibly the same pointer) that *     is writable. */GstMiniObject *gst_mini_object_make_writable (GstMiniObject * mini_object){  GstMiniObject *ret;  g_return_val_if_fail (mini_object != NULL, NULL);  if (gst_mini_object_is_writable (mini_object)) {    ret = mini_object;  } else {    ret = gst_mini_object_copy (mini_object);    GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy %s miniobject %p -> %p",        g_type_name (GST_MINI_OBJECT_TYPE (mini_object)), mini_object, ret);    gst_mini_object_unref (mini_object);  }  return ret;}

static GstMemorySystem *_sysmem_copy (GstMemorySystem * mem, gssize offset, gsize size){  GstMemorySystem *copy;  if (size == -1)    size = mem->mem.size > offset ? mem->mem.size - offset : 0;  copy =      _sysmem_new_block (0, mem->mem.maxsize, mem->mem.align,      mem->mem.offset + offset, size);  GST_CAT_DEBUG (GST_CAT_PERFORMANCE,      "memcpy %" G_GSIZE_FORMAT " memory %p -> %p", mem->mem.maxsize, mem,      copy);  memcpy (copy->data, mem->data, mem->mem.maxsize);  return copy;}

/** * gst_mini_object_make_writable: * @mini_object: the mini-object to make writable * * Checks if a mini-object is writable.  If not, a writable copy is made and * returned.  This gives away the reference to the original mini object, * and returns a reference to the new object. * * MT safe * * Returns: a mini-object (possibly the same pointer) that is writable. */GstMiniObject *gst_mini_object_make_writable (GstMiniObject * mini_object){  GstMiniObject *ret;  g_return_val_if_fail (mini_object != NULL, NULL);  if (gst_mini_object_is_writable (mini_object)) {    ret = mini_object;  } else {    GST_CAT_DEBUG (GST_CAT_PERFORMANCE, "copy %s miniobject",        g_type_name (G_TYPE_FROM_INSTANCE (mini_object)));    ret = gst_mini_object_copy (mini_object);    gst_mini_object_unref (mini_object);  }  return ret;}