FFmpeg
frame_thread_encoder.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include <stdatomic.h>
22 
23 #include "frame_thread_encoder.h"
24 
25 #include "libavutil/avassert.h"
26 #include "libavutil/cpu.h"
27 #include "libavutil/mem.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/thread.h"
30 #include "avcodec.h"
31 #include "avcodec_internal.h"
32 #include "codec_par.h"
33 #include "encode.h"
34 #include "internal.h"
35 #include "pthread_internal.h"
36 
37 #define MAX_THREADS 64
38 /* There can be as many as MAX_THREADS + 1 outstanding tasks.
39  * An additional + 1 is needed so that one can distinguish
40  * the case of zero and MAX_THREADS + 1 outstanding tasks modulo
41  * the number of buffers. */
42 #define BUFFER_SIZE (MAX_THREADS + 2)
43 
44 typedef struct{
48  int finished;
50 } Task;
51 
52 typedef struct{
54 
55  pthread_mutex_t task_fifo_mutex; /* Used to guard (next_)task_index */
57 
58  unsigned pthread_init_cnt;
59  unsigned max_tasks;
60  Task tasks[BUFFER_SIZE];
61  pthread_mutex_t finished_task_mutex; /* Guards tasks[i].finished */
63 
64  unsigned next_task_index;
65  unsigned task_index;
67 
71 
72 #define OFF(member) offsetof(ThreadContext, member)
73 DEFINE_OFFSET_ARRAY(ThreadContext, thread_ctx, pthread_init_cnt,
74  (OFF(task_fifo_mutex), OFF(finished_task_mutex)),
75  (OFF(task_fifo_cond), OFF(finished_task_cond)));
76 #undef OFF
77 
78 static void * attribute_align_arg worker(void *v){
79  AVCodecContext *avctx = v;
81 
82  while (!atomic_load(&c->exit)) {
83  int ret;
84  AVPacket *pkt;
85  AVFrame *frame;
86  Task *task;
87  unsigned task_index;
88 
89  pthread_mutex_lock(&c->task_fifo_mutex);
90  while (c->next_task_index == c->task_index || atomic_load(&c->exit)) {
91  if (atomic_load(&c->exit)) {
92  pthread_mutex_unlock(&c->task_fifo_mutex);
93  goto end;
94  }
95  pthread_cond_wait(&c->task_fifo_cond, &c->task_fifo_mutex);
96  }
97  task_index = c->next_task_index;
98  c->next_task_index = (c->next_task_index + 1) % c->max_tasks;
99  pthread_mutex_unlock(&c->task_fifo_mutex);
100  /* The main thread ensures that any two outstanding tasks have
101  * different indices, ergo each worker thread owns its element
102  * of c->tasks with the exception of finished, which is shared
103  * with the main thread and guarded by finished_task_mutex. */
104  task = &c->tasks[task_index];
105  frame = task->indata;
106  pkt = task->outdata;
107 
108  ret = ff_encode_encode_cb(avctx, pkt, frame, &task->got_packet);
109  pthread_mutex_lock(&c->finished_task_mutex);
110  task->return_code = ret;
111  task->finished = 1;
112  pthread_cond_signal(&c->finished_task_cond);
113  pthread_mutex_unlock(&c->finished_task_mutex);
114  }
115 end:
116  avcodec_free_context(&avctx);
117  return NULL;
118 }
119 
121 {
122  int i=0;
123  ThreadContext *c;
124  AVCodecContext *thread_avctx = NULL;
125  AVCodecParameters *par = NULL;
126  int ret;
127 
128  if( !(avctx->thread_type & FF_THREAD_FRAME)
130  return 0;
131 
132  if( !avctx->thread_count
133  && avctx->codec_id == AV_CODEC_ID_MJPEG
134  && !(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
135  av_log(avctx, AV_LOG_DEBUG,
136  "Forcing thread count to 1 for MJPEG encoding, use -thread_type slice "
137  "or a constant quantizer if you want to use multiple cpu cores\n");
138  avctx->thread_count = 1;
139  }
140  if( avctx->thread_count > 1
141  && avctx->codec_id == AV_CODEC_ID_MJPEG
142  && !(avctx->flags & AV_CODEC_FLAG_QSCALE))
143  av_log(avctx, AV_LOG_WARNING,
144  "MJPEG CBR encoding works badly with frame multi-threading, consider "
145  "using -threads 1, -thread_type slice or a constant quantizer.\n");
146 
147  if (avctx->codec_id == AV_CODEC_ID_HUFFYUV ||
148  avctx->codec_id == AV_CODEC_ID_FFVHUFF) {
149  int warn = 0;
150  int64_t tmp;
151 
152  if (avctx->flags & AV_CODEC_FLAG_PASS1)
153  warn = 1;
154  else if (av_opt_get_int(avctx->priv_data, "context", 0, &tmp) >= 0 &&
155  tmp > 0) {
156  warn = av_opt_get_int(avctx->priv_data, "non_deterministic", 0, &tmp) < 0
157  || !tmp;
158  }
159  // huffyuv does not support these with multiple frame threads currently
160  if (warn) {
161  av_log(avctx, AV_LOG_WARNING,
162  "Forcing thread count to 1 for huffyuv encoding with first pass or context 1\n");
163  avctx->thread_count = 1;
164  }
165  }
166 
167  if(!avctx->thread_count) {
168  avctx->thread_count = av_cpu_count();
169  avctx->thread_count = FFMIN(avctx->thread_count, MAX_THREADS);
170  }
171 
172  if(avctx->thread_count <= 1)
173  return 0;
174 
175  if(avctx->thread_count > MAX_THREADS)
176  return AVERROR(EINVAL);
177 
180  if(!c)
181  return AVERROR(ENOMEM);
182 
183  c->parent_avctx = avctx;
184 
185  ret = ff_pthread_init(c, thread_ctx_offsets);
186  if (ret < 0)
187  goto fail;
188  atomic_init(&c->exit, 0);
189 
190  c->max_tasks = avctx->thread_count + 2;
191  for (unsigned j = 0; j < c->max_tasks; j++) {
192  if (!(c->tasks[j].indata = av_frame_alloc()) ||
193  !(c->tasks[j].outdata = av_packet_alloc())) {
194  ret = AVERROR(ENOMEM);
195  goto fail;
196  }
197  }
198 
199  par = avcodec_parameters_alloc();
200  if (!par) {
201  ret = AVERROR(ENOMEM);
202  goto fail;
203  }
204 
205  ret = avcodec_parameters_from_context(par, avctx);
206  if (ret < 0)
207  goto fail;
208 
209  for(i=0; i<avctx->thread_count ; i++){
210  thread_avctx = avcodec_alloc_context3(avctx->codec);
211  if (!thread_avctx) {
212  ret = AVERROR(ENOMEM);
213  goto fail;
214  }
215 
216  ret = avcodec_parameters_to_context(thread_avctx, par);
217  if (ret < 0)
218  goto fail;
219 
220  ret = av_opt_copy(thread_avctx, avctx);
221  if (ret < 0)
222  goto fail;
223  if (avctx->codec->priv_class) {
224  ret = av_opt_copy(thread_avctx->priv_data, avctx->priv_data);
225  if (ret < 0)
226  goto fail;
227  }
228  thread_avctx->thread_count = 1;
229  thread_avctx->active_thread_type &= ~FF_THREAD_FRAME;
230 
231 #define DUP_MATRIX(m) \
232  if (avctx->m) { \
233  thread_avctx->m = av_memdup(avctx->m, 64 * sizeof(*avctx->m)); \
234  if (!thread_avctx->m) { \
235  ret = AVERROR(ENOMEM); \
236  goto fail; \
237  } \
238  }
239  DUP_MATRIX(intra_matrix);
240  DUP_MATRIX(chroma_intra_matrix);
241  DUP_MATRIX(inter_matrix);
242 
243 #undef DUP_MATRIX
244 
245  thread_avctx->opaque = avctx->opaque;
246  thread_avctx->get_encode_buffer = avctx->get_encode_buffer;
247  thread_avctx->execute = avctx->execute;
248  thread_avctx->execute2 = avctx->execute2;
249  thread_avctx->stats_in = avctx->stats_in;
250 
251  if ((ret = avcodec_open2(thread_avctx, avctx->codec, NULL)) < 0)
252  goto fail;
253  av_assert0(!thread_avctx->internal->frame_thread_encoder);
254  thread_avctx->internal->frame_thread_encoder = c;
255  if ((ret = pthread_create(&c->worker[i], NULL, worker, thread_avctx))) {
256  ret = AVERROR(ret);
257  goto fail;
258  }
259  }
260 
262 
264 
265  return 0;
266 fail:
268  avcodec_free_context(&thread_avctx);
269  avctx->thread_count = i;
270  av_log(avctx, AV_LOG_ERROR, "ff_frame_thread_encoder_init failed\n");
272  return ret;
273 }
274 
276 {
278 
279  /* In case initializing the mutexes/condition variables failed,
280  * they must not be used. In this case the thread_count is zero
281  * as no thread has been initialized yet. */
282  if (avctx->thread_count > 0) {
283  pthread_mutex_lock(&c->task_fifo_mutex);
284  atomic_store(&c->exit, 1);
285  pthread_cond_broadcast(&c->task_fifo_cond);
286  pthread_mutex_unlock(&c->task_fifo_mutex);
287 
288  for (int i = 0; i < avctx->thread_count; i++)
289  pthread_join(c->worker[i], NULL);
290  }
291 
292  for (unsigned i = 0; i < c->max_tasks; i++) {
293  av_frame_free(&c->tasks[i].indata);
294  av_packet_free(&c->tasks[i].outdata);
295  }
296 
297  ff_pthread_free(c, thread_ctx_offsets);
299 }
300 
302  AVFrame *frame, int *got_packet_ptr)
303 {
305  Task *outtask;
306 
307  av_assert1(!*got_packet_ptr);
308 
309  if(frame){
310  av_frame_move_ref(c->tasks[c->task_index].indata, frame);
311 
312  pthread_mutex_lock(&c->task_fifo_mutex);
313  c->task_index = (c->task_index + 1) % c->max_tasks;
314  pthread_cond_signal(&c->task_fifo_cond);
315  pthread_mutex_unlock(&c->task_fifo_mutex);
316  }
317 
318  outtask = &c->tasks[c->finished_task_index];
319  pthread_mutex_lock(&c->finished_task_mutex);
320  /* The access to task_index in the following code is ok,
321  * because it is only ever changed by the main thread. */
322  if (c->task_index == c->finished_task_index ||
323  (frame && !outtask->finished &&
324  (c->task_index - c->finished_task_index + c->max_tasks) % c->max_tasks <= avctx->thread_count)) {
325  pthread_mutex_unlock(&c->finished_task_mutex);
326  return 0;
327  }
328  while (!outtask->finished) {
329  pthread_cond_wait(&c->finished_task_cond, &c->finished_task_mutex);
330  }
331  pthread_mutex_unlock(&c->finished_task_mutex);
332  /* We now own outtask completely: No worker thread touches it any more,
333  * because there is no outstanding task with this index. */
334  outtask->finished = 0;
335  av_packet_move_ref(pkt, outtask->outdata);
336  *got_packet_ptr = outtask->got_packet;
337  c->finished_task_index = (c->finished_task_index + 1) % c->max_tasks;
338 
339  return outtask->return_code;
340 }
pthread_mutex_t
_fmutex pthread_mutex_t
Definition: os2threads.h:53
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
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
AV_CODEC_ID_HUFFYUV
@ AV_CODEC_ID_HUFFYUV
Definition: codec_id.h:77
Task::finished
int finished
Definition: frame_thread_encoder.c:48
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:212
thread.h
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:224
BUFFER_SIZE
#define BUFFER_SIZE
Definition: frame_thread_encoder.c:42
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:375
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
internal.h
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:89
encode.h
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
ff_encode_encode_cb
int ff_encode_encode_cb(AVCodecContext *avctx, AVPacket *avpkt, AVFrame *frame, int *got_packet)
Definition: encode.c:248
ff_pthread_free
av_cold void ff_pthread_free(void *obj, const unsigned offsets[])
Definition: pthread.c:91
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
fail
#define fail()
Definition: checkasm.h:179
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
ThreadContext::parent_avctx
AVCodecContext * parent_avctx
Definition: frame_thread_encoder.c:53
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:37
Task::outdata
AVPacket * outdata
Definition: frame_thread_encoder.c:46
ThreadContext::finished_task_index
unsigned finished_task_index
Definition: frame_thread_encoder.c:66
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
frame_thread_encoder.h
av_cold
#define av_cold
Definition: attributes.h:90
ff_frame_thread_encoder_init
av_cold int ff_frame_thread_encoder_init(AVCodecContext *avctx)
Initialize frame thread encoder.
Definition: frame_thread_encoder.c:120
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1342
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVCodecContext::thread_type
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1592
ThreadContext::exit
atomic_int exit
Definition: frame_thread_encoder.c:69
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AV_CODEC_ID_FFVHUFF
@ AV_CODEC_ID_FFVHUFF
Definition: codec_id.h:119
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
DEFINE_OFFSET_ARRAY
DEFINE_OFFSET_ARRAY(ThreadContext, thread_ctx, pthread_init_cnt,(OFF(task_fifo_mutex), OFF(finished_task_mutex)),(OFF(task_fifo_cond), OFF(finished_task_cond)))
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
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
ff_thread_video_encode_frame
int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, AVFrame *frame, int *got_packet_ptr)
Definition: frame_thread_encoder.c:301
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
avcodec_parameters_to_context
int avcodec_parameters_to_context(AVCodecContext *codec, const struct AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
ThreadContext::task_fifo_mutex
pthread_mutex_t task_fifo_mutex
Definition: frame_thread_encoder.c:55
NULL
#define NULL
Definition: coverity.c:32
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:164
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
pthread_internal.h
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:142
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:1205
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: packet.c:484
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:82
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:2110
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:209
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:50
Task::indata
AVFrame * indata
Definition: frame_thread_encoder.c:45
cpu.h
ThreadContext::next_task_index
unsigned next_task_index
Definition: frame_thread_encoder.c:64
ThreadContext::task_index
unsigned task_index
Definition: frame_thread_encoder.c:65
DUP_MATRIX
#define DUP_MATRIX(m)
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
pthread_t
Definition: os2threads.h:44
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1593
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
ThreadContext::finished_task_cond
pthread_cond_t finished_task_cond
Definition: frame_thread_encoder.c:62
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
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:633
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:256
pthread_cond_t
Definition: os2threads.h:58
worker
static void *attribute_align_arg worker(void *v)
Definition: frame_thread_encoder.c:78
OFF
#define OFF(member)
Definition: frame_thread_encoder.c:72
avcodec.h
ThreadContext::finished_task_mutex
pthread_mutex_t finished_task_mutex
Definition: frame_thread_encoder.c:61
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVCodecContext::opaque
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:487
pthread_cond_signal
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1601
ThreadContext
Definition: frame_thread_encoder.c:52
AVCodecContext::execute
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:1612
avcodec_internal.h
ThreadContext::pthread_init_cnt
unsigned pthread_init_cnt
Definition: frame_thread_encoder.c:58
AVCodecContext::get_encode_buffer
int(* get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags)
This callback is called at the beginning of each packet to get a data buffer for it.
Definition: avcodec.h:2019
ff_frame_thread_encoder_free
av_cold void ff_frame_thread_encoder_free(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:275
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:104
pthread_cond_wait
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
ThreadContext::max_tasks
unsigned max_tasks
Definition: frame_thread_encoder.c:59
mem.h
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
Task::got_packet
int got_packet
Definition: frame_thread_encoder.c:49
codec_par.h
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:501
Task::return_code
int return_code
Definition: frame_thread_encoder.c:47
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
Task
Definition: frame_thread_encoder.c:44
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
AVCodecContext::execute2
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:1631
ThreadContext::task_fifo_cond
pthread_cond_t task_fifo_cond
Definition: frame_thread_encoder.c:56
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:78