[gstreamermm] C++11: use rvalue references for transfer-full function parameters
- From: Marcin Kolny <mkolny src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gstreamermm] C++11: use rvalue references for transfer-full function parameters
- Date: Sat, 22 Aug 2015 11:33:37 +0000 (UTC)
commit ee1bffe298950e565226807748b08d24f0e9ce7f
Author: Marcin Kolny <marcin kolny gmail com>
Date: Sat Aug 22 11:26:09 2015 +0000
C++11: use rvalue references for transfer-full function parameters
This commit breaks the API. But version 1.6 of gstreamermm enables C++11
flag in compilers, so it's good time to change API slightly. Since
version 1.6 gstreamermm's API will be marked as 'stable'.
* gstreamer/src/allocator.ccg:
* gstreamer/src/allocator.hg:
* gstreamer/src/buffer.ccg:
* gstreamer/src/buffer.hg:
* gstreamer/src/bus.ccg:
* gstreamer/src/bus.hg:
* gstreamer/src/caps.ccg:
* gstreamer/src/caps.hg:
* gstreamer/src/pad.ccg:
* gstreamer/src/pad.hg: use rvalues for some function parameters.
* tests/plugins/foo.h:
* tests/regression/test-regression-seekonstartup.cc:
* tests/test-allocator.cc:
* tests/test-buffer.cc:
* tests/test-bus.cc:
* tests/test-caps.cc:
* tests/test-pad.cc: update tests.
* tools/m4/convert_gst.m4: add rvalues conversion definitions.
gstreamer/src/allocator.ccg | 17 +----
gstreamer/src/allocator.hg | 9 +--
gstreamer/src/buffer.ccg | 42 ++++---------
gstreamer/src/buffer.hg | 70 +++------------------
gstreamer/src/bus.ccg | 7 --
gstreamer/src/bus.hg | 12 +---
gstreamer/src/caps.ccg | 29 ++++-----
gstreamer/src/caps.hg | 19 +-----
gstreamer/src/pad.ccg | 30 ---------
gstreamer/src/pad.hg | 69 ++-------------------
tests/plugins/foo.h | 2 +-
tests/regression/test-regression-seekonstartup.cc | 3 +-
tests/test-allocator.cc | 8 +-
tests/test-buffer.cc | 31 +++++++++-
tests/test-bus.cc | 3 +-
tests/test-caps.cc | 4 +-
tests/test-pad.cc | 20 ++++++
tools/m4/convert_gst.m4 | 5 ++
18 files changed, 111 insertions(+), 269 deletions(-)
---
diff --git a/gstreamer/src/allocator.ccg b/gstreamer/src/allocator.ccg
index 8dee06c..5cd861d 100644
--- a/gstreamer/src/allocator.ccg
+++ b/gstreamer/src/allocator.ccg
@@ -52,15 +52,6 @@ void Allocator::set_default()
gst_allocator_set_default(gobj());
}
-void Allocator::free(Glib::RefPtr<Gst::Memory>& memory)
-{
- GstMemory* memory_gobj = memory->gobj();
- memory->reference();
- memory.reset();
-
- gst_allocator_free(gobj(), memory_gobj);
-}
-
void Allocator_Class::free_vfunc_callback(GstAllocator* self, GstMemory* memory)
{
Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
@@ -82,7 +73,7 @@ void Allocator_Class::free_vfunc_callback(GstAllocator* self, GstMemory* memory)
#endif //GLIBMM_EXCEPTIONS_ENABLED
// Call the virtual member method, which derived classes might override.
Glib::RefPtr<Gst::Memory> mem = Glib::wrap(memory);
- obj->free_vfunc(mem);
+ obj->free_vfunc(std::move(mem));
return;
#ifdef GLIBMM_EXCEPTIONS_ENABLED
}
@@ -106,7 +97,7 @@ void Allocator_Class::free_vfunc_callback(GstAllocator* self, GstMemory* memory)
}
-void Gst::Allocator::free_vfunc(Glib::RefPtr<Gst::Memory>& memory)
+void Gst::Allocator::free_vfunc(Glib::RefPtr<Gst::Memory>&& memory)
{
BaseClassType *const base = static_cast<BaseClassType*>(
g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobject_))
@@ -114,9 +105,7 @@ void Gst::Allocator::free_vfunc(Glib::RefPtr<Gst::Memory>& memory)
if(base && base->free)
{
- GstMemory* mem_gobj = memory->gobj();
- memory->reference();
- memory.reset();
+ GstMemory* mem_gobj = memory.release()->gobj();
(*base->free)(gobj(), mem_gobj);
}
}
diff --git a/gstreamer/src/allocator.hg b/gstreamer/src/allocator.hg
index e5f523d..6bf7e03 100644
--- a/gstreamer/src/allocator.hg
+++ b/gstreamer/src/allocator.hg
@@ -87,19 +87,14 @@ public:
*/
static Glib::RefPtr<Gst::Allocator> get_default_allocator();
- /** Free @a memory that was previously allocated with alloc().
- * @param memory The memory to free.
- */
- void free(Glib::RefPtr<Gst::Memory>& memory);
- _IGNORE(gst_allocator_free)
-
+ _WRAP_METHOD(void free(Glib::RefPtr<Gst::Memory>&& memory), gst_allocator_free)
_WRAP_METHOD(Glib::RefPtr<Gst::Memory> alloc(gsize size, Gst::AllocationParams params),
gst_allocator_alloc)
_WRAP_VFUNC(Glib::RefPtr<Gst::Memory> alloc(gsize size, Gst::AllocationParams params), "alloc",
refreturn_ctype)
// This vfunc is hand-coded because it takes reference to a memory.
// In generally, arguments are passed to a function by copy, so
// custom wrapper is necessary.
- virtual void free_vfunc(Glib::RefPtr<Gst::Memory>& memory);
+ virtual void free_vfunc(Glib::RefPtr<Gst::Memory>&& memory);
protected:
#m4begin
diff --git a/gstreamer/src/buffer.ccg b/gstreamer/src/buffer.ccg
index 8a9a27c..38f26a6 100644
--- a/gstreamer/src/buffer.ccg
+++ b/gstreamer/src/buffer.ccg
@@ -45,40 +45,22 @@ guint64 Buffer::offset_none()
return GST_BUFFER_OFFSET_NONE;
}
-void Buffer::insert_memory(guint idx, Glib::RefPtr<Gst::Memory>& mem)
+Glib::RefPtr<Gst::Buffer> Buffer::append_region(Glib::RefPtr<Gst::Buffer>&& buf, gssize offset, gssize size)
{
- GstMemory *mem_gobj = mem->gobj();
- mem->reference();
- mem.reset();
- gst_buffer_insert_memory(gobj(), idx, mem_gobj);
+ if (is_writable())
+ {
+ return Glib::wrap(gst_buffer_append_region(gobj(), buf.release()->gobj(), offset, size), true);
+ }
+ else
+ {
+ reference();
+ return Glib::wrap(gst_buffer_append_region(gobj(), buf.release()->gobj(), offset, size), false);
+ }
}
-void Buffer::prepend_memory(Glib::RefPtr<Gst::Memory>& mem)
+Glib::RefPtr<Gst::Buffer> Buffer::append(Glib::RefPtr<Gst::Buffer>&& buf)
{
- insert_memory(0, mem);
-}
-
-void Buffer::append_memory(Glib::RefPtr<Gst::Memory>& mem)
-{
- insert_memory(-1, mem);
-}
-
-void Buffer::replace_memory_range(guint idx, gint length, Glib::RefPtr<Gst::Memory>& mem)
-{
- GstMemory *mem_gobj = mem->gobj();
- mem->reference();
- mem.reset();
- gst_buffer_replace_memory_range(gobj(), idx, length, mem_gobj);
-}
-
-void Buffer::replace_memory(guint idx, Glib::RefPtr<Gst::Memory>& mem)
-{
- replace_memory_range(idx, 1, mem);
-}
-
-void Buffer::replace_all_memory(Glib::RefPtr<Gst::Memory>& mem)
-{
- replace_memory_range(0, -1, mem);
+ return append_region(std::move(buf), 0, -1);
}
} // namespace Gst
diff --git a/gstreamer/src/buffer.hg b/gstreamer/src/buffer.hg
index fc71cdf..0da0c7e 100644
--- a/gstreamer/src/buffer.hg
+++ b/gstreamer/src/buffer.hg
@@ -135,40 +135,19 @@ public:
_WRAP_METHOD(guint n_memory() const, gst_buffer_n_memory)
- /** Insert the memory block @mem to @buffer at @idx. This function takes ownership
- * of @mem and thus doesn't increase its refcount.
- *
- * Only get_max_memory() can be added to a buffer. If more memory is
- * added, existing memory blocks will automatically be merged to make room for
- * the new memory.
- *
- * @param idx: the index to add the memory at, or -1 to append it to the end.
- * @param mem: a Gst::Memory.
- */
- void insert_memory(guint idx, Glib::RefPtr<Gst::Memory>& mem);
- _IGNORE(gst_buffer_insert_memory)
+ _WRAP_METHOD(void insert_memory(gint idx, Glib::RefPtr<Gst::Memory>&& mem), gst_buffer_insert_memory)
_WRAP_METHOD(Glib::RefPtr<Gst::Memory> get_all_memory() const, gst_buffer_get_all_memory)
_WRAP_METHOD(gsize fill(gsize offset, gconstpointer src, gsize size), gst_buffer_fill)
- _WRAP_METHOD(Glib::RefPtr<Gst::Buffer> append(const Glib::RefPtr<Gst::Buffer>& buf) const,
gst_buffer_append)
+ Glib::RefPtr<Gst::Buffer> append_region(Glib::RefPtr<Gst::Buffer>&& buf, gssize offset, gssize size);
+ _IGNORE(gst_buffer_append_region)
- _WRAP_METHOD(Glib::RefPtr<Gst::Buffer> append_region(const Glib::RefPtr<Gst::Buffer>& buf, gssize offset,
gssize size) const, gst_buffer_append_region)
+ Glib::RefPtr<Gst::Buffer> append(Glib::RefPtr<Gst::Buffer>&& buf);
+ _IGNORE(gst_buffer_append)
- /** Replaces @a length memory blocks in @a buffer starting at @a idx with @a mem.
- *
- * If @a length is -1, all memory starting from @a idx will be removed and
- * replaced with @a mem.
- *
- * @a buffer should be writable.
- *
- * @param idx An index.
- * @param length A length should not be 0.
- * @param mem A Gst::Memory.
- */
- void replace_memory_range(guint idx, gint length, Glib::RefPtr<Gst::Memory>& mem);
- _IGNORE(gst_buffer_replace_memory_range)
+ _WRAP_METHOD(void replace_memory_range(guint idx, gint length, Glib::RefPtr<Gst::Memory>&& mem),
gst_buffer_replace_memory_range)
_WRAP_METHOD(Glib::RefPtr<Gst::Memory> get_memory_range(guint idx, gint length),
gst_buffer_get_memory_range)
@@ -176,27 +155,9 @@ public:
_WRAP_METHOD(bool find_memory(gsize offset, gsize size, guint& idx, guint& length, gsize& skip),
gst_buffer_find_memory)
- /** Prepend the memory block @mem to @buffer. This function takes
- * ownership of @mem and thus doesn't increase its refcount.
- *
- * This function is identical to insert_memory() with an index of 0.
- * See insert_memory() for more details.
- *
- * @param mem: a Gst::Memory.
- */
- void prepend_memory(Glib::RefPtr<Gst::Memory>& mem);
- _IGNORE(gst_buffer_prepend_memory)
+ _WRAP_METHOD(void prepend_memory(Glib::RefPtr<Gst::Memory>&& mem), gst_buffer_prepend_memory)
- /** Append the memory block @mem to @buffer. This function takes
- * ownership of @mem and thus doesn't increase its refcount.
-
- * This function is identical to insert_memory() with an index of -1.
- * See insert_memory() for more details.
- *
- * @param mem: a Gst::Memory.
- */
- void append_memory(Glib::RefPtr<Gst::Memory>& mem);
- _IGNORE(gst_buffer_append_memory);
+ _WRAP_METHOD(void append_memory(Glib::RefPtr<Gst::Memory>&& mem), gst_buffer_append_memory)
_WRAP_METHOD(void remove_memory(guint idx), gst_buffer_remove_memory)
@@ -204,20 +165,9 @@ public:
_WRAP_METHOD(gsize memset(gsize offset, guint8 val, gsize size), gst_buffer_memset)
- /** Replaces the memory block at index @a idx in @a buffer with @a mem.
- *
- * @param idx An index.
- * @param mem A Gst::Memory.
- */
- void replace_memory(guint idx, Glib::RefPtr<Gst::Memory>& mem);
- _IGNORE(gst_buffer_replace_memory)
+ _WRAP_METHOD(void replace_memory(guint idx, Glib::RefPtr<Gst::Memory>&& mem), gst_buffer_replace_memory)
- /** Replaces all memory in @a buffer with @a mem.
- *
- * @param mem A Gst::Memory.
- */
- void replace_all_memory(Glib::RefPtr<Gst::Memory>& mem);
- _IGNORE(gst_buffer_replace_all_memory)
+ _WRAP_METHOD(void replace_all_memory(Glib::RefPtr<Gst::Memory>&& mem), gst_buffer_replace_all_memory)
_WRAP_METHOD(gsize extract(gsize offset, gpointer dest, gsize size), gst_buffer_extract)
diff --git a/gstreamer/src/bus.ccg b/gstreamer/src/bus.ccg
index 3aab995..74d3159 100644
--- a/gstreamer/src/bus.ccg
+++ b/gstreamer/src/bus.ccg
@@ -86,13 +86,6 @@ bool Bus::remove_watch(guint id)
return g_source_remove(id);
}
-bool Bus::post(Glib::RefPtr<Gst::Message>& message)
-{
- GstMessage* msg = message->gobj();
- message->reference(); message.reset();
- return gst_bus_post(gobj(), msg);
-}
-
void Bus::set_sync_handler(const SlotMessageSync& slot)
{
// Clear a possibly existing sync handler by calling with 0 before setting
diff --git a/gstreamer/src/bus.hg b/gstreamer/src/bus.hg
index 7edc7ee..6a7c247 100644
--- a/gstreamer/src/bus.hg
+++ b/gstreamer/src/bus.hg
@@ -111,17 +111,7 @@ public:
*/
_WRAP_CREATE()
- /** Post a message on the given bus. Ownership of the message
- * is taken by the bus.
- *
- * @param message The Gst::Message to post. RefPtr is reset inside method.
- * @return <tt>true</tt> if the message could be posted, <tt>false</tt> if the bus is flushing.
- *
- * MT safe.
- */
- bool post(Glib::RefPtr<Gst::Message>& message);
- _IGNORE(gst_bus_post)
-
+ _WRAP_METHOD(bool post(Glib::RefPtr<Gst::Message>&& message), gst_bus_post)
_WRAP_METHOD(bool have_pending() const, gst_bus_have_pending)
_WRAP_METHOD(Glib::RefPtr<Gst::Message> peek(), gst_bus_peek)
_WRAP_METHOD(Glib::RefPtr<const Gst::Message> peek() const, gst_bus_peek)
diff --git a/gstreamer/src/caps.ccg b/gstreamer/src/caps.ccg
index eab7b07..916281e 100644
--- a/gstreamer/src/caps.ccg
+++ b/gstreamer/src/caps.ccg
@@ -118,22 +118,6 @@ Caps::set_simple(const Glib::ustring& name, const char* data)
set_simple(name, std::string(data));
}
-Glib::RefPtr<Gst::Caps> Caps::merge(Glib::RefPtr<Gst::Caps>& caps)
-{
- GstCaps *c1 = gobj(), *c2 = Glib::unwrap(caps);
- caps->reference(); caps.reset();
- reference();
- return Glib::wrap(gst_caps_merge(c1, c2));
-}
-
-void Caps::append(Glib::RefPtr<Gst::Caps>& caps)
-{
- caps->reference();
- GstCaps *c_caps = Glib::unwrap(caps);
- caps.reset();
- gst_caps_append(gobj(), c_caps);
-}
-
CapsFeatures Caps::get_features(guint index) const
{
GstCapsFeatures* features = gst_caps_get_features(gobj(), index);
@@ -152,6 +136,19 @@ Glib::RefPtr<Gst::Caps> Caps::truncate()
return Glib::wrap(gst_caps_truncate(gobj()));
}
+Glib::RefPtr<Gst::Caps> Caps::merge(Glib::RefPtr<Gst::Caps>&& caps)
+{
+ if (is_writable())
+ {
+ return Glib::wrap(gst_caps_merge(gobj(), caps.release()->gobj()), true);
+ }
+ else
+ {
+ reference();
+ return Glib::wrap(gst_caps_merge(gobj(), caps.release()->gobj()), false);
+ }
+}
+
} //namespace Gst
namespace Glib
diff --git a/gstreamer/src/caps.hg b/gstreamer/src/caps.hg
index de463f3..f421509 100644
--- a/gstreamer/src/caps.hg
+++ b/gstreamer/src/caps.hg
@@ -88,24 +88,9 @@ public:
_WRAP_METHOD(Glib::RefPtr<Gst::Caps> copy_nth(guint nth) const, gst_caps_copy_nth)
- /** Appends the structures contained in @a caps to this object. The structures in
- * @a caps are not copied -- they are transferred to this object, and then @a caps is
- * freed. If either caps is ANY, the resulting caps will be ANY.
- *
- * @param caps The Gst::Caps to append.
- */
- void append(Glib::RefPtr<Gst::Caps>& caps);
- _IGNORE(gst_caps_append)
+ _WRAP_METHOD(void append(Glib::RefPtr<Gst::Caps>&& caps), gst_caps_append)
- /** Appends the structures contained in @a caps to an object if they are not yet
- * expressed by this object. The structures in @a caps are not copied -- they are
- * transferred to a writable copy of this object, and then @a caps is freed.
- * If either caps is ANY, the resulting caps will be ANY.
- *
- * @param caps The Gst::Caps to merge in.
- * @return The merged caps.
- */
- Glib::RefPtr<Gst::Caps> merge(Glib::RefPtr<Gst::Caps>& caps);
+ Glib::RefPtr<Gst::Caps> merge(Glib::RefPtr<Gst::Caps>&& caps);
_IGNORE(gst_caps_merge)
/** Appends a structure to caps.
diff --git a/gstreamer/src/pad.ccg b/gstreamer/src/pad.ccg
index bd5f026..245e9b3 100644
--- a/gstreamer/src/pad.ccg
+++ b/gstreamer/src/pad.ccg
@@ -145,23 +145,6 @@ FlowReturn Pad::get_range(guint64 offset, guint size, Glib::RefPtr<Gst::Buffer>&
return FlowReturn(result);
}
-FlowReturn Pad::push(Glib::RefPtr<Gst::Buffer>& buffer)
-{
- GstBuffer *buffer_gobj = buffer->gobj();
- /* gst_pad_push takes ownership of given "buffer". It is recommended (for performance reasons) that the
buffer given to gst_pad_push() has
- * only one reference, since in other cases it will be copied whenever "make_writable" will be called.
- */
- buffer->reference(); //allocate additional ref for gst_pad_push()
- buffer.reset(); //take away buffer from the caller
- return FlowReturn(gst_pad_push(gobj(), buffer_gobj));
-}
-
-bool Pad::push_event(const Glib::RefPtr<Gst::Event>& event)
-{
- event->reference();
- return gst_pad_push_event(gobj(), event->gobj());
-}
-
FlowReturn Pad::pull_range(guint64 offset, guint size, Glib::RefPtr<Gst::Buffer>& buffer)
{
GstBuffer* c_buffer = nullptr;
@@ -170,12 +153,6 @@ FlowReturn Pad::pull_range(guint64 offset, guint size, Glib::RefPtr<Gst::Buffer>
return FlowReturn(result);
}
-bool Pad::send_event(const Glib::RefPtr<Gst::Event>& event)
-{
- event->reference();
- return gst_pad_send_event(gobj(), event->gobj());
-}
-
bool Pad::query_position(Format& format) const
{
return gst_pad_query_position(const_cast<GstPad*>(gobj()), (GstFormat)format, nullptr);
@@ -186,13 +163,6 @@ bool Pad::query_duration(Format& format) const
return gst_pad_query_duration(const_cast<GstPad*>(gobj()), (GstFormat)format, nullptr);
}
-FlowReturn Pad::chain(Glib::RefPtr<Gst::Buffer>& buffer)
-{
- buffer->reference(); //hold reference for gst_pad_chain()
- buffer.reset(); //free caller's reference
- return FlowReturn(gst_pad_chain(gobj(), buffer->gobj()));
-}
-
GstFlowReturn Pad::Pad_Chain_gstreamermm_callback(GstPad* pad, GstObject*, GstBuffer *buffer)
{
//FIXME: It's made like vfunc wrappers, but why there is no reffing of pad?
diff --git a/gstreamer/src/pad.hg b/gstreamer/src/pad.hg
index 45653ec..e8d7c22 100644
--- a/gstreamer/src/pad.hg
+++ b/gstreamer/src/pad.hg
@@ -218,39 +218,8 @@ public:
_WRAP_METHOD(bool proxy_query_caps(const Glib::RefPtr<Gst::Query>& query), gst_pad_proxy_query_caps)
_WRAP_METHOD(bool proxy_query_caps(const Glib::RefPtr<Gst::Query>& query) const, gst_pad_proxy_query_caps,
constversion)
_WRAP_METHOD(bool peer_query_accept_caps(const Glib::RefPtr<const Gst::Caps>& caps) const,
gst_pad_peer_query_accept_caps)
-
- // This method is written manually because an extra ref is necessary
- /** Pushes a buffer to the peer of the pad. The pad must be a source pad,
- * otherwise this method returns Gst::FLOW_ERROR.
- *
- * This function will call an installed pad block before triggering any
- * installed pad probes.
- *
- * If the caps on buffer are different from the currently configured caps on
- * pad, this function will call any installed setcaps function on pad (see
- * the C API gst_pad_set_setcaps_function()). In case of failure to
- * renegotiate the new format, this function returns
- * Gst::FLOW_NOT_NEGOTIATED.
- *
- * The function proceeds calling chain() on the peer pad and returns the
- * value from that function. If pad has no peer, Gst::FLOW_NOT_LINKED will
- * be returned.
- *
- * @param buffer The Gst::Buffer to push.
- * @return A Gst::FlowReturn from the peer pad. MT safe.
- */
- FlowReturn push(Glib::RefPtr<Gst::Buffer>& buffer);
- _IGNORE(gst_pad_push)
-
- // This method is written manually because an extra ref is necessary
- /** Sends the event to the peer of the pad. This function is mainly used by
- * elements to send events to their peer elements.
- *
- * @param event The GstEvent to send to the pad.
- * @return true if the event was handled. MT safe.
- */
- bool push_event(const Glib::RefPtr<Gst::Event>& event);
- _IGNORE(gst_pad_push_event)
+ _WRAP_METHOD(FlowReturn push(Glib::RefPtr<Gst::Buffer>&& buffer), gst_pad_push)
+ _WRAP_METHOD(bool push_event(Glib::RefPtr<Gst::Event>&& event), gst_pad_push_event)
/** Pulls a buffer from the peer pad. This function will first trigger the
* pad block signal if it was installed. This method works only on sink
@@ -276,34 +245,9 @@ public:
_IGNORE(gst_pad_pull_range)
_WRAP_METHOD(bool activate_mode(Gst::PadMode mode, bool active = true), gst_pad_activate_mode)
+ _WRAP_METHOD(bool send_event(Glib::RefPtr<Gst::Event>&& event), gst_pad_send_event)
- // This method is written manually because an extra ref is necessary
- /** Sends the event to the pad. This function can be used by applications to
- * send events in the pipeline.
- *
- * If the pad is a source pad, event should be an upstream event. If the pad
- * is a sink pad, the event should be a downstream event. For example, you
- * would not send a Gst::EVENT_EOS on a src pad; EOS events only propagate
- * downstream. Furthermore, some downstream events have to be serialized
- * with data flow, like EOS, while some can travel out-of-band, like
- * Gst::EVENT_FLUSH_START. If the event needs to be serialized with data
- * flow, this function will take the pad's stream lock while calling its
- * event function.
- *
- * To find out whether an event type is upstream, downstream, or downstream
- * and serialized, see Gst::EventTypeFlags, Gst::Enums::get_flags(),
- * is_upstream(), Gst::Event::is_downstream(), and
- * Gst::Event::is_serialized(). Note that in practice that an application or
- * plugin doesn't need to bother itself with this information; the core
- * handles all necessary locks and checks.
- *
- * @param event The Gst::Event to send to the pad.
- * @return true if the event was handled.
- */
- bool send_event(const Glib::RefPtr<Gst::Event>& event);
- _IGNORE(gst_pad_send_event)
-
- _WRAP_METHOD(bool event_default(const Glib::RefPtr<Gst::Object>& parent{?}, const
Glib::RefPtr<Gst::Event>& event), gst_pad_event_default)
+ _WRAP_METHOD(bool event_default(const Glib::RefPtr<Gst::Object>& parent{?}, Glib::RefPtr<Gst::Event>&&
event), gst_pad_event_default)
_WRAP_METHOD(bool query(const Glib::RefPtr<Gst::Query>& query) const, gst_pad_query)
_WRAP_METHOD(bool peer_query(const Glib::RefPtr<Gst::Query>& query) const, gst_pad_peer_query)
_WRAP_METHOD(Glib::RefPtr<Gst::Caps> peer_query_caps(const Glib::RefPtr<Gst::Caps>& filter) const,
gst_pad_peer_query_caps)
@@ -335,10 +279,7 @@ public:
_WRAP_METHOD(Gst::Iterator<const Gst::Pad> iterate_internal_links() const, gst_pad_iterate_internal_links)
_WRAP_METHOD(Gst::Iterator<Gst::Pad> iterate_internal_links_default(const Glib::RefPtr<Gst::Object>&
parent{?}), gst_pad_iterate_internal_links_default)
_WRAP_METHOD(Gst::Iterator<const Gst::Pad> iterate_internal_links_default(const Glib::RefPtr<Gst::Object>&
parent{?}) const, gst_pad_iterate_internal_links_default)
-
- // This method is written manually because an extra ref is necessary
- FlowReturn chain(Glib::RefPtr<Gst::Buffer>& buffer);
- _IGNORE(gst_pad_chain)
+ _WRAP_METHOD(Gst::FlowReturn chain(Glib::RefPtr<Gst::Buffer>&& buffer), gst_pad_chain)
_WRAP_METHOD(Glib::RefPtr<Gst::Caps> get_current_caps(), gst_pad_get_current_caps)
_WRAP_METHOD(bool pause_task() , gst_pad_pause_task)
diff --git a/tests/plugins/foo.h b/tests/plugins/foo.h
index 39239fc..250cba5 100644
--- a/tests/plugins/foo.h
+++ b/tests/plugins/foo.h
@@ -39,7 +39,7 @@ public:
std::sort(mapinfo->get_data(), mapinfo->get_data() + mapinfo->get_size());
buf->unmap(mapinfo);
assert(buf->gobj()->mini_object.refcount==1);
- return srcpad->push(buf);
+ return srcpad->push(std::move(buf));
}
explicit Foo(GstElement *gobj)
diff --git a/tests/regression/test-regression-seekonstartup.cc
b/tests/regression/test-regression-seekonstartup.cc
index c4fce91..5e0fb82 100644
--- a/tests/regression/test-regression-seekonstartup.cc
+++ b/tests/regression/test-regression-seekonstartup.cc
@@ -46,8 +46,7 @@ void dec_counter()
if (g_atomic_int_dec_and_test (&counter))
{
prerolled = true;
- Glib::RefPtr<Message> app = MessageApplication::create(pipeline, Structure("empty"));
- bus->post(app);
+ bus->post(MessageApplication::create(pipeline, Structure("empty")));
}
}
diff --git a/tests/test-allocator.cc b/tests/test-allocator.cc
index 9f460da..bbff25b 100644
--- a/tests/test-allocator.cc
+++ b/tests/test-allocator.cc
@@ -40,7 +40,7 @@ TEST(AllocatorTest, ShouldCorrectAllocateMemory)
EXPECT_EQ(7ul, mem->get_align());
EXPECT_TRUE(flags & mem->get_flags());
- allocator->free(mem);
+ allocator->free(std::move(mem));
}
class DerivedFromAllocator : public Gst::Allocator
@@ -62,10 +62,10 @@ public:
return r;
}
- virtual void free_vfunc(Glib::RefPtr<Gst::Memory>& memory)
+ void free_vfunc(Glib::RefPtr<Gst::Memory>&& memory) override
{
memory->gobj()->allocator = the_allocator->gobj(); // pretend that it was the_allocator who allocated
this memory
- the_allocator->free(memory);
+ the_allocator->free(std::move(memory));
}
static Glib::RefPtr<Allocator> create()
@@ -95,7 +95,7 @@ TEST(AllocatorTest, DerivedFromAllocatorShouldReturnProperlyRefcountedWrappedGst
EXPECT_EQ(7ul, mem->get_align());
EXPECT_TRUE(flags & mem->get_flags());
- allocator->free(mem);
+ allocator->free(std::move(mem));
}
TEST(AllocatorTest, DerivedFromAllocatorShouldReturnProperlyRefcountedGstMemory)
diff --git a/tests/test-buffer.cc b/tests/test-buffer.cc
index 7ad1c27..bc946a1 100644
--- a/tests/test-buffer.cc
+++ b/tests/test-buffer.cc
@@ -53,7 +53,7 @@ TEST(BufferTest, ShouldInsertMemoryObjectAndResetItButAllowToMakeExplicityRef)
delete data;
Glib::RefPtr<Buffer> buf = Buffer::create(10);
mem2 = mem;
- buf->insert_memory(0, mem);
+ buf->insert_memory(0, std::move(mem));
ASSERT_FALSE(mem);
ASSERT_EQ(2, mem2->gobj()->mini_object.refcount); // two - one handled by mem2,
//and the second by memory stored in buffer
@@ -77,7 +77,7 @@ TEST(BufferTest, ShouldResetMemoryPointerButAllowIncreaseRefcount)
Glib::RefPtr<Memory> mem2 = mem;
{
Glib::RefPtr<Buffer> buf = Buffer::create(10);
- buf->replace_memory_range(0, -1, mem);
+ buf->replace_memory_range(0, -1, std::move(mem));
}
ASSERT_FALSE(mem);
ASSERT_EQ(1, mem2->gobj()->mini_object.refcount);
@@ -119,3 +119,30 @@ TEST(BufferTest, CheckBufferCopyIntoMethod)
ASSERT_EQ(1, src->get_refcount());
ASSERT_EQ(1, dest->get_refcount());
}
+
+TEST(BufferTest, CheckRefcountAppendBufferToBuffer)
+{
+ Glib::RefPtr<Gst::Buffer> buf1 = Gst::Buffer::create(10);
+
+ { // buf1 not writable
+ Glib::RefPtr<Gst::Buffer> buf2 = Gst::Buffer::create(6);
+ Glib::RefPtr<Gst::Buffer> dummy = buf1;
+ Glib::RefPtr<Gst::Buffer> b = buf1->append(std::move(buf2));
+ ASSERT_FALSE(buf2);
+ ASSERT_EQ(2, buf1->get_refcount()); // dummy + buf1
+ ASSERT_EQ(1, b->get_refcount());
+ ASSERT_EQ(16u, b->get_size());
+ ASSERT_EQ(10u, buf1->get_size());
+ ASSERT_FALSE(b == buf1);
+ }
+
+ { // buf1 writable
+ Glib::RefPtr<Gst::Buffer> buf2 = Gst::Buffer::create(6);
+ Glib::RefPtr<Gst::Buffer> b = buf1->append(std::move(buf2));
+ ASSERT_FALSE(buf2);
+ ASSERT_EQ(2, buf1->get_refcount()); // b + buf1
+ ASSERT_EQ(2, b->get_refcount());
+ ASSERT_EQ(16u, b->get_size());
+ ASSERT_TRUE(b == buf1);
+ }
+}
diff --git a/tests/test-bus.cc b/tests/test-bus.cc
index f40b5ff..0ae919e 100644
--- a/tests/test-bus.cc
+++ b/tests/test-bus.cc
@@ -18,8 +18,7 @@ protected:
void PostMessage()
{
- Glib::RefPtr<Message> m = MessageEos::create(Glib::RefPtr<Object>());
- bool message_posted = bus->post(m);
+ bool message_posted = bus->post(MessageEos::create(Glib::RefPtr<Object>()));
ASSERT_TRUE(message_posted);
}
diff --git a/tests/test-caps.cc b/tests/test-caps.cc
index ba05d4f..873c8b2 100644
--- a/tests/test-caps.cc
+++ b/tests/test-caps.cc
@@ -84,7 +84,7 @@ TEST_F(CapsTest, AppendCapsToCaps)
Glib::RefPtr<Caps> new_caps = Caps::create_simple("video/x-raw");
new_caps->set_simple("width", width);
- caps->append(new_caps);
+ caps->append(std::move(new_caps));
CheckCaps("width", width, 1);
CheckCaps("framerate", framerate);
@@ -117,7 +117,7 @@ TEST_F(CapsTest, MergeCaps)
{
Glib::RefPtr<Caps> tmp = Caps::create_from_string("video/x-raw, format=RGBA");
Glib::RefPtr<Caps> tmp2 = Caps::create_from_string("video/x-raw, format=RGB");
- tmp = tmp->merge(tmp2);
+ tmp = tmp->merge(std::move(tmp2));
ASSERT_EQ(1, tmp->get_refcount());
ASSERT_FALSE(tmp2);
}
diff --git a/tests/test-pad.cc b/tests/test-pad.cc
index e8b8ce7..a473fd3 100644
--- a/tests/test-pad.cc
+++ b/tests/test-pad.cc
@@ -59,3 +59,23 @@ TEST_F(PadTest, PadVerifyGetPadTemplateCaps)
}
ASSERT_EQ(1, caps->get_refcount());
}
+
+TEST_F(PadTest, PadPushVerifyBufferRefcount)
+{
+ Glib::RefPtr<Gst::Buffer> buffer = Gst::Buffer::create();
+ pad = Pad::create(pad_name, Gst::PAD_SRC);
+
+ ASSERT_EQ(1, buffer->get_refcount());
+ pad->push(std::move(buffer));
+ ASSERT_FALSE(buffer);
+}
+
+TEST_F(PadTest, PadEventDefault)
+{
+ Glib::RefPtr<Gst::Event> event = Gst::EventEos::create();
+ pad = Pad::create(pad_name, pad_direction);
+
+ ASSERT_EQ(1, event->get_refcount());
+ pad->event_default(std::move(event));
+ ASSERT_FALSE(event);
+}
diff --git a/tools/m4/convert_gst.m4 b/tools/m4/convert_gst.m4
index 9c3321c..a43b71d 100644
--- a/tools/m4/convert_gst.m4
+++ b/tools/m4/convert_gst.m4
@@ -94,6 +94,8 @@ _CONVERSION(`const Glib::RefPtr<const Gst::Buffer>&',`GstBuffer*', `const_cast<G
_CONVERSION(`const Glib::RefPtr<Gst::Buffer>&',`const GstBuffer*', `Glib::unwrap($3)')
_CONVERSION(`Glib::RefPtr<Gst::Buffer>',`GstBuffer*', `Glib::unwrap($3)')
_CONVERSION(`GstBuffer*', `const Glib::RefPtr<Gst::Buffer>&', `Glib::wrap($3, true)')
+_CONVERSION(`Glib::RefPtr<Gst::Buffer>&&',`GstBuffer*',`($3) ? $3.release()->gobj() : nullptr')
+
dnl BufferList
_CONVERSION(`Glib::RefPtr<Gst::BufferList>',`GstBufferList*', `Glib::unwrap($3)')
@@ -115,6 +117,7 @@ _CONVERSION(`const Glib::RefPtr<Gst::Caps>&',`GstCaps*', `Glib::unwrap($3)')
_CONVERSION(`const Glib::RefPtr<const Gst::Caps>&',`GstCaps*', `const_cast<$2>(Glib::unwrap($3))')
_CONVERSION(`const Glib::RefPtr<Gst::Caps>&',`const GstCaps*', `Glib::unwrap($3)')
_CONVERSION(`const Glib::RefPtr<const Gst::Caps>&',`const GstCaps*', `Glib::unwrap($3)')
+_CONVERSION(`Glib::RefPtr<Gst::Caps>&&',`GstCaps*',`($3) ? $3.release()->gobj() : nullptr')
dnl CapsFeatures
_CONVERSION(`const Gst::CapsFeatures&',`const GstCapsFeatures*',`$3.gobj()')
@@ -166,6 +169,7 @@ dnl Event
_CONVERSION(`const Glib::RefPtr<Gst::Event>&',`GstEvent*', `Glib::unwrap($3)')
_CONVERSION(`GstEvent*',`const Glib::RefPtr<Gst::Event>&', `Glib::wrap($3)')
_CONVERSION(`GstEvent*',`Glib::RefPtr<Gst::Event>', `Glib::wrap($3)')
+_CONVERSION(`Glib::RefPtr<Gst::Event>&&',`GstEvent*',`($3) ? $3.release()->gobj() : nullptr')
dnl Socket
_CONVERSION(`const Glib::RefPtr<Gio::Socket>&',`GSocket*', `Glib::unwrap($3)')
@@ -194,6 +198,7 @@ _CONVERSION(`GstMemory*',`Glib::RefPtr<Gst::Memory>',`Glib::wrap($3)')
_CONVERSION(`Glib::RefPtr<Gst::Memory>&',`GstMemory*', `Glib::unwrap($3)')
_CONVERSION(`const Glib::RefPtr<Gst::Memory>&',`GstMemory*', `Glib::unwrap($3)')
_CONVERSION(`Glib::RefPtr<Gst::Memory>',`GstMemory*', `Glib::unwrap($3)')
+_CONVERSION(`Glib::RefPtr<Gst::Memory>&&',`GstMemory*',`($3) ? $3.release()->gobj() : nullptr')
dnl Message
_CONVERSION(`GstMessage*',`Glib::RefPtr<Gst::Message>',`Glib::wrap($3)')
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]