FFmpeg: libavcodec/pthread_frame.c Source File

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.
50   STATE_INPUT_READY,
51  ///< Set before the codec has called ff_thread_finish_setup().
52   STATE_SETTING_UP,
53  /**
54  * Set when the codec calls get_buffer().
55  * State is returned to STATE_SETTING_UP afterwards.
56  */
57   STATE_GET_BUFFER,
58  /**
59  * Set when the codec calls get_format().
60  * State is returned to STATE_SETTING_UP afterwards.
61  */
62   STATE_GET_FORMAT,
63  ///< Set after the codec has called ff_thread_finish_setup().
64   STATE_SETUP_FINISHED,
65 };
66 
67 enum {
68   UNINITIALIZED, ///< Thread has not been created, AVCodec->close mustn't be called
69   NEEDS_CLOSE, ///< AVCodec->close needs to be called
70   INITIALIZED, ///< Thread has been properly set up
71 };
72 
73 /**
74  * Context used by codec threads and stored in their AVCodecInternal thread_ctx.
75  */
76  typedef struct PerThreadContext {
77   struct FrameThreadContext *parent;
78 
79   pthread_t thread;
80   int thread_init;
81   unsigned pthread_init_cnt;///< Number of successfully initialized mutexes/conditions
82   pthread_cond_t input_cond; ///< Used to wait for a new packet from the main thread.
83   pthread_cond_t progress_cond; ///< Used by child threads to wait for progress to change.
84   pthread_cond_t output_cond; ///< Used by the main thread to wait for frames to finish.
85 
86   pthread_mutex_t mutex; ///< Mutex used to protect the contents of the PerThreadContext.
87   pthread_mutex_t progress_mutex; ///< Mutex used to protect frame progress values and progress_cond.
88 
89   AVCodecContext *avctx; ///< Context used to decode packets passed to this thread.
90 
91   AVPacket *avpkt; ///< Input packet (for decoding) or output (for encoding).
92 
93   AVFrame *frame; ///< Output frame (for decoding) or input (for encoding).
94   int got_frame; ///< The output of got_picture_ptr from the last avcodec_decode_video() call.
95   int result; ///< The result of the last codec decode/encode() call.
96 
97   atomic_int state;
98 
99 #if FF_API_THREAD_SAFE_CALLBACKS
100  /**
101  * Array of frames passed to ff_thread_release_buffer().
102  * Frames are released after all threads referencing them are finished.
103  */
104   AVFrame **released_buffers;
105   int num_released_buffers;
106   int released_buffers_allocated;
107 
108   AVFrame *requested_frame; ///< AVFrame the codec passed to get_buffer()
109   int requested_flags; ///< flags passed to get_buffer() for requested_frame
110 
111   const enum AVPixelFormat *available_formats; ///< Format array for get_format()
112   enum AVPixelFormat result_format; ///< get_format() result
113 #endif
114 
115   int die; ///< Set when the thread should exit.
116 
117   int hwaccel_serializing;
118   int async_serializing;
119 
120   atomic_int debug_threads; ///< Set if the FF_DEBUG_THREADS option is set.
121 } PerThreadContext;
122 
123 /**
124  * Context stored in the client AVCodecInternal thread_ctx.
125  */
126  typedef struct FrameThreadContext {
127   PerThreadContext *threads; ///< The contexts for each thread.
128   PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.
129 
130   unsigned pthread_init_cnt; ///< Number of successfully initialized mutexes/conditions
131   pthread_mutex_t buffer_mutex; ///< Mutex used to protect get/release_buffer().
132  /**
133  * This lock is used for ensuring threads run in serial when hwaccel
134  * is used.
135  */
136   pthread_mutex_t hwaccel_mutex;
137   pthread_mutex_t async_mutex;
138   pthread_cond_t async_cond;
139   int async_lock;
140 
141   int next_decoding; ///< The next context to submit a packet to.
142   int next_finished; ///< The next context to return output from.
143 
144   int delaying; /**<
145  * Set for the first N packets, where N is the number of threads.
146  * While it is set, ff_thread_en/decode_frame won't return any results.
147  */
148 } FrameThreadContext;
149 
150 #if FF_API_THREAD_SAFE_CALLBACKS
151  #define THREAD_SAFE_CALLBACKS(avctx) \
152 ((avctx)->thread_safe_callbacks || (avctx)->get_buffer2 == avcodec_default_get_buffer2)
153 #endif
154 
155  static void async_lock(FrameThreadContext *fctx)
156 {
157  pthread_mutex_lock(&fctx->async_mutex);
158  while (fctx->async_lock)
159  pthread_cond_wait(&fctx->async_cond, &fctx->async_mutex);
160  fctx->async_lock = 1;
161  pthread_mutex_unlock(&fctx->async_mutex);
162 }
163 
164  static void async_unlock(FrameThreadContext *fctx)
165 {
166  pthread_mutex_lock(&fctx->async_mutex);
167  av_assert0(fctx->async_lock);
168  fctx->async_lock = 0;
169  pthread_cond_broadcast(&fctx->async_cond);
170  pthread_mutex_unlock(&fctx->async_mutex);
171 }
172 
173 /**
174  * Codec worker thread.
175  *
176  * Automatically calls ff_thread_finish_setup() if the codec does
177  * not provide an update_thread_context method, or if the codec returns
178  * before calling it.
179  */
180  static attribute_align_arg void *frame_worker_thread(void *arg)
181 {
182  PerThreadContext *p = arg;
183  AVCodecContext *avctx = p->avctx;
184  const AVCodec *codec = avctx->codec;
185 
186  pthread_mutex_lock(&p->mutex);
187  while (1) {
188  while (atomic_load(&p->state) == STATE_INPUT_READY && !p->die)
189  pthread_cond_wait(&p->input_cond, &p->mutex);
190 
191  if (p->die) break;
192 
193 FF_DISABLE_DEPRECATION_WARNINGS
194  if (!codec->update_thread_context
195 #if FF_API_THREAD_SAFE_CALLBACKS
196  && THREAD_SAFE_CALLBACKS(avctx)
197 #endif
198  )
199  ff_thread_finish_setup(avctx);
200 FF_ENABLE_DEPRECATION_WARNINGS
201 
202  /* If a decoder supports hwaccel, then it must call ff_get_format().
203  * Since that call must happen before ff_thread_finish_setup(), the
204  * decoder is required to implement update_thread_context() and call
205  * ff_thread_finish_setup() manually. Therefore the above
206  * ff_thread_finish_setup() call did not happen and hwaccel_serializing
207  * cannot be true here. */
208  av_assert0(!p->hwaccel_serializing);
209 
210  /* if the previous thread uses hwaccel then we take the lock to ensure
211  * the threads don't run concurrently */
212  if (avctx->hwaccel) {
213  pthread_mutex_lock(&p->parent->hwaccel_mutex);
214  p->hwaccel_serializing = 1;
215  }
216 
217  av_frame_unref(p->frame);
218  p->got_frame = 0;
219  p->result = codec->decode(avctx, p->frame, &p->got_frame, p->avpkt);
220 
221  if ((p->result < 0 || !p->got_frame) && p->frame->buf[0]) {
222  if (avctx->codec->caps_internal & FF_CODEC_CAP_ALLOCATE_PROGRESS)
223  av_log(avctx, AV_LOG_ERROR, "A frame threaded decoder did not "
224  "free the frame on failure. This is a bug, please report it.\n");
225  av_frame_unref(p->frame);
226  }
227 
228  if (atomic_load(&p->state) == STATE_SETTING_UP)
229  ff_thread_finish_setup(avctx);
230 
231  if (p->hwaccel_serializing) {
232  p->hwaccel_serializing = 0;
233  pthread_mutex_unlock(&p->parent->hwaccel_mutex);
234  }
235 
236  if (p->async_serializing) {
237  p->async_serializing = 0;
238 
239  async_unlock(p->parent);
240  }
241 
242  pthread_mutex_lock(&p->progress_mutex);
243 
244  atomic_store(&p->state, STATE_INPUT_READY);
245 
246  pthread_cond_broadcast(&p->progress_cond);
247  pthread_cond_signal(&p->output_cond);
248  pthread_mutex_unlock(&p->progress_mutex);
249  }
250  pthread_mutex_unlock(&p->mutex);
251 
252  return NULL;
253 }
254 
255 /**
256  * Update the next thread's AVCodecContext with values from the reference thread's context.
257  *
258  * @param dst The destination context.
259  * @param src The source context.
260  * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
261  * @return 0 on success, negative error code on failure
262  */
263  static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src, int for_user)
264 {
265  int err = 0;
266 
267  if (dst != src && (for_user || src->codec->update_thread_context)) {
268  dst->time_base = src->time_base;
269  dst->framerate = src->framerate;
270  dst->width = src->width;
271  dst->height = src->height;
272  dst->pix_fmt = src->pix_fmt;
273  dst->sw_pix_fmt = src->sw_pix_fmt;
274 
275  dst->coded_width = src->coded_width;
276  dst->coded_height = src->coded_height;
277 
278  dst->has_b_frames = src->has_b_frames;
279  dst->idct_algo = src->idct_algo;
280  dst->properties = src->properties;
281 
282  dst->bits_per_coded_sample = src->bits_per_coded_sample;
283  dst->sample_aspect_ratio = src->sample_aspect_ratio;
284 
285  dst->profile = src->profile;
286  dst->level = src->level;
287 
288  dst->bits_per_raw_sample = src->bits_per_raw_sample;
289  dst->ticks_per_frame = src->ticks_per_frame;
290  dst->color_primaries = src->color_primaries;
291 
292  dst->color_trc = src->color_trc;
293  dst->colorspace = src->colorspace;
294  dst->color_range = src->color_range;
295  dst->chroma_sample_location = src->chroma_sample_location;
296 
297  dst->hwaccel = src->hwaccel;
298  dst->hwaccel_context = src->hwaccel_context;
299 
300  dst->channels = src->channels;
301  dst->sample_rate = src->sample_rate;
302  dst->sample_fmt = src->sample_fmt;
303  dst->channel_layout = src->channel_layout;
304  dst->internal->hwaccel_priv_data = src->internal->hwaccel_priv_data;
305 
306  if (!!dst->hw_frames_ctx != !!src->hw_frames_ctx ||
307  (dst->hw_frames_ctx && dst->hw_frames_ctx->data != src->hw_frames_ctx->data)) {
308  av_buffer_unref(&dst->hw_frames_ctx);
309 
310  if (src->hw_frames_ctx) {
311  dst->hw_frames_ctx = av_buffer_ref(src->hw_frames_ctx);
312  if (!dst->hw_frames_ctx)
313  return AVERROR(ENOMEM);
314  }
315  }
316 
317  dst->hwaccel_flags = src->hwaccel_flags;
318 
319  err = av_buffer_replace(&dst->internal->pool, src->internal->pool);
320  if (err < 0)
321  return err;
322  }
323 
324  if (for_user) {
325  if (dst->codec->update_thread_context_for_user)
326  err = dst->codec->update_thread_context_for_user(dst, src);
327  } else {
328  if (dst->codec->update_thread_context)
329  err = dst->codec->update_thread_context(dst, src);
330  }
331 
332  return err;
333 }
334 
335 /**
336  * Update the next thread's AVCodecContext with values set by the user.
337  *
338  * @param dst The destination context.
339  * @param src The source context.
340  * @return 0 on success, negative error code on failure
341  */
342  static int update_context_from_user(AVCodecContext *dst, AVCodecContext *src)
343 {
344  dst->flags = src->flags;
345 
346  dst->draw_horiz_band= src->draw_horiz_band;
347  dst->get_buffer2 = src->get_buffer2;
348 
349  dst->opaque = src->opaque;
350  dst->debug = src->debug;
351 
352  dst->slice_flags = src->slice_flags;
353  dst->flags2 = src->flags2;
354  dst->export_side_data = src->export_side_data;
355 
356  dst->skip_loop_filter = src->skip_loop_filter;
357  dst->skip_idct = src->skip_idct;
358  dst->skip_frame = src->skip_frame;
359 
360  dst->frame_number = src->frame_number;
361  dst->reordered_opaque = src->reordered_opaque;
362 #if FF_API_THREAD_SAFE_CALLBACKS
363 FF_DISABLE_DEPRECATION_WARNINGS
364  dst->thread_safe_callbacks = src->thread_safe_callbacks;
365 FF_ENABLE_DEPRECATION_WARNINGS
366 #endif
367 
368  if (src->slice_count && src->slice_offset) {
369  if (dst->slice_count < src->slice_count) {
370  int err = av_reallocp_array(&dst->slice_offset, src->slice_count,
371  sizeof(*dst->slice_offset));
372  if (err < 0)
373  return err;
374  }
375  memcpy(dst->slice_offset, src->slice_offset,
376  src->slice_count * sizeof(*dst->slice_offset));
377  }
378  dst->slice_count = src->slice_count;
379  return 0;
380 }
381 
382 #if FF_API_THREAD_SAFE_CALLBACKS
383 /// Releases the buffers that this decoding thread was the last user of.
384  static void release_delayed_buffers(PerThreadContext *p)
385 {
386  FrameThreadContext *fctx = p->parent;
387 
388  while (p->num_released_buffers > 0) {
389  AVFrame *f;
390 
391  pthread_mutex_lock(&fctx->buffer_mutex);
392 
393  // fix extended data in case the caller screwed it up
394  av_assert0(p->avctx->codec_type == AVMEDIA_TYPE_VIDEO ||
395  p->avctx->codec_type == AVMEDIA_TYPE_AUDIO);
396  f = p->released_buffers[--p->num_released_buffers];
397  f->extended_data = f->data;
398  av_frame_unref(f);
399 
400  pthread_mutex_unlock(&fctx->buffer_mutex);
401  }
402 }
403 #endif
404 
405  static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx,
406  AVPacket *avpkt)
407 {
408  FrameThreadContext *fctx = p->parent;
409  PerThreadContext *prev_thread = fctx->prev_thread;
410  const AVCodec *codec = p->avctx->codec;
411  int ret;
412 
413  if (!avpkt->size && !(codec->capabilities & AV_CODEC_CAP_DELAY))
414  return 0;
415 
416  pthread_mutex_lock(&p->mutex);
417 
418  ret = update_context_from_user(p->avctx, user_avctx);
419  if (ret) {
420  pthread_mutex_unlock(&p->mutex);
421  return ret;
422  }
423  atomic_store_explicit(&p->debug_threads,
424  (p->avctx->debug & FF_DEBUG_THREADS) != 0,
425  memory_order_relaxed);
426 
427 #if FF_API_THREAD_SAFE_CALLBACKS
428  release_delayed_buffers(p);
429 #endif
430 
431  if (prev_thread) {
432  int err;
433  if (atomic_load(&prev_thread->state) == STATE_SETTING_UP) {
434  pthread_mutex_lock(&prev_thread->progress_mutex);
435  while (atomic_load(&prev_thread->state) == STATE_SETTING_UP)
436  pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
437  pthread_mutex_unlock(&prev_thread->progress_mutex);
438  }
439 
440  err = update_context_from_thread(p->avctx, prev_thread->avctx, 0);
441  if (err) {
442  pthread_mutex_unlock(&p->mutex);
443  return err;
444  }
445  }
446 
447  av_packet_unref(p->avpkt);
448  ret = av_packet_ref(p->avpkt, avpkt);
449  if (ret < 0) {
450  pthread_mutex_unlock(&p->mutex);
451  av_log(p->avctx, AV_LOG_ERROR, "av_packet_ref() failed in submit_packet()\n");
452  return ret;
453  }
454 
455  atomic_store(&p->state, STATE_SETTING_UP);
456  pthread_cond_signal(&p->input_cond);
457  pthread_mutex_unlock(&p->mutex);
458 
459 #if FF_API_THREAD_SAFE_CALLBACKS
460 FF_DISABLE_DEPRECATION_WARNINGS
461  /*
462  * If the client doesn't have a thread-safe get_buffer(),
463  * then decoding threads call back to the main thread,
464  * and it calls back to the client here.
465  */
466 
467  if (!p->avctx->thread_safe_callbacks && (
468  p->avctx->get_format != avcodec_default_get_format ||
469  p->avctx->get_buffer2 != avcodec_default_get_buffer2)) {
470  while (atomic_load(&p->state) != STATE_SETUP_FINISHED && atomic_load(&p->state) != STATE_INPUT_READY) {
471  int call_done = 1;
472  pthread_mutex_lock(&p->progress_mutex);
473  while (atomic_load(&p->state) == STATE_SETTING_UP)
474  pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
475 
476  switch (atomic_load_explicit(&p->state, memory_order_acquire)) {
477  case STATE_GET_BUFFER:
478  p->result = ff_get_buffer(p->avctx, p->requested_frame, p->requested_flags);
479  break;
480  case STATE_GET_FORMAT:
481  p->result_format = ff_get_format(p->avctx, p->available_formats);
482  break;
483  default:
484  call_done = 0;
485  break;
486  }
487  if (call_done) {
488  atomic_store(&p->state, STATE_SETTING_UP);
489  pthread_cond_signal(&p->progress_cond);
490  }
491  pthread_mutex_unlock(&p->progress_mutex);
492  }
493  }
494 FF_ENABLE_DEPRECATION_WARNINGS
495 #endif
496 
497  fctx->prev_thread = p;
498  fctx->next_decoding++;
499 
500  return 0;
501 }
502 
503  int ff_thread_decode_frame(AVCodecContext *avctx,
504  AVFrame *picture, int *got_picture_ptr,
505  AVPacket *avpkt)
506 {
507  FrameThreadContext *fctx = avctx->internal->thread_ctx;
508  int finished = fctx->next_finished;
509  PerThreadContext *p;
510  int err;
511 
512  /* release the async lock, permitting blocked hwaccel threads to
513  * go forward while we are in this function */
514  async_unlock(fctx);
515 
516  /*
517  * Submit a packet to the next decoding thread.
518  */
519 
520  p = &fctx->threads[fctx->next_decoding];
521  err = submit_packet(p, avctx, avpkt);
522  if (err)
523  goto finish;
524 
525  /*
526  * If we're still receiving the initial packets, don't return a frame.
527  */
528 
529  if (fctx->next_decoding > (avctx->thread_count-1-(avctx->codec_id == AV_CODEC_ID_FFV1)))
530  fctx->delaying = 0;
531 
532  if (fctx->delaying) {
533  *got_picture_ptr=0;
534  if (avpkt->size) {
535  err = avpkt->size;
536  goto finish;
537  }
538  }
539 
540  /*
541  * Return the next available frame from the oldest thread.
542  * If we're at the end of the stream, then we have to skip threads that
543  * didn't output a frame/error, because we don't want to accidentally signal
544  * EOF (avpkt->size == 0 && *got_picture_ptr == 0 && err >= 0).
545  */
546 
547  do {
548  p = &fctx->threads[finished++];
549 
550  if (atomic_load(&p->state) != STATE_INPUT_READY) {
551  pthread_mutex_lock(&p->progress_mutex);
552  while (atomic_load_explicit(&p->state, memory_order_relaxed) != STATE_INPUT_READY)
553  pthread_cond_wait(&p->output_cond, &p->progress_mutex);
554  pthread_mutex_unlock(&p->progress_mutex);
555  }
556 
557  av_frame_move_ref(picture, p->frame);
558  *got_picture_ptr = p->got_frame;
559  picture->pkt_dts = p->avpkt->dts;
560  err = p->result;
561 
562  /*
563  * A later call with avkpt->size == 0 may loop over all threads,
564  * including this one, searching for a frame/error to return before being
565  * stopped by the "finished != fctx->next_finished" condition.
566  * Make sure we don't mistakenly return the same frame/error again.
567  */
568  p->got_frame = 0;
569  p->result = 0;
570 
571  if (finished >= avctx->thread_count) finished = 0;
572  } while (!avpkt->size && !*got_picture_ptr && err >= 0 && finished != fctx->next_finished);
573 
574  update_context_from_thread(avctx, p->avctx, 1);
575 
576  if (fctx->next_decoding >= avctx->thread_count) fctx->next_decoding = 0;
577 
578  fctx->next_finished = finished;
579 
580  /* return the size of the consumed packet if no error occurred */
581  if (err >= 0)
582  err = avpkt->size;
583 finish:
584  async_lock(fctx);
585  return err;
586 }
587 
588  void ff_thread_report_progress(ThreadFrame *f, int n, int field)
589 {
590  PerThreadContext *p;
591  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
592 
593  if (!progress ||
594  atomic_load_explicit(&progress[field], memory_order_relaxed) >= n)
595  return;
596 
597  p = f->owner[field]->internal->thread_ctx;
598 
599  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
600  av_log(f->owner[field], AV_LOG_DEBUG,
601  "%p finished %d field %d\n", progress, n, field);
602 
603  pthread_mutex_lock(&p->progress_mutex);
604 
605  atomic_store_explicit(&progress[field], n, memory_order_release);
606 
607  pthread_cond_broadcast(&p->progress_cond);
608  pthread_mutex_unlock(&p->progress_mutex);
609 }
610 
611  void ff_thread_await_progress(ThreadFrame *f, int n, int field)
612 {
613  PerThreadContext *p;
614  atomic_int *progress = f->progress ? (atomic_int*)f->progress->data : NULL;
615 
616  if (!progress ||
617  atomic_load_explicit(&progress[field], memory_order_acquire) >= n)
618  return;
619 
620  p = f->owner[field]->internal->thread_ctx;
621 
622  if (atomic_load_explicit(&p->debug_threads, memory_order_relaxed))
623  av_log(f->owner[field], AV_LOG_DEBUG,
624  "thread awaiting %d field %d from %p\n", n, field, progress);
625 
626  pthread_mutex_lock(&p->progress_mutex);
627  while (atomic_load_explicit(&progress[field], memory_order_relaxed) < n)
628  pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
629  pthread_mutex_unlock(&p->progress_mutex);
630 }
631 
632  void ff_thread_finish_setup(AVCodecContext *avctx) {
633  PerThreadContext *p = avctx->internal->thread_ctx;
634 
635  if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
636 
637  if (avctx->hwaccel && !p->hwaccel_serializing) {
638  pthread_mutex_lock(&p->parent->hwaccel_mutex);
639  p->hwaccel_serializing = 1;
640  }
641 
642  /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
643  if (avctx->hwaccel &&
644  !(avctx->hwaccel->caps_internal & HWACCEL_CAP_ASYNC_SAFE)) {
645  p->async_serializing = 1;
646 
647  async_lock(p->parent);
648  }
649 
650  pthread_mutex_lock(&p->progress_mutex);
651  if(atomic_load(&p->state) == STATE_SETUP_FINISHED){
652  av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
653  }
654 
655  atomic_store(&p->state, STATE_SETUP_FINISHED);
656 
657  pthread_cond_broadcast(&p->progress_cond);
658  pthread_mutex_unlock(&p->progress_mutex);
659 }
660 
661 /// Waits for all threads to finish.
662  static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
663 {
664  int i;
665 
666  async_unlock(fctx);
667 
668  for (i = 0; i < thread_count; i++) {
669  PerThreadContext *p = &fctx->threads[i];
670 
671  if (atomic_load(&p->state) != STATE_INPUT_READY) {
672  pthread_mutex_lock(&p->progress_mutex);
673  while (atomic_load(&p->state) != STATE_INPUT_READY)
674  pthread_cond_wait(&p->output_cond, &p->progress_mutex);
675  pthread_mutex_unlock(&p->progress_mutex);
676  }
677  p->got_frame = 0;
678  }
679 
680  async_lock(fctx);
681 }
682 
683 #define OFF(member) offsetof(FrameThreadContext, member)
684 DEFINE_OFFSET_ARRAY(FrameThreadContext, thread_ctx, pthread_init_cnt,
685  (OFF(buffer_mutex), OFF(hwaccel_mutex), OFF(async_mutex)),
686  (OFF(async_cond)));
687 #undef OFF
688 
689  #define OFF(member) offsetof(PerThreadContext, member)
690 DEFINE_OFFSET_ARRAY(PerThreadContext, per_thread, pthread_init_cnt,
691  (OFF(progress_mutex), OFF(mutex)),
692  (OFF(input_cond), OFF(progress_cond), OFF(output_cond)));
693 #undef OFF
694 
695  void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
696 {
697  FrameThreadContext *fctx = avctx->internal->thread_ctx;
698  const AVCodec *codec = avctx->codec;
699  int i;
700 
701  park_frame_worker_threads(fctx, thread_count);
702 
703  if (fctx->prev_thread && avctx->internal->hwaccel_priv_data !=
704  fctx->prev_thread->avctx->internal->hwaccel_priv_data) {
705  if (update_context_from_thread(avctx, fctx->prev_thread->avctx, 1) < 0) {
706  av_log(avctx, AV_LOG_ERROR, "Failed to update user thread.\n");
707  }
708  }
709 
710  if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
711  if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
712  av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
713  fctx->prev_thread->avctx->internal->is_copy = fctx->threads->avctx->internal->is_copy;
714  fctx->threads->avctx->internal->is_copy = 1;
715  }
716 
717  for (i = 0; i < thread_count; i++) {
718  PerThreadContext *p = &fctx->threads[i];
719  AVCodecContext *ctx = p->avctx;
720 
721  if (ctx->internal) {
722  if (p->thread_init == INITIALIZED) {
723  pthread_mutex_lock(&p->mutex);
724  p->die = 1;
725  pthread_cond_signal(&p->input_cond);
726  pthread_mutex_unlock(&p->mutex);
727 
728  pthread_join(p->thread, NULL);
729  }
730  if (codec->close && p->thread_init != UNINITIALIZED)
731  codec->close(ctx);
732 
733 #if FF_API_THREAD_SAFE_CALLBACKS
734  release_delayed_buffers(p);
735  for (int j = 0; j < p->released_buffers_allocated; j++)
736  av_frame_free(&p->released_buffers[j]);
737  av_freep(&p->released_buffers);
738 #endif
739  if (ctx->priv_data) {
740  if (codec->priv_class)
741  av_opt_free(ctx->priv_data);
742  av_freep(&ctx->priv_data);
743  }
744 
745  av_freep(&ctx->slice_offset);
746 
747  av_buffer_unref(&ctx->internal->pool);
748  av_freep(&ctx->internal);
749  av_buffer_unref(&ctx->hw_frames_ctx);
750  }
751 
752  av_frame_free(&p->frame);
753 
754  ff_pthread_free(p, per_thread_offsets);
755  av_packet_free(&p->avpkt);
756 
757  av_freep(&p->avctx);
758  }
759 
760  av_freep(&fctx->threads);
761  ff_pthread_free(fctx, thread_ctx_offsets);
762 
763  av_freep(&avctx->internal->thread_ctx);
764 }
765 
766  static av_cold int init_thread(PerThreadContext *p, int *threads_to_free,
767  FrameThreadContext *fctx, AVCodecContext *avctx,
768  const AVCodec *codec, int first)
769 {
770  AVCodecContext *copy;
771  int err;
772 
773  atomic_init(&p->state, STATE_INPUT_READY);
774 
775  copy = av_memdup(avctx, sizeof(*avctx));
776  if (!copy)
777  return AVERROR(ENOMEM);
778  copy->priv_data = NULL;
779 
780  /* From now on, this PerThreadContext will be cleaned up by
781  * ff_frame_thread_free in case of errors. */
782  (*threads_to_free)++;
783 
784  p->parent = fctx;
785  p->avctx = copy;
786 
787  copy->internal = av_memdup(avctx->internal, sizeof(*avctx->internal));
788  if (!copy->internal)
789  return AVERROR(ENOMEM);
790  copy->internal->thread_ctx = p;
791 
792  copy->delay = avctx->delay;
793 
794  if (codec->priv_data_size) {
795  copy->priv_data = av_mallocz(codec->priv_data_size);
796  if (!copy->priv_data)
797  return AVERROR(ENOMEM);
798 
799  if (codec->priv_class) {
800  *(const AVClass **)copy->priv_data = codec->priv_class;
801  err = av_opt_copy(copy->priv_data, avctx->priv_data);
802  if (err < 0)
803  return err;
804  }
805  }
806 
807  err = ff_pthread_init(p, per_thread_offsets);
808  if (err < 0)
809  return err;
810 
811  if (!(p->frame = av_frame_alloc()) ||
812  !(p->avpkt = av_packet_alloc()))
813  return AVERROR(ENOMEM);
814  copy->internal->last_pkt_props = p->avpkt;
815 
816  if (!first)
817  copy->internal->is_copy = 1;
818 
819  if (codec->init) {
820  err = codec->init(copy);
821  if (err < 0) {
822  if (codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP)
823  p->thread_init = NEEDS_CLOSE;
824  return err;
825  }
826  }
827  p->thread_init = NEEDS_CLOSE;
828 
829  if (first)
830  update_context_from_thread(avctx, copy, 1);
831 
832  atomic_init(&p->debug_threads, (copy->debug & FF_DEBUG_THREADS) != 0);
833 
834  err = AVERROR(pthread_create(&p->thread, NULL, frame_worker_thread, p));
835  if (err < 0)
836  return err;
837  p->thread_init = INITIALIZED;
838 
839  return 0;
840 }
841 
842  int ff_frame_thread_init(AVCodecContext *avctx)
843 {
844  int thread_count = avctx->thread_count;
845  const AVCodec *codec = avctx->codec;
846  FrameThreadContext *fctx;
847  int err, i = 0;
848 
849  if (!thread_count) {
850  int nb_cpus = av_cpu_count();
851  // use number of cores + 1 as thread count if there is more than one
852  if (nb_cpus > 1)
853  thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
854  else
855  thread_count = avctx->thread_count = 1;
856  }
857 
858  if (thread_count <= 1) {
859  avctx->active_thread_type = 0;
860  return 0;
861  }
862 
863  avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));
864  if (!fctx)
865  return AVERROR(ENOMEM);
866 
867  err = ff_pthread_init(fctx, thread_ctx_offsets);
868  if (err < 0) {
869  ff_pthread_free(fctx, thread_ctx_offsets);
870  av_freep(&avctx->internal->thread_ctx);
871  return err;
872  }
873 
874  fctx->async_lock = 1;
875  fctx->delaying = 1;
876 
877  if (codec->type == AVMEDIA_TYPE_VIDEO)
878  avctx->delay = avctx->thread_count - 1;
879 
880  fctx->threads = av_calloc(thread_count, sizeof(*fctx->threads));
881  if (!fctx->threads) {
882  err = AVERROR(ENOMEM);
883  goto error;
884  }
885 
886  for (; i < thread_count; ) {
887  PerThreadContext *p = &fctx->threads[i];
888  int first = !i;
889 
890  err = init_thread(p, &i, fctx, avctx, codec, first);
891  if (err < 0)
892  goto error;
893  }
894 
895  return 0;
896 
897 error:
898  ff_frame_thread_free(avctx, i);
899  return err;
900 }
901 
902  void ff_thread_flush(AVCodecContext *avctx)
903 {
904  int i;
905  FrameThreadContext *fctx = avctx->internal->thread_ctx;
906 
907  if (!fctx) return;
908 
909  park_frame_worker_threads(fctx, avctx->thread_count);
910  if (fctx->prev_thread) {
911  if (fctx->prev_thread != &fctx->threads[0])
912  update_context_from_thread(fctx->threads[0].avctx, fctx->prev_thread->avctx, 0);
913  }
914 
915  fctx->next_decoding = fctx->next_finished = 0;
916  fctx->delaying = 1;
917  fctx->prev_thread = NULL;
918  for (i = 0; i < avctx->thread_count; i++) {
919  PerThreadContext *p = &fctx->threads[i];
920  // Make sure decode flush calls with size=0 won't return old frames
921  p->got_frame = 0;
922  av_frame_unref(p->frame);
923  p->result = 0;
924 
925 #if FF_API_THREAD_SAFE_CALLBACKS
926  release_delayed_buffers(p);
927 #endif
928 
929  if (avctx->codec->flush)
930  avctx->codec->flush(p->avctx);
931  }
932 }
933 
934  int ff_thread_can_start_frame(AVCodecContext *avctx)
935 {
936  PerThreadContext *p = avctx->internal->thread_ctx;
937 FF_DISABLE_DEPRECATION_WARNINGS
938  if ((avctx->active_thread_type&FF_THREAD_FRAME) && atomic_load(&p->state) != STATE_SETTING_UP &&
939  (avctx->codec->update_thread_context
940 #if FF_API_THREAD_SAFE_CALLBACKS
941  || !THREAD_SAFE_CALLBACKS(avctx)
942 #endif
943  )) {
944  return 0;
945  }
946 FF_ENABLE_DEPRECATION_WARNINGS
947  return 1;
948 }
949 
950  static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int flags)
951 {
952  PerThreadContext *p = avctx->internal->thread_ctx;
953  int err;
954 
955  f->owner[0] = f->owner[1] = avctx;
956 
957  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
958  return ff_get_buffer(avctx, f->f, flags);
959 
960 FF_DISABLE_DEPRECATION_WARNINGS
961  if (atomic_load(&p->state) != STATE_SETTING_UP &&
962  (avctx->codec->update_thread_context
963 #if FF_API_THREAD_SAFE_CALLBACKS
964  || !THREAD_SAFE_CALLBACKS(avctx)
965 #endif
966  )) {
967 FF_ENABLE_DEPRECATION_WARNINGS
968  av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
969  return -1;
970  }
971 
972  if (avctx->codec->caps_internal & FF_CODEC_CAP_ALLOCATE_PROGRESS) {
973  atomic_int *progress;
974  f->progress = av_buffer_alloc(2 * sizeof(*progress));
975  if (!f->progress) {
976  return AVERROR(ENOMEM);
977  }
978  progress = (atomic_int*)f->progress->data;
979 
980  atomic_init(&progress[0], -1);
981  atomic_init(&progress[1], -1);
982  }
983 
984  pthread_mutex_lock(&p->parent->buffer_mutex);
985 #if !FF_API_THREAD_SAFE_CALLBACKS
986  err = ff_get_buffer(avctx, f->f, flags);
987 #else
988 FF_DISABLE_DEPRECATION_WARNINGS
989  if (THREAD_SAFE_CALLBACKS(avctx)) {
990  err = ff_get_buffer(avctx, f->f, flags);
991  } else {
992  pthread_mutex_lock(&p->progress_mutex);
993  p->requested_frame = f->f;
994  p->requested_flags = flags;
995  atomic_store_explicit(&p->state, STATE_GET_BUFFER, memory_order_release);
996  pthread_cond_broadcast(&p->progress_cond);
997 
998  while (atomic_load(&p->state) != STATE_SETTING_UP)
999  pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
1000 
1001  err = p->result;
1002 
1003  pthread_mutex_unlock(&p->progress_mutex);
1004 
1005  }
1006  if (!THREAD_SAFE_CALLBACKS(avctx) && !avctx->codec->update_thread_context)
1007  ff_thread_finish_setup(avctx);
1008 FF_ENABLE_DEPRECATION_WARNINGS
1009 #endif
1010  if (err)
1011  av_buffer_unref(&f->progress);
1012 
1013  pthread_mutex_unlock(&p->parent->buffer_mutex);
1014 
1015  return err;
1016 }
1017 
1018 #if FF_API_THREAD_SAFE_CALLBACKS
1019 FF_DISABLE_DEPRECATION_WARNINGS
1020  enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1021 {
1022  enum AVPixelFormat res;
1023  PerThreadContext *p = avctx->internal->thread_ctx;
1024  if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||
1025  avctx->get_format == avcodec_default_get_format)
1026  return ff_get_format(avctx, fmt);
1027  if (atomic_load(&p->state) != STATE_SETTING_UP) {
1028  av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");
1029  return -1;
1030  }
1031  pthread_mutex_lock(&p->progress_mutex);
1032  p->available_formats = fmt;
1033  atomic_store(&p->state, STATE_GET_FORMAT);
1034  pthread_cond_broadcast(&p->progress_cond);
1035 
1036  while (atomic_load(&p->state) != STATE_SETTING_UP)
1037  pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
1038 
1039  res = p->result_format;
1040 
1041  pthread_mutex_unlock(&p->progress_mutex);
1042 
1043  return res;
1044 }
1045 FF_ENABLE_DEPRECATION_WARNINGS
1046 #endif
1047 
1048  int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
1049 {
1050  int ret = thread_get_buffer_internal(avctx, f, flags);
1051  if (ret < 0)
1052  av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");
1053  return ret;
1054 }
1055 
1056  void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
1057 {
1058 #if FF_API_THREAD_SAFE_CALLBACKS
1059 FF_DISABLE_DEPRECATION_WARNINGS
1060  PerThreadContext *p = avctx->internal->thread_ctx;
1061  FrameThreadContext *fctx;
1062  AVFrame *dst;
1063  int ret = 0;
1064  int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
1065  THREAD_SAFE_CALLBACKS(avctx);
1066 FF_ENABLE_DEPRECATION_WARNINGS
1067 #endif
1068 
1069  if (!f->f)
1070  return;
1071 
1072  if (avctx->debug & FF_DEBUG_BUFFERS)
1073  av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
1074 
1075  av_buffer_unref(&f->progress);
1076  f->owner[0] = f->owner[1] = NULL;
1077 
1078 #if !FF_API_THREAD_SAFE_CALLBACKS
1079  av_frame_unref(f->f);
1080 #else
1081  // when the frame buffers are not allocated, just reset it to clean state
1082  if (can_direct_free || !f->f->buf[0]) {
1083  av_frame_unref(f->f);
1084  return;
1085  }
1086 
1087  fctx = p->parent;
1088  pthread_mutex_lock(&fctx->buffer_mutex);
1089 
1090  if (p->num_released_buffers == p->released_buffers_allocated) {
1091  AVFrame **tmp = av_realloc_array(p->released_buffers, p->released_buffers_allocated + 1,
1092  sizeof(*p->released_buffers));
1093  if (tmp) {
1094  tmp[p->released_buffers_allocated] = av_frame_alloc();
1095  p->released_buffers = tmp;
1096  }
1097 
1098  if (!tmp || !tmp[p->released_buffers_allocated]) {
1099  ret = AVERROR(ENOMEM);
1100  goto fail;
1101  }
1102  p->released_buffers_allocated++;
1103  }
1104 
1105  dst = p->released_buffers[p->num_released_buffers];
1106  av_frame_move_ref(dst, f->f);
1107 
1108  p->num_released_buffers++;
1109 
1110 fail:
1111  pthread_mutex_unlock(&fctx->buffer_mutex);
1112 
1113  // make sure the frame is clean even if we fail to free it
1114  // this leaks, but it is better than crashing
1115  if (ret < 0) {
1116  av_log(avctx, AV_LOG_ERROR, "Could not queue a frame for freeing, this will leak\n");
1117  memset(f->f->buf, 0, sizeof(f->f->buf));
1118  if (f->f->extended_buf)
1119  memset(f->f->extended_buf, 0, f->f->nb_extended_buf * sizeof(*f->f->extended_buf));
1120  av_frame_unref(f->f);
1121  }
1122 #endif
1123 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
pthread_mutex_t
_fmutex pthread_mutex_t
Definition: os2threads.h:53
hwconfig.h
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:424
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1359
AVCodec
AVCodec.
Definition: codec.h:202
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
AVCodecContext::hwaccel_context
void * hwaccel_context
Hardware accelerator context.
Definition: avcodec.h:1370
pthread_join
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
Definition: os2threads.h:94
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
PerThreadContext::input_cond
pthread_cond_t input_cond
Used to wait for a new packet from the main thread.
Definition: pthread_frame.c:82
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
AVERROR
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
opt.h
AVCodecContext::get_format
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Callback to negotiate the pixel format.
Definition: avcodec.h:647
INITIALIZED
@ INITIALIZED
Thread has been properly set up.
Definition: pthread_frame.c:70
FF_API_THREAD_SAFE_CALLBACKS
#define FF_API_THREAD_SAFE_CALLBACKS
Definition: version.h:57
AVCodecContext::channel_layout
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1043
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:960
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1089
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:992
PerThreadContext::debug_threads
atomic_int debug_threads
Set if the FF_DEBUG_THREADS option is set.
Definition: pthread_frame.c:120
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:228
AVCodec::update_thread_context
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:268
FrameThreadContext::next_decoding
int next_decoding
The next context to submit a packet to.
Definition: pthread_frame.c:141
thread.h
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
NEEDS_CLOSE
@ NEEDS_CLOSE
AVCodec->close needs to be called.
Definition: pthread_frame.c:69
ff_thread_flush
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
Definition: pthread_frame.c:902
AVHWAccel::caps_internal
int caps_internal
Internal hwaccel capabilities.
Definition: avcodec.h:2188
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: pthread_frame.c:934
MAX_AUTO_THREADS
#define MAX_AUTO_THREADS
Definition: pthread_internal.h:26
PerThreadContext::state
atomic_int state
Definition: pthread_frame.c:97
FrameThreadContext
Context stored in the client AVCodecInternal thread_ctx.
Definition: pthread_frame.c:126
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
park_frame_worker_threads
static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
Waits for all threads to finish.
Definition: pthread_frame.c:662
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
THREAD_SAFE_CALLBACKS
#define THREAD_SAFE_CALLBACKS(avctx)
Definition: pthread_frame.c:151
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:953
AVCodecContext::slice_offset
int * slice_offset
slice offsets in the frame in bytes
Definition: avcodec.h:744
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:221
internal.h
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
version.h
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
avcodec_default_get_format
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
Definition: decode.c:877
AVCodec::flush
void(* flush)(struct AVCodecContext *)
Flush buffers.
Definition: codec.h:336
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:513
AVCodecContext::delay
int delay
Codec delay.
Definition: avcodec.h:539
UNINITIALIZED
@ UNINITIALIZED
Thread has not been created, AVCodec->close mustn't be called.
Definition: pthread_frame.c:68
PerThreadContext::die
int die
Set when the thread should exit.
Definition: pthread_frame.c:115
thread.h
ff_pthread_free
av_cold void ff_pthread_free(void *obj, const unsigned offsets[])
Definition: pthread.c:94
FrameThreadContext::next_finished
int next_finished
The next context to return output from.
Definition: pthread_frame.c:142
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
AVCodecInternal::pool
AVBufferRef * pool
Definition: internal.h:132
AVCodecContext::slice_count
int slice_count
slice count
Definition: avcodec.h:737
FrameThreadContext::buffer_mutex
pthread_mutex_t buffer_mutex
Mutex used to protect get/release_buffer().
Definition: pthread_frame.c:131
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:311
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1710
AVCodecInternal::is_copy
int is_copy
When using frame-threaded decoding, this field is set for the first worker thread (e....
Definition: internal.h:124
ff_frame_thread_free
void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
Definition: pthread_frame.c:695
AVCodecContext::skip_idct
enum AVDiscard skip_idct
Skip IDCT/dequantization for selected frames.
Definition: avcodec.h:1666
finish
static void finish(void)
Definition: movenc.c:342
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:392
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1673
fail
#define fail()
Definition: checkasm.h:127
PerThreadContext::available_formats
enum AVPixelFormat * available_formats
Format array for get_format()
Definition: pthread_frame.c:111
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1440
FrameThreadContext::pthread_init_cnt
unsigned pthread_init_cnt
Number of successfully initialized mutexes/conditions.
Definition: pthread_frame.c:130
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:463
PerThreadContext
Context used by codec threads and stored in their AVCodecInternal thread_ctx.
Definition: pthread_frame.c:76
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:571
submit_packet
static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx, AVPacket *avpkt)
Definition: pthread_frame.c:405
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:97
AVCodecContext::get_buffer2
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:1147
STATE_SETUP_FINISHED
@ STATE_SETUP_FINISHED
Definition: pthread_frame.c:64
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:946
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
ff_thread_await_progress
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: pthread_frame.c:611
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:588
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:679
FrameThreadContext::async_lock
int async_lock
Definition: pthread_frame.c:139
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:224
init_thread
static av_cold int init_thread(PerThreadContext *p, int *threads_to_free, FrameThreadContext *fctx, AVCodecContext *avctx, const AVCodec *codec, int first)
Definition: pthread_frame.c:766
STATE_INPUT_READY
@ STATE_INPUT_READY
Set when the thread is awaiting a packet.
Definition: pthread_frame.c:50
PerThreadContext::output_cond
pthread_cond_t output_cond
Used by the main thread to wait for frames to finish.
Definition: pthread_frame.c:84
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:515
PerThreadContext::requested_flags
int requested_flags
flags passed to get_buffer() for requested_frame
Definition: pthread_frame.c:109
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1425
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
update_context_from_user
static int update_context_from_user(AVCodecContext *dst, AVCodecContext *src)
Update the next thread's AVCodecContext with values set by the user.
Definition: pthread_frame.c:342
field
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
Definition: writing_filters.txt:78
atomic_load
#define atomic_load(object)
Definition: stdatomic.h:93
pthread_cond_broadcast
static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)
Definition: os2threads.h:162
f
#define f(width, name)
Definition: cbs_vp9.c:255
FrameThreadContext::prev_thread
PerThreadContext * prev_thread
The last thread submit_packet() was called on.
Definition: pthread_frame.c:128
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:393
arg
const char * arg
Definition: jacosubdec.c:67
pthread_create
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
if
if(ret)
Definition: filter_design.txt:179
PerThreadContext::got_frame
int got_frame
The output of got_picture_ptr from the last avcodec_decode_video() call.
Definition: pthread_frame.c:94
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:967
av_buffer_unref
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:139
AVCodecContext::slice_flags
int slice_flags
slice flags
Definition: avcodec.h:846
AVCodec::type
enum AVMediaType type
Definition: codec.h:215
frame_worker_thread
static attribute_align_arg void * frame_worker_thread(void *arg)
Codec worker thread.
Definition: pthread_frame.c:180
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:418
PerThreadContext::released_buffers
AVFrame ** released_buffers
Array of frames passed to ff_thread_release_buffer().
Definition: pthread_frame.c:104
PerThreadContext::progress_mutex
pthread_mutex_t progress_mutex
Mutex used to protect frame progress values and progress_cond.
Definition: pthread_frame.c:87
src
#define src
Definition: vp8dsp.c:255
FrameThreadContext::async_mutex
pthread_mutex_t async_mutex
Definition: pthread_frame.c:137
ff_thread_finish_setup
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...
Definition: pthread_frame.c:632
FrameThreadContext::hwaccel_mutex
pthread_mutex_t hwaccel_mutex
This lock is used for ensuring threads run in serial when hwaccel is used.
Definition: pthread_frame.c:136
PerThreadContext::avctx
AVCodecContext * avctx
Context used to decode packets passed to this thread.
Definition: pthread_frame.c:89
pthread_internal.h
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1617
AVCodecContext::thread_safe_callbacks
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:1479
AVFrame::pkt_dts
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:431
FF_DEBUG_BUFFERS
#define FF_DEBUG_BUFFERS
Definition: avcodec.h:1314
av_packet_ref
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
Definition: avpacket.c:432
AVCodecContext::level
int level
level
Definition: avcodec.h:1651
atomic_load_explicit
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
FF_DEBUG_THREADS
#define FF_DEBUG_THREADS
Definition: avcodec.h:1315
OFF
#define OFF(member)
Definition: pthread_frame.c:689
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:68
async_lock
static void async_lock(FrameThreadContext *fctx)
Definition: pthread_frame.c:155
PerThreadContext::pthread_init_cnt
unsigned pthread_init_cnt
Number of successfully initialized mutexes/conditions.
Definition: pthread_frame.c:81
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1056
PerThreadContext::thread
pthread_t thread
Definition: pthread_frame.c:79
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:191
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:506
PerThreadContext::result
int result
The result of the last codec decode/encode() call.
Definition: pthread_frame.c:95
AV_CODEC_ID_FFV1
@ AV_CODEC_ID_FFV1
Definition: codec_id.h:83
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:470
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1652
AVPacket::size
int size
Definition: packet.h:374
ff_thread_decode_frame
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
Definition: pthread_frame.c:503
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:187
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:185
AVCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec.h:318
AVCodec::update_thread_context_for_user
int(* update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy variables back to the user-facing context.
Definition: codec.h:273
cpu.h
PerThreadContext::avpkt
AVPacket * avpkt
Input packet (for decoding) or output (for encoding).
Definition: pthread_frame.c:91
async_unlock
static void async_unlock(FrameThreadContext *fctx)
Definition: pthread_frame.c:164
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1000
FrameThreadContext::async_cond
pthread_cond_t async_cond
Definition: pthread_frame.c:138
PerThreadContext::num_released_buffers
int num_released_buffers
Definition: pthread_frame.c:105
frame.h
buffer.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
av_reallocp_array
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:232
PerThreadContext::parent
struct FrameThreadContext * parent
Definition: pthread_frame.c:77
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
AVCodecContext::skip_loop_filter
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:1659
pthread_t
Definition: os2threads.h:44
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1451
AVCodecContext::channels
int channels
number of audio channels
Definition: avcodec.h:993
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1418
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1453
PerThreadContext::thread_init
int thread_init
Definition: pthread_frame.c:80
STATE_SETTING_UP
@ STATE_SETTING_UP
Definition: pthread_frame.c:52
log.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1822
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
internal.h
common.h
AVCodecContext::hwaccel_flags
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).
Definition: avcodec.h:1917
atomic_store_explicit
#define atomic_store_explicit(object, desired, order)
Definition: stdatomic.h:90
release_delayed_buffers
static void release_delayed_buffers(PerThreadContext *p)
Releases the buffers that this decoding thread was the last user of.
Definition: pthread_frame.c:384
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Definition: hwconfig.h:26
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:462
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:435
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1397
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:974
pthread_cond_t
Definition: os2threads.h:58
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:271
AVCodec::priv_data_size
int priv_data_size
Definition: codec.h:256
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1858
avcodec.h
STATE_GET_BUFFER
@ STATE_GET_BUFFER
Set when the codec calls get_buffer().
Definition: pthread_frame.c:57
DEFINE_OFFSET_ARRAY
DEFINE_OFFSET_ARRAY(FrameThreadContext, thread_ctx, pthread_init_cnt,(OFF(buffer_mutex), OFF(hwaccel_mutex), OFF(async_mutex)),(OFF(async_cond)))
ret
ret
Definition: filter_design.txt:187
AVCodec::caps_internal
int caps_internal
Internal codec capabilities.
Definition: codec.h:254
ff_frame_thread_init
int ff_frame_thread_init(AVCodecContext *avctx)
Definition: pthread_frame.c:842
PerThreadContext::async_serializing
int async_serializing
Definition: pthread_frame.c:118
AVCodecContext::opaque
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:425
pthread_cond_signal
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
AVCodecContext::draw_horiz_band
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, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band.
Definition: avcodec.h:618
thread_get_buffer_internal
static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int flags)
Definition: pthread_frame.c:950
AVCodecContext
main external API structure.
Definition: avcodec.h:383
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1459
PerThreadContext::hwaccel_serializing
int hwaccel_serializing
Definition: pthread_frame.c:117
ThreadFrame
Definition: thread.h:34
PerThreadContext::frame
AVFrame * frame
Output frame (for decoding) or input (for encoding).
Definition: pthread_frame.c:93
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1525
ff_thread_get_format
FF_DISABLE_DEPRECATION_WARNINGS enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: pthread_frame.c:1020
PerThreadContext::result_format
enum AVPixelFormat result_format
get_format() result
Definition: pthread_frame.c:112
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1984
AV_CODEC_CAP_DELAY
#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:82
ff_pthread_init
av_cold int ff_pthread_init(void *obj, const unsigned offsets[])
Initialize/destroy a list of mutexes/conditions contained in a structure.
Definition: pthread.c:107
pthread_cond_wait
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1302
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:82
ff_thread_get_buffer
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1048
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:571
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:391
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FrameThreadContext::delaying
int delaying
Set for the first N packets, where N is the number of threads.
Definition: pthread_frame.c:144
STATE_GET_FORMAT
@ STATE_GET_FORMAT
Set when the codec calls get_format().
Definition: pthread_frame.c:62
mem.h
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:77
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1023
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1775
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::reordered_opaque
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame....
Definition: avcodec.h:1352
AVCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec.h:289
AVCodecInternal::thread_ctx
void * thread_ctx
Definition: internal.h:134
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
PerThreadContext::mutex
pthread_mutex_t mutex
Mutex used to protect the contents of the PerThreadContext.
Definition: pthread_frame.c:86
AVCodec::decode
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
Definition: codec.h:316
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
PerThreadContext::requested_frame
AVFrame * requested_frame
AVFrame the codec passed to get_buffer()
Definition: pthread_frame.c:108
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1717
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1228
AVCodecContext::sample_aspect_ratio
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:753
mutex
static AVMutex mutex
Definition: log.c:44
PerThreadContext::released_buffers_allocated
int released_buffers_allocated
Definition: pthread_frame.c:106
PerThreadContext::progress_cond
pthread_cond_t progress_cond
Used by child threads to wait for progress to change.
Definition: pthread_frame.c:83
FrameThreadContext::threads
PerThreadContext * threads
The contexts for each thread.
Definition: pthread_frame.c:127
update_context_from_thread
static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src, int for_user)
Update the next thread's AVCodecContext with values from the reference thread's context.
Definition: pthread_frame.c:263
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:64
Generated on Wed Aug 24 2022 21:37:51 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /