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] |
|