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. */ GType gst_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; } }
gboolean dshow_vdec_register (GstPlugin * plugin) { GTypeInfo info = { sizeof (GstDshowVideoDecClass), (GBaseInitFunc) gst_dshowvideodec_base_init, NULL, (GClassInitFunc) gst_dshowvideodec_class_init, NULL, NULL, sizeof (GstDshowVideoDec), 0, (GInstanceInitFunc) gst_dshowvideodec_init, }; gint i; GST_DEBUG_CATEGORY_INIT (dshowvideodec_debug, "dshowvideodec", 0, "Directshow filter video decoder"); CoInitializeEx (NULL, COINIT_MULTITHREADED); for (i = 0; i < sizeof (video_dec_codecs) / sizeof (CodecEntry); i++) { GType type; if (gst_dshow_find_filter (video_dec_codecs[i].input_majortype, video_dec_codecs[i].input_subtype, video_dec_codecs[i].output_majortype, video_dec_codecs[i].output_subtype, video_dec_codecs[i].preferred_filter_substring, NULL)) { GST_CAT_DEBUG (dshowvideodec_debug, "Registering %s", video_dec_codecs[i].element_name); tmp = &video_dec_codecs[i]; type = g_type_register_static (GST_TYPE_ELEMENT, video_dec_codecs[i].element_name, &info, 0); if (!gst_element_register (plugin, video_dec_codecs[i].element_name, GST_RANK_PRIMARY, type)) { return FALSE; } GST_CAT_DEBUG (dshowvideodec_debug, "Registered %s", video_dec_codecs[i].element_name); } else { GST_CAT_DEBUG (dshowvideodec_debug, "Element %s not registered (the format is not supported by the system)", video_dec_codecs[i].element_name); } } CoUninitialize (); return TRUE; }
/** * 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); }
/** * 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. */ gboolean gst_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, ¶ms); 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; }
gboolean gst_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; } }
gboolean dshow_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. */ gboolean gst_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 void gst_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 (¶ms); }
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. */ void gst_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 gboolean got_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 void gst_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. */ void gst_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. */ void gst_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; }