FFmpeg coverage

../../../ffmpeg/
Coverage:
low: ≥ 0%
medium: ≥ 75.0%
high: ≥ 90.0%
Lines:
294 / 308
95.5%
Branches:
224 / 264
84.8%
Functions:
20 / 20
100.0%
fftools/sync_queue.c
Line Branch Exec Source
1 /*
2 * This file is part of FFmpeg.
3 *
4 * FFmpeg is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * FFmpeg is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with FFmpeg; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19 #include <stdint.h>
20 #include <string.h>
21
22 #include "libavutil/avassert.h"
23 #include "libavutil/container_fifo.h"
24 #include "libavutil/channel_layout.h"
25 #include "libavutil/cpu.h"
26 #include "libavutil/error.h"
27 #include "libavutil/mathematics.h"
28 #include "libavutil/mem.h"
29 #include "libavutil/samplefmt.h"
30 #include "libavutil/timestamp.h"
31
32 #include "sync_queue.h"
33
34 /*
35 * How this works:
36 * --------------
37 * time: 0 1 2 3 4 5 6 7 8 9 10 11 12 13
38 * -------------------------------------------------------------------
39 * | | | | | | | | | | | | | |
40 * | ┌───┐┌────────┐┌───┐┌─────────────┐
41 * stream 0| │d=1││ d=2 ││d=1││ d=3 │
42 * | └───┘└────────┘└───┘└─────────────┘
43 * ┌───┐ ┌───────────────────────┐
44 * stream 1│d=1│ │ d=5 │
45 * └───┘ └───────────────────────┘
46 * | ┌───┐┌───┐┌───┐┌───┐
47 * stream 2| │d=1││d=1││d=1││d=1│ <- stream 2 is the head stream of the queue
48 * | └───┘└───┘└───┘└───┘
49 * ^ ^
50 * [stream 2 tail] [stream 2 head]
51 *
52 * We have N streams (N=3 in the diagram), each stream is a FIFO. The *tail* of
53 * each FIFO is the frame with smallest end time, the *head* is the frame with
54 * the largest end time. Frames submitted to the queue with sq_send() are placed
55 * after the head, frames returned to the caller with sq_receive() are taken
56 * from the tail.
57 *
58 * The head stream of the whole queue (SyncQueue.head_stream) is the limiting
59 * stream with the *smallest* head timestamp, i.e. the stream whose source lags
60 * furthest behind all other streams. It determines which frames can be output
61 * from the queue.
62 *
63 * In the diagram, the head stream is 2, because it head time is t=5, while
64 * streams 0 and 1 end at t=8 and t=9 respectively. All frames that _end_ at
65 * or before t=5 can be output, i.e. the first 3 frames from stream 0, first
66 * frame from stream 1, and all 4 frames from stream 2.
67 */
68
69 #define SQPTR(sq, frame) ((sq->type == SYNC_QUEUE_FRAMES) ? \
70 (void*)frame.f : (void*)frame.p)
71
72 typedef struct SyncQueueStream {
73 AVContainerFifo *fifo;
74 AVRational tb;
75
76 /* number of audio samples in fifo */
77 uint64_t samples_queued;
78 /* stream head: largest timestamp seen */
79 int64_t head_ts;
80 int limiting;
81 /* no more frames will be sent for this stream */
82 int finished;
83
84 uint64_t frames_sent;
85 uint64_t samples_sent;
86 uint64_t frames_max;
87 int frame_samples;
88 } SyncQueueStream;
89
90 struct SyncQueue {
91 enum SyncQueueType type;
92
93 void *logctx;
94
95 /* no more frames will be sent for any stream */
96 int finished;
97 /* sync head: the stream with the _smallest_ head timestamp
98 * this stream determines which frames can be output */
99 int head_stream;
100 /* the finished stream with the smallest finish timestamp or -1 */
101 int head_finished_stream;
102
103 // maximum buffering duration in microseconds
104 int64_t buf_size_us;
105
106 SyncQueueStream *streams;
107 unsigned int nb_streams;
108
109 int have_limiting;
110
111 uintptr_t align_mask;
112 };
113
114 /**
115 * Compute the end timestamp of a frame. If nb_samples is provided, consider
116 * the frame to have this number of audio samples, otherwise use frame duration.
117 */
118 328678 static int64_t frame_end(const SyncQueue *sq, SyncQueueFrame frame, int nb_samples)
119 {
120
2/2
✓ Branch 2 → 3 taken 112470 times.
✓ Branch 2 → 4 taken 216208 times.
 328678 if (nb_samples) {
121 112470 int64_t d = av_rescale_q(nb_samples, (AVRational){ 1, frame.f->sample_rate},
122 112470 frame.f->time_base);
123 112470 return frame.f->pts + d;
124 }
125
126 216208 return (sq->type == SYNC_QUEUE_PACKETS) ?
127
2/2
✓ Branch 4 → 5 taken 4536 times.
✓ Branch 4 → 6 taken 211672 times.
 216208 frame.p->pts + frame.p->duration :
128 211672 frame.f->pts + frame.f->duration;
129 }
130
131 90327 static int frame_samples(const SyncQueue *sq, SyncQueueFrame frame)
132 {
133
2/2
✓ Branch 2 → 3 taken 87570 times.
✓ Branch 2 → 4 taken 2757 times.
 90327 return (sq->type == SYNC_QUEUE_PACKETS) ? 0 : frame.f->nb_samples;
134 }
135
136 56227 static int frame_null(const SyncQueue *sq, SyncQueueFrame frame)
137 {
138
2/2
✓ Branch 2 → 3 taken 1028 times.
✓ Branch 2 → 4 taken 55199 times.
 56227 return (sq->type == SYNC_QUEUE_PACKETS) ? (frame.p == NULL) : (frame.f == NULL);
139 }
140
141 48901 static void tb_update(const SyncQueue *sq, SyncQueueStream *st,
142 const SyncQueueFrame frame)
143 {
144 97802 AVRational tb = (sq->type == SYNC_QUEUE_PACKETS) ?
145
2/2
✓ Branch 2 → 3 taken 951 times.
✓ Branch 2 → 4 taken 47950 times.
 48901 frame.p->time_base : frame.f->time_base;
146
147
2/4
✓ Branch 5 → 6 taken 48901 times.
✗ Branch 5 → 7 not taken.
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 9 taken 48901 times.
 48901 av_assert0(tb.num > 0 && tb.den > 0);
148
149
4/4
✓ Branch 9 → 10 taken 48785 times.
✓ Branch 9 → 12 taken 116 times.
✓ Branch 10 → 11 taken 45377 times.
✓ Branch 10 → 12 taken 3408 times.
 48901 if (tb.num == st->tb.num && tb.den == st->tb.den)
150 45377 return;
151
152 // timebase should not change after the first frame
153
1/2
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 16 taken 3524 times.
 3524 av_assert0(!av_container_fifo_can_read(st->fifo));
154
155
2/2
✓ Branch 16 → 17 taken 1 time.
✓ Branch 16 → 18 taken 3523 times.
 3524 if (st->head_ts != AV_NOPTS_VALUE)
156 1 st->head_ts = av_rescale_q(st->head_ts, st->tb, tb);
157
158 3524 st->tb = tb;
159 }
160
161 10487 static void finish_stream(SyncQueue *sq, unsigned int stream_idx)
162 {
163 10487 SyncQueueStream *st = &sq->streams[stream_idx];
164
165
2/2
✓ Branch 2 → 3 taken 3606 times.
✓ Branch 2 → 6 taken 6881 times.
 10487 if (!st->finished)
166 3606 av_log(sq->logctx, AV_LOG_DEBUG,
167 "sq: finish %u; head ts %s\n", stream_idx,
168 3606 av_ts2timestr(st->head_ts, &st->tb));
169
170 10487 st->finished = 1;
171
172
4/4
✓ Branch 6 → 7 taken 9529 times.
✓ Branch 6 → 24 taken 958 times.
✓ Branch 7 → 8 taken 9464 times.
✓ Branch 7 → 24 taken 65 times.
 10487 if (st->limiting && st->head_ts != AV_NOPTS_VALUE) {
173 /* check if this stream is the new finished head */
174
4/4
✓ Branch 8 → 9 taken 6297 times.
✓ Branch 8 → 11 taken 3167 times.
✓ Branch 10 → 11 taken 1 time.
✓ Branch 10 → 12 taken 6296 times.
 15761 if (sq->head_finished_stream < 0 ||
175 6297 av_compare_ts(st->head_ts, st->tb,
176 6297 sq->streams[sq->head_finished_stream].head_ts,
177 6297 sq->streams[sq->head_finished_stream].tb) < 0) {
178 3168 sq->head_finished_stream = stream_idx;
179 }
180
181 /* mark as finished all streams that should no longer receive new frames,
182 * due to them being ahead of some finished stream */
183 9464 st = &sq->streams[sq->head_finished_stream];
184
2/2
✓ Branch 23 → 13 taken 9490 times.
✓ Branch 23 → 24 taken 9464 times.
 18954 for (unsigned int i = 0; i < sq->nb_streams; i++) {
185 9490 SyncQueueStream *st1 = &sq->streams[i];
186
6/6
✓ Branch 13 → 14 taken 26 times.
✓ Branch 13 → 22 taken 9464 times.
✓ Branch 14 → 15 taken 24 times.
✓ Branch 14 → 22 taken 2 times.
✓ Branch 16 → 17 taken 18 times.
✓ Branch 16 → 22 taken 6 times.
 9514 if (st != st1 && st1->head_ts != AV_NOPTS_VALUE &&
187 24 av_compare_ts(st->head_ts, st->tb, st1->head_ts, st1->tb) <= 0) {
188
2/2
✓ Branch 17 → 18 taken 3 times.
✓ Branch 17 → 21 taken 15 times.
 18 if (!st1->finished)
189 3 av_log(sq->logctx, AV_LOG_DEBUG,
190 "sq: finish secondary %u; head ts %s\n", i,
191 3 av_ts2timestr(st1->head_ts, &st1->tb));
192
193 18 st1->finished = 1;
194 }
195 }
196 }
197
198 /* mark the whole queue as finished if all streams are finished */
199
2/2
✓ Branch 28 → 25 taken 26471 times.
✓ Branch 28 → 29 taken 10294 times.
 36765 for (unsigned int i = 0; i < sq->nb_streams; i++) {
200
2/2
✓ Branch 25 → 26 taken 193 times.
✓ Branch 25 → 27 taken 26278 times.
 26471 if (!sq->streams[i].finished)
201 193 return;
202 }
203 10294 sq->finished = 1;
204
205 10294 av_log(sq->logctx, AV_LOG_DEBUG, "sq: finish queue\n");
206 }
207
208 13023 static void queue_head_update(SyncQueue *sq)
209 {
210
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 5 taken 13023 times.
 13023 av_assert0(sq->have_limiting);
211
212
2/2
✓ Branch 5 → 6 taken 3244 times.
✓ Branch 5 → 19 taken 9779 times.
 13023 if (sq->head_stream < 0) {
213 3244 unsigned first_limiting = UINT_MAX;
214
215 /* wait for one timestamp in each stream before determining
216 * the queue head */
217
2/2
✓ Branch 14 → 7 taken 3327 times.
✓ Branch 14 → 15 taken 3168 times.
 6495 for (unsigned int i = 0; i < sq->nb_streams; i++) {
218 3327 SyncQueueStream *st = &sq->streams[i];
219
2/2
✓ Branch 7 → 8 taken 4 times.
✓ Branch 7 → 9 taken 3323 times.
 3327 if (!st->limiting)
220 4 continue;
221
2/2
✓ Branch 9 → 10 taken 76 times.
✓ Branch 9 → 11 taken 3247 times.
 3323 if (st->head_ts == AV_NOPTS_VALUE)
222 76 return;
223
2/2
✓ Branch 11 → 12 taken 3242 times.
✓ Branch 11 → 13 taken 5 times.
 3247 if (first_limiting == UINT_MAX)
224 3242 first_limiting = i;
225 }
226
227 // placeholder value, correct one will be found below
228
1/2
✗ Branch 15 → 16 not taken.
✓ Branch 15 → 18 taken 3168 times.
 3168 av_assert0(first_limiting < UINT_MAX);
229 3168 sq->head_stream = first_limiting;
230 }
231
232
2/2
✓ Branch 26 → 20 taken 13324 times.
✓ Branch 26 → 27 taken 12947 times.
 26271 for (unsigned int i = 0; i < sq->nb_streams; i++) {
233 13324 SyncQueueStream *st_head = &sq->streams[sq->head_stream];
234 13324 SyncQueueStream *st_other = &sq->streams[i];
235
5/6
✓ Branch 20 → 21 taken 13292 times.
✓ Branch 20 → 25 taken 32 times.
✓ Branch 21 → 22 taken 13292 times.
✗ Branch 21 → 25 not taken.
✓ Branch 23 → 24 taken 9 times.
✓ Branch 23 → 25 taken 13283 times.
 26616 if (st_other->limiting && st_other->head_ts != AV_NOPTS_VALUE &&
236 13292 av_compare_ts(st_other->head_ts, st_other->tb,
237 st_head->head_ts, st_head->tb) < 0)
238 9 sq->head_stream = i;
239 }
240 }
241
242 /* update this stream's head timestamp */
243 48995 static void stream_update_ts(SyncQueue *sq, unsigned int stream_idx, int64_t ts)
244 {
245 48995 SyncQueueStream *st = &sq->streams[stream_idx];
246
247
2/2
✓ Branch 2 → 3 taken 48992 times.
✓ Branch 2 → 5 taken 3 times.
 48995 if (ts == AV_NOPTS_VALUE ||
248
4/4
✓ Branch 3 → 4 taken 45449 times.
✓ Branch 3 → 6 taken 3543 times.
✓ Branch 4 → 5 taken 130 times.
✓ Branch 4 → 6 taken 45319 times.
 48992 (st->head_ts != AV_NOPTS_VALUE && st->head_ts >= ts))
249 133 return;
250
251 48862 st->head_ts = ts;
252
253 /* if this stream is now ahead of some finished stream, then
254 * this stream is also finished */
255
4/4
✓ Branch 6 → 7 taken 116 times.
✓ Branch 6 → 10 taken 48746 times.
✓ Branch 8 → 9 taken 5 times.
✓ Branch 8 → 10 taken 111 times.
 48978 if (sq->head_finished_stream >= 0 &&
256 116 av_compare_ts(sq->streams[sq->head_finished_stream].head_ts,
257 116 sq->streams[sq->head_finished_stream].tb,
258 ts, st->tb) <= 0)
259 5 finish_stream(sq, stream_idx);
260
261 /* update the overall head timestamp if it could have changed */
262
2/2
✓ Branch 10 → 11 taken 13498 times.
✓ Branch 10 → 14 taken 35364 times.
 48862 if (st->limiting &&
263
4/4
✓ Branch 11 → 12 taken 10254 times.
✓ Branch 11 → 13 taken 3244 times.
✓ Branch 12 → 13 taken 9779 times.
✓ Branch 12 → 14 taken 475 times.
 13498 (sq->head_stream < 0 || sq->head_stream == stream_idx))
264 13023 queue_head_update(sq);
265 }
266
267 /* If the queue for the given stream (or all streams when stream_idx=-1)
268 * is overflowing, trigger a fake heartbeat on lagging streams.
269 *
270 * @return 1 if heartbeat triggered, 0 otherwise
271 */
272 46025 static int overflow_heartbeat(SyncQueue *sq, int stream_idx)
273 {
274 SyncQueueStream *st;
275 SyncQueueFrame frame;
276 46025 int64_t tail_ts = AV_NOPTS_VALUE;
277
278 /* if no stream specified, pick the one that is most ahead */
279
1/2
✓ Branch 2 → 3 taken 46025 times.
✗ Branch 2 → 13 not taken.
 46025 if (stream_idx < 0) {
280 46025 int64_t ts = AV_NOPTS_VALUE;
281
282
2/2
✓ Branch 10 → 4 taken 378765 times.
✓ Branch 10 → 11 taken 46025 times.
 424790 for (int i = 0; i < sq->nb_streams; i++) {
283 378765 st = &sq->streams[i];
284
4/4
✓ Branch 4 → 5 taken 373392 times.
✓ Branch 4 → 9 taken 5373 times.
✓ Branch 5 → 6 taken 327370 times.
✓ Branch 5 → 8 taken 46022 times.
 378765 if (st->head_ts != AV_NOPTS_VALUE &&
285
2/2
✓ Branch 7 → 8 taken 472 times.
✓ Branch 7 → 9 taken 326898 times.
 327370 (ts == AV_NOPTS_VALUE ||
286 327370 av_compare_ts(ts, sq->streams[stream_idx].tb,
287 st->head_ts, st->tb) < 0)) {
288 46494 ts = st->head_ts;
289 46494 stream_idx = i;
290 }
291 }
292 /* no stream has a timestamp yet -> nothing to do */
293
2/2
✓ Branch 11 → 12 taken 3 times.
✓ Branch 11 → 13 taken 46022 times.
 46025 if (stream_idx < 0)
294 3 return 0;
295 }
296
297 46022 st = &sq->streams[stream_idx];
298
299 /* get the chosen stream's tail timestamp */
300
4/4
✓ Branch 16 → 17 taken 46022 times.
✓ Branch 16 → 19 taken 26560 times.
✓ Branch 18 → 14 taken 26560 times.
✓ Branch 18 → 19 taken 19462 times.
 118604 for (size_t i = 0; tail_ts == AV_NOPTS_VALUE &&
301 72582 av_container_fifo_peek(st->fifo, (void**)&frame, i) >= 0; i++)
302 26560 tail_ts = frame_end(sq, frame, 0);
303
304 /* overflow triggers when the tail is over specified duration behind the head */
305
4/4
✓ Branch 19 → 20 taken 26560 times.
✓ Branch 19 → 22 taken 19462 times.
✓ Branch 20 → 21 taken 1617 times.
✓ Branch 20 → 22 taken 24943 times.
 46022 if (tail_ts == AV_NOPTS_VALUE || tail_ts >= st->head_ts ||
306
2/2
✓ Branch 21 → 22 taken 1523 times.
✓ Branch 21 → 23 taken 94 times.
 1617 av_rescale_q(st->head_ts - tail_ts, st->tb, AV_TIME_BASE_Q) < sq->buf_size_us)
307 45928 return 0;
308
309 /* signal a fake timestamp for all streams that prevent tail_ts from being output */
310 94 tail_ts++;
311
2/2
✓ Branch 41 → 24 taken 188 times.
✓ Branch 41 → 42 taken 94 times.
 282 for (unsigned int i = 0; i < sq->nb_streams; i++) {
312 188 const SyncQueueStream *st1 = &sq->streams[i];
313 int64_t ts;
314
315
3/4
✓ Branch 24 → 25 taken 94 times.
✓ Branch 24 → 29 taken 94 times.
✓ Branch 25 → 26 taken 94 times.
✗ Branch 25 → 29 not taken.
 188 if (st == st1 || st1->finished ||
316
3/4
✓ Branch 26 → 27 taken 93 times.
✓ Branch 26 → 30 taken 1 time.
✗ Branch 28 → 29 not taken.
✓ Branch 28 → 30 taken 93 times.
 187 (st1->head_ts != AV_NOPTS_VALUE &&
317 93 av_compare_ts(tail_ts, st->tb, st1->head_ts, st1->tb) <= 0))
318 94 continue;
319
320 94 ts = av_rescale_q(tail_ts, st->tb, st1->tb);
321
2/2
✓ Branch 30 → 31 taken 93 times.
✓ Branch 30 → 34 taken 1 time.
 94 if (st1->head_ts != AV_NOPTS_VALUE)
322
1/2
✗ Branch 31 → 32 not taken.
✓ Branch 31 → 33 taken 93 times.
 93 ts = FFMAX(st1->head_ts + 1, ts);
323
324 94 av_log(sq->logctx, AV_LOG_DEBUG, "sq: %u overflow heardbeat %s -> %s\n",
325 94 i, av_ts2timestr(st1->head_ts, &st1->tb), av_ts2timestr(ts, &st1->tb));
326
327 94 stream_update_ts(sq, i, ts);
328 }
329
330 94 return 1;
331 }
332
333 56227 int sq_send(SyncQueue *sq, unsigned int stream_idx, SyncQueueFrame frame)
334 {
335 SyncQueueStream *st;
336 int64_t ts;
337 int ret, nb_samples;
338
339
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 5 taken 56227 times.
 56227 av_assert0(stream_idx < sq->nb_streams);
340 56227 st = &sq->streams[stream_idx];
341
342
2/2
✓ Branch 6 → 7 taken 7261 times.
✓ Branch 6 → 10 taken 48966 times.
 56227 if (frame_null(sq, frame)) {
343 7261 av_log(sq->logctx, AV_LOG_DEBUG, "sq: %u EOF\n", stream_idx);
344 7261 finish_stream(sq, stream_idx);
345 7261 return 0;
346 }
347
2/2
✓ Branch 10 → 11 taken 65 times.
✓ Branch 10 → 12 taken 48901 times.
 48966 if (st->finished)
348 65 return AVERROR_EOF;
349
350 48901 tb_update(sq, st, frame);
351
352 48901 nb_samples = frame_samples(sq, frame);
353 // make sure frame duration is consistent with sample count
354
2/2
✓ Branch 14 → 15 taken 39393 times.
✓ Branch 14 → 19 taken 9508 times.
 48901 if (nb_samples) {
355
1/2
✗ Branch 15 → 16 not taken.
✓ Branch 15 → 18 taken 39393 times.
 39393 av_assert0(frame.f->sample_rate > 0);
356 39393 frame.f->duration = av_rescale_q(nb_samples, (AVRational){ 1, frame.f->sample_rate },
357 39393 frame.f->time_base);
358 }
359
360 48901 ts = frame_end(sq, frame, 0);
361
362 48901 av_log(sq->logctx, AV_LOG_DEBUG, "sq: send %u ts %s\n", stream_idx,
363 48901 av_ts2timestr(ts, &st->tb));
364
365
2/2
✓ Branch 22 → 23 taken 47950 times.
✓ Branch 22 → 24 taken 951 times.
 48901 ret = av_container_fifo_write(st->fifo, SQPTR(sq, frame), 0);
366
1/2
✗ Branch 26 → 27 not taken.
✓ Branch 26 → 28 taken 48901 times.
 48901 if (ret < 0)
367 ✗ return ret;
368
369 48901 stream_update_ts(sq, stream_idx, ts);
370
371 48901 st->samples_queued += nb_samples;
372 48901 st->samples_sent += nb_samples;
373
374
2/2
✓ Branch 29 → 30 taken 35294 times.
✓ Branch 29 → 31 taken 13607 times.
 48901 if (st->frame_samples)
375 35294 st->frames_sent = st->samples_sent / st->frame_samples;
376 else
377 13607 st->frames_sent++;
378
379
2/2
✓ Branch 32 → 33 taken 3158 times.
✓ Branch 32 → 35 taken 45743 times.
 48901 if (st->frames_sent >= st->frames_max) {
380 3158 av_log(sq->logctx, AV_LOG_DEBUG, "sq: %u frames_max %"PRIu64" reached\n",
381 stream_idx, st->frames_max);
382
383 3158 finish_stream(sq, stream_idx);
384 }
385
386 48901 return 0;
387 }
388
389 102590 static void offset_audio(AVFrame *f, int nb_samples)
390 {
391 102590 const int planar = av_sample_fmt_is_planar(f->format);
392
2/2
✓ Branch 3 → 4 taken 23672 times.
✓ Branch 3 → 5 taken 78918 times.
 102590 const int planes = planar ? f->ch_layout.nb_channels : 1;
393 102590 const int bps = av_get_bytes_per_sample(f->format);
394
2/2
✓ Branch 7 → 8 taken 78918 times.
✓ Branch 7 → 9 taken 23672 times.
 102590 const int offset = nb_samples * bps * (planar ? 1 : f->ch_layout.nb_channels);
395
396
1/2
✗ Branch 10 → 11 not taken.
✓ Branch 10 → 13 taken 102590 times.
 102590 av_assert0(bps > 0);
397
1/2
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 16 taken 102590 times.
 102590 av_assert0(nb_samples < f->nb_samples);
398
399
2/2
✓ Branch 20 → 17 taken 126118 times.
✓ Branch 20 → 21 taken 102590 times.
 228708 for (int i = 0; i < planes; i++) {
400 126118 f->extended_data[i] += offset;
401
2/2
✓ Branch 17 → 18 taken 125902 times.
✓ Branch 17 → 19 taken 216 times.
 126118 if (i < FF_ARRAY_ELEMS(f->data))
402 125902 f->data[i] = f->extended_data[i];
403 }
404 102590 f->linesize[0] -= offset;
405 102590 f->nb_samples -= nb_samples;
406 102590 f->duration = av_rescale_q(f->nb_samples, (AVRational){ 1, f->sample_rate },
407 f->time_base);
408 102590 f->pts += av_rescale_q(nb_samples, (AVRational){ 1, f->sample_rate },
409 f->time_base);
410 102590 }
411
412 87643 static int frame_is_aligned(const SyncQueue *sq, const AVFrame *frame)
413 {
414 // only checks linesize[0], so only works for audio
415
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 5 taken 87643 times.
 87643 av_assert0(frame->nb_samples > 0);
416
1/2
✗ Branch 5 → 6 not taken.
✓ Branch 5 → 8 taken 87643 times.
 87643 av_assert0(sq->align_mask);
417
418 // only check data[0], because we always offset all data pointers
419 // by the same offset, so if one is aligned, all are
420
2/2
✓ Branch 8 → 9 taken 86781 times.
✓ Branch 8 → 12 taken 862 times.
 87643 if (!((uintptr_t)frame->data[0] & sq->align_mask) &&
421
1/2
✓ Branch 9 → 10 taken 86781 times.
✗ Branch 9 → 12 not taken.
 86781 !(frame->linesize[0] & sq->align_mask) &&
422
1/2
✓ Branch 10 → 11 taken 86781 times.
✗ Branch 10 → 12 not taken.
 86781 frame->linesize[0] > sq->align_mask)
423 86781 return 1;
424
425 862 return 0;
426 }
427
428 105303 static int receive_samples(SyncQueue *sq, SyncQueueStream *st,
429 AVFrame *dst, int nb_samples)
430 {
431 SyncQueueFrame src;
432 int ret;
433
434
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 5 taken 105303 times.
 105303 av_assert0(st->samples_queued >= nb_samples);
435
436 105303 ret = av_container_fifo_peek(st->fifo, (void**)&src, 0);
437
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 9 taken 105303 times.
 105303 av_assert0(ret >= 0);
438
439 // peeked frame has enough samples and its data is aligned
440 // -> we can just make a reference and limit its sample count
441
4/4
✓ Branch 9 → 10 taken 80486 times.
✓ Branch 9 → 17 taken 24817 times.
✓ Branch 11 → 12 taken 79627 times.
✓ Branch 11 → 17 taken 859 times.
 105303 if (src.f->nb_samples > nb_samples && frame_is_aligned(sq, src.f)) {
442 79627 ret = av_frame_ref(dst, src.f);
443
1/2
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 15 taken 79627 times.
 79627 if (ret < 0)
444 ✗ return ret;
445
446 79627 dst->nb_samples = nb_samples;
447 79627 offset_audio(src.f, nb_samples);
448 79627 st->samples_queued -= nb_samples;
449
450 79627 goto finish;
451 }
452
453 // otherwise allocate a new frame and copy the data
454 25676 ret = av_channel_layout_copy(&dst->ch_layout, &src.f->ch_layout);
455
1/2
✗ Branch 18 → 19 not taken.
✓ Branch 18 → 20 taken 25676 times.
 25676 if (ret < 0)
456 ✗ return ret;
457
458 25676 dst->format = src.f->format;
459 25676 dst->nb_samples = nb_samples;
460
461 25676 ret = av_frame_get_buffer(dst, 0);
462
1/2
✗ Branch 21 → 22 not taken.
✓ Branch 21 → 23 taken 25676 times.
 25676 if (ret < 0)
463 ✗ goto fail;
464
465 25676 ret = av_frame_copy_props(dst, src.f);
466
1/2
✗ Branch 24 → 25 not taken.
✓ Branch 24 → 26 taken 25676 times.
 25676 if (ret < 0)
467 ✗ goto fail;
468
469 25676 dst->nb_samples = 0;
470
2/2
✓ Branch 36 → 27 taken 51101 times.
✓ Branch 36 → 37 taken 25676 times.
 76777 while (dst->nb_samples < nb_samples) {
471 int to_copy;
472
473 51101 ret = av_container_fifo_peek(st->fifo, (void**)&src, 0);
474
1/2
✗ Branch 28 → 29 not taken.
✓ Branch 28 → 31 taken 51101 times.
 51101 av_assert0(ret >= 0);
475
476 51101 to_copy = FFMIN(nb_samples - dst->nb_samples, src.f->nb_samples);
477
478 51101 av_samples_copy(dst->extended_data, src.f->extended_data, dst->nb_samples,
479 51101 0, to_copy, dst->ch_layout.nb_channels, dst->format);
480
481
2/2
✓ Branch 32 → 33 taken 22963 times.
✓ Branch 32 → 34 taken 28138 times.
 51101 if (to_copy < src.f->nb_samples)
482 22963 offset_audio(src.f, to_copy);
483 else
484 28138 av_container_fifo_drain(st->fifo, 1);
485
486 51101 st->samples_queued -= to_copy;
487
488 51101 dst->nb_samples += to_copy;
489 }
490
491 25676 finish:
492 105303 dst->duration = av_rescale_q(nb_samples, (AVRational){ 1, dst->sample_rate },
493 dst->time_base);
494
495 105303 return 0;
496
497 ✗ fail:
498 ✗ av_frame_unref(dst);
499 ✗ return ret;
500 }
501
502 667121 static int receive_for_stream(SyncQueue *sq, unsigned int stream_idx,
503 SyncQueueFrame frame)
504 {
505 632342 const SyncQueueStream *st_head = sq->head_stream >= 0 ?
506
2/2
✓ Branch 2 → 3 taken 34779 times.
✓ Branch 2 → 4 taken 632342 times.
 667121 &sq->streams[sq->head_stream] : NULL;
507 SyncQueueStream *st;
508
509
1/2
✗ Branch 5 → 6 not taken.
✓ Branch 5 → 8 taken 667121 times.
 667121 av_assert0(stream_idx < sq->nb_streams);
510 667121 st = &sq->streams[stream_idx];
511
512
2/2
✓ Branch 9 → 10 taken 559512 times.
✓ Branch 9 → 52 taken 107609 times.
 667121 if (av_container_fifo_can_read(st->fifo) &&
513
4/4
✓ Branch 10 → 11 taken 432631 times.
✓ Branch 10 → 12 taken 126881 times.
✓ Branch 11 → 12 taken 320 times.
✓ Branch 11 → 52 taken 432311 times.
 559512 (st->frame_samples <= st->samples_queued || st->finished)) {
514 127201 int nb_samples = st->frame_samples;
515 SyncQueueFrame peek;
516 int64_t ts;
517 127201 int cmp = 1;
518
519
2/2
✓ Branch 12 → 13 taken 3806 times.
✓ Branch 12 → 14 taken 123395 times.
 127201 if (st->finished)
520 3806 nb_samples = FFMIN(nb_samples, st->samples_queued);
521
522 127201 av_container_fifo_peek(st->fifo, (void**)&peek, 0);
523 127201 ts = frame_end(sq, peek, nb_samples);
524
525 /* check if this stream's tail timestamp does not overtake
526 * the overall queue head */
527
4/4
✓ Branch 16 → 17 taken 127198 times.
✓ Branch 16 → 19 taken 3 times.
✓ Branch 17 → 18 taken 14721 times.
✓ Branch 17 → 19 taken 112477 times.
 127201 if (ts != AV_NOPTS_VALUE && st_head)
528 14721 cmp = av_compare_ts(ts, st->tb, st_head->head_ts, st_head->tb);
529
530 /* We can release frames that do not end after the queue head.
531 * Frames with no timestamps are just passed through with no conditions.
532 * Frames are also passed through when there are no limiting streams.
533 */
534
6/6
✓ Branch 19 → 20 taken 113586 times.
✓ Branch 19 → 22 taken 13615 times.
✓ Branch 20 → 21 taken 113583 times.
✓ Branch 20 → 22 taken 3 times.
✓ Branch 21 → 22 taken 112398 times.
✓ Branch 21 → 51 taken 1185 times.
 127201 if (cmp <= 0 || ts == AV_NOPTS_VALUE || !sq->have_limiting) {
535
2/2
✓ Branch 22 → 23 taken 112457 times.
✓ Branch 22 → 30 taken 13559 times.
 126016 if (nb_samples &&
536
4/4
✓ Branch 23 → 24 taken 7157 times.
✓ Branch 23 → 26 taken 105300 times.
✓ Branch 25 → 26 taken 3 times.
✓ Branch 25 → 30 taken 7154 times.
 217760 (nb_samples != peek.f->nb_samples || !frame_is_aligned(sq, peek.f))) {
537 105303 int ret = receive_samples(sq, st, frame.f, nb_samples);
538
1/2
✗ Branch 27 → 28 not taken.
✓ Branch 27 → 29 taken 105303 times.
 105303 if (ret < 0)
539 ✗ return ret;
540 } else {
541
2/2
✓ Branch 30 → 31 taken 19810 times.
✓ Branch 30 → 32 taken 903 times.
 20713 int ret = av_container_fifo_read(st->fifo, SQPTR(sq, frame), 0);
542
1/2
✗ Branch 34 → 35 not taken.
✓ Branch 34 → 37 taken 20713 times.
 20713 av_assert0(ret >= 0);
543
544
1/2
✗ Branch 38 → 39 not taken.
✓ Branch 38 → 41 taken 20713 times.
 20713 av_assert0(st->samples_queued >= frame_samples(sq, frame));
545 20713 st->samples_queued -= frame_samples(sq, frame);
546 }
547
548 238417 av_log(sq->logctx, AV_LOG_DEBUG,
549 "sq: receive %u ts %s queue head %d ts %s\n", stream_idx,
550 126016 av_ts2timestr(frame_end(sq, frame, 0), &st->tb),
551 sq->head_stream,
552
2/2
✓ Branch 43 → 44 taken 13615 times.
✓ Branch 43 → 45 taken 112401 times.
 126016 st_head ? av_ts2timestr(st_head->head_ts, &st_head->tb) : "N/A");
553
554 126016 return 0;
555 }
556 }
557
558
4/4
✓ Branch 53 → 54 taken 10435 times.
✓ Branch 53 → 57 taken 509715 times.
✓ Branch 55 → 56 taken 10243 times.
✓ Branch 55 → 57 taken 192 times.
 520150 return (sq->finished || (st->finished && !av_container_fifo_can_read(st->fifo))) ?
559
2/2
✓ Branch 52 → 53 taken 520150 times.
✓ Branch 52 → 56 taken 20955 times.
 1061255 AVERROR_EOF : AVERROR(EAGAIN);
560 }
561
562 182247 static int receive_internal(SyncQueue *sq, int stream_idx, SyncQueueFrame frame)
563 {
564 182247 int nb_eof = 0;
565 int ret;
566
567 /* read a frame for a specific stream */
568
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 8 taken 182247 times.
 182247 if (stream_idx >= 0) {
569 ✗ ret = receive_for_stream(sq, stream_idx, frame);
570
0/2
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
 ✗ return (ret < 0) ? ret : stream_idx;
571 }
572
573 /* read a frame for any stream with available output */
574
2/2
✓ Branch 18 → 9 taken 667121 times.
✓ Branch 18 → 19 taken 56231 times.
 723352 for (unsigned int i = 0; i < sq->nb_streams; i++) {
575 667121 ret = receive_for_stream(sq, i, frame);
576
4/4
✓ Branch 10 → 11 taken 635923 times.
✓ Branch 10 → 12 taken 31198 times.
✓ Branch 11 → 12 taken 509907 times.
✓ Branch 11 → 13 taken 126016 times.
 667121 if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN)) {
577 541105 nb_eof += (ret == AVERROR_EOF);
578 541105 continue;
579 }
580
1/2
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 15 taken 126016 times.
 126016 return (ret < 0) ? ret : i;
581 }
582
583
2/2
✓ Branch 19 → 20 taken 10206 times.
✓ Branch 19 → 21 taken 46025 times.
 56231 return (nb_eof == sq->nb_streams) ? AVERROR_EOF : AVERROR(EAGAIN);
584 }
585
586 182153 int sq_receive(SyncQueue *sq, int stream_idx, SyncQueueFrame frame)
587 {
588 182153 int ret = receive_internal(sq, stream_idx, frame);
589
590 /* try again if the queue overflowed and triggered a fake heartbeat
591 * for lagging streams */
592
4/4
✓ Branch 3 → 4 taken 46025 times.
✓ Branch 3 → 7 taken 136128 times.
✓ Branch 5 → 6 taken 94 times.
✓ Branch 5 → 7 taken 45931 times.
 182153 if (ret == AVERROR(EAGAIN) && overflow_heartbeat(sq, stream_idx))
593 94 ret = receive_internal(sq, stream_idx, frame);
594
595 182153 return ret;
596 }
597
598 3611 int sq_add_stream(SyncQueue *sq, int limiting)
599 {
600 SyncQueueStream *tmp, *st;
601
602 3611 tmp = av_realloc_array(sq->streams, sq->nb_streams + 1, sizeof(*sq->streams));
603
1/2
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 5 taken 3611 times.
 3611 if (!tmp)
604 ✗ return AVERROR(ENOMEM);
605 3611 sq->streams = tmp;
606
607 3611 st = &sq->streams[sq->nb_streams];
608 3611 memset(st, 0, sizeof(*st));
609
610 7222 st->fifo = (sq->type == SYNC_QUEUE_FRAMES) ?
611
2/2
✓ Branch 5 → 6 taken 3509 times.
✓ Branch 5 → 7 taken 102 times.
 3611 av_container_fifo_alloc_avframe(0) : av_container_fifo_alloc_avpacket(0);
612
1/2
✗ Branch 8 → 9 not taken.
✓ Branch 8 → 10 taken 3611 times.
 3611 if (!st->fifo)
613 ✗ return AVERROR(ENOMEM);
614
615 /* we set a valid default, so that a pathological stream that never
616 * receives even a real timebase (and no frames) won't stall all other
617 * streams forever; cf. overflow_heartbeat() */
618 3611 st->tb = (AVRational){ 1, 1 };
619 3611 st->head_ts = AV_NOPTS_VALUE;
620 3611 st->frames_max = UINT64_MAX;
621 3611 st->limiting = limiting;
622
623 3611 sq->have_limiting |= limiting;
624
625 3611 return sq->nb_streams++;
626 }
627
628 3228 void sq_limit_frames(SyncQueue *sq, unsigned int stream_idx, uint64_t frames)
629 {
630 SyncQueueStream *st;
631
632
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 5 taken 3228 times.
 3228 av_assert0(stream_idx < sq->nb_streams);
633 3228 st = &sq->streams[stream_idx];
634
635 3228 st->frames_max = frames;
636
2/2
✓ Branch 5 → 6 taken 63 times.
✓ Branch 5 → 7 taken 3165 times.
 3228 if (st->frames_sent >= st->frames_max)
637 63 finish_stream(sq, stream_idx);
638 3228 }
639
640 362 void sq_frame_samples(SyncQueue *sq, unsigned int stream_idx,
641 int frame_samples)
642 {
643 SyncQueueStream *st;
644
645
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 5 taken 362 times.
 362 av_assert0(sq->type == SYNC_QUEUE_FRAMES);
646
1/2
✗ Branch 5 → 6 not taken.
✓ Branch 5 → 8 taken 362 times.
 362 av_assert0(stream_idx < sq->nb_streams);
647 362 st = &sq->streams[stream_idx];
648
649 362 st->frame_samples = frame_samples;
650
651 362 sq->align_mask = av_cpu_max_align() - 1;
652 362 }
653
654 3381 SyncQueue *sq_alloc(enum SyncQueueType type, int64_t buf_size_us, void *logctx)
655 {
656 3381 SyncQueue *sq = av_mallocz(sizeof(*sq));
657
658
1/2
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 5 taken 3381 times.
 3381 if (!sq)
659 ✗ return NULL;
660
661 3381 sq->type = type;
662 3381 sq->buf_size_us = buf_size_us;
663 3381 sq->logctx = logctx;
664
665 3381 sq->head_stream = -1;
666 3381 sq->head_finished_stream = -1;
667
668 3381 return sq;
669 }
670
671 12467 void sq_free(SyncQueue **psq)
672 {
673 12467 SyncQueue *sq = *psq;
674
675
2/2
✓ Branch 2 → 3 taken 9086 times.
✓ Branch 2 → 4 taken 3381 times.
 12467 if (!sq)
676 9086 return;
677
678
2/2
✓ Branch 7 → 5 taken 3611 times.
✓ Branch 7 → 8 taken 3381 times.
 6992 for (unsigned int i = 0; i < sq->nb_streams; i++)
679 3611 av_container_fifo_free(&sq->streams[i].fifo);
680
681 3381 av_freep(&sq->streams);
682
683 3381 av_freep(psq);
684 }
685