297 lines
8.1 KiB
C
297 lines
8.1 KiB
C
/*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* Copyright (c) 2015 Matthieu Bouron <matthieu.bouron stupeflix.com>
|
|
*
|
|
* 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 "framepool.h"
|
|
#include "libavutil/avassert.h"
|
|
#include "libavutil/avutil.h"
|
|
#include "libavutil/buffer.h"
|
|
#include "libavutil/frame.h"
|
|
#include "libavutil/imgutils.h"
|
|
#include "libavutil/mem.h"
|
|
#include "libavutil/pixfmt.h"
|
|
|
|
struct FFFramePool {
|
|
|
|
enum AVMediaType type;
|
|
|
|
/* video */
|
|
int width;
|
|
int height;
|
|
|
|
/* audio */
|
|
int planes;
|
|
int channels;
|
|
int nb_samples;
|
|
|
|
/* common */
|
|
int format;
|
|
int align;
|
|
int linesize[4];
|
|
AVBufferPool *pools[4];
|
|
|
|
};
|
|
|
|
FFFramePool *ff_frame_pool_video_init(AVBufferRef* (*alloc)(int size),
|
|
int width,
|
|
int height,
|
|
enum AVPixelFormat format,
|
|
int align)
|
|
{
|
|
int i, ret;
|
|
FFFramePool *pool;
|
|
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(format);
|
|
|
|
if (!desc)
|
|
return NULL;
|
|
|
|
pool = av_mallocz(sizeof(FFFramePool));
|
|
if (!pool)
|
|
return NULL;
|
|
|
|
pool->type = AVMEDIA_TYPE_VIDEO;
|
|
pool->width = width;
|
|
pool->height = height;
|
|
pool->format = format;
|
|
pool->align = align;
|
|
|
|
if ((ret = av_image_check_size2(width, height, INT64_MAX, format, 0, NULL)) < 0) {
|
|
goto fail;
|
|
}
|
|
|
|
if (!pool->linesize[0]) {
|
|
for(i = 1; i <= align; i += i) {
|
|
ret = av_image_fill_linesizes(pool->linesize, pool->format,
|
|
FFALIGN(pool->width, i));
|
|
if (ret < 0) {
|
|
goto fail;
|
|
}
|
|
if (!(pool->linesize[0] & (pool->align - 1)))
|
|
break;
|
|
}
|
|
|
|
for (i = 0; i < 4 && pool->linesize[i]; i++) {
|
|
pool->linesize[i] = FFALIGN(pool->linesize[i], pool->align);
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < 4 && pool->linesize[i]; i++) {
|
|
int h = FFALIGN(pool->height, 32);
|
|
if (i == 1 || i == 2)
|
|
h = AV_CEIL_RSHIFT(h, desc->log2_chroma_h);
|
|
|
|
pool->pools[i] = av_buffer_pool_init(pool->linesize[i] * h + 16 + 16 - 1,
|
|
alloc);
|
|
if (!pool->pools[i])
|
|
goto fail;
|
|
}
|
|
|
|
if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
|
|
desc->flags & FF_PSEUDOPAL) {
|
|
pool->pools[1] = av_buffer_pool_init(AVPALETTE_SIZE, alloc);
|
|
if (!pool->pools[1])
|
|
goto fail;
|
|
}
|
|
|
|
return pool;
|
|
|
|
fail:
|
|
ff_frame_pool_uninit(&pool);
|
|
return NULL;
|
|
}
|
|
|
|
FFFramePool *ff_frame_pool_audio_init(AVBufferRef* (*alloc)(int size),
|
|
int channels,
|
|
int nb_samples,
|
|
enum AVSampleFormat format,
|
|
int align)
|
|
{
|
|
int ret, planar;
|
|
FFFramePool *pool;
|
|
|
|
pool = av_mallocz(sizeof(FFFramePool));
|
|
if (!pool)
|
|
return NULL;
|
|
|
|
planar = av_sample_fmt_is_planar(format);
|
|
|
|
pool->type = AVMEDIA_TYPE_AUDIO;
|
|
pool->planes = planar ? channels : 1;
|
|
pool->channels = channels;
|
|
pool->nb_samples = nb_samples;
|
|
pool->format = format;
|
|
pool->align = align;
|
|
|
|
ret = av_samples_get_buffer_size(&pool->linesize[0], channels,
|
|
nb_samples, format, 0);
|
|
if (ret < 0)
|
|
goto fail;
|
|
|
|
pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
|
|
if (!pool->pools[0])
|
|
goto fail;
|
|
|
|
return pool;
|
|
|
|
fail:
|
|
ff_frame_pool_uninit(&pool);
|
|
return NULL;
|
|
}
|
|
|
|
int ff_frame_pool_get_video_config(FFFramePool *pool,
|
|
int *width,
|
|
int *height,
|
|
enum AVPixelFormat *format,
|
|
int *align)
|
|
{
|
|
if (!pool)
|
|
return AVERROR(EINVAL);
|
|
|
|
av_assert0(pool->type == AVMEDIA_TYPE_VIDEO);
|
|
|
|
*width = pool->width;
|
|
*height = pool->height;
|
|
*format = pool->format;
|
|
*align = pool->align;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int ff_frame_pool_get_audio_config(FFFramePool *pool,
|
|
int *channels,
|
|
int *nb_samples,
|
|
enum AVSampleFormat *format,
|
|
int *align)
|
|
{
|
|
if (!pool)
|
|
return AVERROR(EINVAL);
|
|
|
|
av_assert0(pool->type == AVMEDIA_TYPE_AUDIO);
|
|
|
|
*channels = pool->channels;
|
|
*nb_samples = pool->nb_samples;
|
|
*format = pool->format;
|
|
*align = pool->align;
|
|
|
|
return 0;
|
|
}
|
|
|
|
AVFrame *ff_frame_pool_get(FFFramePool *pool)
|
|
{
|
|
int i;
|
|
AVFrame *frame;
|
|
const AVPixFmtDescriptor *desc;
|
|
|
|
frame = av_frame_alloc();
|
|
if (!frame) {
|
|
return NULL;
|
|
}
|
|
|
|
switch(pool->type) {
|
|
case AVMEDIA_TYPE_VIDEO:
|
|
desc = av_pix_fmt_desc_get(pool->format);
|
|
if (!desc) {
|
|
goto fail;
|
|
}
|
|
|
|
frame->width = pool->width;
|
|
frame->height = pool->height;
|
|
frame->format = pool->format;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
frame->linesize[i] = pool->linesize[i];
|
|
if (!pool->pools[i])
|
|
break;
|
|
|
|
frame->buf[i] = av_buffer_pool_get(pool->pools[i]);
|
|
if (!frame->buf[i])
|
|
goto fail;
|
|
|
|
frame->data[i] = frame->buf[i]->data;
|
|
}
|
|
|
|
if (desc->flags & AV_PIX_FMT_FLAG_PAL ||
|
|
desc->flags & FF_PSEUDOPAL) {
|
|
enum AVPixelFormat format =
|
|
pool->format == AV_PIX_FMT_PAL8 ? AV_PIX_FMT_BGR8 : pool->format;
|
|
|
|
av_assert0(frame->data[1] != NULL);
|
|
if (avpriv_set_systematic_pal2((uint32_t *)frame->data[1], format) < 0)
|
|
goto fail;
|
|
}
|
|
|
|
frame->extended_data = frame->data;
|
|
break;
|
|
case AVMEDIA_TYPE_AUDIO:
|
|
frame->nb_samples = pool->nb_samples;
|
|
frame->channels = pool->channels;
|
|
frame->format = pool->format;
|
|
frame->linesize[0] = pool->linesize[0];
|
|
|
|
if (pool->planes > AV_NUM_DATA_POINTERS) {
|
|
frame->extended_data = av_mallocz_array(pool->planes,
|
|
sizeof(*frame->extended_data));
|
|
frame->nb_extended_buf = pool->planes - AV_NUM_DATA_POINTERS;
|
|
frame->extended_buf = av_mallocz_array(frame->nb_extended_buf,
|
|
sizeof(*frame->extended_buf));
|
|
if (!frame->extended_data || !frame->extended_buf)
|
|
goto fail;
|
|
} else {
|
|
frame->extended_data = frame->data;
|
|
av_assert0(frame->nb_extended_buf == 0);
|
|
}
|
|
|
|
for (i = 0; i < FFMIN(pool->planes, AV_NUM_DATA_POINTERS); i++) {
|
|
frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
|
|
if (!frame->buf[i])
|
|
goto fail;
|
|
frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
|
|
}
|
|
for (i = 0; i < frame->nb_extended_buf; i++) {
|
|
frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
|
|
if (!frame->extended_buf[i])
|
|
goto fail;
|
|
frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
|
|
}
|
|
|
|
break;
|
|
default:
|
|
av_assert0(0);
|
|
}
|
|
|
|
return frame;
|
|
fail:
|
|
av_frame_free(&frame);
|
|
return NULL;
|
|
}
|
|
|
|
void ff_frame_pool_uninit(FFFramePool **pool)
|
|
{
|
|
int i;
|
|
|
|
if (!pool || !*pool)
|
|
return;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
av_buffer_pool_uninit(&(*pool)->pools[i]);
|
|
}
|
|
|
|
av_freep(pool);
|
|
}
|