highperfocused/ffmpeg
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lavc decoders: work with refcounted frames.

Browse Source
This commit is contained in:
Anton Khirnov
2012-11-21 21:34:46 +01:00
parent 6e7b50b427
commit 759001c534
239 changed files with 3904 additions and 4335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
libavcodec/pthread.c
View File

@ -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,14 +489,6 @@ 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)
{
@ -509,11 +498,13 @@ static void release_delayed_buffers(PerThreadContext *p)
AVFrame *f;
pthread_mutex_lock(&fctx->buffer_mutex);
f = &p->released_buffers[--p->num_released_buffers];
free_progress(f);
f->thread_opaque = NULL;
f->owner->release_buffer(f->owner, f);
// 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];
f->extended_data = f->data;
av_frame_unref(f);
pthread_mutex_unlock(&fctx->buffer_mutex);
}
}
@ -567,15 +558,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 +631,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 +656,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;
if (!progress || progress[field] >= n) return;
@ -680,10 +674,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;
@ -760,8 +754,6 @@ static void frame_thread_free(AVCodecContext *avctx, int thread_count)
for (i = 0; i < thread_count; i++) {
PerThreadContext *p = &fctx->threads[i];
avcodec_default_free_buffers(p->avctx);
pthread_mutex_destroy(&p->mutex);
pthread_mutex_destroy(&p->progress_mutex);
pthread_cond_destroy(&p->input_cond);
@ -769,6 +761,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);
@ -901,34 +894,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)) {
@ -936,22 +910,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);
@ -967,41 +946,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 (p->num_released_buffers >= MAX_BUFFERS) {
av_log(p->avctx, AV_LOG_ERROR, "too many thread_release_buffer calls!\n");
return;
}
if(avctx->debug & FF_DEBUG_BUFFERS)
if (avctx->debug & FF_DEBUG_BUFFERS)
av_log(avctx, AV_LOG_DEBUG, "thread_release_buffer called on pic %p\n", f);
av_buffer_unref(&f->progress);
f->owner = NULL;
if (can_direct_free) {
av_frame_unref(f->f);
return;
}
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));
}
/**