添加链接 注册    登录
link管理
链接快照平台
  • 输入网页链接，自动生成快照
  • 标签化管理网页链接
相关文章推荐
捣蛋的针织衫  ·  FFMPEG结构体分析 ...·  1 周前    · 
老实的充值卡  ·  FFmpeg 编解码器文档_ FFmpeg中文网·  1 周前    · 
健身的煎鸡蛋  ·  FFmpeg 入门(5)：视频同步 | ...·  1 周前    · 
发怒的楼房  ·  还不知道如何学习音视频？_牛客网·  1 周前    · 
求醉的斑马  ·  Intel ...·  1 周前    · 
旅行中的书包  ·  Spring Boot 2의 경우 403 ...·  1 月前    · 
失望的鸵鸟  ·  CUDA error: an ...·  7 月前    · 
想旅行的显示器  ·  C++基础---无返回值函数(void函数) ...·  10 月前    · 
玩足球的爆米花  ·  T20天正V8破解下载 T20天正电气软件 ...·  1 年前    · 
私奔的领结  ·  RestTemplate 最详解 - 知乎·  1 年前    · 
link管理  ›  FFmpeg: libavcodec/pthread_frame.c Source File
pthread next ffmpeg
https://ffmpeg.org/doxygen/trunk/pthread__frame_8c_source.html
乖乖的牛肉面
3 月前
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 */
19 /**
20 * @file
21 * Frame multithreading support functions
22 * @see doc/multithreading.txt
23 */
25 #include <stdatomic.h>
27 #include " avcodec.h "
28 #include " avcodec_internal.h "
29 #include " codec_desc.h "
30 #include " codec_internal.h "
31 #include " decode.h "
32 #include " hwaccel_internal.h "
33 #include " hwconfig.h "
34 #include " internal.h "
35 #include " packet_internal.h "
36 #include " pthread_internal.h "
37 #include " refstruct.h "
38 #include " thread.h "
39 #include " threadframe.h "
40 #include " version_major.h "
42 #include " libavutil/avassert.h "
43 #include " libavutil/buffer.h "
44 #include " libavutil/common.h "
45 #include " libavutil/cpu.h "
46 #include " libavutil/frame.h "
47 #include " libavutil/internal.h "
48 #include " libavutil/log.h "
49 #include " libavutil/mem.h "
50 #include " libavutil/opt.h "
51 #include " libavutil/thread.h "
53 enum {
54 /// Set when the thread is awaiting a packet.
55 STATE_INPUT_READY ,
56 /// Set before the codec has called ff_thread_finish_setup().
57 STATE_SETTING_UP ,
58 /// Set after the codec has called ff_thread_finish_setup().
59 STATE_SETUP_FINISHED ,
60 };
62 enum {
63 UNINITIALIZED , ///< Thread has not been created, AVCodec->close mustn't be called
64 NEEDS_CLOSE , ///< FFCodec->close needs to be called
65 INITIALIZED , ///< Thread has been properly set up
66 };
68 typedef struct DecodedFrames {
69 AVFrame ** f ;
70 size_t nb_f ;
71 size_t nb_f_allocated ;
72 } DecodedFrames ;
74 typedef struct ThreadFrameProgress {
75 atomic_int progress [2];
76 } ThreadFrameProgress ;
78 /**
79 * Context used by codec threads and stored in their AVCodecInternal thread_ctx.
80 */
81 typedef struct PerThreadContext {
82 struct FrameThreadContext * parent ;
84 pthread_t thread ;
85 int thread_init ;
86 unsigned pthread_init_cnt ; ///< Number of successfully initialized mutexes/conditions
87 pthread_cond_t input_cond ; ///< Used to wait for a new packet from the main thread.
88 pthread_cond_t progress_cond ; ///< Used by child threads to wait for progress to change.
89 pthread_cond_t output_cond ; ///< Used by the main thread to wait for frames to finish.
91 pthread_mutex_t mutex ; ///< Mutex used to protect the contents of the PerThreadContext.
92 pthread_mutex_t progress_mutex ; ///< Mutex used to protect frame progress values and progress_cond.
94 AVCodecContext * avctx ; ///< Context used to decode packets passed to this thread.
96 AVPacket * avpkt ; ///< Input packet (for decoding) or output (for encoding).
98 /**
99 * Decoded frames from a single decode iteration.
100 */
101 DecodedFrames df ;
102 int result ; ///< The result of the last codec decode/encode() call.
104 atomic_int state ;
106 int die ; ///< Set when the thread should exit.
108 int hwaccel_serializing ;
109 int async_serializing ;
111 // set to 1 in ff_thread_finish_setup() when a threadsafe hwaccel is used;
112 // cannot check hwaccel caps directly, because
113 // worked threads clear hwaccel state for thread-unsafe hwaccels
114 // after each decode call
115 int hwaccel_threadsafe ;
117 atomic_int debug_threads ; ///< Set if the FF_DEBUG_THREADS option is set.
119 /// The following two fields have the same semantics as the DecodeContext field
120 int intra_only_flag ;
121 enum AVPictureType initial_pict_type ;
122 } PerThreadContext ;
124 /**
125 * Context stored in the client AVCodecInternal thread_ctx.
126 */
127 typedef struct FrameThreadContext {
128 PerThreadContext * threads ; ///< The contexts for each thread.
129 PerThreadContext * prev_thread ; ///< The last thread submit_packet() was called on.
131 unsigned pthread_init_cnt ; ///< Number of successfully initialized mutexes/conditions
132 pthread_mutex_t buffer_mutex ; ///< Mutex used to protect get/release_buffer().
133 /**
134 * This lock is used for ensuring threads run in serial when thread-unsafe
135 * hwaccel is used.
136 */
137 pthread_mutex_t hwaccel_mutex ;
138 pthread_mutex_t async_mutex ;
139 pthread_cond_t async_cond ;
140 int async_lock ;
142 DecodedFrames df ;
143 int result ;
145 /**
146 * Packet to be submitted to the next thread for decoding.
147 */
148 AVPacket * next_pkt ;
150 int next_decoding ; ///< The next context to submit a packet to.
151 int next_finished ; ///< The next context to return output from.
153 /* hwaccel state for thread-unsafe hwaccels is temporarily stored here in
154 * order to transfer its ownership to the next decoding thread without the
155 * need for extra synchronization */
156 const AVHWAccel * stash_hwaccel ;
157 void * stash_hwaccel_context ;
158 void * stash_hwaccel_priv ;
159 } FrameThreadContext ;
161 static int hwaccel_serial ( const AVCodecContext *avctx)
162 {
163 return avctx-> hwaccel && !( ffhwaccel (avctx-> hwaccel )-> caps_internal & HWACCEL_CAP_THREAD_SAFE );
164 }
166 static void async_lock ( FrameThreadContext *fctx)
167 {
168 pthread_mutex_lock (&fctx-> async_mutex );
169 while (fctx-> async_lock )
170 pthread_cond_wait (&fctx-> async_cond , &fctx-> async_mutex );
171 fctx-> async_lock = 1;
172 pthread_mutex_unlock (&fctx-> async_mutex );
173 }
175 static void async_unlock ( FrameThreadContext *fctx)
176 {
177 pthread_mutex_lock (&fctx-> async_mutex );
178 av_assert0 (fctx-> async_lock );
179 fctx-> async_lock = 0;
180 pthread_cond_broadcast (&fctx-> async_cond );
181 pthread_mutex_unlock (&fctx-> async_mutex );
182 }
184 static void thread_set_name ( PerThreadContext *p)
185 {
186 AVCodecContext *avctx = p-> avctx ;
187 int idx = p - p-> parent -> threads ;
188 char name [16];
190 snprintf ( name , sizeof ( name ), "av:%.7s:df%d" , avctx-> codec -> name , idx);
192 ff_thread_setname ( name );
193 }
195 // get a free frame to decode into
196 static AVFrame * decoded_frames_get_free ( DecodedFrames * df )
197 {
198 if ( df ->nb_f == df ->nb_f_allocated) {
199 AVFrame ** tmp = av_realloc_array ( df ->f, df ->nb_f + 1,
200 sizeof (* df ->f));
201 if (! tmp )
202 return NULL ;
203 df ->f = tmp ;
205 df ->f[ df ->nb_f] = av_frame_alloc ();
206 if (! df ->f[ df ->nb_f])
207 return NULL ;
209 df ->nb_f_allocated++;
210 }
212 av_assert0 (! df ->f[ df ->nb_f]->buf[0]);
214 return df ->f[ df ->nb_f];
215 }
217 static void decoded_frames_pop ( DecodedFrames * df , AVFrame *dst)
218 {
219 AVFrame *tmp_frame = df ->f[0];
220 av_frame_move_ref (dst, tmp_frame);
221 memmove( df ->f, df ->f + 1, ( df ->nb_f - 1) * sizeof (* df ->f));
222 df ->f[-- df ->nb_f] = tmp_frame;
223 }
225 static void decoded_frames_flush ( DecodedFrames * df )
226 {
227 for ( size_t i = 0; i < df ->nb_f; i ++)
228 av_frame_unref ( df ->f[ i ]);
229 df ->nb_f = 0;
230 }
232 static void decoded_frames_free ( DecodedFrames * df )
233 {
234 for ( size_t i = 0; i < df ->nb_f_allocated; i ++)
235 av_frame_free (& df ->f[ i ]);
236 av_freep (& df ->f);
237 df ->nb_f = 0;
238 df ->nb_f_allocated = 0;
239 }
241 /**
242 * Codec worker thread.
243 *
244 * Automatically calls ff_thread_finish_setup() if the codec does
245 * not provide an update_thread_context method, or if the codec returns
246 * before calling it.
247 */
248 static attribute_align_arg void * frame_worker_thread ( void * arg )
249 {
250 PerThreadContext *p = arg ;
251 AVCodecContext *avctx = p-> avctx ;
252 const FFCodec *codec = ffcodec (avctx-> codec );
254 thread_set_name (p);
256 pthread_mutex_lock (&p-> mutex );
257 while (1) {
258 int ret ;
260 while ( atomic_load (&p-> state ) == STATE_INPUT_READY && !p-> die )
261 pthread_cond_wait (&p-> input_cond , &p-> mutex );
263 if (p-> die ) break ;
265 if (!codec-> update_thread_context )
266 ff_thread_finish_setup (avctx);
268 /* If a decoder supports hwaccel, then it must call ff_get_format().
269 * Since that call must happen before ff_thread_finish_setup(), the
270 * decoder is required to implement update_thread_context() and call
271 * ff_thread_finish_setup() manually. Therefore the above
272 * ff_thread_finish_setup() call did not happen and hwaccel_serializing
273 * cannot be true here. */
274 av_assert0 (!p-> hwaccel_serializing );
276 /* if the previous thread uses thread-unsafe hwaccel then we take the
277 * lock to ensure the threads don't run concurrently */
278 if ( hwaccel_serial (avctx)) {
279 pthread_mutex_lock (&p-> parent -> hwaccel_mutex );
280 p-> hwaccel_serializing = 1;
281 }
283 ret = 0;
284 while ( ret >= 0) {
285 AVFrame * frame ;
287 /* get the frame which will store the output */
288 frame = decoded_frames_get_free (&p-> df );
289 if (! frame ) {
290 p-> result = AVERROR (ENOMEM);
291 goto alloc_fail;
292 }
294 /* do the actual decoding */
295 ret = ff_decode_receive_frame_internal (avctx, frame );
296 if ( ret == 0)
297 p-> df . nb_f ++;
298 else if (ret < 0 && frame->buf[0])
299 av_frame_unref ( frame );
301 p-> result = ( ret == AVERROR (EAGAIN)) ? 0 : ret ;
302 }
304 if ( atomic_load (&p-> state ) == STATE_SETTING_UP )
305 ff_thread_finish_setup (avctx);
307 alloc_fail:
308 if (p-> hwaccel_serializing ) {
309 /* wipe hwaccel state for thread-unsafe hwaccels to avoid stale
310 * pointers lying around;
311 * the state was transferred to FrameThreadContext in
312 * ff_thread_finish_setup(), so nothing is leaked */
313 avctx-> hwaccel = NULL ;
314 avctx-> hwaccel_context = NULL ;
315 avctx-> internal -> hwaccel_priv_data = NULL ;
317 p-> hwaccel_serializing = 0;
318 pthread_mutex_unlock (&p-> parent -> hwaccel_mutex );
319 }
320 av_assert0 (!avctx-> hwaccel ||
321 ( ffhwaccel (avctx-> hwaccel )-> caps_internal & HWACCEL_CAP_THREAD_SAFE ));
323 if (p-> async_serializing ) {
324 p-> async_serializing = 0;
326 async_unlock (p-> parent );
327 }
329 pthread_mutex_lock (&p-> progress_mutex );
331 atomic_store (&p-> state , STATE_INPUT_READY );
333 pthread_cond_broadcast (&p-> progress_cond );
334 pthread_cond_signal (&p-> output_cond );
335 pthread_mutex_unlock (&p-> progress_mutex );
336 }
337 pthread_mutex_unlock (&p-> mutex );
339 return NULL ;
340 }
342 /**
343 * Update the next thread's AVCodecContext with values from the reference thread's context.
344 *
345 * @param dst The destination context.
346 * @param src The source context.
347 * @param for_user 0 if the destination is a codec thread, 1 if the destination is the user's thread
348 * @return 0 on success, negative error code on failure
349 */
350 static int update_context_from_thread ( AVCodecContext *dst, const AVCodecContext * src , int for_user)
351 {
352 const FFCodec * const codec = ffcodec (dst-> codec );
353 int err = 0;
355 if (dst != src && (for_user || codec-> update_thread_context )) {
356 dst-> time_base = src ->time_base;
357 dst-> framerate = src ->framerate;
358 dst-> width = src ->width;
359 dst-> height = src ->height;
360 dst-> pix_fmt = src ->pix_fmt;
361 dst-> sw_pix_fmt = src ->sw_pix_fmt;
363 dst-> coded_width = src ->coded_width;
364 dst-> coded_height = src ->coded_height;
366 dst-> has_b_frames = src ->has_b_frames;
367 dst-> idct_algo = src ->idct_algo;
368 dst-> properties = src ->properties;
370 dst-> bits_per_coded_sample = src ->bits_per_coded_sample;
371 dst-> sample_aspect_ratio = src ->sample_aspect_ratio;
373 dst-> profile = src ->profile;
374 dst-> level = src ->level;
376 dst-> bits_per_raw_sample = src ->bits_per_raw_sample;
377 #if FF_API_TICKS_PER_FRAME
378 FF_DISABLE_DEPRECATION_WARNINGS
379 dst-> ticks_per_frame = src ->ticks_per_frame;
380 FF_ENABLE_DEPRECATION_WARNINGS
381 #endif
382 dst-> color_primaries = src ->color_primaries;
384 dst-> color_trc = src ->color_trc;
385 dst-> colorspace = src ->colorspace;
386 dst-> color_range = src ->color_range;
387 dst-> chroma_sample_location = src ->chroma_sample_location;
389 dst-> sample_rate = src ->sample_rate;
390 dst-> sample_fmt = src ->sample_fmt;
391 err = av_channel_layout_copy (&dst-> ch_layout , & src ->ch_layout);
392 if (err < 0)
393 return err;
395 if (!!dst-> hw_frames_ctx != !! src ->hw_frames_ctx ||
396 (dst-> hw_frames_ctx && dst-> hw_frames_ctx -> data != src ->hw_frames_ctx->data)) {
397 av_buffer_unref (&dst-> hw_frames_ctx );
399 if ( src ->hw_frames_ctx) {
400 dst-> hw_frames_ctx = av_buffer_ref ( src ->hw_frames_ctx);
401 if (!dst-> hw_frames_ctx )
402 return AVERROR (ENOMEM);
403 }
404 }
406 dst-> hwaccel_flags = src ->hwaccel_flags;
408 ff_refstruct_replace (&dst-> internal -> pool , src ->internal->pool);
409 }
411 if (for_user) {
412 if (codec-> update_thread_context_for_user )
413 err = codec-> update_thread_context_for_user (dst, src );
414 } else {
415 const PerThreadContext *p_src = src ->internal->thread_ctx;
416 PerThreadContext *p_dst = dst-> internal -> thread_ctx ;
418 if (codec-> update_thread_context ) {
419 err = codec-> update_thread_context (dst, src );
420 if (err < 0)
421 return err;
422 }
424 // reset dst hwaccel state if needed
425 av_assert0 (p_dst-> hwaccel_threadsafe ||
426 (!dst-> hwaccel && !dst-> internal -> hwaccel_priv_data ));
427 if (p_dst-> hwaccel_threadsafe &&
428 (!p_src-> hwaccel_threadsafe || dst-> hwaccel != src ->hwaccel)) {
429 ff_hwaccel_uninit (dst);
430 p_dst-> hwaccel_threadsafe = 0;
431 }
433 // propagate hwaccel state for threadsafe hwaccels
434 if (p_src-> hwaccel_threadsafe ) {
435 const FFHWAccel * hwaccel = ffhwaccel ( src ->hwaccel);
436 if (!dst-> hwaccel ) {
437 if ( hwaccel ->priv_data_size) {
438 av_assert0 ( hwaccel ->update_thread_context);
440 dst-> internal -> hwaccel_priv_data =
441 av_mallocz ( hwaccel ->priv_data_size);
442 if (!dst-> internal -> hwaccel_priv_data )
443 return AVERROR (ENOMEM);
444 }
445 dst-> hwaccel = src ->hwaccel;
446 }
447 av_assert0 (dst-> hwaccel == src ->hwaccel);
449 if ( hwaccel ->update_thread_context) {
450 err = hwaccel ->update_thread_context(dst, src );
451 if (err < 0) {
452 av_log (dst, AV_LOG_ERROR , "Error propagating hwaccel state\n" );
453 ff_hwaccel_uninit (dst);
454 return err;
455 }
456 }
457 p_dst-> hwaccel_threadsafe = 1;
458 }
459 }
461 return err;
462 }
464 /**
465 * Update the next thread's AVCodecContext with values set by the user.
466 *
467 * @param dst The destination context.
468 * @param src The source context.
469 * @return 0 on success, negative error code on failure
470 */
471 static int update_context_from_user ( AVCodecContext *dst, const AVCodecContext * src )
472 {
473 int err;
475 dst-> flags = src ->flags;
477 dst-> draw_horiz_band = src ->draw_horiz_band;
478 dst-> get_buffer2 = src ->get_buffer2;
480 dst-> opaque = src ->opaque;
481 dst-> debug = src ->debug;
483 dst-> slice_flags = src ->slice_flags;
484 dst-> flags2 = src ->flags2;
485 dst-> export_side_data = src ->export_side_data;
487 dst-> skip_loop_filter = src ->skip_loop_filter;
488 dst-> skip_idct = src ->skip_idct;
489 dst-> skip_frame = src ->skip_frame;
491 dst-> frame_num = src ->frame_num;
493 av_packet_unref (dst-> internal -> last_pkt_props );
494 err = av_packet_copy_props (dst-> internal -> last_pkt_props , src ->internal->last_pkt_props);
495 if (err < 0)
496 return err;
498 return 0;
499 }
501 static int submit_packet ( PerThreadContext *p, AVCodecContext *user_avctx,
502 AVPacket *in_pkt)
503 {
504 FrameThreadContext *fctx = p-> parent ;
505 PerThreadContext *prev_thread = fctx-> prev_thread ;
506 const AVCodec *codec = p-> avctx -> codec ;
507 int ret ;
509 pthread_mutex_lock (&p-> mutex );
511 av_packet_unref (p-> avpkt );
512 av_packet_move_ref (p-> avpkt , in_pkt);
514 if ( AVPACKET_IS_EMPTY (p-> avpkt ))
515 p-> avctx -> internal -> draining = 1;
517 ret = update_context_from_user (p-> avctx , user_avctx);
518 if ( ret ) {
519 pthread_mutex_unlock (&p-> mutex );
520 return ret ;
521 }
522 atomic_store_explicit (&p-> debug_threads ,
523 (p-> avctx -> debug & FF_DEBUG_THREADS ) != 0,
524 memory_order_relaxed);
526 if (prev_thread) {
527 if ( atomic_load (&prev_thread-> state ) == STATE_SETTING_UP ) {
528 pthread_mutex_lock (&prev_thread-> progress_mutex );
529 while ( atomic_load (&prev_thread-> state ) == STATE_SETTING_UP )
530 pthread_cond_wait (&prev_thread-> progress_cond , &prev_thread-> progress_mutex );
531 pthread_mutex_unlock (&prev_thread-> progress_mutex );
532 }
534 /* codecs without delay might not be prepared to be called repeatedly here during
535 * flushing (vp3/theora), and also don't need to be, since from this point on, they
536 * will always return EOF anyway */
537 if (!p-> avctx -> internal -> draining ||
538 (codec-> capabilities & AV_CODEC_CAP_DELAY )) {
539 ret = update_context_from_thread (p-> avctx , prev_thread-> avctx , 0);
540 if ( ret ) {
541 pthread_mutex_unlock (&p-> mutex );
542 return ret ;
543 }
544 }
545 }
547 /* transfer the stashed hwaccel state, if any */
548 av_assert0 (!p-> avctx -> hwaccel || p-> hwaccel_threadsafe );
549 if (!p-> hwaccel_threadsafe ) {
550 FFSWAP ( const AVHWAccel *, p-> avctx -> hwaccel , fctx-> stash_hwaccel );
551 FFSWAP ( void *, p-> avctx -> hwaccel_context , fctx-> stash_hwaccel_context );
552 FFSWAP ( void *, p-> avctx -> internal -> hwaccel_priv_data , fctx-> stash_hwaccel_priv );
553 }
555 atomic_store (&p-> state , STATE_SETTING_UP );
556 pthread_cond_signal (&p-> input_cond );
557 pthread_mutex_unlock (&p-> mutex );
559 fctx-> prev_thread = p;
560 fctx-> next_decoding = (fctx-> next_decoding + 1) % p-> avctx -> thread_count ;
562 return 0;
563 }
565 int ff_thread_receive_frame ( AVCodecContext *avctx, AVFrame * frame )
566 {
567 FrameThreadContext *fctx = avctx-> internal -> thread_ctx ;
568 int ret = 0;
570 /* release the async lock, permitting blocked hwaccel threads to
571 * go forward while we are in this function */
572 async_unlock (fctx);
574 /* submit packets to threads while there are no buffered results to return */
575 while (!fctx-> df . nb_f && !fctx-> result ) {
576 PerThreadContext *p;
578 /* get a packet to be submitted to the next thread */
579 av_packet_unref (fctx-> next_pkt );
580 ret = ff_decode_get_packet (avctx, fctx-> next_pkt );
581 if ( ret < 0 && ret != AVERROR_EOF )
582 goto finish ;
584 ret = submit_packet (&fctx-> threads [fctx-> next_decoding ], avctx,
585 fctx-> next_pkt );
586 if ( ret < 0)
587 goto finish ;
589 /* do not return any frames until all threads have something to do */
590 if (fctx-> next_decoding != fctx-> next_finished &&
591 !avctx-> internal -> draining )
592 continue ;
594 p = &fctx-> threads [fctx-> next_finished ];
595 fctx-> next_finished = (fctx-> next_finished + 1) % avctx-> thread_count ;
597 if ( atomic_load (&p-> state ) != STATE_INPUT_READY ) {
598 pthread_mutex_lock (&p-> progress_mutex );
599 while ( atomic_load_explicit (&p-> state , memory_order_relaxed) != STATE_INPUT_READY )
600 pthread_cond_wait (&p-> output_cond , &p-> progress_mutex );
601 pthread_mutex_unlock (&p-> progress_mutex );
602 }
604 update_context_from_thread (avctx, p-> avctx , 1);
605 fctx-> result = p-> result ;
606 p-> result = 0;
607 if (p-> df . nb_f )
608 FFSWAP ( DecodedFrames , fctx-> df , p-> df );
609 }
611 /* a thread may return multiple frames AND an error
612 * we first return all the frames, then the error */
613 if (fctx-> df . nb_f ) {
614 decoded_frames_pop (&fctx-> df , frame );
615 ret = 0;
616 } else {
617 ret = fctx-> result ;
618 fctx-> result = 0;
619 }
621 finish :
622 async_lock (fctx);
623 return ret ;
624 }
626 void ff_thread_report_progress ( ThreadFrame * f , int n, int field )
627 {
628 PerThreadContext *p;
629 atomic_int *progress = f ->progress ? f ->progress->progress : NULL ;
631 if (!progress ||
632 atomic_load_explicit (&progress[ field ], memory_order_relaxed) >= n)
633 return ;
635 p = f ->owner[ field ]->internal->thread_ctx;
637 if ( atomic_load_explicit (&p-> debug_threads , memory_order_relaxed))
638 av_log ( f ->owner[ field ], AV_LOG_DEBUG ,
639 "%p finished %d field %d\n" , progress, n, field );
641 pthread_mutex_lock (&p-> progress_mutex );
643 atomic_store_explicit (&progress[ field ], n, memory_order_release);
645 pthread_cond_broadcast (&p-> progress_cond );
646 pthread_mutex_unlock (&p-> progress_mutex );
647 }
649 void ff_thread_await_progress ( const ThreadFrame * f , int n, int field )
650 {
651 PerThreadContext *p;
652 atomic_int *progress = f ->progress ? f ->progress->progress : NULL ;
654 if (!progress ||
655 atomic_load_explicit (&progress[ field ], memory_order_acquire) >= n)
656 return ;
658 p = f ->owner[ field ]->internal->thread_ctx;
660 if ( atomic_load_explicit (&p-> debug_threads , memory_order_relaxed))
661 av_log ( f ->owner[ field ], AV_LOG_DEBUG ,
662 "thread awaiting %d field %d from %p\n" , n, field , progress);
664 pthread_mutex_lock (&p-> progress_mutex );
665 while ( atomic_load_explicit (&progress[ field ], memory_order_relaxed) < n)
666 pthread_cond_wait (&p-> progress_cond , &p-> progress_mutex );
667 pthread_mutex_unlock (&p-> progress_mutex );
668 }
670 void ff_thread_finish_setup ( AVCodecContext *avctx) {
671 PerThreadContext *p;
673 if (!(avctx-> active_thread_type & FF_THREAD_FRAME )) return ;
675 p = avctx-> internal -> thread_ctx ;
677 p-> hwaccel_threadsafe = avctx-> hwaccel &&
678 ( ffhwaccel (avctx-> hwaccel )-> caps_internal & HWACCEL_CAP_THREAD_SAFE );
680 if ( hwaccel_serial (avctx) && !p-> hwaccel_serializing ) {
681 pthread_mutex_lock (&p-> parent -> hwaccel_mutex );
682 p-> hwaccel_serializing = 1;
683 }
685 /* this assumes that no hwaccel calls happen before ff_thread_finish_setup() */
686 if (avctx-> hwaccel &&
687 !( ffhwaccel (avctx-> hwaccel )-> caps_internal & HWACCEL_CAP_ASYNC_SAFE )) {
688 p-> async_serializing = 1;
690 async_lock (p-> parent );
691 }
693 /* thread-unsafe hwaccels share a single private data instance, so we
694 * save hwaccel state for passing to the next thread;
695 * this is done here so that this worker thread can wipe its own hwaccel
696 * state after decoding, without requiring synchronization */
697 av_assert0 (!p-> parent -> stash_hwaccel );
698 if ( hwaccel_serial (avctx)) {
699 p-> parent -> stash_hwaccel = avctx-> hwaccel ;
700 p-> parent -> stash_hwaccel_context = avctx-> hwaccel_context ;
701 p-> parent -> stash_hwaccel_priv = avctx-> internal -> hwaccel_priv_data ;
702 }
704 pthread_mutex_lock (&p-> progress_mutex );
705 if ( atomic_load (&p-> state ) == STATE_SETUP_FINISHED ){
706 av_log (avctx, AV_LOG_WARNING , "Multiple ff_thread_finish_setup() calls\n" );
707 }
709 atomic_store (&p-> state , STATE_SETUP_FINISHED );
711 pthread_cond_broadcast (&p-> progress_cond );
712 pthread_mutex_unlock (&p-> progress_mutex );
713 }
715 /// Waits for all threads to finish.
716 static void park_frame_worker_threads ( FrameThreadContext *fctx, int thread_count)
717 {
718 int i ;
720 async_unlock (fctx);
722 for ( i = 0; i < thread_count; i ++) {
723 PerThreadContext *p = &fctx-> threads [ i ];
725 if ( atomic_load (&p-> state ) != STATE_INPUT_READY ) {
726 pthread_mutex_lock (&p-> progress_mutex );
727 while ( atomic_load (&p-> state ) != STATE_INPUT_READY )
728 pthread_cond_wait (&p-> output_cond , &p-> progress_mutex );
729 pthread_mutex_unlock (&p-> progress_mutex );
730 }
731 }
733 async_lock (fctx);
734 }
736 #define OFF(member) offsetof(FrameThreadContext, member)
737 DEFINE_OFFSET_ARRAY ( FrameThreadContext , thread_ctx, pthread_init_cnt,
738 ( OFF (buffer_mutex), OFF (hwaccel_mutex), OFF (async_mutex)),
739 ( OFF (async_cond)));
740 #undef OFF
742 #define OFF(member) offsetof(PerThreadContext, member)
743 DEFINE_OFFSET_ARRAY ( PerThreadContext , per_thread, pthread_init_cnt,
744 ( OFF (progress_mutex), OFF ( mutex )),
745 ( OFF (input_cond), OFF (progress_cond), OFF (output_cond)));
746 #undef OFF
748 void ff_frame_thread_free ( AVCodecContext *avctx, int thread_count)
749 {
750 FrameThreadContext *fctx = avctx-> internal -> thread_ctx ;
751 const FFCodec *codec = ffcodec (avctx-> codec );
752 int i ;
754 park_frame_worker_threads (fctx, thread_count);
756 for ( i = 0; i < thread_count; i ++) {
757 PerThreadContext *p = &fctx-> threads [ i ];
758 AVCodecContext * ctx = p-> avctx ;
760 if ( ctx ->internal) {
761 if (p-> thread_init == INITIALIZED ) {
762 pthread_mutex_lock (&p-> mutex );
763 p-> die = 1;
764 pthread_cond_signal (&p-> input_cond );
765 pthread_mutex_unlock (&p-> mutex );
767 pthread_join (p-> thread , NULL );
768 }
769 if (codec-> close && p-> thread_init != UNINITIALIZED )
770 codec-> close ( ctx );
772 /* When using a threadsafe hwaccel, this is where
773 * each thread's context is uninit'd and freed. */
774 ff_hwaccel_uninit ( ctx );
776 if ( ctx -> priv_data ) {
777 if (codec-> p . priv_class )
778 av_opt_free ( ctx -> priv_data );
779 av_freep (& ctx -> priv_data );
780 }
782 ff_refstruct_unref (& ctx ->internal->pool);
783 av_packet_free (& ctx ->internal->in_pkt);
784 av_packet_free (& ctx ->internal->last_pkt_props);
785 av_freep (& ctx ->internal);
786 av_buffer_unref (& ctx ->hw_frames_ctx);
787 av_frame_side_data_free (& ctx ->decoded_side_data,
788 & ctx ->nb_decoded_side_data);
789 }
791 decoded_frames_free (&p-> df );
793 ff_pthread_free (p, per_thread_offsets);
794 av_packet_free (&p-> avpkt );
796 av_freep (&p-> avctx );
797 }
799 decoded_frames_free (&fctx-> df );
800 av_packet_free (&fctx-> next_pkt );
802 av_freep (&fctx-> threads );
803 ff_pthread_free (fctx, thread_ctx_offsets);
805 /* if we have stashed hwaccel state, move it to the user-facing context,
806 * so it will be freed in ff_codec_close() */
807 av_assert0 (!avctx-> hwaccel );
808 FFSWAP ( const AVHWAccel *, avctx-> hwaccel , fctx-> stash_hwaccel );
809 FFSWAP ( void *, avctx-> hwaccel_context , fctx-> stash_hwaccel_context );
810 FFSWAP ( void *, avctx-> internal -> hwaccel_priv_data , fctx-> stash_hwaccel_priv );
812 av_freep (&avctx-> internal -> thread_ctx );
813 }
815 static av_cold int init_thread ( PerThreadContext *p, int *threads_to_free,
816 FrameThreadContext *fctx, AVCodecContext *avctx,
817 const FFCodec *codec, int first )
818 {
819 AVCodecContext * copy ;
820 int err;
822 p-> initial_pict_type = AV_PICTURE_TYPE_NONE ;
823 if (avctx-> codec_descriptor -> props & AV_CODEC_PROP_INTRA_ONLY ) {
824 p-> intra_only_flag = AV_FRAME_FLAG_KEY ;
825 if (avctx-> codec_type == AVMEDIA_TYPE_VIDEO )
826 p-> initial_pict_type = AV_PICTURE_TYPE_I ;
827 }
829 atomic_init (&p-> state , STATE_INPUT_READY );
831 copy = av_memdup (avctx, sizeof (*avctx));
832 if (! copy )
833 return AVERROR (ENOMEM);
834 copy ->priv_data = NULL ;
835 copy ->decoded_side_data = NULL ;
836 copy ->nb_decoded_side_data = 0;
838 /* From now on, this PerThreadContext will be cleaned up by
839 * ff_frame_thread_free in case of errors. */
840 (*threads_to_free)++;
842 p-> parent = fctx;
843 p-> avctx = copy ;
845 copy ->internal = ff_decode_internal_alloc ();
846 if (! copy ->internal)
847 return AVERROR (ENOMEM);
848 copy ->internal->thread_ctx = p;
849 copy ->internal->progress_frame_pool = avctx-> internal -> progress_frame_pool ;
851 copy ->delay = avctx-> delay ;
853 if (codec-> priv_data_size ) {
854 copy ->priv_data = av_mallocz (codec-> priv_data_size );
855 if (! copy ->priv_data)
856 return AVERROR (ENOMEM);
858 if (codec-> p . priv_class ) {
859 *( const AVClass **) copy ->priv_data = codec-> p . priv_class ;
860 err = av_opt_copy ( copy ->priv_data, avctx-> priv_data );
861 if (err < 0)
862 return err;
863 }
864 }
866 err = ff_pthread_init (p, per_thread_offsets);
867 if (err < 0)
868 return err;
870 if (!(p-> avpkt = av_packet_alloc ()))
871 return AVERROR (ENOMEM);
873 copy ->internal->is_frame_mt = 1;
874 if (! first )
875 copy ->internal->is_copy = 1;
877 copy ->internal->in_pkt = av_packet_alloc ();
878 if (! copy ->internal->in_pkt)
879 return AVERROR (ENOMEM);
881 copy ->internal->last_pkt_props = av_packet_alloc ();
882 if (! copy ->internal->last_pkt_props)
883 return AVERROR (ENOMEM);
885 if (codec-> init ) {
886 err = codec-> init ( copy );
887 if (err < 0) {
888 if (codec-> caps_internal & FF_CODEC_CAP_INIT_CLEANUP )
889 p-> thread_init = NEEDS_CLOSE ;
890 return err;
891 }
892 }
893 p-> thread_init = NEEDS_CLOSE ;
895 if ( first ) {
896 update_context_from_thread (avctx, copy , 1);
898 av_frame_side_data_free (&avctx-> decoded_side_data , &avctx-> nb_decoded_side_data );
899 for ( int i = 0; i < copy ->nb_decoded_side_data; i ++) {
900 err = av_frame_side_data_clone (&avctx-> decoded_side_data ,
901 &avctx-> nb_decoded_side_data ,
902 copy ->decoded_side_data[ i ], 0);
903 if (err < 0)
904 return err;
905 }
906 }
908 atomic_init (&p-> debug_threads , ( copy ->debug & FF_DEBUG_THREADS ) != 0);
910 err = AVERROR ( pthread_create (&p-> thread , NULL , frame_worker_thread , p));
911 if (err < 0)
912 return err;
913 p-> thread_init = INITIALIZED ;
915 return 0;
916 }
918 int ff_frame_thread_init ( AVCodecContext *avctx)
919 {
920 int thread_count = avctx-> thread_count ;
921 const FFCodec *codec = ffcodec (avctx-> codec );
922 FrameThreadContext *fctx;
923 int err, i = 0;
925 if (!thread_count) {
926 int nb_cpus = av_cpu_count ();
927 // use number of cores + 1 as thread count if there is more than one
928 if (nb_cpus > 1)
929 thread_count = avctx-> thread_count = FFMIN (nb_cpus + 1, MAX_AUTO_THREADS );
930 else
931 thread_count = avctx-> thread_count = 1;
932 }
934 if (thread_count <= 1) {
935 avctx-> active_thread_type = 0;
936 return 0;
937 }
939 avctx-> internal -> thread_ctx = fctx = av_mallocz ( sizeof ( FrameThreadContext ));
940 if (!fctx)
941 return AVERROR (ENOMEM);
943 err = ff_pthread_init (fctx, thread_ctx_offsets);
944 if (err < 0) {
945 ff_pthread_free (fctx, thread_ctx_offsets);
946 av_freep (&avctx-> internal -> thread_ctx );
947 return err;
948 }
950 fctx-> next_pkt = av_packet_alloc ();
951 if (!fctx-> next_pkt )
952 return AVERROR (ENOMEM);
954 fctx-> async_lock = 1;
956 if (codec-> p . type == AVMEDIA_TYPE_VIDEO )
957 avctx-> delay = avctx-> thread_count - 1;
959 fctx-> threads = av_calloc (thread_count, sizeof (*fctx-> threads ));
960 if (!fctx-> threads ) {
961 err = AVERROR (ENOMEM);
962 goto error ;
963 }
965 for (; i < thread_count; ) {
966 PerThreadContext *p = &fctx-> threads [ i ];
967 int first = ! i ;
969 err = init_thread (p, & i , fctx, avctx, codec, first );
970 if (err < 0)
971 goto error ;
972 }
974 return 0;
976 error :
977 ff_frame_thread_free (avctx, i );
978 return err;
979 }
981 void ff_thread_flush ( AVCodecContext *avctx)
982 {
983 int i ;
984 FrameThreadContext *fctx = avctx-> internal -> thread_ctx ;
986 if (!fctx) return ;
988 park_frame_worker_threads (fctx, avctx-> thread_count );
989 if (fctx-> prev_thread ) {
990 if (fctx-> prev_thread != &fctx-> threads [0])
991 update_context_from_thread (fctx-> threads [0]. avctx , fctx-> prev_thread -> avctx , 0);
992 }
994 fctx-> next_decoding = fctx-> next_finished = 0;
995 fctx-> prev_thread = NULL ;
997 decoded_frames_flush (&fctx-> df );
998 fctx-> result = 0;
1000 for ( i = 0; i < avctx-> thread_count ; i ++) {
1001 PerThreadContext *p = &fctx-> threads [ i ];
1003 decoded_frames_flush (&p-> df );
1004 p-> result = 0;
1006 avcodec_flush_buffers (p-> avctx );
1007 }
1008 }
1010 int ff_thread_can_start_frame ( AVCodecContext *avctx)
1011 {
1012 if ((avctx-> active_thread_type & FF_THREAD_FRAME ) &&
1013 ffcodec (avctx-> codec )-> update_thread_context ) {
1014 PerThreadContext *p = avctx-> internal -> thread_ctx ;
1016 if ( atomic_load (&p-> state ) != STATE_SETTING_UP )
1017 return 0;
1018 }
1020 return 1;
1021 }
1023 static int thread_get_buffer_internal ( AVCodecContext *avctx, AVFrame * f , int flags )
1024 {
1025 PerThreadContext *p;
1026 int err;
1028 if (!(avctx-> active_thread_type & FF_THREAD_FRAME ))
1029 return ff_get_buffer (avctx, f , flags );
1031 p = avctx-> internal -> thread_ctx ;
1032 if ( atomic_load (&p-> state ) != STATE_SETTING_UP &&
1033 ffcodec (avctx-> codec )-> update_thread_context ) {
1034 av_log (avctx, AV_LOG_ERROR , "get_buffer() cannot be called after ff_thread_finish_setup()\n" );
1035 return -1;
1036 }
1038 pthread_mutex_lock (&p-> parent -> buffer_mutex );
1039 err = ff_get_buffer (avctx, f , flags );
1041 pthread_mutex_unlock (&p-> parent -> buffer_mutex );
1043 return err;
1044 }
1046 int ff_thread_get_buffer ( AVCodecContext *avctx, AVFrame * f , int flags )
1047 {
1048 int ret = thread_get_buffer_internal (avctx, f , flags );
1049 if ( ret < 0)
1050 av_log (avctx, AV_LOG_ERROR , "thread_get_buffer() failed\n" );
1051 return ret ;
1052 }
1054 int ff_thread_get_ext_buffer ( AVCodecContext *avctx, ThreadFrame * f , int flags )
1055 {
1056 int ret ;
1058 f ->owner[0] = f ->owner[1] = avctx;
1059 if (!(avctx-> active_thread_type & FF_THREAD_FRAME ))
1060 return ff_get_buffer (avctx, f ->f, flags );
1062 f ->progress = ff_refstruct_allocz ( sizeof (* f ->progress));
1063 if (! f ->progress)
1064 return AVERROR (ENOMEM);
1066 atomic_init (& f ->progress->progress[0], -1);
1067 atomic_init (& f ->progress->progress[1], -1);
1069 ret = ff_thread_get_buffer (avctx, f ->f, flags );
1070 if ( ret )
1071 ff_refstruct_unref (& f ->progress);
1072 return ret ;
1073 }
1075 void ff_thread_release_ext_buffer ( ThreadFrame * f )
1076 {
1077 ff_refstruct_unref (& f ->progress);
1078 f ->owner[0] = f ->owner[1] = NULL ;
1079 if ( f ->f)
1080 av_frame_unref ( f ->f);
1081 }
1083 enum ThreadingStatus ff_thread_sync_ref ( AVCodecContext *avctx, size_t offset )
1084 {
1085 PerThreadContext *p;
1086 const void * ref ;
1088 if (!avctx-> internal -> is_copy )
1089 return avctx-> active_thread_type & FF_THREAD_FRAME ?
1090 FF_THREAD_IS_FIRST_THREAD : FF_THREAD_NO_FRAME_THREADING ;
1092 p = avctx-> internal -> thread_ctx ;
1094 av_assert1 (memcpy(& ref , ( char *)avctx-> priv_data + offset , sizeof ( ref )) && ref == NULL );
1096 memcpy(& ref , ( const char *)p-> parent -> threads [0]. avctx -> priv_data + offset , sizeof ( ref ));
1097 av_assert1 ( ref );
1098 ff_refstruct_replace (( char *)avctx-> priv_data + offset , ref );
1100 return FF_THREAD_IS_COPY ;
1101 }
1103 int ff_thread_get_packet ( AVCodecContext *avctx, AVPacket * pkt )
1104 {
1105 PerThreadContext *p = avctx-> internal -> thread_ctx ;
1107 if (! AVPACKET_IS_EMPTY (p-> avpkt )) {
1108 av_packet_move_ref ( pkt , p-> avpkt );
1109 return 0;
1110 }
1112 return avctx-> internal -> draining ? AVERROR_EOF : AVERROR (EAGAIN);
1113 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
pthread_mutex_t
_fmutex pthread_mutex_t
Definition: os2threads.h:53
FFCodec::update_thread_context
int(* update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy necessary context variables from a previous thread context to the current one.
Definition: codec_internal.h:156
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:428
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1431
AVCodec
AVCodec.
Definition: codec.h:187
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
thread_set_name
static void thread_set_name(PerThreadContext *p)
Definition: pthread_frame.c:184
AVCodecContext::hwaccel_context
void * hwaccel_context
Legacy hardware accelerator context.
Definition: avcodec.h:1455
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
ff_decode_get_packet
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
Definition: decode.c:240
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
PerThreadContext::input_cond
pthread_cond_t input_cond
Used to wait for a new packet from the main thread.
Definition: pthread_frame.c:87
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
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
PerThreadContext::initial_pict_type
enum AVPictureType initial_pict_type
Definition: pthread_frame.c:121
hwaccel_serial
static int hwaccel_serial(const AVCodecContext *avctx)
Definition: pthread_frame.c:161
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:685
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2081
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
PerThreadContext::debug_threads
atomic_int debug_threads
Set if the FF_DEBUG_THREADS option is set.
Definition: pthread_frame.c:117
df
#define df(A, B)
Definition: vf_xbr.c:91
AVCodec::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: codec.h:212
FrameThreadContext::next_decoding
int next_decoding
The next context to submit a packet to.
Definition: pthread_frame.c:150
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ff_thread_flush
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
Definition: pthread_frame.c:981
init_thread
static av_cold int init_thread(PerThreadContext *p, int *threads_to_free, FrameThreadContext *fctx, AVCodecContext *avctx, const FFCodec *codec, int first)
Definition: pthread_frame.c:815
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: pthread_frame.c:1010
decoded_frames_free
static void decoded_frames_free(DecodedFrames *df)
Definition: pthread_frame.c:232
AVPictureType
AVPictureType
Definition: avutil.h:277
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1866
MAX_AUTO_THREADS
#define MAX_AUTO_THREADS
Definition: pthread_internal.h:26
FF_THREAD_IS_FIRST_THREAD
@ FF_THREAD_IS_FIRST_THREAD
Definition: thread.h:66
FrameThreadContext
Context stored in the client AVCodecInternal thread_ctx.
Definition: pthread_frame.c:127
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
park_frame_worker_threads
static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
Waits for all threads to finish.
Definition: pthread_frame.c:716
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
ff_thread_sync_ref
enum ThreadingStatus ff_thread_sync_ref(AVCodecContext *avctx, size_t offset)
Allows to synchronize objects whose lifetime is the whole decoding process among all frame threads.
Definition: pthread_frame.c:1083
version_major.h
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
FrameThreadContext::next_pkt
AVPacket * next_pkt
Packet to be submitted to the next thread for decoding.
Definition: pthread_frame.c:148
ff_thread_receive_frame
int ff_thread_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Submit available packets for decoding to worker threads, return a decoded frame if available.
Definition: pthread_frame.c:565
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
av_frame_side_data_clone
int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd, const AVFrameSideData *src, unsigned int flags)
Add a new side data entry to an array based on existing side data, taking a reference towards the con...
Definition: frame.c:874
AVCodecContext::delay
int delay
Codec delay.
Definition: avcodec.h:601
PerThreadContext::die
int die
Set when the thread should exit.
Definition: pthread_frame.c:106
ff_pthread_free
av_cold void ff_pthread_free(void *obj, const unsigned offsets[])
Definition: pthread.c:92
FrameThreadContext::next_finished
int next_finished
The next context to return output from.
Definition: pthread_frame.c:151
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
STATE_INPUT_READY
@ STATE_INPUT_READY
Set when the thread is awaiting a packet.
Definition: pthread_frame.c:55
FrameThreadContext::buffer_mutex
pthread_mutex_t buffer_mutex
Mutex used to protect get/release_buffer().
Definition: pthread_frame.c:132
ff_hwaccel_uninit
void ff_hwaccel_uninit(AVCodecContext *avctx)
Definition: decode.c:1253
av_memdup
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
Definition: mem.c:304
FFCodec::priv_data_size
int priv_data_size
Definition: codec_internal.h:144
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
AVCodecInternal::is_copy
int is_copy
When using frame-threaded decoding, this field is set for the first worker thread (e....
Definition: internal.h:54
AVCodecInternal::progress_frame_pool
struct FFRefStructPool * progress_frame_pool
Definition: internal.h:71
ff_frame_thread_free
void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
Definition: pthread_frame.c:748
AVCodecContext::skip_idct
enum AVDiscard skip_idct
Skip IDCT/dequantization for selected frames.
Definition: avcodec.h:1817
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
finish
static void finish(void)
Definition: movenc.c:373
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1824
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1587
update_context_from_user
static int update_context_from_user(AVCodecContext *dst, const AVCodecContext *src)
Update the next thread's AVCodecContext with values set by the user.
Definition: pthread_frame.c:471
FrameThreadContext::pthread_init_cnt
unsigned pthread_init_cnt
Number of successfully initialized mutexes/conditions.
Definition: pthread_frame.c:131
av_opt_free
void av_opt_free(void *obj)
Free all allocated objects in obj.
Definition: opt.c:1914
HWACCEL_CAP_THREAD_SAFE
#define HWACCEL_CAP_THREAD_SAFE
Definition: hwaccel_internal.h:32
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
PerThreadContext
Context used by codec threads and stored in their AVCodecInternal thread_ctx.
Definition: pthread_frame.c:81
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:148
AVCodecContext::get_buffer2
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:1226
first
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
Definition: rate_distortion.txt:12
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
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
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:626
FFCodec::update_thread_context_for_user
int(* update_thread_context_for_user)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy variables back to the user-facing context.
Definition: codec_internal.h:161
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:723
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVCodecInternal::pool
struct FramePool * pool
Definition: internal.h:69
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2082
PerThreadContext::output_cond
pthread_cond_t output_cond
Used by the main thread to wait for frames to finish.
Definition: pthread_frame.c:89
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1046
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1579
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
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
FrameThreadContext::prev_thread
PerThreadContext * prev_thread
The last thread submit_packet() was called on.
Definition: pthread_frame.c:129
FFCodec::init
int(* init)(struct AVCodecContext *)
Definition: codec_internal.h:177
arg
const char * arg
Definition: jacosubdec.c:67
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
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
HWACCEL_CAP_ASYNC_SAFE
#define HWACCEL_CAP_ASYNC_SAFE
Header providing the internals of AVHWAccel.
Definition: hwaccel_internal.h:31
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
hwaccel_internal.h
UNINITIALIZED
@ UNINITIALIZED
Thread has not been created, AVCodec->close mustn't be called.
Definition: pthread_frame.c:63
ff_thread_await_progress
void ff_thread_await_progress(const ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: pthread_frame.c:649
AVCodecContext::slice_flags
int slice_flags
slice flags
Definition: avcodec.h:730
thread_get_buffer_internal
static int thread_get_buffer_internal(AVCodecContext *avctx, AVFrame *f, int flags)
Definition: pthread_frame.c:1023
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
frame_worker_thread
static attribute_align_arg void * frame_worker_thread(void *arg)
Codec worker thread.
Definition: pthread_frame.c:248
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:480
PerThreadContext::progress_mutex
pthread_mutex_t progress_mutex
Mutex used to protect frame progress values and progress_cond.
Definition: pthread_frame.c:92
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
FrameThreadContext::async_mutex
pthread_mutex_t async_mutex
Definition: pthread_frame.c:138
ff_thread_finish_setup
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
Definition: pthread_frame.c:670
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1075
FrameThreadContext::hwaccel_mutex
pthread_mutex_t hwaccel_mutex
This lock is used for ensuring threads run in serial when thread-unsafe hwaccel is used.
Definition: pthread_frame.c:137
PerThreadContext::avctx
AVCodecContext * avctx
Context used to decode packets passed to this thread.
Definition: pthread_frame.c:94
ff_refstruct_allocz
static void * ff_refstruct_allocz(size_t size)
Equivalent to ff_refstruct_alloc_ext(size, 0, NULL, NULL)
Definition: refstruct.h:105
pthread_internal.h
FF_THREAD_IS_COPY
@ FF_THREAD_IS_COPY
Definition: thread.h:65
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:485
AVPACKET_IS_EMPTY
#define AVPACKET_IS_EMPTY(pkt)
Definition: packet_internal.h:26
AVCodecContext::level
int level
Encoding level descriptor.
Definition: avcodec.h:1788
atomic_load_explicit
#define atomic_load_explicit(object, order)
Definition: stdatomic.h:96
FF_DEBUG_THREADS
#define FF_DEBUG_THREADS
Definition: avcodec.h:1413
OFF
#define OFF(member)
Definition: pthread_frame.c:742
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:82
AVCodecInternal::last_pkt_props
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
Definition: internal.h:90
PerThreadContext::df
DecodedFrames df
Decoded frames from a single decode iteration.
Definition: pthread_frame.c:101
async_lock
static void async_lock(FrameThreadContext *fctx)
Definition: pthread_frame.c:166
av_opt_copy
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
Definition: opt.c:2114
PerThreadContext::pthread_init_cnt
unsigned pthread_init_cnt
Number of successfully initialized mutexes/conditions.
Definition: pthread_frame.c:86
av_cpu_count
int av_cpu_count(void)
Definition: cpu.c:209
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:50
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:544
PerThreadContext::result
int result
The result of the last codec decode/encode() call.
Definition: pthread_frame.c:102
FrameThreadContext::stash_hwaccel
const AVHWAccel * stash_hwaccel
Definition: pthread_frame.c:156
f
f
Definition: af_crystalizer.c:122
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:509
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1599
copy
static void copy(const float *p1, float *p2, const int length)
Definition: vf_vaguedenoiser.c:186
codec_internal.h
AVCodecInternal::hwaccel_priv_data
void * hwaccel_priv_data
hwaccel-specific private data
Definition: internal.h:130
PerThreadContext::intra_only_flag
int intra_only_flag
The following two fields have the same semantics as the DecodeContext field.
Definition: pthread_frame.c:120
PerThreadContext::avpkt
AVPacket * avpkt
Input packet (for decoding) or output (for encoding).
Definition: pthread_frame.c:96
async_unlock
static void async_unlock(FrameThreadContext *fctx)
Definition: pthread_frame.c:175
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1057
FrameThreadContext::async_cond
pthread_cond_t async_cond
Definition: pthread_frame.c:139
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:305
decoded_frames_pop
static void decoded_frames_pop(DecodedFrames *df, AVFrame *dst)
Definition: pthread_frame.c:217
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
PerThreadContext::parent
struct FrameThreadContext * parent
Definition: pthread_frame.c:82
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
AVCodecContext::skip_loop_filter
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:1810
FF_THREAD_NO_FRAME_THREADING
@ FF_THREAD_NO_FRAME_THREADING
Definition: thread.h:67
ff_thread_get_packet
int ff_thread_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Get a packet for decoding.
Definition: pthread_frame.c:1103
pthread_t
Definition: os2threads.h:44
ff_decode_receive_frame_internal
int ff_decode_receive_frame_internal(struct AVCodecContext *avctx, AVFrame *frame)
Do the actual decoding and obtain a decoded frame from the decoder, if available.
Definition: decode.c:613
STATE_SETUP_FINISHED
@ STATE_SETUP_FINISHED
Set after the codec has called ff_thread_finish_setup().
Definition: pthread_frame.c:59
decoded_frames_flush
static void decoded_frames_flush(DecodedFrames *df)
Definition: pthread_frame.c:225
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1598
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1572
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:135
av_packet_copy_props
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
Definition: packet.c:391
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:1800
av_frame_side_data_free
void av_frame_side_data_free(AVFrameSideData ***sd, int *nb_sd)
Free all side data entries and their contents, then zeroes out the values which the pointers are poin...
Definition: frame.c:111
AVCodecContext::hwaccel_flags
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active).
Definition: avcodec.h:1510
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
atomic_store_explicit
#define atomic_store_explicit(object, desired, order)
Definition: stdatomic.h:90
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:635
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:608
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
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1552
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:702
pthread_cond_t
Definition: os2threads.h:58
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1054
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
NEEDS_CLOSE
@ NEEDS_CLOSE
FFCodec->close needs to be called.
Definition: pthread_frame.c:64
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1479
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2035
DEFINE_OFFSET_ARRAY
DEFINE_OFFSET_ARRAY(FrameThreadContext, thread_ctx, pthread_init_cnt,(OFF(buffer_mutex), OFF(hwaccel_mutex), OFF(async_mutex)),(OFF(async_cond)))
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
avcodec_flush_buffers
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
Definition: avcodec.c:364
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
ff_frame_thread_init
int ff_frame_thread_init(AVCodecContext *avctx)
Definition: pthread_frame.c:918
ff_decode_internal_alloc
struct AVCodecInternal * ff_decode_internal_alloc(void)
Definition: decode.c:2182
decoded_frames_get_free
static AVFrame * decoded_frames_get_free(DecodedFrames *df)
Definition: pthread_frame.c:196
AVCodecContext::opaque
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:487
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
ff_refstruct_replace
void ff_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
pthread_cond_signal
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
Definition: os2threads.h:152
AVCodecContext::draw_horiz_band
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band.
Definition: avcodec.h:758
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:1606
avcodec_internal.h
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1644
ffhwaccel
static const FFHWAccel * ffhwaccel(const AVHWAccel *codec)
Definition: hwaccel_internal.h:166
submit_packet
static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx, AVPacket *in_pkt)
Definition: pthread_frame.c:501
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:576
AVCodecContext::export_side_data
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame,...
Definition: avcodec.h:1931
AV_CODEC_CAP_DELAY
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:76
FFCodec::close
int(* close)(struct AVCodecContext *)
Definition: codec_internal.h:239
INITIALIZED
@ INITIALIZED
Thread has been properly set up.
Definition: pthread_frame.c:65
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:105
pthread_cond_wait
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: os2threads.h:192
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1400
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:444
AVCodecInternal::draining
int draining
decoding: AVERROR_EOF has been returned from ff_decode_get_packet(); must not be used by decoders tha...
Definition: internal.h:139
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:633
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
packet_internal.h
ThreadingStatus
ThreadingStatus
Definition: thread.h:64
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:510
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
PerThreadContext::mutex
pthread_mutex_t mutex
Mutex used to protect the contents of the PerThreadContext.
Definition: pthread_frame.c:91
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
update_context_from_thread
static int update_context_from_thread(AVCodecContext *dst, const AVCodecContext *src, int for_user)
Update the next thread's AVCodecContext with values from the reference thread's context.
Definition: pthread_frame.c:350
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:664
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
STATE_SETTING_UP
@ STATE_SETTING_UP
Set before the codec has called ff_thread_finish_setup().
Definition: pthread_frame.c:57
codec_desc.h
FFHWAccel::caps_internal
int caps_internal
Internal hwaccel capabilities.
Definition: hwaccel_internal.h:117
snprintf
#define snprintf
Definition: snprintf.h:34
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1288
ff_refstruct_unref
void ff_refstruct_unref(void *objp)
Decrement the reference count of the underlying object and automatically free the object if there are...
Definition: refstruct.c:120
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:642
ThreadFrameProgress::progress
atomic_int progress[2]
Definition: pthread_frame.c:75
mutex
static AVMutex mutex
Definition: log.c:46
PerThreadContext::progress_cond
pthread_cond_t progress_cond
Used by child threads to wait for progress to change.
Definition: pthread_frame.c:88
FrameThreadContext::threads
PerThreadContext * threads
The contexts for each thread.
Definition: pthread_frame.c:128
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:78
ff_thread_setname
static int ff_thread_setname(const char *name)
Definition: thread.h:216
 
推荐文章
捣蛋的针织衫  ·  FFMPEG结构体分析 AVFrame__ffmpeg架构
1 周前
老实的充值卡  ·  FFmpeg 编解码器文档_ FFmpeg中文网
1 周前
健身的煎鸡蛋  ·  FFmpeg 入门(5)：视频同步 | SamirChen
1 周前
发怒的楼房  ·  还不知道如何学习音视频？_牛客网
1 周前
求醉的斑马  ·  Intel VAAPI/QSV/oneVPL区别简介
1 周前
旅行中的书包  ·  Spring Boot 2의 경우 403 대신 401
1 月前
失望的鸵鸟  ·  CUDA error: an illegal memory access was encountered error when inference · Issue #3848 · ultralytic
7 月前
想旅行的显示器  ·  C++基础---无返回值函数(void函数)-CSDN博客
10 月前
玩足球的爆米花  ·  T20天正V8破解下载 T20天正电气软件 v8.0 官方中文破解版(含安装教程) 下载-脚本之家
1 年前
私奔的领结  ·  RestTemplate 最详解 - 知乎
1 年前
Link管理   ·   51好读   ·   Sov5搜索   ·   小百科
link管理 - 链接快照平台