33 #define MAX_REFERENCES 8 42 VAProcFilterCapDeinterlacing
56 #define D(name) case VAProcDeinterlacing ## name: return #name 84 VAProcFilterParameterBufferDeinterlacing
params;
88 vas = vaQueryVideoProcFilterCaps(vpp_ctx->
hwctx->
display,
90 VAProcFilterDeinterlacing,
93 if (vas != VA_STATUS_SUCCESS) {
95 "caps: %d (%s).\n", vas, vaErrorStr(vas));
99 if (ctx->
mode == VAProcDeinterlacingNone) {
105 "deinterlacing mode.\n", ctx->
mode,
114 "not supported.\n", ctx->
mode,
120 params.type = VAProcFilterDeinterlacing;
121 params.algorithm = ctx->
mode;
125 VAProcFilterParameterBufferType,
132 vas = vaQueryVideoProcPipelineCaps(vpp_ctx->
hwctx->
display,
136 if (vas != VA_STATUS_SUCCESS) {
138 "caps: %d (%s).\n", vas, vaErrorStr(vas));
150 "references (%u forward, %u back).\n",
184 VASurfaceID input_surface;
187 VAProcPipelineParameterBuffer
params;
188 VAProcFilterParameterBufferDeinterlacing *filter_params;
190 void *filter_params_addr =
NULL;
191 int err,
i,
field, current_frame_index;
210 current_frame_index = ctx->
pipeline_caps.num_forward_references;
212 input_frame = ctx->
frame_queue[current_frame_index];
213 input_surface = (VASurfaceID)(uintptr_t)input_frame->
data[3];
214 for (i = 0; i < ctx->
pipeline_caps.num_forward_references; i++)
215 forward_references[i] = (VASurfaceID)(uintptr_t)
218 backward_references[i] = (VASurfaceID)(uintptr_t)
222 "deinterlace input.\n", input_surface);
224 for (i = 0; i < ctx->
pipeline_caps.num_backward_references; i++)
228 for (i = 0; i < ctx->
pipeline_caps.num_forward_references; i++)
232 for (field = 0; field < ctx->
field_rate; field++) {
245 input_frame, output_frame);
251 &filter_params_addr);
252 if (vas != VA_STATUS_SUCCESS) {
254 "buffer: %d (%s).\n", vas, vaErrorStr(vas));
258 filter_params = filter_params_addr;
259 filter_params->flags = 0;
261 filter_params->flags |= field ? VA_DEINTERLACING_BOTTOM_FIELD : 0;
263 filter_params->flags |= VA_DEINTERLACING_BOTTOM_FIELD_FIRST;
264 filter_params->flags |= field ? 0 : VA_DEINTERLACING_BOTTOM_FIELD;
266 filter_params_addr =
NULL;
268 if (vas != VA_STATUS_SUCCESS)
270 "buffer: %d (%s).\n", vas, vaErrorStr(vas));
273 params.num_filters = 1;
275 params.forward_references = forward_references;
276 params.num_forward_references =
278 params.backward_references = backward_references;
279 params.num_backward_references =
283 params.filters =
NULL;
284 params.num_filters = 0;
293 output_frame->
pts = 2 * input_frame->
pts;
295 output_frame->
pts = input_frame->
pts +
312 if (filter_params_addr)
330 #define OFFSET(x) offsetof(DeintVAAPIContext, x) 331 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM) 333 {
"mode",
"Deinterlacing mode",
335 VAProcDeinterlacingNone, VAProcDeinterlacingCount - 1,
FLAGS,
"mode" },
336 {
"default",
"Use the highest-numbered (and therefore possibly most advanced) deinterlacing algorithm",
338 {
"bob",
"Use the bob deinterlacing algorithm",
340 {
"weave",
"Use the weave deinterlacing algorithm",
342 {
"motion_adaptive",
"Use the motion adaptive deinterlacing algorithm",
344 {
"motion_compensated",
"Use the motion compensated deinterlacing algorithm",
347 {
"rate",
"Generate output at frame rate or field rate",
349 {
"frame",
"Output at frame rate (one frame of output for each field-pair)",
351 {
"field",
"Output at field rate (one frame of output for each field)",
354 {
"auto",
"Only deinterlace fields, passing frames through unchanged",
387 .
name =
"deinterlace_vaapi",
393 .
inputs = deint_vaapi_inputs,
394 .
outputs = deint_vaapi_outputs,
395 .priv_class = &deint_vaapi_class,
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
This structure describes decoded (raw) audio or video data.
int ff_vaapi_vpp_config_input(AVFilterLink *inlink)
#define LIBAVUTIL_VERSION_INT
Main libavfilter public API header.
Memory handling functions.
int ff_vaapi_vpp_config_output(AVFilterLink *outlink)
static av_cold int init(AVCodecContext *avctx)
VAProcFilterCapDeinterlacing deint_caps[VAProcDeinterlacingCount]
static int deint_vaapi_filter_frame(AVFilterLink *inlink, AVFrame *input_frame)
const char * av_default_item_name(void *ptr)
Return the context name.
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
static int deint_vaapi_build_filter_params(AVFilterContext *avctx)
const char * name
Pad name.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
AVFilterLink ** inputs
array of pointers to input links
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
static av_cold int uninit(AVCodecContext *avctx)
static void deint_vaapi_pipeline_uninit(AVFilterContext *avctx)
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
AVFilter ff_vf_deinterlace_vaapi
#define AV_LOG_VERBOSE
Detailed information.
int interlaced_frame
The content of the picture is interlaced.
A filter pad used for either input or output.
A link between two filters.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void * priv
private data for use by the filter
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
simple assert() macros that are a bit more flexible than ISO C assert().
int ff_vaapi_vpp_make_param_buffers(AVFilterContext *avctx, int type, const void *data, size_t size, int count)
static int deint_vaapi_config_output(AVFilterLink *outlink)
AVFrame * frame_queue[MAX_REFERENCES]
static const char * deint_vaapi_mode_name(int mode)
void ff_vaapi_vpp_pipeline_uninit(AVFilterContext *avctx)
int extra_delay_for_timestamps
AVFilterContext * src
source filter
static const AVFilterPad outputs[]
VAProcPipelineCaps pipeline_caps
VADisplay display
The VADisplay handle, to be filled by the user.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
VABufferID filter_buffers[VAProcFilterCount]
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
Describe the class of an AVClass context structure.
Rational number (pair of numerator and denominator).
const char * name
Filter name.
static const AVClass deint_vaapi_class
AVFilterLink ** outputs
array of pointers to output links
enum AVPixelFormat output_format
AVVAAPIDeviceContext * hwctx
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int ff_vaapi_vpp_render_picture(AVFilterContext *avctx, VAProcPipelineParameterBuffer *params, AVFrame *output_frame)
The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink
static av_cold int deint_vaapi_init(AVFilterContext *avctx)
int ff_vaapi_vpp_query_formats(AVFilterContext *avctx)
static const AVFilterPad deint_vaapi_inputs[]
static int query_formats(AVFilterContext *ctx)
common internal and external API header
void ff_vaapi_vpp_ctx_init(AVFilterContext *avctx)
static const AVFilterPad deint_vaapi_outputs[]
int top_field_first
If the content is interlaced, is top field displayed first.
AVFilterContext * dst
dest filter
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
int ff_vaapi_vpp_init_params(AVFilterContext *avctx, VAProcPipelineParameterBuffer *params, const AVFrame *input_frame, AVFrame *output_frame)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
int(* build_filter_params)(AVFilterContext *avctx)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
mode
Use these values in ebur128_init (or'ed).
void(* pipeline_uninit)(AVFilterContext *avctx)
void ff_vaapi_vpp_ctx_uninit(AVFilterContext *avctx)
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
static const AVOption deint_vaapi_options[]