xenia-project/FFmpeg
1
0
Fork 0
mirror of https://github.com/xenia-project/FFmpeg.git synced 2024-11-27 21:40:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

lavc: Remove old vaapi decode infrastructure

Browse Source 
Deprecates struct vaapi_context and the installed header vaapi.h,
to be removed at the next version bump.

(cherry picked from commit 851960f6f8)
This commit is contained in:
Mark Thompson 2016-08-24 23:30:29 +01:00
parent 542a65d0b3
commit 2a4a8653b6
8 changed files with 69 additions and 389 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/APIchanges
View File

@ -15,6 +15,10 @@ libavutil: 2015-08-28
API changes, most recent first: API changes, most recent first:
2017-01-xx - xxxxxxx - lavc 57.74.100 - vaapi.h
Deprecate struct vaapi_context and the vaapi.h installed header.
Callers should set AVCodecContext.hw_frames_ctx instead.
2017-01-12 - xxxxxxx - lavfi 6.69.100- buffersink.h 2017-01-12 - xxxxxxx - lavfi 6.69.100- buffersink.h
Add av_buffersink_get_*() functions. Add av_buffersink_get_*() functions.

5
libavcodec/Makefile
View File

@ -771,7 +771,7 @@ OBJS-$(CONFIG_ADPCM_YAMAHA_ENCODER) += adpcmenc.o adpcm_data.o
# hardware accelerators # hardware accelerators
OBJS-$(CONFIG_D3D11VA) += dxva2.o OBJS-$(CONFIG_D3D11VA) += dxva2.o
OBJS-$(CONFIG_DXVA2) += dxva2.o OBJS-$(CONFIG_DXVA2) += dxva2.o
OBJS-$(CONFIG_VAAPI) += vaapi.o vaapi_decode.o OBJS-$(CONFIG_VAAPI) += vaapi_decode.o
OBJS-$(CONFIG_VDA) += vda.o videotoolbox.o OBJS-$(CONFIG_VDA) += vda.o videotoolbox.o
OBJS-$(CONFIG_VIDEOTOOLBOX) += videotoolbox.o OBJS-$(CONFIG_VIDEOTOOLBOX) += videotoolbox.o
OBJS-$(CONFIG_VDPAU) += vdpau.o OBJS-$(CONFIG_VDPAU) += vdpau.o
@ -1003,8 +1003,7 @@ SKIPHEADERS-$(CONFIG_QSV) += qsv.h qsv_internal.h
SKIPHEADERS-$(CONFIG_QSVDEC) += qsvdec.h SKIPHEADERS-$(CONFIG_QSVDEC) += qsvdec.h
SKIPHEADERS-$(CONFIG_QSVENC) += qsvenc.h SKIPHEADERS-$(CONFIG_QSVENC) += qsvenc.h
SKIPHEADERS-$(CONFIG_XVMC) += xvmc.h SKIPHEADERS-$(CONFIG_XVMC) += xvmc.h
SKIPHEADERS-$(CONFIG_VAAPI) += vaapi_decode.h vaapi_encode.h \ SKIPHEADERS-$(CONFIG_VAAPI) += vaapi_decode.h vaapi_encode.h
vaapi_internal.h
SKIPHEADERS-$(CONFIG_VDA) += vda.h vda_vt_internal.h SKIPHEADERS-$(CONFIG_VDA) += vda.h vda_vt_internal.h
SKIPHEADERS-$(CONFIG_VDPAU) += vdpau.h vdpau_internal.h SKIPHEADERS-$(CONFIG_VDPAU) += vdpau.h vdpau_internal.h
SKIPHEADERS-$(CONFIG_VIDEOTOOLBOX) += videotoolbox.h vda_vt_internal.h SKIPHEADERS-$(CONFIG_VIDEOTOOLBOX) += videotoolbox.h vda_vt_internal.h

251
libavcodec/vaapi.c
View File

@ -1,251 +0,0 @@
/*
* Video Acceleration API (video decoding)
* HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
*
* Copyright (C) 2008-2009 Splitted-Desktop Systems
*
* 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/log.h"
#include "mpegvideo.h"
#include "vaapi_internal.h"
/**
* @addtogroup VAAPI_Decoding
*
* @{
*/
static void destroy_buffers(VADisplay display, VABufferID *buffers, unsigned int n_buffers)
{
unsigned int i;
for (i = 0; i < n_buffers; i++) {
if (buffers[i] != VA_INVALID_ID) {
vaDestroyBuffer(display, buffers[i]);
buffers[i] = VA_INVALID_ID;
}
}
}
int ff_vaapi_context_init(AVCodecContext *avctx)
{
FFVAContext * const vactx = ff_vaapi_get_context(avctx);
const struct vaapi_context * const user_vactx = avctx->hwaccel_context;
if (!user_vactx) {
av_log(avctx, AV_LOG_ERROR, "Hardware acceleration context (hwaccel_context) does not exist.\n");
return AVERROR(ENOSYS);
}
vactx->display = user_vactx->display;
vactx->config_id = user_vactx->config_id;
vactx->context_id = user_vactx->context_id;
vactx->pic_param_buf_id = VA_INVALID_ID;
vactx->iq_matrix_buf_id = VA_INVALID_ID;
vactx->bitplane_buf_id = VA_INVALID_ID;
return 0;
}
int ff_vaapi_context_fini(AVCodecContext *avctx)
{
return 0;
}
int ff_vaapi_render_picture(FFVAContext *vactx, VASurfaceID surface)
{
VABufferID va_buffers[3];
unsigned int n_va_buffers = 0;
if (vactx->pic_param_buf_id == VA_INVALID_ID)
return 0;
vaUnmapBuffer(vactx->display, vactx->pic_param_buf_id);
va_buffers[n_va_buffers++] = vactx->pic_param_buf_id;
if (vactx->iq_matrix_buf_id != VA_INVALID_ID) {
vaUnmapBuffer(vactx->display, vactx->iq_matrix_buf_id);
va_buffers[n_va_buffers++] = vactx->iq_matrix_buf_id;
}
if (vactx->bitplane_buf_id != VA_INVALID_ID) {
vaUnmapBuffer(vactx->display, vactx->bitplane_buf_id);
va_buffers[n_va_buffers++] = vactx->bitplane_buf_id;
}
if (vaBeginPicture(vactx->display, vactx->context_id,
surface) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(vactx->display, vactx->context_id,
va_buffers, n_va_buffers) != VA_STATUS_SUCCESS)
return -1;
if (vaRenderPicture(vactx->display, vactx->context_id,
vactx->slice_buf_ids,
vactx->n_slice_buf_ids) != VA_STATUS_SUCCESS)
return -1;
if (vaEndPicture(vactx->display, vactx->context_id) != VA_STATUS_SUCCESS)
return -1;
return 0;
}
int ff_vaapi_commit_slices(FFVAContext *vactx)
{
VABufferID *slice_buf_ids;
VABufferID slice_param_buf_id, slice_data_buf_id;
if (vactx->slice_count == 0)
return 0;
slice_buf_ids =
av_fast_realloc(vactx->slice_buf_ids,
&vactx->slice_buf_ids_alloc,
(vactx->n_slice_buf_ids + 2) * sizeof(slice_buf_ids[0]));
if (!slice_buf_ids)
return -1;
vactx->slice_buf_ids = slice_buf_ids;
slice_param_buf_id = VA_INVALID_ID;
if (vaCreateBuffer(vactx->display, vactx->context_id,
VASliceParameterBufferType,
vactx->slice_param_size,
vactx->slice_count, vactx->slice_params,
&slice_param_buf_id) != VA_STATUS_SUCCESS)
return -1;
vactx->slice_count = 0;
slice_data_buf_id = VA_INVALID_ID;
if (vaCreateBuffer(vactx->display, vactx->context_id,
VASliceDataBufferType,
vactx->slice_data_size,
1, (void *)vactx->slice_data,
&slice_data_buf_id) != VA_STATUS_SUCCESS)
return -1;
vactx->slice_data = NULL;
vactx->slice_data_size = 0;
slice_buf_ids[vactx->n_slice_buf_ids++] = slice_param_buf_id;
slice_buf_ids[vactx->n_slice_buf_ids++] = slice_data_buf_id;
return 0;
}
static void *alloc_buffer(FFVAContext *vactx, int type, unsigned int size, uint32_t *buf_id)
{
void *data = NULL;
*buf_id = VA_INVALID_ID;
if (vaCreateBuffer(vactx->display, vactx->context_id,
type, size, 1, NULL, buf_id) == VA_STATUS_SUCCESS)
vaMapBuffer(vactx->display, *buf_id, &data);
return data;
}
void *ff_vaapi_alloc_pic_param(FFVAContext *vactx, unsigned int size)
{
return alloc_buffer(vactx, VAPictureParameterBufferType, size, &vactx->pic_param_buf_id);
}
void *ff_vaapi_alloc_iq_matrix(FFVAContext *vactx, unsigned int size)
{
return alloc_buffer(vactx, VAIQMatrixBufferType, size, &vactx->iq_matrix_buf_id);
}
uint8_t *ff_vaapi_alloc_bitplane(FFVAContext *vactx, uint32_t size)
{
return alloc_buffer(vactx, VABitPlaneBufferType, size, &vactx->bitplane_buf_id);
}
VASliceParameterBufferBase *ff_vaapi_alloc_slice(FFVAContext *vactx, const uint8_t *buffer, uint32_t size)
{
uint8_t *slice_params;
VASliceParameterBufferBase *slice_param;
if (!vactx->slice_data)
vactx->slice_data = buffer;
if (vactx->slice_data + vactx->slice_data_size != buffer) {
if (ff_vaapi_commit_slices(vactx) < 0)
return NULL;
vactx->slice_data = buffer;
}
slice_params =
av_fast_realloc(vactx->slice_params,
&vactx->slice_params_alloc,
(vactx->slice_count + 1) * vactx->slice_param_size);
if (!slice_params)
return NULL;
vactx->slice_params = slice_params;
slice_param = (VASliceParameterBufferBase *)(slice_params + vactx->slice_count * vactx->slice_param_size);
slice_param->slice_data_size = size;
slice_param->slice_data_offset = vactx->slice_data_size;
slice_param->slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
vactx->slice_count++;
vactx->slice_data_size += size;
return slice_param;
}
void ff_vaapi_common_end_frame(AVCodecContext *avctx)
{
FFVAContext * const vactx = ff_vaapi_get_context(avctx);
destroy_buffers(vactx->display, &vactx->pic_param_buf_id, 1);
destroy_buffers(vactx->display, &vactx->iq_matrix_buf_id, 1);
destroy_buffers(vactx->display, &vactx->bitplane_buf_id, 1);
destroy_buffers(vactx->display, vactx->slice_buf_ids, vactx->n_slice_buf_ids);
av_freep(&vactx->slice_buf_ids);
av_freep(&vactx->slice_params);
vactx->n_slice_buf_ids = 0;
vactx->slice_buf_ids_alloc = 0;
vactx->slice_count = 0;
vactx->slice_params_alloc = 0;
}
#if CONFIG_H263_VAAPI_HWACCEL || CONFIG_MPEG1_VAAPI_HWACCEL || \
CONFIG_MPEG2_VAAPI_HWACCEL || CONFIG_MPEG4_VAAPI_HWACCEL || \
CONFIG_VC1_VAAPI_HWACCEL || CONFIG_WMV3_VAAPI_HWACCEL
int ff_vaapi_mpeg_end_frame(AVCodecContext *avctx)
{
FFVAContext * const vactx = ff_vaapi_get_context(avctx);
MpegEncContext *s = avctx->priv_data;
int ret;
ret = ff_vaapi_commit_slices(vactx);
if (ret < 0)
goto finish;
ret = ff_vaapi_render_picture(vactx,
ff_vaapi_get_surface_id(s->current_picture_ptr->f));
if (ret < 0)
goto finish;
ff_mpeg_draw_horiz_band(s, 0, s->avctx->height);
finish:
ff_vaapi_common_end_frame(avctx);
return ret;
}
#endif
/* @} */

7
libavcodec/vaapi.h
View File

@ -34,6 +34,8 @@
#include "libavutil/attributes.h" #include "libavutil/attributes.h"
#include "version.h" #include "version.h"
#if FF_API_STRUCT_VAAPI_CONTEXT
/** /**
* @defgroup lavc_codec_hwaccel_vaapi VA API Decoding * @defgroup lavc_codec_hwaccel_vaapi VA API Decoding
* @ingroup lavc_codec_hwaccel * @ingroup lavc_codec_hwaccel
@ -48,7 +50,10 @@
* during initialization or through each AVCodecContext.get_buffer() * during initialization or through each AVCodecContext.get_buffer()
* function call. In any case, they must be valid prior to calling * function call. In any case, they must be valid prior to calling
* decoding functions. * decoding functions.
*
* Deprecated: use AVCodecContext.hw_frames_ctx instead.
*/ */
attribute_deprecated
struct vaapi_context { struct vaapi_context {
/** /**
* Window system dependent data * Window system dependent data
@ -186,4 +191,6 @@ struct vaapi_context {
/* @} */ /* @} */
#endif /* FF_API_STRUCT_VAAPI_CONTEXT */
#endif /* AVCODEC_VAAPI_H */ #endif /* AVCODEC_VAAPI_H */

78
libavcodec/vaapi_decode.c
View File

@ -427,6 +427,7 @@ int ff_vaapi_decode_init(AVCodecContext *avctx)
ctx->va_config = VA_INVALID_ID; ctx->va_config = VA_INVALID_ID;
ctx->va_context = VA_INVALID_ID; ctx->va_context = VA_INVALID_ID;
#if FF_API_STRUCT_VAAPI_CONTEXT
if (avctx->hwaccel_context) { if (avctx->hwaccel_context) {
av_log(avctx, AV_LOG_WARNING, "Using deprecated struct " av_log(avctx, AV_LOG_WARNING, "Using deprecated struct "
"vaapi_context in decode.\n"); "vaapi_context in decode.\n");
@ -453,7 +454,9 @@ int ff_vaapi_decode_init(AVCodecContext *avctx)
ctx->hwctx->driver_quirks = ctx->hwctx->driver_quirks =
AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS; AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS;
} else if (avctx->hw_frames_ctx) { } else
#endif
if (avctx->hw_frames_ctx) {
// This structure has a shorter lifetime than the enclosing // This structure has a shorter lifetime than the enclosing
// AVCodecContext, so we inherit the references from there // AVCodecContext, so we inherit the references from there
// and do not need to make separate ones. // and do not need to make separate ones.
@ -471,6 +474,7 @@ int ff_vaapi_decode_init(AVCodecContext *avctx)
goto fail; goto fail;
} }
#if FF_API_STRUCT_VAAPI_CONTEXT
if (ctx->have_old_context) { if (ctx->have_old_context) {
ctx->va_config = ctx->old_context->config_id; ctx->va_config = ctx->old_context->config_id;
ctx->va_context = ctx->old_context->context_id; ctx->va_context = ctx->old_context->context_id;
@ -478,27 +482,31 @@ int ff_vaapi_decode_init(AVCodecContext *avctx)
av_log(avctx, AV_LOG_DEBUG, "Using user-supplied decoder " av_log(avctx, AV_LOG_DEBUG, "Using user-supplied decoder "
"context: %#x/%#x.\n", ctx->va_config, ctx->va_context); "context: %#x/%#x.\n", ctx->va_config, ctx->va_context);
} else { } else {
err = vaapi_decode_make_config(avctx); #endif
if (err)
goto fail;
vas = vaCreateContext(ctx->hwctx->display, ctx->va_config, err = vaapi_decode_make_config(avctx);
avctx->coded_width, avctx->coded_height, if (err)
VA_PROGRESSIVE, goto fail;
ctx->hwfc->surface_ids,
ctx->hwfc->nb_surfaces,
&ctx->va_context);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to create decode "
"context: %d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
}
av_log(avctx, AV_LOG_DEBUG, "Decode context initialised: " vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
"%#x/%#x.\n", ctx->va_config, ctx->va_context); avctx->coded_width, avctx->coded_height,
VA_PROGRESSIVE,
ctx->hwfc->surface_ids,
ctx->hwfc->nb_surfaces,
&ctx->va_context);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to create decode "
"context: %d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
} }
av_log(avctx, AV_LOG_DEBUG, "Decode context initialised: "
"%#x/%#x.\n", ctx->va_config, ctx->va_context);
#if FF_API_STRUCT_VAAPI_CONTEXT
}
#endif
return 0; return 0;
fail: fail:
@ -511,26 +519,32 @@ int ff_vaapi_decode_uninit(AVCodecContext *avctx)
VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data; VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
VAStatus vas; VAStatus vas;
#if FF_API_STRUCT_VAAPI_CONTEXT
if (ctx->have_old_context) { if (ctx->have_old_context) {
av_buffer_unref(&ctx->device_ref); av_buffer_unref(&ctx->device_ref);
} else { } else {
if (ctx->va_context != VA_INVALID_ID) { #endif
vas = vaDestroyContext(ctx->hwctx->display, ctx->va_context);
if (vas != VA_STATUS_SUCCESS) { if (ctx->va_context != VA_INVALID_ID) {
av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode " vas = vaDestroyContext(ctx->hwctx->display, ctx->va_context);
"context %#x: %d (%s).\n", if (vas != VA_STATUS_SUCCESS) {
ctx->va_context, vas, vaErrorStr(vas)); av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode "
} "context %#x: %d (%s).\n",
ctx->va_context, vas, vaErrorStr(vas));
} }
if (ctx->va_config != VA_INVALID_ID) { }
vas = vaDestroyConfig(ctx->hwctx->display, ctx->va_config); if (ctx->va_config != VA_INVALID_ID) {
if (vas != VA_STATUS_SUCCESS) { vas = vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode " if (vas != VA_STATUS_SUCCESS) {
"configuration %#x: %d (%s).\n", av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode "
ctx->va_config, vas, vaErrorStr(vas)); "configuration %#x: %d (%s).\n",
} ctx->va_config, vas, vaErrorStr(vas));
} }
} }
#if FF_API_STRUCT_VAAPI_CONTEXT
}
#endif
return 0; return 0;
} }

6
libavcodec/vaapi_decode.h
View File

@ -26,7 +26,11 @@
#include "libavutil/hwcontext_vaapi.h" #include "libavutil/hwcontext_vaapi.h"
#include "avcodec.h" #include "avcodec.h"
#include "version.h"
#if FF_API_STRUCT_VAAPI_CONTEXT
#include "vaapi.h" #include "vaapi.h"
#endif
static inline VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic) static inline VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
{ {
@ -54,9 +58,11 @@ typedef struct VAAPIDecodeContext {
VAConfigID va_config; VAConfigID va_config;
VAContextID va_context; VAContextID va_context;
#if FF_API_STRUCT_VAAPI_CONTEXT
int have_old_context; int have_old_context;
struct vaapi_context *old_context; struct vaapi_context *old_context;
AVBufferRef *device_ref; AVBufferRef *device_ref;
#endif
AVHWDeviceContext *device; AVHWDeviceContext *device;
AVVAAPIDeviceContext *hwctx; AVVAAPIDeviceContext *hwctx;

102
libavcodec/vaapi_internal.h
View File

@ -1,102 +0,0 @@
/*
* Video Acceleration API (video decoding)
* HW decode acceleration for MPEG-2, MPEG-4, H.264 and VC-1
*
* Copyright (C) 2008-2009 Splitted-Desktop Systems
*
* 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 AVCODEC_VAAPI_INTERNAL_H
#define AVCODEC_VAAPI_INTERNAL_H
#include <va/va.h>
#include "vaapi.h"
#include "avcodec.h"
#include "internal.h"
/**
* @addtogroup VAAPI_Decoding
*
* @{
*/
typedef struct {
VADisplay display; ///< Windowing system dependent handle
VAConfigID config_id; ///< Configuration ID
VAContextID context_id; ///< Context ID (video decode pipeline)
VABufferID pic_param_buf_id; ///< Picture parameter buffer
VABufferID iq_matrix_buf_id; ///< Inverse quantiser matrix buffer
VABufferID bitplane_buf_id; ///< Bitplane buffer (for VC-1 decoding)
VABufferID *slice_buf_ids; ///< Slice parameter/data buffers
unsigned int n_slice_buf_ids; ///< Number of effective slice buffers
unsigned int slice_buf_ids_alloc; ///< Number of allocated slice buffers
void *slice_params; ///< Pointer to slice parameter buffers
unsigned int slice_param_size; ///< Size of a slice parameter element
unsigned int slice_params_alloc; ///< Number of allocated slice parameters
unsigned int slice_count; ///< Number of slices currently filled in
const uint8_t *slice_data; ///< Pointer to slice data buffer base
unsigned int slice_data_size; ///< Current size of slice data
} FFVAContext;
/** Extract vaapi_context from an AVCodecContext */
static inline FFVAContext *ff_vaapi_get_context(AVCodecContext *avctx)
{
return avctx->internal->hwaccel_priv_data;
}
/** Extract VASurfaceID from an AVFrame */
static inline VASurfaceID ff_vaapi_get_surface_id(AVFrame *pic)
{
return (uintptr_t)pic->data[3];
}
/** Common AVHWAccel.init() implementation */
int ff_vaapi_context_init(AVCodecContext *avctx);
/** Common AVHWAccel.uninit() implementation */
int ff_vaapi_context_fini(AVCodecContext *avctx);
/** Common AVHWAccel.end_frame() implementation */
void ff_vaapi_common_end_frame(AVCodecContext *avctx);
/** Allocate a new picture parameter buffer */
void *ff_vaapi_alloc_pic_param(FFVAContext *vactx, unsigned int size);
/** Allocate a new IQ matrix buffer */
void *ff_vaapi_alloc_iq_matrix(FFVAContext *vactx, unsigned int size);
/** Allocate a new bit-plane buffer */
uint8_t *ff_vaapi_alloc_bitplane(FFVAContext *vactx, uint32_t size);
/**
* Allocate a new slice descriptor for the input slice.
*
* @param vactx the VA API context
* @param buffer the slice data buffer base
* @param size the size of the slice in bytes
* @return the newly allocated slice parameter
*/
VASliceParameterBufferBase *ff_vaapi_alloc_slice(FFVAContext *vactx, const uint8_t *buffer, uint32_t size);
int ff_vaapi_mpeg_end_frame(AVCodecContext *avctx);
int ff_vaapi_commit_slices(FFVAContext *vactx);
int ff_vaapi_render_picture(FFVAContext *vactx, VASurfaceID surface);
/* @} */
#endif /* AVCODEC_VAAPI_INTERNAL_H */

5
libavcodec/version.h
View File

@ -28,7 +28,7 @@
#include "libavutil/version.h" #include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 57 #define LIBAVCODEC_VERSION_MAJOR 57
#define LIBAVCODEC_VERSION_MINOR 73 #define LIBAVCODEC_VERSION_MINOR 74
#define LIBAVCODEC_VERSION_MICRO 100 #define LIBAVCODEC_VERSION_MICRO 100
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \ #define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
@ -226,5 +226,8 @@
#ifndef FF_API_NVENC_OLD_NAME #ifndef FF_API_NVENC_OLD_NAME
#define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59) #define FF_API_NVENC_OLD_NAME (LIBAVCODEC_VERSION_MAJOR < 59)
#endif #endif
#ifndef FF_API_STRUCT_VAAPI_CONTEXT
#define FF_API_STRUCT_VAAPI_CONTEXT (LIBAVCODEC_VERSION_MAJOR < 59)
#endif
#endif /* AVCODEC_VERSION_H */ #endif /* AVCODEC_VERSION_H */