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 "hwconfig.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 #if FF_API_THREAD_SAFE_CALLBACKS
93  /**
94  * Array of frames passed to ff_thread_release_buffer().
95  * Frames are released after all threads referencing them are finished.
96  */
100 
101  AVFrame *requested_frame; ///< AVFrame the codec passed to get_buffer()
102  int requested_flags; ///< flags passed to get_buffer() for requested_frame
103 
104  const enum AVPixelFormat *available_formats; ///< Format array for get_format()
105  enum AVPixelFormat result_format; ///< get_format() result
106 #endif
107 
108  int die; ///< Set when the thread should exit.
109 
112 
113  atomic_int debug_threads; ///< Set if the FF_DEBUG_THREADS option is set.
115 
116 /**
117  * Context stored in the client AVCodecInternal thread_ctx.
118  */
119 typedef struct FrameThreadContext {
120  PerThreadContext *threads; ///< The contexts for each thread.
121  PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.
122 
123  pthread_mutex_t buffer_mutex; ///< Mutex used to protect get/release_buffer().
124  /**
125  * This lock is used for ensuring threads run in serial when hwaccel
126  * is used.
127  */
132 
133  int next_decoding; ///< The next context to submit a packet to.
134  int next_finished; ///< The next context to return output from.
135 
136  int delaying; /**<
137  * Set for the first N packets, where N is the number of threads.
138  * While it is set, ff_thread_en/decode_frame won't return any results.
139  */
141 
142 #if FF_API_THREAD_SAFE_CALLBACKS
143 #define THREAD_SAFE_CALLBACKS(avctx) \
144 ((avctx)->thread_safe_callbacks || (avctx)->get_buffer2 == avcodec_default_get_buffer2)
145 #endif
146 
147 static void async_lock(FrameThreadContext *fctx)
148 {
150  while (fctx->async_lock)
151  pthread_cond_wait(&fctx->async_cond, &fctx->async_mutex);
152  fctx->async_lock = 1;
154 }
155 
157 {
159  av_assert0(fctx->async_lock);
160  fctx->async_lock = 0;
163 }
164 
165 /**
166  * Codec worker thread.
167  *
168  * Automatically calls ff_thread_finish_setup() if the codec does
169  * not provide an update_thread_context method, or if the codec returns
170  * before calling it.
171  */
172 static attribute_align_arg void *frame_worker_thread(void *arg)
173 {
174  PerThreadContext *p = arg;
175  AVCodecContext *avctx = p->avctx;
176  const AVCodec *codec = avctx->codec;
177 
179  while (1) {
180  while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)
182 
183  if (p->die) break;
184 
186  if (!codec->update_thread_context
188  && THREAD_SAFE_CALLBACKS(avctx)
189 #endif
190  )
191  ff_thread_finish_setup(avctx);
193 
194  /* If a decoder supports hwaccel, then it must call ff_get_format().
195  * Since that call must happen before ff_thread_finish_setup(), the
196  * decoder is required to implement update_thread_context() and call
197  * ff_thread_finish_setup() manually. Therefore the above
198  * ff_thread_finish_setup() call did not happen and hwaccel_serializing
199  * cannot be true here. */
201 
202  /* if the previous thread uses hwaccel then we take the lock to ensure
203  * the threads don't run concurrently */
204  if (avctx->hwaccel) {
206  p->hwaccel_serializing = 1;
207  }
208 
209  av_frame_unref(p->frame);
210  p->got_frame = 0;
211  p->result = codec->decode(avctx, p->frame, &p->got_frame, &p->avpkt);
212 
213  if ((p->result < 0 || !p->got_frame) && p->frame->buf[0]) {
215  av_log(avctx, AV_LOG_ERROR, "A frame threaded decoder did not "
216  "free the frame on failure. This is a bug, please report it.\n");
217  av_frame_unref(p->frame);
218  }
219 
220  if (atomic_load(&p->state) == STATE_SETTING_UP)
221  ff_thread_finish_setup(avctx);
222 
223  if (p->hwaccel_serializing) {
224  p->hwaccel_serializing = 0;
226  }
227 
228  if (p->async_serializing) {
229  p->async_serializing = 0;
230 
231  async_unlock(p->parent);
232  }
233 
235 
237 
241  }
243 
244  return NULL;
245 }
246 
247 /**
248  * Update the next thread's AVCodecContext with values from the reference thread's context.
249  *
250  * @param dst The destination context.
251  * @param src The source context.
252  * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
253  * @return 0 on success, negative error code on failure
254  */
256 {
257  int err = 0;
258 
259  if (dst != src && (for_user || src->codec->update_thread_context)) {
260  dst->time_base = src->time_base;
261  dst->framerate = src->framerate;
262  dst->width = src->width;
263  dst->height = src->height;
264  dst->pix_fmt = src->pix_fmt;
265  dst->sw_pix_fmt = src->sw_pix_fmt;
266 
267  dst->coded_width = src->coded_width;
268  dst->coded_height = src->coded_height;
269 
270  dst->has_b_frames = src->has_b_frames;
271  dst->idct_algo = src->idct_algo;
272 
275 
276  dst->profile = src->profile;
277  dst->level = src->level;
278 
280  dst->ticks_per_frame = src->ticks_per_frame;
281  dst->color_primaries = src->color_primaries;
282 
283  dst->color_trc = src->color_trc;
284  dst->colorspace = src->colorspace;
285  dst->color_range = src->color_range;
287 
288  dst->hwaccel = src->hwaccel;
289  dst->hwaccel_context = src->hwaccel_context;
290 
291  dst->channels = src->channels;
292  dst->sample_rate = src->sample_rate;
293  dst->sample_fmt = src->sample_fmt;
294  dst->channel_layout = src->channel_layout;
296 
297  if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||
298  (dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {
300 
301  if (src->hw_frames_ctx) {
303  if (!dst->hw_frames_ctx)
304  return AVERROR(ENOMEM);
305  }
306  }
307 
308  dst->hwaccel_flags = src->hwaccel_flags;
309 
310  err = av_buffer_replace(&dst->internal->pool, src->internal->pool);
311  if (err < 0)
312  return err;
313  }
314 
315  if (for_user) {
316 #if FF_API_CODED_FRAME
318  dst->coded_frame = src->coded_frame;
320 #endif
321  } else {
322  if (dst->codec->update_thread_context)
323  err = dst->codec->update_thread_context(dst, src);
324  }
325 
326  return err;
327 }
328 
329 /**
330  * Update the next thread's AVCodecContext with values set by the user.
331  *
332  * @param dst The destination context.
333  * @param src The source context.
334  * @return 0 on success, negative error code on failure
335  */
337 {
338  dst->flags = src->flags;
339 
340  dst->draw_horiz_band= src->draw_horiz_band;
341  dst->get_buffer2 = src->get_buffer2;
342 
343  dst->opaque = src->opaque;
344  dst->debug = src->debug;
345  dst->debug_mv = src->debug_mv;
346 
347  dst->slice_flags = src->slice_flags;
348  dst->flags2 = src->flags2;
350 
352  dst->skip_idct = src->skip_idct;
353  dst->skip_frame = src->skip_frame;
354 
355  dst->frame_number = src->frame_number;
357 #if FF_API_THREAD_SAFE_CALLBACKS
361 #endif
362 
363  if (src->slice_count && src->slice_offset) {
364  if (dst->slice_count < src->slice_count) {
365  int err = av_reallocp_array(&dst->slice_offset, src->slice_count,
366  sizeof(*dst->slice_offset));
367  if (err < 0)
368  return err;
369  }
370  memcpy(dst->slice_offset, src->slice_offset,
371  src->slice_count * sizeof(*dst->slice_offset));
372  }
373  dst->slice_count = src->slice_count;
374  return 0;
375 }
376 
377 #if FF_API_THREAD_SAFE_CALLBACKS
378 /// Releases the buffers that this decoding thread was the last user of.
380 {
381  FrameThreadContext *fctx = p->parent;
382 
383  while (p->num_released_buffers > 0) {
384  AVFrame *f;
385 
387 
388  // fix extended data in case the caller screwed it up
392  f->extended_data = f->data;
393  av_frame_unref(f);
394 
396  }
397 }
398 #endif
399 
400 static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,
401  AVPacket *avpkt)
402 {
403  FrameThreadContext *fctx = p->parent;
404  PerThreadContext *prev_thread = fctx->prev_thread;
405  const AVCodec *codec = p->avctx->codec;
406  int ret;
407 
408  if (!avpkt->size && !(codec->capabilities & AV_CODEC_CAP_DELAY))
409  return 0;
410 
412 
413  ret = update_context_from_user(p->avctx, user_avctx);
414  if (ret) {
416  return ret;
417  }
419  (p->avctx->debug & FF_DEBUG_THREADS) != 0,
420  memory_order_relaxed);
421 
422 #if FF_API_THREAD_SAFE_CALLBACKS
424 #endif
425 
426  if (prev_thread) {
427  int err;
428  if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {
429  pthread_mutex_lock(&prev_thread->progress_mutex);
430  while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
431  pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
432  pthread_mutex_unlock(&prev_thread->progress_mutex);
433  }
434 
435  err = update_context_from_thread(p->avctx, prev_thread->avctx, 0);
436  if (err) {
438  return err;
439  }
440  }
441 
442  av_packet_unref(&p->avpkt);
443  ret = av_packet_ref(&p->avpkt, avpkt);
444  if (ret < 0) {
446  av_log(p->avctx, AV_LOG_ERROR, "av_packet_ref() failed in submit_packet()\n");
447  return ret;
448  }
449 
453 
454 #if FF_API_THREAD_SAFE_CALLBACKS
456  /*
457  * If the client doesn't have a thread-safe get_buffer(),
458  * then decoding threads call back to the main thread,
459  * and it calls back to the client here.
460  */
461 
462  if (!p->avctx->thread_safe_callbacks && (
466  int call_done = 1;
468  while (atomic_load(&p->state) == STATE_SETTING_UP)
470 
471  switch (atomic_load_explicit(&p->state, memory_order_acquire)) {
472  case STATE_GET_BUFFER:
474  break;
475  case STATE_GET_FORMAT:
477  break;
478  default:
479  call_done = 0;
480  break;
481  }
482  if (call_done) {
485  }
487  }
488  }
490 #endif
491 
492  fctx->prev_thread = p;
493  fctx->next_decoding++;
494 
495  return 0;
496 }
497 
499  AVFrame *picture, int *got_picture_ptr,
500  AVPacket *avpkt)
501 {
502  FrameThreadContext *fctx = avctx->internal->thread_ctx;
503  int finished = fctx->next_finished;
504  PerThreadContext *p;
505  int err;
506 
507  /* release the async lock, permitting blocked hwaccel threads to
508  * go forward while we are in this function */
509  async_unlock(fctx);
510 
511  /*
512  * Submit a packet to the next decoding thread.
513  */
514 
515  p = &fctx->threads[fctx->next_decoding];
516  err = submit_packet(p, avctx, avpkt);
517  if (err)
518  goto finish;
519 
520  /*
521  * If we're still receiving the initial packets, don't return a frame.
522  */
523 
524  if (fctx->next_decoding > (avctx->thread_count-1-(avctx->codec_id == AV_CODEC_ID_FFV1)))
525  fctx->delaying = 0;
526 
527  if (fctx->delaying) {
528  *got_picture_ptr=0;
529  if (avpkt->size) {
530  err = avpkt->size;
531  goto finish;
532  }
533  }
534 
535  /*
536  * Return the next available frame from the oldest thread.
537  * If we're at the end of the stream, then we have to skip threads that
538  * didn't output a frame/error, because we don't want to accidentally signal
539  * EOF (avpkt->size == 0 && *got_picture_ptr == 0 && err >= 0).
540  */
541 
542  do {
543  p = &fctx->threads[finished++];
544 
545  if (atomic_load(&p->state) != STATE_INPUT_READY) {
547  while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)
550  }
551 
552  av_frame_move_ref(picture, p->frame);
553  *got_picture_ptr = p->got_frame;
554  picture->pkt_dts = p->avpkt.dts;
555  err = p->result;
556 
557  /*
558  * A later call with avkpt->size == 0 may loop over all threads,
559  * including this one, searching for a frame/error to return before being
560  * stopped by the "finished != fctx->next_finished" condition.
561  * Make sure we don't mistakenly return the same frame/error again.
562  */
563  p->got_frame = 0;
564  p->result = 0;
565 
566  if (finished >= avctx->thread_count) finished = 0;
567  } while (!avpkt->size && !*got_picture_ptr && err >= 0 && finished != fctx->next_finished);
568 
569  update_context_from_thread(avctx, p->avctx, 1);
570 
571  if (fctx->next_decoding >= avctx->thread_count) fctx->next_decoding = 0;
572 
573  fctx->next_finished = finished;
574 
575  /* return the size of the consumed packet if no error occurred */
576  if (err >= 0)
577  err = avpkt->size;
578 finish:
579  async_lock(fctx);
580  return err;
581 }
582 
584 {
585  PerThreadContext *p;
586  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
587 
588  if (!progress ||
589  atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)
590  return;
591 
592  p = f->owner[field]->internal->thread_ctx;
593 
594  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
595  av_log(f->owner[field], AV_LOG_DEBUG,
596  "%p finished %d field %d\n", progress, n, field);
597 
599 
600  atomic_store_explicit(&progress[field], n, memory_order_release);
601 
604 }
605 
607 {
608  PerThreadContext *p;
609  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
610 
611  if (!progress ||
612  atomic_load_explicit(&progress[field], memory_order_acquire) >= n)
613  return;
614 
615  p = f->owner[field]->internal->thread_ctx;
616 
617  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
618  av_log(f->owner[field], AV_LOG_DEBUG,
619  "thread awaiting %d field %d from %p\n", n, field, progress);
620 
622  while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)
625 }
626 
628  PerThreadContext *p = avctx->internal->thread_ctx;
629 
630  if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
631 
632  if (avctx->hwaccel && !p->hwaccel_serializing) {
634  p->hwaccel_serializing = 1;
635  }
636 
637  /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
638  if (avctx->hwaccel &&
640  p->async_serializing = 1;
641 
642  async_lock(p->parent);
643  }
644 
647  av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
648  }
649 
651 
654 }
655 
656 /// Waits for all threads to finish.
657 static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
658 {
659  int i;
660 
661  async_unlock(fctx);
662 
663  for (i = 0; i < thread_count; i++) {
664  PerThreadContext *p = &fctx->threads[i];
665 
666  if (atomic_load(&p->state) != STATE_INPUT_READY) {
668  while (atomic_load(&p->state) != STATE_INPUT_READY)
671  }
672  p->got_frame = 0;
673  }
674 
675  async_lock(fctx);
676 }
677 
678 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
679 {
680  FrameThreadContext *fctx = avctx->internal->thread_ctx;
681  const AVCodec *codec = avctx->codec;
682  int i;
683 
684  park_frame_worker_threads(fctx, thread_count);
685 
686  if (fctx->prev_thread && avctx->internal->hwaccel_priv_data !=
688  if (update_context_from_thread(avctx, fctx->prev_thread->avctx, 1) < 0) {
689  av_log(avctx, AV_LOG_ERROR, "Failed to update user thread.\n");
690  }
691  }
692 
693  if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
694  if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
695  av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
697  fctx->threads->avctx->internal->is_copy = 1;
698  }
699 
700  for (i = 0; i < thread_count; i++) {
701  PerThreadContext *p = &fctx->threads[i];
702 
704  p->die = 1;
707 
708  if (p->thread_init)
709  pthread_join(p->thread, NULL);
710  p->thread_init=0;
711 
712  if (codec->close && p->avctx)
713  codec->close(p->avctx);
714 
715 #if FF_API_THREAD_SAFE_CALLBACKS
717 #endif
718  av_frame_free(&p->frame);
719  }
720 
721  for (i = 0; i < thread_count; i++) {
722  PerThreadContext *p = &fctx->threads[i];
723 
729  av_packet_unref(&p->avpkt);
730 
731 #if FF_API_THREAD_SAFE_CALLBACKS
732  for (int j = 0; j < p->released_buffers_allocated; j++)
735 #endif
736 
737  if (p->avctx) {
738  if (codec->priv_class)
740  av_freep(&p->avctx->priv_data);
741 
743  }
744 
745  if (p->avctx) {
747  av_freep(&p->avctx->internal);
749  }
750 
751  av_freep(&p->avctx);
752  }
753 
754  av_freep(&fctx->threads);
759 
760  av_freep(&avctx->internal->thread_ctx);
761 
762  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
763  av_opt_free(avctx->priv_data);
764  avctx->codec = NULL;
765 }
766 
768 {
769  int thread_count = avctx->thread_count;
770  const AVCodec *codec = avctx->codec;
772  FrameThreadContext *fctx;
773  int i, err = 0;
774 
775  if (!thread_count) {
776  int nb_cpus = av_cpu_count();
777 #if FF_API_DEBUG_MV
778  if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || avctx->debug_mv)
779  nb_cpus = 1;
780 #endif
781  // use number of cores + 1 as thread count if there is more than one
782  if (nb_cpus > 1)
783  thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
784  else
785  thread_count = avctx->thread_count = 1;
786  }
787 
788  if (thread_count <= 1) {
789  avctx->active_thread_type = 0;
790  return 0;
791  }
792 
793  avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));
794  if (!fctx)
795  return AVERROR(ENOMEM);
796 
797  fctx->threads = av_mallocz_array(thread_count, sizeof(PerThreadContext));
798  if (!fctx->threads) {
799  av_freep(&avctx->internal->thread_ctx);
800  return AVERROR(ENOMEM);
801  }
802 
807 
808  fctx->async_lock = 1;
809  fctx->delaying = 1;
810 
811  if (codec->type == AVMEDIA_TYPE_VIDEO)
812  avctx->delay = src->thread_count - 1;
813 
814  for (i = 0; i < thread_count; i++) {
816  PerThreadContext *p = &fctx->threads[i];
817 
823 
824  p->frame = av_frame_alloc();
825  if (!p->frame) {
826  av_freep(&copy);
827  err = AVERROR(ENOMEM);
828  goto error;
829  }
830 
831  p->parent = fctx;
832  p->avctx = copy;
833 
834  if (!copy) {
835  err = AVERROR(ENOMEM);
836  goto error;
837  }
838 
839  *copy = *src;
840 
841  copy->internal = av_malloc(sizeof(AVCodecInternal));
842  if (!copy->internal) {
843  copy->priv_data = NULL;
844  err = AVERROR(ENOMEM);
845  goto error;
846  }
847  *copy->internal = *src->internal;
848  copy->internal->thread_ctx = p;
849  copy->internal->last_pkt_props = &p->avpkt;
850 
851  copy->delay = avctx->delay;
852 
853  if (codec->priv_data_size) {
854  copy->priv_data = av_mallocz(codec->priv_data_size);
855  if (!copy->priv_data) {
856  err = AVERROR(ENOMEM);
857  goto error;
858  }
859 
860  if (codec->priv_class) {
861  *(const AVClass **)copy->priv_data = codec->priv_class;
862  err = av_opt_copy(copy->priv_data, src->priv_data);
863  if (err < 0)
864  goto error;
865  }
866  }
867 
868  if (i)
869  copy->internal->is_copy = 1;
870 
871  if (codec->init)
872  err = codec->init(copy);
873 
874  if (err) goto error;
875 
876  if (!i)
877  update_context_from_thread(avctx, copy, 1);
878 
879  atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);
880 
882  p->thread_init= !err;
883  if(!p->thread_init)
884  goto error;
885  }
886 
887  return 0;
888 
889 error:
890  ff_frame_thread_free(avctx, i+1);
891 
892  return err;
893 }
894 
896 {
897  int i;
898  FrameThreadContext *fctx = avctx->internal->thread_ctx;
899 
900  if (!fctx) return;
901 
903  if (fctx->prev_thread) {
904  if (fctx->prev_thread != &fctx->threads[0])
906  }
907 
908  fctx->next_decoding = fctx->next_finished = 0;
909  fctx->delaying = 1;
910  fctx->prev_thread = NULL;
911  for (i = 0; i < avctx->thread_count; i++) {
912  PerThreadContext *p = &fctx->threads[i];
913  // Make sure decode flush calls with size=0 won't return old frames
914  p->got_frame = 0;
915  av_frame_unref(p->frame);
916  p->result = 0;
917 
918 #if FF_API_THREAD_SAFE_CALLBACKS
920 #endif
921 
922  if (avctx->codec->flush)
923  avctx->codec->flush(p->avctx);
924  }
925 }
926 
928 {
929  PerThreadContext *p = avctx->internal->thread_ctx;
934  || !THREAD_SAFE_CALLBACKS(avctx)
935 #endif
936  )) {
937  return 0;
938  }
940  return 1;
941 }
942 
944 {
945  PerThreadContext *p = avctx->internal->thread_ctx;
946  int err;
947 
948  f->owner[0] = f->owner[1] = avctx;
949 
950  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
951  return ff_get_buffer(avctx, f->f, flags);
952 
954  if (atomic_load(&p->state) != STATE_SETTING_UP &&
957  || !THREAD_SAFE_CALLBACKS(avctx)
958 #endif
959  )) {
961  av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
962  return -1;
963  }
964 
966  atomic_int *progress;
967  f->progress = av_buffer_alloc(2 * sizeof(*progress));
968  if (!f->progress) {
969  return AVERROR(ENOMEM);
970  }
971  progress = (atomic_int*)f->progress->data;
972 
973  atomic_init(&progress[0], -1);
974  atomic_init(&progress[1], -1);
975  }
976 
978 #if !FF_API_THREAD_SAFE_CALLBACKS
979  err = ff_get_buffer(avctx, f->f, flags);
980 #else
982  if (THREAD_SAFE_CALLBACKS(avctx)) {
983  err = ff_get_buffer(avctx, f->f, flags);
984  } else {
986  p->requested_frame = f->f;
987  p->requested_flags = flags;
988  atomic_store_explicit(&p->state, STATE_GET_BUFFER, memory_order_release);
990 
991  while (atomic_load(&p->state) != STATE_SETTING_UP)
993 
994  err = p->result;
995 
997 
998  }
999  if (!THREAD_SAFE_CALLBACKS(avctx) && !avctx->codec->update_thread_context)
1000  ff_thread_finish_setup(avctx);
1002 #endif
1003  if (err)
1005 
1007 
1008  return err;
1009 }
1010 
1011 #if FF_API_THREAD_SAFE_CALLBACKS
1014 {
1015  enum AVPixelFormat res;
1016  PerThreadContext *p = avctx->internal->thread_ctx;
1017  if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||
1019  return ff_get_format(avctx, fmt);
1020  if (atomic_load(&p->state) != STATE_SETTING_UP) {
1021  av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");
1022  return -1;
1023  }
1025  p->available_formats = fmt;
1028 
1029  while (atomic_load(&p->state) != STATE_SETTING_UP)
1031 
1032  res = p->result_format;
1033 
1035 
1036  return res;
1037 }
1039 #endif
1040 
1042 {
1043  int ret = thread_get_buffer_internal(avctx, f, flags);
1044  if (ret < 0)
1045  av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");
1046  return ret;
1047 }
1048 
1050 {
1051 #if FF_API_THREAD_SAFE_CALLBACKS
1053  PerThreadContext *p = avctx->internal->thread_ctx;
1054  FrameThreadContext *fctx;
1055  AVFrame *dst;
1056  int ret = 0;
1057  int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
1058  THREAD_SAFE_CALLBACKS(avctx);
1060 #endif
1061 
1062  if (!f->f)
1063  return;
1064 
1065  if (avctx->debug & FF_DEBUG_BUFFERS)
1066  av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
1067 
1069  f->owner[0] = f->owner[1] = NULL;
1070 
1071 #if !FF_API_THREAD_SAFE_CALLBACKS
1072  av_frame_unref(f->f);
1073 #else
1074  // when the frame buffers are not allocated, just reset it to clean state
1075  if (can_direct_free || !f->f->buf[0]) {
1076  av_frame_unref(f->f);
1077  return;
1078  }
1079 
1080  fctx = p->parent;
1082 
1083  if (p->num_released_buffers == p->released_buffers_allocated) {
1084  AVFrame **tmp = av_realloc_array(p->released_buffers, p->released_buffers_allocated + 1,
1085  sizeof(*p->released_buffers));
1086  if (tmp) {
1087  tmp[p->released_buffers_allocated] = av_frame_alloc();
1088  p->released_buffers = tmp;
1089  }
1090 
1091  if (!tmp || !tmp[p->released_buffers_allocated]) {
1092  ret = AVERROR(ENOMEM);
1093  goto fail;
1094  }
1095  p->released_buffers_allocated++;
1096  }
1097 
1098  dst = p->released_buffers[p->num_released_buffers];
1099  av_frame_move_ref(dst, f->f);
1100 
1101  p->num_released_buffers++;
1102 
1103 fail:
1105 
1106  // make sure the frame is clean even if we fail to free it
1107  // this leaks, but it is better than crashing
1108  if (ret < 0) {
1109  av_log(avctx, AV_LOG_ERROR, "Could not queue a frame for freeing, this will leak\n");
1110  memset(f->f->buf, 0, sizeof(f->f->buf));
1111  if (f->f->extended_buf)
1112  memset(f->f->extended_buf, 0, f->f->nb_extended_buf * sizeof(*f->f->extended_buf));
1113  av_frame_unref(f->f);
1114  }
1115 #endif
1116 }
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:783
int caps_internal
Internal hwaccel capabilities.
Definition: avcodec.h:2571
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:1299
const struct AVCodec * codec
Definition: avcodec.h:540
AVRational framerate
Definition: avcodec.h:2081
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
#define pthread_mutex_lock(a)
Definition: ffprobe.c:62
Set when the thread is awaiting a packet.
Definition: pthread_frame.c:50
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
#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:275
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:719
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:147
static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx, AVPacket *avpkt)
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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:505
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:303
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1166
int nb_extended_buf
Number of elements in extended_buf.
Definition: frame.h:523
int size
Definition: packet.h:364
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:910
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:741
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:582
enum AVMediaType type
Definition: codec.h:203
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1762
static void error(const char *err)
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:1695
int profile
profile
Definition: avcodec.h:1871
enum AVPixelFormat * available_formats
Format array for get_format()
AVCodec.
Definition: codec.h:190
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:144
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:766
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:654
Set when the codec calls get_buffer().
Definition: pthread_frame.c:57
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2016
#define FF_API_THREAD_SAFE_CALLBACKS
Definition: version.h:151
#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: codec.h:75
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
Definition: avcodec.h:2366
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Definition: decode.c:1087
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1199
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:1707
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:138
Multithreading support functions.
#define THREAD_SAFE_CALLBACKS(avctx)
Set when the codec calls get_format().
Definition: pthread_frame.c:62
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:152
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1755
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...
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1173
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,...)
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:75
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:615
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:885
Libavcodec version macros.
#define src
Definition: vp8dsp.c:254
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:821
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:126
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
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:1809
int capabilities
Codec capabilities.
Definition: codec.h:209
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:215
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:611
simple assert() macros that are a bit more flexible than ISO C assert().
#define fail()
Definition: checkasm.h:123
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1242
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:206
common internal API header
#define HWACCEL_CAP_ASYNC_SAFE
Definition: hwconfig.h:26
pthread_cond_t output_cond
Used by the main thread to wait for frames to finish.
Definition: pthread_frame.c:77
int(* update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy necessary context variables from a previous thread context to the current one.
Definition: codec.h:253
AVFrame ** released_buffers
Array of frames passed to ff_thread_release_buffer().
Definition: pthread_frame.c:97
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1801
#define FFMIN(a, b)
Definition: common.h:96
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers, this array will hold all the references which cannot fit into AVFrame.buf.
Definition: frame.h:519
int width
picture width / height.
Definition: avcodec.h:704
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1734
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2238
int priv_data_size
Definition: codec.h:238
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:1145
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
Definition: os2threads.h:94
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
int level
level
Definition: avcodec.h:1994
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1638
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:1688
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:663
pthread_t thread
Definition: pthread_frame.c:73
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:66
#define FF_DEBUG_THREADS
Definition: avcodec.h:1639
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1790
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
static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
Definition: os2threads.h:80
int(* decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt)
Definition: codec.h:284
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:1668
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:539
enum AVCodecID codec_id
Definition: avcodec.h:541
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:1191
enum AVDiscard skip_idct
Skip IDCT/dequantization for selected frames.
Definition: avcodec.h:2009
int debug
debug
Definition: avcodec.h:1616
main external API structure.
Definition: avcodec.h:531
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:606
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:1879
int slice_flags
slice flags
Definition: avcodec.h:1009
AVCodecContext * owner[2]
Definition: thread.h:36
int coded_height
Definition: avcodec.h:719
Describe the class of an AVClass context structure.
Definition: log.h:67
int(* init)(struct AVCodecContext *)
Definition: codec.h:269
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:1346
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1159
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1152
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
enum AVPixelFormat result_format
get_format() result
int delaying
Set for the first N packets, where N is the number of threads.
refcounted data buffer API
#define atomic_store_explicit(object, desired, order)
Definition: stdatomic.h:90
static void async_unlock(FrameThreadContext *fctx)
PerThreadContext * threads
The contexts for each thread.
static void async_lock(FrameThreadContext *fctx)
AVBufferRef * pool
Definition: internal.h:136
#define MAX_AUTO_THREADS
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:560
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:216
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:423
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1610
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
_fmutex pthread_mutex_t
Definition: os2threads.h:53
common internal and external API header
int released_buffers_allocated
Definition: pthread_frame.c:99
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:169
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.
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1788
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:133
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1781
int caps_internal
Internal codec capabilities.
Definition: codec.h:308
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:2002
attribute_deprecated int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:1825
void * priv_data
Definition: avcodec.h:558
int(* close)(struct AVCodecContext *)
Definition: codec.h:285
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:162
int channels
number of audio channels
Definition: avcodec.h:1192
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:566
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:618
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: packet.h:362
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:901
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1222
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:2299
int debug_mv
debug motion vectors
Definition: avcodec.h:2169
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:361
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
int delay
Codec delay.
Definition: avcodec.h:687
int ff_frame_thread_init(AVCodecContext *avctx)
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2088
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:573
int i
Definition: input.c:407
int av_buffer_replace(AVBufferRef **pdst, AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:219
FF_DISABLE_DEPRECATION_WARNINGS enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
static uint8_t tmp[11]
Definition: aes_ctr.c:26