We only deal in TIME format ourselves, but if the subclass can handle
converting other formats into TIME format, we can support that too.
Fixes seeking in DEFAULT (sample) format with flacparse,
and the flacdec unit test.
Sometimes a transform filter would need the buffer pool or the memory
allocator negotiated by the base class, for example, for querying different
parameters, such as a bigger number of buffers to allocate by the buffer pool.
This patch expose a two getters accessors: one for the buffer pool and the
other for the memory allocator.
Sometimes the sources would use the buffer pool or the memory allocator for
something else than just allocating output buffers; for example, querying for
different parameters, such as a bigger number of buffers to allocate by the
pool.
This patch expose a two getters accessors: one for the buffer pool and the
other for the memory allocator.
Don't just return FALSE for seek events with negative rates when
operating in push mode. An upstream demuxer may support this just
fine, so if we're not operating in pull mode always check upstream
first if it can handle the seek event. This fixes reverse playback
where the upstream demuxer supports it (e.g. with qtdemux). The
same code would work fine in 0.10, because baseparse will just
call the default pad event handler if FALSE was returned from the
baseparse event handler, and the pad event handler will just
forward it upstream. In 0.11 the baseclass or subclass is
responsible for chaining up to the parent class or forwarding the
event upstream in any case.
Disable reverse playback in pull mode for now, there seems to
be something going wrong with the segment configuration in that
case.
This specifies if a given taglist applies to the complete
medium or only this specific stream. By default a taglist
has a stream scope.
Fixes bug #677619.
Define a 0 and -1 step amount. They used to almost do the same thing but now, 0
cancels/stops the current step and -1 keeps on stepping until the end of the
segment.
See https://bugzilla.gnome.org/show_bug.cgi?id=679378
Move code that checks for upstream seekability and all that to
the right place, otherwise it will never be done for formats
that have headers such as FLAC, as handle_and_push frame will
be called the first time only after headers have been processed
(and framecount is > 0). This then makes us report that we
can't seek, which disables the seek bar in totem.
when we have a new step event with a -1 amount, make sure that we follow the
regular code path so that the stop_end handler is called as usual. This takes
care of flushing the buffer in case of a flushing step and also posts a step end
message.
See https://bugzilla.gnome.org/show_bug.cgi?id=679378
In 0.11 the caller may provide a buffer to be filled by the source to
pull_range/get_range/create, but it's easy to miss this new case when
porting code from 0.10. Provide fallback that copies the created data
into the provided buffer for now.
This makes oggdemux in pull-mode work with dataurisrc.
Make gst_query_add_allocation_meta() take a copy of the passed caps instead of
taking ownership. This makes it easier for the caller in most cases because it
doesn't have to make a copy and deal with NULL values.
Make GstAllocator a GstObject instead of a GstMiniObject, like bufferpool.
Make a new gstallocator.c file. Make a GstAllocator subclass for the default
allocator.
Make it possible to add API specific flags to the ALLOCATION query. This makes
it possible to also check what kinds of subfeatures of the metadata API are
supported.
This is a queue which has the same API as GQueue, except that:
* It uses an array, instead of a doubled-linked-list
* The array can only grow.
This code is not-threadsafe. It is up to the owner to make sure the
proper locking is taken before calling this API.
Rename gst_base_sink_wait_eos() to gst_base_sink_wait() to avoid confusion and
introspection problems with the ::wait_eos vmethod. Also this method can be used
to wait for other things than EOS. Update the docs a little.
Add the running-time of the buffer that caused the async operation to complete
to the async-done message.
Update bin to handle the new async-done message.
Use the new RESET_TIME message to reset the start-time of the pipeline to the
requested time.
Make basesink request a new running-time when the flush-stop message tells it to
insteasd of waiting for preroll.
Use the pad methods to set and check the reconfigure flags
Clear the reconfigure flag before we negotiate so that we don't miss any
reconfigure events while negotiating
Release the object lock before we get the time of the clock because that code
might take other locks.
Fix potential clock refcount error because we released the object lock but
didn't ref the clock.
... since processing might still continue (if e.g. NOT_LINKED)
and then proper state (e.g. offset) needs to be maintained
(e.g. to arrange for a new frame setup).
The proto for helper_find_suggest has a different argument than the actual
function in the same file has. This causes the Sun Studio compiler to fail.
Fixes https://bugzilla.gnome.org/show_bug.cgi?id=676624
Conflicts:
libs/gst/base/gsttypefindhelper.c
Add a prepare method that is called before sync happens. The purpose of this
method is to prepare the rendering of the giving buffer so that the following
render() call after sync is a quick as possible.
In gst_base_src_start_complete() we do a perform_seek() that will eventually
start the streaming thread which acquires the live lock and then goes to sleep
in the case of appsrc. Right after we perform seek we also try to acquire the
live lock which might then deadlock.
fix this by taking the stream lock before performing the seek. This makes sure
that the streaming thread cannot start and grab the live lock until we are done
and release the stream lock again.
Fixes https://bugzilla.gnome.org/show_bug.cgi?id=676048
This allows subclasses to override it, as is necessary for e.g. the
video-crop meta. It is now necessary that after decide_allocation()
there is always a allocator and a configured buffer pool inside the
query.
It causes the timestamp to go wrong, should not cause much of a performance
increase and in the cases where it is faster, it is broken in 0.10 as well.
We should try to review this when rewriting the adapter for 0.11 memory
features.
Fixes https://bugzilla.gnome.org/show_bug.cgi?id=674791
... which presently mainly serves to answer SEEKING query negatively
to dissuade upstream encoders from doing any seeking and
"header finalization" (since the returned result of pushing a
sticky event is fairly useless nowadays).
Remove GST_MAJORMINOR and replace it by GST_API_VERSION
Also set GST_VERSION_{MAJOR,MINOR,MICRO,NANO} explicitely
now.
All versions are at 1.0.0 now for the release soon but
API/ABI can still change until the 1.0.0 release.
Next release versions until 1.0.0 will be 0.10.9X and
these will be release candidates. GST_VERSION_* will
nonetheless stay at 1.0.0.0.
This avoids ending up with plenty of pending data (since we'll only
try to parse/push one frame from the incoming buffer).
Fixes increasing memory consumption when parsers aren't linked
Conflicts:
libs/gst/base/gstbaseparse.c
This avoids ending up with plenty of pending data (since we'll only
try to parse/push one frame from the incoming buffer).
Fixes increasing memory consumption when parsers aren't linked
Add an option to control if transform_ip is called in passthrough mode or not.
for elements that don't want to look at the data in passthrough mode, this can
avoid some extra processing, mostly in subclasses.
gst_buffer_take_memory -> gst_buffer_insert_memory because insert is what the
method does.
Make all methods deal with ranges so that we can replace, merge, remove and map
a certain subset of the memory in a buffer. With the new methods we can make
some code nicer and reuse more code. Being able to deal with a subset of the
buffer memory allows us to optimize more cases later (most notably RTP headers
and payload that could be in different memory objects).
Make some more convenient macros that call the more generic range methods.
Add gst_buffer_append() which appends the memory blocks from one buffer to
another. Remove the old inefficient _merge() and _join() methods which forced a
premature memcpy in most cases.
Remove the _is_span() and _span() methods they are not needed anymore now that
we can _append(). Merging and spanning will be delayed until mapping or maybe
not at all when the element can deal with the different memory blocks.
... which controls how to (forcibly) deal with (non-)writable data and
is not necessarily related to identical caps.
In particular, it is also not so helpful anymore with a more advanced
GstVideoFilter subclass which always has a transform_ip method currently,
even though its subclass may not have a corresponding _ip method.
Improve the docs of the get/pull_range functions, define the lifetime of the
buffer in case of errors and short reads.
Make sure the code does what the docs say.
Make it so that one can specify a buffer for get/pull_range where the downstream
element should write into. When passing NULL, upstream should allocate a buffer,
like in 0.10.
We also need to change the probes a little because before the pull probe, there
could already be a buffer passed. This then allows us to use the same PROBE
macro for before and after pulling.
While we're at the probes, make the query probe more powerful by handling the
GST_PAD_PROBE_DROP return value. Returning _DROP from a query probe will now
return TRUE upstream and will not forward the probe to the peer or handler.
Also handle _DROP for get/pull_range properly by not dispatching to the
peer/handler or by generating EOS when the probe returns DROP and no buffer.
Make filesrc handle the non-NULL buffer passed in the get_range function and
skip the allocation in that case, writing directly into the downstream provided
buffer.
Update tests because now we need to make sure to not pass a random value in the
buffer pointer to get/pull_range
Separate the bufferpool and allocator hints in the allocation query, some
of the values don't always make sense together.
Keep the bufferpool and its configuration together.
Keep the allocator and its parameters together.
Allow for multiple bufferpool configurations in the query.
Group the extra allocation parameters in a GstAllocationParams structure to make
it easier to deal with them and so that we can extend them later if needed.
Make gst_buffer_new_allocate() take the GstAllocationParams for added
functionality.
Add boxed type for GstAllocationParams.
Change gst_allocator_alloc() so that we can also spicify flags and padding.
Add 2 new flags to mark the memory 0 prefixed/padded. This allows us to
remove some resizes in the base classes.
When allocating memory, memset prefix and padding with 0 when the flags tell
us to.
On resize, clear the zero padding flags if we can't guarantee the memory is
still 0 filled.
Update tests.
Negotiating padding is needed on second thought so include it in the
ALLOCATION query.
Make the bufferpool take padding into account when allocating.
Make basesrc take padding into account.
Use padding and prefix when allocating in basetransform.
Rework some caps operations so they don't rely on writable caps but instead take
ownership of the input caps and do _make_writable() only when needed.
Remove some const from caps functions, it does not make much sense for
refcounted objects and does not allow us to return a refcount to the const input
caps.
Rework the base classes fixate vmethods to not operate on the caps in-place.
All this saves us around 30% of caps and structure copy and new operations.
Answer the allocation query with FALSE when we are not negotiated yet because at
that point we have no idea if we need to proxy the allocation query or not.
Previously only the last would be pushed, which would cause
invalid running times downstream. This also fixes the handling
of update newsegment events.
The segment start adjustment code in pull mode should never trigger
anymore because the bisection code earlier would have already made
sure that we're at the desired position.
Also move the gap handling some lines below after sending the currently
configured segments. Otherwise we might fill gaps in a segment that is
not configured downstream yet.
Add a vmethod to filter metadata that should be passed upstream. By default,
don't pass anything.
Add a vmethod to transform metadata from the input buffer to the output buffer.
By default, nothing is transformed or copied.
Remove metadata that describes the particular memory of the buffer it is
attached to. We need to do this because in non-passthrough mode we will allocate
new memory for our output buffer.
Improve the propose allocation vmethod by passing the downstream allocation
query to it. This way the vmethod implementation can use properties of the
downstream allocation to generate the upstream query result. If there is no
downstream quety, it means that the element is working in passthrough mode.
Implement a default decide_allocation.
Rename gst_base_transform_suggest to gst_base_transform_reconfigure_sink because
that is what it does. Also remove the caps and size because that is not needed.
Rename gst_base_transform_reconfigure to gst_base_transform_reconfigure_src.
Remove some old unused code in capsfilter.
Always call the propose_allocation method and provide a default implementation
that passes the query on in passthrough mode so that subclasses can also call
this. Also pass if the transform is in passthrough mode so that the
implementation can adjust its algorithm.
Make it possible to also implement non-inplace fixate functions. Let the fixate
function make the caps writable when needed because some fixate functions might
not need to modify the caps.
Make it possible to configure a GDestroyNotify and user_data for
gst_memory_new_wrapped() this allows for more flexible wrapping of foreign
memory blocks.
Use a frame flag to signal to subclass it should reset any retained
state w.r.t. frame parsing since the frame being passed is 'new',
i.e. not related to previously passed and processed data.
Make the pad activation code look more like other activation code.
Only start the sinkpad task when we decide to activate in pull mode, when we
later add srcpad pullmode this will be needed.
... so as to allow the push-mode case to provide data to subclass
on a buffer by buffer basis (as in regular forward case), rather
than all buffers of a fragment chucked together.
Also refactor buffer handling some more, and add some debug.
... since that is already handled by _update_duration, or should not be done
altogether if the duration is determined by non-estimated means.
Fixes#669502.
Clean up the prepare_output_buffer function.
Reuse the input buffer when it is writable and when doing an
in-place but non-passthrough transform.
Move the copy-metadata function call to the prepare_output_buffer default
function. If subclasses implement a custom prepare_output_buffer, they must also
copy the metadata themselves.
Remove a useless memory copy because prepare_output_buffer already did that.
Place the allocator object in the ALLOCATION query instead of the name. This
allows us to exchange allocators that are not in the global pool of allocators.
Update elements for the new api
Add refcounting to the GstAllocator object.
Remove const from functions because the allocator is refcounted now.
Rename the vmethods for consistency
Expose the constructor for GstAllocator and add a destroy notify for the
user_data. This should make it possible to create allocators that are not
registered and shared globally along with the possibility to destroy them
properly.
Update defs with new symbols.
And only forward the allocation query if we're working in
passthrough mode if no ::propose_allocation is implemented.
In place buffer transformations will change the buffer
content and require explicit handling of all metas.
When _clear gets called between _map and _unmap, buffers
will be unreffed. If the adapter was mapped, memory leaks
may occur.
While calling _clear between _map and _unmap does not seem
like such a great idea, this is possible in the audio
encoder base class, as _clear may be called in _finish_frame.
Since the audio encoder relies on flushing to keep track of
timestamps, delaying flushing till after handle_frame seems
dangerous.
So, we unmap on clear, as the next unmap will do nothing.
This makes _clear safe to call between _map and _unmap,
while avoiding leaking the mapped buffer.
https://bugzilla.gnome.org/show_bug.cgi?id=664133
GstBaseParse was not clearing its adapter on reset causing
problems when a pipeline went for example from PLAYING to NULL
state and then back to PLAYING again. The data from the last
stream would be used in the parser.
https://bugzilla.gnome.org/show_bug.cgi?id=667444
There are many good use cases for GstIndex and we want
to add it back again in some form, but possibly not with
the current API, which is very powerful (maybe too powerful),
but also a bit confusing. At the very least we'd need to
make the API bindings-friendly.
Conflicts:
libs/gst/base/gstbasetransform.c
libs/gst/controller/gstinterpolationcontrolsource.c
libs/gst/controller/gstlfocontrolsource.c
plugins/elements/gstfilesrc.c
Dit not merge controller or basetransform changes.
Conflicts:
gst/gstindexfactory.c
libs/gst/base/gstbasetransform.c
plugins/elements/gstfakesink.c
plugins/elements/gstfakesrc.c
plugins/elements/gstidentity.c
plugins/elements/gstinputselector.c
plugins/elements/gstoutputselector.c
Note: did not merge any of the basetransform changes from 0.10.
Add a method to enable async start behaviour. The subclass can then complete the
start operation from any other thread by caling gst_base_src_start_complete().
The base class can wait for the start to complete with
gst_base_src_start_wait().
Add private replacements for deprecated functions such as
g_mutex_new(), g_mutex_free(), g_cond_new() etc., mostly
to avoid the deprecation warnings. We can't change most of
these in 0.10 because they're part of our API and ABI.
Merge the render_object code with the chain method. It is only called from there
and there are quite a few variables that can be reused to makes things less
confusing.
Add new wait_eos vmethod to wait for the eos timeout before posting the EOS
message on the bus.
Add default event handler. Move the default event actions in there. Call the
event vmethod from the pad event handler. Subclasses are now supposed to chain
up to the parent event handler or unref the event and do their own thing.
Avoid passing unused parameters to functions.
Rename the last-buffer property to last-sample and make it return the new
GstSample type so that we can include caps and timing info in one nice bundle.
This makes sure that we get correct and complete caps. The suggested caps
could be incomplete, e.g. video/x-raw-rgb without any fields, and by
intersecting with the peer caps we get something usable.
Fixes bug #662199.
