FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 <stdint.h>
28 
29 #if HAVE_PTHREADS
30 #include <pthread.h>
31 #elif HAVE_W32THREADS
32 #include "compat/w32pthreads.h"
33 #elif HAVE_OS2THREADS
34 #include "compat/os2threads.h"
35 #endif
36 
37 #include "avcodec.h"
38 #include "internal.h"
39 #include "pthread_internal.h"
40 #include "thread.h"
41 
42 #include "libavutil/avassert.h"
43 #include "libavutil/buffer.h"
44 #include "libavutil/common.h"
45 #include "libavutil/cpu.h"
46 #include "libavutil/frame.h"
47 #include "libavutil/log.h"
48 #include "libavutil/mem.h"
49 
50 /**
51  * Context used by codec threads and stored in their AVCodecInternal thread_ctx.
52  */
53 typedef struct PerThreadContext {
55 
58  pthread_cond_t input_cond; ///< Used to wait for a new packet from the main thread.
59  pthread_cond_t progress_cond; ///< Used by child threads to wait for progress to change.
60  pthread_cond_t output_cond; ///< Used by the main thread to wait for frames to finish.
61 
62  pthread_mutex_t mutex; ///< Mutex used to protect the contents of the PerThreadContext.
63  pthread_mutex_t progress_mutex; ///< Mutex used to protect frame progress values and progress_cond.
64 
65  AVCodecContext *avctx; ///< Context used to decode packets passed to this thread.
66 
67  AVPacket avpkt; ///< Input packet (for decoding) or output (for encoding).
68  uint8_t *buf; ///< backup storage for packet data when the input packet is not refcounted
69  int allocated_buf_size; ///< Size allocated for buf
70 
71  AVFrame *frame; ///< Output frame (for decoding) or input (for encoding).
72  int got_frame; ///< The output of got_picture_ptr from the last avcodec_decode_video() call.
73  int result; ///< The result of the last codec decode/encode() call.
74 
75  enum {
76  STATE_INPUT_READY, ///< Set when the thread is awaiting a packet.
77  STATE_SETTING_UP, ///< Set before the codec has called ff_thread_finish_setup().
79  * Set when the codec calls get_buffer().
80  * State is returned to STATE_SETTING_UP afterwards.
81  */
83  * Set when the codec calls get_format().
84  * State is returned to STATE_SETTING_UP afterwards.
85  */
86  STATE_SETUP_FINISHED ///< Set after the codec has called ff_thread_finish_setup().
87  } state;
88 
89  /**
90  * Array of frames passed to ff_thread_release_buffer().
91  * Frames are released after all threads referencing them are finished.
92  */
96 
97  AVFrame *requested_frame; ///< AVFrame the codec passed to get_buffer()
98  int requested_flags; ///< flags passed to get_buffer() for requested_frame
99 
100  const enum AVPixelFormat *available_formats; ///< Format array for get_format()
101  enum AVPixelFormat result_format; ///< get_format() result
103 
104 /**
105  * Context stored in the client AVCodecInternal thread_ctx.
106  */
107 typedef struct FrameThreadContext {
108  PerThreadContext *threads; ///< The contexts for each thread.
109  PerThreadContext *prev_thread; ///< The last thread submit_packet() was called on.
110 
111  pthread_mutex_t buffer_mutex; ///< Mutex used to protect get/release_buffer().
112 
113  int next_decoding; ///< The next context to submit a packet to.
114  int next_finished; ///< The next context to return output from.
115 
116  int delaying; /**<
117  * Set for the first N packets, where N is the number of threads.
118  * While it is set, ff_thread_en/decode_frame won't return any results.
119  */
120 
121  int die; ///< Set when threads should exit.
123 
124 #define THREAD_SAFE_CALLBACKS(avctx) \
125 ((avctx)->thread_safe_callbacks || (!(avctx)->get_buffer && (avctx)->get_buffer2 == avcodec_default_get_buffer2))
126 
127 /**
128  * Codec worker thread.
129  *
130  * Automatically calls ff_thread_finish_setup() if the codec does
131  * not provide an update_thread_context method, or if the codec returns
132  * before calling it.
133  */
134 static attribute_align_arg void *frame_worker_thread(void *arg)
135 {
136  PerThreadContext *p = arg;
137  FrameThreadContext *fctx = p->parent;
138  AVCodecContext *avctx = p->avctx;
139  const AVCodec *codec = avctx->codec;
140 
142  while (1) {
143  while (p->state == STATE_INPUT_READY && !fctx->die)
145 
146  if (fctx->die) break;
147 
148  if (!codec->update_thread_context && THREAD_SAFE_CALLBACKS(avctx))
149  ff_thread_finish_setup(avctx);
150 
151  av_frame_unref(p->frame);
152  p->got_frame = 0;
153  p->result = codec->decode(avctx, p->frame, &p->got_frame, &p->avpkt);
154 
155  if ((p->result < 0 || !p->got_frame) && p->frame->buf[0]) {
156  if (avctx->internal->allocate_progress)
157  av_log(avctx, AV_LOG_ERROR, "A frame threaded decoder did not "
158  "free the frame on failure. This is a bug, please report it.\n");
159  av_frame_unref(p->frame);
160  }
161 
162  if (p->state == STATE_SETTING_UP) ff_thread_finish_setup(avctx);
163 
165 #if 0 //BUFREF-FIXME
166  for (i = 0; i < MAX_BUFFERS; i++)
167  if (p->progress_used[i] && (p->got_frame || p->result<0 || avctx->codec_id != AV_CODEC_ID_H264)) {
168  p->progress[i][0] = INT_MAX;
169  p->progress[i][1] = INT_MAX;
170  }
171 #endif
172  p->state = STATE_INPUT_READY;
173 
177  }
179 
180  return NULL;
181 }
182 
183 /**
184  * Update the next thread's AVCodecContext with values from the reference thread's context.
185  *
186  * @param dst The destination context.
187  * @param src The source context.
188  * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
189  */
191 {
192  int err = 0;
193 
194  if (dst != src) {
195  dst->time_base = src->time_base;
196  dst->width = src->width;
197  dst->height = src->height;
198  dst->pix_fmt = src->pix_fmt;
199 
200  dst->coded_width = src->coded_width;
201  dst->coded_height = src->coded_height;
202 
203  dst->has_b_frames = src->has_b_frames;
204  dst->idct_algo = src->idct_algo;
205 
209 
210  dst->profile = src->profile;
211  dst->level = src->level;
212 
214  dst->ticks_per_frame = src->ticks_per_frame;
215  dst->color_primaries = src->color_primaries;
216 
217  dst->color_trc = src->color_trc;
218  dst->colorspace = src->colorspace;
219  dst->color_range = src->color_range;
221 
222  dst->hwaccel = src->hwaccel;
223  dst->hwaccel_context = src->hwaccel_context;
224 
225  dst->channels = src->channels;
226  dst->sample_rate = src->sample_rate;
227  dst->sample_fmt = src->sample_fmt;
228  dst->channel_layout = src->channel_layout;
229  }
230 
231  if (for_user) {
232  dst->delay = src->thread_count - 1;
233  dst->coded_frame = src->coded_frame;
234  } else {
235  if (dst->codec->update_thread_context)
236  err = dst->codec->update_thread_context(dst, src);
237  }
238 
239  return err;
240 }
241 
242 /**
243  * Update the next thread's AVCodecContext with values set by the user.
244  *
245  * @param dst The destination context.
246  * @param src The source context.
247  * @return 0 on success, negative error code on failure
248  */
250 {
251 #define copy_fields(s, e) memcpy(&dst->s, &src->s, (char*)&dst->e - (char*)&dst->s);
252  dst->flags = src->flags;
253 
254  dst->draw_horiz_band= src->draw_horiz_band;
255  dst->get_buffer2 = src->get_buffer2;
256 #if FF_API_GET_BUFFER
258  dst->get_buffer = src->get_buffer;
259  dst->release_buffer = src->release_buffer;
261 #endif
262 
263  dst->opaque = src->opaque;
264  dst->debug = src->debug;
265  dst->debug_mv = src->debug_mv;
266 
267  dst->slice_flags = src->slice_flags;
268  dst->flags2 = src->flags2;
269 
270  copy_fields(skip_loop_filter, subtitle_header);
271 
272  dst->frame_number = src->frame_number;
275 
276  if (src->slice_count && src->slice_offset) {
277  if (dst->slice_count < src->slice_count) {
278  int *tmp = av_realloc(dst->slice_offset, src->slice_count *
279  sizeof(*dst->slice_offset));
280  if (!tmp) {
281  av_free(dst->slice_offset);
282  return AVERROR(ENOMEM);
283  }
284  dst->slice_offset = tmp;
285  }
286  memcpy(dst->slice_offset, src->slice_offset,
287  src->slice_count * sizeof(*dst->slice_offset));
288  }
289  dst->slice_count = src->slice_count;
290  return 0;
291 #undef copy_fields
292 }
293 
294 /// Releases the buffers that this decoding thread was the last user of.
296 {
297  FrameThreadContext *fctx = p->parent;
298 
299  while (p->num_released_buffers > 0) {
300  AVFrame *f;
301 
303 
304  // fix extended data in case the caller screwed it up
308  f->extended_data = f->data;
309  av_frame_unref(f);
310 
312  }
313 }
314 
316 {
317  FrameThreadContext *fctx = p->parent;
318  PerThreadContext *prev_thread = fctx->prev_thread;
319  const AVCodec *codec = p->avctx->codec;
320  int ret;
321 
322  if (!avpkt->size && !(codec->capabilities & CODEC_CAP_DELAY)) return 0;
323 
325 
327 
328  if (prev_thread) {
329  int err;
330  if (prev_thread->state == STATE_SETTING_UP) {
331  pthread_mutex_lock(&prev_thread->progress_mutex);
332  while (prev_thread->state == STATE_SETTING_UP)
333  pthread_cond_wait(&prev_thread->progress_cond, &prev_thread->progress_mutex);
334  pthread_mutex_unlock(&prev_thread->progress_mutex);
335  }
336 
337  err = update_context_from_thread(p->avctx, prev_thread->avctx, 0);
338  if (err) {
340  return err;
341  }
342  }
343 
346  p->avpkt = *avpkt;
347  if (avpkt->buf)
348  p->avpkt.buf = av_buffer_ref(avpkt->buf);
349  else {
351  if (!p->buf) {
353  return AVERROR(ENOMEM);
354  }
355  p->avpkt.data = p->buf;
356  memcpy(p->buf, avpkt->data, avpkt->size);
357  memset(p->buf + avpkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
358  }
359  if ((ret = av_copy_packet_side_data(&p->avpkt, avpkt)) < 0)
360  return ret;
361 
362  p->state = STATE_SETTING_UP;
365 
366  /*
367  * If the client doesn't have a thread-safe get_buffer(),
368  * then decoding threads call back to the main thread,
369  * and it calls back to the client here.
370  */
371 
373  if (!p->avctx->thread_safe_callbacks && (
376  p->avctx->get_buffer ||
377 #endif
380  while (p->state != STATE_SETUP_FINISHED && p->state != STATE_INPUT_READY) {
381  int call_done = 1;
383  while (p->state == STATE_SETTING_UP)
385 
386  switch (p->state) {
387  case STATE_GET_BUFFER:
389  break;
390  case STATE_GET_FORMAT:
392  break;
393  default:
394  call_done = 0;
395  break;
396  }
397  if (call_done) {
398  p->state = STATE_SETTING_UP;
400  }
402  }
403  }
404 
405  fctx->prev_thread = p;
406  fctx->next_decoding++;
407 
408  return 0;
409 }
410 
412  AVFrame *picture, int *got_picture_ptr,
413  AVPacket *avpkt)
414 {
415  FrameThreadContext *fctx = avctx->internal->thread_ctx;
416  int finished = fctx->next_finished;
417  PerThreadContext *p;
418  int err;
419 
420  /*
421  * Submit a packet to the next decoding thread.
422  */
423 
424  p = &fctx->threads[fctx->next_decoding];
425  err = update_context_from_user(p->avctx, avctx);
426  if (err) return err;
427  err = submit_packet(p, avpkt);
428  if (err) return err;
429 
430  /*
431  * If we're still receiving the initial packets, don't return a frame.
432  */
433 
434  if (fctx->next_decoding > (avctx->thread_count-1-(avctx->codec_id == AV_CODEC_ID_FFV1)))
435  fctx->delaying = 0;
436 
437  if (fctx->delaying) {
438  *got_picture_ptr=0;
439  if (avpkt->size)
440  return avpkt->size;
441  }
442 
443  /*
444  * Return the next available frame from the oldest thread.
445  * If we're at the end of the stream, then we have to skip threads that
446  * didn't output a frame, because we don't want to accidentally signal
447  * EOF (avpkt->size == 0 && *got_picture_ptr == 0).
448  */
449 
450  do {
451  p = &fctx->threads[finished++];
452 
453  if (p->state != STATE_INPUT_READY) {
455  while (p->state != STATE_INPUT_READY)
458  }
459 
460  av_frame_move_ref(picture, p->frame);
461  *got_picture_ptr = p->got_frame;
462  picture->pkt_dts = p->avpkt.dts;
463 
464  /*
465  * A later call with avkpt->size == 0 may loop over all threads,
466  * including this one, searching for a frame to return before being
467  * stopped by the "finished != fctx->next_finished" condition.
468  * Make sure we don't mistakenly return the same frame again.
469  */
470  p->got_frame = 0;
471 
472  if (finished >= avctx->thread_count) finished = 0;
473  } while (!avpkt->size && !*got_picture_ptr && finished != fctx->next_finished);
474 
475  update_context_from_thread(avctx, p->avctx, 1);
476 
477  if (fctx->next_decoding >= avctx->thread_count) fctx->next_decoding = 0;
478 
479  fctx->next_finished = finished;
480 
481  /* return the size of the consumed packet if no error occurred */
482  return (p->result >= 0) ? avpkt->size : p->result;
483 }
484 
485 void ff_thread_report_progress(ThreadFrame *f, int n, int field)
486 {
487  PerThreadContext *p;
488  volatile int *progress = f->progress ? (int*)f->progress->data : NULL;
489 
490  if (!progress || progress[field] >= n) return;
491 
492  p = f->owner->internal->thread_ctx;
493 
494  if (f->owner->debug&FF_DEBUG_THREADS)
495  av_log(f->owner, AV_LOG_DEBUG, "%p finished %d field %d\n", progress, n, field);
496 
498  progress[field] = n;
501 }
502 
503 void ff_thread_await_progress(ThreadFrame *f, int n, int field)
504 {
505  PerThreadContext *p;
506  volatile int *progress = f->progress ? (int*)f->progress->data : NULL;
507 
508  if (!progress || progress[field] >= n) return;
509 
510  p = f->owner->internal->thread_ctx;
511 
512  if (f->owner->debug&FF_DEBUG_THREADS)
513  av_log(f->owner, AV_LOG_DEBUG, "thread awaiting %d field %d from %p\n", n, field, progress);
514 
516  while (progress[field] < n)
519 }
520 
522  PerThreadContext *p = avctx->internal->thread_ctx;
523 
524  if (!(avctx->active_thread_type&FF_THREAD_FRAME)) return;
525 
526  if(p->state == STATE_SETUP_FINISHED){
527  av_log(avctx, AV_LOG_WARNING, "Multiple ff_thread_finish_setup() calls\n");
528  }
529 
531  p->state = STATE_SETUP_FINISHED;
534 }
535 
536 /// Waits for all threads to finish.
537 static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
538 {
539  int i;
540 
541  for (i = 0; i < thread_count; i++) {
542  PerThreadContext *p = &fctx->threads[i];
543 
544  if (p->state != STATE_INPUT_READY) {
546  while (p->state != STATE_INPUT_READY)
549  }
550  p->got_frame = 0;
551  }
552 }
553 
554 void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
555 {
556  FrameThreadContext *fctx = avctx->internal->thread_ctx;
557  const AVCodec *codec = avctx->codec;
558  int i;
559 
560  park_frame_worker_threads(fctx, thread_count);
561 
562  if (fctx->prev_thread && fctx->prev_thread != fctx->threads)
563  if (update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0) < 0) {
564  av_log(avctx, AV_LOG_ERROR, "Final thread update failed\n");
566  fctx->threads->avctx->internal->is_copy = 1;
567  }
568 
569  fctx->die = 1;
570 
571  for (i = 0; i < thread_count; i++) {
572  PerThreadContext *p = &fctx->threads[i];
573 
577 
578  if (p->thread_init)
579  pthread_join(p->thread, NULL);
580  p->thread_init=0;
581 
582  if (codec->close)
583  codec->close(p->avctx);
584 
585  avctx->codec = NULL;
586 
588  av_frame_free(&p->frame);
589  }
590 
591  for (i = 0; i < thread_count; i++) {
592  PerThreadContext *p = &fctx->threads[i];
593 
601  av_freep(&p->buf);
603 
604  if (i) {
605  av_freep(&p->avctx->priv_data);
607  }
608 
609  av_freep(&p->avctx->internal);
610  av_freep(&p->avctx);
611  }
612 
613  av_freep(&fctx->threads);
615  av_freep(&avctx->internal->thread_ctx);
616 }
617 
619 {
620  int thread_count = avctx->thread_count;
621  const AVCodec *codec = avctx->codec;
622  AVCodecContext *src = avctx;
623  FrameThreadContext *fctx;
624  int i, err = 0;
625 
626 #if HAVE_W32THREADS
627  w32thread_init();
628 #endif
629 
630  if (!thread_count) {
631  int nb_cpus = av_cpu_count();
632  if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) || avctx->debug_mv)
633  nb_cpus = 1;
634  // use number of cores + 1 as thread count if there is more than one
635  if (nb_cpus > 1)
636  thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
637  else
638  thread_count = avctx->thread_count = 1;
639  }
640 
641  if (thread_count <= 1) {
642  avctx->active_thread_type = 0;
643  return 0;
644  }
645 
646  avctx->internal->thread_ctx = fctx = av_mallocz(sizeof(FrameThreadContext));
647 
648  fctx->threads = av_mallocz(sizeof(PerThreadContext) * thread_count);
649  pthread_mutex_init(&fctx->buffer_mutex, NULL);
650  fctx->delaying = 1;
651 
652  for (i = 0; i < thread_count; i++) {
654  PerThreadContext *p = &fctx->threads[i];
655 
656  pthread_mutex_init(&p->mutex, NULL);
658  pthread_cond_init(&p->input_cond, NULL);
659  pthread_cond_init(&p->progress_cond, NULL);
660  pthread_cond_init(&p->output_cond, NULL);
661 
662  p->frame = av_frame_alloc();
663  if (!p->frame) {
664  err = AVERROR(ENOMEM);
665  av_freep(&copy);
666  goto error;
667  }
668 
669  p->parent = fctx;
670  p->avctx = copy;
671 
672  if (!copy) {
673  err = AVERROR(ENOMEM);
674  goto error;
675  }
676 
677  *copy = *src;
678 
679  copy->internal = av_malloc(sizeof(AVCodecInternal));
680  if (!copy->internal) {
681  err = AVERROR(ENOMEM);
682  goto error;
683  }
684  *copy->internal = *src->internal;
685  copy->internal->thread_ctx = p;
686  copy->internal->pkt = &p->avpkt;
687 
688  if (!i) {
689  src = copy;
690 
691  if (codec->init)
692  err = codec->init(copy);
693 
694  update_context_from_thread(avctx, copy, 1);
695  } else {
696  copy->priv_data = av_malloc(codec->priv_data_size);
697  if (!copy->priv_data) {
698  err = AVERROR(ENOMEM);
699  goto error;
700  }
701  memcpy(copy->priv_data, src->priv_data, codec->priv_data_size);
702  copy->internal->is_copy = 1;
703 
704  if (codec->init_thread_copy)
705  err = codec->init_thread_copy(copy);
706  }
707 
708  if (err) goto error;
709 
710  err = AVERROR(pthread_create(&p->thread, NULL, frame_worker_thread, p));
711  p->thread_init= !err;
712  if(!p->thread_init)
713  goto error;
714  }
715 
716  return 0;
717 
718 error:
719  ff_frame_thread_free(avctx, i+1);
720 
721  return err;
722 }
723 
725 {
726  int i;
727  FrameThreadContext *fctx = avctx->internal->thread_ctx;
728 
729  if (!fctx) return;
730 
732  if (fctx->prev_thread) {
733  if (fctx->prev_thread != &fctx->threads[0])
735  }
736 
737  fctx->next_decoding = fctx->next_finished = 0;
738  fctx->delaying = 1;
739  fctx->prev_thread = NULL;
740  for (i = 0; i < avctx->thread_count; i++) {
741  PerThreadContext *p = &fctx->threads[i];
742  // Make sure decode flush calls with size=0 won't return old frames
743  p->got_frame = 0;
744  av_frame_unref(p->frame);
745 
747 
748  if (avctx->codec->flush)
749  avctx->codec->flush(p->avctx);
750  }
751 }
752 
754 {
755  PerThreadContext *p = avctx->internal->thread_ctx;
756  if ((avctx->active_thread_type&FF_THREAD_FRAME) && p->state != STATE_SETTING_UP &&
757  (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
758  return 0;
759  }
760  return 1;
761 }
762 
764 {
765  PerThreadContext *p = avctx->internal->thread_ctx;
766  int err;
767 
768  f->owner = avctx;
769 
770  ff_init_buffer_info(avctx, f->f);
771 
772  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
773  return ff_get_buffer(avctx, f->f, flags);
774 
775  if (p->state != STATE_SETTING_UP &&
776  (avctx->codec->update_thread_context || !THREAD_SAFE_CALLBACKS(avctx))) {
777  av_log(avctx, AV_LOG_ERROR, "get_buffer() cannot be called after ff_thread_finish_setup()\n");
778  return -1;
779  }
780 
781  if (avctx->internal->allocate_progress) {
782  int *progress;
783  f->progress = av_buffer_alloc(2 * sizeof(int));
784  if (!f->progress) {
785  return AVERROR(ENOMEM);
786  }
787  progress = (int*)f->progress->data;
788 
789  progress[0] = progress[1] = -1;
790  }
791 
794  if (avctx->thread_safe_callbacks || (
796  !avctx->get_buffer &&
797 #endif
800  err = ff_get_buffer(avctx, f->f, flags);
801  } else {
803  p->requested_frame = f->f;
804  p->requested_flags = flags;
805  p->state = STATE_GET_BUFFER;
807 
808  while (p->state != STATE_SETTING_UP)
810 
811  err = p->result;
812 
814 
815  }
816  if (!THREAD_SAFE_CALLBACKS(avctx) && !avctx->codec->update_thread_context)
817  ff_thread_finish_setup(avctx);
818 
819  if (err)
821 
823 
824  return err;
825 }
826 
828 {
829  enum AVPixelFormat res;
830  PerThreadContext *p = avctx->internal->thread_ctx;
831  if (!(avctx->active_thread_type & FF_THREAD_FRAME) || avctx->thread_safe_callbacks ||
833  return avctx->get_format(avctx, fmt);
834  if (p->state != STATE_SETTING_UP) {
835  av_log(avctx, AV_LOG_ERROR, "get_format() cannot be called after ff_thread_finish_setup()\n");
836  return -1;
837  }
839  p->available_formats = fmt;
840  p->state = STATE_GET_FORMAT;
842 
843  while (p->state != STATE_SETTING_UP)
845 
846  res = p->result_format;
847 
849 
850  return res;
851 }
852 
854 {
855  int ret = thread_get_buffer_internal(avctx, f, flags);
856  if (ret < 0)
857  av_log(avctx, AV_LOG_ERROR, "thread_get_buffer() failed\n");
858  return ret;
859 }
860 
862 {
863  PerThreadContext *p = avctx->internal->thread_ctx;
864  FrameThreadContext *fctx;
865  AVFrame *dst, *tmp;
867  int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
868  avctx->thread_safe_callbacks ||
869  (
871  !avctx->get_buffer &&
872 #endif
875 
876  if (!f->f->buf[0])
877  return;
878 
879  if (avctx->debug & FF_DEBUG_BUFFERS)
880  av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
881 
883  f->owner = NULL;
884 
885  if (can_direct_free) {
886  av_frame_unref(f->f);
887  return;
888  }
889 
890  fctx = p->parent;
892 
893  if (p->num_released_buffers + 1 >= INT_MAX / sizeof(*p->released_buffers))
894  goto fail;
896  (p->num_released_buffers + 1) *
897  sizeof(*p->released_buffers));
898  if (!tmp)
899  goto fail;
900  p->released_buffers = tmp;
901 
903  av_frame_move_ref(dst, f->f);
904 
906 
907 fail:
909 }