FFmpeg
avisynth.c
Go to the documentation of this file.
1 /*
2  * AviSynth(+) support
3  * Copyright (c) 2012 AvxSynth Team
4  *
5  * This file is part of FFmpeg
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "libavutil/attributes.h"
23 #include "libavutil/internal.h"
24 #include "libavutil/mem.h"
25 #include "libavutil/opt.h"
26 #include "libavutil/thread.h"
27 
28 #include "avformat.h"
29 #include "demux.h"
30 #include "internal.h"
31 #include "config.h"
32 
33 /* Enable function pointer definitions for runtime loading. */
34 #define AVSC_NO_DECLSPEC
35 
36 /* Platform-specific directives. */
37 #ifdef _WIN32
38  #include "compat/w32dlfcn.h"
39  #include "libavutil/wchar_filename.h"
40  #undef EXTERN_C
41  #define AVISYNTH_LIB "avisynth"
42 #else
43  #include <dlfcn.h>
44  #define AVISYNTH_NAME "libavisynth"
45  #define AVISYNTH_LIB AVISYNTH_NAME SLIBSUF
46 #endif
47 
48 /* Endianness guards for audio */
49 #if HAVE_BIGENDIAN
50  #define PCM(format) (AV_CODEC_ID_PCM_ ## format ## BE)
51 #else
52  #define PCM(format) (AV_CODEC_ID_PCM_ ## format ## LE)
53 #endif
54 
55 #include <avisynth/avisynth_c.h>
56 
57 typedef struct AviSynthLibrary {
58  void *library;
59 #define AVSC_DECLARE_FUNC(name) name ## _func name
60  AVSC_DECLARE_FUNC(avs_bit_blt);
61  AVSC_DECLARE_FUNC(avs_clip_get_error);
62  AVSC_DECLARE_FUNC(avs_check_version);
63  AVSC_DECLARE_FUNC(avs_create_script_environment);
64  AVSC_DECLARE_FUNC(avs_delete_script_environment);
65  AVSC_DECLARE_FUNC(avs_get_audio);
66  AVSC_DECLARE_FUNC(avs_get_channel_mask);
67  AVSC_DECLARE_FUNC(avs_get_error);
68  AVSC_DECLARE_FUNC(avs_get_frame);
69  AVSC_DECLARE_FUNC(avs_get_version);
70  AVSC_DECLARE_FUNC(avs_get_video_info);
71  AVSC_DECLARE_FUNC(avs_invoke);
72  AVSC_DECLARE_FUNC(avs_is_color_space);
73  AVSC_DECLARE_FUNC(avs_release_clip);
74  AVSC_DECLARE_FUNC(avs_release_value);
75  AVSC_DECLARE_FUNC(avs_release_video_frame);
76  AVSC_DECLARE_FUNC(avs_take_clip);
77  AVSC_DECLARE_FUNC(avs_bits_per_pixel);
78  AVSC_DECLARE_FUNC(avs_get_height_p);
79  AVSC_DECLARE_FUNC(avs_get_pitch_p);
80  AVSC_DECLARE_FUNC(avs_get_read_ptr_p);
81  AVSC_DECLARE_FUNC(avs_get_row_size_p);
82  AVSC_DECLARE_FUNC(avs_is_planar_rgb);
83  AVSC_DECLARE_FUNC(avs_is_planar_rgba);
84  AVSC_DECLARE_FUNC(avs_get_frame_props_ro);
85  AVSC_DECLARE_FUNC(avs_prop_get_int);
86  AVSC_DECLARE_FUNC(avs_prop_get_type);
87  AVSC_DECLARE_FUNC(avs_get_env_property);
88 #undef AVSC_DECLARE_FUNC
89 } AviSynthLibrary;
90 
91 typedef enum AviSynthFlags {
92  AVISYNTH_FRAMEPROP_FIELD_ORDER = (1 << 0),
93  AVISYNTH_FRAMEPROP_RANGE = (1 << 1),
94  AVISYNTH_FRAMEPROP_PRIMARIES = (1 << 2),
95  AVISYNTH_FRAMEPROP_TRANSFER = (1 << 3),
96  AVISYNTH_FRAMEPROP_MATRIX = (1 << 4),
97  AVISYNTH_FRAMEPROP_CHROMA_LOCATION = (1 << 5),
98  AVISYNTH_FRAMEPROP_SAR = (1 << 6),
99 } AviSynthFlags;
100 
101 typedef struct AviSynthContext {
102  const AVClass *class;
103  AVS_ScriptEnvironment *env;
104  AVS_Clip *clip;
105  const AVS_VideoInfo *vi;
106 
107  /* avisynth_read_packet_video() iterates over this. */
108  int n_planes;
109  const int *planes;
110 
111  int curr_stream;
112  int curr_frame;
113  int64_t curr_sample;
114 
115  int error;
116 
117  uint32_t flags;
118  struct AviSynthLibrary avs_library;
119 } AviSynthContext;
120 
121 static av_cold int avisynth_load_library(AviSynthContext *avs)
122 {
123  avs->avs_library.library = dlopen(AVISYNTH_LIB, RTLD_NOW | RTLD_LOCAL);
124  if (!avs->avs_library.library)
125  return AVERROR_UNKNOWN;
126 
127 #define LOAD_AVS_FUNC(name, continue_on_fail) \
128  avs->avs_library.name = (name ## _func) \
129  dlsym(avs->avs_library.library, #name); \
130  if (!continue_on_fail && !avs->avs_library.name) \
131  goto fail;
132 
133  LOAD_AVS_FUNC(avs_bit_blt, 0);
134  LOAD_AVS_FUNC(avs_clip_get_error, 0);
135  LOAD_AVS_FUNC(avs_check_version, 0);
136  LOAD_AVS_FUNC(avs_create_script_environment, 0);
137  LOAD_AVS_FUNC(avs_delete_script_environment, 0);
138  LOAD_AVS_FUNC(avs_get_audio, 0);
139  LOAD_AVS_FUNC(avs_get_channel_mask, 1);
140  LOAD_AVS_FUNC(avs_get_error, 1); // New to AviSynth 2.6
141  LOAD_AVS_FUNC(avs_get_frame, 0);
142  LOAD_AVS_FUNC(avs_get_version, 0);
143  LOAD_AVS_FUNC(avs_get_video_info, 0);
144  LOAD_AVS_FUNC(avs_invoke, 0);
145  LOAD_AVS_FUNC(avs_is_color_space, 1);
146  LOAD_AVS_FUNC(avs_release_clip, 0);
147  LOAD_AVS_FUNC(avs_release_value, 0);
148  LOAD_AVS_FUNC(avs_release_video_frame, 0);
149  LOAD_AVS_FUNC(avs_take_clip, 0);
150  LOAD_AVS_FUNC(avs_bits_per_pixel, 1);
151  LOAD_AVS_FUNC(avs_get_height_p, 1);
152  LOAD_AVS_FUNC(avs_get_pitch_p, 1);
153  LOAD_AVS_FUNC(avs_get_read_ptr_p, 1);
154  LOAD_AVS_FUNC(avs_get_row_size_p, 1);
155  LOAD_AVS_FUNC(avs_is_planar_rgb, 1);
156  LOAD_AVS_FUNC(avs_is_planar_rgba, 1);
157  LOAD_AVS_FUNC(avs_get_frame_props_ro, 1);
158  LOAD_AVS_FUNC(avs_prop_get_int, 1);
159  LOAD_AVS_FUNC(avs_prop_get_type, 1);
160  LOAD_AVS_FUNC(avs_get_env_property, 1);
161 #undef LOAD_AVS_FUNC
162 
163  return 0;
164 
165 fail:
166  dlclose(avs->avs_library.library);
167  return AVERROR_UNKNOWN;
168 }
169 
170 /* Note that avisynth_context_create and avisynth_context_destroy
171  * do not allocate or free the actual context! That is taken care of
172  * by libavformat. */
173 static av_cold int avisynth_context_create(AVFormatContext *s)
174 {
175  AviSynthContext *avs = s->priv_data;
176  int ret;
177 
178  if (!avs->avs_library.library)
179  if (ret = avisynth_load_library(avs))
180  return ret;
181 
182  avs->env = avs->avs_library.avs_create_script_environment(3);
183  if (avs->avs_library.avs_get_error) {
184  const char *error = avs->avs_library.avs_get_error(avs->env);
185  if (error) {
186  av_log(s, AV_LOG_ERROR, "%s\n", error);
187  return AVERROR_UNKNOWN;
188  }
189  }
190 
191  return 0;
192 }
193 
194 static av_cold void avisynth_context_destroy(AviSynthContext *avs)
195 {
196  if (avs->clip) {
197  avs->avs_library.avs_release_clip(avs->clip);
198  avs->clip = NULL;
199  }
200  if (avs->env) {
201  avs->avs_library.avs_delete_script_environment(avs->env);
202  avs->env = NULL;
203  }
204 }
205 
206 /* Create AVStream from audio and video data. */
207 static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
208 {
209  AviSynthContext *avs = s->priv_data;
210  const AVS_Map *avsmap;
211  AVS_VideoFrame *frame;
212  int error;
213  int planar = 0; // 0: packed, 1: YUV, 2: Y8, 3: Planar RGB, 4: YUVA, 5: Planar RGBA
214  int sar_num = 1;
215  int sar_den = 1;
216 
217  static const int avs_planes_packed[1] = { 0 };
218  static const int avs_planes_grey[1] = { AVS_PLANAR_Y };
219  static const int avs_planes_yuv[3] = { AVS_PLANAR_Y, AVS_PLANAR_U,
220  AVS_PLANAR_V };
221  static const int avs_planes_rgb[3] = { AVS_PLANAR_G, AVS_PLANAR_B,
222  AVS_PLANAR_R };
223  static const int avs_planes_yuva[4] = { AVS_PLANAR_Y, AVS_PLANAR_U,
224  AVS_PLANAR_V, AVS_PLANAR_A };
225  static const int avs_planes_rgba[4] = { AVS_PLANAR_G, AVS_PLANAR_B,
226  AVS_PLANAR_R, AVS_PLANAR_A };
227 
228  st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
229  st->codecpar->codec_id = AV_CODEC_ID_RAWVIDEO;
230  st->codecpar->width = avs->vi->width;
231  st->codecpar->height = avs->vi->height;
232 
233  st->avg_frame_rate = (AVRational) { avs->vi->fps_numerator,
234  avs->vi->fps_denominator };
235  st->start_time = 0;
236  st->duration = avs->vi->num_frames;
237  st->nb_frames = avs->vi->num_frames;
238  avpriv_set_pts_info(st, 32, avs->vi->fps_denominator, avs->vi->fps_numerator);
239 
240 
241  switch (avs->vi->pixel_type) {
242  /* 10~16-bit YUV pix_fmts (AviSynth+) */
243  case AVS_CS_YUV444P10:
244  st->codecpar->format = AV_PIX_FMT_YUV444P10;
245  planar = 1;
246  break;
247  case AVS_CS_YUV422P10:
248  st->codecpar->format = AV_PIX_FMT_YUV422P10;
249  planar = 1;
250  break;
251  case AVS_CS_YUV420P10:
252  st->codecpar->format = AV_PIX_FMT_YUV420P10;
253  planar = 1;
254  break;
255  case AVS_CS_YUV444P12:
256  st->codecpar->format = AV_PIX_FMT_YUV444P12;
257  planar = 1;
258  break;
259  case AVS_CS_YUV422P12:
260  st->codecpar->format = AV_PIX_FMT_YUV422P12;
261  planar = 1;
262  break;
263  case AVS_CS_YUV420P12:
264  st->codecpar->format = AV_PIX_FMT_YUV420P12;
265  planar = 1;
266  break;
267  case AVS_CS_YUV444P14:
268  st->codecpar->format = AV_PIX_FMT_YUV444P14;
269  planar = 1;
270  break;
271  case AVS_CS_YUV422P14:
272  st->codecpar->format = AV_PIX_FMT_YUV422P14;
273  planar = 1;
274  break;
275  case AVS_CS_YUV420P14:
276  st->codecpar->format = AV_PIX_FMT_YUV420P14;
277  planar = 1;
278  break;
279  case AVS_CS_YUV444P16:
280  st->codecpar->format = AV_PIX_FMT_YUV444P16;
281  planar = 1;
282  break;
283  case AVS_CS_YUV422P16:
284  st->codecpar->format = AV_PIX_FMT_YUV422P16;
285  planar = 1;
286  break;
287  case AVS_CS_YUV420P16:
288  st->codecpar->format = AV_PIX_FMT_YUV420P16;
289  planar = 1;
290  break;
291  /* 8~16-bit YUV pix_fmts with Alpha (AviSynth+) */
292  case AVS_CS_YUVA444:
293  st->codecpar->format = AV_PIX_FMT_YUVA444P;
294  planar = 4;
295  break;
296  case AVS_CS_YUVA422:
297  st->codecpar->format = AV_PIX_FMT_YUVA422P;
298  planar = 4;
299  break;
300  case AVS_CS_YUVA420:
301  st->codecpar->format = AV_PIX_FMT_YUVA420P;
302  planar = 4;
303  break;
304  case AVS_CS_YUVA444P10:
305  st->codecpar->format = AV_PIX_FMT_YUVA444P10;
306  planar = 4;
307  break;
308  case AVS_CS_YUVA422P10:
309  st->codecpar->format = AV_PIX_FMT_YUVA422P10;
310  planar = 4;
311  break;
312  case AVS_CS_YUVA420P10:
313  st->codecpar->format = AV_PIX_FMT_YUVA420P10;
314  planar = 4;
315  break;
316  case AVS_CS_YUVA422P12:
317  st->codecpar->format = AV_PIX_FMT_YUVA422P12;
318  planar = 4;
319  break;
320  case AVS_CS_YUVA444P16:
321  st->codecpar->format = AV_PIX_FMT_YUVA444P16;
322  planar = 4;
323  break;
324  case AVS_CS_YUVA422P16:
325  st->codecpar->format = AV_PIX_FMT_YUVA422P16;
326  planar = 4;
327  break;
328  case AVS_CS_YUVA420P16:
329  st->codecpar->format = AV_PIX_FMT_YUVA420P16;
330  planar = 4;
331  break;
332  /* Planar RGB pix_fmts (AviSynth+) */
333  case AVS_CS_RGBP:
334  st->codecpar->format = AV_PIX_FMT_GBRP;
335  planar = 3;
336  break;
337  case AVS_CS_RGBP10:
338  st->codecpar->format = AV_PIX_FMT_GBRP10;
339  planar = 3;
340  break;
341  case AVS_CS_RGBP12:
342  st->codecpar->format = AV_PIX_FMT_GBRP12;
343  planar = 3;
344  break;
345  case AVS_CS_RGBP14:
346  st->codecpar->format = AV_PIX_FMT_GBRP14;
347  planar = 3;
348  break;
349  case AVS_CS_RGBP16:
350  st->codecpar->format = AV_PIX_FMT_GBRP16;
351  planar = 3;
352  break;
353  /* Single precision floating point Planar RGB (AviSynth+) */
354  case AVS_CS_RGBPS:
355  st->codecpar->format = AV_PIX_FMT_GBRPF32;
356  planar = 3;
357  break;
358  /* Planar RGB pix_fmts with Alpha (AviSynth+) */
359  case AVS_CS_RGBAP:
360  st->codecpar->format = AV_PIX_FMT_GBRAP;
361  planar = 5;
362  break;
363  case AVS_CS_RGBAP10:
364  st->codecpar->format = AV_PIX_FMT_GBRAP10;
365  planar = 5;
366  break;
367  case AVS_CS_RGBAP12:
368  st->codecpar->format = AV_PIX_FMT_GBRAP12;
369  planar = 5;
370  break;
371  case AVS_CS_RGBAP16:
372  st->codecpar->format = AV_PIX_FMT_GBRAP16;
373  planar = 5;
374  break;
375  /* Single precision floating point Planar RGB with Alpha (AviSynth+) */
376  case AVS_CS_RGBAPS:
377  st->codecpar->format = AV_PIX_FMT_GBRAPF32;
378  planar = 5;
379  break;
380  /* 10~16-bit gray pix_fmts (AviSynth+) */
381  case AVS_CS_Y10:
382  st->codecpar->format = AV_PIX_FMT_GRAY10;
383  planar = 2;
384  break;
385  case AVS_CS_Y12:
386  st->codecpar->format = AV_PIX_FMT_GRAY12;
387  planar = 2;
388  break;
389  case AVS_CS_Y14:
390  st->codecpar->format = AV_PIX_FMT_GRAY14;
391  planar = 2;
392  break;
393  case AVS_CS_Y16:
394  st->codecpar->format = AV_PIX_FMT_GRAY16;
395  planar = 2;
396  break;
397  /* Single precision floating point gray (AviSynth+) */
398  case AVS_CS_Y32:
399  st->codecpar->format = AV_PIX_FMT_GRAYF32;
400  planar = 2;
401  break;
402  /* pix_fmts added in AviSynth 2.6 */
403  case AVS_CS_YV24:
404  st->codecpar->format = AV_PIX_FMT_YUV444P;
405  planar = 1;
406  break;
407  case AVS_CS_YV16:
408  st->codecpar->format = AV_PIX_FMT_YUV422P;
409  planar = 1;
410  break;
411  case AVS_CS_YV411:
412  st->codecpar->format = AV_PIX_FMT_YUV411P;
413  planar = 1;
414  break;
415  case AVS_CS_Y8:
416  st->codecpar->format = AV_PIX_FMT_GRAY8;
417  planar = 2;
418  break;
419  /* 16-bit packed RGB pix_fmts (AviSynth+) */
420  case AVS_CS_BGR48:
421  st->codecpar->format = AV_PIX_FMT_BGR48;
422  break;
423  case AVS_CS_BGR64:
424  st->codecpar->format = AV_PIX_FMT_BGRA64;
425  break;
426  /* AviSynth 2.5 pix_fmts */
427  case AVS_CS_BGR24:
428  st->codecpar->format = AV_PIX_FMT_BGR24;
429  break;
430  case AVS_CS_BGR32:
431  st->codecpar->format = AV_PIX_FMT_RGB32;
432  break;
433  case AVS_CS_YUY2:
434  st->codecpar->format = AV_PIX_FMT_YUYV422;
435  break;
436  case AVS_CS_YV12:
437  st->codecpar->format = AV_PIX_FMT_YUV420P;
438  planar = 1;
439  break;
440  case AVS_CS_I420: // Is this even used anywhere?
441  st->codecpar->format = AV_PIX_FMT_YUV420P;
442  planar = 1;
443  break;
444  default:
445  av_log(s, AV_LOG_ERROR,
446  "unknown AviSynth colorspace %d\n", avs->vi->pixel_type);
447  avs->error = 1;
448  return AVERROR_UNKNOWN;
449  }
450 
451  switch (planar) {
452  case 5: // Planar RGB + Alpha
453  avs->n_planes = 4;
454  avs->planes = avs_planes_rgba;
455  break;
456  case 4: // YUV + Alpha
457  avs->n_planes = 4;
458  avs->planes = avs_planes_yuva;
459  break;
460  case 3: // Planar RGB
461  avs->n_planes = 3;
462  avs->planes = avs_planes_rgb;
463  break;
464  case 2: // Y8
465  avs->n_planes = 1;
466  avs->planes = avs_planes_grey;
467  break;
468  case 1: // YUV
469  avs->n_planes = 3;
470  avs->planes = avs_planes_yuv;
471  break;
472  default:
473  avs->n_planes = 1;
474  avs->planes = avs_planes_packed;
475  }
476 
477  /* Read AviSynth+'s frame properties to set additional info.
478  *
479  * Due to a bug preventing the C interface from accessing frame
480  * properties in earlier versions of interface version 8, and
481  * previous attempts at being clever resulting in pre-8 versions
482  * of AviSynth+ segfaulting, only enable this if we detect
483  * version 9 at the minimum. Technically, 8.1 works, but the time
484  * distance between 8.1 and 9 is very small, so just restrict it to 9. */
485 
486  if (avs->avs_library.avs_get_version(avs->clip) >= 9) {
487 
488  frame = avs->avs_library.avs_get_frame(avs->clip, 0);
489  avsmap = avs->avs_library.avs_get_frame_props_ro(avs->env, frame);
490 
491  /* Field order */
492  if(avs->flags & AVISYNTH_FRAMEPROP_FIELD_ORDER) {
493  if(avs->avs_library.avs_prop_get_type(avs->env, avsmap, "_FieldBased") == AVS_PROPTYPE_UNSET) {
494  st->codecpar->field_order = AV_FIELD_UNKNOWN;
495  } else {
496  switch (avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_FieldBased", 0, &error)) {
497  case 0:
498  st->codecpar->field_order = AV_FIELD_PROGRESSIVE;
499  break;
500  case 1:
501  st->codecpar->field_order = AV_FIELD_BB;
502  break;
503  case 2:
504  st->codecpar->field_order = AV_FIELD_TT;
505  break;
506  default:
507  st->codecpar->field_order = AV_FIELD_UNKNOWN;
508  }
509  }
510  }
511 
512  /* Color Range */
513  if(avs->flags & AVISYNTH_FRAMEPROP_RANGE) {
514  if(avs->avs_library.avs_prop_get_type(avs->env, avsmap, "_ColorRange") == AVS_PROPTYPE_UNSET) {
515  st->codecpar->color_range = AVCOL_RANGE_UNSPECIFIED;
516  } else {
517  switch (avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_ColorRange", 0, &error)) {
518  case 0:
519  st->codecpar->color_range = AVCOL_RANGE_JPEG;
520  break;
521  case 1:
522  st->codecpar->color_range = AVCOL_RANGE_MPEG;
523  break;
524  default:
525  st->codecpar->color_range = AVCOL_RANGE_UNSPECIFIED;
526  }
527  }
528  }
529 
530  /* Color Primaries */
531  if(avs->flags & AVISYNTH_FRAMEPROP_PRIMARIES) {
532  switch (avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_Primaries", 0, &error)) {
533  case 1:
534  st->codecpar->color_primaries = AVCOL_PRI_BT709;
535  break;
536  case 2:
537  st->codecpar->color_primaries = AVCOL_PRI_UNSPECIFIED;
538  break;
539  case 4:
540  st->codecpar->color_primaries = AVCOL_PRI_BT470M;
541  break;
542  case 5:
543  st->codecpar->color_primaries = AVCOL_PRI_BT470BG;
544  break;
545  case 6:
546  st->codecpar->color_primaries = AVCOL_PRI_SMPTE170M;
547  break;
548  case 7:
549  st->codecpar->color_primaries = AVCOL_PRI_SMPTE240M;
550  break;
551  case 8:
552  st->codecpar->color_primaries = AVCOL_PRI_FILM;
553  break;
554  case 9:
555  st->codecpar->color_primaries = AVCOL_PRI_BT2020;
556  break;
557  case 10:
558  st->codecpar->color_primaries = AVCOL_PRI_SMPTE428;
559  break;
560  case 11:
561  st->codecpar->color_primaries = AVCOL_PRI_SMPTE431;
562  break;
563  case 12:
564  st->codecpar->color_primaries = AVCOL_PRI_SMPTE432;
565  break;
566  case 22:
567  st->codecpar->color_primaries = AVCOL_PRI_EBU3213;
568  break;
569  default:
570  st->codecpar->color_primaries = AVCOL_PRI_UNSPECIFIED;
571  }
572  }
573 
574  /* Color Transfer Characteristics */
575  if(avs->flags & AVISYNTH_FRAMEPROP_TRANSFER) {
576  switch (avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_Transfer", 0, &error)) {
577  case 1:
578  st->codecpar->color_trc = AVCOL_TRC_BT709;
579  break;
580  case 2:
581  st->codecpar->color_trc = AVCOL_TRC_UNSPECIFIED;
582  break;
583  case 4:
584  st->codecpar->color_trc = AVCOL_TRC_GAMMA22;
585  break;
586  case 5:
587  st->codecpar->color_trc = AVCOL_TRC_GAMMA28;
588  break;
589  case 6:
590  st->codecpar->color_trc = AVCOL_TRC_SMPTE170M;
591  break;
592  case 7:
593  st->codecpar->color_trc = AVCOL_TRC_SMPTE240M;
594  break;
595  case 8:
596  st->codecpar->color_trc = AVCOL_TRC_LINEAR;
597  break;
598  case 9:
599  st->codecpar->color_trc = AVCOL_TRC_LOG;
600  break;
601  case 10:
602  st->codecpar->color_trc = AVCOL_TRC_LOG_SQRT;
603  break;
604  case 11:
605  st->codecpar->color_trc = AVCOL_TRC_IEC61966_2_4;
606  break;
607  case 12:
608  st->codecpar->color_trc = AVCOL_TRC_BT1361_ECG;
609  break;
610  case 13:
611  st->codecpar->color_trc = AVCOL_TRC_IEC61966_2_1;
612  break;
613  case 14:
614  st->codecpar->color_trc = AVCOL_TRC_BT2020_10;
615  break;
616  case 15:
617  st->codecpar->color_trc = AVCOL_TRC_BT2020_12;
618  break;
619  case 16:
620  st->codecpar->color_trc = AVCOL_TRC_SMPTE2084;
621  break;
622  case 17:
623  st->codecpar->color_trc = AVCOL_TRC_SMPTE428;
624  break;
625  case 18:
626  st->codecpar->color_trc = AVCOL_TRC_ARIB_STD_B67;
627  break;
628  default:
629  st->codecpar->color_trc = AVCOL_TRC_UNSPECIFIED;
630  }
631  }
632 
633  /* Matrix coefficients */
634  if(avs->flags & AVISYNTH_FRAMEPROP_MATRIX) {
635  if(avs->avs_library.avs_prop_get_type(avs->env, avsmap, "_Matrix") == AVS_PROPTYPE_UNSET) {
636  st->codecpar->color_space = AVCOL_SPC_UNSPECIFIED;
637  } else {
638  switch (avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_Matrix", 0, &error)) {
639  case 0:
640  st->codecpar->color_space = AVCOL_SPC_RGB;
641  break;
642  case 1:
643  st->codecpar->color_space = AVCOL_SPC_BT709;
644  break;
645  case 2:
646  st->codecpar->color_space = AVCOL_SPC_UNSPECIFIED;
647  break;
648  case 4:
649  st->codecpar->color_space = AVCOL_SPC_FCC;
650  break;
651  case 5:
652  st->codecpar->color_space = AVCOL_SPC_BT470BG;
653  break;
654  case 6:
655  st->codecpar->color_space = AVCOL_SPC_SMPTE170M;
656  break;
657  case 7:
658  st->codecpar->color_space = AVCOL_SPC_SMPTE240M;
659  break;
660  case 8:
661  st->codecpar->color_space = AVCOL_SPC_YCGCO;
662  break;
663  case 9:
664  st->codecpar->color_space = AVCOL_SPC_BT2020_NCL;
665  break;
666  case 10:
667  st->codecpar->color_space = AVCOL_SPC_BT2020_CL;
668  break;
669  case 11:
670  st->codecpar->color_space = AVCOL_SPC_SMPTE2085;
671  break;
672  case 12:
673  st->codecpar->color_space = AVCOL_SPC_CHROMA_DERIVED_NCL;
674  break;
675  case 13:
676  st->codecpar->color_space = AVCOL_SPC_CHROMA_DERIVED_CL;
677  break;
678  case 14:
679  st->codecpar->color_space = AVCOL_SPC_ICTCP;
680  break;
681  default:
682  st->codecpar->color_space = AVCOL_SPC_UNSPECIFIED;
683  }
684  }
685  }
686 
687  /* Chroma Location */
688  if(avs->flags & AVISYNTH_FRAMEPROP_CHROMA_LOCATION) {
689  if(avs->avs_library.avs_prop_get_type(avs->env, avsmap, "_ChromaLocation") == AVS_PROPTYPE_UNSET) {
690  st->codecpar->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
691  } else {
692  switch (avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_ChromaLocation", 0, &error)) {
693  case 0:
694  st->codecpar->chroma_location = AVCHROMA_LOC_LEFT;
695  break;
696  case 1:
697  st->codecpar->chroma_location = AVCHROMA_LOC_CENTER;
698  break;
699  case 2:
700  st->codecpar->chroma_location = AVCHROMA_LOC_TOPLEFT;
701  break;
702  case 3:
703  st->codecpar->chroma_location = AVCHROMA_LOC_TOP;
704  break;
705  case 4:
706  st->codecpar->chroma_location = AVCHROMA_LOC_BOTTOMLEFT;
707  break;
708  case 5:
709  st->codecpar->chroma_location = AVCHROMA_LOC_BOTTOM;
710  break;
711  default:
712  st->codecpar->chroma_location = AVCHROMA_LOC_UNSPECIFIED;
713  }
714  }
715  }
716 
717  /* Sample aspect ratio */
718  if(avs->flags & AVISYNTH_FRAMEPROP_SAR) {
719  sar_num = avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_SARNum", 0, &error);
720  sar_den = avs->avs_library.avs_prop_get_int(avs->env, avsmap, "_SARDen", 0, &error);
721  st->sample_aspect_ratio = (AVRational){ sar_num, sar_den };
722  }
723 
724  avs->avs_library.avs_release_video_frame(frame);
725  } else {
726  st->codecpar->field_order = AV_FIELD_UNKNOWN;
727  /* AviSynth works with frame-based video, detecting field order can
728  * only work when avs_is_field_based returns 'false'. */
729  av_log(s, AV_LOG_TRACE, "avs_is_field_based: %d\n", avs_is_field_based(avs->vi));
730  if (avs_is_field_based(avs->vi) == 0) {
731  if (avs_is_tff(avs->vi)) {
732  st->codecpar->field_order = AV_FIELD_TT;
733  }
734  else if (avs_is_bff(avs->vi)) {
735  st->codecpar->field_order = AV_FIELD_BB;
736  }
737  }
738  }
739 
740  return 0;
741 }
742 
743 static int avisynth_create_stream_audio(AVFormatContext *s, AVStream *st)
744 {
745  AviSynthContext *avs = s->priv_data;
746 
747  st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
748  st->codecpar->sample_rate = avs->vi->audio_samples_per_second;
749  st->codecpar->ch_layout.nb_channels = avs->vi->nchannels;
750  st->duration = avs->vi->num_audio_samples;
751  avpriv_set_pts_info(st, 64, 1, avs->vi->audio_samples_per_second);
752 
753  if (avs->avs_library.avs_get_version(avs->clip) >= 10)
754  av_channel_layout_from_mask(&st->codecpar->ch_layout,
755  avs->avs_library.avs_get_channel_mask(avs->vi));
756 
757  switch (avs->vi->sample_type) {
758  case AVS_SAMPLE_INT8:
759  st->codecpar->codec_id = AV_CODEC_ID_PCM_U8;
760  break;
761  case AVS_SAMPLE_INT16:
762  st->codecpar->codec_id = PCM(S16);
763  break;
764  case AVS_SAMPLE_INT24:
765  st->codecpar->codec_id = PCM(S24);
766  break;
767  case AVS_SAMPLE_INT32:
768  st->codecpar->codec_id = PCM(S32);
769  break;
770  case AVS_SAMPLE_FLOAT:
771  st->codecpar->codec_id = PCM(F32);
772  break;
773  default:
774  av_log(s, AV_LOG_ERROR,
775  "unknown AviSynth sample type %d\n", avs->vi->sample_type);
776  avs->error = 1;
777  return AVERROR_UNKNOWN;
778  }
779  return 0;
780 }
781 
782 static int avisynth_create_stream(AVFormatContext *s)
783 {
784  AviSynthContext *avs = s->priv_data;
785  AVStream *st;
786  int ret;
787  int id = 0;
788 
789  if (avs_has_video(avs->vi)) {
790  st = avformat_new_stream(s, NULL);
791  if (!st)
792  return AVERROR_UNKNOWN;
793  st->id = id++;
794  if (ret = avisynth_create_stream_video(s, st))
795  return ret;
796  }
797  if (avs_has_audio(avs->vi)) {
798  st = avformat_new_stream(s, NULL);
799  if (!st)
800  return AVERROR_UNKNOWN;
801  st->id = id++;
802  if (ret = avisynth_create_stream_audio(s, st))
803  return ret;
804  }
805  return 0;
806 }
807 
808 static int avisynth_open_file(AVFormatContext *s)
809 {
810  AviSynthContext *avs = s->priv_data;
811  AVS_Value val;
812  int ret;
813 
814  if (ret = avisynth_context_create(s))
815  return ret;
816 
817  if (!avs->avs_library.avs_check_version(avs->env, 7)) {
818  AVS_Value args[] = {
819  avs_new_value_string(s->url),
820  avs_new_value_bool(1) // filename is in UTF-8
821  };
822  val = avs->avs_library.avs_invoke(avs->env, "Import",
823  avs_new_value_array(args, 2), 0);
824  } else {
825  AVS_Value arg;
826 #ifdef _WIN32
827  char *filename_ansi;
828  /* Convert UTF-8 to ANSI code page */
829  if (utf8toansi(s->url, &filename_ansi)) {
830  ret = AVERROR_UNKNOWN;
831  goto fail;
832  }
833  arg = avs_new_value_string(filename_ansi);
834 #else
835  arg = avs_new_value_string(s->url);
836 #endif
837  val = avs->avs_library.avs_invoke(avs->env, "Import", arg, 0);
838 #ifdef _WIN32
839  av_free(filename_ansi);
840 #endif
841  }
842 
843  if (avs_is_error(val)) {
844  av_log(s, AV_LOG_ERROR, "%s\n", avs_as_error(val));
845  ret = AVERROR_UNKNOWN;
846  goto fail;
847  }
848  if (!avs_is_clip(val)) {
849  av_log(s, AV_LOG_ERROR, "AviSynth script did not return a clip\n");
850  ret = AVERROR_UNKNOWN;
851  goto fail;
852  }
853 
854  avs->clip = avs->avs_library.avs_take_clip(val, avs->env);
855  avs->vi = avs->avs_library.avs_get_video_info(avs->clip);
856 
857  /* On Windows, FFmpeg supports AviSynth interface version 6 or higher.
858  * This includes AviSynth 2.6 RC1 or higher, and AviSynth+ r1718 or higher,
859  * and excludes 2.5 and the 2.6 alphas. */
860 
861  if (avs->avs_library.avs_get_version(avs->clip) < 6) {
862  av_log(s, AV_LOG_ERROR,
863  "AviSynth version is too old. Please upgrade to either AviSynth 2.6 >= RC1 or AviSynth+ >= r1718.\n");
864  ret = AVERROR_UNKNOWN;
865  goto fail;
866  }
867 
868  /* Release the AVS_Value as it will go out of scope. */
869  avs->avs_library.avs_release_value(val);
870 
871  if (ret = avisynth_create_stream(s))
872  goto fail;
873 
874  return 0;
875 
876 fail:
877  avisynth_context_destroy(avs);
878  return ret;
879 }
880 
881 static void avisynth_next_stream(AVFormatContext *s, AVStream **st,
882  AVPacket *pkt, int *discard)
883 {
884  AviSynthContext *avs = s->priv_data;
885 
886  avs->curr_stream++;
887  avs->curr_stream %= s->nb_streams;
888 
889  *st = s->streams[avs->curr_stream];
890  if ((*st)->discard == AVDISCARD_ALL)
891  *discard = 1;
892  else
893  *discard = 0;
894 
895  return;
896 }
897 
898 /* Copy AviSynth clip data into an AVPacket. */
899 static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt,
900  int discard)
901 {
902  AviSynthContext *avs = s->priv_data;
903  AVS_VideoFrame *frame;
904  unsigned char *dst_p;
905  const unsigned char *src_p;
906  int n, i, plane, rowsize, planeheight, pitch, bits, ret;
907  const char *error;
908 
909  if (avs->curr_frame >= avs->vi->num_frames)
910  return AVERROR_EOF;
911 
912  /* This must happen even if the stream is discarded to prevent desync. */
913  n = avs->curr_frame++;
914  if (discard)
915  return 0;
916 
917  bits = avs->avs_library.avs_bits_per_pixel(avs->vi);
918 
919  /* Without the cast to int64_t, calculation overflows at about 9k x 9k
920  * resolution. */
921  pkt->size = (((int64_t)avs->vi->width *
922  (int64_t)avs->vi->height) * bits) / 8;
923  if (!pkt->size)
924  return AVERROR_UNKNOWN;
925 
926  if ((ret = av_new_packet(pkt, pkt->size)) < 0)
927  return ret;
928 
929  pkt->pts = n;
930  pkt->dts = n;
931  pkt->duration = 1;
932  pkt->stream_index = avs->curr_stream;
933 
934  frame = avs->avs_library.avs_get_frame(avs->clip, n);
935  error = avs->avs_library.avs_clip_get_error(avs->clip);
936  if (error) {
937  av_log(s, AV_LOG_ERROR, "%s\n", error);
938  avs->error = 1;
939  av_packet_unref(pkt);
940  return AVERROR_UNKNOWN;
941  }
942 
943  dst_p = pkt->data;
944  for (i = 0; i < avs->n_planes; i++) {
945  plane = avs->planes[i];
946  src_p = avs->avs_library.avs_get_read_ptr_p(frame, plane);
947  pitch = avs->avs_library.avs_get_pitch_p(frame, plane);
948 
949  rowsize = avs->avs_library.avs_get_row_size_p(frame, plane);
950  planeheight = avs->avs_library.avs_get_height_p(frame, plane);
951 
952  /* Flip RGB video. */
953  if (avs->avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR) ||
954  avs->avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR48) ||
955  avs->avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR64)) {
956  src_p = src_p + (planeheight - 1) * pitch;
957  pitch = -pitch;
958  }
959 
960  avs->avs_library.avs_bit_blt(avs->env, dst_p, rowsize, src_p, pitch,
961  rowsize, planeheight);
962  dst_p += rowsize * planeheight;
963  }
964 
965  avs->avs_library.avs_release_video_frame(frame);
966  return 0;
967 }
968 
969 static int avisynth_read_packet_audio(AVFormatContext *s, AVPacket *pkt,
970  int discard)
971 {
972  AviSynthContext *avs = s->priv_data;
973  AVRational fps, samplerate;
974  int samples, ret;
975  int64_t n;
976  const char *error;
977 
978  if (avs->curr_sample >= avs->vi->num_audio_samples)
979  return AVERROR_EOF;
980 
981  fps.num = avs->vi->fps_numerator;
982  fps.den = avs->vi->fps_denominator;
983  samplerate.num = avs->vi->audio_samples_per_second;
984  samplerate.den = 1;
985 
986  if (avs_has_video(avs->vi)) {
987  if (avs->curr_frame < avs->vi->num_frames)
988  samples = av_rescale_q(avs->curr_frame, samplerate, fps) -
989  avs->curr_sample;
990  else
991  samples = av_rescale_q(1, samplerate, fps);
992  } else {
993  samples = 1000;
994  }
995 
996  /* After seeking, audio may catch up with video. */
997  if (samples <= 0) {
998  pkt->size = 0;
999  pkt->data = NULL;
1000  return 0;
1001  }
1002 
1003  if (avs->curr_sample + samples > avs->vi->num_audio_samples)
1004  samples = avs->vi->num_audio_samples - avs->curr_sample;
1005 
1006  /* This must happen even if the stream is discarded to prevent desync. */
1007  n = avs->curr_sample;
1008  avs->curr_sample += samples;
1009  if (discard)
1010  return 0;
1011 
1012  pkt->size = avs_bytes_per_channel_sample(avs->vi) *
1013  samples * avs->vi->nchannels;
1014  if (!pkt->size)
1015  return AVERROR_UNKNOWN;
1016 
1017  if ((ret = av_new_packet(pkt, pkt->size)) < 0)
1018  return ret;
1019 
1020  pkt->pts = n;
1021  pkt->dts = n;
1022  pkt->duration = samples;
1023  pkt->stream_index = avs->curr_stream;
1024 
1025  avs->avs_library.avs_get_audio(avs->clip, pkt->data, n, samples);
1026  error = avs->avs_library.avs_clip_get_error(avs->clip);
1027  if (error) {
1028  av_log(s, AV_LOG_ERROR, "%s\n", error);
1029  avs->error = 1;
1030  av_packet_unref(pkt);
1031  return AVERROR_UNKNOWN;
1032  }
1033  return 0;
1034 }
1035 
1036 static av_cold int avisynth_read_header(AVFormatContext *s)
1037 {
1038  int ret;
1039 
1040  if (ret = avisynth_open_file(s))
1041  return ret;
1042 
1043  return 0;
1044 }
1045 
1046 static int avisynth_read_packet(AVFormatContext *s, AVPacket *pkt)
1047 {
1048  AviSynthContext *avs = s->priv_data;
1049  AVStream *st;
1050  int discard = 0;
1051  int ret;
1052 
1053  if (avs->error)
1054  return AVERROR_UNKNOWN;
1055 
1056  /* If either stream reaches EOF, try to read the other one before
1057  * giving up. */
1058  avisynth_next_stream(s, &st, pkt, &discard);
1059  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1060  ret = avisynth_read_packet_video(s, pkt, discard);
1061  if (ret == AVERROR_EOF && avs_has_audio(avs->vi)) {
1062  avisynth_next_stream(s, &st, pkt, &discard);
1063  return avisynth_read_packet_audio(s, pkt, discard);
1064  }
1065  } else {
1066  ret = avisynth_read_packet_audio(s, pkt, discard);
1067  if (ret == AVERROR_EOF && avs_has_video(avs->vi)) {
1068  avisynth_next_stream(s, &st, pkt, &discard);
1069  return avisynth_read_packet_video(s, pkt, discard);
1070  }
1071  }
1072 
1073  return ret;
1074 }
1075 
1076 static av_cold int avisynth_read_close(AVFormatContext *s)
1077 {
1078  AviSynthContext *avs = s->priv_data;
1079 
1080  if (avs->avs_library.library) {
1081  avisynth_context_destroy(s->priv_data);
1082  dlclose(avs->avs_library.library);
1083  }
1084 
1085  return 0;
1086 }
1087 
1088 static int avisynth_read_seek(AVFormatContext *s, int stream_index,
1089  int64_t timestamp, int flags)
1090 {
1091  AviSynthContext *avs = s->priv_data;
1092  AVStream *st;
1093  AVRational fps, samplerate;
1094 
1095  if (avs->error)
1096  return AVERROR_UNKNOWN;
1097 
1098  fps = (AVRational) { avs->vi->fps_numerator,
1099  avs->vi->fps_denominator };
1100  samplerate = (AVRational) { avs->vi->audio_samples_per_second, 1 };
1101 
1102  st = s->streams[stream_index];
1103  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1104  /* AviSynth frame counts are signed int. */
1105  if ((timestamp >= avs->vi->num_frames) ||
1106  (timestamp > INT_MAX) ||
1107  (timestamp < 0))
1108  return AVERROR_EOF;
1109  avs->curr_frame = timestamp;
1110  if (avs_has_audio(avs->vi))
1111  avs->curr_sample = av_rescale_q(timestamp, samplerate, fps);
1112  } else {
1113  if ((timestamp >= avs->vi->num_audio_samples) || (timestamp < 0))
1114  return AVERROR_EOF;
1115  /* Force frame granularity for seeking. */
1116  if (avs_has_video(avs->vi)) {
1117  avs->curr_frame = av_rescale_q(timestamp, fps, samplerate);
1118  avs->curr_sample = av_rescale_q(avs->curr_frame, samplerate, fps);
1119  } else {
1120  avs->curr_sample = timestamp;
1121  }
1122  }
1123 
1124  return 0;
1125 }
1126 
1127 #define AVISYNTH_FRAMEPROP_DEFAULT AVISYNTH_FRAMEPROP_FIELD_ORDER | AVISYNTH_FRAMEPROP_RANGE | \
1128  AVISYNTH_FRAMEPROP_PRIMARIES | AVISYNTH_FRAMEPROP_TRANSFER | \
1129  AVISYNTH_FRAMEPROP_MATRIX | AVISYNTH_FRAMEPROP_CHROMA_LOCATION
1130 #define OFFSET(x) offsetof(AviSynthContext, x)
1131 static const AVOption avisynth_options[] = {
1132  { "avisynth_flags", "set flags related to reading frame properties from script (AviSynth+ v3.7.1 or higher)", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = AVISYNTH_FRAMEPROP_DEFAULT}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1133  { "field_order", "read field order", 0, AV_OPT_TYPE_CONST, {.i64 = AVISYNTH_FRAMEPROP_FIELD_ORDER}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1134  { "range", "read color range", 0, AV_OPT_TYPE_CONST, {.i64 = AVISYNTH_FRAMEPROP_RANGE}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1135  { "primaries", "read color primaries", 0, AV_OPT_TYPE_CONST, {.i64 = AVISYNTH_FRAMEPROP_PRIMARIES}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1136  { "transfer", "read color transfer characteristics", 0, AV_OPT_TYPE_CONST, {.i64 = AVISYNTH_FRAMEPROP_TRANSFER}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1137  { "matrix", "read matrix coefficients", 0, AV_OPT_TYPE_CONST, {.i64 = AVISYNTH_FRAMEPROP_MATRIX}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1138  { "chroma_location", "read chroma location", 0, AV_OPT_TYPE_CONST, {.i64 = AVISYNTH_FRAMEPROP_CHROMA_LOCATION}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1139  { "sar", "read sample aspect ratio", 0, AV_OPT_TYPE_CONST, {.i64 = AVISYNTH_FRAMEPROP_SAR}, 0, 1, AV_OPT_FLAG_DECODING_PARAM, .unit = "flags" },
1140  { NULL },
1141 };
1142 
1143 static const AVClass avisynth_demuxer_class = {
1144  .class_name = "AviSynth demuxer",
1145  .item_name = av_default_item_name,
1146  .option = avisynth_options,
1147  .version = LIBAVUTIL_VERSION_INT,
1148 };
1149 
1150 const FFInputFormat ff_avisynth_demuxer = {
1151  .p.name = "avisynth",
1152  .p.long_name = NULL_IF_CONFIG_SMALL("AviSynth script"),
1153  .p.extensions = "avs",
1154  .p.priv_class = &avisynth_demuxer_class,
1155  .priv_data_size = sizeof(AviSynthContext),
1156  .read_header = avisynth_read_header,
1157  .read_packet = avisynth_read_packet,
1158  .read_close = avisynth_read_close,
1159  .read_seek = avisynth_read_seek,
1160 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
flags
const SwsFlags flags[]
Definition: swscale.c:61
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:579
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:430
AV_PIX_FMT_GBRAP16
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:551
wchar_filename.h
AVCOL_PRI_EBU3213
@ AVCOL_PRI_EBU3213
EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors.
Definition: pixfmt.h:635
opt.h
avisynth_demuxer_class
static const AVClass avisynth_demuxer_class
Definition: avisynth.c:1143
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
OFFSET
#define OFFSET(x)
Definition: avisynth.c:1130
AVCodecParameters::color_space
enum AVColorSpace color_space
Definition: codec_par.h:169
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const struct AVCodec *c)
Add a new stream to a media file.
thread.h
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:210
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:653
AVCHROMA_LOC_BOTTOM
@ AVCHROMA_LOC_BOTTOM
Definition: pixfmt.h:776
avisynth_read_seek
static int avisynth_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: avisynth.c:1088
int64_t
long long int64_t
Definition: coverity.c:34
avisynth_read_packet
static int avisynth_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: avisynth.c:1046
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
AviSynthContext::curr_sample
int64_t curr_sample
Definition: avisynth.c:113
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:578
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:750
AVPacket::data
uint8_t * data
Definition: packet.h:535
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:573
AviSynthLibrary::library
void * library
Definition: avisynth.c:58
AVOption
AVOption.
Definition: opt.h:429
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:647
AVISYNTH_FRAMEPROP_MATRIX
@ AVISYNTH_FRAMEPROP_MATRIX
Definition: avisynth.c:96
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:833
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:528
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:674
AVCOL_TRC_BT2020_12
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
Definition: pixfmt.h:660
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:553
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:329
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:574
AVCOL_SPC_BT2020_CL
@ AVCOL_SPC_BT2020_CL
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:685
AviSynthContext::curr_stream
int curr_stream
Definition: avisynth.c:111
AVCodecParameters::color_primaries
enum AVColorPrimaries color_primaries
Definition: codec_par.h:167
AviSynthLibrary
Definition: avisynth.c:57
AVCOL_SPC_BT470BG
@ AVCOL_SPC_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601
Definition: pixfmt.h:679
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:211
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:777
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:546
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:658
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
fail
#define fail()
Definition: checkasm.h:196
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:544
read_seek
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:151
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:580
AVISYNTH_FRAMEPROP_SAR
@ AVISYNTH_FRAMEPROP_SAR
Definition: avisynth.c:98
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:650
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:143
val
static double val(void *priv, double ch)
Definition: aeval.c:77
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:511
AVCOL_TRC_LOG_SQRT
@ AVCOL_TRC_LOG_SQRT
"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
Definition: pixfmt.h:655
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:803
AVISYNTH_LIB
#define AVISYNTH_LIB
Definition: avisynth.c:45
planar
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
Definition: audioconvert.c:56
AVRational::num
int num
Numerator.
Definition: rational.h:59
avisynth_create_stream_video
static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
Definition: avisynth.c:207
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:649
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:531
AVCodecParameters::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: codec_par.h:168
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:236
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
av_cold
#define av_cold
Definition: attributes.h:90
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:540
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_read_callback.c:42
AV_FIELD_UNKNOWN
@ AV_FIELD_UNKNOWN
Definition: defs.h:209
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:548
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCHROMA_LOC_TOP
@ AVCHROMA_LOC_TOP
Definition: pixfmt.h:774
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:99
AV_PIX_FMT_GBRAP12
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:549
LOAD_AVS_FUNC
#define LOAD_AVS_FUNC(name, continue_on_fail)
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:108
AVCOL_TRC_BT1361_ECG
@ AVCOL_TRC_BT1361_ECG
ITU-R BT1361 Extended Colour Gamut.
Definition: pixfmt.h:657
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:541
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:549
AVCOL_SPC_SMPTE170M
@ AVCOL_SPC_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC / functionally identical to above
Definition: pixfmt.h:680
avisynth_read_close
static av_cold int avisynth_read_close(AVFormatContext *s)
Definition: avisynth.c:1076
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:201
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
av_channel_layout_from_mask
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:252
PCM
#define PCM(format)
Definition: avisynth.c:52
bits
uint8_t bits
Definition: vp3data.h:128
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:539
AVCOL_PRI_SMPTE428
@ AVCOL_PRI_SMPTE428
SMPTE ST 428-1 (CIE 1931 XYZ)
Definition: pixfmt.h:631
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:510
AviSynthContext::error
int error
Definition: avisynth.c:115
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
avisynth_next_stream
static void avisynth_next_stream(AVFormatContext *s, AVStream **st, AVPacket *pkt, int *discard)
Definition: avisynth.c:881
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
AVCOL_PRI_SMPTE240M
@ AVCOL_PRI_SMPTE240M
identical to above, also called "SMPTE C" even though it uses D65
Definition: pixfmt.h:628
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:565
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:622
AVCOL_SPC_CHROMA_DERIVED_CL
@ AVCOL_SPC_CHROMA_DERIVED_CL
Chromaticity-derived constant luminance system.
Definition: pixfmt.h:688
AVCOL_PRI_BT470BG
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:626
arg
const char * arg
Definition: jacosubdec.c:67
AVCOL_PRI_SMPTE170M
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
Definition: pixfmt.h:627
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:508
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:229
AVFormatContext
Format I/O context.
Definition: avformat.h:1264
internal.h
AviSynthContext::env
AVS_ScriptEnvironment * env
Definition: avisynth.c:103
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:547
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:767
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
AviSynthContext::planes
const int * planes
Definition: avisynth.c:109
AV_PIX_FMT_BGR48
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:519
NULL
#define NULL
Definition: coverity.c:32
avisynth_context_destroy
static av_cold void avisynth_context_destroy(AviSynthContext *avs)
Definition: avisynth.c:194
AVCHROMA_LOC_LEFT
@ AVCHROMA_LOC_LEFT
MPEG-2/4 4:2:0, H.264 default for 4:2:0.
Definition: pixfmt.h:771
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:773
AVCOL_TRC_IEC61966_2_4
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
Definition: pixfmt.h:656
avisynth_read_packet_audio
static int avisynth_read_packet_audio(AVFormatContext *s, AVPacket *pkt, int discard)
Definition: avisynth.c:969
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:621
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:240
AviSynthContext::flags
uint32_t flags
Definition: avisynth.c:117
avisynth_read_header
static av_cold int avisynth_read_header(AVFormatContext *s)
Definition: avisynth.c:1036
AVCOL_TRC_BT2020_10
@ AVCOL_TRC_BT2020_10
ITU-R BT2020 for 10-bit system.
Definition: pixfmt.h:659
AVCOL_SPC_YCGCO
@ AVCOL_SPC_YCGCO
used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
Definition: pixfmt.h:682
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:529
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AviSynthContext::avs_library
struct AviSynthLibrary avs_library
Definition: avisynth.c:118
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:716
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
AVStream::nb_frames
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:805
AVCOL_PRI_BT2020
@ AVCOL_PRI_BT2020
ITU-R BT2020.
Definition: pixfmt.h:630
avisynth_options
static const AVOption avisynth_options[]
Definition: avisynth.c:1131
AviSynthContext::clip
AVS_Clip * clip
Definition: avisynth.c:104
AVCOL_TRC_SMPTE2084
@ AVCOL_TRC_SMPTE2084
SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.
Definition: pixfmt.h:661
AVCOL_PRI_SMPTE431
@ AVCOL_PRI_SMPTE431
SMPTE ST 431-2 (2011) / DCI P3.
Definition: pixfmt.h:633
AVPacket::size
int size
Definition: packet.h:536
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
AVCOL_TRC_SMPTE240M
@ AVCOL_TRC_SMPTE240M
Definition: pixfmt.h:652
avisynth_read_packet_video
static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt, int discard)
Definition: avisynth.c:899
avisynth_create_stream
static int avisynth_create_stream(AVFormatContext *s)
Definition: avisynth.c:782
AVCOL_PRI_FILM
@ AVCOL_PRI_FILM
colour filters using Illuminant C
Definition: pixfmt.h:629
AVISYNTH_FRAMEPROP_PRIMARIES
@ AVISYNTH_FRAMEPROP_PRIMARIES
Definition: avisynth.c:94
AVCOL_TRC_LOG
@ AVCOL_TRC_LOG
"Logarithmic transfer characteristic (100:1 range)"
Definition: pixfmt.h:654
AviSynthContext
Definition: avisynth.c:101
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:561
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:533
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:535
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:770
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:822
FFInputFormat::p
AVInputFormat p
The public AVInputFormat.
Definition: demux.h:46
AVISYNTH_FRAMEPROP_TRANSFER
@ AVISYNTH_FRAMEPROP_TRANSFER
Definition: avisynth.c:95
AviSynthFlags
AviSynthFlags
Definition: avisynth.c:91
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:534
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:500
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:174
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:575
attributes.h
read_header
static int read_header(FFV1Context *f, RangeCoder *c)
Definition: ffv1dec.c:489
AVCOL_SPC_CHROMA_DERIVED_NCL
@ AVCOL_SPC_CHROMA_DERIVED_NCL
Chromaticity-derived non-constant luminance system.
Definition: pixfmt.h:687
AviSynthContext::curr_frame
int curr_frame
Definition: avisynth.c:112
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:646
AVISYNTH_FRAMEPROP_CHROMA_LOCATION
@ AVISYNTH_FRAMEPROP_CHROMA_LOCATION
Definition: avisynth.c:97
AVCOL_SPC_SMPTE240M
@ AVCOL_SPC_SMPTE240M
derived from 170M primaries and D65 white point, 170M is derived from BT470 System M's primaries
Definition: pixfmt.h:681
AV_PIX_FMT_BGRA64
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:523
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:528
AVCOL_SPC_BT2020_NCL
@ AVCOL_SPC_BT2020_NCL
ITU-R BT2020 non-constant luminance system.
Definition: pixfmt.h:684
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
AVISYNTH_FRAMEPROP_DEFAULT
#define AVISYNTH_FRAMEPROP_DEFAULT
Definition: avisynth.c:1127
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:545
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:212
demux.h
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:166
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:676
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
AVCodecParameters::field_order
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:161
avisynth_create_stream_audio
static int avisynth_create_stream_audio(AVFormatContext *s, AVStream *st)
Definition: avisynth.c:743
AVCOL_PRI_BT470M
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:624
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:756
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:744
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:81
frame
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 the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AVISYNTH_FRAMEPROP_RANGE
@ AVISYNTH_FRAMEPROP_RANGE
Definition: avisynth.c:93
avformat.h
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:532
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:170
ff_avisynth_demuxer
const FFInputFormat ff_avisynth_demuxer
Definition: avisynth.c:1150
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:537
AVISYNTH_FRAMEPROP_FIELD_ORDER
@ AVISYNTH_FRAMEPROP_FIELD_ORDER
Definition: avisynth.c:92
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:665
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:772
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVCOL_SPC_FCC
@ AVCOL_SPC_FCC
FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:678
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:576
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:562
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
AVCOL_TRC_SMPTE170M
@ AVCOL_TRC_SMPTE170M
also ITU-R BT601-6 525 or 625 / ITU-R BT1358 525 or 625 / ITU-R BT1700 NTSC
Definition: pixfmt.h:651
AVPacket::stream_index
int stream_index
Definition: packet.h:537
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
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:356
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
avisynth_load_library
static av_cold int avisynth_load_library(AviSynthContext *avs)
Definition: avisynth.c:121
mem.h
AV_CODEC_ID_PCM_U8
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:341
AVCodecParameters::format
int format
Definition: codec_par.h:92
AVCOL_PRI_SMPTE432
@ AVCOL_PRI_SMPTE432
SMPTE ST 432-1 (2010) / P3 D65 / Display P3.
Definition: pixfmt.h:634
AviSynthContext::n_planes
int n_planes
Definition: avisynth.c:108
AviSynthContext::vi
const AVS_VideoInfo * vi
Definition: avisynth.c:105
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
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:512
AVCOL_SPC_SMPTE2085
@ AVCOL_SPC_SMPTE2085
SMPTE 2085, Y'D'zD'x.
Definition: pixfmt.h:686
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:80
FFInputFormat
Definition: demux.h:42
AV_OPT_TYPE_FLAGS
@ AV_OPT_TYPE_FLAGS
Underlying C type is unsigned int.
Definition: opt.h:255
AviSynthLibrary::AVSC_DECLARE_FUNC
AVSC_DECLARE_FUNC(avs_bit_blt)
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVCOL_TRC_SMPTE428
@ AVCOL_TRC_SMPTE428
SMPTE ST 428-1.
Definition: pixfmt.h:663
avisynth_context_create
static av_cold int avisynth_context_create(AVFormatContext *s)
Definition: avisynth.c:173
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:538
avisynth_open_file
static int avisynth_open_file(AVFormatContext *s)
Definition: avisynth.c:808
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:793
AV_PIX_FMT_GRAY12
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:509
AVCOL_SPC_BT709
@ AVCOL_SPC_BT709
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / derived in SMPTE RP 177 Annex B
Definition: pixfmt.h:675
AVCOL_SPC_ICTCP
@ AVCOL_SPC_ICTCP
ITU-R BT.2100-0, ICtCp.
Definition: pixfmt.h:689
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
AVCHROMA_LOC_BOTTOMLEFT
@ AVCHROMA_LOC_BOTTOMLEFT
Definition: pixfmt.h:775
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:173
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:536
w32dlfcn.h
Generated on Sun Jun 15 2025 19:22:46 for FFmpeg by   doxygen 1.8.17