FFmpeg
vf_transpose_npp.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <nppi.h>
20 #include <stdio.h>
21 #include <string.h>
22 
23 #include "libavutil/common.h"
24 #include "libavutil/hwcontext.h"
26 #include "libavutil/cuda_check.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/opt.h"
29 #include "libavutil/pixdesc.h"
30 
31 #include "avfilter.h"
32 #include "filters.h"
33 #include "formats.h"
34 #include "video.h"
35 
36 #define CHECK_CU(x) FF_CUDA_CHECK_DL(ctx, device_hwctx->internal->cuda_dl, x)
37 
38 static const enum AVPixelFormat supported_formats[] = {
41 };
42 
47 };
48 
49 enum Transpose {
54 };
55 
60 };
61 
62 typedef struct NPPTransposeStageContext {
66  struct {
67  int width;
68  int height;
69  } planes_in[3], planes_out[3];
73 
74 typedef struct NPPTransposeContext {
75  const AVClass *class;
78 
79  int passthrough; ///< PassthroughType, landscape passthrough mode enabled
80  int dir; ///< TransposeDir
82 
84 {
85  NPPTransposeContext *s = ctx->priv;
86  int i;
87 
88  for (i = 0; i < FF_ARRAY_ELEMS(s->stages); i++) {
89  s->stages[i].frame = av_frame_alloc();
90  if (!s->stages[i].frame)
91  return AVERROR(ENOMEM);
92  }
93 
94  s->tmp_frame = av_frame_alloc();
95  if (!s->tmp_frame)
96  return AVERROR(ENOMEM);
97 
98  return 0;
99 }
100 
102 {
103  NPPTransposeContext *s = ctx->priv;
104  int i;
105 
106  for (i = 0; i < FF_ARRAY_ELEMS(s->stages); i++) {
107  av_frame_free(&s->stages[i].frame);
108  av_buffer_unref(&s->stages[i].frames_ctx);
109  }
110 
111  av_frame_free(&s->tmp_frame);
112 }
113 
114 static int init_stage(NPPTransposeStageContext *stage, AVBufferRef *device_ctx)
115 {
116  AVBufferRef *out_ref = NULL;
117  AVHWFramesContext *out_ctx;
118  int in_sw, in_sh, out_sw, out_sh;
119  int ret, i;
120 
121  av_pix_fmt_get_chroma_sub_sample(stage->in_fmt, &in_sw, &in_sh);
122  av_pix_fmt_get_chroma_sub_sample(stage->out_fmt, &out_sw, &out_sh);
123 
124  if (!stage->planes_out[0].width) {
125  stage->planes_out[0].width = stage->planes_in[0].width;
126  stage->planes_out[0].height = stage->planes_in[0].height;
127  }
128 
129  for (i = 1; i < FF_ARRAY_ELEMS(stage->planes_in); i++) {
130  stage->planes_in[i].width = stage->planes_in[0].width >> in_sw;
131  stage->planes_in[i].height = stage->planes_in[0].height >> in_sh;
132  stage->planes_out[i].width = stage->planes_out[0].width >> out_sw;
133  stage->planes_out[i].height = stage->planes_out[0].height >> out_sh;
134  }
135 
136  out_ref = av_hwframe_ctx_alloc(device_ctx);
137  if (!out_ref)
138  return AVERROR(ENOMEM);
139  out_ctx = (AVHWFramesContext*)out_ref->data;
140 
141  out_ctx->format = AV_PIX_FMT_CUDA;
142  out_ctx->sw_format = stage->out_fmt;
143  out_ctx->width = FFALIGN(stage->planes_out[0].width, 32);
144  out_ctx->height = FFALIGN(stage->planes_out[0].height, 32);
145 
146  ret = av_hwframe_ctx_init(out_ref);
147  if (ret < 0)
148  goto fail;
149 
150  av_frame_unref(stage->frame);
151  ret = av_hwframe_get_buffer(out_ref, stage->frame, 0);
152  if (ret < 0)
153  goto fail;
154 
155  stage->frame->width = stage->planes_out[0].width;
156  stage->frame->height = stage->planes_out[0].height;
157  av_buffer_unref(&stage->frames_ctx);
158  stage->frames_ctx = out_ref;
159 
160  return 0;
161 
162 fail:
163  av_buffer_unref(&out_ref);
164  return ret;
165 }
166 
167 static int format_is_supported(enum AVPixelFormat fmt)
168 {
169  int i;
170 
171  for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++)
172  if (supported_formats[i] == fmt)
173  return 1;
174 
175  return 0;
176 }
177 
178 static int init_processing_chain(AVFilterContext *ctx, int in_width, int in_height,
179  int out_width, int out_height)
180 {
181  FilterLink *inl = ff_filter_link(ctx->inputs[0]);
182  FilterLink *outl = ff_filter_link(ctx->outputs[0]);
183  NPPTransposeContext *s = ctx->priv;
184  AVHWFramesContext *in_frames_ctx;
185  enum AVPixelFormat format;
186  int i, ret, last_stage = -1;
187  int rot_width = out_width, rot_height = out_height;
188 
189  /* check that we have a hw context */
190  if (!inl->hw_frames_ctx) {
191  av_log(ctx, AV_LOG_ERROR, "No hw context provided on input\n");
192  return AVERROR(EINVAL);
193  }
194 
195  in_frames_ctx = (AVHWFramesContext*)inl->hw_frames_ctx->data;
196  format = in_frames_ctx->sw_format;
197 
199  av_log(ctx, AV_LOG_ERROR, "Unsupported input format: %s\n",
201  return AVERROR(ENOSYS);
202  }
203 
204  if (s->dir != NPP_TRANSPOSE_CCLOCK_FLIP) {
205  s->stages[STAGE_ROTATE].stage_needed = 1;
206  }
207 
208  if (s->dir == NPP_TRANSPOSE_CCLOCK_FLIP || s->dir == NPP_TRANSPOSE_CLOCK_FLIP) {
209  s->stages[STAGE_TRANSPOSE].stage_needed = 1;
210 
211  /* Rotating by 180° in case of clock_flip, or not at all for cclock_flip, so width/height unchanged by rotation */
212  rot_width = in_width;
213  rot_height = in_height;
214  }
215 
216  s->stages[STAGE_ROTATE].in_fmt = format;
217  s->stages[STAGE_ROTATE].out_fmt = format;
218  s->stages[STAGE_ROTATE].planes_in[0].width = in_width;
219  s->stages[STAGE_ROTATE].planes_in[0].height = in_height;
220  s->stages[STAGE_ROTATE].planes_out[0].width = rot_width;
221  s->stages[STAGE_ROTATE].planes_out[0].height = rot_height;
222  s->stages[STAGE_TRANSPOSE].in_fmt = format;
223  s->stages[STAGE_TRANSPOSE].out_fmt = format;
224  s->stages[STAGE_TRANSPOSE].planes_in[0].width = rot_width;
225  s->stages[STAGE_TRANSPOSE].planes_in[0].height = rot_height;
226  s->stages[STAGE_TRANSPOSE].planes_out[0].width = out_width;
227  s->stages[STAGE_TRANSPOSE].planes_out[0].height = out_height;
228 
229  /* init the hardware contexts */
230  for (i = 0; i < FF_ARRAY_ELEMS(s->stages); i++) {
231  if (!s->stages[i].stage_needed)
232  continue;
233  ret = init_stage(&s->stages[i], in_frames_ctx->device_ref);
234  if (ret < 0)
235  return ret;
236  last_stage = i;
237  }
238 
239  if (last_stage >= 0) {
240  outl->hw_frames_ctx = av_buffer_ref(s->stages[last_stage].frames_ctx);
241  } else {
243  s->passthrough = 1;
244  }
245 
246  if (!outl->hw_frames_ctx)
247  return AVERROR(ENOMEM);
248 
249  return 0;
250 }
251 
253 {
254  FilterLink *outl = ff_filter_link(outlink);
255  AVFilterContext *ctx = outlink->src;
256  AVFilterLink *inlink = ctx->inputs[0];
258  NPPTransposeContext *s = ctx->priv;
259  int ret;
260 
261  if ((inlink->w >= inlink->h && s->passthrough == NPP_TRANSPOSE_PT_TYPE_LANDSCAPE) ||
262  (inlink->w <= inlink->h && s->passthrough == NPP_TRANSPOSE_PT_TYPE_PORTRAIT))
263  {
264  if (inl->hw_frames_ctx) {
266  if (!outl->hw_frames_ctx)
267  return AVERROR(ENOMEM);
268  }
269 
271  "w:%d h:%d -> w:%d h:%d (passthrough mode)\n",
272  inlink->w, inlink->h, inlink->w, inlink->h);
273  return 0;
274  } else {
275  s->passthrough = NPP_TRANSPOSE_PT_TYPE_NONE;
276  }
277 
278  outlink->w = inlink->h;
279  outlink->h = inlink->w;
280  outlink->sample_aspect_ratio = (AVRational){inlink->sample_aspect_ratio.den, inlink->sample_aspect_ratio.num};
281 
282  ret = init_processing_chain(ctx, inlink->w, inlink->h, outlink->w, outlink->h);
283  if (ret < 0)
284  return ret;
285 
286  av_log(ctx, AV_LOG_VERBOSE, "w:%d h:%d -transpose-> w:%d h:%d\n",
287  inlink->w, inlink->h, outlink->w, outlink->h);
288 
289  return 0;
290 }
291 
293  AVFrame *out, AVFrame *in)
294 {
295  NPPTransposeContext *s = ctx->priv;
296  NppStatus err;
297  int i;
298 
299  for (i = 0; i < FF_ARRAY_ELEMS(stage->planes_in) && i < FF_ARRAY_ELEMS(in->data) && in->data[i]; i++) {
300  int iw = stage->planes_in[i].width;
301  int ih = stage->planes_in[i].height;
302  int ow = stage->planes_out[i].width;
303  int oh = stage->planes_out[i].height;
304 
305  // nppRotate uses 0,0 as the rotation point
306  // need to shift the image accordingly after rotation
307  // need to subtract 1 to get the correct coordinates
308  double angle = s->dir == NPP_TRANSPOSE_CLOCK ? -90.0 : s->dir == NPP_TRANSPOSE_CCLOCK ? 90.0 : 180.0;
309  int shiftw = (s->dir == NPP_TRANSPOSE_CLOCK || s->dir == NPP_TRANSPOSE_CLOCK_FLIP) ? ow - 1 : 0;
310  int shifth = (s->dir == NPP_TRANSPOSE_CCLOCK || s->dir == NPP_TRANSPOSE_CLOCK_FLIP) ? oh - 1 : 0;
311 
312  err = nppiRotate_8u_C1R(in->data[i], (NppiSize){ iw, ih },
313  in->linesize[i], (NppiRect){ 0, 0, iw, ih },
314  out->data[i], out->linesize[i],
315  (NppiRect){ 0, 0, ow, oh },
316  angle, shiftw, shifth, NPPI_INTER_NN);
317  if (err != NPP_SUCCESS) {
318  av_log(ctx, AV_LOG_ERROR, "NPP rotate error: %d\n", err);
319  return AVERROR_UNKNOWN;
320  }
321  }
322 
323  return 0;
324 }
325 
327  AVFrame *out, AVFrame *in)
328 {
329  NppStatus err;
330  int i;
331 
332  for (i = 0; i < FF_ARRAY_ELEMS(stage->planes_in) && i < FF_ARRAY_ELEMS(in->data) && in->data[i]; i++) {
333  int iw = stage->planes_in[i].width;
334  int ih = stage->planes_in[i].height;
335 
336  err = nppiTranspose_8u_C1R(in->data[i], in->linesize[i],
337  out->data[i], out->linesize[i],
338  (NppiSize){ iw, ih });
339  if (err != NPP_SUCCESS) {
340  av_log(ctx, AV_LOG_ERROR, "NPP transpose error: %d\n", err);
341  return AVERROR_UNKNOWN;
342  }
343  }
344 
345  return 0;
346 }
347 
349  AVFrame *out, AVFrame *in) = {
352 };
353 
355 {
356  NPPTransposeContext *s = ctx->priv;
357  AVFrame *src = in;
358  int i, ret, last_stage = -1;
359 
360  for (i = 0; i < FF_ARRAY_ELEMS(s->stages); i++) {
361  if (!s->stages[i].stage_needed)
362  continue;
363 
364  ret = npptranspose_process[i](ctx, &s->stages[i], s->stages[i].frame, src);
365  if (ret < 0)
366  return ret;
367 
368  src = s->stages[i].frame;
369  last_stage = i;
370  }
371 
372  if (last_stage < 0)
373  return AVERROR_BUG;
374 
375  ret = av_hwframe_get_buffer(src->hw_frames_ctx, s->tmp_frame, 0);
376  if (ret < 0)
377  return ret;
378 
380  av_frame_move_ref(src, s->tmp_frame);
381 
382  ret = av_frame_copy_props(out, in);
383  if (ret < 0)
384  return ret;
385 
386  return 0;
387 }
388 
390 {
391  AVFilterContext *ctx = link->dst;
392  NPPTransposeContext *s = ctx->priv;
393  AVFilterLink *outlink = ctx->outputs[0];
394  FilterLink *outl = ff_filter_link(outlink);
395  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)outl->hw_frames_ctx->data;
396  AVCUDADeviceContext *device_hwctx = frames_ctx->device_ctx->hwctx;
397  AVFrame *out = NULL;
398  CUcontext dummy;
399  int ret = 0;
400 
401  if (s->passthrough)
402  return ff_filter_frame(outlink, in);
403 
404  out = av_frame_alloc();
405  if (!out) {
406  ret = AVERROR(ENOMEM);
407  goto fail;
408  }
409 
410  ret = CHECK_CU(device_hwctx->internal->cuda_dl->cuCtxPushCurrent(device_hwctx->cuda_ctx));
411  if (ret < 0)
412  goto fail;
413 
414  ret = npptranspose_filter(ctx, out, in);
415 
416  CHECK_CU(device_hwctx->internal->cuda_dl->cuCtxPopCurrent(&dummy));
417  if (ret < 0)
418  goto fail;
419 
420  av_frame_free(&in);
421 
422  return ff_filter_frame(outlink, out);
423 
424 fail:
425  av_frame_free(&in);
426  av_frame_free(&out);
427  return ret;
428 }
429 
430 #define OFFSET(x) offsetof(NPPTransposeContext, x)
431 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)
432 
433 static const AVOption options[] = {
434  { "dir", "set transpose direction", OFFSET(dir), AV_OPT_TYPE_INT, { .i64 = NPP_TRANSPOSE_CCLOCK_FLIP }, 0, 3, FLAGS, .unit = "dir" },
435  { "cclock_flip", "rotate counter-clockwise with vertical flip", 0, AV_OPT_TYPE_CONST, { .i64 = NPP_TRANSPOSE_CCLOCK_FLIP }, 0, 0, FLAGS, .unit = "dir" },
436  { "clock", "rotate clockwise", 0, AV_OPT_TYPE_CONST, { .i64 = NPP_TRANSPOSE_CLOCK }, 0, 0, FLAGS, .unit = "dir" },
437  { "cclock", "rotate counter-clockwise", 0, AV_OPT_TYPE_CONST, { .i64 = NPP_TRANSPOSE_CCLOCK }, 0, 0, FLAGS, .unit = "dir" },
438  { "clock_flip", "rotate clockwise with vertical flip", 0, AV_OPT_TYPE_CONST, { .i64 = NPP_TRANSPOSE_CLOCK_FLIP }, 0, 0, FLAGS, .unit = "dir" },
439  { "passthrough", "do not apply transposition if the input matches the specified geometry", OFFSET(passthrough), AV_OPT_TYPE_INT, { .i64 = NPP_TRANSPOSE_PT_TYPE_NONE }, 0, 2, FLAGS, .unit = "passthrough" },
440  { "none", "always apply transposition", 0, AV_OPT_TYPE_CONST, { .i64 = NPP_TRANSPOSE_PT_TYPE_NONE }, 0, 0, FLAGS, .unit = "passthrough" },
441  { "landscape", "preserve landscape geometry", 0, AV_OPT_TYPE_CONST, { .i64 = NPP_TRANSPOSE_PT_TYPE_LANDSCAPE }, 0, 0, FLAGS, .unit = "passthrough" },
442  { "portrait", "preserve portrait geometry", 0, AV_OPT_TYPE_CONST, { .i64 = NPP_TRANSPOSE_PT_TYPE_PORTRAIT }, 0, 0, FLAGS, .unit = "passthrough" },
443  { NULL },
444 };
445 
446 static const AVClass npptranspose_class = {
447  .class_name = "npptranspose",
448  .item_name = av_default_item_name,
449  .option = options,
450  .version = LIBAVUTIL_VERSION_INT,
451 };
452 
454  {
455  .name = "default",
456  .type = AVMEDIA_TYPE_VIDEO,
457  .filter_frame = npptranspose_filter_frame,
458  },
459 };
460 
462  {
463  .name = "default",
464  .type = AVMEDIA_TYPE_VIDEO,
465  .config_props = npptranspose_config_props,
466  },
467 };
468 
470  .name = "transpose_npp",
471  .description = NULL_IF_CONFIG_SMALL("NVIDIA Performance Primitives video transpose"),
472  .init = npptranspose_init,
473  .uninit = npptranspose_uninit,
474  .priv_size = sizeof(NPPTransposeContext),
475  .priv_class = &npptranspose_class,
479  .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,
480 };
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:85
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
init_processing_chain
static int init_processing_chain(AVFilterContext *ctx, int in_width, int in_height, int out_width, int out_height)
Definition: vf_transpose_npp.c:178
AVERROR
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
opt.h
npptranspose_filter
static int npptranspose_filter(AVFilterContext *ctx, AVFrame *out, AVFrame *in)
Definition: vf_transpose_npp.c:354
hwcontext_cuda_internal.h
npptranspose_init
static int npptranspose_init(AVFilterContext *ctx)
Definition: vf_transpose_npp.c:83
out
FILE * out
Definition: movenc.c:55
ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1061
npptranspose_class
static const AVClass npptranspose_class
Definition: vf_transpose_npp.c:446
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
supported_formats
static enum AVPixelFormat supported_formats[]
Definition: vf_transpose_npp.c:38
inlink
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
Definition: filter_design.txt:212
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
av_hwframe_ctx_init
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
Definition: hwcontext.c:322
FILTER_INPUTS
#define FILTER_INPUTS(array)
Definition: filters.h:262
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
pixdesc.h
AVFrame::width
int width
Definition: frame.h:461
av_hwframe_ctx_alloc
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
Definition: hwcontext.c:248
AVOption
AVOption.
Definition: opt.h:429
NPPTransposeStageContext::frame
AVFrame * frame
Definition: vf_transpose_npp.c:71
NPPTransposeStageContext::planes_in
struct NPPTransposeStageContext::@358 planes_in[3]
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
Passthrough
Passthrough
Definition: vf_transpose_npp.c:56
AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:205
options
static const AVOption options[]
Definition: vf_transpose_npp.c:433
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVHWFramesContext::width
int width
The allocated dimensions of the frames in this pool.
Definition: hwcontext.h:217
video.h
init_stage
static int init_stage(NPPTransposeStageContext *stage, AVBufferRef *device_ctx)
Definition: vf_transpose_npp.c:114
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
NPPTransposeContext::dir
int dir
TransposeDir.
Definition: vf_transpose_npp.c:80
ff_vf_transpose_npp
const AVFilter ff_vf_transpose_npp
Definition: vf_transpose_npp.c:469
formats.h
NPPTransposeContext::tmp_frame
AVFrame * tmp_frame
Definition: vf_transpose_npp.c:77
npptranspose_config_props
static int npptranspose_config_props(AVFilterLink *outlink)
Definition: vf_transpose_npp.c:252
fail
#define fail()
Definition: checkasm.h:193
TransposeStage
TransposeStage
Definition: vf_transpose_npp.c:43
dummy
int dummy
Definition: motion.c:66
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:3198
AVFilterPad
A filter pad used for either input or output.
Definition: filters.h:38
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AVHWFramesContext::height
int height
Definition: hwcontext.h:217
OFFSET
#define OFFSET(x)
Definition: vf_transpose_npp.c:430
NPP_TRANSPOSE_CLOCK
@ NPP_TRANSPOSE_CLOCK
Definition: vf_transpose_npp.c:51
s
#define s(width, name)
Definition: cbs_vp9.c:198
npptranspose_rotate
static int npptranspose_rotate(AVFilterContext *ctx, NPPTransposeStageContext *stage, AVFrame *out, AVFrame *in)
Definition: vf_transpose_npp.c:292
format
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 format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
filters.h
ctx
AVFormatContext * ctx
Definition: movenc.c:49
format_is_supported
static int format_is_supported(enum AVPixelFormat fmt)
Definition: vf_transpose_npp.c:167
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
FILTER_OUTPUTS
#define FILTER_OUTPUTS(array)
Definition: filters.h:263
link
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 link
Definition: filter_design.txt:23
if
if(ret)
Definition: filter_design.txt:179
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:210
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:725
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVHWFramesContext::device_ref
AVBufferRef * device_ref
A reference to the parent AVHWDeviceContext.
Definition: hwcontext.h:126
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
options
Definition: swscale.c:42
Transpose
Transpose
Definition: vf_transpose_npp.c:49
npptranspose_process
static int(*const npptranspose_process[])(AVFilterContext *ctx, NPPTransposeStageContext *stage, AVFrame *out, AVFrame *in)
Definition: vf_transpose_npp.c:348
NPPTransposeStageContext::stage_needed
int stage_needed
Definition: vf_transpose_npp.c:63
ff_filter_link
static FilterLink * ff_filter_link(AVFilterLink *link)
Definition: filters.h:197
NPPTransposeContext
Definition: vf_transpose_npp.c:74
NPPTransposeStageContext::height
int height
Definition: vf_transpose_npp.c:68
FF_FILTER_FLAG_HWFRAME_AWARE
#define FF_FILTER_FLAG_HWFRAME_AWARE
The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...
Definition: filters.h:206
NPP_TRANSPOSE_PT_TYPE_PORTRAIT
@ NPP_TRANSPOSE_PT_TYPE_PORTRAIT
Definition: vf_transpose_npp.c:59
NPP_TRANSPOSE_CCLOCK
@ NPP_TRANSPOSE_CCLOCK
Definition: vf_transpose_npp.c:52
CHECK_CU
#define CHECK_CU(x)
Definition: vf_transpose_npp.c:36
NPP_TRANSPOSE_PT_TYPE_LANDSCAPE
@ NPP_TRANSPOSE_PT_TYPE_LANDSCAPE
Definition: vf_transpose_npp.c:58
NPPTransposeStageContext::planes_out
struct NPPTransposeStageContext::@358 planes_out[3]
npptranspose_uninit
static void npptranspose_uninit(AVFilterContext *ctx)
Definition: vf_transpose_npp.c:101
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:94
NPPTransposeStageContext::out_fmt
enum AVPixelFormat out_fmt
Definition: vf_transpose_npp.c:65
NPPTransposeStageContext::in_fmt
enum AVPixelFormat in_fmt
Definition: vf_transpose_npp.c:64
NPP_TRANSPOSE_CLOCK_FLIP
@ NPP_TRANSPOSE_CLOCK_FLIP
Definition: vf_transpose_npp.c:53
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
NPPTransposeContext::passthrough
int passthrough
PassthroughType, landscape passthrough mode enabled.
Definition: vf_transpose_npp.c:79
NPPTransposeContext::stages
NPPTransposeStageContext stages[STAGE_NB]
Definition: vf_transpose_npp.c:76
internal.h
common.h
npptranspose_outputs
static const AVFilterPad npptranspose_outputs[]
Definition: vf_transpose_npp.c:461
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:649
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
AVFilterPad::name
const char * name
Pad name.
Definition: filters.h:44
npptranspose_transpose
static int npptranspose_transpose(AVFilterContext *ctx, NPPTransposeStageContext *stage, AVFrame *out, AVFrame *in)
Definition: vf_transpose_npp.c:326
FLAGS
#define FLAGS
Definition: vf_transpose_npp.c:431
NPPTransposeStageContext
Definition: vf_transpose_npp.c:62
AVFilter
Filter definition.
Definition: avfilter.h:201
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
AVCUDADeviceContext
This struct is allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_cuda.h:42
ret
ret
Definition: filter_design.txt:187
AVClass::class_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...
Definition: log.h:80
AVHWFramesContext::device_ctx
AVHWDeviceContext * device_ctx
The parent AVHWDeviceContext.
Definition: hwcontext.h:134
cuda_check.h
AVFrame::height
int height
Definition: frame.h:461
NPPTransposeStageContext::width
int width
Definition: vf_transpose_npp.c:67
npptranspose_filter_frame
static int npptranspose_filter_frame(AVFilterLink *link, AVFrame *in)
Definition: vf_transpose_npp.c:389
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
avfilter.h
STAGE_NB
@ STAGE_NB
Definition: vf_transpose_npp.c:46
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
NPP_TRANSPOSE_PT_TYPE_NONE
@ NPP_TRANSPOSE_PT_TYPE_NONE
Definition: vf_transpose_npp.c:57
AVFilterContext
An instance of a filter.
Definition: avfilter.h:457
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
NPPTransposeStageContext::frames_ctx
AVBufferRef * frames_ctx
Definition: vf_transpose_npp.c:70
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
STAGE_TRANSPOSE
@ STAGE_TRANSPOSE
Definition: vf_transpose_npp.c:45
hwcontext.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:434
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
NPP_TRANSPOSE_CCLOCK_FLIP
@ NPP_TRANSPOSE_CCLOCK_FLIP
Definition: vf_transpose_npp.c:50
npptranspose_inputs
static const AVFilterPad npptranspose_inputs[]
Definition: vf_transpose_npp.c:453
av_hwframe_get_buffer
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
Definition: hwcontext.c:491
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
FILTER_SINGLE_PIXFMT
#define FILTER_SINGLE_PIXFMT(pix_fmt_)
Definition: filters.h:252
src
#define src
Definition: vp8dsp.c:248
av_get_pix_fmt_name
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.
Definition: pixdesc.c:3090
STAGE_ROTATE
@ STAGE_ROTATE
Definition: vf_transpose_npp.c:44