RepoMirrors
/
ffmpeg
mirror of https://git.ffmpeg.org/ffmpeg.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

avcodec/threadframe: Add ff_thread_(get|release)_ext_buffer() 

These will be used by the codecs that need allocated progress
and is in preparation for no longer using ThreadFrame by the codecs
that don't.

Reviewed-by: Anton Khirnov <anton@khirnov.net>
Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
This commit is contained in:
Andreas Rheinhardt 2022-02-06 07:44:10 +01:00
parent b3551b6072
commit f025b8e110
15 changed files with 118 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
libavcodec/ffv1.c
View File

@ -31,6 +31,7 @@
#include "avcodec.h" #include "avcodec.h"
#include "rangecoder.h" #include "rangecoder.h"
#include "ffv1.h" #include "ffv1.h"
#include "threadframe.h"
av_cold int ff_ffv1_common_init(AVCodecContext *avctx) av_cold int ff_ffv1_common_init(AVCodecContext *avctx)
{ {
@ -198,11 +199,11 @@ av_cold int ff_ffv1_close(AVCodecContext *avctx)
int i, j; int i, j;
if (s->picture.f) if (s->picture.f)
ff_thread_release_buffer(avctx, &s->picture); ff_thread_release_ext_buffer(avctx, &s->picture);
av_frame_free(&s->picture.f); av_frame_free(&s->picture.f);
if (s->last_picture.f) if (s->last_picture.f)
ff_thread_release_buffer(avctx, &s->last_picture); ff_thread_release_ext_buffer(avctx, &s->last_picture);
av_frame_free(&s->last_picture.f); av_frame_free(&s->last_picture.f);
for (j = 0; j < s->max_slice_count; j++) { for (j = 0; j < s->max_slice_count; j++) {

9
libavcodec/ffv1dec.c
View File

@ -842,7 +842,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
AVFrame *p; AVFrame *p;
if (f->last_picture.f) if (f->last_picture.f)
ff_thread_release_buffer(avctx, &f->last_picture); ff_thread_release_ext_buffer(avctx, &f->last_picture);
FFSWAP(ThreadFrame, f->picture, f->last_picture); FFSWAP(ThreadFrame, f->picture, f->last_picture);
f->cur = p = f->picture.f; f->cur = p = f->picture.f;
@ -874,7 +874,8 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
p->key_frame = 0; p->key_frame = 0;
} }
if ((ret = ff_thread_get_buffer(avctx, &f->picture, AV_GET_BUFFER_FLAG_REF)) < 0) ret = ff_thread_get_ext_buffer(avctx, &f->picture, AV_GET_BUFFER_FLAG_REF);
if (ret < 0)
return ret; return ret;
if (avctx->debug & FF_DEBUG_PICT_INFO) if (avctx->debug & FF_DEBUG_PICT_INFO)
@ -966,7 +967,7 @@ static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPac
ff_thread_report_progress(&f->picture, INT_MAX, 0); ff_thread_report_progress(&f->picture, INT_MAX, 0);
if (f->last_picture.f) if (f->last_picture.f)
ff_thread_release_buffer(avctx, &f->last_picture); ff_thread_release_ext_buffer(avctx, &f->last_picture);
if ((ret = av_frame_ref(data, f->picture.f)) < 0) if ((ret = av_frame_ref(data, f->picture.f)) < 0)
return ret; return ret;
@ -1037,7 +1038,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
av_assert1(fdst->max_slice_count == fsrc->max_slice_count); av_assert1(fdst->max_slice_count == fsrc->max_slice_count);
ff_thread_release_buffer(dst, &fdst->picture); ff_thread_release_ext_buffer(dst, &fdst->picture);
if (fsrc->picture.f->data[0]) { if (fsrc->picture.f->data[0]) {
if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0) if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0)
return ret; return ret;

4
libavcodec/h264_picture.c
View File

@ -40,7 +40,7 @@ void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
if (!pic->f || !pic->f->buf[0]) if (!pic->f || !pic->f->buf[0])
return; return;
ff_thread_release_buffer(h->avctx, &pic->tf); ff_thread_release_ext_buffer(h->avctx, &pic->tf);
ff_thread_release_buffer(h->avctx, &pic->tf_grain); ff_thread_release_buffer(h->avctx, &pic->tf_grain);
av_buffer_unref(&pic->hwaccel_priv_buf); av_buffer_unref(&pic->hwaccel_priv_buf);
@ -155,7 +155,7 @@ int ff_h264_replace_picture(H264Context *h, H264Picture *dst, const H264Picture
av_assert0(src->tf.f == src->f); av_assert0(src->tf.f == src->f);
dst->tf.f = dst->f; dst->tf.f = dst->f;
ff_thread_release_buffer(h->avctx, &dst->tf); ff_thread_release_ext_buffer(h->avctx, &dst->tf);
ret = ff_thread_ref_frame(&dst->tf, &src->tf); ret = ff_thread_ref_frame(&dst->tf, &src->tf);
if (ret < 0) if (ret < 0)
goto fail; goto fail;

6
libavcodec/h264_slice.c
View File

@ -191,8 +191,8 @@ static int alloc_picture(H264Context *h, H264Picture *pic)
av_assert0(!pic->f->data[0]); av_assert0(!pic->f->data[0]);
pic->tf.f = pic->f; pic->tf.f = pic->f;
ret = ff_thread_get_buffer(h->avctx, &pic->tf, pic->reference ? ret = ff_thread_get_ext_buffer(h->avctx, &pic->tf,
AV_GET_BUFFER_FLAG_REF : 0); pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
if (ret < 0) if (ret < 0)
goto fail; goto fail;
@ -1699,7 +1699,7 @@ static int h264_field_start(H264Context *h, const H264SliceContext *sl,
ff_thread_await_progress(&prev->tf, INT_MAX, 0); ff_thread_await_progress(&prev->tf, INT_MAX, 0);
if (prev->field_picture) if (prev->field_picture)
ff_thread_await_progress(&prev->tf, INT_MAX, 1); ff_thread_await_progress(&prev->tf, INT_MAX, 1);
ff_thread_release_buffer(h->avctx, &h->short_ref[0]->tf); ff_thread_release_ext_buffer(h->avctx, &h->short_ref[0]->tf);
h->short_ref[0]->tf.f = h->short_ref[0]->f; h->short_ref[0]->tf.f = h->short_ref[0]->f;
ret = ff_thread_ref_frame(&h->short_ref[0]->tf, &prev->tf); ret = ff_thread_ref_frame(&h->short_ref[0]->tf, &prev->tf);
if (ret < 0) if (ret < 0)

6
libavcodec/hevc_refs.c
View File

@ -36,7 +36,7 @@ void ff_hevc_unref_frame(HEVCContext *s, HEVCFrame *frame, int flags)
frame->flags &= ~flags; frame->flags &= ~flags;
if (!frame->flags) { if (!frame->flags) {
ff_thread_release_buffer(s->avctx, &frame->tf); ff_thread_release_ext_buffer(s->avctx, &frame->tf);
ff_thread_release_buffer(s->avctx, &frame->tf_grain); ff_thread_release_buffer(s->avctx, &frame->tf_grain);
frame->needs_fg = 0; frame->needs_fg = 0;
@ -88,8 +88,8 @@ static HEVCFrame *alloc_frame(HEVCContext *s)
if (frame->frame->buf[0]) if (frame->frame->buf[0])
continue; continue;
ret = ff_thread_get_buffer(s->avctx, &frame->tf, ret = ff_thread_get_ext_buffer(s->avctx, &frame->tf,
AV_GET_BUFFER_FLAG_REF); AV_GET_BUFFER_FLAG_REF);
if (ret < 0) if (ret < 0)
return NULL; return NULL;

12
libavcodec/mimic.c
View File

@ -112,7 +112,7 @@ static av_cold int mimic_decode_end(AVCodecContext *avctx)
for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
if (ctx->frames[i].f) if (ctx->frames[i].f)
ff_thread_release_buffer(avctx, &ctx->frames[i]); ff_thread_release_ext_buffer(avctx, &ctx->frames[i]);
av_frame_free(&ctx->frames[i].f); av_frame_free(&ctx->frames[i].f);
} }
@ -164,7 +164,7 @@ static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCod
dst->prev_index = src->next_prev_index; dst->prev_index = src->next_prev_index;
for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) { for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
ff_thread_release_buffer(avctx, &dst->frames[i]); ff_thread_release_ext_buffer(avctx, &dst->frames[i]);
if (i != src->next_cur_index && src->frames[i].f->data[0]) { if (i != src->next_cur_index && src->frames[i].f->data[0]) {
ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]); ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
if (ret < 0) if (ret < 0)
@ -395,11 +395,11 @@ static int mimic_decode_frame(AVCodecContext *avctx, void *data,
return AVERROR_INVALIDDATA; return AVERROR_INVALIDDATA;
} }
ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]); ff_thread_release_ext_buffer(avctx, &ctx->frames[ctx->cur_index]);
ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P : ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
AV_PICTURE_TYPE_I; AV_PICTURE_TYPE_I;
if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index], if ((res = ff_thread_get_ext_buffer(avctx, &ctx->frames[ctx->cur_index],
AV_GET_BUFFER_FLAG_REF)) < 0) AV_GET_BUFFER_FLAG_REF)) < 0)
return res; return res;
ctx->next_prev_index = ctx->cur_index; ctx->next_prev_index = ctx->cur_index;
@ -420,7 +420,7 @@ static int mimic_decode_frame(AVCodecContext *avctx, void *data,
ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0); ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
if (res < 0) { if (res < 0) {
if (!(avctx->active_thread_type & FF_THREAD_FRAME)) if (!(avctx->active_thread_type & FF_THREAD_FRAME))
ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]); ff_thread_release_ext_buffer(avctx, &ctx->frames[ctx->cur_index]);
return res; return res;
} }

7
libavcodec/mpegpicture.c
View File

@ -29,6 +29,7 @@
#include "motion_est.h" #include "motion_est.h"
#include "mpegpicture.h" #include "mpegpicture.h"
#include "mpegutils.h" #include "mpegutils.h"
#include "threadframe.h"
static void av_noinline free_picture_tables(Picture *pic) static void av_noinline free_picture_tables(Picture *pic)
{ {
@ -130,8 +131,8 @@ static int alloc_frame_buffer(AVCodecContext *avctx, Picture *pic,
pic->f->height = avctx->height + 2 * EDGE_WIDTH; pic->f->height = avctx->height + 2 * EDGE_WIDTH;
} }
r = ff_thread_get_buffer(avctx, &pic->tf, r = ff_thread_get_ext_buffer(avctx, &pic->tf,
pic->reference ? AV_GET_BUFFER_FLAG_REF : 0); pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
} else { } else {
pic->f->width = avctx->width; pic->f->width = avctx->width;
pic->f->height = avctx->height; pic->f->height = avctx->height;
@ -321,7 +322,7 @@ void ff_mpeg_unref_picture(AVCodecContext *avctx, Picture *pic)
if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE && if (avctx->codec_id != AV_CODEC_ID_WMV3IMAGE &&
avctx->codec_id != AV_CODEC_ID_VC1IMAGE && avctx->codec_id != AV_CODEC_ID_VC1IMAGE &&
avctx->codec_id != AV_CODEC_ID_MSS2) avctx->codec_id != AV_CODEC_ID_MSS2)
ff_thread_release_buffer(avctx, &pic->tf); ff_thread_release_ext_buffer(avctx, &pic->tf);
else if (pic->f) else if (pic->f)
av_frame_unref(pic->f); av_frame_unref(pic->f);

17
libavcodec/pngdec.c
View File

@ -721,8 +721,9 @@ static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s,
s->bpp += byte_depth; s->bpp += byte_depth;
} }
ff_thread_release_buffer(avctx, &s->picture); ff_thread_release_ext_buffer(avctx, &s->picture);
if ((ret = ff_thread_get_buffer(avctx, &s->picture, AV_GET_BUFFER_FLAG_REF)) < 0) if ((ret = ff_thread_get_ext_buffer(avctx, &s->picture,
AV_GET_BUFFER_FLAG_REF)) < 0)
return ret; return ret;
p->pict_type = AV_PICTURE_TYPE_I; p->pict_type = AV_PICTURE_TYPE_I;
@ -1560,7 +1561,7 @@ static int decode_frame_png(AVCodecContext *avctx,
goto the_end; goto the_end;
if (!(avctx->active_thread_type & FF_THREAD_FRAME)) { if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
ff_thread_release_buffer(avctx, &s->last_picture); ff_thread_release_ext_buffer(avctx, &s->last_picture);
FFSWAP(ThreadFrame, s->picture, s->last_picture); FFSWAP(ThreadFrame, s->picture, s->last_picture);
} }
@ -1624,9 +1625,9 @@ static int decode_frame_apng(AVCodecContext *avctx,
if (!(avctx->active_thread_type & FF_THREAD_FRAME)) { if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) { if (s->dispose_op == APNG_DISPOSE_OP_PREVIOUS) {
ff_thread_release_buffer(avctx, &s->picture); ff_thread_release_ext_buffer(avctx, &s->picture);
} else { } else {
ff_thread_release_buffer(avctx, &s->last_picture); ff_thread_release_ext_buffer(avctx, &s->last_picture);
FFSWAP(ThreadFrame, s->picture, s->last_picture); FFSWAP(ThreadFrame, s->picture, s->last_picture);
} }
} }
@ -1677,7 +1678,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
src_frame = psrc->dispose_op == APNG_DISPOSE_OP_PREVIOUS ? src_frame = psrc->dispose_op == APNG_DISPOSE_OP_PREVIOUS ?
&psrc->last_picture : &psrc->picture; &psrc->last_picture : &psrc->picture;
ff_thread_release_buffer(dst, &pdst->last_picture); ff_thread_release_ext_buffer(dst, &pdst->last_picture);
if (src_frame && src_frame->f->data[0]) { if (src_frame && src_frame->f->data[0]) {
ret = ff_thread_ref_frame(&pdst->last_picture, src_frame); ret = ff_thread_ref_frame(&pdst->last_picture, src_frame);
if (ret < 0) if (ret < 0)
@ -1712,9 +1713,9 @@ static av_cold int png_dec_end(AVCodecContext *avctx)
{ {
PNGDecContext *s = avctx->priv_data; PNGDecContext *s = avctx->priv_data;
ff_thread_release_buffer(avctx, &s->last_picture); ff_thread_release_ext_buffer(avctx, &s->last_picture);
av_frame_free(&s->last_picture.f); av_frame_free(&s->last_picture.f);
ff_thread_release_buffer(avctx, &s->picture); ff_thread_release_ext_buffer(avctx, &s->picture);
av_frame_free(&s->picture.f); av_frame_free(&s->picture.f);
av_freep(&s->buffer); av_freep(&s->buffer);
s->buffer_size = 0; s->buffer_size = 0;

10
libavcodec/pthread_frame.c
View File

@ -1057,6 +1057,11 @@ int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
return ret; return ret;
} }
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
{
return ff_thread_get_buffer(avctx, f, flags);
}
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f) void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
{ {
#if FF_API_THREAD_SAFE_CALLBACKS #if FF_API_THREAD_SAFE_CALLBACKS
@ -1126,3 +1131,8 @@ fail:
} }
#endif #endif
} }
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
{
ff_thread_release_buffer(avctx, f);
}

24
libavcodec/threadframe.h
View File

@ -50,4 +50,28 @@ void ff_thread_report_progress(ThreadFrame *f, int progress, int field);
*/ */
void ff_thread_await_progress(ThreadFrame *f, int progress, int field); void ff_thread_await_progress(ThreadFrame *f, int progress, int field);
/**
* Wrapper around ff_get_buffer() for frame-multithreaded codecs.
* Call this function instead of ff_get_buffer() if you might need
* to wait for progress on this frame.
* Cannot be called after the codec has called ff_thread_finish_setup().
*
* @param avctx The current context.
* @param f The frame to write into.
* @note: It is fine to call this with codecs that do not support
* frame threading.
*/
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags);
/**
* Unref a ThreadFrame.
*
* This is basically a wrapper around av_frame_unref() and should
* be called instead of it.
*
* @param avctx The current context.
* @param f The picture being released.
*/
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f);
#endif #endif

15
libavcodec/utils.c
View File

@ -875,7 +875,7 @@ int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
if (src->progress && if (src->progress &&
!(dst->progress = av_buffer_ref(src->progress))) { !(dst->progress = av_buffer_ref(src->progress))) {
ff_thread_release_buffer(dst->owner[0], dst); ff_thread_release_ext_buffer(dst->owner[0], dst);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
@ -895,12 +895,25 @@ int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
return ff_get_buffer(avctx, f->f, flags); return ff_get_buffer(avctx, f->f, flags);
} }
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
{
f->owner[0] = f->owner[1] = avctx;
return ff_get_buffer(avctx, f->f, flags);
}
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f) void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
{ {
if (f->f) if (f->f)
av_frame_unref(f->f); av_frame_unref(f->f);
} }
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
{
f->owner[0] = f->owner[1] = NULL;
if (f->f)
av_frame_unref(f->f);
}
void ff_thread_finish_setup(AVCodecContext *avctx) void ff_thread_finish_setup(AVCodecContext *avctx)
{ {
} }

23
libavcodec/vp3.c
View File

@ -333,11 +333,11 @@ static void vp3_decode_flush(AVCodecContext *avctx)
Vp3DecodeContext *s = avctx->priv_data; Vp3DecodeContext *s = avctx->priv_data;
if (s->golden_frame.f) if (s->golden_frame.f)
ff_thread_release_buffer(avctx, &s->golden_frame); ff_thread_release_ext_buffer(avctx, &s->golden_frame);
if (s->last_frame.f) if (s->last_frame.f)
ff_thread_release_buffer(avctx, &s->last_frame); ff_thread_release_ext_buffer(avctx, &s->last_frame);
if (s->current_frame.f) if (s->current_frame.f)
ff_thread_release_buffer(avctx, &s->current_frame); ff_thread_release_ext_buffer(avctx, &s->current_frame);
} }
static av_cold int vp3_decode_end(AVCodecContext *avctx) static av_cold int vp3_decode_end(AVCodecContext *avctx)
@ -2507,25 +2507,25 @@ static int update_frames(AVCodecContext *avctx)
int ret = 0; int ret = 0;
/* shuffle frames (last = current) */ /* shuffle frames (last = current) */
ff_thread_release_buffer(avctx, &s->last_frame); ff_thread_release_ext_buffer(avctx, &s->last_frame);
ret = ff_thread_ref_frame(&s->last_frame, &s->current_frame); ret = ff_thread_ref_frame(&s->last_frame, &s->current_frame);
if (ret < 0) if (ret < 0)
goto fail; goto fail;
if (s->keyframe) { if (s->keyframe) {
ff_thread_release_buffer(avctx, &s->golden_frame); ff_thread_release_ext_buffer(avctx, &s->golden_frame);
ret = ff_thread_ref_frame(&s->golden_frame, &s->current_frame); ret = ff_thread_ref_frame(&s->golden_frame, &s->current_frame);
} }
fail: fail:
ff_thread_release_buffer(avctx, &s->current_frame); ff_thread_release_ext_buffer(avctx, &s->current_frame);
return ret; return ret;
} }
#if HAVE_THREADS #if HAVE_THREADS
static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src) static int ref_frame(Vp3DecodeContext *s, ThreadFrame *dst, ThreadFrame *src)
{ {
ff_thread_release_buffer(s->avctx, dst); ff_thread_release_ext_buffer(s->avctx, dst);
if (src->f->data[0]) if (src->f->data[0])
return ff_thread_ref_frame(dst, src); return ff_thread_ref_frame(dst, src);
return 0; return 0;
@ -2675,7 +2675,8 @@ static int vp3_decode_frame(AVCodecContext *avctx,
s->current_frame.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I s->current_frame.f->pict_type = s->keyframe ? AV_PICTURE_TYPE_I
: AV_PICTURE_TYPE_P; : AV_PICTURE_TYPE_P;
s->current_frame.f->key_frame = s->keyframe; s->current_frame.f->key_frame = s->keyframe;
if ((ret = ff_thread_get_buffer(avctx, &s->current_frame, AV_GET_BUFFER_FLAG_REF)) < 0) if ((ret = ff_thread_get_ext_buffer(avctx, &s->current_frame,
AV_GET_BUFFER_FLAG_REF)) < 0)
goto error; goto error;
if (!s->edge_emu_buffer) if (!s->edge_emu_buffer)
@ -2734,10 +2735,10 @@ static int vp3_decode_frame(AVCodecContext *avctx,
"vp3: first frame not a keyframe\n"); "vp3: first frame not a keyframe\n");
s->golden_frame.f->pict_type = AV_PICTURE_TYPE_I; s->golden_frame.f->pict_type = AV_PICTURE_TYPE_I;
if ((ret = ff_thread_get_buffer(avctx, &s->golden_frame, if ((ret = ff_thread_get_ext_buffer(avctx, &s->golden_frame,
AV_GET_BUFFER_FLAG_REF)) < 0) AV_GET_BUFFER_FLAG_REF)) < 0)
goto error; goto error;
ff_thread_release_buffer(avctx, &s->last_frame); ff_thread_release_ext_buffer(avctx, &s->last_frame);
if ((ret = ff_thread_ref_frame(&s->last_frame, if ((ret = ff_thread_ref_frame(&s->last_frame,
&s->golden_frame)) < 0) &s->golden_frame)) < 0)
goto error; goto error;

8
libavcodec/vp8.c
View File

@ -72,8 +72,8 @@ static void free_buffers(VP8Context *s)
static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref) static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
{ {
int ret; int ret;
if ((ret = ff_thread_get_buffer(s->avctx, &f->tf, if ((ret = ff_thread_get_ext_buffer(s->avctx, &f->tf,
ref ? AV_GET_BUFFER_FLAG_REF : 0)) < 0) ref ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
return ret; return ret;
if (!(f->seg_map = av_buffer_allocz(s->mb_width * s->mb_height))) if (!(f->seg_map = av_buffer_allocz(s->mb_width * s->mb_height)))
goto fail; goto fail;
@ -90,7 +90,7 @@ static int vp8_alloc_frame(VP8Context *s, VP8Frame *f, int ref)
fail: fail:
av_buffer_unref(&f->seg_map); av_buffer_unref(&f->seg_map);
ff_thread_release_buffer(s->avctx, &f->tf); ff_thread_release_ext_buffer(s->avctx, &f->tf);
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
@ -99,7 +99,7 @@ static void vp8_release_frame(VP8Context *s, VP8Frame *f)
av_buffer_unref(&f->seg_map); av_buffer_unref(&f->seg_map);
av_buffer_unref(&f->hwaccel_priv_buf); av_buffer_unref(&f->hwaccel_priv_buf);
f->hwaccel_picture_private = NULL; f->hwaccel_picture_private = NULL;
ff_thread_release_buffer(s->avctx, &f->tf); ff_thread_release_ext_buffer(s->avctx, &f->tf);
} }
#if CONFIG_VP8_DECODER #if CONFIG_VP8_DECODER

18
libavcodec/vp9.c
View File

@ -93,7 +93,7 @@ static void vp9_tile_data_free(VP9TileData *td)
static void vp9_frame_unref(AVCodecContext *avctx, VP9Frame *f) static void vp9_frame_unref(AVCodecContext *avctx, VP9Frame *f)
{ {
ff_thread_release_buffer(avctx, &f->tf); ff_thread_release_ext_buffer(avctx, &f->tf);
av_buffer_unref(&f->extradata); av_buffer_unref(&f->extradata);
av_buffer_unref(&f->hwaccel_priv_buf); av_buffer_unref(&f->hwaccel_priv_buf);
f->segmentation_map = NULL; f->segmentation_map = NULL;
@ -105,7 +105,7 @@ static int vp9_frame_alloc(AVCodecContext *avctx, VP9Frame *f)
VP9Context *s = avctx->priv_data; VP9Context *s = avctx->priv_data;
int ret, sz; int ret, sz;
ret = ff_thread_get_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF); ret = ff_thread_get_ext_buffer(avctx, &f->tf, AV_GET_BUFFER_FLAG_REF);
if (ret < 0) if (ret < 0)
return ret; return ret;
@ -1237,9 +1237,9 @@ static av_cold int vp9_decode_free(AVCodecContext *avctx)
} }
av_buffer_pool_uninit(&s->frame_extradata_pool); av_buffer_pool_uninit(&s->frame_extradata_pool);
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
ff_thread_release_buffer(avctx, &s->s.refs[i]); ff_thread_release_ext_buffer(avctx, &s->s.refs[i]);
av_frame_free(&s->s.refs[i].f); av_frame_free(&s->s.refs[i].f);
ff_thread_release_buffer(avctx, &s->next_refs[i]); ff_thread_release_ext_buffer(avctx, &s->next_refs[i]);
av_frame_free(&s->next_refs[i].f); av_frame_free(&s->next_refs[i].f);
} }
@ -1571,7 +1571,7 @@ static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
((AVFrame *)frame)->pkt_dts = pkt->dts; ((AVFrame *)frame)->pkt_dts = pkt->dts;
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
if (s->next_refs[i].f->buf[0]) if (s->next_refs[i].f->buf[0])
ff_thread_release_buffer(avctx, &s->next_refs[i]); ff_thread_release_ext_buffer(avctx, &s->next_refs[i]);
if (s->s.refs[i].f->buf[0] && if (s->s.refs[i].f->buf[0] &&
(ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0) (ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.refs[i])) < 0)
return ret; return ret;
@ -1611,7 +1611,7 @@ static int vp9_decode_frame(AVCodecContext *avctx, void *frame,
// ref frame setup // ref frame setup
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
if (s->next_refs[i].f->buf[0]) if (s->next_refs[i].f->buf[0])
ff_thread_release_buffer(avctx, &s->next_refs[i]); ff_thread_release_ext_buffer(avctx, &s->next_refs[i]);
if (s->s.h.refreshrefmask & (1 << i)) { if (s->s.h.refreshrefmask & (1 << i)) {
ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf); ret = ff_thread_ref_frame(&s->next_refs[i], &s->s.frames[CUR_FRAME].tf);
} else if (s->s.refs[i].f->buf[0]) { } else if (s->s.refs[i].f->buf[0]) {
@ -1760,7 +1760,7 @@ finish:
// ref frame setup // ref frame setup
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
if (s->s.refs[i].f->buf[0]) if (s->s.refs[i].f->buf[0])
ff_thread_release_buffer(avctx, &s->s.refs[i]); ff_thread_release_ext_buffer(avctx, &s->s.refs[i]);
if (s->next_refs[i].f->buf[0] && if (s->next_refs[i].f->buf[0] &&
(ret = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0) (ret = ff_thread_ref_frame(&s->s.refs[i], &s->next_refs[i])) < 0)
return ret; return ret;
@ -1783,7 +1783,7 @@ static void vp9_decode_flush(AVCodecContext *avctx)
for (i = 0; i < 3; i++) for (i = 0; i < 3; i++)
vp9_frame_unref(avctx, &s->s.frames[i]); vp9_frame_unref(avctx, &s->s.frames[i]);
for (i = 0; i < 8; i++) for (i = 0; i < 8; i++)
ff_thread_release_buffer(avctx, &s->s.refs[i]); ff_thread_release_ext_buffer(avctx, &s->s.refs[i]);
} }
static av_cold int vp9_decode_init(AVCodecContext *avctx) static av_cold int vp9_decode_init(AVCodecContext *avctx)
@ -1832,7 +1832,7 @@ static int vp9_decode_update_thread_context(AVCodecContext *dst, const AVCodecCo
} }
for (i = 0; i < 8; i++) { for (i = 0; i < 8; i++) {
if (s->s.refs[i].f->buf[0]) if (s->s.refs[i].f->buf[0])
ff_thread_release_buffer(dst, &s->s.refs[i]); ff_thread_release_ext_buffer(dst, &s->s.refs[i]);
if (ssrc->next_refs[i].f->buf[0]) { if (ssrc->next_refs[i].f->buf[0]) {
if ((ret = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0) if ((ret = ff_thread_ref_frame(&s->s.refs[i], &ssrc->next_refs[i])) < 0)
return ret; return ret;

18
libavcodec/wavpack.c
View File

@ -1019,7 +1019,7 @@ static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
if (dst == src) if (dst == src)
return 0; return 0;
ff_thread_release_buffer(dst, &fdst->curr_frame); ff_thread_release_ext_buffer(dst, &fdst->curr_frame);
if (fsrc->curr_frame.f->data[0]) { if (fsrc->curr_frame.f->data[0]) {
if ((ret = ff_thread_ref_frame(&fdst->curr_frame, &fsrc->curr_frame)) < 0) if ((ret = ff_thread_ref_frame(&fdst->curr_frame, &fsrc->curr_frame)) < 0)
return ret; return ret;
@ -1066,10 +1066,10 @@ static av_cold int wavpack_decode_end(AVCodecContext *avctx)
av_freep(&s->fdec[i]); av_freep(&s->fdec[i]);
s->fdec_num = 0; s->fdec_num = 0;
ff_thread_release_buffer(avctx, &s->curr_frame); ff_thread_release_ext_buffer(avctx, &s->curr_frame);
av_frame_free(&s->curr_frame.f); av_frame_free(&s->curr_frame.f);
ff_thread_release_buffer(avctx, &s->prev_frame); ff_thread_release_ext_buffer(avctx, &s->prev_frame);
av_frame_free(&s->prev_frame.f); av_frame_free(&s->prev_frame.f);
av_buffer_unref(&s->dsd_ref); av_buffer_unref(&s->dsd_ref);
@ -1539,7 +1539,7 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
av_log(avctx, AV_LOG_ERROR, "Error reinitializing the DSD context\n"); av_log(avctx, AV_LOG_ERROR, "Error reinitializing the DSD context\n");
return ret; return ret;
} }
ff_thread_release_buffer(avctx, &wc->curr_frame); ff_thread_release_ext_buffer(avctx, &wc->curr_frame);
} }
avctx->channels = new_channels; avctx->channels = new_channels;
avctx->channel_layout = new_chmask; avctx->channel_layout = new_chmask;
@ -1547,12 +1547,14 @@ static int wavpack_decode_block(AVCodecContext *avctx, int block_no,
avctx->sample_fmt = sample_fmt; avctx->sample_fmt = sample_fmt;
avctx->bits_per_raw_sample = orig_bpp; avctx->bits_per_raw_sample = orig_bpp;
ff_thread_release_buffer(avctx, &wc->prev_frame); ff_thread_release_ext_buffer(avctx, &wc->prev_frame);
FFSWAP(ThreadFrame, wc->curr_frame, wc->prev_frame); FFSWAP(ThreadFrame, wc->curr_frame, wc->prev_frame);
/* get output buffer */ /* get output buffer */
wc->curr_frame.f->nb_samples = s->samples; wc->curr_frame.f->nb_samples = s->samples;
if ((ret = ff_thread_get_buffer(avctx, &wc->curr_frame, AV_GET_BUFFER_FLAG_REF)) < 0) ret = ff_thread_get_ext_buffer(avctx, &wc->curr_frame,
AV_GET_BUFFER_FLAG_REF);
if (ret < 0)
return ret; return ret;
wc->frame = wc->curr_frame.f; wc->frame = wc->curr_frame.f;
@ -1676,7 +1678,7 @@ static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
} }
ff_thread_await_progress(&s->prev_frame, INT_MAX, 0); ff_thread_await_progress(&s->prev_frame, INT_MAX, 0);
ff_thread_release_buffer(avctx, &s->prev_frame); ff_thread_release_ext_buffer(avctx, &s->prev_frame);
if (s->modulation == MODULATION_DSD) if (s->modulation == MODULATION_DSD)
avctx->execute2(avctx, dsd_channel, s->frame, NULL, avctx->channels); avctx->execute2(avctx, dsd_channel, s->frame, NULL, avctx->channels);
@ -1693,7 +1695,7 @@ static int wavpack_decode_frame(AVCodecContext *avctx, void *data,
error: error:
if (s->frame) { if (s->frame) {
ff_thread_await_progress(&s->prev_frame, INT_MAX, 0); ff_thread_await_progress(&s->prev_frame, INT_MAX, 0);
ff_thread_release_buffer(avctx, &s->prev_frame); ff_thread_release_ext_buffer(avctx, &s->prev_frame);
ff_thread_report_progress(&s->curr_frame, INT_MAX, 0); ff_thread_report_progress(&s->curr_frame, INT_MAX, 0);
} }