falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

lavc: Remove old vaapi decode infrastructure 

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

(cherry picked from commit 851960f6f8)
tags/n3.3
Mark Thompson 9 years ago
parent
542a65d0b3
commit
2a4a8653b6
8 changed files with 69 additions and 389 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +4
    -0
      doc/APIchanges
  2. +2
    -3
      libavcodec/Makefile
  3. +0
    -251
      libavcodec/vaapi.c
  4. +7
    -0
      libavcodec/vaapi.h
  5. +46
    -32
      libavcodec/vaapi_decode.c
  6. +6
    -0
      libavcodec/vaapi_decode.h
  7. +0
    -102
      libavcodec/vaapi_internal.h
  8. +4
    -1
      libavcodec/version.h

+ 4
- 0
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.




+ 2
- 3
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 \
vaapi_internal.h
SKIPHEADERS-$(CONFIG_VAAPI) += vaapi_decode.h vaapi_encode.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


+ 0
- 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
- 0
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 */

+ 46
- 32
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);
if (err)
goto fail;
#endif


vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
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;
}
err = vaapi_decode_make_config(avctx);
if (err)
goto fail;


av_log(avctx, AV_LOG_DEBUG, "Decode context initialised: "
"%#x/%#x.\n", ctx->va_config, ctx->va_context);
vas = vaCreateContext(ctx->hwctx->display, ctx->va_config,
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) {
vas = vaDestroyContext(ctx->hwctx->display, ctx->va_context);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode "
"context %#x: %d (%s).\n",
ctx->va_context, vas, vaErrorStr(vas));
}
#endif

if (ctx->va_context != VA_INVALID_ID) {
vas = vaDestroyContext(ctx->hwctx->display, ctx->va_context);
if (vas != VA_STATUS_SUCCESS) {
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 (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode "
"configuration %#x: %d (%s).\n",
ctx->va_config, vas, vaErrorStr(vas));
}
}
if (ctx->va_config != VA_INVALID_ID) {
vas = vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to destroy decode "
"configuration %#x: %d (%s).\n",
ctx->va_config, vas, vaErrorStr(vas));
} }
} }


#if FF_API_STRUCT_VAAPI_CONTEXT
}
#endif

return 0; return 0;
} }

+ 6
- 0
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;


+ 0
- 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 */

+ 4
- 1
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 */

Write Preview
Loading…
Cancel
Save