copy = gst_buffer_list_new_sized (list->n_allocated);
/* add and ref all buffers in the array */
- for (i = 0; i < len; i++)
+ for (i = 0; i < len; i++) {
copy->buffers[i] = gst_buffer_ref (list->buffers[i]);
+ gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (copy->buffers[i]),
+ GST_MINI_OBJECT_CAST (copy));
+ }
copy->n_buffers = len;
_gst_buffer_list_free (GstBufferList * list)
{
guint i, len;
+ gsize slice_size;
GST_LOG ("free %p", list);
/* unrefs all buffers too */
len = list->n_buffers;
- for (i = 0; i < len; i++)
+ for (i = 0; i < len; i++) {
+ gst_mini_object_remove_parent (GST_MINI_OBJECT_CAST (list->buffers[i]),
+ GST_MINI_OBJECT_CAST (list));
gst_buffer_unref (list->buffers[i]);
+ }
if (GST_BUFFER_LIST_IS_USING_DYNAMIC_ARRAY (list))
g_free (list->buffers);
- g_slice_free1 (list->slice_size, list);
+ slice_size = list->slice_size;
+
+#ifdef USE_POISONING
+ memset (list, 0xff, slice_size);
+#endif
+
+ g_slice_free1 (slice_size, list);
}
static void
guint i;
if (unref_old) {
- for (i = idx; i < idx + length; ++i)
+ for (i = idx; i < idx + length; ++i) {
+ gst_mini_object_remove_parent (GST_MINI_OBJECT_CAST (list->buffers[i]),
+ GST_MINI_OBJECT_CAST (list));
gst_buffer_unref (list->buffers[i]);
+ }
}
if (idx + length != list->n_buffers) {
{
guint i, len;
gboolean ret = TRUE;
+ gboolean list_was_writable, first_warning = TRUE;
g_return_val_if_fail (GST_IS_BUFFER_LIST (list), FALSE);
g_return_val_if_fail (func != NULL, FALSE);
+ list_was_writable = gst_buffer_list_is_writable (list);
+
len = list->n_buffers;
for (i = 0; i < len;) {
GstBuffer *buf, *buf_ret;
+ gboolean was_writable;
buf = buf_ret = list->buffers[i];
+
+ /* If the buffer is writable, we remove us as parent for now to
+ * allow the callback to destroy the buffer. If we get the buffer
+ * back, we add ourselves as parent again.
+ *
+ * Non-writable buffers just get another reference as they were not
+ * writable to begin with, and they would possibly become writable
+ * by removing ourselves as parent
+ */
+ was_writable = list_was_writable && gst_buffer_is_writable (buf);
+
+ if (was_writable)
+ gst_mini_object_remove_parent (GST_MINI_OBJECT_CAST (buf),
+ GST_MINI_OBJECT_CAST (list));
+ else
+ gst_buffer_ref (buf);
+
ret = func (&buf_ret, i, user_data);
/* Check if the function changed the buffer */
if (buf != buf_ret) {
- if (buf_ret == NULL) {
- gst_buffer_list_remove_range_internal (list, i, 1, FALSE);
+ /* If the list was not writable but the callback was actually changing
+ * our buffer, then it wouldn't have been allowed to do so.
+ *
+ * Fortunately we still have a reference to the old buffer in that case
+ * and just not modify the list, unref the new buffer (if any) and warn
+ * about this */
+ if (!list_was_writable) {
+ if (first_warning) {
+ g_critical
+ ("gst_buffer_list_foreach: non-writable list %p was changed from callback",
+ list);
+ first_warning = FALSE;
+ }
+ if (buf_ret)
+ gst_buffer_unref (buf_ret);
+ } else if (buf_ret == NULL) {
+ gst_buffer_list_remove_range_internal (list, i, 1, !was_writable);
--len;
} else {
+ if (!was_writable)
+ gst_buffer_unref (buf);
+
list->buffers[i] = buf_ret;
+ gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (buf_ret),
+ GST_MINI_OBJECT_CAST (list));
}
+ } else {
+ if (was_writable)
+ gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (buf),
+ GST_MINI_OBJECT_CAST (list));
+ else
+ gst_buffer_unref (buf);
}
if (!ret)
GstBuffer *
gst_buffer_list_get_writable (GstBufferList * list, guint idx)
{
- GstBuffer **p_buf;
+ GstBuffer *new_buf;
g_return_val_if_fail (GST_IS_BUFFER_LIST (list), NULL);
g_return_val_if_fail (gst_buffer_list_is_writable (list), NULL);
g_return_val_if_fail (idx < list->n_buffers, NULL);
- p_buf = &list->buffers[idx];
- return (*p_buf = gst_buffer_make_writable (*p_buf));
+ /* We have to implement this manually here to correctly add/remove the
+ * parent */
+ if (gst_buffer_is_writable (list->buffers[idx]))
+ return list->buffers[idx];
+
+ gst_mini_object_remove_parent (GST_MINI_OBJECT_CAST (list->buffers[idx]),
+ GST_MINI_OBJECT_CAST (list));
+ new_buf = gst_buffer_copy (list->buffers[idx]);
+ gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (new_buf),
+ GST_MINI_OBJECT_CAST (list));
+ gst_buffer_unref (list->buffers[idx]);
+ list->buffers[idx] = new_buf;
+
+ return new_buf;
}
/**
g_return_if_fail (gst_buffer_list_is_writable (list));
if (idx == -1 && list->n_buffers < list->n_allocated) {
+ gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (buffer),
+ GST_MINI_OBJECT_CAST (list));
list->buffers[list->n_buffers++] = buffer;
return;
}
++list->n_buffers;
list->buffers[idx] = buffer;
+ gst_mini_object_add_parent (GST_MINI_OBJECT_CAST (buffer),
+ GST_MINI_OBJECT_CAST (list));
}
/**