A |
| abort_track [Synthesized.source] |
|
| abort_track [Switch.switch] |
|
| abort_track [Source.source] |
Tells the source to finish the reading of current track.
|
| abort_track [Request_source.unqueued] |
|
| abort_track [Output.output] |
|
| abort_track [Generated.Make.source] |
|
| add_metadata [Output.output] |
|
| add_subsection [Doc.item] |
|
| advance [Source.source] |
|
| after_output [Switch.switch] |
|
| after_output [Source.source] |
Wait for output round to finish.
|
| attach [Source.clock] |
Attach an output source to the clock.
|
| attach_clock [Source.clock] |
|
C |
| cached_select [Switch.switch] |
|
| clock [Source.source] |
The clock under which the source will run, initially unknown.
|
| close [IoRing.output] |
|
| close [IoRing.input] |
|
| copy_queue [Request_source.queued] |
|
| copy_queue [Request_source.unqueued] |
|
| create_request [Source.source] |
Create a request with a "source" metadata.
|
D |
| detach [Source.clock] |
Detach output sources which satisfy a given criterion from the source.
|
E |
| encode [Output.encoded] |
|
| end_tick [Source.clock] |
|
| expire [Request_source.queued] |
#expire f marks queued requests r such that f r as expired,
which will trigger their removal from the queue as soon as possible .
|
G |
| get [Source.source] |
get buf asks the source to fill the buffer buf if possible.
|
| get [Plug.plug] |
|
| get_all [Plug.plug] |
|
| get_block [IoRing.input] |
|
| get_doc [Doc.item] |
|
| get_frame [Synthesized.source] |
|
| get_frame [Switch.switch] |
|
| get_frame [Source.source] |
|
| get_frame [Request_source.unqueued] |
|
| get_frame [Output.output] |
|
| get_frame [Generated.Make.source] |
|
| get_next_file [Request_source.queued] |
Everything you need is defined.
|
| get_next_file [Request_source.unqueued] |
get_next_file is the only thing you've got to define,
it's supposed to return "quickly" as it is run in the Root thread.
|
| get_next_request [Request_source.queued] |
You should only define this.
|
| get_ready [Source.source] |
The operator says to the source that he will ask it frames.
|
| get_subsection [Doc.item] |
|
| get_subsections [Doc.item] |
|
| get_tick [Source.clock] |
|
H |
| has_subsection [Doc.item] |
|
I |
| id [Source.source] |
Identifier of the source.
|
| id [IoRing.output] |
|
| id [IoRing.input] |
|
| id [Source.clock] |
Identifier of the clock.
|
| insert_metadata [Output.encoded] |
|
| is_active [Source.active_source] |
Is the source active ?
If the returned value is false, then output_reset
should not be called on that source.
|
| is_active [Output.output] |
An infallible (normal) output can always stream.
|
| is_output [Source.source] |
|
| is_ready [Synthesized.source] |
|
| is_ready [Switch.switch] |
|
| is_ready [Source.source] |
is_ready tells you if get can be called.
|
| is_ready [Request_source.unqueued] |
|
| is_ready [Output.output] |
|
| is_ready [Generated.Make.source] |
|
| is_registered [Plug.plug] |
|
| iter [Plug.plug] |
|
K |
| keys [Plug.plug] |
|
| kind [Source.source] |
What kind of content does this source produce.
|
L |
| leave [Source.source] |
Opposite of get_ready : the operator no longer needs the source.
|
| length [Generated.Make.source] |
|
| list_subsections [Doc.item] |
|
| log [Source.source] |
|
| log [Generated.Make.source] |
|
M |
| metadata_queue [Output.output] |
|
N |
| notify_new_request [Request_source.queued] |
This method should be called whenever the feeding task gets
a new opportunity to add more data into the queue.
|
O |
| on_shutdown [Source.source] |
Register a callback, to be executed when source shuts down.
|
| output [Source.active_source] |
Start a new output round, triggers computation of a new frame.
|
| output [Output.output] |
|
| output_get_ready [Source.active_source] |
Special init phase for outputs.
|
| output_get_ready [Output.output] |
|
| output_get_ready [IoRing.input] |
|
| output_reset [Source.active_source] |
Do whatever needed when the latency gets too big and is reset.
|
| output_reset [Output.encoded] |
|
| output_reset [Output.output] |
|
| output_send [Output.encoded] |
|
| output_send [Output.output] |
|
| output_start [Output.encoded] |
|
| output_start [Output.output] |
|
| output_start [IoRing.output] |
|
| output_stop [Output.encoded] |
|
| output_stop [Output.output] |
|
| output_stop [IoRing.output] |
|
P |
| pull_block [IoRing.input] |
|
| push_block [IoRing.output] |
|
| put_block [IoRing.output] |
|
R |
| reader [IoRing.output] |
|
| register [Plug.plug] |
|
| register_blocking_source [Clock.self_sync] |
|
| register_command [Source.source] |
|
| remaining [Synthesized.source] |
|
| remaining [Switch.switch] |
|
| remaining [Source.source] |
Number of frames left in the current track.
|
| remaining [Request_source.unqueued] |
|
| remaining [Output.output] |
|
| remaining [Generated.Make.source] |
|
S |
| seek [Synthesized.source] |
|
| seek [Source.source] |
|
| seek [Generated.Make.source] |
|
| select [Switch.random] |
|
| select [Switch.fallback] |
|
| select [Switch.lang_switch] |
|
| select [Switch.switch] |
The selection method should return None or Some c,
where c is a ready child.
|
| send [Output.encoded] |
|
| set_clock [Source.source] |
Choose your clock, by adjusting to your children source,
or anything custom.
|
| set_id [Source.source] |
|
| sleep [Switch.switch] |
|
| sleep [Source.source] |
|
| sleep [IoRing.input] |
|
| sourcering_stop [IoRing.base] |
|
| start_outputs [Source.clock] |
|
| stype [Synthesized.source] |
|
| stype [Switch.random] |
|
| stype [Switch.fallback] |
|
| stype [Switch.lang_switch] |
|
| stype [Source.source] |
|
| stype [Request_source.queued] |
|
| stype [Output.output] |
|
| stype [Generated.Make.consumer] |
|
| sub_clocks [Source.clock] |
|
| synthesize [Synthesized.source] |
|
U |
| unregister_blocking_source [Clock.self_sync] |
|
W |
| wake_up [Switch.switch] |
|
| wake_up [Source.source] |
Called when the source must be ready and had no active operator,
means that the source has to initialize.
|
| writer [IoRing.input] |
|