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 
79  while (c->next_task_index == c->task_index || atomic_load(&c->exit)) {
80  if (atomic_load(&c->exit)) {
82  goto end;
83  }
85  }
86  task_index = c->next_task_index;
87  c->next_task_index = (c->next_task_index + 1) % c->max_tasks;
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  }
108  av_frame_unref(frame);
111  task->return_code = ret;
112  task->finished = 1;
115  }
116 end:
118  avcodec_close(avctx);
120  av_freep(&avctx);
121  return NULL;
122 }
123 
125  int i=0;
126  ThreadContext *c;
127 
128 
129  if( !(avctx->thread_type & FF_THREAD_FRAME)
131  return 0;
132 
133  if( !avctx->thread_count
134  && avctx->codec_id == AV_CODEC_ID_MJPEG
135  && !(avctx->flags & AV_CODEC_FLAG_QSCALE)) {
136  av_log(avctx, AV_LOG_DEBUG,
137  "Forcing thread count to 1 for MJPEG encoding, use -thread_type slice "
138  "or a constant quantizer if you want to use multiple cpu cores\n");
139  avctx->thread_count = 1;
140  }
141  if( avctx->thread_count > 1
142  && avctx->codec_id == AV_CODEC_ID_MJPEG
143  && !(avctx->flags & AV_CODEC_FLAG_QSCALE))
144  av_log(avctx, AV_LOG_WARNING,
145  "MJPEG CBR encoding works badly with frame multi-threading, consider "
146  "using -threads 1, -thread_type slice or a constant quantizer.\n");
147 
148  if (avctx->codec_id == AV_CODEC_ID_HUFFYUV ||
149  avctx->codec_id == AV_CODEC_ID_FFVHUFF) {
150  int warn = 0;
151  int context_model = 0;
152  AVDictionaryEntry *con = av_dict_get(options, "context", NULL, AV_DICT_MATCH_CASE);
153 
154  if (con && con->value)
155  context_model = atoi(con->value);
156 
157  if (avctx->flags & AV_CODEC_FLAG_PASS1)
158  warn = 1;
159  else if(context_model > 0) {
160  AVDictionaryEntry *t = av_dict_get(options, "non_deterministic",
162  warn = !t || !t->value || !atoi(t->value) ? 1 : 0;
163  }
164  // huffyuv does not support these with multiple frame threads currently
165  if (warn) {
166  av_log(avctx, AV_LOG_WARNING,
167  "Forcing thread count to 1 for huffyuv encoding with first pass or context 1\n");
168  avctx->thread_count = 1;
169  }
170  }
171 
172  if(!avctx->thread_count) {
173  avctx->thread_count = av_cpu_count();
174  avctx->thread_count = FFMIN(avctx->thread_count, MAX_THREADS);
175  }
176 
177  if(avctx->thread_count <= 1)
178  return 0;
179 
180  if(avctx->thread_count > MAX_THREADS)
181  return AVERROR(EINVAL);
182 
184  c = avctx->internal->frame_thread_encoder = av_mallocz(sizeof(ThreadContext));
185  if(!c)
186  return AVERROR(ENOMEM);
187 
188  c->parent_avctx = avctx;
189 
195  atomic_init(&c->exit, 0);
196 
197  c->max_tasks = avctx->thread_count + 2;
198  for (unsigned i = 0; i < c->max_tasks; i++) {
199  if (!(c->tasks[i].indata = av_frame_alloc()) ||
200  !(c->tasks[i].outdata = av_packet_alloc()))
201  goto fail;
202  }
203 
204  for(i=0; i<avctx->thread_count ; i++){
205  AVDictionary *tmp = NULL;
206  int ret;
207  void *tmpv;
208  AVCodecContext *thread_avctx = avcodec_alloc_context3(avctx->codec);
209  if(!thread_avctx)
210  goto fail;
211  tmpv = thread_avctx->priv_data;
212  *thread_avctx = *avctx;
213  ret = av_opt_copy(thread_avctx, avctx);
214  if (ret < 0)
215  goto fail;
216  thread_avctx->priv_data = tmpv;
217  thread_avctx->internal = NULL;
218  if (avctx->codec->priv_class) {
219  int ret = av_opt_copy(thread_avctx->priv_data, avctx->priv_data);
220  if (ret < 0)
221  goto fail;
222  } else if (avctx->codec->priv_data_size) {
223  memcpy(thread_avctx->priv_data, avctx->priv_data, avctx->codec->priv_data_size);
224  }
225  thread_avctx->thread_count = 1;
226  thread_avctx->active_thread_type &= ~FF_THREAD_FRAME;
227 
228  av_dict_copy(&tmp, options, 0);
229  av_dict_set(&tmp, "threads", "1", 0);
230  if(avcodec_open2(thread_avctx, avctx->codec, &tmp) < 0) {
231  av_dict_free(&tmp);
232  goto fail;
233  }
234  av_dict_free(&tmp);
235  av_assert0(!thread_avctx->internal->frame_thread_encoder);
236  thread_avctx->internal->frame_thread_encoder = c;
237  if(pthread_create(&c->worker[i], NULL, worker, thread_avctx)) {
238  goto fail;
239  }
240  }
241 
243 
244  return 0;
245 fail:
246  avctx->thread_count = i;
247  av_log(avctx, AV_LOG_ERROR, "ff_frame_thread_encoder_init failed\n");
249  return -1;
250 }
251 
253  int i;
255 
257  atomic_store(&c->exit, 1);
260 
261  for (i=0; i<avctx->thread_count; i++) {
262  pthread_join(c->worker[i], NULL);
263  }
264 
265  for (unsigned i = 0; i < c->max_tasks; i++) {
266  av_frame_free(&c->tasks[i].indata);
267  av_packet_free(&c->tasks[i].outdata);
268  }
269 
276 }
277 
279  AVFrame *frame, int *got_packet_ptr)
280 {
282  Task *outtask;
283 
284  av_assert1(!*got_packet_ptr);
285 
286  if(frame){
287  av_frame_move_ref(c->tasks[c->task_index].indata, frame);
288 
290  c->task_index = (c->task_index + 1) % c->max_tasks;
293  }
294 
295  outtask = &c->tasks[c->finished_task_index];
297  /* The access to task_index in the following code is ok,
298  * because it is only ever changed by the main thread. */
299  if (c->task_index == c->finished_task_index ||
300  (frame && !outtask->finished &&
301  (c->task_index - c->finished_task_index + c->max_tasks) % c->max_tasks <= avctx->thread_count)) {
303  return 0;
304  }
305  while (!outtask->finished) {
307  }
309  /* We now own outtask completely: No worker thread touches it any more,
310  * because there is no outstanding task with this index. */
311  outtask->finished = 0;
312  av_packet_move_ref(pkt, outtask->outdata);
313  if(pkt->data)
314  *got_packet_ptr = 1;
316 
317  return outtask->return_code;
318 }
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:545
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
Definition: os2threads.h:112
unsigned finished_task_index
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
#define pthread_mutex_lock(a)
Definition: ffprobe.c:63
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
#define atomic_store(object, desired)
Definition: stdatomic.h:85
int av_cpu_count(void)
Definition: cpu.c:275
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
int size
Definition: packet.h:370
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:583
AVCodecContext * parent_avctx
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
AVPacket * pkt
Definition: movenc.c:59
intptr_t atomic_int
Definition: stdatomic.h:55
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
Definition: os2threads.h:144
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:191
AVOptions.
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
Multithreading support functions.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
int(* encode2)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec.h:289
void * frame_thread_encoder
Definition: internal.h:163
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
uint8_t * data
Definition: packet.h:369
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:690
int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, AVFrame *frame, int *got_packet_ptr)
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
#define av_log(a,...)
pthread_mutex_t buffer_mutex
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:523
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
#define atomic_load(object)
Definition: stdatomic.h:93
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
int capabilities
Codec capabilities.
Definition: codec.h:216
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
pthread_cond_t finished_task_cond
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
simple assert() macros that are a bit more flexible than ISO C assert().
#define fail()
Definition: checkasm.h:133
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
AVPacket * outdata
AVFrame * indata
int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options)
#define MAX_THREADS
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:275
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1784
#define FFMIN(a, b)
Definition: common.h:105
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:170
int priv_data_size
Definition: codec.h:245
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:696
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
Definition: os2threads.h:94
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
Definition: os2threads.h:104
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
pthread_mutex_t task_fifo_mutex
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:67
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
Definition: avcodec.h:1773
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
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:546
main external API structure.
Definition: avcodec.h:536
Task tasks[BUFFER_SIZE]
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
pthread_t worker[MAX_THREADS]
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
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:223
const OptionDef options[]
Definition: ffmpeg_opt.c:3427
common internal api header.
_fmutex pthread_mutex_t
Definition: os2threads.h:53
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:1789
static av_always_inline int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
Definition: os2threads.h:133
void * priv_data
Definition: avcodec.h:563
pthread_mutex_t finished_task_mutex
char * value
Definition: dict.h:87
#define BUFFER_SIZE
static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)
Definition: os2threads.h:162
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:571
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:368
#define atomic_init(obj, value)
Definition: stdatomic.h:33
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
#define av_freep(p)
static void *attribute_align_arg worker(void *v)
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
pthread_cond_t task_fifo_cond
This structure stores compressed data.
Definition: packet.h:346
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int i
Definition: input.c:407
int thread_type
Which multithreading methods to use.
Definition: avcodec.h:1783
static uint8_t tmp[11]
Definition: aes_ctr.c:27