FFmpeg
pthread_frame.c
Go to the documentation of this file.
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 "config.h"
26 
27 #include <stdatomic.h>
28 #include <stdint.h>
29 
30 #include "avcodec.h"
31 #include "hwaccel.h"
32 #include "internal.h"
33 #include "pthread_internal.h"
34 #include "thread.h"
35 #include "version.h"
36 
37 #include "libavutil/avassert.h"
38 #include "libavutil/buffer.h"
39 #include "libavutil/common.h"
40 #include "libavutil/cpu.h"
41 #include "libavutil/frame.h"
42 #include "libavutil/internal.h"
43 #include "libavutil/log.h"
44 #include "libavutil/mem.h"
45 #include "libavutil/opt.h"
46 #include "libavutil/thread.h"
47 
48 enum {
49  ///< Set when the thread is awaiting a packet.
51  ///< Set before the codec has called ff_thread_finish_setup().
53  /**
54  * Set when the codec calls get_buffer().
55  * State is returned to STATE_SETTING_UP afterwards.
56  */
58  /**
59  * Set when the codec calls get_format().
60  * State is returned to STATE_SETTING_UP afterwards.
61  */
63  ///< Set after the codec has called ff_thread_finish_setup().
65 };
66 
67 /**
68  * Context used by codec threads and stored in their AVCodecInternal thread_ctx.
69  */
70 typedef struct PerThreadContext {
72 
75  pthread_cond_t input_cond; ///< Used to wait for a new packet from the main thread.
76  pthread_cond_t progress_cond; ///< Used by child threads to wait for progress to change.
77  pthread_cond_t output_cond; ///< Used by the main thread to wait for frames to finish.
78 
79  pthread_mutex_t mutex; ///< Mutex used to protect the contents of the PerThreadContext.
80  pthread_mutex_t progress_mutex; ///< Mutex used to protect frame progress values and progress_cond.
81 
82  AVCodecContext *avctx; ///< Context used to decode packets passed to this thread.
83 
84  AVPacket avpkt; ///< Input packet (for decoding) or output (for encoding).
85 
86  AVFrame *frame; ///< Output frame (for decoding) or input (for encoding).
87  int got_frame; ///< The output of got_picture_ptr from the last avcodec_decode_video() call.
88  int result; ///< The result of the last codec decode/encode() call.
89 
91 
92  /**
93  * Array of frames passed to ff_thread_release_buffer().
94  * Frames are released after all threads referencing them are finished.
95  */
99 
100  AVFrame *requested_frame; ///< AVFrame the codec passed to get_buffer()
101  int requested_flags; ///< flags passed to get_buffer() for requested_frame
102 
103  const enum AVPixelFormat *available_formats; ///< Format array for get_format()
104  enum AVPixelFormat result_format; ///< get_format() result
105 
106  int die; ///< Set when the thread should exit.
107 
110 
111  atomic_int debug_threads; ///< Set if the FF_DEBUG_THREADS option is set.
113 
114 /**
115  * Context stored in the client AVCodecInternal thread_ctx.
116  */
117 typedef struct FrameThreadContext {
118  PerThreadContext *threads; ///< The contexts for each thread.
119  PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.
120 
121  pthread_mutex_t buffer_mutex; ///< Mutex used to protect get/release_buffer().
122  /**
123  * This lock is used for ensuring threads run in serial when hwaccel
124  * is used.
125  */
130 
131  int next_decoding; ///< The next context to submit a packet to.
132  int next_finished; ///< The next context to return output from.
133 
134  int delaying; /**<
135  * Set for the first N packets, where N is the number of threads.
136  * While it is set, ff_thread_en/decode_frame won't return any results.
137  */
139 
140 #define THREAD_SAFE_CALLBACKS(avctx) \
141 ((avctx)->thread_safe_callbacks || (avctx)->get_buffer2 == avcodec_default_get_buffer2)
142 
143 static void async_lock(FrameThreadContext *fctx)
144 {
146  while (fctx->async_lock)
147  pthread_cond_wait(&fctx->async_cond, &fctx->async_mutex);
148  fctx->async_lock = 1;
150 }
151 
153 {
155  av_assert0(fctx->async_lock);
156  fctx->async_lock = 0;
159 }
160 
161 /**
162  * Codec worker thread.
163  *
164  * Automatically calls ff_thread_finish_setup() if the codec does
165  * not provide an update_thread_context method, or if the codec returns
166  * before calling it.
167  */
168 static attribute_align_arg void *frame_worker_thread(void *arg)
169 {
170  PerThreadContext *p = arg;
171  AVCodecContext *avctx = p->avctx;
172  const AVCodec *codec = avctx->codec;
173 
175  while (1) {
176  while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)
178 
179  if (p->die) break;
180 
181  if (!codec->update_thread_context && THREAD_SAFE_CALLBACKS(avctx))
182  ff_thread_finish_setup(avctx);
183 
184  /* If a decoder supports hwaccel, then it must call ff_get_format().
185  * Since that call must happen before ff_thread_finish_setup(), the
186  * decoder is required to implement update_thread_context() and call
187  * ff_thread_finish_setup() manually. Therefore the above
188  * ff_thread_finish_setup() call did not happen and hwaccel_serializing
189  * cannot be true here. */
191 
192  /* if the previous thread uses hwaccel then we take the lock to ensure
193  * the threads don't run concurrently */
194  if (avctx->hwaccel) {
196  p->hwaccel_serializing = 1;
197  }
198 
199  av_frame_unref(p->frame);
200  p->got_frame = 0;
201  p->result = codec->decode(avctx, p->frame, &p->got_frame, &p->avpkt);
202 
203  if ((p->result < 0 || !p->got_frame) && p->frame->buf[0]) {
204  if (avctx->internal->allocate_progress)
205  av_log(avctx, AV_LOG_ERROR, "A frame threaded decoder did not "
206  "free the frame on failure. This is a bug, please report it.\n");
207  av_frame_unref(p->frame);
208  }
209 
210  if (atomic_load(&p->state) == STATE_SETTING_UP)
211  ff_thread_finish_setup(avctx);
212 
213  if (p->hwaccel_serializing) {
214  p->hwaccel_serializing = 0;
216  }
217 
218  if (p->async_serializing) {
219  p->async_serializing = 0;
220 
221  async_unlock(p->parent);
222  }
223 
225 
227 
231  }
233 
234  return NULL;
235 }
236 
237 /**
238  * Update the next thread's AVCodecContext with values from the reference thread's context.
239  *
240  * @param dst The destination context.
241  * @param src The source context.
242  * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
243  * @return 0 on success, negative error code on failure
244  */
246 {
247  int err = 0;
248 
249  if (dst != src && (for_user || !(src->codec_descriptor->props & AV_CODEC_PROP_INTRA_ONLY))) {
250  dst->time_base = src->time_base;
251  dst->framerate = src->framerate;
252  dst->width = src->width;
253  dst->height = src->height;
254  dst->pix_fmt = src->pix_fmt;
255  dst->sw_pix_fmt = src->sw_pix_fmt;
256 
257  dst->coded_width = src->coded_width;
258  dst->coded_height = src->coded_height;
259 
260  dst->has_b_frames = src->has_b_frames;
261  dst->idct_algo = src->idct_algo;
262 
265 
266  dst->profile = src->profile;
267  dst->level = src->level;
268 
270  dst->ticks_per_frame = src->ticks_per_frame;
271  dst->color_primaries = src->color_primaries;
272 
273  dst->color_trc = src->color_trc;
274  dst->colorspace = src->colorspace;
275  dst->color_range = src->color_range;
277 
278  dst->hwaccel = src->hwaccel;
279  dst->hwaccel_context = src->hwaccel_context;
280 
281  dst->channels = src->channels;
282  dst->sample_rate = src->sample_rate;
283  dst->sample_fmt = src->sample_fmt;
284  dst->channel_layout = src->channel_layout;
286 
287  if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||
288  (dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {
290 
291  if (src->hw_frames_ctx) {
293  if (!dst->hw_frames_ctx)
294  return AVERROR(ENOMEM);
295  }
296  }
297 
298  dst->hwaccel_flags = src->hwaccel_flags;
299  }
300 
301  if (for_user) {
302  dst->delay = src->thread_count - 1;
303 #if FF_API_CODED_FRAME
305  dst->coded_frame = src->coded_frame;
307 #endif
308  } else {
309  if (dst->codec->update_thread_context)
310  err = dst->codec->update_thread_context(dst, src);
311  }
312 
313  return err;
314 }
315 
316 /**
317  * Update the next thread's AVCodecContext with values set by the user.
318  *
319  * @param dst The destination context.
320  * @param src The source context.
321  * @return 0 on success, negative error code on failure
322  */
324 {
325 #define copy_fields(s, e) memcpy(&dst->s, &src->s, (char*)&dst->e - (char*)&dst->s);
326  dst->flags = src->flags;
327 
328  dst->draw_horiz_band= src->draw_horiz_band;
329  dst->get_buffer2 = src->get_buffer2;
330 
331  dst->opaque = src->opaque;
332  dst->debug = src->debug;
333  dst->debug_mv = src->debug_mv;
334 
335  dst->slice_flags = src->slice_flags;
336  dst->flags2 = src->flags2;
337 
338  copy_fields(skip_loop_filter, subtitle_header);
339 
340  dst->frame_number = src->frame_number;
343 
344  if (src->slice_count && src->slice_offset) {
345  if (dst->slice_count < src->slice_count) {
346  int err = av_reallocp_array(&dst->slice_offset, src->slice_count,
347  sizeof(*dst->slice_offset));
348  if (err < 0)
349  return err;
350  }
351  memcpy(dst->slice_offset, src->slice_offset,
352  src->slice_count * sizeof(*dst->slice_offset));
353  }
354  dst->slice_count = src->slice_count;
355  return 0;
356 #undef copy_fields
357 }
358 
359 /// Releases the buffers that this decoding thread was the last user of.
361 {
362  FrameThreadContext *fctx = p->parent;
363 
364  while (p->num_released_buffers > 0) {
365  AVFrame *f;
366 
368 
369  // fix extended data in case the caller screwed it up
373  f->extended_data = f->data;
374  av_frame_unref(f);
375 
377  }
378 }
379 
380 static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,
381  AVPacket *avpkt)
382 {
383  FrameThreadContext *fctx = p->parent;
384  PerThreadContext *prev_thread = fctx->prev_thread;
385  const AVCodec *codec = p->avctx->codec;
386  int ret;
387 
388  if (!avpkt->size && !(codec->capabilities & AV_CODEC_CAP_DELAY))
389  return 0;
390 
392 
393  ret = update_context_from_user(p->avctx, user_avctx);
394  if (ret) {
396  return ret;
397  }
399  (p->avctx->debug & FF_DEBUG_THREADS) != 0,
400  memory_order_relaxed);
401 
403 
404  if (prev_thread) {
405  int err;
406  if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {
407  pthread_mutex_lock(&prev_thread->progress_mutex);
408  while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
409  pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
410  pthread_mutex_unlock(&prev_thread->progress_mutex);
411  }
412 
413  err = update_context_from_thread(p->avctx, prev_thread->avctx, 0);
414  if (err) {
416  return err;
417  }
418  }
419 
420  av_packet_unref(&p->avpkt);
421  ret = av_packet_ref(&p->avpkt, avpkt);
422  if (ret < 0) {
424  av_log(p->avctx, AV_LOG_ERROR, "av_packet_ref() failed in submit_packet()\n");
425  return ret;
426  }
427 
431 
432  /*
433  * If the client doesn't have a thread-safe get_buffer(),
434  * then decoding threads call back to the main thread,
435  * and it calls back to the client here.
436  */
437 
438  if (!p->avctx->thread_safe_callbacks && (
442  int call_done = 1;
444  while (atomic_load(&p->state) == STATE_SETTING_UP)
446 
447  switch (atomic_load_explicit(&p->state, memory_order_acquire)) {
448  case STATE_GET_BUFFER:
450  break;
451  case STATE_GET_FORMAT:
453  break;
454  default:
455  call_done = 0;
456  break;
457  }
458  if (call_done) {
461  }
463  }
464  }
465 
466  fctx->prev_thread = p;
467  fctx->next_decoding++;
468 
469  return 0;
470 }
471 
473  AVFrame *picture, int *got_picture_ptr,
474  AVPacket *avpkt)
475 {
476  FrameThreadContext *fctx = avctx->internal->thread_ctx;
477  int finished = fctx->next_finished;
478  PerThreadContext *p;
479  int err;
480 
481  /* release the async lock, permitting blocked hwaccel threads to
482  * go forward while we are in this function */
483  async_unlock(fctx);
484 
485  /*
486  * Submit a packet to the next decoding thread.
487  */
488 
489  p = &fctx->threads[fctx->next_decoding];
490  err = submit_packet(p, avctx, avpkt);
491  if (err)
492  goto finish;
493 
494  /*
495  * If we're still receiving the initial packets, don't return a frame.
496  */
497 
498  if (fctx->next_decoding > (avctx->thread_count-1-(avctx->codec_id == AV_CODEC_ID_FFV1)))
499  fctx->delaying = 0;
500 
501  if (fctx->delaying) {
502  *got_picture_ptr=0;
503  if (avpkt->size) {
504  err = avpkt->size;
505  goto finish;
506  }
507  }
508 
509  /*
510  * Return the next available frame from the oldest thread.
511  * If we're at the end of the stream, then we have to skip threads that
512  * didn't output a frame/error, because we don't want to accidentally signal
513  * EOF (avpkt->size == 0 && *got_picture_ptr == 0 && err >= 0).
514  */
515 
516  do {
517  p = &fctx->threads[finished++];
518 
519  if (atomic_load(&p->state) != STATE_INPUT_READY) {
521  while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)
524  }
525 
526  av_frame_move_ref(picture, p->frame);
527  *got_picture_ptr = p->got_frame;
528  picture->pkt_dts = p->avpkt.dts;
529  err = p->result;
530 
531  /*
532  * A later call with avkpt->size == 0 may loop over all threads,
533  * including this one, searching for a frame/error to return before being
534  * stopped by the "finished != fctx->next_finished" condition.
535  * Make sure we don't mistakenly return the same frame/error again.
536  */
537  p->got_frame = 0;
538  p->result = 0;
539 
540  if (finished >= avctx->thread_count) finished = 0;
541  } while (!avpkt->size && !*got_picture_ptr && err >= 0 && finished != fctx->next_finished);
542 
543  update_context_from_thread(avctx, p->avctx, 1);
544 
545  if (fctx->next_decoding >= avctx->thread_count) fctx->next_decoding = 0;
546 
547  fctx->next_finished = finished;
548 
549  /* return the size of the consumed packet if no error occurred */
550  if (err >= 0)
551  err = avpkt->size;
552 finish:
553  async_lock(fctx);
554  return err;
555 }
556 
558 {
559  PerThreadContext *p;
560  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
561 
562  if (!progress ||
563  atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)
564  return;
565 
566  p = f->owner[field]->internal->thread_ctx;
567 
568  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
569  av_log(f->owner[field], AV_LOG_DEBUG,
570  "%p finished %d field %d\n", progress, n, field);
571 
573 
574  atomic_store_explicit(&progress[field], n, memory_order_release);
575 
578 }
579 
581 {
582  PerThreadContext *p;
583  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
584 
585  if (!progress ||
586  atomic_load_explicit(&progress[field], memory_order_acquire) >= n)
587  return;
588 
589  p = f->owner[field]->internal->thread_ctx;
590 
591  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
592  av_log(f->owner[field], AV_LOG_DEBUG,
593  "thread awaiting %d field %d from %p\n", n, field, progress);
594 
596  while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)
599 }
600 
602  PerThreadContext *p = avctx->internal->thread_ctx;
603 
604  if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
605 
606  if (avctx->hwaccel && !p->hwaccel_serializing) {
608  p->hwaccel_serializing = 1;
609  }
610 
611  /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
612  if (avctx->hwaccel &&
614  p->async_serializing = 1;
615 
616  async_lock(p->parent);
617  }
618 
621  av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
622  }
623 
625 
628 }
629 
630 /// Waits for all threads to finish.
631 static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
632 {
633  int i;
634 
635  async_unlock(fctx);
636 
637  for (i = 0; i < thread_count; i++) {
638  PerThreadContext *p = &fctx->threads[i];
639 
640  if (atomic_load(&p->state) != STATE_INPUT_READY) {
642  while (atomic_load(&p->state) != STATE_INPUT_READY)
645  }
646  p->got_frame = 0;
647  }
648 
649  async_lock(fctx);
650 }
651 
652 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
653 {
654  FrameThreadContext *fctx = avctx->internal->thread_ctx;
655  const AVCodec *codec = avctx->codec;
656  int i;
657 
658  park_frame_worker_threads(fctx, thread_count);
659 
660  if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
661  if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
662  av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
664  fctx->threads->avctx->internal->is_copy = 1;
665  }
666 
667  for (i = 0; i < thread_count; i++) {
668  PerThreadContext *p = &fctx->threads[i];
669 
671  p->die = 1;
674 
675  if (p->thread_init)
676  pthread_join(p->thread, NULL);
677  p->thread_init=0;
678 
679  if (codec->close && p->avctx)
680  codec->close(p->avctx);
681 
683  av_frame_free(&p->frame);
684  }
685 
686  for (i = 0; i < thread_count; i++) {
687  PerThreadContext *p = &fctx->threads[i];
688 
694  av_packet_unref(&p->avpkt);
696 
697  if (i && p->avctx) {
698  av_freep(&p->avctx->priv_data);
700  }
701 
702  if (p->avctx) {
703  av_freep(&p->avctx->internal);
705  }
706 
707  av_freep(&p->avctx);
708  }
709 
710  av_freep(&fctx->threads);
715 
716  av_freep(&avctx->internal->thread_ctx);
717 
718  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
719  av_opt_free(avctx->priv_data);
720  avctx->codec = NULL;
721 }
722 
724 {
725  int thread_count = avctx->thread_count;
726  const AVCodec *codec = avctx->codec;
728  FrameThreadContext *fctx;
729  int i, err = 0;
730 
731  if (!thread_count) {
732  int nb_cpus = av_cpu_count();
733 #if FF_API_DEBUG_MV
734  if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || avctx->debug_mv)
735  nb_cpus = 1;
736 #endif
737  // use number of cores + 1 as thread count if there is more than one
738  if (nb_cpus > 1)
739  thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
740  else
741  thread_count = avctx->thread_count = 1;
742  }
743 
744  if (thread_count <= 1) {
745  avctx->active_thread_type = 0;
746  return 0;
747  }
748 
749  avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));
750  if (!fctx)
751  return AVERROR(ENOMEM);
752 
753  fctx->threads = av_mallocz_array(thread_count, sizeof(PerThreadContext));
754  if (!fctx->threads) {
755  av_freep(&avctx->internal->thread_ctx);
756  return AVERROR(ENOMEM);
757  }
758 
763 
764  fctx->async_lock = 1;
765  fctx->delaying = 1;
766 
767  for (i = 0; i < thread_count; i++) {
769  PerThreadContext *p = &fctx->threads[i];
770 
776 
777  p->frame = av_frame_alloc();
778  if (!p->frame) {
779  av_freep(&copy);
780  err = AVERROR(ENOMEM);
781  goto error;
782  }
783 
784  p->parent = fctx;
785  p->avctx = copy;
786 
787  if (!copy) {
788  err = AVERROR(ENOMEM);
789  goto error;
790  }
791 
792  *copy = *src;
793 
794  copy->internal = av_malloc(sizeof(AVCodecInternal));
795  if (!copy->internal) {
796  copy->priv_data = NULL;
797  err = AVERROR(ENOMEM);
798  goto error;
799  }
800  *copy->internal = *src->internal;
801  copy->internal->thread_ctx = p;
802  copy->internal->last_pkt_props = &p->avpkt;
803 
804  if (!i) {
805  src = copy;
806 
807  if (codec->init)
808  err = codec->init(copy);
809 
810  update_context_from_thread(avctx, copy, 1);
811  } else {
812  copy->priv_data = av_malloc(codec->priv_data_size);
813  if (!copy->priv_data) {
814  err = AVERROR(ENOMEM);
815  goto error;
816  }
817  memcpy(copy->priv_data, src->priv_data, codec->priv_data_size);
818  copy->internal->is_copy = 1;
819 
820  if (codec->init_thread_copy)
821  err = codec->init_thread_copy(copy);
822  }
823 
824  if (err) goto error;
825 
826  atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);
827 
829  p->thread_init= !err;
830  if(!p->thread_init)
831  goto error;
832  }
833 
834  return 0;
835 
836 error:
837  ff_frame_thread_free(avctx, i+1);
838 
839  return err;
840 }
841 
843 {
844  int i;
845  FrameThreadContext *fctx = avctx->internal->thread_ctx;
846 
847  if (!fctx) return;
848 
850  if (fctx->prev_thread) {
851  if (fctx->prev_thread != &fctx->threads[0])
853  }
854 
855  fctx->next_decoding = fctx->next_finished = 0;
856  fctx->delaying = 1;
857  fctx->prev_thread = NULL;
858  for (i = 0; i < avctx->thread_count; i++) {
859  PerThreadContext *p = &fctx->threads[i];
860  // Make sure decode flush calls with size=0 won't return old frames
861  p->got_frame = 0;
862  av_frame_unref(p->frame);
863  p->result = 0;
864 
866 
867  if (avctx->codec->flush)
868  avctx->codec->flush(p->avctx);
869  }
870 }
871 
873 {
874  PerThreadContext *p = avctx->internal->thread_ctx;
876  (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
877  return 0;
878  }
879  return 1;
880 }
881 
883 {
884  PerThreadContext *p = avctx->internal->thread_ctx;
885  int err;
886 
887  f->owner[0] = f->owner[1] = avctx;
888 
889  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
890  return ff_get_buffer(avctx, f->f, flags);
891 
892  if (atomic_load(&p->state) != STATE_SETTING_UP &&
893  (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
894  av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
895  return -1;
896  }
897 
898  if (avctx->internal->allocate_progress) {
899  atomic_int *progress;
900  f->progress = av_buffer_alloc(2 * sizeof(*progress));
901  if (!f->progress) {
902  return AVERROR(ENOMEM);
903  }
904  progress = (atomic_int*)f->progress->data;
905 
906  atomic_init(&progress[0], -1);
907  atomic_init(&progress[1], -1);
908  }
909 
911  if (THREAD_SAFE_CALLBACKS(avctx)) {
912  err = ff_get_buffer(avctx, f->f, flags);
913  } else {
915  p->requested_frame = f->f;
916  p->requested_flags = flags;
917  atomic_store_explicit(&p->state, STATE_GET_BUFFER, memory_order_release);
919 
920  while (atomic_load(&p->state) != STATE_SETTING_UP)
922 
923  err = p->result;
924 
926 
927  }
928  if (!THREAD_SAFE_CALLBACKS(avctx) && !avctx->codec->update_thread_context)
929  ff_thread_finish_setup(avctx);
930  if (err)
932 
934 
935  return err;
936 }
937 
939 {
940  enum AVPixelFormat res;
941  PerThreadContext *p = avctx->internal->thread_ctx;
942  if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||
944  return ff_get_format(avctx, fmt);
945  if (atomic_load(&p->state) != STATE_SETTING_UP) {
946  av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");
947  return -1;
948  }
950  p->available_formats = fmt;
953 
954  while (atomic_load(&p->state) != STATE_SETTING_UP)
956 
957  res = p->result_format;
958 
960 
961  return res;
962 }
963 
965 {
966  int ret = thread_get_buffer_internal(avctx, f, flags);
967  if (ret < 0)
968  av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");
969  return ret;
970 }
971 
973 {
974  PerThreadContext *p = avctx->internal->thread_ctx;
975  FrameThreadContext *fctx;
976  AVFrame *dst, *tmp;
977  int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
978  THREAD_SAFE_CALLBACKS(avctx);
979 
980  if (!f->f || !f->f->buf[0])
981  return;
982 
983  if (avctx->debug & FF_DEBUG_BUFFERS)
984  av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
985 
987  f->owner[0] = f->owner[1] = NULL;
988 
989  if (can_direct_free) {
990  av_frame_unref(f->f);
991  return;
992  }
993 
994  fctx = p->parent;
996 
997  if (p->num_released_buffers + 1 >= INT_MAX / sizeof(*p->released_buffers))
998  goto fail;
1000  (p->num_released_buffers + 1) *
1001  sizeof(*p->released_buffers));
1002  if (!tmp)
1003  goto fail;
1004  p->released_buffers = tmp;
1005 
1006  dst = &p->released_buffers[p->num_released_buffers];
1007  av_frame_move_ref(dst, f->f);
1008 
1009  p->num_released_buffers++;
1010 
1011 fail:
1013 }
static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int flags)
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: avcodec.h:1817
int caps_internal
Internal hwaccel capabilities.
Definition: avcodec.h:3798
pthread_cond_t progress_cond
Used by child threads to wait for progress to change.
Definition: pthread_frame.c:76
#define NULL
Definition: coverity.c:32
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1371
const struct AVCodec * codec
Definition: avcodec.h:1574
AVRational framerate
Definition: avcodec.h:3105
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: avcodec.h:750
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:3126
Set when the thread is awaiting a packet.
Definition: pthread_frame.c:50
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:108
static void copy(const float *p1, float *p2, const int length)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
#define copy_fields(s, e)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
#define pthread_mutex_lock(a)
Definition: ffprobe.c:61
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:166
#define atomic_store(object, desired)
Definition: stdatomic.h:85
Context used by codec threads and stored in their AVCodecInternal thread_ctx.
Definition: pthread_frame.c:70
int av_cpu_count(void)
Definition: cpu.c:267
AVFrame * requested_frame
AVFrame the codec passed to get_buffer()
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1753
const char * fmt
Definition: avisynth_c.h:861
atomic_int state
Definition: pthread_frame.c:90
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:172
static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx, AVPacket *avpkt)
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVFrame * f
Definition: thread.h:35
Memory handling functions.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:486
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2200
int size
Definition: avcodec.h:1478
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1944
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:582
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2796
pthread_cond_t input_cond
Used to wait for a new packet from the main thread.
Definition: pthread_frame.c:75
intptr_t atomic_int
Definition: stdatomic.h:55
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:2729
#define src
Definition: vp8dsp.c:254
int profile
profile
Definition: avcodec.h:2898
enum AVPixelFormat * available_formats
Format array for get_format()
AVCodec.
Definition: avcodec.h:3481
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:140
AVPacket avpkt
Input packet (for decoding) or output (for encoding).
Definition: pthread_frame.c:84
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, &#39;draw_horiz_band&#39; is called by the libavcodec decoder to draw a horizontal band...
Definition: avcodec.h:1800
Set when the codec calls get_format().
Definition: pthread_frame.c:62
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1688
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1006
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Definition: decode.c:1159
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2233
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:2741
AVOptions.
#define f(width, name)
Definition: cbs_vp9.c:255
static attribute_align_arg void * frame_worker_thread(void *arg)
Codec worker thread.
void * thread_ctx
Definition: internal.h:163
Multithreading support functions.
#define THREAD_SAFE_CALLBACKS(avctx)
pthread_mutex_t hwaccel_mutex
This lock is used for ensuring threads run in serial when hwaccel is used.
static void finish(void)
Definition: movenc.c:345
int requested_flags
flags passed to get_buffer() for requested_frame
int next_decoding
The next context to submit a packet to.
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:148
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2789
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2207
Context stored in the client AVCodecInternal thread_ctx.
AVCodecContext * avctx
Context used to decode packets passed to this thread.
Definition: pthread_frame.c:82
#define av_log(a,...)
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:608
int die
Set when the thread should exit.
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
int slice_count
slice count
Definition: avcodec.h:1919
Libavcodec version macros.
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1855
PerThreadContext * prev_thread
The last thread submit_packet() was called on.
void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
#define atomic_load(object)
Definition: stdatomic.h:93
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:136
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2843
int capabilities
Codec capabilities.
Definition: avcodec.h:3500
int result
The result of the last codec decode/encode() call.
Definition: pthread_frame.c:88
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
simple assert() macros that are a bit more flexible than ISO C assert().
#define fail()
Definition: checkasm.h:120
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2276
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
Definition: mem.c:205
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:732
common internal API header
pthread_cond_t output_cond
Used by the main thread to wait for frames to finish.
Definition: pthread_frame.c:77
Set when the codec calls get_buffer().
Definition: pthread_frame.c:57
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2835
#define FFMIN(a, b)
Definition: common.h:96
int width
picture width / height.
Definition: avcodec.h:1738
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:2768
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3262
int priv_data_size
Definition: avcodec.h:3529
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:2179
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
Definition: os2threads.h:90
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:100
int level
level
Definition: avcodec.h:3018
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:2672
void * av_fast_realloc(void *ptr, unsigned int *size, size_t min_size)
Reallocate the given buffer if it is not large enough, otherwise do nothing.
Definition: mem.c:476
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:2722
int n
Definition: avisynth_c.h:760
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1697
pthread_t thread
Definition: pthread_frame.c:73
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:65
#define FF_DEBUG_THREADS
Definition: avcodec.h:2673
static void error(const char *err)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2824
if(ret)
int got_frame
The output of got_picture_ptr from the last avcodec_decode_video() call.
Definition: pthread_frame.c:87
static int update_context_from_user(AVCodecContext *dst, AVCodecContext *src)
Update the next thread&#39;s AVCodecContext with values set by the user.
pthread_mutex_t buffer_mutex
Mutex used to protect get/release_buffer().
AVBufferRef * progress
Definition: thread.h:39
pthread_mutex_t progress_mutex
Mutex used to protect frame progress values and progress_cond.
Definition: pthread_frame.c:80
int(* update_thread_context)(AVCodecContext *dst, const AVCodecContext *src)
Copy necessary context variables from a previous thread context to the current one.
Definition: avcodec.h:3548
static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
Definition: os2threads.h:76
pthread_cond_t async_cond
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1702
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:1573
enum AVCodecID codec_id
Definition: avcodec.h:1575
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
int sample_rate
samples per second
Definition: avcodec.h:2225
int debug
debug
Definition: avcodec.h:2650
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:1565
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
uint8_t * data
The data buffer.
Definition: buffer.h:89
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1964
int(* close)(AVCodecContext *)
Definition: avcodec.h:3580
int slice_flags
slice flags
Definition: avcodec.h:2043
AVCodecContext * owner[2]
Definition: thread.h:36
int coded_height
Definition: avcodec.h:1753
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:2380
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:2193
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:2186
enum AVPixelFormat result_format
get_format() result
int delaying
Set for the first N packets, where N is the number of threads.
int(* init_thread_copy)(AVCodecContext *)
If defined, called on thread contexts when they are created.
Definition: avcodec.h:3540
refcounted data buffer API
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
#define atomic_store_explicit(object, desired, order)
Definition: stdatomic.h:90
static void async_unlock(FrameThreadContext *fctx)
PerThreadContext * threads
The contexts for each thread.
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:151
static void async_lock(FrameThreadContext *fctx)
#define MAX_AUTO_THREADS
AVFrame * released_buffers
Array of frames passed to ff_thread_release_buffer().
Definition: pthread_frame.c:96
struct FrameThreadContext * parent
Definition: pthread_frame.c:71
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
#define flags(name, subs,...)
Definition: cbs_av1.c:561
const AVClass * priv_class
AVClass for the private context.
Definition: avcodec.h:3507
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:404
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1558
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)
Definition: avcodec.h:3579
common internal api header.
_fmutex pthread_mutex_t
Definition: os2threads.h:49
common internal and external API header
void(* flush)(AVCodecContext *)
Flush buffers.
Definition: avcodec.h:3602
int(* init)(AVCodecContext *)
Definition: avcodec.h:3564
int released_buffers_allocated
Definition: pthread_frame.c:98
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:190
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src, int for_user)
Update the next thread&#39;s AVCodecContext with values from the reference thread&#39;s context.
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:129
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2815
int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:2853
#define HWACCEL_CAP_ASYNC_SAFE
Definition: hwaccel.h:26
void * priv_data
Definition: avcodec.h:1592
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
AVFrame * frame
Output frame (for decoding) or input (for encoding).
Definition: pthread_frame.c:86
int ff_thread_can_start_frame(AVCodecContext *avctx)
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)
Definition: os2threads.h:158
int channels
number of audio channels
Definition: avcodec.h:2226
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1600
pthread_mutex_t mutex
Mutex used to protect the contents of the PerThreadContext.
Definition: pthread_frame.c:79
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1652
static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
Waits for all threads to finish.
pthread_mutex_t async_mutex
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:1935
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2256
atomic_int debug_threads
Set if the FF_DEBUG_THREADS option is set.
static void release_delayed_buffers(PerThreadContext *p)
Releases the buffers that this decoding thread was the last user of.
#define atomic_init(obj, value)
Definition: stdatomic.h:33
#define av_freep(p)
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active)...
Definition: avcodec.h:3323
int debug_mv
debug motion vectors
Definition: avcodec.h:3193
int next_finished
The next context to return output from.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
int delay
Codec delay.
Definition: avcodec.h:1721
int ff_frame_thread_init(AVCodecContext *avctx)
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:3112
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:1607
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
static uint8_t tmp[11]
Definition: aes_ctr.c:26