FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavcodec/pthread_frame.c
Date: 2025-01-20 09:27:23
Exec Total Coverage
Lines: 424 544 77.9%
Functions: 26 28 92.9%
Branches: 190 316 60.1%
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 /**
20 * @file
21 * Frame multithreading support functions
22 * @see doc/multithreading.txt
23 */
24
25 #include <stdatomic.h>
26
27 #include "avcodec.h"
28 #include "avcodec_internal.h"
29 #include "codec_desc.h"
30 #include "codec_internal.h"
31 #include "decode.h"
32 #include "hwaccel_internal.h"
33 #include "hwconfig.h"
34 #include "internal.h"
35 #include "packet_internal.h"
36 #include "pthread_internal.h"
37 #include "libavutil/refstruct.h"
38 #include "thread.h"
39 #include "threadframe.h"
40 #include "version_major.h"
41
42 #include "libavutil/avassert.h"
43 #include "libavutil/buffer.h"
44 #include "libavutil/common.h"
45 #include "libavutil/cpu.h"
46 #include "libavutil/frame.h"
47 #include "libavutil/internal.h"
48 #include "libavutil/log.h"
49 #include "libavutil/mem.h"
50 #include "libavutil/opt.h"
51 #include "libavutil/thread.h"
52
53 enum {
54 /// Set when the thread is awaiting a packet.
55 STATE_INPUT_READY,
56 /// Set before the codec has called ff_thread_finish_setup().
57 STATE_SETTING_UP,
58 /// Set after the codec has called ff_thread_finish_setup().
59 STATE_SETUP_FINISHED,
60 };
61
62 enum {
63 UNINITIALIZED, ///< Thread has not been created, AVCodec->close mustn't be called
64 NEEDS_CLOSE, ///< FFCodec->close needs to be called
65 INITIALIZED, ///< Thread has been properly set up
66 };
67
68 typedef struct DecodedFrames {
69 AVFrame **f;
70 size_t nb_f;
71 size_t nb_f_allocated;
72 } DecodedFrames;
73
74 typedef struct ThreadFrameProgress {
75 atomic_int progress[2];
76 } ThreadFrameProgress;
77
78 /**
79 * Context used by codec threads and stored in their AVCodecInternal thread_ctx.
80 */
81 typedef struct PerThreadContext {
82 struct FrameThreadContext *parent;
83
84 pthread_t thread;
85 int thread_init;
86 unsigned pthread_init_cnt;///< Number of successfully initialized mutexes/conditions
87 pthread_cond_t input_cond; ///< Used to wait for a new packet from the main thread.
88 pthread_cond_t progress_cond; ///< Used by child threads to wait for progress to change.
89 pthread_cond_t output_cond; ///< Used by the main thread to wait for frames to finish.
90
91 pthread_mutex_t mutex; ///< Mutex used to protect the contents of the PerThreadContext.
92 pthread_mutex_t progress_mutex; ///< Mutex used to protect frame progress values and progress_cond.
93
94 AVCodecContext *avctx; ///< Context used to decode packets passed to this thread.
95
96 AVPacket *avpkt; ///< Input packet (for decoding) or output (for encoding).
97
98 /**
99 * Decoded frames from a single decode iteration.
100 */
101 DecodedFrames df;
102 int result; ///< The result of the last codec decode/encode() call.
103
104 atomic_int state;
105
106 int die; ///< Set when the thread should exit.
107
108 int hwaccel_serializing;
109 int async_serializing;
110
111 // set to 1 in ff_thread_finish_setup() when a threadsafe hwaccel is used;
112 // cannot check hwaccel caps directly, because
113 // worked threads clear hwaccel state for thread-unsafe hwaccels
114 // after each decode call
115 int hwaccel_threadsafe;
116
117 atomic_int debug_threads; ///< Set if the FF_DEBUG_THREADS option is set.
118
119 /// The following two fields have the same semantics as the DecodeContext field
120 int intra_only_flag;
121 enum AVPictureType initial_pict_type;
122 } PerThreadContext;
123
124 /**
125 * Context stored in the client AVCodecInternal thread_ctx.
126 */
127 typedef struct FrameThreadContext {
128 PerThreadContext *threads; ///< The contexts for each thread.
129 PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.
130
131 unsigned pthread_init_cnt; ///< Number of successfully initialized mutexes/conditions
132 pthread_mutex_t buffer_mutex; ///< Mutex used to protect get/release_buffer().
133 /**
134 * This lock is used for ensuring threads run in serial when thread-unsafe
135 * hwaccel is used.
136 */
137 pthread_mutex_t hwaccel_mutex;
138 pthread_mutex_t async_mutex;
139 pthread_cond_t async_cond;
140 int async_lock;
141
142 DecodedFrames df;
143 int result;
144
145 /**
146 * Packet to be submitted to the next thread for decoding.
147 */
148 AVPacket *next_pkt;
149
150 int next_decoding; ///< The next context to submit a packet to.
151 int next_finished; ///< The next context to return output from.
152
153 /* hwaccel state for thread-unsafe hwaccels is temporarily stored here in
154 * order to transfer its ownership to the next decoding thread without the
155 * need for extra synchronization */
156 const AVHWAccel *stash_hwaccel;
157 void *stash_hwaccel_context;
158 void *stash_hwaccel_priv;
159 } FrameThreadContext;
160
161 1818 static int hwaccel_serial(const AVCodecContext *avctx)
162 {
163
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1818 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1818 return avctx->hwaccel && !(ffhwaccel(avctx->hwaccel)->caps_internal & HWACCEL_CAP_THREAD_SAFE);
164 }
165
166 842 static void async_lock(FrameThreadContext *fctx)
167 {
168 842 pthread_mutex_lock(&fctx->async_mutex);
169
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 842 times.
 842 while (fctx->async_lock)
170 ✗ pthread_cond_wait(&fctx->async_cond, &fctx->async_mutex);
171 842 fctx->async_lock = 1;
172 842 pthread_mutex_unlock(&fctx->async_mutex);
173 842 }
174
175 842 static void async_unlock(FrameThreadContext *fctx)
176 {
177 842 pthread_mutex_lock(&fctx->async_mutex);
178
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 842 times.
 842 av_assert0(fctx->async_lock);
179 842 fctx->async_lock = 0;
180 842 pthread_cond_broadcast(&fctx->async_cond);
181 842 pthread_mutex_unlock(&fctx->async_mutex);
182 842 }
183
184 76 static void thread_set_name(PerThreadContext *p)
185 {
186 76 AVCodecContext *avctx = p->avctx;
187 76 int idx = p - p->parent->threads;
188 char name[16];
189
190 76 snprintf(name, sizeof(name), "av:%.7s:df%d", avctx->codec->name, idx);
191
192 76 ff_thread_setname(name);
193 76 }
194
195 // get a free frame to decode into
196 1144 static AVFrame *decoded_frames_get_free(DecodedFrames *df)
197 {
198
2/2
✓ Branch 0 taken 163 times.
✓ Branch 1 taken 981 times.
 1144 if (df->nb_f == df->nb_f_allocated) {
199 163 AVFrame **tmp = av_realloc_array(df->f, df->nb_f + 1,
200 sizeof(*df->f));
201
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 163 times.
 163 if (!tmp)
202 ✗ return NULL;
203 163 df->f = tmp;
204
205 163 df->f[df->nb_f] = av_frame_alloc();
206
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 163 times.
 163 if (!df->f[df->nb_f])
207 ✗ return NULL;
208
209 163 df->nb_f_allocated++;
210 }
211
212
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1144 times.
 1144 av_assert0(!df->f[df->nb_f]->buf[0]);
213
214 1144 return df->f[df->nb_f];
215 }
216
217 537 static void decoded_frames_pop(DecodedFrames *df, AVFrame *dst)
218 {
219 537 AVFrame *tmp_frame = df->f[0];
220 537 av_frame_move_ref(dst, tmp_frame);
221 537 memmove(df->f, df->f + 1, (df->nb_f - 1) * sizeof(*df->f));
222 537 df->f[--df->nb_f] = tmp_frame;
223 537 }
224
225 ✗ static void decoded_frames_flush(DecodedFrames *df)
226 {
227 ✗ for (size_t i = 0; i < df->nb_f; i++)
228 ✗ av_frame_unref(df->f[i]);
229 ✗ df->nb_f = 0;
230 ✗ }
231
232 86 static void decoded_frames_free(DecodedFrames *df)
233 {
234
2/2
✓ Branch 0 taken 163 times.
✓ Branch 1 taken 86 times.
 249 for (size_t i = 0; i < df->nb_f_allocated; i++)
235 163 av_frame_free(&df->f[i]);
236 86 av_freep(&df->f);
237 86 df->nb_f = 0;
238 86 df->nb_f_allocated = 0;
239 86 }
240
241 /**
242 * Codec worker thread.
243 *
244 * Automatically calls ff_thread_finish_setup() if the codec does
245 * not provide an update_thread_context method, or if the codec returns
246 * before calling it.
247 */
248 76 static attribute_align_arg void *frame_worker_thread(void *arg)
249 {
250 76 PerThreadContext *p = arg;
251 76 AVCodecContext *avctx = p->avctx;
252 76 const FFCodec *codec = ffcodec(avctx->codec);
253
254 76 thread_set_name(p);
255
256 76 pthread_mutex_lock(&p->mutex);
257 606 while (1) {
258 int ret;
259
260
4/4
✓ Branch 0 taken 753 times.
✓ Branch 1 taken 606 times.
✓ Branch 2 taken 677 times.
✓ Branch 3 taken 76 times.
 1359 while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)
261 677 pthread_cond_wait(&p->input_cond, &p->mutex);
262
263
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 606 times.
 682 if (p->die) break;
264
265
2/2
✓ Branch 0 taken 494 times.
✓ Branch 1 taken 112 times.
 606 if (!codec->update_thread_context)
266 494 ff_thread_finish_setup(avctx);
267
268 /* If a decoder supports hwaccel, then it must call ff_get_format().
269 * Since that call must happen before ff_thread_finish_setup(), the
270 * decoder is required to implement update_thread_context() and call
271 * ff_thread_finish_setup() manually. Therefore the above
272 * ff_thread_finish_setup() call did not happen and hwaccel_serializing
273 * cannot be true here. */
274
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 av_assert0(!p->hwaccel_serializing);
275
276 /* if the previous thread uses thread-unsafe hwaccel then we take the
277 * lock to ensure the threads don't run concurrently */
278
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 606 times.
 606 if (hwaccel_serial(avctx)) {
279 ✗ pthread_mutex_lock(&p->parent->hwaccel_mutex);
280 ✗ p->hwaccel_serializing = 1;
281 }
282
283 606 ret = 0;
284
2/2
✓ Branch 0 taken 1144 times.
✓ Branch 1 taken 606 times.
 1750 while (ret >= 0) {
285 AVFrame *frame;
286
287 /* get the frame which will store the output */
288 1144 frame = decoded_frames_get_free(&p->df);
289
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1144 times.
 1144 if (!frame) {
290 ✗ p->result = AVERROR(ENOMEM);
291 ✗ goto alloc_fail;
292 }
293
294 /* do the actual decoding */
295 1144 ret = ff_decode_receive_frame_internal(avctx, frame);
296
2/2
✓ Branch 0 taken 538 times.
✓ Branch 1 taken 606 times.
 1144 if (ret == 0)
297 538 p->df.nb_f++;
298
2/4
✓ Branch 0 taken 606 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 606 times.
 606 else if (ret < 0 && frame->buf[0])
299 ✗ av_frame_unref(frame);
300
301
2/2
✓ Branch 0 taken 606 times.
✓ Branch 1 taken 538 times.
 1144 p->result = (ret == AVERROR(EAGAIN)) ? 0 : ret;
302 }
303
304
2/2
✓ Branch 0 taken 578 times.
✓ Branch 1 taken 28 times.
 606 if (atomic_load(&p->state) == STATE_SETTING_UP)
305 28 ff_thread_finish_setup(avctx);
306
307 578 alloc_fail:
308
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 if (p->hwaccel_serializing) {
309 /* wipe hwaccel state for thread-unsafe hwaccels to avoid stale
310 * pointers lying around;
311 * the state was transferred to FrameThreadContext in
312 * ff_thread_finish_setup(), so nothing is leaked */
313 ✗ avctx->hwaccel = NULL;
314 ✗ avctx->hwaccel_context = NULL;
315 ✗ avctx->internal->hwaccel_priv_data = NULL;
316
317 ✗ p->hwaccel_serializing = 0;
318 ✗ pthread_mutex_unlock(&p->parent->hwaccel_mutex);
319 }
320
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 606 av_assert0(!avctx->hwaccel ||
321 (ffhwaccel(avctx->hwaccel)->caps_internal & HWACCEL_CAP_THREAD_SAFE));
322
323
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 if (p->async_serializing) {
324 ✗ p->async_serializing = 0;
325
326 ✗ async_unlock(p->parent);
327 }
328
329 606 pthread_mutex_lock(&p->progress_mutex);
330
331 606 atomic_store(&p->state, STATE_INPUT_READY);
332
333 606 pthread_cond_broadcast(&p->progress_cond);
334 606 pthread_cond_signal(&p->output_cond);
335 606 pthread_mutex_unlock(&p->progress_mutex);
336 }
337 76 pthread_mutex_unlock(&p->mutex);
338
339 76 return NULL;
340 }
341
342 /**
343 * Update the next thread's AVCodecContext with values from the reference thread's context.
344 *
345 * @param dst The destination context.
346 * @param src The source context.
347 * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
348 * @return 0 on success, negative error code on failure
349 */
350 1111 static int update_context_from_thread(AVCodecContext *dst, const AVCodecContext *src, int for_user)
351 {
352 1111 const FFCodec *const codec = ffcodec(dst->codec);
353 1111 int err = 0;
354
355
5/6
✓ Branch 0 taken 1111 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 555 times.
✓ Branch 3 taken 556 times.
✓ Branch 4 taken 108 times.
✓ Branch 5 taken 447 times.
 1111 if (dst != src && (for_user || codec->update_thread_context)) {
356 664 dst->time_base = src->time_base;
357 664 dst->framerate = src->framerate;
358 664 dst->width = src->width;
359 664 dst->height = src->height;
360 664 dst->pix_fmt = src->pix_fmt;
361 664 dst->sw_pix_fmt = src->sw_pix_fmt;
362
363 664 dst->coded_width = src->coded_width;
364 664 dst->coded_height = src->coded_height;
365
366 664 dst->has_b_frames = src->has_b_frames;
367 664 dst->idct_algo = src->idct_algo;
368 #if FF_API_CODEC_PROPS
369 FF_DISABLE_DEPRECATION_WARNINGS
370 664 dst->properties = src->properties;
371 FF_ENABLE_DEPRECATION_WARNINGS
372 #endif
373
374 664 dst->bits_per_coded_sample = src->bits_per_coded_sample;
375 664 dst->sample_aspect_ratio = src->sample_aspect_ratio;
376
377 664 dst->profile = src->profile;
378 664 dst->level = src->level;
379
380 664 dst->bits_per_raw_sample = src->bits_per_raw_sample;
381 #if FF_API_TICKS_PER_FRAME
382 FF_DISABLE_DEPRECATION_WARNINGS
383 664 dst->ticks_per_frame = src->ticks_per_frame;
384 FF_ENABLE_DEPRECATION_WARNINGS
385 #endif
386 664 dst->color_primaries = src->color_primaries;
387
388 664 dst->color_trc = src->color_trc;
389 664 dst->colorspace = src->colorspace;
390 664 dst->color_range = src->color_range;
391 664 dst->chroma_sample_location = src->chroma_sample_location;
392
393 664 dst->sample_rate = src->sample_rate;
394 664 dst->sample_fmt = src->sample_fmt;
395 664 err = av_channel_layout_copy(&dst->ch_layout, &src->ch_layout);
396
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 664 times.
 664 if (err < 0)
397 ✗ return err;
398
399
1/2
✓ Branch 0 taken 664 times.
✗ Branch 1 not taken.
 664 if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||
400
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 664 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 664 (dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {
401 ✗ av_buffer_unref(&dst->hw_frames_ctx);
402
403 ✗ if (src->hw_frames_ctx) {
404 ✗ dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
405 ✗ if (!dst->hw_frames_ctx)
406 ✗ return AVERROR(ENOMEM);
407 }
408 }
409
410 664 dst->hwaccel_flags = src->hwaccel_flags;
411
412 664 av_refstruct_replace(&dst->internal->pool, src->internal->pool);
413 664 ff_decode_internal_sync(dst, src);
414 }
415
416
2/2
✓ Branch 0 taken 556 times.
✓ Branch 1 taken 555 times.
 1111 if (for_user) {
417
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 498 times.
 556 if (codec->update_thread_context_for_user)
418 58 err = codec->update_thread_context_for_user(dst, src);
419 } else {
420 555 const PerThreadContext *p_src = src->internal->thread_ctx;
421 555 PerThreadContext *p_dst = dst->internal->thread_ctx;
422
423
2/2
✓ Branch 0 taken 108 times.
✓ Branch 1 taken 447 times.
 555 if (codec->update_thread_context) {
424 108 err = codec->update_thread_context(dst, src);
425
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 108 times.
 108 if (err < 0)
426 ✗ return err;
427 }
428
429 // reset dst hwaccel state if needed
430
3/6
✓ Branch 0 taken 555 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 555 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 555 times.
 555 av_assert0(p_dst->hwaccel_threadsafe ||
431 (!dst->hwaccel && !dst->internal->hwaccel_priv_data));
432
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 555 times.
 555 if (p_dst->hwaccel_threadsafe &&
433 ✗ (!p_src->hwaccel_threadsafe || dst->hwaccel != src->hwaccel)) {
434 ✗ ff_hwaccel_uninit(dst);
435 ✗ p_dst->hwaccel_threadsafe = 0;
436 }
437
438 // propagate hwaccel state for threadsafe hwaccels
439
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 555 times.
 555 if (p_src->hwaccel_threadsafe) {
440 ✗ const FFHWAccel *hwaccel = ffhwaccel(src->hwaccel);
441 ✗ if (!dst->hwaccel) {
442 ✗ if (hwaccel->priv_data_size) {
443 ✗ av_assert0(hwaccel->update_thread_context);
444
445 ✗ dst->internal->hwaccel_priv_data =
446 ✗ av_mallocz(hwaccel->priv_data_size);
447 ✗ if (!dst->internal->hwaccel_priv_data)
448 ✗ return AVERROR(ENOMEM);
449 }
450 ✗ dst->hwaccel = src->hwaccel;
451 }
452 ✗ av_assert0(dst->hwaccel == src->hwaccel);
453
454 ✗ if (hwaccel->update_thread_context) {
455 ✗ err = hwaccel->update_thread_context(dst, src);
456 ✗ if (err < 0) {
457 ✗ av_log(dst, AV_LOG_ERROR, "Error propagating hwaccel state\n");
458 ✗ ff_hwaccel_uninit(dst);
459 ✗ return err;
460 }
461 }
462 ✗ p_dst->hwaccel_threadsafe = 1;
463 }
464 }
465
466 1111 return err;
467 }
468
469 /**
470 * Update the next thread's AVCodecContext with values set by the user.
471 *
472 * @param dst The destination context.
473 * @param src The source context.
474 * @return 0 on success, negative error code on failure
475 */
476 606 static int update_context_from_user(AVCodecContext *dst, const AVCodecContext *src)
477 {
478 int err;
479
480 606 dst->flags = src->flags;
481
482 606 dst->draw_horiz_band= src->draw_horiz_band;
483 606 dst->get_buffer2 = src->get_buffer2;
484
485 606 dst->opaque = src->opaque;
486 606 dst->debug = src->debug;
487
488 606 dst->slice_flags = src->slice_flags;
489 606 dst->flags2 = src->flags2;
490 606 dst->export_side_data = src->export_side_data;
491
492 606 dst->skip_loop_filter = src->skip_loop_filter;
493 606 dst->skip_idct = src->skip_idct;
494 606 dst->skip_frame = src->skip_frame;
495
496 606 dst->frame_num = src->frame_num;
497
498 606 av_packet_unref(dst->internal->last_pkt_props);
499 606 err = av_packet_copy_props(dst->internal->last_pkt_props, src->internal->last_pkt_props);
500
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 if (err < 0)
501 ✗ return err;
502
503 606 return 0;
504 }
505
506 606 static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,
507 AVPacket *in_pkt)
508 {
509 606 FrameThreadContext *fctx = p->parent;
510 606 PerThreadContext *prev_thread = fctx->prev_thread;
511 606 const AVCodec *codec = p->avctx->codec;
512 int ret;
513
514 606 pthread_mutex_lock(&p->mutex);
515
516 606 av_packet_unref(p->avpkt);
517 606 av_packet_move_ref(p->avpkt, in_pkt);
518
519
3/4
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 538 times.
✓ Branch 2 taken 68 times.
✗ Branch 3 not taken.
 606 if (AVPACKET_IS_EMPTY(p->avpkt))
520 68 p->avctx->internal->draining = 1;
521
522 606 ret = update_context_from_user(p->avctx, user_avctx);
523
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 if (ret) {
524 ✗ pthread_mutex_unlock(&p->mutex);
525 ✗ return ret;
526 }
527 606 atomic_store_explicit(&p->debug_threads,
528 (p->avctx->debug & FF_DEBUG_THREADS) != 0,
529 memory_order_relaxed);
530
531
2/2
✓ Branch 0 taken 596 times.
✓ Branch 1 taken 10 times.
 606 if (prev_thread) {
532
2/2
✓ Branch 0 taken 276 times.
✓ Branch 1 taken 320 times.
 596 if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {
533 276 pthread_mutex_lock(&prev_thread->progress_mutex);
534
2/2
✓ Branch 0 taken 276 times.
✓ Branch 1 taken 276 times.
 552 while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
535 276 pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
536 276 pthread_mutex_unlock(&prev_thread->progress_mutex);
537 }
538
539 /* codecs without delay might not be prepared to be called repeatedly here during
540 * flushing (vp3/theora), and also don't need to be, since from this point on, they
541 * will always return EOF anyway */
542
2/2
✓ Branch 0 taken 68 times.
✓ Branch 1 taken 528 times.
 596 if (!p->avctx->internal->draining ||
543
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 41 times.
 68 (codec->capabilities & AV_CODEC_CAP_DELAY)) {
544 555 ret = update_context_from_thread(p->avctx, prev_thread->avctx, 0);
545
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 555 times.
 555 if (ret) {
546 ✗ pthread_mutex_unlock(&p->mutex);
547 ✗ return ret;
548 }
549 }
550 }
551
552 /* transfer the stashed hwaccel state, if any */
553
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 606 av_assert0(!p->avctx->hwaccel || p->hwaccel_threadsafe);
554
1/2
✓ Branch 0 taken 606 times.
✗ Branch 1 not taken.
 606 if (!p->hwaccel_threadsafe) {
555 606 FFSWAP(const AVHWAccel*, p->avctx->hwaccel, fctx->stash_hwaccel);
556 606 FFSWAP(void*, p->avctx->hwaccel_context, fctx->stash_hwaccel_context);
557 606 FFSWAP(void*, p->avctx->internal->hwaccel_priv_data, fctx->stash_hwaccel_priv);
558 }
559
560 606 atomic_store(&p->state, STATE_SETTING_UP);
561 606 pthread_cond_signal(&p->input_cond);
562 606 pthread_mutex_unlock(&p->mutex);
563
564 606 fctx->prev_thread = p;
565 606 fctx->next_decoding = (fctx->next_decoding + 1) % p->avctx->thread_count;
566
567 606 return 0;
568 }
569
570 832 int ff_thread_receive_frame(AVCodecContext *avctx, AVFrame *frame)
571 {
572 832 FrameThreadContext *fctx = avctx->internal->thread_ctx;
573 832 int ret = 0;
574
575 /* release the async lock, permitting blocked hwaccel threads to
576 * go forward while we are in this function */
577 832 async_unlock(fctx);
578
579 /* submit packets to threads while there are no buffered results to return */
580
4/4
✓ Branch 0 taken 901 times.
✓ Branch 1 taken 537 times.
✓ Branch 2 taken 892 times.
✓ Branch 3 taken 9 times.
 1438 while (!fctx->df.nb_f && !fctx->result) {
581 PerThreadContext *p;
582
583 /* get a packet to be submitted to the next thread */
584 892 av_packet_unref(fctx->next_pkt);
585 892 ret = ff_decode_get_packet(avctx, fctx->next_pkt);
586
4/4
✓ Branch 0 taken 354 times.
✓ Branch 1 taken 538 times.
✓ Branch 2 taken 286 times.
✓ Branch 3 taken 68 times.
 892 if (ret < 0 && ret != AVERROR_EOF)
587 286 goto finish;
588
589 606 ret = submit_packet(&fctx->threads[fctx->next_decoding], avctx,
590 fctx->next_pkt);
591
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 if (ret < 0)
592 ✗ goto finish;
593
594 /* do not return any frames until all threads have something to do */
595
2/2
✓ Branch 0 taken 72 times.
✓ Branch 1 taken 534 times.
 606 if (fctx->next_decoding != fctx->next_finished &&
596
2/2
✓ Branch 0 taken 60 times.
✓ Branch 1 taken 12 times.
 72 !avctx->internal->draining)
597 60 continue;
598
599 546 p = &fctx->threads[fctx->next_finished];
600 546 fctx->next_finished = (fctx->next_finished + 1) % avctx->thread_count;
601
602
2/2
✓ Branch 0 taken 142 times.
✓ Branch 1 taken 404 times.
 546 if (atomic_load(&p->state) != STATE_INPUT_READY) {
603 142 pthread_mutex_lock(&p->progress_mutex);
604
2/2
✓ Branch 0 taken 142 times.
✓ Branch 1 taken 142 times.
 284 while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)
605 142 pthread_cond_wait(&p->output_cond, &p->progress_mutex);
606 142 pthread_mutex_unlock(&p->progress_mutex);
607 }
608
609 546 update_context_from_thread(avctx, p->avctx, 1);
610 546 fctx->result = p->result;
611 546 p->result = 0;
612
2/2
✓ Branch 0 taken 535 times.
✓ Branch 1 taken 11 times.
 546 if (p->df.nb_f)
613 535 FFSWAP(DecodedFrames, fctx->df, p->df);
614 }
615
616 /* a thread may return multiple frames AND an error
617 * we first return all the frames, then the error */
618
2/2
✓ Branch 0 taken 537 times.
✓ Branch 1 taken 9 times.
 546 if (fctx->df.nb_f) {
619 537 decoded_frames_pop(&fctx->df, frame);
620 537 ret = 0;
621 } else {
622 9 ret = fctx->result;
623 9 fctx->result = 0;
624 }
625
626 832 finish:
627 832 async_lock(fctx);
628 832 return ret;
629 }
630
631 287086 void ff_thread_report_progress(ThreadFrame *f, int n, int field)
632 {
633 PerThreadContext *p;
634
2/2
✓ Branch 0 taken 1240 times.
✓ Branch 1 taken 285846 times.
 287086 atomic_int *progress = f->progress ? f->progress->progress : NULL;
635
636
2/2
✓ Branch 0 taken 1240 times.
✓ Branch 1 taken 285846 times.
 287086 if (!progress ||
637
2/2
✓ Branch 0 taken 27 times.
✓ Branch 1 taken 1213 times.
 1240 atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)
638 285873 return;
639
640 1213 p = f->owner[field]->internal->thread_ctx;
641
642
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1213 times.
 1213 if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
643 ✗ av_log(f->owner[field], AV_LOG_DEBUG,
644 "%p finished %d field %d\n", progress, n, field);
645
646 1213 pthread_mutex_lock(&p->progress_mutex);
647
648 1213 atomic_store_explicit(&progress[field], n, memory_order_release);
649
650 1213 pthread_cond_broadcast(&p->progress_cond);
651 1213 pthread_mutex_unlock(&p->progress_mutex);
652 }
653
654 150874 void ff_thread_await_progress(const ThreadFrame *f, int n, int field)
655 {
656 PerThreadContext *p;
657
2/2
✓ Branch 0 taken 150193 times.
✓ Branch 1 taken 681 times.
 150874 atomic_int *progress = f->progress ? f->progress->progress : NULL;
658
659
2/2
✓ Branch 0 taken 150193 times.
✓ Branch 1 taken 681 times.
 150874 if (!progress ||
660
2/2
✓ Branch 0 taken 149666 times.
✓ Branch 1 taken 527 times.
 150193 atomic_load_explicit(&progress[field], memory_order_acquire) >= n)
661 150347 return;
662
663 527 p = f->owner[field]->internal->thread_ctx;
664
665
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 527 times.
 527 if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
666 ✗ av_log(f->owner[field], AV_LOG_DEBUG,
667 "thread awaiting %d field %d from %p\n", n, field, progress);
668
669 527 pthread_mutex_lock(&p->progress_mutex);
670
2/2
✓ Branch 0 taken 530 times.
✓ Branch 1 taken 527 times.
 1057 while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)
671 530 pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
672 527 pthread_mutex_unlock(&p->progress_mutex);
673 }
674
675 24046 void ff_thread_finish_setup(AVCodecContext *avctx) {
676 PerThreadContext *p;
677
678
2/2
✓ Branch 0 taken 23440 times.
✓ Branch 1 taken 606 times.
 24046 if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
679
680 606 p = avctx->internal->thread_ctx;
681
682
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 p->hwaccel_threadsafe = avctx->hwaccel &&
683 ✗ (ffhwaccel(avctx->hwaccel)->caps_internal & HWACCEL_CAP_THREAD_SAFE);
684
685
1/4
✗ Branch 1 not taken.
✓ Branch 2 taken 606 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 606 if (hwaccel_serial(avctx) && !p->hwaccel_serializing) {
686 ✗ pthread_mutex_lock(&p->parent->hwaccel_mutex);
687 ✗ p->hwaccel_serializing = 1;
688 }
689
690 /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 if (avctx->hwaccel &&
692 ✗ !(ffhwaccel(avctx->hwaccel)->caps_internal & HWACCEL_CAP_ASYNC_SAFE)) {
693 ✗ p->async_serializing = 1;
694
695 ✗ async_lock(p->parent);
696 }
697
698 /* thread-unsafe hwaccels share a single private data instance, so we
699 * save hwaccel state for passing to the next thread;
700 * this is done here so that this worker thread can wipe its own hwaccel
701 * state after decoding, without requiring synchronization */
702
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 av_assert0(!p->parent->stash_hwaccel);
703
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 606 times.
 606 if (hwaccel_serial(avctx)) {
704 ✗ p->parent->stash_hwaccel = avctx->hwaccel;
705 ✗ p->parent->stash_hwaccel_context = avctx->hwaccel_context;
706 ✗ p->parent->stash_hwaccel_priv = avctx->internal->hwaccel_priv_data;
707 }
708
709 606 pthread_mutex_lock(&p->progress_mutex);
710
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 606 times.
 606 if(atomic_load(&p->state) == STATE_SETUP_FINISHED){
711 ✗ av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
712 }
713
714 606 atomic_store(&p->state, STATE_SETUP_FINISHED);
715
716 606 pthread_cond_broadcast(&p->progress_cond);
717 606 pthread_mutex_unlock(&p->progress_mutex);
718 }
719
720 /// Waits for all threads to finish.
721 10 static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
722 {
723 int i;
724
725 10 async_unlock(fctx);
726
727
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 10 times.
 86 for (i = 0; i < thread_count; i++) {
728 76 PerThreadContext *p = &fctx->threads[i];
729
730
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 72 times.
 76 if (atomic_load(&p->state) != STATE_INPUT_READY) {
731 4 pthread_mutex_lock(&p->progress_mutex);
732
2/2
✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
 8 while (atomic_load(&p->state) != STATE_INPUT_READY)
733 4 pthread_cond_wait(&p->output_cond, &p->progress_mutex);
734 4 pthread_mutex_unlock(&p->progress_mutex);
735 }
736 }
737
738 10 async_lock(fctx);
739 10 }
740
741 #define OFF(member) offsetof(FrameThreadContext, member)
742 DEFINE_OFFSET_ARRAY(FrameThreadContext, thread_ctx, pthread_init_cnt,
743 (OFF(buffer_mutex), OFF(hwaccel_mutex), OFF(async_mutex)),
744 (OFF(async_cond)));
745 #undef OFF
746
747 #define OFF(member) offsetof(PerThreadContext, member)
748 DEFINE_OFFSET_ARRAY(PerThreadContext, per_thread, pthread_init_cnt,
749 (OFF(progress_mutex), OFF(mutex)),
750 (OFF(input_cond), OFF(progress_cond), OFF(output_cond)));
751 #undef OFF
752
753 10 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
754 {
755 10 FrameThreadContext *fctx = avctx->internal->thread_ctx;
756 10 const FFCodec *codec = ffcodec(avctx->codec);
757 int i;
758
759 10 park_frame_worker_threads(fctx, thread_count);
760
761
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 10 times.
 86 for (i = 0; i < thread_count; i++) {
762 76 PerThreadContext *p = &fctx->threads[i];
763 76 AVCodecContext *ctx = p->avctx;
764
765
1/2
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
 76 if (ctx->internal) {
766
1/2
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
 76 if (p->thread_init == INITIALIZED) {
767 76 pthread_mutex_lock(&p->mutex);
768 76 p->die = 1;
769 76 pthread_cond_signal(&p->input_cond);
770 76 pthread_mutex_unlock(&p->mutex);
771
772 76 pthread_join(p->thread, NULL);
773 }
774
2/4
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 76 times.
✗ Branch 3 not taken.
 76 if (codec->close && p->thread_init != UNINITIALIZED)
775 76 codec->close(ctx);
776
777 /* When using a threadsafe hwaccel, this is where
778 * each thread's context is uninit'd and freed. */
779 76 ff_hwaccel_uninit(ctx);
780
781
1/2
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
 76 if (ctx->priv_data) {
782
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 18 times.
 76 if (codec->p.priv_class)
783 58 av_opt_free(ctx->priv_data);
784 76 av_freep(&ctx->priv_data);
785 }
786
787 76 av_refstruct_unref(&ctx->internal->pool);
788 76 av_packet_free(&ctx->internal->in_pkt);
789 76 av_packet_free(&ctx->internal->last_pkt_props);
790 76 ff_decode_internal_uninit(ctx);
791 76 av_freep(&ctx->internal);
792 76 av_buffer_unref(&ctx->hw_frames_ctx);
793 76 av_frame_side_data_free(&ctx->decoded_side_data,
794 &ctx->nb_decoded_side_data);
795 }
796
797 76 decoded_frames_free(&p->df);
798
799 76 ff_pthread_free(p, per_thread_offsets);
800 76 av_packet_free(&p->avpkt);
801
802 76 av_freep(&p->avctx);
803 }
804
805 10 decoded_frames_free(&fctx->df);
806 10 av_packet_free(&fctx->next_pkt);
807
808 10 av_freep(&fctx->threads);
809 10 ff_pthread_free(fctx, thread_ctx_offsets);
810
811 /* if we have stashed hwaccel state, move it to the user-facing context,
812 * so it will be freed in ff_codec_close() */
813
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 av_assert0(!avctx->hwaccel);
814 10 FFSWAP(const AVHWAccel*, avctx->hwaccel, fctx->stash_hwaccel);
815 10 FFSWAP(void*, avctx->hwaccel_context, fctx->stash_hwaccel_context);
816 10 FFSWAP(void*, avctx->internal->hwaccel_priv_data, fctx->stash_hwaccel_priv);
817
818 10 av_freep(&avctx->internal->thread_ctx);
819 10 }
820
821 76 static av_cold int init_thread(PerThreadContext *p, int *threads_to_free,
822 FrameThreadContext *fctx, AVCodecContext *avctx,
823 const FFCodec *codec, int first)
824 {
825 AVCodecContext *copy;
826 int err;
827
828 76 p->initial_pict_type = AV_PICTURE_TYPE_NONE;
829
2/2
✓ Branch 0 taken 47 times.
✓ Branch 1 taken 29 times.
 76 if (avctx->codec_descriptor->props & AV_CODEC_PROP_INTRA_ONLY) {
830 47 p->intra_only_flag = AV_FRAME_FLAG_KEY;
831
2/2
✓ Branch 0 taken 18 times.
✓ Branch 1 taken 29 times.
 47 if (avctx->codec_type == AVMEDIA_TYPE_VIDEO)
832 18 p->initial_pict_type = AV_PICTURE_TYPE_I;
833 }
834
835 76 atomic_init(&p->state, STATE_INPUT_READY);
836
837 76 copy = av_memdup(avctx, sizeof(*avctx));
838
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (!copy)
839 ✗ return AVERROR(ENOMEM);
840 76 copy->priv_data = NULL;
841 76 copy->decoded_side_data = NULL;
842 76 copy->nb_decoded_side_data = 0;
843
844 /* From now on, this PerThreadContext will be cleaned up by
845 * ff_frame_thread_free in case of errors. */
846 76 (*threads_to_free)++;
847
848 76 p->parent = fctx;
849 76 p->avctx = copy;
850
851 76 copy->internal = ff_decode_internal_alloc();
852
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (!copy->internal)
853 ✗ return AVERROR(ENOMEM);
854 76 ff_decode_internal_sync(copy, avctx);
855 76 copy->internal->thread_ctx = p;
856 76 copy->internal->progress_frame_pool = avctx->internal->progress_frame_pool;
857
858 76 copy->delay = avctx->delay;
859
860
1/2
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
 76 if (codec->priv_data_size) {
861 76 copy->priv_data = av_mallocz(codec->priv_data_size);
862
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (!copy->priv_data)
863 ✗ return AVERROR(ENOMEM);
864
865
2/2
✓ Branch 0 taken 58 times.
✓ Branch 1 taken 18 times.
 76 if (codec->p.priv_class) {
866 58 *(const AVClass **)copy->priv_data = codec->p.priv_class;
867 58 err = av_opt_copy(copy->priv_data, avctx->priv_data);
868
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 58 times.
 58 if (err < 0)
869 ✗ return err;
870 }
871 }
872
873 76 err = ff_pthread_init(p, per_thread_offsets);
874
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (err < 0)
875 ✗ return err;
876
877
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 76 times.
 76 if (!(p->avpkt = av_packet_alloc()))
878 ✗ return AVERROR(ENOMEM);
879
880 76 copy->internal->is_frame_mt = 1;
881
2/2
✓ Branch 0 taken 66 times.
✓ Branch 1 taken 10 times.
 76 if (!first)
882 66 copy->internal->is_copy = 1;
883
884 76 copy->internal->in_pkt = av_packet_alloc();
885
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (!copy->internal->in_pkt)
886 ✗ return AVERROR(ENOMEM);
887
888 76 copy->internal->last_pkt_props = av_packet_alloc();
889
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (!copy->internal->last_pkt_props)
890 ✗ return AVERROR(ENOMEM);
891
892
1/2
✓ Branch 0 taken 76 times.
✗ Branch 1 not taken.
 76 if (codec->init) {
893 76 err = codec->init(copy);
894
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (err < 0) {
895 ✗ if (codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP)
896 ✗ p->thread_init = NEEDS_CLOSE;
897 ✗ return err;
898 }
899 }
900 76 p->thread_init = NEEDS_CLOSE;
901
902
2/2
✓ Branch 0 taken 10 times.
✓ Branch 1 taken 66 times.
 76 if (first) {
903 10 update_context_from_thread(avctx, copy, 1);
904
905 10 av_frame_side_data_free(&avctx->decoded_side_data, &avctx->nb_decoded_side_data);
906
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 for (int i = 0; i < copy->nb_decoded_side_data; i++) {
907 ✗ err = av_frame_side_data_clone(&avctx->decoded_side_data,
908 &avctx->nb_decoded_side_data,
909 ✗ copy->decoded_side_data[i], 0);
910 ✗ if (err < 0)
911 ✗ return err;
912 }
913 }
914
915 76 atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);
916
917 76 err = AVERROR(pthread_create(&p->thread, NULL, frame_worker_thread, p));
918
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (err < 0)
919 ✗ return err;
920 76 p->thread_init = INITIALIZED;
921
922 76 return 0;
923 }
924
925 10 int ff_frame_thread_init(AVCodecContext *avctx)
926 {
927 10 int thread_count = avctx->thread_count;
928 10 const FFCodec *codec = ffcodec(avctx->codec);
929 FrameThreadContext *fctx;
930 10 int err, i = 0;
931
932
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (!thread_count) {
933 ✗ int nb_cpus = av_cpu_count();
934 // use number of cores + 1 as thread count if there is more than one
935 ✗ if (nb_cpus > 1)
936 ✗ thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
937 else
938 ✗ thread_count = avctx->thread_count = 1;
939 }
940
941
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (thread_count <= 1) {
942 ✗ avctx->active_thread_type = 0;
943 ✗ return 0;
944 }
945
946 10 avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));
947
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (!fctx)
948 ✗ return AVERROR(ENOMEM);
949
950 10 err = ff_pthread_init(fctx, thread_ctx_offsets);
951
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (err < 0) {
952 ✗ ff_pthread_free(fctx, thread_ctx_offsets);
953 ✗ av_freep(&avctx->internal->thread_ctx);
954 ✗ return err;
955 }
956
957 10 fctx->next_pkt = av_packet_alloc();
958
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (!fctx->next_pkt)
959 ✗ return AVERROR(ENOMEM);
960
961 10 fctx->async_lock = 1;
962
963
2/2
✓ Branch 0 taken 6 times.
✓ Branch 1 taken 4 times.
 10 if (codec->p.type == AVMEDIA_TYPE_VIDEO)
964 6 avctx->delay = avctx->thread_count - 1;
965
966 10 fctx->threads = av_calloc(thread_count, sizeof(*fctx->threads));
967
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
 10 if (!fctx->threads) {
968 ✗ err = AVERROR(ENOMEM);
969 ✗ goto error;
970 }
971
972
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 10 times.
 86 for (; i < thread_count; ) {
973 76 PerThreadContext *p = &fctx->threads[i];
974 76 int first = !i;
975
976 76 err = init_thread(p, &i, fctx, avctx, codec, first);
977
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 76 times.
 76 if (err < 0)
978 ✗ goto error;
979 }
980
981 10 return 0;
982
983 ✗ error:
984 ✗ ff_frame_thread_free(avctx, i);
985 ✗ return err;
986 }
987
988 ✗ void ff_thread_flush(AVCodecContext *avctx)
989 {
990 int i;
991 ✗ FrameThreadContext *fctx = avctx->internal->thread_ctx;
992
993 ✗ if (!fctx) return;
994
995 ✗ park_frame_worker_threads(fctx, avctx->thread_count);
996 ✗ if (fctx->prev_thread) {
997 ✗ if (fctx->prev_thread != &fctx->threads[0])
998 ✗ update_context_from_thread(fctx->threads[0].avctx, fctx->prev_thread->avctx, 0);
999 }
1000
1001 ✗ fctx->next_decoding = fctx->next_finished = 0;
1002 ✗ fctx->prev_thread = NULL;
1003
1004 ✗ decoded_frames_flush(&fctx->df);
1005 ✗ fctx->result = 0;
1006
1007 ✗ for (i = 0; i < avctx->thread_count; i++) {
1008 ✗ PerThreadContext *p = &fctx->threads[i];
1009
1010 ✗ decoded_frames_flush(&p->df);
1011 ✗ p->result = 0;
1012
1013 ✗ avcodec_flush_buffers(p->avctx);
1014 }
1015 }
1016
1017 36910 int ff_thread_can_start_frame(AVCodecContext *avctx)
1018 {
1019
2/2
✓ Branch 0 taken 52 times.
✓ Branch 1 taken 36858 times.
 36910 if ((avctx->active_thread_type & FF_THREAD_FRAME) &&
1020
1/2
✓ Branch 1 taken 52 times.
✗ Branch 2 not taken.
 52 ffcodec(avctx->codec)->update_thread_context) {
1021 52 PerThreadContext *p = avctx->internal->thread_ctx;
1022
1023
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 52 times.
 52 if (atomic_load(&p->state) != STATE_SETTING_UP)
1024 ✗ return 0;
1025 }
1026
1027 36910 return 1;
1028 }
1029
1030 52419 static int thread_get_buffer_internal(AVCodecContext *avctx, AVFrame *f, int flags)
1031 {
1032 PerThreadContext *p;
1033 int err;
1034
1035
2/2
✓ Branch 0 taken 51881 times.
✓ Branch 1 taken 538 times.
 52419 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1036 51881 return ff_get_buffer(avctx, f, flags);
1037
1038 538 p = avctx->internal->thread_ctx;
1039
2/2
✓ Branch 0 taken 453 times.
✓ Branch 1 taken 85 times.
 538 if (atomic_load(&p->state) != STATE_SETTING_UP &&
1040
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 453 times.
 453 ffcodec(avctx->codec)->update_thread_context) {
1041 ✗ av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
1042 ✗ return -1;
1043 }
1044
1045 538 pthread_mutex_lock(&p->parent->buffer_mutex);
1046 538 err = ff_get_buffer(avctx, f, flags);
1047
1048 538 pthread_mutex_unlock(&p->parent->buffer_mutex);
1049
1050 538 return err;
1051 }
1052
1053 52419 int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
1054 {
1055 52419 int ret = thread_get_buffer_internal(avctx, f, flags);
1056
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 52419 times.
 52419 if (ret < 0)
1057 ✗ av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");
1058 52419 return ret;
1059 }
1060
1061 25676 int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
1062 {
1063 int ret;
1064
1065 25676 f->owner[0] = f->owner[1] = avctx;
1066
2/2
✓ Branch 0 taken 25634 times.
✓ Branch 1 taken 42 times.
 25676 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1067 25634 return ff_get_buffer(avctx, f->f, flags);
1068
1069 42 f->progress = av_refstruct_allocz(sizeof(*f->progress));
1070
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
 42 if (!f->progress)
1071 ✗ return AVERROR(ENOMEM);
1072
1073 42 atomic_init(&f->progress->progress[0], -1);
1074 42 atomic_init(&f->progress->progress[1], -1);
1075
1076 42 ret = ff_thread_get_buffer(avctx, f->f, flags);
1077
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
 42 if (ret)
1078 ✗ av_refstruct_unref(&f->progress);
1079 42 return ret;
1080 }
1081
1082 53234 void ff_thread_release_ext_buffer(ThreadFrame *f)
1083 {
1084 53234 av_refstruct_unref(&f->progress);
1085 53234 f->owner[0] = f->owner[1] = NULL;
1086
1/2
✓ Branch 0 taken 53234 times.
✗ Branch 1 not taken.
 53234 if (f->f)
1087 53234 av_frame_unref(f->f);
1088 53234 }
1089
1090 704 enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset)
1091 {
1092 PerThreadContext *p;
1093 const void *ref;
1094
1095
2/2
✓ Branch 0 taken 696 times.
✓ Branch 1 taken 8 times.
 704 if (!avctx->internal->is_copy)
1096 696 return avctx->active_thread_type & FF_THREAD_FRAME ?
1097
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 695 times.
 696 FF_THREAD_IS_FIRST_THREAD : FF_THREAD_NO_FRAME_THREADING;
1098
1099 8 p = avctx->internal->thread_ctx;
1100
1101 av_assert1(memcpy(&ref, (char*)avctx->priv_data + offset, sizeof(ref)) && ref == NULL);
1102
1103 8 memcpy(&ref, (const char*)p->parent->threads[0].avctx->priv_data + offset, sizeof(ref));
1104 av_assert1(ref);
1105 8 av_refstruct_replace((char*)avctx->priv_data + offset, ref);
1106
1107 8 return FF_THREAD_IS_COPY;
1108 }
1109
1110 1076 int ff_thread_get_packet(AVCodecContext *avctx, AVPacket *pkt)
1111 {
1112 1076 PerThreadContext *p = avctx->internal->thread_ctx;
1113
1114
3/4
✓ Branch 0 taken 538 times.
✓ Branch 1 taken 538 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 538 times.
 1076 if (!AVPACKET_IS_EMPTY(p->avpkt)) {
1115 538 av_packet_move_ref(pkt, p->avpkt);
1116 538 return 0;
1117 }
1118
1119
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 538 times.
 538 return avctx->internal->draining ? AVERROR_EOF : AVERROR(EAGAIN);
1120 }
1121