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 
346  dst->slice_flags = src->slice_flags;
347  dst->flags2 = src->flags2;
349 
351  dst->skip_idct = src->skip_idct;
352  dst->skip_frame = src->skip_frame;
353 
354  dst->frame_number = src->frame_number;
356 #if FF_API_THREAD_SAFE_CALLBACKS
360 #endif
361 
362  if (src->slice_count && src->slice_offset) {
363  if (dst->slice_count < src->slice_count) {
364  int err = av_reallocp_array(&dst->slice_offset, src->slice_count,
365  sizeof(*dst->slice_offset));
366  if (err < 0)
367  return err;
368  }
369  memcpy(dst->slice_offset, src->slice_offset,
370  src->slice_count * sizeof(*dst->slice_offset));
371  }
372  dst->slice_count = src->slice_count;
373  return 0;
374 }
375 
376 #if FF_API_THREAD_SAFE_CALLBACKS
377 /// Releases the buffers that this decoding thread was the last user of.
379 {
380  FrameThreadContext *fctx = p->parent;
381 
382  while (p->num_released_buffers > 0) {
383  AVFrame *f;
384 
386 
387  // fix extended data in case the caller screwed it up
391  f->extended_data = f->data;
392  av_frame_unref(f);
393 
395  }
396 }
397 #endif
398 
399 static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,
400  AVPacket *avpkt)
401 {
402  FrameThreadContext *fctx = p->parent;
403  PerThreadContext *prev_thread = fctx->prev_thread;
404  const AVCodec *codec = p->avctx->codec;
405  int ret;
406 
407  if (!avpkt->size && !(codec->capabilities & AV_CODEC_CAP_DELAY))
408  return 0;
409 
411 
412  ret = update_context_from_user(p->avctx, user_avctx);
413  if (ret) {
415  return ret;
416  }
418  (p->avctx->debug & FF_DEBUG_THREADS) != 0,
419  memory_order_relaxed);
420 
421 #if FF_API_THREAD_SAFE_CALLBACKS
423 #endif
424 
425  if (prev_thread) {
426  int err;
427  if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {
428  pthread_mutex_lock(&prev_thread->progress_mutex);
429  while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
430  pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
431  pthread_mutex_unlock(&prev_thread->progress_mutex);
432  }
433 
434  err = update_context_from_thread(p->avctx, prev_thread->avctx, 0);
435  if (err) {
437  return err;
438  }
439  }
440 
441  av_packet_unref(&p->avpkt);
442  ret = av_packet_ref(&p->avpkt, avpkt);
443  if (ret < 0) {
445  av_log(p->avctx, AV_LOG_ERROR, "av_packet_ref() failed in submit_packet()\n");
446  return ret;
447  }
448 
452 
453 #if FF_API_THREAD_SAFE_CALLBACKS
455  /*
456  * If the client doesn't have a thread-safe get_buffer(),
457  * then decoding threads call back to the main thread,
458  * and it calls back to the client here.
459  */
460 
461  if (!p->avctx->thread_safe_callbacks && (
465  int call_done = 1;
467  while (atomic_load(&p->state) == STATE_SETTING_UP)
469 
470  switch (atomic_load_explicit(&p->state, memory_order_acquire)) {
471  case STATE_GET_BUFFER:
473  break;
474  case STATE_GET_FORMAT:
476  break;
477  default:
478  call_done = 0;
479  break;
480  }
481  if (call_done) {
484  }
486  }
487  }
489 #endif
490 
491  fctx->prev_thread = p;
492  fctx->next_decoding++;
493 
494  return 0;
495 }
496 
498  AVFrame *picture, int *got_picture_ptr,
499  AVPacket *avpkt)
500 {
501  FrameThreadContext *fctx = avctx->internal->thread_ctx;
502  int finished = fctx->next_finished;
503  PerThreadContext *p;
504  int err;
505 
506  /* release the async lock, permitting blocked hwaccel threads to
507  * go forward while we are in this function */
508  async_unlock(fctx);
509 
510  /*
511  * Submit a packet to the next decoding thread.
512  */
513 
514  p = &fctx->threads[fctx->next_decoding];
515  err = submit_packet(p, avctx, avpkt);
516  if (err)
517  goto finish;
518 
519  /*
520  * If we're still receiving the initial packets, don't return a frame.
521  */
522 
523  if (fctx->next_decoding > (avctx->thread_count-1-(avctx->codec_id == AV_CODEC_ID_FFV1)))
524  fctx->delaying = 0;
525 
526  if (fctx->delaying) {
527  *got_picture_ptr=0;
528  if (avpkt->size) {
529  err = avpkt->size;
530  goto finish;
531  }
532  }
533 
534  /*
535  * Return the next available frame from the oldest thread.
536  * If we're at the end of the stream, then we have to skip threads that
537  * didn't output a frame/error, because we don't want to accidentally signal
538  * EOF (avpkt->size == 0 && *got_picture_ptr == 0 && err >= 0).
539  */
540 
541  do {
542  p = &fctx->threads[finished++];
543 
544  if (atomic_load(&p->state) != STATE_INPUT_READY) {
546  while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)
549  }
550 
551  av_frame_move_ref(picture, p->frame);
552  *got_picture_ptr = p->got_frame;
553  picture->pkt_dts = p->avpkt.dts;
554  err = p->result;
555 
556  /*
557  * A later call with avkpt->size == 0 may loop over all threads,
558  * including this one, searching for a frame/error to return before being
559  * stopped by the "finished != fctx->next_finished" condition.
560  * Make sure we don't mistakenly return the same frame/error again.
561  */
562  p->got_frame = 0;
563  p->result = 0;
564 
565  if (finished >= avctx->thread_count) finished = 0;
566  } while (!avpkt->size && !*got_picture_ptr && err >= 0 && finished != fctx->next_finished);
567 
568  update_context_from_thread(avctx, p->avctx, 1);
569 
570  if (fctx->next_decoding >= avctx->thread_count) fctx->next_decoding = 0;
571 
572  fctx->next_finished = finished;
573 
574  /* return the size of the consumed packet if no error occurred */
575  if (err >= 0)
576  err = avpkt->size;
577 finish:
578  async_lock(fctx);
579  return err;
580 }
581 
583 {
584  PerThreadContext *p;
585  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
586 
587  if (!progress ||
588  atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)
589  return;
590 
591  p = f->owner[field]->internal->thread_ctx;
592 
593  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
594  av_log(f->owner[field], AV_LOG_DEBUG,
595  "%p finished %d field %d\n", progress, n, field);
596 
598 
599  atomic_store_explicit(&progress[field], n, memory_order_release);
600 
603 }
604 
606 {
607  PerThreadContext *p;
608  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
609 
610  if (!progress ||
611  atomic_load_explicit(&progress[field], memory_order_acquire) >= n)
612  return;
613 
614  p = f->owner[field]->internal->thread_ctx;
615 
616  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
617  av_log(f->owner[field], AV_LOG_DEBUG,
618  "thread awaiting %d field %d from %p\n", n, field, progress);
619 
621  while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)
624 }
625 
627  PerThreadContext *p = avctx->internal->thread_ctx;
628 
629  if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
630 
631  if (avctx->hwaccel && !p->hwaccel_serializing) {
633  p->hwaccel_serializing = 1;
634  }
635 
636  /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
637  if (avctx->hwaccel &&
639  p->async_serializing = 1;
640 
641  async_lock(p->parent);
642  }
643 
646  av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
647  }
648 
650 
653 }
654 
655 /// Waits for all threads to finish.
656 static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
657 {
658  int i;
659 
660  async_unlock(fctx);
661 
662  for (i = 0; i < thread_count; i++) {
663  PerThreadContext *p = &fctx->threads[i];
664 
665  if (atomic_load(&p->state) != STATE_INPUT_READY) {
667  while (atomic_load(&p->state) != STATE_INPUT_READY)
670  }
671  p->got_frame = 0;
672  }
673 
674  async_lock(fctx);
675 }
676 
677 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
678 {
679  FrameThreadContext *fctx = avctx->internal->thread_ctx;
680  const AVCodec *codec = avctx->codec;
681  int i;
682 
683  park_frame_worker_threads(fctx, thread_count);
684 
685  if (fctx->prev_thread && avctx->internal->hwaccel_priv_data !=
687  if (update_context_from_thread(avctx, fctx->prev_thread->avctx, 1) < 0) {
688  av_log(avctx, AV_LOG_ERROR, "Failed to update user thread.\n");
689  }
690  }
691 
692  if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
693  if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
694  av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
696  fctx->threads->avctx->internal->is_copy = 1;
697  }
698 
699  for (i = 0; i < thread_count; i++) {
700  PerThreadContext *p = &fctx->threads[i];
701 
703  p->die = 1;
706 
707  if (p->thread_init)
708  pthread_join(p->thread, NULL);
709  p->thread_init=0;
710 
711  if (codec->close && p->avctx)
712  codec->close(p->avctx);
713 
714 #if FF_API_THREAD_SAFE_CALLBACKS
716 #endif
717  av_frame_free(&p->frame);
718  }
719 
720  for (i = 0; i < thread_count; i++) {
721  PerThreadContext *p = &fctx->threads[i];
722 
728  av_packet_unref(&p->avpkt);
729 
730 #if FF_API_THREAD_SAFE_CALLBACKS
731  for (int j = 0; j < p->released_buffers_allocated; j++)
734 #endif
735 
736  if (p->avctx) {
737  if (codec->priv_class)
739  av_freep(&p->avctx->priv_data);
740 
742  }
743 
744  if (p->avctx) {
746  av_freep(&p->avctx->internal);
748  }
749 
750  av_freep(&p->avctx);
751  }
752 
753  av_freep(&fctx->threads);
758 
759  av_freep(&avctx->internal->thread_ctx);
760 
761  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
762  av_opt_free(avctx->priv_data);
763  avctx->codec = NULL;
764 }
765 
767 {
768  int thread_count = avctx->thread_count;
769  const AVCodec *codec = avctx->codec;
771  FrameThreadContext *fctx;
772  int i, err = 0;
773 
774  if (!thread_count) {
775  int nb_cpus = av_cpu_count();
776  // use number of cores + 1 as thread count if there is more than one
777  if (nb_cpus > 1)
778  thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
779  else
780  thread_count = avctx->thread_count = 1;
781  }
782 
783  if (thread_count <= 1) {
784  avctx->active_thread_type = 0;
785  return 0;
786  }
787 
788  avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));
789  if (!fctx)
790  return AVERROR(ENOMEM);
791 
792  fctx->threads = av_mallocz_array(thread_count, sizeof(PerThreadContext));
793  if (!fctx->threads) {
794  av_freep(&avctx->internal->thread_ctx);
795  return AVERROR(ENOMEM);
796  }
797 
802 
803  fctx->async_lock = 1;
804  fctx->delaying = 1;
805 
806  if (codec->type == AVMEDIA_TYPE_VIDEO)
807  avctx->delay = src->thread_count - 1;
808 
809  for (i = 0; i < thread_count; i++) {
811  PerThreadContext *p = &fctx->threads[i];
812 
818 
819  p->frame = av_frame_alloc();
820  if (!p->frame) {
821  av_freep(&copy);
822  err = AVERROR(ENOMEM);
823  goto error;
824  }
825 
826  p->parent = fctx;
827  p->avctx = copy;
828 
829  if (!copy) {
830  err = AVERROR(ENOMEM);
831  goto error;
832  }
833 
834  *copy = *src;
835 
836  copy->internal = av_malloc(sizeof(AVCodecInternal));
837  if (!copy->internal) {
838  copy->priv_data = NULL;
839  err = AVERROR(ENOMEM);
840  goto error;
841  }
842  *copy->internal = *src->internal;
843  copy->internal->thread_ctx = p;
844  copy->internal->last_pkt_props = &p->avpkt;
845 
846  copy->delay = avctx->delay;
847 
848  if (codec->priv_data_size) {
849  copy->priv_data = av_mallocz(codec->priv_data_size);
850  if (!copy->priv_data) {
851  err = AVERROR(ENOMEM);
852  goto error;
853  }
854 
855  if (codec->priv_class) {
856  *(const AVClass **)copy->priv_data = codec->priv_class;
857  err = av_opt_copy(copy->priv_data, src->priv_data);
858  if (err < 0)
859  goto error;
860  }
861  }
862 
863  if (i)
864  copy->internal->is_copy = 1;
865 
866  if (codec->init)
867  err = codec->init(copy);
868 
869  if (err) goto error;
870 
871  if (!i)
872  update_context_from_thread(avctx, copy, 1);
873 
874  atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);
875 
877  p->thread_init= !err;
878  if(!p->thread_init)
879  goto error;
880  }
881 
882  return 0;
883 
884 error:
885  ff_frame_thread_free(avctx, i+1);
886 
887  return err;
888 }
889 
891 {
892  int i;
893  FrameThreadContext *fctx = avctx->internal->thread_ctx;
894 
895  if (!fctx) return;
896 
898  if (fctx->prev_thread) {
899  if (fctx->prev_thread != &fctx->threads[0])
901  }
902 
903  fctx->next_decoding = fctx->next_finished = 0;
904  fctx->delaying = 1;
905  fctx->prev_thread = NULL;
906  for (i = 0; i < avctx->thread_count; i++) {
907  PerThreadContext *p = &fctx->threads[i];
908  // Make sure decode flush calls with size=0 won't return old frames
909  p->got_frame = 0;
910  av_frame_unref(p->frame);
911  p->result = 0;
912 
913 #if FF_API_THREAD_SAFE_CALLBACKS
915 #endif
916 
917  if (avctx->codec->flush)
918  avctx->codec->flush(p->avctx);
919  }
920 }
921 
923 {
924  PerThreadContext *p = avctx->internal->thread_ctx;
929  || !THREAD_SAFE_CALLBACKS(avctx)
930 #endif
931  )) {
932  return 0;
933  }
935  return 1;
936 }
937 
939 {
940  PerThreadContext *p = avctx->internal->thread_ctx;
941  int err;
942 
943  f->owner[0] = f->owner[1] = avctx;
944 
945  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
946  return ff_get_buffer(avctx, f->f, flags);
947 
949  if (atomic_load(&p->state) != STATE_SETTING_UP &&
952  || !THREAD_SAFE_CALLBACKS(avctx)
953 #endif
954  )) {
956  av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
957  return -1;
958  }
959 
961  atomic_int *progress;
962  f->progress = av_buffer_alloc(2 * sizeof(*progress));
963  if (!f->progress) {
964  return AVERROR(ENOMEM);
965  }
966  progress = (atomic_int*)f->progress->data;
967 
968  atomic_init(&progress[0], -1);
969  atomic_init(&progress[1], -1);
970  }
971 
973 #if !FF_API_THREAD_SAFE_CALLBACKS
974  err = ff_get_buffer(avctx, f->f, flags);
975 #else
977  if (THREAD_SAFE_CALLBACKS(avctx)) {
978  err = ff_get_buffer(avctx, f->f, flags);
979  } else {
981  p->requested_frame = f->f;
982  p->requested_flags = flags;
983  atomic_store_explicit(&p->state, STATE_GET_BUFFER, memory_order_release);
985 
986  while (atomic_load(&p->state) != STATE_SETTING_UP)
988 
989  err = p->result;
990 
992 
993  }
994  if (!THREAD_SAFE_CALLBACKS(avctx) && !avctx->codec->update_thread_context)
995  ff_thread_finish_setup(avctx);
997 #endif
998  if (err)
1000 
1002 
1003  return err;
1004 }
1005 
1006 #if FF_API_THREAD_SAFE_CALLBACKS
1009 {
1010  enum AVPixelFormat res;
1011  PerThreadContext *p = avctx->internal->thread_ctx;
1012  if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||
1014  return ff_get_format(avctx, fmt);
1015  if (atomic_load(&p->state) != STATE_SETTING_UP) {
1016  av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");
1017  return -1;
1018  }
1020  p->available_formats = fmt;
1023 
1024  while (atomic_load(&p->state) != STATE_SETTING_UP)
1026 
1027  res = p->result_format;
1028 
1030 
1031  return res;
1032 }
1034 #endif
1035 
1037 {
1038  int ret = thread_get_buffer_internal(avctx, f, flags);
1039  if (ret < 0)
1040  av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");
1041  return ret;
1042 }
1043 
1045 {
1046 #if FF_API_THREAD_SAFE_CALLBACKS
1048  PerThreadContext *p = avctx->internal->thread_ctx;
1049  FrameThreadContext *fctx;
1050  AVFrame *dst;
1051  int ret = 0;
1052  int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
1053  THREAD_SAFE_CALLBACKS(avctx);
1055 #endif
1056 
1057  if (!f->f)
1058  return;
1059 
1060  if (avctx->debug & FF_DEBUG_BUFFERS)
1061  av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
1062 
1064  f->owner[0] = f->owner[1] = NULL;
1065 
1066 #if !FF_API_THREAD_SAFE_CALLBACKS
1067  av_frame_unref(f->f);
1068 #else
1069  // when the frame buffers are not allocated, just reset it to clean state
1070  if (can_direct_free || !f->f->buf[0]) {
1071  av_frame_unref(f->f);
1072  return;
1073  }
1074 
1075  fctx = p->parent;
1077 
1078  if (p->num_released_buffers == p->released_buffers_allocated) {
1079  AVFrame **tmp = av_realloc_array(p->released_buffers, p->released_buffers_allocated + 1,
1080  sizeof(*p->released_buffers));
1081  if (tmp) {
1082  tmp[p->released_buffers_allocated] = av_frame_alloc();
1083  p->released_buffers = tmp;
1084  }
1085 
1086  if (!tmp || !tmp[p->released_buffers_allocated]) {
1087  ret = AVERROR(ENOMEM);
1088  goto fail;
1089  }
1090  p->released_buffers_allocated++;
1091  }
1092 
1093  dst = p->released_buffers[p->num_released_buffers];
1094  av_frame_move_ref(dst, f->f);
1095 
1096  p->num_released_buffers++;
1097 
1098 fail:
1100 
1101  // make sure the frame is clean even if we fail to free it
1102  // this leaks, but it is better than crashing
1103  if (ret < 0) {
1104  av_log(avctx, AV_LOG_ERROR, "Could not queue a frame for freeing, this will leak\n");
1105  memset(f->f->buf, 0, sizeof(f->f->buf));
1106  if (f->f->extended_buf)
1107  memset(f->f->extended_buf, 0, f->f->nb_extended_buf * sizeof(*f->f->extended_buf));
1108  av_frame_unref(f->f);
1109  }
1110 #endif
1111 }
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:2540
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:1323
const struct AVCodec * codec
Definition: avcodec.h:540
AVRational framerate
Definition: avcodec.h:2062
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:63
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:150
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:1742
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:1675
int profile
profile
Definition: avcodec.h:1849
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
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1997
#define FF_API_THREAD_SAFE_CALLBACKS
Definition: version.h:154
#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:2337
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Definition: decode.c:1111
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:1687
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:141
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:152
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1735
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:76
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:255
#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:127
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:1787
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:133
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
Set when the thread is awaiting a packet.
Definition: pthread_frame.c:50
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:1779
#define FFMIN(a, b)
Definition: common.h:105
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:1714
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2209
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:1975
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1630
Set when the codec calls get_format().
Definition: pthread_frame.c:62
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:1668
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:67
#define FF_DEBUG_THREADS
Definition: avcodec.h:1631
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1768
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:1692
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:1990
int debug
debug
Definition: avcodec.h:1618
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:1902
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:139
#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:561
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:1611
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
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:171
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:1789
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:1759
int caps_internal
Internal codec capabilities.
Definition: codec.h:308
Set when the codec calls get_buffer().
Definition: pthread_frame.c:57
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:1983
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:1803
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:84
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:2270
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:2069
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:27