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/imgutils.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/thread.h"
29 #include "avcodec.h"
30 #include "internal.h"
31 #include "thread.h"
32 
33 #define MAX_THREADS 64
34 /* There can be as many as MAX_THREADS + 1 outstanding tasks.
35  * An additional + 1 is needed so that one can distinguish
36  * the case of zero and MAX_THREADS + 1 outstanding tasks modulo
37  * the number of buffers. */
38 #define BUFFER_SIZE (MAX_THREADS + 2)
39 
40 typedef struct{
44  int finished;
45 } Task;
46 
47 typedef struct{
50 
51  pthread_mutex_t task_fifo_mutex; /* Used to guard (next_)task_index */
53 
54  unsigned max_tasks;
55  Task tasks[BUFFER_SIZE];
56  pthread_mutex_t finished_task_mutex; /* Guards tasks[i].finished */
58 
59  unsigned next_task_index;
60  unsigned task_index;
62 
66 
67 static void * attribute_align_arg worker(void *v){
68  AVCodecContext *avctx = v;
70 
71  while (!atomic_load(&c->exit)) {
72  int got_packet = 0, ret;
73  AVPacket *pkt;
74  AVFrame *frame;
75  Task *task;
76  unsigned task_index;
77 
78  pthread_mutex_lock(&c->task_fifo_mutex);
79  while (c->next_task_index == c->task_index || atomic_load(&c->exit)) {
80  if (atomic_load(&c->exit)) {
81  pthread_mutex_unlock(&c->task_fifo_mutex);
82  goto end;
83  }
84  pthread_cond_wait(&c->task_fifo_cond, &c->task_fifo_mutex);
85  }
86  task_index = c->next_task_index;
87  c->next_task_index = (c->next_task_index + 1) % c->max_tasks;
88  pthread_mutex_unlock(&c->task_fifo_mutex);
89  /* The main thread ensures that any two outstanding tasks have
90  * different indices, ergo each worker thread owns its element
91  * of c->tasks with the exception of finished, which is shared
92  * with the main thread and guarded by finished_task_mutex. */
93  task = &c->tasks[task_index];
94  frame = task->indata;
95  pkt = task->outdata;
96 
97  ret = avctx->codec->encode2(avctx, pkt, frame, &got_packet);
98  if(got_packet) {
99  int ret2 = av_packet_make_refcounted(pkt);
100  if (ret >= 0 && ret2 < 0)
101  ret = ret2;
102  pkt->pts = pkt->dts = frame->pts;
103  } else {
104  pkt->data = NULL;
105  pkt->size = 0;
106  }
107  pthread_mutex_lock(&c->buffer_mutex);
109  pthread_mutex_unlock(&c->buffer_mutex);
110  pthread_mutex_lock(&c->finished_task_mutex);
111  task->return_code = ret;
112  task->finished = 1;
113  pthread_cond_signal(&c->finished_task_cond);
114  pthread_mutex_unlock(&c->finished_task_mutex);
115  }
116 end:
117  pthread_mutex_lock(&c->buffer_mutex);
118  avcodec_close(avctx);
119  pthread_mutex_unlock(&c->buffer_mutex);
120  av_freep(&avctx);
121  return NULL;
122 }
123 
125 {
126  int i=0;
127  ThreadContext *c;
128 
129 
130  if( !(avctx->thread_type & FF_THREAD_FRAME)
132  return 0;
133 
134  if( !avctx->thread_count
135  && avctx->codec_id == AV_CODEC_ID_MJPEG
136  && !(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
137  av_log(avctx, AV_LOG_DEBUG,
138  "Forcing thread count to 1 for MJPEG encoding, use -thread_type slice "
139  "or a constant quantizer if you want to use multiple cpu cores\n");
140  avctx->thread_count = 1;
141  }
142  if( avctx->thread_count > 1
143  && avctx->codec_id == AV_CODEC_ID_MJPEG
144  && !(avctx->flags & AV_CODEC_FLAG_QSCALE))
145  av_log(avctx, AV_LOG_WARNING,
146  "MJPEG CBR encoding works badly with frame multi-threading, consider "
147  "using -threads 1, -thread_type slice or a constant quantizer.\n");
148 
149  if (avctx->codec_id == AV_CODEC_ID_HUFFYUV ||
150  avctx->codec_id == AV_CODEC_ID_FFVHUFF) {
151  int warn = 0;
152  int64_t tmp;
153 
154  if (avctx->flags & AV_CODEC_FLAG_PASS1)
155  warn = 1;
156  else if (av_opt_get_int(avctx->priv_data, "context", 0, &tmp) >= 0 &&
157  tmp > 0) {
158  warn = av_opt_get_int(avctx->priv_data, "non_deterministic", 0, &tmp) < 0
159  || !tmp;
160  }
161  // huffyuv does not support these with multiple frame threads currently
162  if (warn) {
163  av_log(avctx, AV_LOG_WARNING,
164  "Forcing thread count to 1 for huffyuv encoding with first pass or context 1\n");
165  avctx->thread_count = 1;
166  }
167  }
168 
169  if(!avctx->thread_count) {
170  avctx->thread_count = av_cpu_count();
171  avctx->thread_count = FFMIN(avctx->thread_count, MAX_THREADS);
172  }
173 
174  if(avctx->thread_count <= 1)
175  return 0;
176 
177  if(avctx->thread_count > MAX_THREADS)
178  return AVERROR(EINVAL);
179 
182  if(!c)
183  return AVERROR(ENOMEM);
184 
185  c->parent_avctx = avctx;
186 
187  pthread_mutex_init(&c->task_fifo_mutex, NULL);
188  pthread_mutex_init(&c->finished_task_mutex, NULL);
189  pthread_mutex_init(&c->buffer_mutex, NULL);
190  pthread_cond_init(&c->task_fifo_cond, NULL);
191  pthread_cond_init(&c->finished_task_cond, NULL);
192  atomic_init(&c->exit, 0);
193 
194  c->max_tasks = avctx->thread_count + 2;
195  for (unsigned i = 0; i < c->max_tasks; i++) {
196  if (!(c->tasks[i].indata = av_frame_alloc()) ||
197  !(c->tasks[i].outdata = av_packet_alloc()))
198  goto fail;
199  }
200 
201  for(i=0; i<avctx->thread_count ; i++){
202  int ret;
203  void *tmpv;
204  AVCodecContext *thread_avctx = avcodec_alloc_context3(avctx->codec);
205  if(!thread_avctx)
206  goto fail;
207  tmpv = thread_avctx->priv_data;
208  *thread_avctx = *avctx;
209  ret = av_opt_copy(thread_avctx, avctx);
210  if (ret < 0)
211  goto fail;
212  thread_avctx->priv_data = tmpv;
213  thread_avctx->internal = NULL;
214  if (avctx->codec->priv_class) {
215  int ret = av_opt_copy(thread_avctx->priv_data, avctx->priv_data);
216  if (ret < 0)
217  goto fail;
218  }
219  thread_avctx->thread_count = 1;
220  thread_avctx->active_thread_type &= ~FF_THREAD_FRAME;
221 
222  if (avcodec_open2(thread_avctx, avctx->codec, NULL) < 0)
223  goto fail;
224  av_assert0(!thread_avctx->internal->frame_thread_encoder);
225  thread_avctx->internal->frame_thread_encoder = c;
226  if(pthread_create(&c->worker[i], NULL, worker, thread_avctx)) {
227  goto fail;
228  }
229  }
230 
232 
233  return 0;
234 fail:
235  avctx->thread_count = i;
236  av_log(avctx, AV_LOG_ERROR, "ff_frame_thread_encoder_init failed\n");
238  return -1;
239 }
240 
242  int i;
244 
245  pthread_mutex_lock(&c->task_fifo_mutex);
246  atomic_store(&c->exit, 1);
247  pthread_cond_broadcast(&c->task_fifo_cond);
248  pthread_mutex_unlock(&c->task_fifo_mutex);
249 
250  for (i=0; i<avctx->thread_count; i++) {
251  pthread_join(c->worker[i], NULL);
252  }
253 
254  for (unsigned i = 0; i < c->max_tasks; i++) {
255  av_frame_free(&c->tasks[i].indata);
256  av_packet_free(&c->tasks[i].outdata);
257  }
258 
259  pthread_mutex_destroy(&c->task_fifo_mutex);
260  pthread_mutex_destroy(&c->finished_task_mutex);
261  pthread_mutex_destroy(&c->buffer_mutex);
262  pthread_cond_destroy(&c->task_fifo_cond);
263  pthread_cond_destroy(&c->finished_task_cond);
265 }
266 
268  AVFrame *frame, int *got_packet_ptr)
269 {
271  Task *outtask;
272 
273  av_assert1(!*got_packet_ptr);
274 
275  if(frame){
276  av_frame_move_ref(c->tasks[c->task_index].indata, frame);
277 
278  pthread_mutex_lock(&c->task_fifo_mutex);
279  c->task_index = (c->task_index + 1) % c->max_tasks;
280  pthread_cond_signal(&c->task_fifo_cond);
281  pthread_mutex_unlock(&c->task_fifo_mutex);
282  }
283 
284  outtask = &c->tasks[c->finished_task_index];
285  pthread_mutex_lock(&c->finished_task_mutex);
286  /* The access to task_index in the following code is ok,
287  * because it is only ever changed by the main thread. */
288  if (c->task_index == c->finished_task_index ||
289  (frame && !outtask->finished &&
290  (c->task_index - c->finished_task_index + c->max_tasks) % c->max_tasks <= avctx->thread_count)) {
291  pthread_mutex_unlock(&c->finished_task_mutex);
292  return 0;
293  }
294  while (!outtask->finished) {
295  pthread_cond_wait(&c->finished_task_cond, &c->finished_task_mutex);
296  }
297  pthread_mutex_unlock(&c->finished_task_mutex);
298  /* We now own outtask completely: No worker thread touches it any more,
299  * because there is no outstanding task with this index. */
300  outtask->finished = 0;
301  av_packet_move_ref(pkt, outtask->outdata);
302  if(pkt->data)
303  *got_packet_ptr = 1;
304  c->finished_task_index = (c->finished_task_index + 1) % c->max_tasks;
305 
306  return outtask->return_code;
307 }
avcodec_close
av_cold int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: avcodec.c:446
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:187
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:75
Task::finished
int finished
Definition: frame_thread_encoder.c:44
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:223
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:215
BUFFER_SIZE
#define BUFFER_SIZE
Definition: frame_thread_encoder.c:38
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:216
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:159
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
ThreadContext::buffer_mutex
pthread_mutex_t buffer_mutex
Definition: frame_thread_encoder.c:49
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:70
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:393
fail
#define fail()
Definition: checkasm.h:134
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1429
ThreadContext::parent_avctx
AVCodecContext * parent_avctx
Definition: frame_thread_encoder.c:48
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:464
MAX_THREADS
#define MAX_THREADS
Definition: frame_thread_encoder.c:33
Task::outdata
AVPacket * outdata
Definition: frame_thread_encoder.c:42
ThreadContext::finished_task_index
unsigned finished_task_index
Definition: frame_thread_encoder.c:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:98
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
frame_thread_encoder.h
ff_frame_thread_encoder_free
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:241
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:141
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:1439
ThreadContext::exit
atomic_int exit
Definition: frame_thread_encoder.c:64
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
AV_CODEC_ID_FFVHUFF
@ AV_CODEC_ID_FFVHUFF
Definition: codec_id.h:117
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:394
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:267
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
ThreadContext::task_fifo_mutex
pthread_mutex_t task_fifo_mutex
Definition: frame_thread_encoder.c:51
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:419
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:135
av_opt_get_int
int av_opt_get_int(void *obj, const char *name, int search_flags, int64_t *out_val)
Definition: opt.c:912
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:459
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:67
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:184
Task::indata
AVFrame * indata
Definition: frame_thread_encoder.c:41
AVPacket::size
int size
Definition: packet.h:366
ThreadContext::next_task_index
unsigned next_task_index
Definition: frame_thread_encoder.c:59
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:291
ThreadContext::task_index
unsigned task_index
Definition: frame_thread_encoder.c:60
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:364
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
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:465
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:59
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:1440
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:57
ThreadContext::finished_task_cond
pthread_cond_t finished_task_cond
Definition: frame_thread_encoder.c:57
i
int i
Definition: input.c:407
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:358
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
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:460
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:436
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:244
pthread_cond_t
Definition: os2threads.h:58
worker
static void *attribute_align_arg worker(void *v)
Definition: frame_thread_encoder.c:67
avcodec.h
ThreadContext::finished_task_mutex
pthread_mutex_t finished_task_mutex
Definition: frame_thread_encoder.c:56
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
AVCodecContext
main external API structure.
Definition: avcodec.h:384
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1448
ThreadContext
Definition: frame_thread_encoder.c:47
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:54
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1770
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
AVPacket
This structure stores compressed data.
Definition: packet.h:342
Task::return_code
int return_code
Definition: frame_thread_encoder.c:43
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
Task
Definition: frame_thread_encoder.c:40
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
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:52
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:236
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:63
ff_frame_thread_encoder_init
int ff_frame_thread_encoder_init(AVCodecContext *avctx)
Definition: frame_thread_encoder.c:124