On 2013-02-13 19:50:38 +0100, Anton Khirnov wrote:
> ---
> doc/multithreading.txt | 5 ++
> libavcodec/internal.h | 15 +++++
> libavcodec/pthread.c | 169
> ++++++++++++++++++++++++------------------------
> libavcodec/thread.h | 20 ++++--
> libavcodec/utils.c | 19 ++++++
> 5 files changed, 139 insertions(+), 89 deletions(-)
>
> diff --git a/doc/multithreading.txt b/doc/multithreading.txt
> index b72bc16..9b27b10 100644
> --- a/doc/multithreading.txt
> +++ b/doc/multithreading.txt
> @@ -57,6 +57,11 @@ which re-allocates them for other threads.
> Add CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very
> little
> speed gain at this point but it should work.
>
> +If there are inter-frame dependencies, so the codec calls
> +ff_thread_report/await_progress(), set AVCodecInternal.allocate_progress. The
> +frames must then be freed with ff_thread_release_buffer().
> +Otherwise leave it at zero and decode directly into the user-supplied frames.
> +
> Call ff_thread_report_progress() after some part of the current picture has
> decoded.
> A good place to put this is where draw_horiz_band() is called - add this if
> it isn't
> called anywhere, as it's useful too and the implementation is trivial when
> you're
> diff --git a/libavcodec/internal.h b/libavcodec/internal.h
> index 8e64640..594bd1e 100644
> --- a/libavcodec/internal.h
> +++ b/libavcodec/internal.h
> @@ -61,6 +61,21 @@ typedef struct AVCodecInternal {
> */
> int is_copy;
>
> + /**
> + * Whether to allocate progress for frame threading.
> + *
> + * The codec must set it to 1 if it uses
> ff_thread_await/report_progress(),
> + * then progress will be allocated in ff_thread_get_buffer(). The frames
> + * then MUST be freed with ff_thread_release_buffer().
> + *
> + * If the codec does not need to call the progress functions (there are
> no
> + * dependencies between the frames), it should leave this at 0. Then it
> can
> + * decode straight to the user-provided frames (which the user will then
> + * free with av_frame_unref()), there is no need to call
> + * ff_thread_release_buffer().
> + */
> + int allocate_progress;
> +
> #if FF_API_OLD_DECODE_AUDIO
> /**
> * Internal sample count used by avcodec_encode_audio() to fabricate pts.
> diff --git a/libavcodec/pthread.c b/libavcodec/pthread.c
> index 82df03c..c2be1a4 100644
> --- a/libavcodec/pthread.c
> +++ b/libavcodec/pthread.c
> @@ -52,6 +52,7 @@
> #include "avcodec.h"
> #include "internal.h"
> #include "thread.h"
> +#include "libavutil/avassert.h"
> #include "libavutil/common.h"
>
> #if HAVE_PTHREADS
> @@ -80,9 +81,6 @@ typedef struct ThreadContext {
> int done;
> } ThreadContext;
>
> -/// Max number of frame buffers that can be allocated when using frame
> threads.
> -#define MAX_BUFFERS (32+1)
> -
> /**
> * Context used by codec threads and stored in their AVCodecContext
> thread_opaque.
> */
> @@ -122,16 +120,12 @@ typedef struct PerThreadContext {
> * Array of frames passed to ff_thread_release_buffer().
> * Frames are released after all threads referencing them are finished.
> */
> - AVFrame released_buffers[MAX_BUFFERS];
> - int num_released_buffers;
> -
> - /**
> - * Array of progress values used by ff_thread_get_buffer().
> - */
> - int progress[MAX_BUFFERS][2];
> - uint8_t progress_used[MAX_BUFFERS];
> + AVFrame *released_buffers;
> + int num_released_buffers;
> + int released_buffers_allocated;
>
> AVFrame *requested_frame; ///< AVFrame the codec passed to
> get_buffer()
> + int requested_flags; ///< flags passed to get_buffer() for
> requested_frame
> } PerThreadContext;
>
> /**
> @@ -459,8 +453,11 @@ static int update_context_from_user(AVCodecContext *dst,
> AVCodecContext *src)
> dst->flags = src->flags;
>
> dst->draw_horiz_band= src->draw_horiz_band;
> + dst->get_buffer2 = src->get_buffer2;
> +#if FF_API_GET_BUFFER
> dst->get_buffer = src->get_buffer;
> dst->release_buffer = src->release_buffer;
> +#endif
>
> dst->opaque = src->opaque;
> dst->debug = src->debug;
> @@ -492,28 +489,21 @@ static int update_context_from_user(AVCodecContext
> *dst, AVCodecContext *src)
> #undef copy_fields
> }
>
> -static void free_progress(AVFrame *f)
> -{
> - PerThreadContext *p = f->owner->thread_opaque;
> - int *progress = f->thread_opaque;
> -
> - p->progress_used[(progress - p->progress[0]) / 2] = 0;
> -}
> -
> /// Releases the buffers that this decoding thread was the last user of.
> static void release_delayed_buffers(PerThreadContext *p)
> {
> FrameThreadContext *fctx = p->parent;
> + AVFrame *f;
>
> while (p->num_released_buffers > 0) {
> - AVFrame *f;
> -
unnecessary change, I won't mind though
> pthread_mutex_lock(&fctx->buffer_mutex);
> +
> + // fix extended data in case the caller screwed it up
> + av_assert0(p->avctx->codec_type == AVMEDIA_TYPE_VIDEO);
> f = &p->released_buffers[--p->num_released_buffers];
> - free_progress(f);
> - f->thread_opaque = NULL;
> + f->extended_data = f->data;
> + av_frame_unref(f);
>
> - f->owner->release_buffer(f->owner, f);
> pthread_mutex_unlock(&fctx->buffer_mutex);
> }
> }
> @@ -567,15 +557,18 @@ static int submit_packet(PerThreadContext *p, AVPacket
> *avpkt)
> * and it calls back to the client here.
> */
>
> - if (!p->avctx->thread_safe_callbacks &&
> - p->avctx->get_buffer != avcodec_default_get_buffer) {
> + if (!p->avctx->thread_safe_callbacks && (
> +#if FF_API_GET_BUFFER
> + p->avctx->get_buffer ||
> +#endif
> + p->avctx->get_buffer2 != avcodec_default_get_buffer2)) {
> while (p->state != STATE_SETUP_FINISHED && p->state !=
> STATE_INPUT_READY) {
> pthread_mutex_lock(&p->progress_mutex);
> while (p->state == STATE_SETTING_UP)
> pthread_cond_wait(&p->progress_cond, &p->progress_mutex);
>
> if (p->state == STATE_GET_BUFFER) {
> - p->result = ff_get_buffer(p->avctx, p->requested_frame);
> + p->result = ff_get_buffer(p->avctx, p->requested_frame,
> p->requested_flags);
> p->state = STATE_SETTING_UP;
> pthread_cond_signal(&p->progress_cond);
> }
> @@ -637,7 +630,7 @@ int ff_thread_decode_frame(AVCodecContext *avctx,
> pthread_mutex_unlock(&p->progress_mutex);
> }
>
> - *picture = p->frame;
> + av_frame_move_ref(picture, &p->frame);
> *got_picture_ptr = p->got_frame;
> picture->pkt_dts = p->avpkt.dts;
>
> @@ -662,10 +655,10 @@ int ff_thread_decode_frame(AVCodecContext *avctx,
> return (p->result >= 0) ? avpkt->size : p->result;
> }
>
> -void ff_thread_report_progress(AVFrame *f, int n, int field)
> +void ff_thread_report_progress(ThreadFrame *f, int n, int field)
> {
> PerThreadContext *p;
> - int *progress = f->thread_opaque;
> + int *progress = f->progress ? (int*)f->progress->data : NULL;
the cast looks unecessary, please omit if that doesn't adds a warning.
same for all following handling of progress
> if (!progress || progress[field] >= n) return;
>
> @@ -680,10 +673,10 @@ void ff_thread_report_progress(AVFrame *f, int n, int
> field)
> pthread_mutex_unlock(&p->progress_mutex);
> }
>
> -void ff_thread_await_progress(AVFrame *f, int n, int field)
> +void ff_thread_await_progress(ThreadFrame *f, int n, int field)
> {
> PerThreadContext *p;
> - int *progress = f->thread_opaque;
> + int *progress = f->progress ? (int*)f->progress->data : NULL;
>
> if (!progress || progress[field] >= n) return;
>
> @@ -730,7 +723,7 @@ static void frame_thread_free(AVCodecContext *avctx, int
> thread_count)
> {
> FrameThreadContext *fctx = avctx->thread_opaque;
> const AVCodec *codec = avctx->codec;
> - int i;
> + int i, j;
unused variable j
> park_frame_worker_threads(fctx, thread_count);
>
> @@ -767,6 +760,7 @@ static void frame_thread_free(AVCodecContext *avctx, int
> thread_count)
> pthread_cond_destroy(&p->output_cond);
> av_buffer_unref(&p->avpkt.buf);
> av_freep(&p->buf);
> + av_freep(&p->released_buffers);
>
> if (i) {
> av_freep(&p->avctx->priv_data);
> @@ -899,34 +893,15 @@ void ff_thread_flush(AVCodecContext *avctx)
> }
> }
>
> -static int *allocate_progress(PerThreadContext *p)
> -{
> - int i;
> -
> - for (i = 0; i < MAX_BUFFERS; i++)
> - if (!p->progress_used[i]) break;
> -
> - if (i == MAX_BUFFERS) {
> - av_log(p->avctx, AV_LOG_ERROR, "allocate_progress() overflow\n");
> - return NULL;
> - }
> -
> - p->progress_used[i] = 1;
> -
> - return p->progress[i];
> -}
> -
> -int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f)
> +int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
> {
> PerThreadContext *p = avctx->thread_opaque;
> - int *progress, err;
> + int err;
>
> f->owner = avctx;
>
> - if (!(avctx->active_thread_type&FF_THREAD_FRAME)) {
> - f->thread_opaque = NULL;
> - return ff_get_buffer(avctx, f);
> - }
> + if (!(avctx->active_thread_type & FF_THREAD_FRAME))
> + return ff_get_buffer(avctx, f->f, flags);
>
> if (p->state != STATE_SETTING_UP &&
> (avctx->codec->update_thread_context ||
> !avctx->thread_safe_callbacks)) {
> @@ -934,22 +909,27 @@ int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame
> *f)
> return -1;
> }
>
> - pthread_mutex_lock(&p->parent->buffer_mutex);
> - f->thread_opaque = progress = allocate_progress(p);
> + if (avctx->internal->allocate_progress) {
> + int *progress;
> + f->progress = av_buffer_alloc(2 * sizeof(int));
> + if (!f->progress) {
> + return AVERROR(ENOMEM);
> + }
> + progress = (int*)f->progress->data;
>
> - if (!progress) {
> - pthread_mutex_unlock(&p->parent->buffer_mutex);
> - return -1;
> + progress[0] = progress[1] = -1;
> }
>
> - progress[0] =
> - progress[1] = -1;
> -
> - if (avctx->thread_safe_callbacks ||
> - avctx->get_buffer == avcodec_default_get_buffer) {
> - err = ff_get_buffer(avctx, f);
> + pthread_mutex_lock(&p->parent->buffer_mutex);
> + if (avctx->thread_safe_callbacks || (
> +#if FF_API_GET_BUFFER
> + !avctx->get_buffer &&
> +#endif
> + avctx->get_buffer2 == avcodec_default_get_buffer2)) {
> + err = ff_get_buffer(avctx, f->f, flags);
> } else {
> - p->requested_frame = f;
> + p->requested_frame = f->f;
> + p->requested_flags = flags;
> p->state = STATE_GET_BUFFER;
> pthread_mutex_lock(&p->progress_mutex);
> pthread_cond_signal(&p->progress_cond);
> @@ -965,41 +945,60 @@ int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame
> *f)
> ff_thread_finish_setup(avctx);
> }
>
> - if (err) {
> - free_progress(f);
> - f->thread_opaque = NULL;
> - }
> + if (err)
> + av_buffer_unref(&f->progress);
> +
> pthread_mutex_unlock(&p->parent->buffer_mutex);
>
> return err;
> }
>
> -void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
> +void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
> {
> PerThreadContext *p = avctx->thread_opaque;
> FrameThreadContext *fctx;
> + AVFrame *dst, *tmp;
> + int can_direct_free = !(avctx->active_thread_type & FF_THREAD_FRAME) ||
> + avctx->thread_safe_callbacks ||
> + (
> +#if FF_API_GET_BUFFER
> + !avctx->get_buffer &&
> +#endif
> + avctx->get_buffer2 ==
> avcodec_default_get_buffer2);
>
> - if (!f->data[0])
> + if (!f->f->data[0])
> return;
>
> - if (!(avctx->active_thread_type&FF_THREAD_FRAME)) {
> - avctx->release_buffer(avctx, f);
> - return;
> - }
> + if (avctx->debug & FF_DEBUG_BUFFERS)
> + av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic
> %p\n", f);
>
> - if (p->num_released_buffers >= MAX_BUFFERS) {
> - av_log(p->avctx, AV_LOG_ERROR, "too many thread_release_buffer
> calls!\n");
> + av_buffer_unref(&f->progress);
> + f->owner = NULL;
> +
> + if (can_direct_free) {
> + av_frame_unref(f->f);
> return;
> }
>
> - if(avctx->debug & FF_DEBUG_BUFFERS)
> - av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic
> %p\n", f);
> -
> fctx = p->parent;
> pthread_mutex_lock(&fctx->buffer_mutex);
> - p->released_buffers[p->num_released_buffers++] = *f;
> +
> + if (p->num_released_buffers + 1 >= INT_MAX /
> sizeof(*p->released_buffers))
> + goto fail;
> + tmp = av_fast_realloc(p->released_buffers,
> &p->released_buffers_allocated,
> + (p->num_released_buffers + 1) *
> + sizeof(*p->released_buffers));
> + if (!tmp)
> + goto fail;
> + p->released_buffers = tmp;
> +
> + dst = &p->released_buffers[p->num_released_buffers];
> + av_frame_move_ref(dst, f->f);
> +
> + p->num_released_buffers++;
> +
> +fail:
> pthread_mutex_unlock(&fctx->buffer_mutex);
> - memset(f->data, 0, sizeof(f->data));
> }
>
> /**
> diff --git a/libavcodec/thread.h b/libavcodec/thread.h
> index 99b0ce1..864e67e 100644
> --- a/libavcodec/thread.h
> +++ b/libavcodec/thread.h
> @@ -27,9 +27,19 @@
> #ifndef AVCODEC_THREAD_H
> #define AVCODEC_THREAD_H
>
> +#include "libavutil/buffer.h"
> +
> #include "config.h"
> #include "avcodec.h"
>
> +typedef struct ThreadFrame {
> + AVFrame *f;
> + AVCodecContext *owner;
> + // progress->data is an array of 2 ints holding progress for top/bottom
> + // fields
> + AVBufferRef *progress;
> +} ThreadFrame;
> +
> /**
> * Wait for decoding threads to finish and reset internal state.
> * Called by avcodec_flush_buffers().
> @@ -71,7 +81,7 @@ void ff_thread_finish_setup(AVCodecContext *avctx);
> * @param field The field being decoded, for field-picture codecs.
> * 0 for top field or frame pictures, 1 for bottom field.
> */
> -void ff_thread_report_progress(AVFrame *f, int progress, int field);
> +void ff_thread_report_progress(ThreadFrame *f, int progress, int field);
>
> /**
> * Wait for earlier decoding threads to finish reference pictures.
> @@ -85,7 +95,7 @@ void ff_thread_report_progress(AVFrame *f, int progress,
> int field);
> * @param field The field being referenced, for field-picture codecs.
> * 0 for top field or frame pictures, 1 for bottom field.
> */
> -void ff_thread_await_progress(AVFrame *f, int progress, int field);
> +void ff_thread_await_progress(ThreadFrame *f, int progress, int field);
>
> /**
> * Wrapper around get_buffer() for frame-multithreaded codecs.
> @@ -95,7 +105,7 @@ void ff_thread_await_progress(AVFrame *f, int progress,
> int field);
> * @param avctx The current context.
> * @param f The frame to write into.
> */
> -int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f);
> +int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags);
>
> /**
> * Wrapper around release_buffer() frame-for multithreaded codecs.
> @@ -108,7 +118,9 @@ int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame
> *f);
> * @param avctx The current context.
> * @param f The picture being released.
> */
> -void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f);
> +void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f);
> +
> +int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src);
>
> int ff_thread_init(AVCodecContext *s);
> void ff_thread_free(AVCodecContext *s);
> diff --git a/libavcodec/utils.c b/libavcodec/utils.c
> index 253290c..c9b6aac 100644
> --- a/libavcodec/utils.c
> +++ b/libavcodec/utils.c
> @@ -2239,6 +2239,25 @@ unsigned int avpriv_toupper4(unsigned int x)
> + (toupper((x >> 24) & 0xFF) << 24);
> }
>
> +int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
> +{
> + int ret;
> +
> + dst->owner = src->owner;
> +
> + ret = av_frame_ref(dst->f, src->f);
> + if (ret < 0)
> + return ret;
> +
> + if (src->progress &&
> + !(dst->progress = av_buffer_ref(src->progress))) {
> + ff_thread_release_buffer(dst->owner, dst);
> + return AVERROR(ENOMEM);
> + }
> +
> + return 0;
> +}
> +
> #if !HAVE_THREADS
>
> int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
otherwise ok
Janne
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
