27 #include <stdatomic.h> 99 #if FF_API_THREAD_SAFE_CALLBACKS 150 #if FF_API_THREAD_SAFE_CALLBACKS 151 #define THREAD_SAFE_CALLBACKS(avctx) \ 152 ((avctx)->thread_safe_callbacks || (avctx)->get_buffer2 == avcodec_default_get_buffer2) 224 "free the frame on failure. This is a bug, please report it.\n");
324 #if FF_API_CODED_FRAME 364 #if FF_API_THREAD_SAFE_CALLBACKS 384 #if FF_API_THREAD_SAFE_CALLBACKS 427 memory_order_relaxed);
429 #if FF_API_THREAD_SAFE_CALLBACKS 461 #if FF_API_THREAD_SAFE_CALLBACKS 506 AVFrame *picture,
int *got_picture_ptr,
550 p = &fctx->
threads[finished++];
574 }
while (!avpkt->
size && !*got_picture_ptr && err >= 0 && finished != fctx->
next_finished);
603 "%p finished %d field %d\n", progress, n, field);
626 "thread awaiting %d field %d from %p\n", n, field, progress);
670 for (i = 0; i < thread_count; i++) {
685 #define SENTINEL 0 // This forbids putting a mutex/condition variable at the front. 686 #define OFFSET_ARRAY(...) __VA_ARGS__, SENTINEL 687 #define DEFINE_OFFSET_ARRAY(type, name, mutexes, conds) \ 688 static const unsigned name ## _offsets[] = { offsetof(type, pthread_init_cnt),\ 689 OFFSET_ARRAY mutexes, \ 692 #define OFF(member) offsetof(FrameThreadContext, member) 694 (
OFF(buffer_mutex),
OFF(hwaccel_mutex),
OFF(async_mutex)),
698 #define OFF(member) offsetof(PerThreadContext, member) 706 unsigned cnt = *(
unsigned*)((
char*)obj + offsets[0]);
707 const unsigned *cur_offset =
offsets;
709 for (; *(++cur_offset) !=
SENTINEL && cnt; cnt--)
711 for (; *(++cur_offset) !=
SENTINEL && cnt; cnt--)
717 const unsigned *cur_offset =
offsets;
721 #define PTHREAD_INIT_LOOP(type) \ 722 for (; *(++cur_offset) != SENTINEL; cnt++) { \ 723 pthread_ ## type ## _t *dst = (void*)((char*)obj + *cur_offset); \ 724 err = pthread_ ## type ## _init(dst, NULL); \ 726 err = AVERROR(err); \ 734 *(
unsigned*)((
char*)obj + offsets[0]) = cnt;
760 for (i = 0; i < thread_count; i++) {
776 #if FF_API_THREAD_SAFE_CALLBACKS 829 (*threads_to_free)++;
867 err = codec->
init(copy);
906 if (thread_count <= 1) {
934 for (; i < thread_count; ) {
938 err =
init_thread(p, &i, fctx, avctx, src, codec, first);
973 #if FF_API_THREAD_SAFE_CALLBACKS 1016 av_log(avctx,
AV_LOG_ERROR,
"get_buffer() cannot be called after ff_thread_finish_setup()\n");
1033 #if !FF_API_THREAD_SAFE_CALLBACKS 1066 #if FF_API_THREAD_SAFE_CALLBACKS 1076 av_log(avctx,
AV_LOG_ERROR,
"get_format() cannot be called after ff_thread_finish_setup()\n");
1106 #if FF_API_THREAD_SAFE_CALLBACKS 1126 #if !FF_API_THREAD_SAFE_CALLBACKS 1130 if (can_direct_free || !f->
f->
buf[0]) {
1138 if (p->num_released_buffers == p->released_buffers_allocated) {
1140 sizeof(*p->released_buffers));
1143 p->released_buffers =
tmp;
1146 if (!tmp || !tmp[p->released_buffers_allocated]) {
1150 p->released_buffers_allocated++;
1153 dst = p->released_buffers[p->num_released_buffers];
1156 p->num_released_buffers++;
1164 av_log(avctx,
AV_LOG_ERROR,
"Could not queue a frame for freeing, this will leak\n");
1165 memset(f->
f->
buf, 0,
sizeof(f->
f->
buf));
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static int thread_get_buffer_internal(AVCodecContext *avctx, ThreadFrame *f, int flags)
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
int caps_internal
Internal hwaccel capabilities.
pthread_cond_t progress_cond
Used by child threads to wait for progress to change.
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
const struct AVCodec * codec
static av_cold int init_pthread(void *obj, const unsigned offsets[])
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
static void copy(const float *p1, float *p2, const int length)
unsigned pthread_init_cnt
Number of successfully initialized mutexes/conditions.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
This structure describes decoded (raw) audio or video data.
#define pthread_mutex_lock(a)
static av_always_inline int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
#define atomic_store(object, desired)
Context used by codec threads and stored in their AVCodecInternal thread_ctx.
AVFrame * requested_frame
AVFrame the codec passed to get_buffer()
int coded_width
Bitstream width / height, may be different from width/height e.g.
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
static int submit_packet(PerThreadContext *p, AVCodecContext *user_avctx, AVPacket *avpkt)
#define AV_LOG_WARNING
Something somehow does not look correct.
Memory handling functions.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
void(* flush)(struct AVCodecContext *)
Flush buffers.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int nb_extended_buf
Number of elements in extended_buf.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
static void error(const char *err)
pthread_cond_t input_cond
Used to wait for a new packet from the main thread.
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
enum AVPixelFormat * available_formats
Format array for get_format()
static av_always_inline int pthread_cond_destroy(pthread_cond_t *cond)
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...
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
enum AVDiscard skip_frame
Skip decoding for selected frames.
#define FF_API_THREAD_SAFE_CALLBACKS
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int export_side_data
Bit set of AV_CODEC_EXPORT_DATA_* flags, which affects the kind of metadata exported in frame...
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
enum AVSampleFormat sample_fmt
audio sample format
static const int offsets[]
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
void * hwaccel_context
Hardware accelerator context.
Thread has been properly set up.
static attribute_align_arg void * frame_worker_thread(void *arg)
Codec worker thread.
Multithreading support functions.
#define THREAD_SAFE_CALLBACKS(avctx)
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But first
pthread_mutex_t hwaccel_mutex
This lock is used for ensuring threads run in serial when hwaccel is used.
AVCodec->close needs to be called.
int requested_flags
flags passed to get_buffer() for requested_frame
int next_decoding
The next context to submit a packet to.
static av_always_inline int pthread_cond_signal(pthread_cond_t *cond)
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
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...
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Context stored in the client AVCodecInternal thread_ctx.
AVCodecContext * avctx
Context used to decode packets passed to this thread.
Thread has not been created, AVCodec->close mustn't be called.
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
int die
Set when the thread should exit.
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
int slice_count
slice count
Libavcodec version macros.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
unsigned pthread_init_cnt
Number of successfully initialized mutexes/conditions.
PerThreadContext * prev_thread
The last thread submit_packet() was called on.
void ff_frame_thread_free(AVCodecContext *avctx, int thread_count)
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
#define atomic_load(object)
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
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
int active_thread_type
Which multithreading methods are in use by the codec.
int capabilities
Codec capabilities.
int result
The result of the last codec decode/encode() call.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int flags
AV_CODEC_FLAG_*.
simple assert() macros that are a bit more flexible than ISO C assert().
static av_cold int init_thread(PerThreadContext *p, int *threads_to_free, FrameThreadContext *fctx, AVCodecContext *avctx, AVCodecContext *src, const AVCodec *codec, int first)
void * av_memdup(const void *p, size_t size)
Duplicate a buffer with av_malloc().
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
int av_reallocp_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array through a pointer to a pointer.
common internal API header
#define HWACCEL_CAP_ASYNC_SAFE
pthread_cond_t output_cond
Used by the main thread to wait for frames to finish.
int(* update_thread_context)(struct AVCodecContext *dst, const struct AVCodecContext *src)
Copy necessary context variables from a previous thread context to the current one.
AVFrame ** released_buffers
Array of frames passed to ff_thread_release_buffer().
#define FF_THREAD_FRAME
Decode more than one frame at once.
Set when the codec calls get_buffer().
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers, this array will hold all the references which cannot fit into AVFrame.buf.
int width
picture width / height.
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
#define atomic_load_explicit(object, order)
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
#define pthread_mutex_unlock(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
int got_frame
The output of got_picture_ptr from the last avcodec_decode_video() call.
static int update_context_from_user(AVCodecContext *dst, AVCodecContext *src)
Update the next thread's AVCodecContext with values set by the user.
pthread_mutex_t buffer_mutex
Mutex used to protect get/release_buffer().
int(* decode)(struct AVCodecContext *avctx, void *outdata, int *got_frame_ptr, struct AVPacket *avpkt)
Decode picture or subtitle data.
pthread_mutex_t progress_mutex
Mutex used to protect frame progress values and progress_cond.
static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
pthread_cond_t async_cond
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Libavcodec external API header.
enum AVMediaType codec_type
AVBufferRef * av_buffer_alloc(buffer_size_t size)
Allocate an AVBuffer of the given size using av_malloc().
int sample_rate
samples per second
enum AVDiscard skip_idct
Skip IDCT/dequantization for selected frames.
main external API structure.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
uint8_t * data
The data buffer.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int slice_flags
slice flags
AVCodecContext * owner[2]
Describe the class of an AVClass context structure.
int(* init)(struct AVCodecContext *)
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.
enum AVColorSpace colorspace
YUV colorspace type.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
enum AVPixelFormat result_format
get_format() result
int delaying
Set for the first N packets, where N is the number of threads.
refcounted data buffer API
#define atomic_store_explicit(object, desired, order)
static void async_unlock(FrameThreadContext *fctx)
#define DEFINE_OFFSET_ARRAY(type, name, mutexes, conds)
PerThreadContext * threads
The contexts for each thread.
static void async_lock(FrameThreadContext *fctx)
AVPacket * avpkt
Input packet (for decoding) or output (for encoding).
struct FrameThreadContext * parent
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
#define flags(name, subs,...)
const AVClass * priv_class
AVClass for the private context.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int(* cond)(enum AVPixelFormat pix_fmt)
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
void av_opt_free(void *obj)
Free all allocated objects in obj.
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
common internal and external API header
int released_buffers_allocated
void * hwaccel_priv_data
hwaccel-specific private data
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
static int update_context_from_thread(AVCodecContext *dst, AVCodecContext *src, int for_user)
Update the next thread's AVCodecContext with values from the reference thread's context.
int av_opt_copy(void *dst, const void *src)
Copy options from src object into dest object.
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
int caps_internal
Internal codec capabilities.
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
attribute_deprecated int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
int(* close)(struct AVCodecContext *)
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
AVFrame * frame
Output frame (for decoding) or input (for encoding).
int ff_thread_can_start_frame(AVCodecContext *avctx)
#define FF_ENABLE_DEPRECATION_WARNINGS
static av_always_inline int pthread_cond_broadcast(pthread_cond_t *cond)
int channels
number of audio channels
struct AVCodecInternal * internal
Private context used for internal data.
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
pthread_mutex_t mutex
Mutex used to protect the contents of the PerThreadContext.
int flags2
AV_CODEC_FLAG2_*.
#define PTHREAD_INIT_LOOP(type)
static void park_frame_worker_threads(FrameThreadContext *fctx, int thread_count)
Waits for all threads to finish.
Set when the thread is awaiting a packet.
pthread_mutex_t async_mutex
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
int * slice_offset
slice offsets in the frame in bytes
int frame_number
Frame counter, set by libavcodec.
atomic_int debug_threads
Set if the FF_DEBUG_THREADS option is set.
static void release_delayed_buffers(PerThreadContext *p)
Releases the buffers that this decoding thread was the last user of.
#define atomic_init(obj, value)
int hwaccel_flags
Bit set of AV_HWACCEL_FLAG_* flags, which affect hardware accelerated decoding (if active)...
Set when the codec calls get_format().
int next_finished
The next context to return output from.
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
uint8_t ** extended_data
pointers to the data planes/channels.
AVPixelFormat
Pixel format.
This structure stores compressed data.
int ff_frame_thread_init(AVCodecContext *avctx)
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
void * opaque
Private data of the user, can be used to carry app specific stuff.
static av_cold void free_pthread(void *obj, const unsigned offsets[])
int av_buffer_replace(AVBufferRef **pdst, AVBufferRef *src)
Ensure dst refers to the same data as src.
FF_DISABLE_DEPRECATION_WARNINGS enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
void * av_mallocz_array(size_t nmemb, size_t size)