mpv/video/vaapi.c

551 lines
16 KiB
C

/*
* This file is part of mpv.
*
* mpv is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* mpv 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with mpv. If not, see <http://www.gnu.org/licenses/>.
*/
#include <assert.h>
#include "vaapi.h"
#include "common/common.h"
#include "common/msg.h"
#include "mp_image.h"
#include "img_format.h"
#include "mp_image_pool.h"
bool check_va_status(struct mp_log *log, VAStatus status, const char *msg)
{
if (status != VA_STATUS_SUCCESS) {
mp_err(log, "%s: %s\n", msg, vaErrorStr(status));
return false;
}
return true;
}
int va_get_colorspace_flag(enum mp_csp csp)
{
#if USE_VAAPI_COLORSPACE
switch (csp) {
case MP_CSP_BT_601: return VA_SRC_BT601;
case MP_CSP_BT_709: return VA_SRC_BT709;
case MP_CSP_SMPTE_240M: return VA_SRC_SMPTE_240;
}
#endif
return 0;
}
struct fmtentry {
uint32_t va;
enum mp_imgfmt mp;
};
static const struct fmtentry va_to_imgfmt[] = {
{VA_FOURCC_YV12, IMGFMT_420P},
{VA_FOURCC_I420, IMGFMT_420P},
{VA_FOURCC_IYUV, IMGFMT_420P},
{VA_FOURCC_NV12, IMGFMT_NV12},
{VA_FOURCC_UYVY, IMGFMT_UYVY},
{VA_FOURCC_YUY2, IMGFMT_YUYV},
// Note: not sure about endian issues (the mp formats are byte-addressed)
{VA_FOURCC_RGBA, IMGFMT_RGBA},
{VA_FOURCC_RGBX, IMGFMT_RGBA},
{VA_FOURCC_BGRA, IMGFMT_BGRA},
{VA_FOURCC_BGRX, IMGFMT_BGRA},
{0 , IMGFMT_NONE}
};
enum mp_imgfmt va_fourcc_to_imgfmt(uint32_t fourcc)
{
for (const struct fmtentry *entry = va_to_imgfmt; entry->va; ++entry) {
if (entry->va == fourcc)
return entry->mp;
}
return IMGFMT_NONE;
}
uint32_t va_fourcc_from_imgfmt(int imgfmt)
{
for (const struct fmtentry *entry = va_to_imgfmt; entry->va; ++entry) {
if (entry->mp == imgfmt)
return entry->va;
}
return 0;
}
struct va_image_formats {
VAImageFormat *entries;
int num;
};
static void va_get_formats(struct mp_vaapi_ctx *ctx)
{
int num = vaMaxNumImageFormats(ctx->display);
VAImageFormat entries[num];
VAStatus status = vaQueryImageFormats(ctx->display, entries, &num);
if (!CHECK_VA_STATUS(ctx, "vaQueryImageFormats()"))
return;
struct va_image_formats *formats = talloc_ptrtype(ctx, formats);
formats->entries = talloc_array(formats, VAImageFormat, num);
formats->num = num;
MP_VERBOSE(ctx, "%d image formats available:\n", num);
for (int i = 0; i < num; i++) {
formats->entries[i] = entries[i];
MP_VERBOSE(ctx, " %s\n", VA_STR_FOURCC(entries[i].fourcc));
}
ctx->image_formats = formats;
}
struct mp_vaapi_ctx *va_initialize(VADisplay *display, struct mp_log *plog)
{
struct mp_log *log = mp_log_new(NULL, plog, "/vaapi");
int major_version, minor_version;
int status = vaInitialize(display, &major_version, &minor_version);
if (!check_va_status(log, status, "vaInitialize()"))
goto error;
mp_verbose(log, "VA API version %d.%d\n", major_version, minor_version);
struct mp_vaapi_ctx *res = talloc_ptrtype(NULL, res);
*res = (struct mp_vaapi_ctx) {
.log = talloc_steal(res, log),
.display = display,
};
va_get_formats(res);
if (!res->image_formats)
goto error;
return res;
error:
if (res && res->display)
vaTerminate(res->display);
talloc_free(log);
talloc_free(res);
return NULL;
}
// Undo va_initialize, and close the VADisplay.
void va_destroy(struct mp_vaapi_ctx *ctx)
{
if (ctx) {
if (ctx->display)
vaTerminate(ctx->display);
talloc_free(ctx);
}
}
VAImageFormat *va_image_format_from_imgfmt(const struct va_image_formats *formats,
int imgfmt)
{
const int fourcc = va_fourcc_from_imgfmt(imgfmt);
if (!formats || !formats->num || !fourcc)
return NULL;
for (int i = 0; i < formats->num; i++) {
if (formats->entries[i].fourcc == fourcc)
return &formats->entries[i];
}
return NULL;
}
static void va_surface_destroy(struct va_surface *surface);
struct va_surface_pool {
struct mp_log *log;
struct mp_vaapi_ctx *ctx;
VADisplay display;
int rt_format;
int num_surfaces, lru_counter;
struct va_surface **surfaces;
};
typedef struct va_surface_priv {
struct mp_vaapi_ctx *ctx;
VADisplay display;
VAImage image; // used for software decoding case
bool is_derived; // is image derived by vaDeriveImage()?
bool is_used; // referenced
bool is_dead; // used, but deallocate VA objects as soon as possible
int order; // for LRU allocation
} va_surface_priv_t;
struct va_surface_pool * va_surface_pool_alloc(struct mp_vaapi_ctx *ctx, int rt_format)
{
struct va_surface_pool *pool = talloc_ptrtype(NULL, pool);
*pool = (struct va_surface_pool) {
.ctx = ctx,
.log = ctx->log,
.display = ctx->display,
.rt_format = rt_format
};
return pool;
}
void va_surface_pool_release(struct va_surface_pool *pool)
{
if (!pool)
return;
va_surface_pool_clear(pool);
talloc_free(pool);
}
void va_surface_pool_releasep(struct va_surface_pool **pool) {
if (!pool)
return;
va_surface_pool_release(*pool);
*pool = NULL;
}
void va_surface_pool_clear(struct va_surface_pool *pool)
{
for (int i=0; i<pool->num_surfaces; ++i) {
struct va_surface *s = pool->surfaces[i];
if (s->p->is_used)
s->p->is_dead = true;
else
va_surface_destroy(s);
}
talloc_free(pool->surfaces);
pool->num_surfaces = 0;
}
void va_surface_destroy(struct va_surface *surface)
{
if (!surface)
return;
if (surface->id != VA_INVALID_ID) {
va_surface_priv_t *p = surface->p;
assert(!p->is_used);
if (p->image.image_id != VA_INVALID_ID)
vaDestroyImage(p->display, p->image.image_id);
vaDestroySurfaces(p->display, &surface->id, 1);
}
talloc_free(surface);
}
void va_surface_release(struct va_surface *surface)
{
if (!surface)
return;
surface->p->is_used = false;
if (surface->p->is_dead)
va_surface_destroy(surface);
}
void va_surface_releasep(struct va_surface **surface)
{
if (!surface)
return;
va_surface_release(*surface);
*surface = NULL;
}
static struct va_surface *va_surface_alloc(struct va_surface_pool *pool,
int w, int h)
{
VASurfaceID id = VA_INVALID_ID;
VAStatus status;
status = vaCreateSurfaces(pool->display, w, h, pool->rt_format, 1, &id);
if (!CHECK_VA_STATUS(pool, "vaCreateSurfaces()"))
return NULL;
struct va_surface *surface = talloc_ptrtype(NULL, surface);
if (!surface)
return NULL;
MP_TARRAY_APPEND(NULL, pool->surfaces, pool->num_surfaces, surface);
surface->id = id;
surface->w = w;
surface->h = h;
surface->rt_format = pool->rt_format;
surface->p = talloc_zero(surface, va_surface_priv_t);
surface->p->ctx = pool->ctx;
surface->p->display = pool->display;
surface->p->image.image_id = surface->p->image.buf = VA_INVALID_ID;
return surface;
}
struct mp_image *va_surface_pool_get_wrapped(struct va_surface_pool *pool,
int imgfmt, int w, int h)
{
return va_surface_wrap(va_surface_pool_get_by_imgfmt(pool, imgfmt, w, h));
}
int va_surface_pool_rt_format(const struct va_surface_pool *pool)
{
return pool->rt_format;
}
bool va_surface_pool_reserve(struct va_surface_pool *pool, int count,
int w, int h)
{
for (int i=0; i<pool->num_surfaces && count > 0; ++i) {
const struct va_surface *s = pool->surfaces[i];
if (s->w == w && s->h == h && !s->p->is_used)
--count;
}
while (count > 0) {
if (!va_surface_alloc(pool, w, h))
break;
--count;
}
return !count;
}
struct va_surface *va_surface_pool_get(struct va_surface_pool *pool,
int w, int h)
{
struct va_surface *best = NULL;
for (int i=0; i<pool->num_surfaces; ++i) {
struct va_surface *s = pool->surfaces[i];
if (!s->p->is_used && s->w == w && s->h == h) {
if (!best || best->p->order > s->p->order)
best = s;
}
}
if (!best)
best = va_surface_alloc(pool, w, h);
if (best) {
best->p->is_used = true;
best->p->order = ++pool->lru_counter;
}
return best;
}
static void va_surface_image_destroy(struct va_surface *surface)
{
if (!surface || surface->p->image.image_id == VA_INVALID_ID)
return;
va_surface_priv_t *p = surface->p;
vaDestroyImage(p->display, p->image.image_id);
p->image.image_id = VA_INVALID_ID;
p->is_derived = false;
}
static VAImage *va_surface_image_alloc(struct va_surface *surface,
VAImageFormat *format)
{
if (!format || !surface)
return NULL;
va_surface_priv_t *p = surface->p;
if (p->image.image_id != VA_INVALID_ID &&
p->image.format.fourcc == format->fourcc)
return &p->image;
va_surface_image_destroy(surface);
VAStatus status = vaDeriveImage(p->display, surface->id, &p->image);
if (status == VA_STATUS_SUCCESS) {
/* vaDeriveImage() is supported, check format */
if (p->image.format.fourcc == format->fourcc &&
p->image.width == surface->w && p->image.height == surface->h) {
p->is_derived = true;
MP_VERBOSE(p->ctx, "Using vaDeriveImage()\n");
} else {
vaDestroyImage(p->display, p->image.image_id);
status = VA_STATUS_ERROR_OPERATION_FAILED;
}
}
if (status != VA_STATUS_SUCCESS) {
p->image.image_id = VA_INVALID_ID;
status = vaCreateImage(p->display, format, surface->w, surface->h,
&p->image);
if (!CHECK_VA_STATUS(p->ctx, "vaCreateImage()")) {
p->image.image_id = VA_INVALID_ID;
return NULL;
}
}
return &surface->p->image;
}
struct va_surface *va_surface_pool_get_by_imgfmt(struct va_surface_pool *pool,
int imgfmt, int w, int h)
{
if (imgfmt == IMGFMT_VAAPI)
return va_surface_pool_get(pool, w, h);
VAImageFormat *format =
va_image_format_from_imgfmt(pool->ctx->image_formats, imgfmt);
if (!format)
return NULL;
// WTF: no mapping from VAImageFormat -> VA_RT_FORMAT_
struct va_surface *surface = va_surface_pool_get(pool, w, h);
if (!surface)
return NULL;
if (va_surface_image_alloc(surface, format))
return surface;
va_surface_release(surface);
return NULL;
}
static void free_va_surface(void *arg)
{
va_surface_release((struct va_surface*)arg);
}
struct mp_image *va_surface_wrap(struct va_surface *surface)
{
if (!surface)
return NULL;
struct mp_image img = {0};
mp_image_setfmt(&img, IMGFMT_VAAPI);
mp_image_set_size(&img, surface->w, surface->h);
img.planes[0] = (uint8_t*)surface;
img.planes[3] = (uint8_t*)(uintptr_t)surface->id;
return mp_image_new_custom_ref(&img, surface, free_va_surface);
}
VASurfaceID va_surface_id_in_mp_image(const struct mp_image *mpi)
{
return mpi && mpi->imgfmt == IMGFMT_VAAPI ?
(VASurfaceID)(uintptr_t)mpi->planes[3] : VA_INVALID_ID;
}
struct va_surface *va_surface_in_mp_image(struct mp_image *mpi)
{
return mpi && mpi->imgfmt == IMGFMT_VAAPI ?
(struct va_surface*)mpi->planes[0] : NULL;
}
VASurfaceID va_surface_id(const struct va_surface *surface)
{
return surface ? surface->id : VA_INVALID_ID;
}
bool va_image_map(struct mp_vaapi_ctx *ctx, VAImage *image, struct mp_image *mpi)
{
int imgfmt = va_fourcc_to_imgfmt(image->format.fourcc);
if (imgfmt == IMGFMT_NONE)
return false;
void *data = NULL;
const VAStatus status = vaMapBuffer(ctx->display, image->buf, &data);
if (!CHECK_VA_STATUS(ctx, "vaMapBuffer()"))
return false;
*mpi = (struct mp_image) {0};
mp_image_setfmt(mpi, imgfmt);
mp_image_set_size(mpi, image->width, image->height);
for (int p = 0; p < image->num_planes; p++) {
mpi->stride[p] = image->pitches[p];
mpi->planes[p] = (uint8_t *)data + image->offsets[p];
}
if (image->format.fourcc == VA_FOURCC_YV12) {
MPSWAP(unsigned int, mpi->stride[1], mpi->stride[2]);
MPSWAP(uint8_t *, mpi->planes[1], mpi->planes[2]);
}
return true;
}
bool va_image_unmap(struct mp_vaapi_ctx *ctx, VAImage *image)
{
const VAStatus status = vaUnmapBuffer(ctx->display, image->buf);
return CHECK_VA_STATUS(ctx, "vaUnmapBuffer()");
}
bool va_surface_upload(struct va_surface *surface, struct mp_image *mpi)
{
va_surface_priv_t *p = surface->p;
if (p->image.image_id == VA_INVALID_ID)
return false;
if (va_fourcc_to_imgfmt(p->image.format.fourcc) != mpi->imgfmt)
return false;
struct mp_image img;
if (!va_image_map(p->ctx, &p->image, &img))
return false;
mp_image_copy(&img, mpi);
va_image_unmap(p->ctx, &p->image);
if (!p->is_derived) {
VAStatus status = vaPutImage2(p->display, surface->id,
p->image.image_id,
0, 0, mpi->w, mpi->h,
0, 0, mpi->w, mpi->h);
if (!CHECK_VA_STATUS(p->ctx, "vaPutImage()"))
return false;
}
return true;
}
static struct mp_image *try_download(struct va_surface *surface,
VAImageFormat *format,
struct mp_image_pool *pool)
{
VAStatus status;
enum mp_imgfmt imgfmt = va_fourcc_to_imgfmt(format->fourcc);
if (imgfmt == IMGFMT_NONE)
return NULL;
if (!va_surface_image_alloc(surface, format))
return NULL;
VAImage *image = &surface->p->image;
if (!surface->p->is_derived) {
status = vaGetImage(surface->p->display, surface->id, 0, 0,
surface->w, surface->h, image->image_id);
if (status != VA_STATUS_SUCCESS)
return NULL;
}
struct mp_image *dst = NULL;
struct mp_image tmp;
if (va_image_map(surface->p->ctx, image, &tmp)) {
assert(tmp.imgfmt == imgfmt);
dst = pool ? mp_image_pool_get(pool, imgfmt, tmp.w, tmp.h)
: mp_image_alloc(imgfmt, tmp.w, tmp.h);
mp_image_copy(dst, &tmp);
va_image_unmap(surface->p->ctx, image);
}
return dst;
}
// pool is optional (used for allocating returned images).
// Note: unlike va_surface_upload(), this will attempt to (re)create the
// VAImage stored with the va_surface.
struct mp_image *va_surface_download(struct va_surface *surface,
struct mp_image_pool *pool)
{
struct mp_vaapi_ctx *ctx = surface->p->ctx;
VAStatus status = vaSyncSurface(surface->p->display, surface->id);
if (!CHECK_VA_STATUS(ctx, "vaSyncSurface()"))
return NULL;
VAImage *image = &surface->p->image;
if (image->image_id != VA_INVALID_ID) {
struct mp_image *mpi = try_download(surface, &image->format, pool);
if (mpi)
return mpi;
}
// We have no clue which format will work, so try them all.
for (int i = 0; i < ctx->image_formats->num; i++) {
VAImageFormat *format = &ctx->image_formats->entries[i];
struct mp_image *mpi = try_download(surface, format, pool);
if (mpi)
return mpi;
}
MP_ERR(ctx, "failed to get surface data.\n");
return NULL;
}