FFmpeg
ffmpeg_sched.h
Go to the documentation of this file.
1 /*
2  * Inter-thread scheduling/synchronization.
3  * Copyright (c) 2023 Anton Khirnov
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #ifndef FFTOOLS_FFMPEG_SCHED_H
23 #define FFTOOLS_FFMPEG_SCHED_H
24 
25 #include <stddef.h>
26 #include <stdint.h>
27 
28 #include "ffmpeg_utils.h"
29 
30 /*
31  * This file contains the API for the transcode scheduler.
32  *
33  * Overall architecture of the transcoding process involves instances of the
34  * following components:
35  * - demuxers, each containing any number of demuxed streams; demuxed packets
36  * belonging to some stream are sent to any number of decoders (transcoding)
37  * and/or muxers (streamcopy);
38  * - decoders, which receive encoded packets from some demuxed stream or
39  * encoder, decode them, and send decoded frames to any number of filtergraph
40  * inputs (audio/video) or encoders (subtitles);
41  * - filtergraphs, each containing zero or more inputs (0 in case the
42  * filtergraph contains a lavfi source filter), and one or more outputs; the
43  * inputs and outputs need not have matching media types;
44  * each filtergraph input receives decoded frames from some decoder or another
45  * filtergraph output;
46  * filtered frames from each output are sent to some encoder;
47  * - encoders, which receive decoded frames from some decoder (subtitles) or
48  * some filtergraph output (audio/video), encode them, and send encoded
49  * packets to any number of muxed streams or decoders;
50  * - muxers, each containing any number of muxed streams; each muxed stream
51  * receives encoded packets from some demuxed stream (streamcopy) or some
52  * encoder (transcoding); those packets are interleaved and written out by the
53  * muxer.
54  *
55  * The structure formed by the above components is a directed acyclic graph
56  * (absence of cycles is checked at startup).
57  *
58  * There must be at least one muxer instance, otherwise the transcode produces
59  * no output and is meaningless. Otherwise, in a generic transcoding scenario
60  * there may be arbitrary number of instances of any of the above components,
61  * interconnected in various ways.
62  *
63  * The code tries to keep all the output streams across all the muxers in sync
64  * (i.e. at the same DTS), which is accomplished by varying the rates at which
65  * packets are read from different demuxers and lavfi sources. Note that the
66  * degree of control we have over synchronization is fundamentally limited - if
67  * some demuxed streams in the same input are interleaved at different rates
68  * than that at which they are to be muxed (e.g. because an input file is badly
69  * interleaved, or the user changed their speed by mismatching amounts), then
70  * there will be increasing amounts of buffering followed by eventual
71  * transcoding failure.
72  *
73  * N.B. 1: there are meaningful transcode scenarios with no demuxers, e.g.
74  * - encoding and muxing output from filtergraph(s) that have no inputs;
75  * - creating a file that contains nothing but attachments and/or metadata.
76  *
77  * N.B. 2: a filtergraph output could, in principle, feed multiple encoders, but
78  * this is unnecessary because the (a)split filter provides the same
79  * functionality.
80  *
81  * The scheduler, in the above model, is the master object that oversees and
82  * facilitates the transcoding process. The basic idea is that all instances
83  * of the abovementioned components communicate only with the scheduler and not
84  * with each other. The scheduler is then the single place containing the
85  * knowledge about the whole transcoding pipeline.
86  */
87 
88 struct AVFrame;
89 struct AVPacket;
90 
91 typedef struct Scheduler Scheduler;
92 
101 };
102 
103 typedef struct SchedulerNode {
105  unsigned idx;
106  unsigned idx_stream;
107 } SchedulerNode;
108 
109 typedef int (*SchThreadFunc)(void *arg);
110 
111 #define SCH_DSTREAM(file, stream) \
112  (SchedulerNode){ .type = SCH_NODE_TYPE_DEMUX, \
113  .idx = file, .idx_stream = stream }
114 #define SCH_MSTREAM(file, stream) \
115  (SchedulerNode){ .type = SCH_NODE_TYPE_MUX, \
116  .idx = file, .idx_stream = stream }
117 #define SCH_DEC(decoder) \
118  (SchedulerNode){ .type = SCH_NODE_TYPE_DEC, \
119  .idx = decoder }
120 #define SCH_ENC(encoder) \
121  (SchedulerNode){ .type = SCH_NODE_TYPE_ENC, \
122  .idx = encoder }
123 #define SCH_FILTER_IN(filter, input) \
124  (SchedulerNode){ .type = SCH_NODE_TYPE_FILTER_IN, \
125  .idx = filter, .idx_stream = input }
126 #define SCH_FILTER_OUT(filter, output) \
127  (SchedulerNode){ .type = SCH_NODE_TYPE_FILTER_OUT, \
128  .idx = filter, .idx_stream = output }
129 
130 Scheduler *sch_alloc(void);
131 void sch_free(Scheduler **sch);
132 
133 int sch_start(Scheduler *sch);
134 int sch_stop(Scheduler *sch, int64_t *finish_ts);
135 
136 /**
137  * Wait until transcoding terminates or the specified timeout elapses.
138  *
139  * @param timeout_us Amount of time in microseconds after which this function
140  * will timeout.
141  * @param transcode_ts Current transcode timestamp in AV_TIME_BASE_Q, for
142  * informational purposes only.
143  *
144  * @retval 0 waiting timed out, transcoding is not finished
145  * @retval 1 transcoding is finished
146  */
147 int sch_wait(Scheduler *sch, uint64_t timeout_us, int64_t *transcode_ts);
148 
149 /**
150  * Add a demuxer to the scheduler.
151  *
152  * @param func Function executed as the demuxer task.
153  * @param ctx Demuxer state; will be passed to func and used for logging.
154  *
155  * @retval ">=0" Index of the newly-created demuxer.
156  * @retval "<0" Error code.
157  */
158 int sch_add_demux(Scheduler *sch, SchThreadFunc func, void *ctx);
159 /**
160  * Add a demuxed stream for a previously added demuxer.
161  *
162  * @param demux_idx index previously returned by sch_add_demux()
163  *
164  * @retval ">=0" Index of the newly-created demuxed stream.
165  * @retval "<0" Error code.
166  */
167 int sch_add_demux_stream(Scheduler *sch, unsigned demux_idx);
168 
169 /**
170  * Add a decoder to the scheduler.
171  *
172  * @param func Function executed as the decoder task.
173  * @param ctx Decoder state; will be passed to func and used for logging.
174  * @param send_end_ts The decoder will return an end timestamp after flush packets
175  * are delivered to it. See documentation for
176  * sch_dec_receive() for more details.
177  *
178  * @retval ">=0" Index of the newly-created decoder.
179  * @retval "<0" Error code.
180  */
181 int sch_add_dec(Scheduler *sch, SchThreadFunc func, void *ctx,
182  int send_end_ts);
183 
184 /**
185  * Add a filtergraph to the scheduler.
186  *
187  * @param nb_inputs Number of filtergraph inputs.
188  * @param nb_outputs number of filtergraph outputs
189  * @param func Function executed as the filtering task.
190  * @param ctx Filter state; will be passed to func and used for logging.
191  *
192  * @retval ">=0" Index of the newly-created filtergraph.
193  * @retval "<0" Error code.
194  */
195 int sch_add_filtergraph(Scheduler *sch, unsigned nb_inputs, unsigned nb_outputs,
196  SchThreadFunc func, void *ctx);
197 
198 /**
199  * Add a muxer to the scheduler.
200  *
201  * Note that muxer thread startup is more complicated than for other components,
202  * because
203  * - muxer streams fed by audio/video encoders become initialized dynamically at
204  * runtime, after those encoders receive their first frame and initialize
205  * themselves, followed by calling sch_mux_stream_ready()
206  * - the header can be written after all the streams for a muxer are initialized
207  * - we may need to write an SDP, which must happen
208  * - AFTER all the headers are written
209  * - BEFORE any packets are written by any muxer
210  * - with all the muxers quiescent
211  * To avoid complicated muxer-thread synchronization dances, we postpone
212  * starting the muxer threads until after the SDP is written. The sequence of
213  * events is then as follows:
214  * - After sch_mux_stream_ready() is called for all the streams in a given muxer,
215  * the header for that muxer is written (care is taken that headers for
216  * different muxers are not written concurrently, since they write file
217  * information to stderr). If SDP is not wanted, the muxer thread then starts
218  * and muxing begins.
219  * - When SDP _is_ wanted, no muxer threads start until the header for the last
220  * muxer is written. After that, the SDP is written, after which all the muxer
221  * threads are started at once.
222  *
223  * In order for the above to work, the scheduler needs to be able to invoke
224  * just writing the header, which is the reason the init parameter exists.
225  *
226  * @param func Function executed as the muxing task.
227  * @param init Callback that is called to initialize the muxer and write the
228  * header. Called after sch_mux_stream_ready() is called for all the
229  * streams in the muxer.
230  * @param ctx Muxer state; will be passed to func/init and used for logging.
231  * @param sdp_auto Determines automatic SDP writing - see sch_sdp_filename().
232  * @param thread_queue_size number of packets that can be buffered before
233  * sending to the muxer blocks
234  *
235  * @retval ">=0" Index of the newly-created muxer.
236  * @retval "<0" Error code.
237  */
238 int sch_add_mux(Scheduler *sch, SchThreadFunc func, int (*init)(void *),
239  void *ctx, int sdp_auto, unsigned thread_queue_size);
240 
241 /**
242  * Default size of a packet thread queue. For muxing this can be overridden by
243  * the thread_queue_size option as passed to a call to sch_add_mux().
244  */
245 #define DEFAULT_PACKET_THREAD_QUEUE_SIZE 8
246 
247 /**
248  * Default size of a frame thread queue.
249  */
250 #define DEFAULT_FRAME_THREAD_QUEUE_SIZE 8
251 
252 /**
253  * Add a muxed stream for a previously added muxer.
254  *
255  * @param mux_idx index previously returned by sch_add_mux()
256  *
257  * @retval ">=0" Index of the newly-created muxed stream.
258  * @retval "<0" Error code.
259  */
260 int sch_add_mux_stream(Scheduler *sch, unsigned mux_idx);
261 
262 /**
263  * Configure limits on packet buffering performed before the muxer task is
264  * started.
265  *
266  * @param mux_idx index previously returned by sch_add_mux()
267  * @param stream_idx_idx index previously returned by sch_add_mux_stream()
268  * @param data_threshold Total size of the buffered packets' data after which
269  * max_packets applies.
270  * @param max_packets maximum Maximum number of buffered packets after
271  * data_threshold is reached.
272  */
273 void sch_mux_stream_buffering(Scheduler *sch, unsigned mux_idx, unsigned stream_idx,
274  size_t data_threshold, int max_packets);
275 
276 /**
277  * Signal to the scheduler that the specified muxed stream is initialized and
278  * ready. Muxing is started once all the streams are ready.
279  */
280 int sch_mux_stream_ready(Scheduler *sch, unsigned mux_idx, unsigned stream_idx);
281 
282 /**
283  * Set the file path for the SDP.
284  *
285  * The SDP is written when either of the following is true:
286  * - this function is called at least once
287  * - sdp_auto=1 is passed to EVERY call of sch_add_mux()
288  */
289 int sch_sdp_filename(Scheduler *sch, const char *sdp_filename);
290 
291 /**
292  * Add an encoder to the scheduler.
293  *
294  * @param func Function executed as the encoding task.
295  * @param ctx Encoder state; will be passed to func and used for logging.
296  * @param open_cb This callback, if specified, will be called when the first
297  * frame is obtained for this encoder. For audio encoders with a
298  * fixed frame size (which use a sync queue in the scheduler to
299  * rechunk frames), it must return that frame size on success.
300  * Otherwise (non-audio, variable frame size) it should return 0.
301  *
302  * @retval ">=0" Index of the newly-created encoder.
303  * @retval "<0" Error code.
304  */
305 int sch_add_enc(Scheduler *sch, SchThreadFunc func, void *ctx,
306  int (*open_cb)(void *func_arg, const struct AVFrame *frame));
307 
308 /**
309  * Add an pre-encoding sync queue to the scheduler.
310  *
311  * @param buf_size_us Sync queue buffering size, passed to sq_alloc().
312  * @param logctx Logging context for the sync queue. passed to sq_alloc().
313  *
314  * @retval ">=0" Index of the newly-created sync queue.
315  * @retval "<0" Error code.
316  */
317 int sch_add_sq_enc(Scheduler *sch, uint64_t buf_size_us, void *logctx);
318 int sch_sq_add_enc(Scheduler *sch, unsigned sq_idx, unsigned enc_idx,
319  int limiting, uint64_t max_frames);
320 
322 
324  /**
325  * Treat the packet as an EOF for SCH_NODE_TYPE_MUX destinations
326  * send normally to other types.
327  */
329 };
330 
331 /**
332  * Called by demuxer tasks to communicate with their downstreams. The following
333  * may be sent:
334  * - a demuxed packet for the stream identified by pkt->stream_index;
335  * - demuxer discontinuity/reset (e.g. after a seek) - this is signalled by an
336  * empty packet with stream_index=-1.
337  *
338  * @param demux_idx demuxer index
339  * @param pkt A demuxed packet to send.
340  * When flushing (i.e. pkt->stream_index=-1 on entry to this
341  * function), on successful return pkt->pts/pkt->time_base will be
342  * set to the maximum end timestamp of any decoded audio stream, or
343  * AV_NOPTS_VALUE if no decoded audio streams are present.
344  *
345  * @retval "non-negative value" success
346  * @retval AVERROR_EOF all consumers for the stream are done
347  * @retval AVERROR_EXIT all consumers are done, should terminate demuxing
348  * @retval "anoter negative error code" other failure
349  */
350 int sch_demux_send(Scheduler *sch, unsigned demux_idx, struct AVPacket *pkt,
351  unsigned flags);
352 
353 /**
354  * Called by decoder tasks to receive a packet for decoding.
355  *
356  * @param dec_idx decoder index
357  * @param pkt Input packet will be written here on success.
358  *
359  * An empty packet signals that the decoder should be flushed, but
360  * more packets will follow (e.g. after seeking). When a decoder
361  * created with send_end_ts=1 receives a flush packet, it must write
362  * the end timestamp of the stream after flushing to
363  * pkt->pts/time_base on the next call to this function (if any).
364  *
365  * @retval "non-negative value" success
366  * @retval AVERROR_EOF no more packets will arrive, should terminate decoding
367  * @retval "another negative error code" other failure
368  */
369 int sch_dec_receive(Scheduler *sch, unsigned dec_idx, struct AVPacket *pkt);
370 
371 /**
372  * Called by decoder tasks to send a decoded frame downstream.
373  *
374  * @param dec_idx Decoder index previously returned by sch_add_dec().
375  * @param frame Decoded frame; on success it is consumed and cleared by this
376  * function
377  *
378  * @retval ">=0" success
379  * @retval AVERROR_EOF all consumers are done, should terminate decoding
380  * @retval "another negative error code" other failure
381  */
382 int sch_dec_send(Scheduler *sch, unsigned dec_idx, struct AVFrame *frame);
383 
384 /**
385  * Called by filtergraph tasks to obtain frames for filtering. Will wait for a
386  * frame to become available and return it in frame.
387  *
388  * Filtergraphs that contain lavfi sources and do not currently require new
389  * input frames should call this function as a means of rate control - then
390  * in_idx should be set equal to nb_inputs on entry to this function.
391  *
392  * @param fg_idx Filtergraph index previously returned by sch_add_filtergraph().
393  * @param[in,out] in_idx On input contains the index of the input on which a frame
394  * is most desired. May be set to nb_inputs to signal that
395  * the filtergraph does not need more input currently.
396  *
397  * On success, will be replaced with the input index of
398  * the actually returned frame or EOF timestamp.
399  *
400  * @retval ">=0" Frame data or EOF timestamp was delivered into frame, in_idx
401  * contains the index of the input it belongs to.
402  * @retval AVERROR(EAGAIN) No frame was returned, the filtergraph should
403  * resume filtering. May only be returned when
404  * in_idx=nb_inputs on entry to this function.
405  * @retval AVERROR_EOF No more frames will arrive, should terminate filtering.
406  */
407 int sch_filter_receive(Scheduler *sch, unsigned fg_idx,
408  unsigned *in_idx, struct AVFrame *frame);
409 /**
410  * Called by filter tasks to signal that a filter input will no longer accept input.
411  *
412  * @param fg_idx Filtergraph index previously returned from sch_add_filtergraph().
413  * @param in_idx Index of the input to finish.
414  */
415 void sch_filter_receive_finish(Scheduler *sch, unsigned fg_idx, unsigned in_idx);
416 
417 /**
418  * Called by filtergraph tasks to send a filtered frame or EOF to consumers.
419  *
420  * @param fg_idx Filtergraph index previously returned by sch_add_filtergraph().
421  * @param out_idx Index of the output which produced the frame.
422  * @param frame The frame to send to consumers. When NULL, signals that no more
423  * frames will be produced for the specified output. When non-NULL,
424  * the frame is consumed and cleared by this function on success.
425  *
426  * @retval "non-negative value" success
427  * @retval AVERROR_EOF all consumers are done
428  * @retval "anoter negative error code" other failure
429  */
430 int sch_filter_send(Scheduler *sch, unsigned fg_idx, unsigned out_idx,
431  struct AVFrame *frame);
432 
433 int sch_filter_command(Scheduler *sch, unsigned fg_idx, struct AVFrame *frame);
434 
435 /**
436  * Called by encoder tasks to obtain frames for encoding. Will wait for a frame
437  * to become available and return it in frame.
438  *
439  * @param enc_idx Encoder index previously returned by sch_add_enc().
440  * @param frame Newly-received frame will be stored here on success. Must be
441  * clean on entrance to this function.
442  *
443  * @retval 0 A frame was successfully delivered into frame.
444  * @retval AVERROR_EOF No more frames will be delivered, the encoder should
445  * flush everything and terminate.
446  *
447  */
448 int sch_enc_receive(Scheduler *sch, unsigned enc_idx, struct AVFrame *frame);
449 
450 /**
451  * Called by encoder tasks to send encoded packets downstream.
452  *
453  * @param enc_idx Encoder index previously returned by sch_add_enc().
454  * @param pkt An encoded packet; it will be consumed and cleared by this
455  * function on success.
456  *
457  * @retval 0 success
458  * @retval "<0" Error code.
459  */
460 int sch_enc_send (Scheduler *sch, unsigned enc_idx, struct AVPacket *pkt);
461 
462 /**
463  * Called by muxer tasks to obtain packets for muxing. Will wait for a packet
464  * for any muxed stream to become available and return it in pkt.
465  *
466  * @param mux_idx Muxer index previously returned by sch_add_mux().
467  * @param pkt Newly-received packet will be stored here on success. Must be
468  * clean on entrance to this function.
469  *
470  * @retval 0 A packet was successfully delivered into pkt. Its stream_index
471  * corresponds to a stream index previously returned from
472  * sch_add_mux_stream().
473  * @retval AVERROR_EOF When pkt->stream_index is non-negative, this signals that
474  * no more packets will be delivered for this stream index.
475  * Otherwise this indicates that no more packets will be
476  * delivered for any stream and the muxer should therefore
477  * flush everything and terminate.
478  */
479 int sch_mux_receive(Scheduler *sch, unsigned mux_idx, struct AVPacket *pkt);
480 
481 /**
482  * Called by muxer tasks to signal that a stream will no longer accept input.
483  *
484  * @param stream_idx Stream index previously returned from sch_add_mux_stream().
485  */
486 void sch_mux_receive_finish(Scheduler *sch, unsigned mux_idx, unsigned stream_idx);
487 
488 int sch_mux_sub_heartbeat_add(Scheduler *sch, unsigned mux_idx, unsigned stream_idx,
489  unsigned dec_idx);
490 int sch_mux_sub_heartbeat(Scheduler *sch, unsigned mux_idx, unsigned stream_idx,
491  const AVPacket *pkt);
492 
493 #endif /* FFTOOLS_FFMPEG_SCHED_H */
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:68
SchedulerNode::idx_stream
unsigned idx_stream
Definition: ffmpeg_sched.h:106
SCH_NODE_TYPE_ENC
@ SCH_NODE_TYPE_ENC
Definition: ffmpeg_sched.h:98
sch_stop
int sch_stop(Scheduler *sch, int64_t *finish_ts)
Definition: ffmpeg_sched.c:2504
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
sch_add_demux
int sch_add_demux(Scheduler *sch, SchThreadFunc func, void *ctx)
Add a demuxer to the scheduler.
Definition: ffmpeg_sched.c:676
SCH_NODE_TYPE_MUX
@ SCH_NODE_TYPE_MUX
Definition: ffmpeg_sched.h:96
sch_dec_send
int sch_dec_send(Scheduler *sch, unsigned dec_idx, struct AVFrame *frame)
Called by decoder tasks to send a decoded frame downstream.
Definition: ffmpeg_sched.c:2174
SchedulerNode::type
enum SchedulerNodeType type
Definition: ffmpeg_sched.h:104
sch_free
void sch_free(Scheduler **sch)
Definition: ffmpeg_sched.c:461
SchThreadFunc
int(* SchThreadFunc)(void *arg)
Definition: ffmpeg_sched.h:109
SCH_NODE_TYPE_NONE
@ SCH_NODE_TYPE_NONE
Definition: ffmpeg_sched.h:94
sch_mux_receive
int sch_mux_receive(Scheduler *sch, unsigned mux_idx, struct AVPacket *pkt)
Called by muxer tasks to obtain packets for muxing.
Definition: ffmpeg_sched.c:2014
sch_enc_send
int sch_enc_send(Scheduler *sch, unsigned enc_idx, struct AVPacket *pkt)
Called by encoder tasks to send encoded packets downstream.
Definition: ffmpeg_sched.c:2279
pkt
AVPacket * pkt
Definition: movenc.c:60
sch_mux_stream_ready
int sch_mux_stream_ready(Scheduler *sch, unsigned mux_idx, unsigned stream_idx)
Signal to the scheduler that the specified muxed stream is initialized and ready.
Definition: ffmpeg_sched.c:1157
sch_sdp_filename
int sch_sdp_filename(Scheduler *sch, const char *sdp_filename)
Set the file path for the SDP.
Definition: ffmpeg_sched.c:607
SchedulerNodeType
SchedulerNodeType
Definition: ffmpeg_sched.h:93
sch_demux_send
int sch_demux_send(Scheduler *sch, unsigned demux_idx, struct AVPacket *pkt, unsigned flags)
Called by demuxer tasks to communicate with their downstreams.
Definition: ffmpeg_sched.c:1970
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ffmpeg_utils.h
sch_enc_receive
int sch_enc_receive(Scheduler *sch, unsigned enc_idx, struct AVFrame *frame)
Called by encoder tasks to obtain frames for encoding.
Definition: ffmpeg_sched.c:2235
sch_start
int sch_start(Scheduler *sch)
Definition: ffmpeg_sched.c:1530
arg
const char * arg
Definition: jacosubdec.c:67
sch_mux_sub_heartbeat
int sch_mux_sub_heartbeat(Scheduler *sch, unsigned mux_idx, unsigned stream_idx, const AVPacket *pkt)
Definition: ffmpeg_sched.c:2045
DemuxSendFlags
DemuxSendFlags
Definition: ffmpeg_sched.h:323
sch_connect
int sch_connect(Scheduler *sch, SchedulerNode src, SchedulerNode dst)
Definition: ffmpeg_sched.c:897
SCH_NODE_TYPE_DEMUX
@ SCH_NODE_TYPE_DEMUX
Definition: ffmpeg_sched.h:95
sch_filter_command
int sch_filter_command(Scheduler *sch, unsigned fg_idx, struct AVFrame *frame)
Definition: ffmpeg_sched.c:2438
sch_alloc
Scheduler * sch_alloc(void)
Definition: ffmpeg_sched.c:573
DEMUX_SEND_STREAMCOPY_EOF
@ DEMUX_SEND_STREAMCOPY_EOF
Treat the packet as an EOF for SCH_NODE_TYPE_MUX destinations send normally to other types.
Definition: ffmpeg_sched.h:328
sch_add_demux_stream
int sch_add_demux_stream(Scheduler *sch, unsigned demux_idx)
Add a demuxed stream for a previously added demuxer.
Definition: ffmpeg_sched.c:703
Scheduler
Definition: ffmpeg_sched.c:269
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
sch_filter_receive_finish
void sch_filter_receive_finish(Scheduler *sch, unsigned fg_idx, unsigned in_idx)
Called by filter tasks to signal that a filter input will no longer accept input.
Definition: ffmpeg_sched.c:2372
sch_add_enc
int sch_add_enc(Scheduler *sch, SchThreadFunc func, void *ctx, int(*open_cb)(void *func_arg, const struct AVFrame *frame))
Add an encoder to the scheduler.
SCH_NODE_TYPE_FILTER_OUT
@ SCH_NODE_TYPE_FILTER_OUT
Definition: ffmpeg_sched.h:100
sch_add_dec
int sch_add_dec(Scheduler *sch, SchThreadFunc func, void *ctx, int send_end_ts)
Add a decoder to the scheduler.
Definition: ffmpeg_sched.c:721
sch_filter_send
int sch_filter_send(Scheduler *sch, unsigned fg_idx, unsigned out_idx, struct AVFrame *frame)
Called by filtergraph tasks to send a filtered frame or EOF to consumers.
Definition: ffmpeg_sched.c:2393
sch_add_sq_enc
int sch_add_sq_enc(Scheduler *sch, uint64_t buf_size_us, void *logctx)
Add an pre-encoding sync queue to the scheduler.
Definition: ffmpeg_sched.c:841
SCH_NODE_TYPE_FILTER_IN
@ SCH_NODE_TYPE_FILTER_IN
Definition: ffmpeg_sched.h:99
SchedulerNode
Definition: ffmpeg_sched.h:103
SCH_NODE_TYPE_DEC
@ SCH_NODE_TYPE_DEC
Definition: ffmpeg_sched.h:97
sch_wait
int sch_wait(Scheduler *sch, uint64_t timeout_us, int64_t *transcode_ts)
Wait until transcoding terminates or the specified timeout elapses.
Definition: ffmpeg_sched.c:1596
sch_add_mux_stream
int sch_add_mux_stream(Scheduler *sch, unsigned mux_idx)
Add a muxed stream for a previously added muxer.
Definition: ffmpeg_sched.c:644
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
sch_add_filtergraph
int sch_add_filtergraph(Scheduler *sch, unsigned nb_inputs, unsigned nb_outputs, SchThreadFunc func, void *ctx)
Add a filtergraph to the scheduler.
Definition: ffmpeg_sched.c:799
sch_filter_receive
int sch_filter_receive(Scheduler *sch, unsigned fg_idx, unsigned *in_idx, struct AVFrame *frame)
Called by filtergraph tasks to obtain frames for filtering.
Definition: ffmpeg_sched.c:2328
sch_sq_add_enc
int sch_sq_add_enc(Scheduler *sch, unsigned sq_idx, unsigned enc_idx, int limiting, uint64_t max_frames)
Definition: ffmpeg_sched.c:866
sch_mux_sub_heartbeat_add
int sch_mux_sub_heartbeat_add(Scheduler *sch, unsigned mux_idx, unsigned stream_idx, unsigned dec_idx)
Definition: ffmpeg_sched.c:1182
SchedulerNode::idx
unsigned idx
Definition: ffmpeg_sched.h:105
AVPacket
This structure stores compressed data.
Definition: packet.h:501
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
sch_dec_receive
int sch_dec_receive(Scheduler *sch, unsigned dec_idx, struct AVPacket *pkt)
Called by decoder tasks to receive a packet for decoding.
Definition: ffmpeg_sched.c:2098
sch_mux_receive_finish
void sch_mux_receive_finish(Scheduler *sch, unsigned mux_idx, unsigned stream_idx)
Called by muxer tasks to signal that a stream will no longer accept input.
Definition: ffmpeg_sched.c:2027
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
sch_add_mux
int sch_add_mux(Scheduler *sch, SchThreadFunc func, int(*init)(void *), void *ctx, int sdp_auto, unsigned thread_queue_size)
Add a muxer to the scheduler.
Definition: ffmpeg_sched.c:620
int
int
Definition: ffmpeg_filter.c:424
sch_mux_stream_buffering
void sch_mux_stream_buffering(Scheduler *sch, unsigned mux_idx, unsigned stream_idx, size_t data_threshold, int max_packets)
Configure limits on packet buffering performed before the muxer task is started.
Definition: ffmpeg_sched.c:1141