FFmpeg  4.0
pthread_slice.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  * Slice multithreading support functions
22  * @see doc/multithreading.txt
23  */
24 
25 #include "config.h"
26 
27 #include "avcodec.h"
28 #include "internal.h"
29 #include "pthread_internal.h"
30 #include "thread.h"
31 
32 #include "libavutil/avassert.h"
33 #include "libavutil/common.h"
34 #include "libavutil/cpu.h"
35 #include "libavutil/mem.h"
36 #include "libavutil/thread.h"
37 #include "libavutil/slicethread.h"
38 
39 typedef int (action_func)(AVCodecContext *c, void *arg);
40 typedef int (action_func2)(AVCodecContext *c, void *arg, int jobnr, int threadnr);
42 
43 typedef struct SliceThreadContext {
48  void *args;
49  int *rets;
50  int job_size;
51 
52  int *entries;
58 
59 static void main_function(void *priv) {
60  AVCodecContext *avctx = priv;
62  c->mainfunc(avctx);
63 }
64 
65 static void worker_func(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
66 {
67  AVCodecContext *avctx = priv;
69  int ret;
70 
71  ret = c->func ? c->func(avctx, (char *)c->args + c->job_size * jobnr)
72  : c->func2(avctx, c->args, jobnr, threadnr);
73  if (c->rets)
74  c->rets[jobnr] = ret;
75 }
76 
78 {
80  int i;
81 
83 
84  for (i = 0; i < c->thread_count; i++) {
87  }
88 
89  av_freep(&c->entries);
92  av_freep(&avctx->internal->thread_ctx);
93 }
94 
95 static int thread_execute(AVCodecContext *avctx, action_func* func, void *arg, int *ret, int job_count, int job_size)
96 {
98 
99  if (!(avctx->active_thread_type&FF_THREAD_SLICE) || avctx->thread_count <= 1)
100  return avcodec_default_execute(avctx, func, arg, ret, job_count, job_size);
101 
102  if (job_count <= 0)
103  return 0;
104 
105  c->job_size = job_size;
106  c->args = arg;
107  c->func = func;
108  c->rets = ret;
109 
110  avpriv_slicethread_execute(c->thread, job_count, !!c->mainfunc );
111  return 0;
112 }
113 
114 static int thread_execute2(AVCodecContext *avctx, action_func2* func2, void *arg, int *ret, int job_count)
115 {
117  c->func2 = func2;
118  return thread_execute(avctx, NULL, arg, ret, job_count, 0);
119 }
120 
122 {
124  c->func2 = func2;
125  c->mainfunc = mainfunc;
126  return thread_execute(avctx, NULL, arg, ret, job_count, 0);
127 }
128 
130 {
132  int thread_count = avctx->thread_count;
133  static void (*mainfunc)(void *);
134 
135  // We cannot do this in the encoder init as the threads are created before
136  if (av_codec_is_encoder(avctx->codec) &&
137  avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
138  avctx->height > 2800)
139  thread_count = avctx->thread_count = 1;
140 
141  if (!thread_count) {
142  int nb_cpus = av_cpu_count();
143  if (avctx->height)
144  nb_cpus = FFMIN(nb_cpus, (avctx->height+15)/16);
145  // use number of cores + 1 as thread count if there is more than one
146  if (nb_cpus > 1)
147  thread_count = avctx->thread_count = FFMIN(nb_cpus + 1, MAX_AUTO_THREADS);
148  else
149  thread_count = avctx->thread_count = 1;
150  }
151 
152  if (thread_count <= 1) {
153  avctx->active_thread_type = 0;
154  return 0;
155  }
156 
157  avctx->internal->thread_ctx = c = av_mallocz(sizeof(*c));
159  if (!c || (thread_count = avpriv_slicethread_create(&c->thread, avctx, worker_func, mainfunc, thread_count)) <= 1) {
160  if (c)
162  av_freep(&avctx->internal->thread_ctx);
163  avctx->thread_count = 1;
164  avctx->active_thread_type = 0;
165  return 0;
166  }
167  avctx->thread_count = thread_count;
168 
169  avctx->execute = thread_execute;
170  avctx->execute2 = thread_execute2;
171  return 0;
172 }
173 
174 void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
175 {
177  int *entries = p->entries;
178 
179  pthread_mutex_lock(&p->progress_mutex[thread]);
180  entries[field] +=n;
181  pthread_cond_signal(&p->progress_cond[thread]);
183 }
184 
185 void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
186 {
188  int *entries = p->entries;
189 
190  if (!entries || !field) return;
191 
192  thread = thread ? thread - 1 : p->thread_count - 1;
193 
194  pthread_mutex_lock(&p->progress_mutex[thread]);
195  while ((entries[field - 1] - entries[field]) < shift){
196  pthread_cond_wait(&p->progress_cond[thread], &p->progress_mutex[thread]);
197  }
199 }
200 
202 {
203  int i;
204 
205  if (avctx->active_thread_type & FF_THREAD_SLICE) {
207 
208  if (p->entries) {
209  av_assert0(p->thread_count == avctx->thread_count);
210  av_freep(&p->entries);
211  }
212 
213  p->thread_count = avctx->thread_count;
214  p->entries = av_mallocz_array(count, sizeof(int));
215 
216  if (!p->progress_mutex) {
219  }
220 
221  if (!p->entries || !p->progress_mutex || !p->progress_cond) {
222  av_freep(&p->entries);
224  av_freep(&p->progress_cond);
225  return AVERROR(ENOMEM);
226  }
227  p->entries_count = count;
228 
229  for (i = 0; i < p->thread_count; i++) {
232  }
233  }
234 
235  return 0;
236 }
237 
239 {
241  memset(p->entries, 0, p->entries_count * sizeof(int));
242 }
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1527
int ff_slice_thread_init(AVCodecContext *avctx)
static int shift(int a, int b)
Definition: sonic.c:82
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:108
#define pthread_mutex_lock(a)
Definition: ffprobe.c:61
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:166
int av_cpu_count(void)
Definition: cpu.c:267
Memory handling functions.
int() action_func2(AVCodecContext *c, void *arg, int jobnr, int threadnr)
Definition: pthread_slice.c:40
static void worker_func(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads)
Definition: pthread_slice.c:65
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:140
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:94
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
struct AVSliceThread AVSliceThread
Definition: slicethread.h:22
void * thread_ctx
Definition: internal.h:163
Multithreading support functions.
pthread_mutex_t * progress_mutex
Definition: pthread_slice.c:56
static void main_function(void *priv)
Definition: pthread_slice.c:59
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:148
#define AVERROR(e)
Definition: error.h:43
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2788
AVSliceThread * thread
Definition: pthread_slice.c:44
action_func2 * func2
Definition: pthread_slice.c:46
const char * arg
Definition: jacosubdec.c:66
simple assert() macros that are a bit more flexible than ISO C assert().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
action_func * func
Definition: pthread_slice.c:45
int ff_alloc_entries(AVCodecContext *avctx, int count)
static int thread_execute2(AVCodecContext *avctx, action_func2 *func2, void *arg, int *ret, int job_count)
#define FFMIN(a, b)
Definition: common.h:96
void avpriv_slicethread_free(AVSliceThread **pctx)
Destroy slice threading context.
Definition: slicethread.c:250
void ff_slice_thread_free(AVCodecContext *avctx)
Definition: pthread_slice.c:77
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:100
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:2781
pthread_cond_t * progress_cond
Definition: pthread_slice.c:55
int n
Definition: avisynth_c.h:684
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:65
if(ret< 0)
Definition: vf_mcdeint.c:279
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:2769
int() action_func(AVCodecContext *c, void *arg)
Definition: pthread_slice.c:39
void ff_reset_entries(AVCodecContext *avctx)
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:2829
Libavcodec external API header.
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
typedef void(RENAME(mix_any_func_type))
enum AVCodecID codec_id
Definition: avcodec.h:1528
int avpriv_slicethread_create(AVSliceThread **pctx, void *priv, void(*worker_func)(void *priv, int jobnr, int threadnr, int nb_jobs, int nb_threads), void(*main_func)(void *priv), int nb_threads)
Create slice threading context.
Definition: slicethread.c:236
main external API structure.
Definition: avcodec.h:1518
void avpriv_slicethread_execute(AVSliceThread *ctx, int nb_jobs, int execute_main)
Execute slice threading.
Definition: slicethread.c:245
#define MAX_AUTO_THREADS
#define FF_CODEC_CAP_SLICE_THREAD_HAS_MF
Codec initializes slice-based threading with a main function.
Definition: internal.h:70
int
int() main_func(AVCodecContext *c)
Definition: pthread_slice.c:41
common internal api header.
_fmutex pthread_mutex_t
Definition: os2threads.h:49
common internal and external API header
main_func * mainfunc
Definition: pthread_slice.c:47
static double c[64]
int ff_slice_thread_execute_with_mainfunc(AVCodecContext *avctx, action_func2 *func2, main_func *mainfunc, void *arg, int *ret, int job_count)
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:129
int caps_internal
Internal codec capabilities.
Definition: avcodec.h:3534
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1553
#define av_freep(p)
void INT64 INT64 count
Definition: avisynth_c.h:690
#define av_malloc_array(a, b)
static int thread_execute(AVCodecContext *avctx, action_func *func, void *arg, int *ret, int job_count, int job_size)
Definition: pthread_slice.c:95
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:2809
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
Definition: utils.c:431
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
Definition: mem.c:191