part-TODO.txt 3.62 KB
Newer Older
1 2 3
TODO - Future Development
-------------------------

4
API/ABI
5
~~~~~~~
Wim Taymans's avatar
Wim Taymans committed
6

7 8 9 10 11
- implement return values from events in addition to the gboolean. This should
  be done by making the event contain a GstStructure with input/output values,
  similar to GstQuery. A typical use case is performing a non-accurate seek to a
  keyframe, after the seek you want to get the new stream time that will
  actually be used to update the slider bar.
Wim Taymans's avatar
Wim Taymans committed
12

13 14 15
- make gst_pad_push_event() return a GstFlowReturn so that we can resend
  NEWSEGMENT and other events.

Wim Taymans's avatar
Wim Taymans committed
16
- GstEvent, GstMessage register like GstFormat or GstQuery.
17

18 19
- query POSITION/DURATION return accuracy. Just a flag or accuracy percentage.

20 21
- use | instead of + as divider in serialization of Flags
  (gstvalue/gststructure)
22

23
- rethink how we handle dynamic replugging wrt segments and other events that
24 25
  already got pushed and need to be pushed again. Might need GstFlowReturn from
  gst_pad_push_event().
26

27 28 29
- Optimize negotiation. We currently do a get_caps() call when we link pads,
  which could potentially generate a huge list of caps and all their
  combinations, we need to avoid generating these huge lists by generating them
Piotr Fusik's avatar
Piotr Fusik committed
30
  incrementally when needed. We can do this with a gst_pad_iterate_caps() call.
31 32
  We also need to incrementally return intersections etc, for this.

Wim Taymans's avatar
Wim Taymans committed
33 34 35 36 37 38
- Elements in a bin have no clue about the final state of the parent element
  since the bin sets the target state on its children in small steps. This
  causes problems for elements that like to know the final state (rtspsrc going
  to PAUSED or READY is different in that we can avoid sending the useless
  PAUSED request).

Wim Taymans's avatar
Wim Taymans committed
39 40
- Make serialisation of structures more consistent, readable and nicer code-wise.

41 42 43 44 45 46
- pad block has several issues: 
  * can't block on selected things, like push, pull, pad_alloc, events, ...
  * can't check why the block happened. We should also be able to get the item/
    reason that blocked the pad. 
  * it only blocks on datapassing. When EOS, the block never happens but ideally
    should because pad block should inform the app when there is no dataflow.
47 48
  * the same goes for segment seeks that don't push in-band EOS events. Maybe
    segment seeks should also send an EOS event when they're done.
49 50 51 52 53
  * blocking should only happen from one thread. If one thread does pad_alloc
    and another a push, the push might be busy while the block callback is done.
  * maybe this name is overloaded. We need to look at some more use cases before
    trying to fix this.

54 55 56 57 58 59 60
- rethink the way we do upstream renegotiation. Currently it's done with
  pad_alloc but this has many issues such as only being able to suggest 1 format
  and the need to allocate a buffer of this suggested format (some elements such
  as capsfilter only know about the format, not the size). We would ideally like
  to let upstream renegotiate a new format just like it did when it started.
  This could, for example, easily be triggered with a RENEGOTIATE event.

61 62
- Remove the XML serialisation stuff.

63 64
- Remove the result format value in queries.

Wim Taymans's avatar
Wim Taymans committed
65 66 67 68 69
- Try to minimize the amount of acceptcaps calls when pushing buffers around.
  The element pushing the buffer usually negotiated already and decided on the
  format.
  The element receiving the buffer usually has to accept the caps anyway.

70

71
IMPLEMENTATION
72
~~~~~~~~~~~~~~
73

74
- implement more QOS, see part-qos.txt.
75 76

- implement BUFFERSIZE.
77

78
- implement pad_block with probes? see above.
79

80 81

DESIGN
82
~~~~~~
83 84 85 86 87

- unlinking pads in the PAUSED state needs to make sure the stream thread is not
  executing code. Can this be done with a flush to unlock all downstream chain
  functions? Do we do this automatically or let the app handle this?