virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2025-08-10 06:10:52 +02:00
Code Issues Releases Activity

lavfi: add FFFrameQueue API.

Browse Source
This commit is contained in:
Nicolas George
2015-12-03 20:05:14 +01:00
parent 14090b7050
commit 62b11db0a0
3 changed files with 297 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
libavfilter/Makefile
View File

@@ -18,6 +18,7 @@ OBJS = allfilters.o \
fifo.o \ fifo.o \
formats.o \ formats.o \
framepool.o \ framepool.o \
framequeue.o \
graphdump.o \ graphdump.o \
graphparser.o \ graphparser.o \
opencl_allkernels.o \ opencl_allkernels.o \

123
libavfilter/framequeue.c Normal file
View File

@@ -0,0 +1,123 @@
/*
* Generic frame queue
* Copyright (c) 2016 Nicolas George
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "libavutil/avassert.h"
#include "framequeue.h"
static inline FFFrameBucket *bucket(FFFrameQueue *fq, size_t idx)
{
return &fq->queue[(fq->tail + idx) & (fq->allocated - 1)];
}
void ff_framequeue_global_init(FFFrameQueueGlobal *fqg)
{
}
static void check_consistency(FFFrameQueue *fq)
{
#if ASSERT_LEVEL >= 2
uint64_t nb_samples = 0;
size_t i;
av_assert0(fq->queued == fq->total_frames_head - fq->total_frames_tail);
for (i = 0; i < fq->queued; i++)
nb_samples += bucket(fq, i)->frame->nb_samples;
av_assert0(nb_samples == fq->total_samples_head - fq->total_samples_tail);
#endif
}
void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg)
{
fq->queue = &fq->first_bucket;
fq->allocated = 1;
}
void ff_framequeue_free(FFFrameQueue *fq)
{
while (fq->queued) {
AVFrame *frame = ff_framequeue_take(fq);
av_frame_free(&frame);
}
if (fq->queue != &fq->first_bucket)
av_freep(&fq->queue);
}
int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame)
{
FFFrameBucket *b;
check_consistency(fq);
if (fq->queued == fq->allocated) {
if (fq->allocated == 1) {
size_t na = 8;
FFFrameBucket *nq = av_realloc_array(NULL, na, sizeof(*nq));
if (!nq)
return AVERROR(ENOMEM);
nq[0] = fq->queue[0];
fq->queue = nq;
fq->allocated = na;
} else {
size_t na = fq->allocated << 1;
FFFrameBucket *nq = av_realloc_array(fq->queue, na, sizeof(*nq));
if (!nq)
return AVERROR(ENOMEM);
if (fq->tail + fq->queued > fq->allocated)
memmove(nq + fq->allocated, nq,
(fq->tail + fq->queued - fq->allocated) * sizeof(*nq));
fq->queue = nq;
fq->allocated = na;
}
}
b = bucket(fq, fq->queued);
b->frame = frame;
fq->queued++;
fq->total_frames_head++;
fq->total_samples_head += frame->nb_samples;
check_consistency(fq);
return 0;
}
AVFrame *ff_framequeue_take(FFFrameQueue *fq)
{
FFFrameBucket *b;
check_consistency(fq);
av_assert1(fq->queued);
b = bucket(fq, 0);
fq->queued--;
fq->tail++;
fq->tail &= fq->allocated - 1;
fq->total_frames_tail++;
fq->total_samples_tail += b->frame->nb_samples;
check_consistency(fq);
return b->frame;
}
AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx)
{
FFFrameBucket *b;
check_consistency(fq);
av_assert1(idx < fq->queued);
b = bucket(fq, idx);
check_consistency(fq);
return b->frame;
}

173
libavfilter/framequeue.h Normal file
View File

@@ -0,0 +1,173 @@
/*
* Generic frame queue
* Copyright (c) 2016 Nicolas George
*
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* FFmpeg is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef AVFILTER_FRAMEQUEUE_H
#define AVFILTER_FRAMEQUEUE_H
/**
* FFFrameQueue: simple AVFrame queue API
*
* Note: this API is not thread-safe. Concurrent access to the same queue
* must be protected by a mutex or any synchronization mechanism.
*/
#include "libavutil/frame.h"
typedef struct FFFrameBucket {
AVFrame *frame;
} FFFrameBucket;
/**
* Structure to hold global options and statistics for frame queues.
*
* This structure is intended to allow implementing global control of the
* frame queues, including memory consumption caps.
*
* It is currently empty.
*/
typedef struct FFFrameQueueGlobal {
} FFFrameQueueGlobal;
/**
* Queue of AVFrame pointers.
*/
typedef struct FFFrameQueue {
/**
* Array of allocated buckets, used as a circular buffer.
*/
FFFrameBucket *queue;
/**
* Size of the array of buckets.
*/
size_t allocated;
/**
* Tail of the queue.
* It is the index in the array of the next frame to take.
*/
size_t tail;
/**
* Number of currently queued frames.
*/
size_t queued;
/**
* Pre-allocated bucket for queues of size 1.
*/
FFFrameBucket first_bucket;
/**
* Total number of frames entered in the queue.
*/
uint64_t total_frames_head;
/**
* Total number of frames dequeued from the queue.
* queued = total_frames_head - total_frames_tail
*/
uint64_t total_frames_tail;
/**
* Total number of samples entered in the queue.
*/
uint64_t total_samples_head;
/**
* Total number of samples dequeued from the queue.
* queued_samples = total_samples_head - total_samples_tail
*/
uint64_t total_samples_tail;
} FFFrameQueue;
/**
* Init a global structure.
*/
void ff_framequeue_global_init(FFFrameQueueGlobal *fqg);
/**
* Init a frame queue and attach it to a global structure.
*/
void ff_framequeue_init(FFFrameQueue *fq, FFFrameQueueGlobal *fqg);
/**
* Free the queue and all queued frames.
*/
void ff_framequeue_free(FFFrameQueue *fq);
/**
* Add a frame.
* @return >=0 or an AVERROR code.
*/
int ff_framequeue_add(FFFrameQueue *fq, AVFrame *frame);
/**
* Take the first frame in the queue.
* Must not be used with empty queues.
*/
AVFrame *ff_framequeue_take(FFFrameQueue *fq);
/**
* Access a frame in the queue, without removing it.
* The first frame is numbered 0; the designated frame must exist.
*/
AVFrame *ff_framequeue_peek(FFFrameQueue *fq, size_t idx);
/**
* Get the number of queued frames.
*/
static inline size_t ff_framequeue_queued_frames(const FFFrameQueue *fq)
{
return fq->queued;
}
/**
* Get the number of queued samples.
*/
static inline uint64_t ff_framequeue_queued_samples(const FFFrameQueue *fq)
{
return fq->total_samples_head - fq->total_samples_tail;
}
/**
* Update the statistics after a frame accessed using ff_framequeue_peek()
* was modified.
* Currently used only as a marker.
*/
static inline void ff_framequeue_update_peeked(FFFrameQueue *fq, size_t idx)
{
}
/**
* Update the sample count in the queue.
*
* This function must be used when the first frame was accessed using
* ff_framequeue_peek() and samples were removed from it.
*/
static inline void ff_framequeue_skip_samples(FFFrameQueue *fq, size_t n)
{
fq->total_samples_tail += n;
}
#endif /* AVFILTER_FRAMEQUEUE_H */