FFmpeg
vapoursynth.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 /**
20 * @file
21 * VapourSynth demuxer
22 *
23 * Synthesizes vapour (?)
24 */
25 
26 #include <limits.h>
27 
28 #include <VapourSynth.h>
29 #include <VSScript.h>
30 
31 #include "libavutil/avassert.h"
32 #include "libavutil/avstring.h"
33 #include "libavutil/eval.h"
34 #include "libavutil/frame.h"
35 #include "libavutil/imgutils.h"
36 #include "libavutil/opt.h"
37 #include "libavutil/pixdesc.h"
38 #include "avformat.h"
39 #include "internal.h"
40 
41 struct VSState {
42  VSScript *vss;
43 };
44 
45 typedef struct VSContext {
46  const AVClass *class;
47 
49 
50  const VSAPI *vsapi;
51  VSCore *vscore;
52 
53  VSNodeRef *outnode;
54  int is_cfr;
56 
57  int c_order[4];
58 
59  /* options */
60  int64_t max_script_size;
61 } VSContext;
62 
63 #define OFFSET(x) offsetof(VSContext, x)
64 #define A AV_OPT_FLAG_AUDIO_PARAM
65 #define D AV_OPT_FLAG_DECODING_PARAM
66 static const AVOption options[] = {
67  {"max_script_size", "set max file size supported (in bytes)", OFFSET(max_script_size), AV_OPT_TYPE_INT64, {.i64 = 1 * 1024 * 1024}, 0, SIZE_MAX - 1, A|D},
68  {NULL}
69 };
70 
71 static void free_vss_state(void *opaque, uint8_t *data)
72 {
73  struct VSState *vss = opaque;
74 
75  if (vss->vss) {
76  vsscript_freeScript(vss->vss);
77  vsscript_finalize();
78  }
79 }
80 
82 {
83  VSContext *vs = s->priv_data;
84 
85  if (vs->outnode)
86  vs->vsapi->freeNode(vs->outnode);
87 
89 
90  vs->vsapi = NULL;
91  vs->vscore = NULL;
92  vs->outnode = NULL;
93 
94  return 0;
95 }
96 
98 {
100  const AVPixFmtDescriptor *pd;
101  if (other == AV_PIX_FMT_NONE || other == pixfmt)
102  return 1; // not affected by byte order
104  return pd && (!!HAVE_BIGENDIAN == !!(pd->flags & AV_PIX_FMT_FLAG_BE));
105 }
106 
107 static av_cold enum AVPixelFormat match_pixfmt(const VSFormat *vsf, int c_order[4])
108 {
109  static const int yuv_order[4] = {0, 1, 2, 0};
110  static const int rgb_order[4] = {1, 2, 0, 0};
111  const AVPixFmtDescriptor *pd;
112 
113  for (pd = av_pix_fmt_desc_next(NULL); pd; pd = av_pix_fmt_desc_next(pd)) {
114  int is_rgb, is_yuv, i;
115  const int *order;
116  enum AVPixelFormat pixfmt;
117 
119 
123  continue;
124 
125  if (pd->log2_chroma_w != vsf->subSamplingW ||
126  pd->log2_chroma_h != vsf->subSamplingH)
127  continue;
128 
129  is_rgb = vsf->colorFamily == cmRGB;
130  if (is_rgb != !!(pd->flags & AV_PIX_FMT_FLAG_RGB))
131  continue;
132 
133  is_yuv = vsf->colorFamily == cmYUV ||
134  vsf->colorFamily == cmYCoCg ||
135  vsf->colorFamily == cmGray;
136  if (!is_rgb && !is_yuv)
137  continue;
138 
139  if (vsf->sampleType != ((pd->flags & AV_PIX_FMT_FLAG_FLOAT) ? stFloat : stInteger))
140  continue;
141 
142  if (av_pix_fmt_count_planes(pixfmt) != vsf->numPlanes)
143  continue;
144 
145  if (!is_native_endian(pixfmt))
146  continue;
147 
148  order = is_yuv ? yuv_order : rgb_order;
149 
150  for (i = 0; i < pd->nb_components; i++) {
151  const AVComponentDescriptor *c = &pd->comp[i];
152  if (order[c->plane] != i ||
153  c->offset != 0 || c->shift != 0 ||
154  c->step != vsf->bytesPerSample ||
155  c->depth != vsf->bitsPerSample)
156  goto cont;
157  }
158 
159  // Use it.
160  memcpy(c_order, order, sizeof(int[4]));
161  return pixfmt;
162 
163  cont: ;
164  }
165 
166  return AV_PIX_FMT_NONE;
167 }
168 
170 {
171  AVStream *st;
172  AVIOContext *pb = s->pb;
173  VSContext *vs = s->priv_data;
174  int64_t sz = avio_size(pb);
175  char *buf = NULL;
176  char dummy;
177  const VSVideoInfo *info;
178  struct VSState *vss_state;
179  int err = 0;
180 
181  vss_state = av_mallocz(sizeof(*vss_state));
182  if (!vss_state) {
183  err = AVERROR(ENOMEM);
184  goto done;
185  }
186 
187  vs->vss_state = av_buffer_create(NULL, 0, free_vss_state, vss_state, 0);
188  if (!vs->vss_state) {
189  err = AVERROR(ENOMEM);
190  av_free(vss_state);
191  goto done;
192  }
193 
194  if (!vsscript_init()) {
195  av_log(s, AV_LOG_ERROR, "Failed to initialize VSScript (possibly PYTHONPATH not set).\n");
196  err = AVERROR_EXTERNAL;
197  goto done;
198  }
199 
200  if (vsscript_createScript(&vss_state->vss)) {
201  av_log(s, AV_LOG_ERROR, "Failed to create script instance.\n");
202  err = AVERROR_EXTERNAL;
203  vsscript_finalize();
204  goto done;
205  }
206 
207  if (sz < 0 || sz > vs->max_script_size) {
208  if (sz < 0)
209  av_log(s, AV_LOG_WARNING, "Could not determine file size\n");
210  sz = vs->max_script_size;
211  }
212 
213  buf = av_malloc(sz + 1);
214  if (!buf) {
215  err = AVERROR(ENOMEM);
216  goto done;
217  }
218  sz = avio_read(pb, buf, sz);
219 
220  if (sz < 0) {
221  av_log(s, AV_LOG_ERROR, "Could not read script.\n");
222  err = sz;
223  goto done;
224  }
225 
226  // Data left means our buffer (the max_script_size option) is too small
227  if (avio_read(pb, &dummy, 1) == 1) {
228  av_log(s, AV_LOG_ERROR, "File size is larger than max_script_size option "
229  "value %"PRIi64", consider increasing the max_script_size option\n",
230  vs->max_script_size);
232  goto done;
233  }
234 
235  buf[sz] = '\0';
236  if (vsscript_evaluateScript(&vss_state->vss, buf, s->url, 0)) {
237  const char *msg = vsscript_getError(vss_state->vss);
238  av_log(s, AV_LOG_ERROR, "Failed to parse script: %s\n", msg ? msg : "(unknown)");
239  err = AVERROR_EXTERNAL;
240  goto done;
241  }
242 
243  vs->vsapi = vsscript_getVSApi();
244  vs->vscore = vsscript_getCore(vss_state->vss);
245 
246  vs->outnode = vsscript_getOutput(vss_state->vss, 0);
247  if (!vs->outnode) {
248  av_log(s, AV_LOG_ERROR, "Could not get script output node.\n");
249  err = AVERROR_EXTERNAL;
250  goto done;
251  }
252 
253  st = avformat_new_stream(s, NULL);
254  if (!st) {
255  err = AVERROR(ENOMEM);
256  goto done;
257  }
258 
259  info = vs->vsapi->getVideoInfo(vs->outnode);
260 
261  if (!info->format || !info->width || !info->height) {
262  av_log(s, AV_LOG_ERROR, "Non-constant input format not supported.\n");
263  err = AVERROR_PATCHWELCOME;
264  goto done;
265  }
266 
267  if (info->fpsDen) {
268  vs->is_cfr = 1;
269  avpriv_set_pts_info(st, 64, info->fpsDen, info->fpsNum);
270  st->duration = info->numFrames;
271  } else {
272  // VFR. Just set "something".
273  avpriv_set_pts_info(st, 64, 1, AV_TIME_BASE);
274  s->ctx_flags |= AVFMTCTX_UNSEEKABLE;
275  }
276 
279  st->codecpar->width = info->width;
280  st->codecpar->height = info->height;
281  st->codecpar->format = match_pixfmt(info->format, vs->c_order);
282 
283  if (st->codecpar->format == AV_PIX_FMT_NONE) {
284  av_log(s, AV_LOG_ERROR, "Unsupported VS pixel format %s\n", info->format->name);
285  err = AVERROR_EXTERNAL;
286  goto done;
287  }
288  av_log(s, AV_LOG_VERBOSE, "VS format %s -> pixfmt %s\n", info->format->name,
290 
291  if (info->format->colorFamily == cmYCoCg)
293 
294 done:
295  av_free(buf);
296  return err;
297 }
298 
299 static void free_frame(void *opaque, uint8_t *data)
300 {
301  AVFrame *frame = (AVFrame *)data;
302 
304 }
305 
306 static int get_vs_prop_int(AVFormatContext *s, const VSMap *map, const char *name, int def)
307 {
308  VSContext *vs = s->priv_data;
309  int64_t res;
310  int err = 1;
311 
312  res = vs->vsapi->propGetInt(map, name, 0, &err);
313  return err || res < INT_MIN || res > INT_MAX ? def : res;
314 }
315 
317  const VSAPI *vsapi;
318  const VSFrameRef *frame;
320 };
321 
322 static void free_vsframe_ref(void *opaque, uint8_t *data)
323 {
324  struct vsframe_ref_data *d = opaque;
325 
326  if (d->frame)
327  d->vsapi->freeFrame(d->frame);
328 
329  av_buffer_unref(&d->vss_state);
330 
331  av_free(d);
332 }
333 
335 {
336  VSContext *vs = s->priv_data;
337  AVStream *st = s->streams[0];
338  AVFrame *frame = NULL;
339  char vserr[80];
340  const VSFrameRef *vsframe;
341  const VSVideoInfo *info = vs->vsapi->getVideoInfo(vs->outnode);
342  const VSMap *props;
343  const AVPixFmtDescriptor *desc;
344  AVBufferRef *vsframe_ref = NULL;
345  struct vsframe_ref_data *ref_data;
346  int err = 0;
347  int i;
348 
349  if (vs->current_frame >= info->numFrames)
350  return AVERROR_EOF;
351 
352  ref_data = av_mallocz(sizeof(*ref_data));
353  if (!ref_data) {
354  err = AVERROR(ENOMEM);
355  goto end;
356  }
357 
358  // (the READONLY flag is important because the ref is reused for plane data)
359  vsframe_ref = av_buffer_create(NULL, 0, free_vsframe_ref, ref_data, AV_BUFFER_FLAG_READONLY);
360  if (!vsframe_ref) {
361  err = AVERROR(ENOMEM);
362  av_free(ref_data);
363  goto end;
364  }
365 
366  vsframe = vs->vsapi->getFrame(vs->current_frame, vs->outnode, vserr, sizeof(vserr));
367  if (!vsframe) {
368  av_log(s, AV_LOG_ERROR, "Error getting frame: %s\n", vserr);
369  err = AVERROR_EXTERNAL;
370  goto end;
371  }
372 
373  ref_data->vsapi = vs->vsapi;
374  ref_data->frame = vsframe;
375 
376  ref_data->vss_state = av_buffer_ref(vs->vss_state);
377  if (!ref_data->vss_state) {
378  err = AVERROR(ENOMEM);
379  goto end;
380  }
381 
382  props = vs->vsapi->getFramePropsRO(vsframe);
383 
384  frame = av_frame_alloc();
385  if (!frame) {
386  err = AVERROR(ENOMEM);
387  goto end;
388  }
389 
390  frame->format = st->codecpar->format;
391  frame->width = st->codecpar->width;
392  frame->height = st->codecpar->height;
394 
395  // Values according to ISO/IEC 14496-10.
396  frame->colorspace = get_vs_prop_int(s, props, "_Matrix", frame->colorspace);
397  frame->color_primaries = get_vs_prop_int(s, props, "_Primaries", frame->color_primaries);
398  frame->color_trc = get_vs_prop_int(s, props, "_Transfer", frame->color_trc);
399 
400  if (get_vs_prop_int(s, props, "_ColorRange", 1) == 0)
402 
403  frame->sample_aspect_ratio.num = get_vs_prop_int(s, props, "_SARNum", 0);
404  frame->sample_aspect_ratio.den = get_vs_prop_int(s, props, "_SARDen", 1);
405 
406  av_assert0(vs->vsapi->getFrameWidth(vsframe, 0) == frame->width);
407  av_assert0(vs->vsapi->getFrameHeight(vsframe, 0) == frame->height);
408 
410 
411  for (i = 0; i < info->format->numPlanes; i++) {
412  int p = vs->c_order[i];
413  ptrdiff_t plane_h = frame->height;
414 
415  frame->data[i] = (void *)vs->vsapi->getReadPtr(vsframe, p);
416  frame->linesize[i] = vs->vsapi->getStride(vsframe, p);
417 
418  frame->buf[i] = av_buffer_ref(vsframe_ref);
419  if (!frame->buf[i]) {
420  err = AVERROR(ENOMEM);
421  goto end;
422  }
423 
424  // Each plane needs an AVBufferRef that indicates the correct plane
425  // memory range. VapourSynth doesn't even give us the memory range,
426  // so make up a bad guess to make FFmpeg happy (even if almost nothing
427  // checks the memory range).
428  if (i == 1 || i == 2)
429  plane_h = AV_CEIL_RSHIFT(plane_h, desc->log2_chroma_h);
430  frame->buf[i]->data = frame->data[i];
431  frame->buf[i]->size = frame->linesize[i] * plane_h;
432  }
433 
434  pkt->buf = av_buffer_create((uint8_t*)frame, sizeof(*frame),
435  free_frame, NULL, 0);
436  if (!pkt->buf) {
437  err = AVERROR(ENOMEM);
438  goto end;
439  }
440 
441  frame = NULL; // pkt owns it now
442 
443  pkt->data = pkt->buf->data;
444  pkt->size = pkt->buf->size;
446 
447  if (vs->is_cfr)
448  pkt->pts = vs->current_frame;
449 
450  vs->current_frame++;
451 
452 end:
454  av_buffer_unref(&vsframe_ref);
455  return err;
456 }
457 
458 static int read_seek_vs(AVFormatContext *s, int stream_idx, int64_t ts, int flags)
459 {
460  VSContext *vs = s->priv_data;
461 
462  if (!vs->is_cfr)
463  return AVERROR(ENOSYS);
464 
465  vs->current_frame = FFMIN(FFMAX(0, ts), s->streams[0]->duration);
466  return 0;
467 }
468 
469 static av_cold int probe_vs(const AVProbeData *p)
470 {
471  // Explicitly do not support this. VS scripts are written in Python, and
472  // can run arbitrary code on the user's system.
473  return 0;
474 }
475 
476 static const AVClass class_vs = {
477  .class_name = "VapourSynth demuxer",
478  .item_name = av_default_item_name,
479  .option = options,
480  .version = LIBAVUTIL_VERSION_INT,
481 };
482 
484  .name = "vapoursynth",
485  .long_name = NULL_IF_CONFIG_SMALL("VapourSynth demuxer"),
486  .priv_data_size = sizeof(VSContext),
487  .flags_internal = FF_FMT_INIT_CLEANUP,
488  .read_probe = probe_vs,
493  .priv_class = &class_vs,
494 };
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:660
av_pix_fmt_swap_endianness
enum AVPixelFormat av_pix_fmt_swap_endianness(enum AVPixelFormat pix_fmt)
Utility function to swap the endianness of a pixel format.
Definition: pixdesc.c:3023
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:656
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
name
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 just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:46
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:144
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
VSContext::current_frame
int current_frame
Definition: vapoursynth.c:55
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2968
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:158
AVFrame::color_primaries
enum AVColorPrimaries color_primaries
Definition: frame.h:658
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:667
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AVFrame::width
int width
Definition: frame.h:412
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:687
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:251
vsframe_ref_data::vss_state
AVBufferRef * vss_state
Definition: vapoursynth.c:319
data
const char data[16]
Definition: mxf.c:148
av_pix_fmt_desc_next
const AVPixFmtDescriptor * av_pix_fmt_desc_next(const AVPixFmtDescriptor *prev)
Iterate over all pixel format descriptors known to libavutil.
Definition: pixdesc.c:2975
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
OFFSET
#define OFFSET(x)
Definition: vapoursynth.c:63
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
get_vs_prop_int
static int get_vs_prop_int(AVFormatContext *s, const VSMap *map, const char *name, int def)
Definition: vapoursynth.c:306
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:590
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:370
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
free_vss_state
static void free_vss_state(void *opaque, uint8_t *data)
Definition: vapoursynth.c:71
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3008
VSContext::outnode
VSNodeRef * outnode
Definition: vapoursynth.c:53
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *st, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: avformat.c:843
class_vs
static const AVClass class_vs
Definition: vapoursynth.c:476
VSContext::vscore
VSCore * vscore
Definition: vapoursynth.c:51
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
AV_PIX_FMT_FLAG_HWACCEL
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:128
dummy
int dummy
Definition: motion.c:66
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
AVERROR_BUFFER_TOO_SMALL
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
Definition: error.h:53
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:900
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:549
av_cold
#define av_cold
Definition: attributes.h:90
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:41
options
static const AVOption options[]
Definition: vapoursynth.c:66
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
AV_BUFFER_FLAG_READONLY
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
Definition: buffer.h:114
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:121
info
MIPS optimizations info
Definition: mips.txt:2
vsframe_ref_data::vsapi
const VSAPI * vsapi
Definition: vapoursynth.c:317
AV_OPT_TYPE_INT64
@ AV_OPT_TYPE_INT64
Definition: opt.h:226
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
ff_vapoursynth_demuxer
const AVInputFormat ff_vapoursynth_demuxer
Definition: vapoursynth.c:483
VSContext::max_script_size
int64_t max_script_size
Definition: vapoursynth.c:60
read_header_vs
static av_cold int read_header_vs(AVFormatContext *s)
Definition: vapoursynth.c:169
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:147
limits.h
AVPixFmtDescriptor::log2_chroma_w
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
Definition: pixdesc.h:80
AV_CODEC_ID_WRAPPED_AVFRAME
@ AV_CODEC_ID_WRAPPED_AVFRAME
Passthrough codec, AVFrames wrapped in AVPacket.
Definition: codec_id.h:603
frame
static AVFrame * frame
Definition: demux_decode.c:54
AVFormatContext
Format I/O context.
Definition: avformat.h:1363
internal.h
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:505
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:550
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
VSContext::c_order
int c_order[4]
Definition: vapoursynth.c:57
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
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
AVComponentDescriptor
Definition: pixdesc.h:30
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
AVFMTCTX_UNSEEKABLE
#define AVFMTCTX_UNSEEKABLE
signal that the stream is definitely not seekable, and attempts to call the seek function will fail.
Definition: avformat.h:1316
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:452
VSContext::vsapi
const VSAPI * vsapi
Definition: vapoursynth.c:50
AVCOL_SPC_YCGCO
@ AVCOL_SPC_YCGCO
used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
Definition: pixfmt.h:622
read_seek_vs
static int read_seek_vs(AVFormatContext *s, int stream_idx, int64_t ts, int flags)
Definition: vapoursynth.c:458
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
is_native_endian
static av_cold int is_native_endian(enum AVPixelFormat pixfmt)
Definition: vapoursynth.c:97
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
VSState::vss
VSScript * vss
Definition: vapoursynth.c:42
eval.h
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
AVPacket::size
int size
Definition: packet.h:523
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:106
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:136
AV_PIX_FMT_FLAG_BITSTREAM
#define AV_PIX_FMT_FLAG_BITSTREAM
All values of a component are bit-wise packed end to end.
Definition: pixdesc.h:124
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:427
VSContext::vss_state
AVBufferRef * vss_state
Definition: vapoursynth.c:48
frame.h
read_close_vs
static av_cold int read_close_vs(AVFormatContext *s)
Definition: vapoursynth.c:81
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
av_pix_fmt_desc_get_id
enum AVPixelFormat av_pix_fmt_desc_get_id(const AVPixFmtDescriptor *desc)
Definition: pixdesc.c:2987
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
AVBufferRef::size
size_t size
Size of data in bytes.
Definition: buffer.h:94
AV_PIX_FMT_FLAG_BAYER
#define AV_PIX_FMT_FLAG_BAYER
The pixel format is following a Bayer pattern.
Definition: pixdesc.h:152
free_frame
static void free_frame(void *opaque, uint8_t *data)
Definition: vapoursynth.c:299
VSContext::is_cfr
int is_cfr
Definition: vapoursynth.c:54
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
read_packet_vs
static int read_packet_vs(AVFormatContext *s, AVPacket *pkt)
Definition: vapoursynth.c:334
AVCodecParameters::height
int height
Definition: codec_par.h:122
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
VSContext
Definition: vapoursynth.c:45
match_pixfmt
static av_cold enum AVPixelFormat match_pixfmt(const VSFormat *vsf, int c_order[4])
Definition: vapoursynth.c:107
AVStream
Stream structure.
Definition: avformat.h:841
pixfmt
enum AVPixelFormat pixfmt
Definition: kmsgrab.c:365
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:71
avformat.h
AVFrame::sample_aspect_ratio
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:447
A
#define A
Definition: vapoursynth.c:64
AVFrame::height
int height
Definition: frame.h:412
probe_vs
static av_cold int probe_vs(const AVProbeData *p)
Definition: vapoursynth.c:469
AV_PIX_FMT_FLAG_XYZ
#define AV_PIX_FMT_FLAG_XYZ
The pixel format contains XYZ-like data (as opposed to YUV/RGB/grayscale).
Definition: pixdesc.h:163
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:659
vsframe_ref_data
Definition: vapoursynth.c:316
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
read_probe
static int read_probe(const AVProbeData *p)
Definition: cdg.c:29
D
#define D
Definition: vapoursynth.c:65
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVCodecParameters::format
int format
Definition: codec_par.h:79
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:499
vsframe_ref_data::frame
const VSFrameRef * frame
Definition: vapoursynth.c:318
d
d
Definition: ffmpeg_filter.c:424
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
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:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
avstring.h
AV_PKT_FLAG_TRUSTED
#define AV_PKT_FLAG_TRUSTED
The packet comes from a trusted source.
Definition: packet.h:591
VSState
Definition: vapoursynth.c:41
AVPixFmtDescriptor::log2_chroma_h
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
Definition: pixdesc.h:89
free_vsframe_ref
static void free_vsframe_ref(void *opaque, uint8_t *data)
Definition: vapoursynth.c:322
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:2888