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