FFmpeg  4.3
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/fifo.h"
26 #include "libavutil/avassert.h"
27 #include "libavutil/imgutils.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/thread.h"
30 #include "avcodec.h"
31 #include "internal.h"
32 #include "thread.h"
33 
34 #define MAX_THREADS 64
35 #define BUFFER_SIZE (2*MAX_THREADS)
36 
37 typedef struct{
38  void *indata;
39  void *outdata;
40  int64_t return_code;
41  unsigned index;
42 } Task;
43 
44 typedef struct{
47 
51 
52  Task finished_tasks[BUFFER_SIZE];
55 
56  unsigned task_index;
58 
62 
63 static void * attribute_align_arg worker(void *v){
64  AVCodecContext *avctx = v;
66  AVPacket *pkt = NULL;
67 
68  while (!atomic_load(&c->exit)) {
69  int got_packet = 0, ret;
70  AVFrame *frame;
71  Task task;
72 
73  if(!pkt) pkt = av_packet_alloc();
74  if(!pkt) continue;
76 
77  pthread_mutex_lock(&c->task_fifo_mutex);
78  while (av_fifo_size(c->task_fifo) <= 0 || atomic_load(&c->exit)) {
79  if (atomic_load(&c->exit)) {
80  pthread_mutex_unlock(&c->task_fifo_mutex);
81  goto end;
82  }
83  pthread_cond_wait(&c->task_fifo_cond, &c->task_fifo_mutex);
84  }
85  av_fifo_generic_read(c->task_fifo, &task, sizeof(task), NULL);
86  pthread_mutex_unlock(&c->task_fifo_mutex);
87  frame = task.indata;
88 
89  ret = avctx->codec->encode2(avctx, pkt, frame, &got_packet);
90  if(got_packet) {
91  int ret2 = av_packet_make_refcounted(pkt);
92  if (ret >= 0 && ret2 < 0)
93  ret = ret2;
94  pkt->pts = pkt->dts = frame->pts;
95  } else {
96  pkt->data = NULL;
97  pkt->size = 0;
98  }
99  pthread_mutex_lock(&c->buffer_mutex);
101  pthread_mutex_unlock(&c->buffer_mutex);
103  pthread_mutex_lock(&c->finished_task_mutex);
104  c->finished_tasks[task.index].outdata = pkt; pkt = NULL;
105  c->finished_tasks[task.index].return_code = ret;
106  pthread_cond_signal(&c->finished_task_cond);
107  pthread_mutex_unlock(&c->finished_task_mutex);
108  }
109 end:
110  av_free(pkt);
111  pthread_mutex_lock(&c->buffer_mutex);
112  avcodec_close(avctx);
113  pthread_mutex_unlock(&c->buffer_mutex);
114  av_freep(&avctx);
115  return NULL;
116 }
117 
119  int i=0;
120  ThreadContext *c;
121 
122 
123  if( !(avctx->thread_type & FF_THREAD_FRAME)
125  return 0;
126 
127  if( !avctx->thread_count
128  && avctx->codec_id == AV_CODEC_ID_MJPEG
129  && !(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
130  av_log(avctx, AV_LOG_DEBUG,
131  "Forcing thread count to 1 for MJPEG encoding, use -thread_type slice "
132  "or a constant quantizer if you want to use multiple cpu cores\n");
133  avctx->thread_count = 1;
134  }
135  if( avctx->thread_count > 1
136  && avctx->codec_id == AV_CODEC_ID_MJPEG
137  && !(avctx->flags & AV_CODEC_FLAG_QSCALE))
138  av_log(avctx, AV_LOG_WARNING,
139  "MJPEG CBR encoding works badly with frame multi-threading, consider "
140  "using -threads 1, -thread_type slice or a constant quantizer.\n");
141 
142  if (avctx->codec_id == AV_CODEC_ID_HUFFYUV ||
143  avctx->codec_id == AV_CODEC_ID_FFVHUFF) {
144  int warn = 0;
145  int context_model = 0;
147 
148  if (con && con->value)
149  context_model = atoi(con->value);
150 
151  if (avctx->flags & AV_CODEC_FLAG_PASS1)
152  warn = 1;
153  else if(context_model > 0) {
154  AVDictionaryEntry *t = av_dict_get(options, "non_deterministic",
156  warn = !t || !t->value || !atoi(t->value) ? 1 : 0;
157  }
158  // huffyuv does not support these with multiple frame threads currently
159  if (warn) {
160  av_log(avctx, AV_LOG_WARNING,
161  "Forcing thread count to 1 for huffyuv encoding with first pass or context 1\n");
162  avctx->thread_count = 1;
163  }
164  }
165 
166  if(!avctx->thread_count) {
167  avctx->thread_count = av_cpu_count();
168  avctx->thread_count = FFMIN(avctx->thread_count, MAX_THREADS);
169  }
170 
171  if(avctx->thread_count <= 1)
172  return 0;
173 
174  if(avctx->thread_count > MAX_THREADS)
175  return AVERROR(EINVAL);
176 
179  if(!c)
180  return AVERROR(ENOMEM);
181 
182  c->parent_avctx = avctx;
183 
184  c->task_fifo = av_fifo_alloc_array(BUFFER_SIZE, sizeof(Task));
185  if(!c->task_fifo)
186  goto fail;
187 
188  pthread_mutex_init(&c->task_fifo_mutex, NULL);
189  pthread_mutex_init(&c->finished_task_mutex, NULL);
190  pthread_mutex_init(&c->buffer_mutex, NULL);
191  pthread_cond_init(&c->task_fifo_cond, NULL);
192  pthread_cond_init(&c->finished_task_cond, NULL);
193  atomic_init(&c->exit, 0);
194 
195  for(i=0; i<avctx->thread_count ; i++){
196  AVDictionary *tmp = NULL;
197  int ret;
198  void *tmpv;
199  AVCodecContext *thread_avctx = avcodec_alloc_context3(avctx->codec);
200  if(!thread_avctx)
201  goto fail;
202  tmpv = thread_avctx->priv_data;
203  *thread_avctx = *avctx;
204  ret = av_opt_copy(thread_avctx, avctx);
205  if (ret < 0)
206  goto fail;
207  thread_avctx->priv_data = tmpv;
208  thread_avctx->internal = NULL;
209  if (avctx->codec->priv_class) {
210  int ret = av_opt_copy(thread_avctx->priv_data, avctx->priv_data);
211  if (ret < 0)
212  goto fail;
213  } else if (avctx->codec->priv_data_size) {
214  memcpy(thread_avctx->priv_data, avctx->priv_data, avctx->codec->priv_data_size);
215  }
216  thread_avctx->thread_count = 1;
217  thread_avctx->active_thread_type &= ~FF_THREAD_FRAME;
218 
219  av_dict_copy(&tmp, options, 0);
220  av_dict_set(&tmp, "threads", "1", 0);
221  if(avcodec_open2(thread_avctx, avctx->codec, &tmp) < 0) {
222  av_dict_free(&tmp);
223  goto fail;
224  }
225  av_dict_free(&tmp);
226  av_assert0(!thread_avctx->internal->frame_thread_encoder);
227  thread_avctx->internal->frame_thread_encoder = c;
228  if(pthread_create(&c->worker[i], NULL, worker, thread_avctx)) {
229  goto fail;
230  }
231  }
232 
234 
235  return 0;
236 fail:
237  avctx->thread_count = i;
238  av_log(avctx, AV_LOG_ERROR, "ff_frame_thread_encoder_init failed\n");
240  return -1;
241 }
242 
244  int i;
246 
247  pthread_mutex_lock(&c->task_fifo_mutex);
248  atomic_store(&c->exit, 1);
249  pthread_cond_broadcast(&c->task_fifo_cond);
250  pthread_mutex_unlock(&c->task_fifo_mutex);
251 
252  for (i=0; i<avctx->thread_count; i++) {
253  pthread_join(c->worker[i], NULL);
254  }
255 
256  while (av_fifo_size(c->task_fifo) > 0) {
257  Task task;
258  AVFrame *frame;
259  av_fifo_generic_read(c->task_fifo, &task, sizeof(task), NULL);
260  frame = task.indata;
262  task.indata = NULL;
263  }
264 
265  for (i=0; i<BUFFER_SIZE; i++) {
266  if (c->finished_tasks[i].outdata != NULL) {
267  AVPacket *pkt = c->finished_tasks[i].outdata;
269  c->finished_tasks[i].outdata = NULL;
270  }
271  }
272 
273  pthread_mutex_destroy(&c->task_fifo_mutex);
274  pthread_mutex_destroy(&c->finished_task_mutex);
275  pthread_mutex_destroy(&c->buffer_mutex);
276  pthread_cond_destroy(&c->task_fifo_cond);
277  pthread_cond_destroy(&c->finished_task_cond);
278  av_fifo_freep(&c->task_fifo);
280 }
281 
282 int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet_ptr){
284  Task task;
285  int ret;
286 
287  av_assert1(!*got_packet_ptr);
288 
289  if(frame){
290  AVFrame *new = av_frame_alloc();
291  if(!new)
292  return AVERROR(ENOMEM);
293  ret = av_frame_ref(new, frame);
294  if(ret < 0) {
295  av_frame_free(&new);
296  return ret;
297  }
298 
299  task.index = c->task_index;
300  task.indata = (void*)new;
301  pthread_mutex_lock(&c->task_fifo_mutex);
302  av_fifo_generic_write(c->task_fifo, &task, sizeof(task), NULL);
303  pthread_cond_signal(&c->task_fifo_cond);
304  pthread_mutex_unlock(&c->task_fifo_mutex);
305 
306  c->task_index = (c->task_index+1) % BUFFER_SIZE;
307  }
308 
309  pthread_mutex_lock(&c->finished_task_mutex);
310  if (c->task_index == c->finished_task_index ||
311  (frame && !c->finished_tasks[c->finished_task_index].outdata &&
312  (c->task_index - c->finished_task_index) % BUFFER_SIZE <= avctx->thread_count)) {
313  pthread_mutex_unlock(&c->finished_task_mutex);
314  return 0;
315  }
316 
317  while (!c->finished_tasks[c->finished_task_index].outdata) {
318  pthread_cond_wait(&c->finished_task_cond, &c->finished_task_mutex);
319  }
320  task = c->finished_tasks[c->finished_task_index];
321  *pkt = *(AVPacket*)(task.outdata);
322  if(pkt->data)
323  *got_packet_ptr = 1;
324  av_freep(&c->finished_tasks[c->finished_task_index].outdata);
325  c->finished_task_index = (c->finished_task_index+1) % BUFFER_SIZE;
326  pthread_mutex_unlock(&c->finished_task_mutex);
327 
328  return task.return_code;
329 }
avcodec_close
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:1121
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:182
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:74
av_fifo_generic_write
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:216
thread.h
pthread_mutex_init
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
BUFFER_SIZE
#define BUFFER_SIZE
Definition: frame_thread_encoder.c:35
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:209
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:152
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
ff_frame_thread_encoder_init
int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options)
Definition: frame_thread_encoder.c:118
AVDictionary
Definition: dict.c:30
av_fifo_generic_read
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
ThreadContext::buffer_mutex
pthread_mutex_t buffer_mutex
Definition: frame_thread_encoder.c:46
thread.h
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:64
AVFifoBuffer
Definition: fifo.h:31
fifo.h
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:535
fail
#define fail()
Definition: checkasm.h:123
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1785
Task::index
unsigned index
Definition: frame_thread_encoder.c:41
ThreadContext::parent_avctx
AVCodecContext * parent_avctx
Definition: frame_thread_encoder.c:45
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:34
ThreadContext::finished_task_index
unsigned finished_task_index
Definition: frame_thread_encoder.c:57
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
Task::indata
void * indata
Definition: frame_thread_encoder.c:38
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
frame_thread_encoder.h
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
ff_frame_thread_encoder_free
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:243
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:157
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVCodecContext::thread_type
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1795
ThreadContext::exit
atomic_int exit
Definition: frame_thread_encoder.c:60
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
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:239
AV_CODEC_ID_FFVHUFF
@ AV_CODEC_ID_FFVHUFF
Definition: codec_id.h:116
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
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:536
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
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
ThreadContext::task_fifo_mutex
pthread_mutex_t task_fifo_mutex
Definition: frame_thread_encoder.c:49
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:561
avcodec_open2
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:548
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:66
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:267
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:62
options
const OptionDef options[]
AVPacket::size
int size
Definition: packet.h:356
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:444
ThreadContext::task_fifo
AVFifoBuffer * task_fifo
Definition: frame_thread_encoder.c:48
AVCodec::encode2
int(* encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec.h:280
Task::outdata
void * outdata
Definition: frame_thread_encoder.c:39
ThreadContext::task_index
unsigned task_index
Definition: frame_thread_encoder.c:56
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
av_packet_make_refcounted
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:671
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:53
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:203
Task::return_code
int64_t return_code
Definition: frame_thread_encoder.c:40
pthread_t
Definition: os2threads.h:44
pthread_cond_destroy
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:144
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1796
pthread_mutex_destroy
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:56
ThreadContext::finished_task_cond
pthread_cond_t finished_task_cond
Definition: frame_thread_encoder.c:54
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
av_fifo_alloc_array
AVFifoBuffer * av_fifo_alloc_array(size_t nmemb, size_t size)
Initialize an AVFifoBuffer.
Definition: fifo.c:49
ff_thread_video_encode_frame
int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet_ptr)
Definition: frame_thread_encoder.c:282
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
pthread_cond_t
Definition: os2threads.h:58
worker
static void *attribute_align_arg worker(void *v)
Definition: frame_thread_encoder.c:63
AVCodec::priv_data_size
int priv_data_size
Definition: codec.h:238
avcodec.h
ThreadContext::finished_task_mutex
pthread_mutex_t finished_task_mutex
Definition: frame_thread_encoder.c:53
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
pthread_cond_signal
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
AVCodecContext
main external API structure.
Definition: avcodec.h:526
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1804
ThreadContext
Definition: frame_thread_encoder.c:44
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
pthread_cond_wait
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
av_fifo_size
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1768
av_fifo_freep
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVDictionaryEntry
Definition: dict.h:81
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
AVPacket
This structure stores compressed data.
Definition: packet.h:332
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
Task
Definition: frame_thread_encoder.c:37
imgutils.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
pthread_cond_init
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:133
AVDictionaryEntry::value
char * value
Definition: dict.h:83
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
ThreadContext::task_fifo_cond
pthread_cond_t task_fifo_cond
Definition: frame_thread_encoder.c:50
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
av_init_packet
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:62