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  /**
93  * Array of frames passed to ff_thread_release_buffer().
94  * Frames are released after all threads referencing them are finished.
95  */
99 
100  AVFrame *requested_frame; ///< AVFrame the codec passed to get_buffer()
101  int requested_flags; ///< flags passed to get_buffer() for requested_frame
102 
103  const enum AVPixelFormat *available_formats; ///< Format array for get_format()
104  enum AVPixelFormat result_format; ///< get_format() result
105 
106  int die; ///< Set when the thread should exit.
107 
110 
111  atomic_int debug_threads; ///< Set if the FF_DEBUG_THREADS option is set.
113 
114 /**
115  * Context stored in the client AVCodecInternal thread_ctx.
116  */
117 typedef struct FrameThreadContext {
118  PerThreadContext *threads; ///< The contexts for each thread.
119  PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.
120 
121  pthread_mutex_t buffer_mutex; ///< Mutex used to protect get/release_buffer().
122  /**
123  * This lock is used for ensuring threads run in serial when hwaccel
124  * is used.
125  */
130 
131  int next_decoding; ///< The next context to submit a packet to.
132  int next_finished; ///< The next context to return output from.
133 
134  int delaying; /**<
135  * Set for the first N packets, where N is the number of threads.
136  * While it is set, ff_thread_en/decode_frame won't return any results.
137  */
139 
140 #define THREAD_SAFE_CALLBACKS(avctx) \
141 ((avctx)->thread_safe_callbacks || (avctx)->get_buffer2 == avcodec_default_get_buffer2)
142 
143 static void async_lock(FrameThreadContext *fctx)
144 {
146  while (fctx->async_lock)
147  pthread_cond_wait(&fctx->async_cond, &fctx->async_mutex);
148  fctx->async_lock = 1;
150 }
151 
153 {
155  av_assert0(fctx->async_lock);
156  fctx->async_lock = 0;
159 }
160 
161 /**
162  * Codec worker thread.
163  *
164  * Automatically calls ff_thread_finish_setup() if the codec does
165  * not provide an update_thread_context method, or if the codec returns
166  * before calling it.
167  */
168 static attribute_align_arg void *frame_worker_thread(void *arg)
169 {
170  PerThreadContext *p = arg;
171  AVCodecContext *avctx = p->avctx;
172  const AVCodec *codec = avctx->codec;
173 
175  while (1) {
176  while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)
178 
179  if (p->die) break;
180 
181  if (!codec->update_thread_context && THREAD_SAFE_CALLBACKS(avctx))
182  ff_thread_finish_setup(avctx);
183 
184  /* If a decoder supports hwaccel, then it must call ff_get_format().
185  * Since that call must happen before ff_thread_finish_setup(), the
186  * decoder is required to implement update_thread_context() and call
187  * ff_thread_finish_setup() manually. Therefore the above
188  * ff_thread_finish_setup() call did not happen and hwaccel_serializing
189  * cannot be true here. */
191 
192  /* if the previous thread uses hwaccel then we take the lock to ensure
193  * the threads don't run concurrently */
194  if (avctx->hwaccel) {
196  p->hwaccel_serializing = 1;
197  }
198 
199  av_frame_unref(p->frame);
200  p->got_frame = 0;
201  p->result = codec->decode(avctx, p->frame, &p->got_frame, &p->avpkt);
202 
203  if ((p->result < 0 || !p->got_frame) && p->frame->buf[0]) {
205  av_log(avctx, AV_LOG_ERROR, "A frame threaded decoder did not "
206  "free the frame on failure. This is a bug, please report it.\n");
207  av_frame_unref(p->frame);
208  }
209 
210  if (atomic_load(&p->state) == STATE_SETTING_UP)
211  ff_thread_finish_setup(avctx);
212 
213  if (p->hwaccel_serializing) {
214  p->hwaccel_serializing = 0;
216  }
217 
218  if (p->async_serializing) {
219  p->async_serializing = 0;
220 
221  async_unlock(p->parent);
222  }
223 
225 
227 
231  }
233 
234  return NULL;
235 }
236 
237 /**
238  * Update the next thread's AVCodecContext with values from the reference thread's context.
239  *
240  * @param dst The destination context.
241  * @param src The source context.
242  * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
243  * @return 0 on success, negative error code on failure
244  */
246 {
247  int err = 0;
248 
249  if (dst != src && (for_user || src->codec->update_thread_context)) {
250  dst->time_base = src->time_base;
251  dst->framerate = src->framerate;
252  dst->width = src->width;
253  dst->height = src->height;
254  dst->pix_fmt = src->pix_fmt;
255  dst->sw_pix_fmt = src->sw_pix_fmt;
256 
257  dst->coded_width = src->coded_width;
258  dst->coded_height = src->coded_height;
259 
260  dst->has_b_frames = src->has_b_frames;
261  dst->idct_algo = src->idct_algo;
262 
265 
266  dst->profile = src->profile;
267  dst->level = src->level;
268 
270  dst->ticks_per_frame = src->ticks_per_frame;
271  dst->color_primaries = src->color_primaries;
272 
273  dst->color_trc = src->color_trc;
274  dst->colorspace = src->colorspace;
275  dst->color_range = src->color_range;
277 
278  dst->hwaccel = src->hwaccel;
279  dst->hwaccel_context = src->hwaccel_context;
280 
281  dst->channels = src->channels;
282  dst->sample_rate = src->sample_rate;
283  dst->sample_fmt = src->sample_fmt;
284  dst->channel_layout = src->channel_layout;
286 
287  if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||
288  (dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {
290 
291  if (src->hw_frames_ctx) {
293  if (!dst->hw_frames_ctx)
294  return AVERROR(ENOMEM);
295  }
296  }
297 
298  dst->hwaccel_flags = src->hwaccel_flags;
299 
300  err = av_buffer_replace(&dst->internal->pool, src->internal->pool);
301  if (err < 0)
302  return err;
303  }
304 
305  if (for_user) {
306 #if FF_API_CODED_FRAME
308  dst->coded_frame = src->coded_frame;
310 #endif
311  } else {
312  if (dst->codec->update_thread_context)
313  err = dst->codec->update_thread_context(dst, src);
314  }
315 
316  return err;
317 }
318 
319 /**
320  * Update the next thread's AVCodecContext with values set by the user.
321  *
322  * @param dst The destination context.
323  * @param src The source context.
324  * @return 0 on success, negative error code on failure
325  */
327 {
328  dst->flags = src->flags;
329 
330  dst->draw_horiz_band= src->draw_horiz_band;
331  dst->get_buffer2 = src->get_buffer2;
332 
333  dst->opaque = src->opaque;
334  dst->debug = src->debug;
335  dst->debug_mv = src->debug_mv;
336 
337  dst->slice_flags = src->slice_flags;
338  dst->flags2 = src->flags2;
340 
342  dst->skip_idct = src->skip_idct;
343  dst->skip_frame = src->skip_frame;
344 
345  dst->frame_number = src->frame_number;
348 
349  if (src->slice_count && src->slice_offset) {
350  if (dst->slice_count < src->slice_count) {
351  int err = av_reallocp_array(&dst->slice_offset, src->slice_count,
352  sizeof(*dst->slice_offset));
353  if (err < 0)
354  return err;
355  }
356  memcpy(dst->slice_offset, src->slice_offset,
357  src->slice_count * sizeof(*dst->slice_offset));
358  }
359  dst->slice_count = src->slice_count;
360  return 0;
361 }
362 
363 /// Releases the buffers that this decoding thread was the last user of.
365 {
366  FrameThreadContext *fctx = p->parent;
367 
368  while (p->num_released_buffers > 0) {
369  AVFrame *f;
370 
372 
373  // fix extended data in case the caller screwed it up
377  f->extended_data = f->data;
378  av_frame_unref(f);
379 
381  }
382 }
383 
384 static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,
385  AVPacket *avpkt)
386 {
387  FrameThreadContext *fctx = p->parent;
388  PerThreadContext *prev_thread = fctx->prev_thread;
389  const AVCodec *codec = p->avctx->codec;
390  int ret;
391 
392  if (!avpkt->size && !(codec->capabilities & AV_CODEC_CAP_DELAY))
393  return 0;
394 
396 
397  ret = update_context_from_user(p->avctx, user_avctx);
398  if (ret) {
400  return ret;
401  }
403  (p->avctx->debug & FF_DEBUG_THREADS) != 0,
404  memory_order_relaxed);
405 
407 
408  if (prev_thread) {
409  int err;
410  if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {
411  pthread_mutex_lock(&prev_thread->progress_mutex);
412  while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
413  pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
414  pthread_mutex_unlock(&prev_thread->progress_mutex);
415  }
416 
417  err = update_context_from_thread(p->avctx, prev_thread->avctx, 0);
418  if (err) {
420  return err;
421  }
422  }
423 
424  av_packet_unref(&p->avpkt);
425  ret = av_packet_ref(&p->avpkt, avpkt);
426  if (ret < 0) {
428  av_log(p->avctx, AV_LOG_ERROR, "av_packet_ref() failed in submit_packet()\n");
429  return ret;
430  }
431 
435 
436  /*
437  * If the client doesn't have a thread-safe get_buffer(),
438  * then decoding threads call back to the main thread,
439  * and it calls back to the client here.
440  */
441 
442  if (!p->avctx->thread_safe_callbacks && (
446  int call_done = 1;
448  while (atomic_load(&p->state) == STATE_SETTING_UP)
450 
451  switch (atomic_load_explicit(&p->state, memory_order_acquire)) {
452  case STATE_GET_BUFFER:
454  break;
455  case STATE_GET_FORMAT:
457  break;
458  default:
459  call_done = 0;
460  break;
461  }
462  if (call_done) {
465  }
467  }
468  }
469 
470  fctx->prev_thread = p;
471  fctx->next_decoding++;
472 
473  return 0;
474 }
475 
477  AVFrame *picture, int *got_picture_ptr,
478  AVPacket *avpkt)
479 {
480  FrameThreadContext *fctx = avctx->internal->thread_ctx;
481  int finished = fctx->next_finished;
482  PerThreadContext *p;
483  int err;
484 
485  /* release the async lock, permitting blocked hwaccel threads to
486  * go forward while we are in this function */
487  async_unlock(fctx);
488 
489  /*
490  * Submit a packet to the next decoding thread.
491  */
492 
493  p = &fctx->threads[fctx->next_decoding];
494  err = submit_packet(p, avctx, avpkt);
495  if (err)
496  goto finish;
497 
498  /*
499  * If we're still receiving the initial packets, don't return a frame.
500  */
501 
502  if (fctx->next_decoding > (avctx->thread_count-1-(avctx->codec_id == AV_CODEC_ID_FFV1)))
503  fctx->delaying = 0;
504 
505  if (fctx->delaying) {
506  *got_picture_ptr=0;
507  if (avpkt->size) {
508  err = avpkt->size;
509  goto finish;
510  }
511  }
512 
513  /*
514  * Return the next available frame from the oldest thread.
515  * If we're at the end of the stream, then we have to skip threads that
516  * didn't output a frame/error, because we don't want to accidentally signal
517  * EOF (avpkt->size == 0 && *got_picture_ptr == 0 && err >= 0).
518  */
519 
520  do {
521  p = &fctx->threads[finished++];
522 
523  if (atomic_load(&p->state) != STATE_INPUT_READY) {
525  while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)
528  }
529 
530  av_frame_move_ref(picture, p->frame);
531  *got_picture_ptr = p->got_frame;
532  picture->pkt_dts = p->avpkt.dts;
533  err = p->result;
534 
535  /*
536  * A later call with avkpt->size == 0 may loop over all threads,
537  * including this one, searching for a frame/error to return before being
538  * stopped by the "finished != fctx->next_finished" condition.
539  * Make sure we don't mistakenly return the same frame/error again.
540  */
541  p->got_frame = 0;
542  p->result = 0;
543 
544  if (finished >= avctx->thread_count) finished = 0;
545  } while (!avpkt->size && !*got_picture_ptr && err >= 0 && finished != fctx->next_finished);
546 
547  update_context_from_thread(avctx, p->avctx, 1);
548 
549  if (fctx->next_decoding >= avctx->thread_count) fctx->next_decoding = 0;
550 
551  fctx->next_finished = finished;
552 
553  /* return the size of the consumed packet if no error occurred */
554  if (err >= 0)
555  err = avpkt->size;
556 finish:
557  async_lock(fctx);
558  return err;
559 }
560 
562 {
563  PerThreadContext *p;
564  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
565 
566  if (!progress ||
567  atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)
568  return;
569 
570  p = f->owner[field]->internal->thread_ctx;
571 
572  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
573  av_log(f->owner[field], AV_LOG_DEBUG,
574  "%p finished %d field %d\n", progress, n, field);
575 
577 
578  atomic_store_explicit(&progress[field], n, memory_order_release);
579 
582 }
583 
585 {
586  PerThreadContext *p;
587  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
588 
589  if (!progress ||
590  atomic_load_explicit(&progress[field], memory_order_acquire) >= n)
591  return;
592 
593  p = f->owner[field]->internal->thread_ctx;
594 
595  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
596  av_log(f->owner[field], AV_LOG_DEBUG,
597  "thread awaiting %d field %d from %p\n", n, field, progress);
598 
600  while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)
603 }
604 
606  PerThreadContext *p = avctx->internal->thread_ctx;
607 
608  if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
609 
610  if (avctx->hwaccel && !p->hwaccel_serializing) {
612  p->hwaccel_serializing = 1;
613  }
614 
615  /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
616  if (avctx->hwaccel &&
618  p->async_serializing = 1;
619 
620  async_lock(p->parent);
621  }
622 
625  av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
626  }
627 
629 
632 }
633 
634 /// Waits for all threads to finish.
635 static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
636 {
637  int i;
638 
639  async_unlock(fctx);
640 
641  for (i = 0; i < thread_count; i++) {
642  PerThreadContext *p = &fctx->threads[i];
643 
644  if (atomic_load(&p->state) != STATE_INPUT_READY) {
646  while (atomic_load(&p->state) != STATE_INPUT_READY)
649  }
650  p->got_frame = 0;
651  }
652 
653  async_lock(fctx);
654 }
655 
656 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
657 {
658  FrameThreadContext *fctx = avctx->internal->thread_ctx;
659  const AVCodec *codec = avctx->codec;
660  int i, j;
661 
662  park_frame_worker_threads(fctx, thread_count);
663 
664  if (fctx->prev_thread && avctx->internal->hwaccel_priv_data !=
666  if (update_context_from_thread(avctx, fctx->prev_thread->avctx, 1) < 0) {
667  av_log(avctx, AV_LOG_ERROR, "Failed to update user thread.\n");
668  }
669  }
670 
671  if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
672  if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
673  av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
675  fctx->threads->avctx->internal->is_copy = 1;
676  }
677 
678  for (i = 0; i < thread_count; i++) {
679  PerThreadContext *p = &fctx->threads[i];
680 
682  p->die = 1;
685 
686  if (p->thread_init)
687  pthread_join(p->thread, NULL);
688  p->thread_init=0;
689 
690  if (codec->close && p->avctx)
691  codec->close(p->avctx);
692 
694  av_frame_free(&p->frame);
695  }
696 
697  for (i = 0; i < thread_count; i++) {
698  PerThreadContext *p = &fctx->threads[i];
699 
705  av_packet_unref(&p->avpkt);
706 
707  for (j = 0; j < p->released_buffers_allocated; j++)
710 
711  if (p->avctx) {
712  if (codec->priv_class)
714  av_freep(&p->avctx->priv_data);
715 
717  }
718 
719  if (p->avctx) {
721  av_freep(&p->avctx->internal);
723  }
724 
725  av_freep(&p->avctx);
726  }
727 
728  av_freep(&fctx->threads);
733 
734  av_freep(&avctx->internal->thread_ctx);
735 
736  if (avctx->priv_data && avctx->codec && avctx->codec->priv_class)
737  av_opt_free(avctx->priv_data);
738  avctx->codec = NULL;
739 }
740 
742 {
743  int thread_count = avctx->thread_count;
744  const AVCodec *codec = avctx->codec;
746  FrameThreadContext *fctx;
747  int i, err = 0;
748 
749  if (!thread_count) {
750  int nb_cpus = av_cpu_count();
751 #if FF_API_DEBUG_MV
752  if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || avctx->debug_mv)
753  nb_cpus = 1;
754 #endif
755  // use number of cores + 1 as thread count if there is more than one
756  if (nb_cpus > 1)
757  thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
758  else
759  thread_count = avctx->thread_count = 1;
760  }
761 
762  if (thread_count <= 1) {
763  avctx->active_thread_type = 0;
764  return 0;
765  }
766 
767  avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));
768  if (!fctx)
769  return AVERROR(ENOMEM);
770 
771  fctx->threads = av_mallocz_array(thread_count, sizeof(PerThreadContext));
772  if (!fctx->threads) {
773  av_freep(&avctx->internal->thread_ctx);
774  return AVERROR(ENOMEM);
775  }
776 
781 
782  fctx->async_lock = 1;
783  fctx->delaying = 1;
784 
785  if (codec->type == AVMEDIA_TYPE_VIDEO)
786  avctx->delay = src->thread_count - 1;
787 
788  for (i = 0; i < thread_count; i++) {
790  PerThreadContext *p = &fctx->threads[i];
791 
797 
798  p->frame = av_frame_alloc();
799  if (!p->frame) {
800  av_freep(&copy);
801  err = AVERROR(ENOMEM);
802  goto error;
803  }
804 
805  p->parent = fctx;
806  p->avctx = copy;
807 
808  if (!copy) {
809  err = AVERROR(ENOMEM);
810  goto error;
811  }
812 
813  *copy = *src;
814 
815  copy->internal = av_malloc(sizeof(AVCodecInternal));
816  if (!copy->internal) {
817  copy->priv_data = NULL;
818  err = AVERROR(ENOMEM);
819  goto error;
820  }
821  *copy->internal = *src->internal;
822  copy->internal->thread_ctx = p;
823  copy->internal->last_pkt_props = &p->avpkt;
824 
825  copy->delay = avctx->delay;
826 
827  if (codec->priv_data_size) {
828  copy->priv_data = av_mallocz(codec->priv_data_size);
829  if (!copy->priv_data) {
830  err = AVERROR(ENOMEM);
831  goto error;
832  }
833 
834  if (codec->priv_class) {
835  *(const AVClass **)copy->priv_data = codec->priv_class;
836  err = av_opt_copy(copy->priv_data, src->priv_data);
837  if (err < 0)
838  goto error;
839  }
840  }
841 
842  if (i)
843  copy->internal->is_copy = 1;
844 
845  if (codec->init)
846  err = codec->init(copy);
847 
848  if (err) goto error;
849 
850  if (!i)
851  update_context_from_thread(avctx, copy, 1);
852 
853  atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);
854 
856  p->thread_init= !err;
857  if(!p->thread_init)
858  goto error;
859  }
860 
861  return 0;
862 
863 error:
864  ff_frame_thread_free(avctx, i+1);
865 
866  return err;
867 }
868 
870 {
871  int i;
872  FrameThreadContext *fctx = avctx->internal->thread_ctx;
873 
874  if (!fctx) return;
875 
877  if (fctx->prev_thread) {
878  if (fctx->prev_thread != &fctx->threads[0])
880  }
881 
882  fctx->next_decoding = fctx->next_finished = 0;
883  fctx->delaying = 1;
884  fctx->prev_thread = NULL;
885  for (i = 0; i < avctx->thread_count; i++) {
886  PerThreadContext *p = &fctx->threads[i];
887  // Make sure decode flush calls with size=0 won't return old frames
888  p->got_frame = 0;
889  av_frame_unref(p->frame);
890  p->result = 0;
891 
893 
894  if (avctx->codec->flush)
895  avctx->codec->flush(p->avctx);
896  }
897 }
898 
900 {
901  PerThreadContext *p = avctx->internal->thread_ctx;
903  (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
904  return 0;
905  }
906  return 1;
907 }
908 
910 {
911  PerThreadContext *p = avctx->internal->thread_ctx;
912  int err;
913 
914  f->owner[0] = f->owner[1] = avctx;
915 
916  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
917  return ff_get_buffer(avctx, f->f, flags);
918 
919  if (atomic_load(&p->state) != STATE_SETTING_UP &&
920  (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
921  av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
922  return -1;
923  }
924 
926  atomic_int *progress;
927  f->progress = av_buffer_alloc(2 * sizeof(*progress));
928  if (!f->progress) {
929  return AVERROR(ENOMEM);
930  }
931  progress = (atomic_int*)f->progress->data;
932 
933  atomic_init(&progress[0], -1);
934  atomic_init(&progress[1], -1);
935  }
936 
938  if (THREAD_SAFE_CALLBACKS(avctx)) {
939  err = ff_get_buffer(avctx, f->f, flags);
940  } else {
942  p->requested_frame = f->f;
943  p->requested_flags = flags;
944  atomic_store_explicit(&p->state, STATE_GET_BUFFER, memory_order_release);
946 
947  while (atomic_load(&p->state) != STATE_SETTING_UP)
949 
950  err = p->result;
951 
953 
954  }
955  if (!THREAD_SAFE_CALLBACKS(avctx) && !avctx->codec->update_thread_context)
956  ff_thread_finish_setup(avctx);
957  if (err)
959 
961 
962  return err;
963 }
964 
966 {
967  enum AVPixelFormat res;
968  PerThreadContext *p = avctx->internal->thread_ctx;
969  if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||
971  return ff_get_format(avctx, fmt);
972  if (atomic_load(&p->state) != STATE_SETTING_UP) {
973  av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");
974  return -1;
975  }
977  p->available_formats = fmt;
980 
981  while (atomic_load(&p->state) != STATE_SETTING_UP)
983 
984  res = p->result_format;
985 
987 
988  return res;
989 }
990 
992 {
993  int ret = thread_get_buffer_internal(avctx, f, flags);
994  if (ret < 0)
995  av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");
996  return ret;
997 }
998 
1000 {
1001  PerThreadContext *p = avctx->internal->thread_ctx;
1002  FrameThreadContext *fctx;
1003  AVFrame *dst;
1004  int ret = 0;
1005  int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
1006  THREAD_SAFE_CALLBACKS(avctx);
1007 
1008  if (!f->f)
1009  return;
1010 
1011  if (avctx->debug & FF_DEBUG_BUFFERS)
1012  av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
1013 
1015  f->owner[0] = f->owner[1] = NULL;
1016 
1017  // when the frame buffers are not allocated, just reset it to clean state
1018  if (can_direct_free || !f->f->buf[0]) {
1019  av_frame_unref(f->f);
1020  return;
1021  }
1022 
1023  fctx = p->parent;
1025 
1028  sizeof(*p->released_buffers));
1029  if (tmp) {
1031  p->released_buffers = tmp;
1032  }
1033 
1034  if (!tmp || !tmp[p->released_buffers_allocated]) {
1035  ret = AVERROR(ENOMEM);
1036  goto fail;
1037  }
1039  }
1040 
1042  av_frame_move_ref(dst, f->f);
1043 
1044  p->num_released_buffers++;
1045 
1046 fail:
1048 
1049  // make sure the frame is clean even if we fail to free it
1050  // this leaks, but it is better than crashing
1051  if (ret < 0) {
1052  av_log(avctx, AV_LOG_ERROR, "Could not queue a frame for freeing, this will leak\n");
1053  memset(f->f->buf, 0, sizeof(f->f->buf));
1054  if (f->f->extended_buf)
1055  memset(f->f->extended_buf, 0, f->f->nb_extended_buf * sizeof(*f->f->extended_buf));
1056  av_frame_unref(f->f);
1057  }
1058 }
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:778
int caps_internal
Internal hwaccel capabilities.
Definition: avcodec.h:2559
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:535
AVRational framerate
Definition: avcodec.h:2069
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:308
#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:714
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:499
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:303
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
int nb_extended_buf
Number of elements in extended_buf.
Definition: frame.h:517
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:905
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:595
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:1757
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:1690
int profile
profile
Definition: avcodec.h:1859
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:761
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:649
Set when the codec calls get_buffer().
Definition: pthread_frame.c:57
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2004
#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:2354
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:1194
#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:1702
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:1750
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:1168
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:880
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:816
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:1804
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:606
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:1237
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:96
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1796
#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:513
int width
picture width / height.
Definition: avcodec.h:699
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1729
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:2226
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:1140
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:1982
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1633
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:1683
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
pthread_t thread
Definition: pthread_frame.c:73
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:66
#define FF_DEBUG_THREADS
Definition: avcodec.h:1634
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1785
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:534
enum AVCodecID codec_id
Definition: avcodec.h:536
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:1186
enum AVDiscard skip_idct
Skip IDCT/dequantization for selected frames.
Definition: avcodec.h:1997
int debug
debug
Definition: avcodec.h:1611
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:526
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:1004
AVCodecContext * owner[2]
Definition: thread.h:36
int coded_height
Definition: avcodec.h:714
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:1341
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
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
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
#define atomic_store_explicit(object, desired, order)
Definition: stdatomic.h:90
static void async_unlock(FrameThreadContext *fctx)
PerThreadContext * threads
The contexts for each thread.
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:566
#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:322
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:417
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:98
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:1776
int caps_internal
Internal codec capabilities.
Definition: codec.h:308
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:1990
int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:1814
void * priv_data
Definition: avcodec.h:553
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:1187
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:561
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:613
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:896
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
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:2287
int debug_mv
debug motion vectors
Definition: avcodec.h:2157
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:355
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
int delay
Codec delay.
Definition: avcodec.h:682
int ff_frame_thread_init(AVCodecContext *avctx)
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:2076
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:568
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
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:190
static uint8_t tmp[11]
Definition: aes_ctr.c:26