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"
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
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 
99  int64_t curr_sample;
100 
101  int error;
102 
103  /* Linked list pointers. */
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. */
121 static int avs_atexit_called = 0;
122 
123 /* Linked list of AviSynthContexts. An atexit handler destroys this list. */
125 
126 static av_cold void avisynth_atexit_handler(void);
127 
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. */
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 
209 {
210  if (avs_atexit_called)
211  return;
212 
213  if (avs == avs_ctx_list) {
214  avs_ctx_list = avs->next;
215  } else {
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 
233 {
235 
236  while (avs) {
237  AviSynthContext *next = avs->next;
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. */
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 
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:
272  planar = 1;
273  break;
274  case AVS_CS_YUV422P10:
276  planar = 1;
277  break;
278  case AVS_CS_YUV420P10:
280  planar = 1;
281  break;
282  case AVS_CS_YUV444P12:
284  planar = 1;
285  break;
286  case AVS_CS_YUV422P12:
288  planar = 1;
289  break;
290  case AVS_CS_YUV420P12:
292  planar = 1;
293  break;
294  case AVS_CS_YUV444P14:
296  planar = 1;
297  break;
298  case AVS_CS_YUV422P14:
300  planar = 1;
301  break;
302  case AVS_CS_YUV420P14:
304  planar = 1;
305  break;
306  case AVS_CS_YUV444P16:
308  planar = 1;
309  break;
310  case AVS_CS_YUV422P16:
312  planar = 1;
313  break;
314  case AVS_CS_YUV420P16:
316  planar = 1;
317  break;
318  /* 8~16-bit YUV pix_fmts with Alpha (AviSynth+) */
319  case AVS_CS_YUVA444:
321  planar = 4;
322  break;
323  case AVS_CS_YUVA422:
325  planar = 4;
326  break;
327  case AVS_CS_YUVA420:
329  planar = 4;
330  break;
331  case AVS_CS_YUVA444P10:
333  planar = 4;
334  break;
335  case AVS_CS_YUVA422P10:
337  planar = 4;
338  break;
339  case AVS_CS_YUVA420P10:
341  planar = 4;
342  break;
343  case AVS_CS_YUVA422P12:
345  planar = 4;
346  break;
347  case AVS_CS_YUVA444P16:
349  planar = 4;
350  break;
351  case AVS_CS_YUVA422P16:
353  planar = 4;
354  break;
355  case AVS_CS_YUVA420P16:
357  planar = 4;
358  break;
359  /* Planar RGB pix_fmts (AviSynth+) */
360  case AVS_CS_RGBP:
362  planar = 3;
363  break;
364  case AVS_CS_RGBP10:
366  planar = 3;
367  break;
368  case AVS_CS_RGBP12:
370  planar = 3;
371  break;
372  case AVS_CS_RGBP14:
374  planar = 3;
375  break;
376  case AVS_CS_RGBP16:
378  planar = 3;
379  break;
380  /* Single precision floating point Planar RGB (AviSynth+) */
381  case AVS_CS_RGBPS:
383  planar = 3;
384  break;
385  /* Planar RGB pix_fmts with Alpha (AviSynth+) */
386  case AVS_CS_RGBAP:
388  planar = 5;
389  break;
390  case AVS_CS_RGBAP10:
392  planar = 5;
393  break;
394  case AVS_CS_RGBAP12:
396  planar = 5;
397  break;
398  case AVS_CS_RGBAP16:
400  planar = 5;
401  break;
402  /* Single precision floating point Planar RGB with Alpha (AviSynth+) */
403  case AVS_CS_RGBAPS:
405  planar = 5;
406  break;
407  /* 10~16-bit gray pix_fmts (AviSynth+) */
408  case AVS_CS_Y10:
410  planar = 2;
411  break;
412  case AVS_CS_Y12:
414  planar = 2;
415  break;
416  case AVS_CS_Y14:
418  planar = 2;
419  break;
420  case AVS_CS_Y16:
422  planar = 2;
423  break;
424  /* Single precision floating point gray (AviSynth+) */
425  case AVS_CS_Y32:
427  planar = 2;
428  break;
429  /* pix_fmts added in AviSynth 2.6 */
430  case AVS_CS_YV24:
432  planar = 1;
433  break;
434  case AVS_CS_YV16:
436  planar = 1;
437  break;
438  case AVS_CS_YV411:
440  planar = 1;
441  break;
442  case AVS_CS_Y8:
444  planar = 2;
445  break;
446  /* 16-bit packed RGB pix_fmts (AviSynth+) */
447  case AVS_CS_BGR48:
449  break;
450  case AVS_CS_BGR64:
452  break;
453  /* AviSynth 2.5 pix_fmts */
454  case AVS_CS_BGR24:
456  break;
457  case AVS_CS_BGR32:
459  break;
460  case AVS_CS_YUY2:
462  break;
463  case AVS_CS_YV12:
465  planar = 1;
466  break;
467  case AVS_CS_I420: // Is this even used anywhere?
469  planar = 1;
470  break;
471  default:
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) {
521  } else {
522  switch (avs_library.avs_prop_get_int(avs->env, avsmap, "_FieldBased", 0, &error)) {
523  case 0:
525  break;
526  case 1:
528  break;
529  case 2:
531  break;
532  default:
534  }
535  }
536 
537  /* Color Range */
538  if(avs_library.avs_prop_get_type(avs->env, avsmap, "_ColorRange") == AVS_PROPTYPE_UNSET) {
540  } else {
541  switch (avs_library.avs_prop_get_int(avs->env, avsmap, "_ColorRange", 0, &error)) {
542  case 0:
544  break;
545  case 1:
547  break;
548  default:
550  }
551  }
552 
553  /* Color Primaries */
554  switch (avs_library.avs_prop_get_int(avs->env, avsmap, "_Primaries", 0, &error)) {
555  case 1:
557  break;
558  case 2:
560  break;
561  case 4:
563  break;
564  case 5:
566  break;
567  case 6:
569  break;
570  case 7:
572  break;
573  case 8:
575  break;
576  case 9:
578  break;
579  case 10:
581  break;
582  case 11:
584  break;
585  case 12:
587  break;
588  case 22:
590  break;
591  default:
593  }
594 
595  /* Color Transfer Characteristics */
596  switch (avs_library.avs_prop_get_int(avs->env, avsmap, "_Transfer", 0, &error)) {
597  case 1:
599  break;
600  case 2:
602  break;
603  case 4:
605  break;
606  case 5:
608  break;
609  case 6:
611  break;
612  case 7:
614  break;
615  case 8:
617  break;
618  case 9:
620  break;
621  case 10:
623  break;
624  case 11:
626  break;
627  case 12:
629  break;
630  case 13:
632  break;
633  case 14:
635  break;
636  case 15:
638  break;
639  case 16:
641  break;
642  case 17:
644  break;
645  case 18:
647  break;
648  default:
650  }
651 
652  /* Matrix coefficients */
653  if(avs_library.avs_prop_get_type(avs->env, avsmap, "_Matrix") == AVS_PROPTYPE_UNSET) {
655  } else {
656  switch (avs_library.avs_prop_get_int(avs->env, avsmap, "_Matrix", 0, &error)) {
657  case 0:
659  break;
660  case 1:
662  break;
663  case 2:
665  break;
666  case 4:
668  break;
669  case 5:
671  break;
672  case 6:
674  break;
675  case 7:
677  break;
678  case 8:
680  break;
681  case 9:
683  break;
684  case 10:
686  break;
687  case 11:
689  break;
690  case 12:
692  break;
693  case 13:
695  break;
696  case 14:
698  break;
699  default:
701  }
702  }
703 
704  /* Chroma Location */
705  if(avs_library.avs_prop_get_type(avs->env, avsmap, "_ChromaLocation") == AVS_PROPTYPE_UNSET) {
707  } else {
708  switch (avs_library.avs_prop_get_int(avs->env, avsmap, "_ChromaLocation", 0, &error)) {
709  case 0:
711  break;
712  case 1:
714  break;
715  case 2:
717  break;
718  case 3:
720  break;
721  case 4:
723  break;
724  case 5:
726  break;
727  default:
729  }
730  }
731  avs_library.avs_release_video_frame(frame);
732  } else {
734  /* AviSynth works with frame-based video, detecting field order can
735  * only work when avs_is_field_based returns 'false'. */
736  av_log(s, AV_LOG_TRACE, "avs_is_field_based: %d\n", avs_is_field_based(avs->vi));
737  if (avs_is_field_based(avs->vi) == 0) {
738  if (avs_is_tff(avs->vi)) {
740  }
741  else if (avs_is_bff(avs->vi)) {
743  }
744  }
745  }
746 
747  return 0;
748 }
749 
751 {
752  AviSynthContext *avs = s->priv_data;
753 
755  st->codecpar->sample_rate = avs->vi->audio_samples_per_second;
756  st->codecpar->ch_layout.nb_channels = avs->vi->nchannels;
757  st->duration = avs->vi->num_audio_samples;
758  avpriv_set_pts_info(st, 64, 1, avs->vi->audio_samples_per_second);
759 
760  switch (avs->vi->sample_type) {
761  case AVS_SAMPLE_INT8:
763  break;
764  case AVS_SAMPLE_INT16:
765  st->codecpar->codec_id = PCM(S16);
766  break;
767  case AVS_SAMPLE_INT24:
768  st->codecpar->codec_id = PCM(S24);
769  break;
770  case AVS_SAMPLE_INT32:
771  st->codecpar->codec_id = PCM(S32);
772  break;
773  case AVS_SAMPLE_FLOAT:
774  st->codecpar->codec_id = PCM(F32);
775  break;
776  default:
778  "unknown AviSynth sample type %d\n", avs->vi->sample_type);
779  avs->error = 1;
780  return AVERROR_UNKNOWN;
781  }
782  return 0;
783 }
784 
786 {
787  AviSynthContext *avs = s->priv_data;
788  AVStream *st;
789  int ret;
790  int id = 0;
791 
792  if (avs_has_video(avs->vi)) {
793  st = avformat_new_stream(s, NULL);
794  if (!st)
795  return AVERROR_UNKNOWN;
796  st->id = id++;
798  return ret;
799  }
800  if (avs_has_audio(avs->vi)) {
801  st = avformat_new_stream(s, NULL);
802  if (!st)
803  return AVERROR_UNKNOWN;
804  st->id = id++;
806  return ret;
807  }
808  return 0;
809 }
810 
812 {
813  AviSynthContext *avs = s->priv_data;
814  AVS_Value val;
815  int ret;
816 
818  return ret;
819 
820  if (!avs_library.avs_check_version(avs->env, 7)) {
821  AVS_Value args[] = {
822  avs_new_value_string(s->url),
823  avs_new_value_bool(1) // filename is in UTF-8
824  };
825  val = avs_library.avs_invoke(avs->env, "Import",
826  avs_new_value_array(args, 2), 0);
827  } else {
828  AVS_Value arg;
829 #ifdef _WIN32
830  char *filename_ansi;
831  /* Convert UTF-8 to ANSI code page */
832  if (utf8toansi(s->url, &filename_ansi)) {
834  goto fail;
835  }
836  arg = avs_new_value_string(filename_ansi);
837 #else
838  arg = avs_new_value_string(s->url);
839 #endif
840  val = avs_library.avs_invoke(avs->env, "Import", arg, 0);
841 #ifdef _WIN32
842  av_free(filename_ansi);
843 #endif
844  }
845 
846  if (avs_is_error(val)) {
847  av_log(s, AV_LOG_ERROR, "%s\n", avs_as_error(val));
849  goto fail;
850  }
851  if (!avs_is_clip(val)) {
852  av_log(s, AV_LOG_ERROR, "AviSynth script did not return a clip\n");
854  goto fail;
855  }
856 
857  avs->clip = avs_library.avs_take_clip(val, avs->env);
858  avs->vi = avs_library.avs_get_video_info(avs->clip);
859 
860  /* On Windows, FFmpeg supports AviSynth interface version 6 or higher.
861  * This includes AviSynth 2.6 RC1 or higher, and AviSynth+ r1718 or higher,
862  * and excludes 2.5 and the 2.6 alphas. */
863 
864  if (avs_library.avs_get_version(avs->clip) < 6) {
866  "AviSynth version is too old. Please upgrade to either AviSynth 2.6 >= RC1 or AviSynth+ >= r1718.\n");
868  goto fail;
869  }
870 
871  /* Release the AVS_Value as it will go out of scope. */
872  avs_library.avs_release_value(val);
873 
875  goto fail;
876 
877  return 0;
878 
879 fail:
881  return ret;
882 }
883 
885  AVPacket *pkt, int *discard)
886 {
887  AviSynthContext *avs = s->priv_data;
888 
889  avs->curr_stream++;
890  avs->curr_stream %= s->nb_streams;
891 
892  *st = s->streams[avs->curr_stream];
893  if ((*st)->discard == AVDISCARD_ALL)
894  *discard = 1;
895  else
896  *discard = 0;
897 
898  return;
899 }
900 
901 /* Copy AviSynth clip data into an AVPacket. */
903  int discard)
904 {
905  AviSynthContext *avs = s->priv_data;
906  AVS_VideoFrame *frame;
907  unsigned char *dst_p;
908  const unsigned char *src_p;
909  int n, i, plane, rowsize, planeheight, pitch, bits, ret;
910  const char *error;
911 
912  if (avs->curr_frame >= avs->vi->num_frames)
913  return AVERROR_EOF;
914 
915  /* This must happen even if the stream is discarded to prevent desync. */
916  n = avs->curr_frame++;
917  if (discard)
918  return 0;
919 
920  bits = avs_library.avs_bits_per_pixel(avs->vi);
921 
922  /* Without the cast to int64_t, calculation overflows at about 9k x 9k
923  * resolution. */
924  pkt->size = (((int64_t)avs->vi->width *
925  (int64_t)avs->vi->height) * bits) / 8;
926  if (!pkt->size)
927  return AVERROR_UNKNOWN;
928 
929  if ((ret = av_new_packet(pkt, pkt->size)) < 0)
930  return ret;
931 
932  pkt->pts = n;
933  pkt->dts = n;
934  pkt->duration = 1;
935  pkt->stream_index = avs->curr_stream;
936 
937  frame = avs_library.avs_get_frame(avs->clip, n);
938  error = avs_library.avs_clip_get_error(avs->clip);
939  if (error) {
940  av_log(s, AV_LOG_ERROR, "%s\n", error);
941  avs->error = 1;
943  return AVERROR_UNKNOWN;
944  }
945 
946  dst_p = pkt->data;
947  for (i = 0; i < avs->n_planes; i++) {
948  plane = avs->planes[i];
949  src_p = avs_library.avs_get_read_ptr_p(frame, plane);
950  pitch = avs_library.avs_get_pitch_p(frame, plane);
951 
952  rowsize = avs_library.avs_get_row_size_p(frame, plane);
953  planeheight = avs_library.avs_get_height_p(frame, plane);
954 
955  /* Flip RGB video. */
956  if (avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR) ||
957  avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR48) ||
958  avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR64)) {
959  src_p = src_p + (planeheight - 1) * pitch;
960  pitch = -pitch;
961  }
962 
963  avs_library.avs_bit_blt(avs->env, dst_p, rowsize, src_p, pitch,
964  rowsize, planeheight);
965  dst_p += rowsize * planeheight;
966  }
967 
968  avs_library.avs_release_video_frame(frame);
969  return 0;
970 }
971 
973  int discard)
974 {
975  AviSynthContext *avs = s->priv_data;
976  AVRational fps, samplerate;
977  int samples, ret;
978  int64_t n;
979  const char *error;
980 
981  if (avs->curr_sample >= avs->vi->num_audio_samples)
982  return AVERROR_EOF;
983 
984  fps.num = avs->vi->fps_numerator;
985  fps.den = avs->vi->fps_denominator;
986  samplerate.num = avs->vi->audio_samples_per_second;
987  samplerate.den = 1;
988 
989  if (avs_has_video(avs->vi)) {
990  if (avs->curr_frame < avs->vi->num_frames)
991  samples = av_rescale_q(avs->curr_frame, samplerate, fps) -
992  avs->curr_sample;
993  else
994  samples = av_rescale_q(1, samplerate, fps);
995  } else {
996  samples = 1000;
997  }
998 
999  /* After seeking, audio may catch up with video. */
1000  if (samples <= 0) {
1001  pkt->size = 0;
1002  pkt->data = NULL;
1003  return 0;
1004  }
1005 
1006  if (avs->curr_sample + samples > avs->vi->num_audio_samples)
1007  samples = avs->vi->num_audio_samples - avs->curr_sample;
1008 
1009  /* This must happen even if the stream is discarded to prevent desync. */
1010  n = avs->curr_sample;
1011  avs->curr_sample += samples;
1012  if (discard)
1013  return 0;
1014 
1015  pkt->size = avs_bytes_per_channel_sample(avs->vi) *
1016  samples * avs->vi->nchannels;
1017  if (!pkt->size)
1018  return AVERROR_UNKNOWN;
1019 
1020  if ((ret = av_new_packet(pkt, pkt->size)) < 0)
1021  return ret;
1022 
1023  pkt->pts = n;
1024  pkt->dts = n;
1025  pkt->duration = samples;
1026  pkt->stream_index = avs->curr_stream;
1027 
1028  avs_library.avs_get_audio(avs->clip, pkt->data, n, samples);
1029  error = avs_library.avs_clip_get_error(avs->clip);
1030  if (error) {
1031  av_log(s, AV_LOG_ERROR, "%s\n", error);
1032  avs->error = 1;
1034  return AVERROR_UNKNOWN;
1035  }
1036  return 0;
1037 }
1038 
1040 {
1041  int ret;
1042 
1043  // Calling library must implement a lock for thread-safe opens.
1044  if (ret = ff_lock_avformat())
1045  return ret;
1046 
1047  if (ret = avisynth_open_file(s)) {
1049  return ret;
1050  }
1051 
1053  return 0;
1054 }
1055 
1057 {
1058  AviSynthContext *avs = s->priv_data;
1059  AVStream *st;
1060  int discard = 0;
1061  int ret;
1062 
1063  if (avs->error)
1064  return AVERROR_UNKNOWN;
1065 
1066  /* If either stream reaches EOF, try to read the other one before
1067  * giving up. */
1068  avisynth_next_stream(s, &st, pkt, &discard);
1069  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1070  ret = avisynth_read_packet_video(s, pkt, discard);
1071  if (ret == AVERROR_EOF && avs_has_audio(avs->vi)) {
1072  avisynth_next_stream(s, &st, pkt, &discard);
1073  return avisynth_read_packet_audio(s, pkt, discard);
1074  }
1075  } else {
1076  ret = avisynth_read_packet_audio(s, pkt, discard);
1077  if (ret == AVERROR_EOF && avs_has_video(avs->vi)) {
1078  avisynth_next_stream(s, &st, pkt, &discard);
1079  return avisynth_read_packet_video(s, pkt, discard);
1080  }
1081  }
1082 
1083  return ret;
1084 }
1085 
1087 {
1088  if (ff_lock_avformat())
1089  return AVERROR_UNKNOWN;
1090 
1091  avisynth_context_destroy(s->priv_data);
1093  return 0;
1094 }
1095 
1096 static int avisynth_read_seek(AVFormatContext *s, int stream_index,
1097  int64_t timestamp, int flags)
1098 {
1099  AviSynthContext *avs = s->priv_data;
1100  AVStream *st;
1101  AVRational fps, samplerate;
1102 
1103  if (avs->error)
1104  return AVERROR_UNKNOWN;
1105 
1106  fps = (AVRational) { avs->vi->fps_numerator,
1107  avs->vi->fps_denominator };
1108  samplerate = (AVRational) { avs->vi->audio_samples_per_second, 1 };
1109 
1110  st = s->streams[stream_index];
1111  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1112  /* AviSynth frame counts are signed int. */
1113  if ((timestamp >= avs->vi->num_frames) ||
1114  (timestamp > INT_MAX) ||
1115  (timestamp < 0))
1116  return AVERROR_EOF;
1117  avs->curr_frame = timestamp;
1118  if (avs_has_audio(avs->vi))
1119  avs->curr_sample = av_rescale_q(timestamp, samplerate, fps);
1120  } else {
1121  if ((timestamp >= avs->vi->num_audio_samples) || (timestamp < 0))
1122  return AVERROR_EOF;
1123  /* Force frame granularity for seeking. */
1124  if (avs_has_video(avs->vi)) {
1125  avs->curr_frame = av_rescale_q(timestamp, fps, samplerate);
1126  avs->curr_sample = av_rescale_q(avs->curr_frame, samplerate, fps);
1127  } else {
1128  avs->curr_sample = timestamp;
1129  }
1130  }
1131 
1132  return 0;
1133 }
1134 
1136  .name = "avisynth",
1137  .long_name = NULL_IF_CONFIG_SMALL("AviSynth script"),
1138  .priv_data_size = sizeof(AviSynthContext),
1143  .extensions = "avs",
1144 };
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:454
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:433
wchar_filename.h
AVCOL_PRI_EBU3213
@ AVCOL_PRI_EBU3213
EBU Tech. 3213-E (nothing there) / one of JEDEC P22 group phosphors.
Definition: pixfmt.h:494
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:512
AVCHROMA_LOC_BOTTOM
@ AVCHROMA_LOC_BOTTOM
Definition: pixfmt.h:632
avisynth_read_seek
static int avisynth_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: avisynth.c:1096
avisynth_read_packet
static int avisynth_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: avisynth.c:1056
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:453
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:606
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:448
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:506
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:411
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:533
AVCOL_TRC_BT2020_12
@ AVCOL_TRC_BT2020_12
ITU-R BT2020 for 12-bit system.
Definition: pixfmt.h:519
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:449
AVCOL_SPC_BT2020_CL
@ AVCOL_SPC_BT2020_CL
ITU-R BT2020 constant luminance system.
Definition: pixfmt.h:544
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:538
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:763
AV_FIELD_TT
@ AV_FIELD_TT
Definition: codec_par.h:40
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:429
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:517
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:427
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:455
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:509
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:395
AVCOL_TRC_LOG_SQRT
@ AVCOL_TRC_LOG_SQRT
"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"
Definition: pixfmt.h:514
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:508
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:414
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:423
AV_PIX_FMT_GBRAP10
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:431
s
#define s(width, name)
Definition: cbs_vp9.c:256
AVCHROMA_LOC_TOP
@ AVCHROMA_LOC_TOP
Definition: pixfmt.h:630
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:432
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:516
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:424
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:539
avisynth_read_close
static av_cold int avisynth_read_close(AVFormatContext *s)
Definition: avisynth.c:1086
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:422
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:490
AV_PIX_FMT_GRAY14
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:394
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:884
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:487
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:443
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:481
AVCOL_SPC_CHROMA_DERIVED_CL
@ AVCOL_SPC_CHROMA_DERIVED_CL
Chromaticity-derived constant luminance system.
Definition: pixfmt.h:547
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:485
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:486
AV_PIX_FMT_GRAY10
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:392
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:430
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:402
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:627
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:629
AVCOL_TRC_IEC61966_2_4
@ AVCOL_TRC_IEC61966_2_4
IEC 61966-2-4.
Definition: pixfmt.h:515
avisynth_read_packet_audio
static int avisynth_read_packet_audio(AVFormatContext *s, AVPacket *pkt, int discard)
Definition: avisynth.c:972
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:480
avisynth_read_header
static av_cold int avisynth_read_header(AVFormatContext *s)
Definition: avisynth.c:1039
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:518
AVCOL_SPC_YCGCO
@ AVCOL_SPC_YCGCO
used by Dirac / VC-2 and H.264 FRext, see ITU-T SG16
Definition: pixfmt.h:541
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:412
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:572
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:489
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:520
AVCOL_PRI_SMPTE431
@ AVCOL_PRI_SMPTE431
SMPTE ST 431-2 (2011) / DCI P3.
Definition: pixfmt.h:492
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:511
avisynth_read_packet_video
static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt, int discard)
Definition: avisynth.c:902
avisynth_create_stream
static int avisynth_create_stream(AVFormatContext *s)
Definition: avisynth.c:785
AVCOL_PRI_FILM
@ AVCOL_PRI_FILM
colour filters using Illuminant C
Definition: pixfmt.h:488
AVCOL_TRC_LOG
@ AVCOL_TRC_LOG
"Logarithmic transfer characteristic (100:1 range)"
Definition: pixfmt.h:513
AviSynthContext
Definition: avisynth.c:88
AV_PIX_FMT_GBRPF32
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:440
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:416
ff_lock_avformat
int ff_lock_avformat(void)
Definition: utils.c:48
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:418
AVCHROMA_LOC_UNSPECIFIED
@ AVCHROMA_LOC_UNSPECIFIED
Definition: pixfmt.h:626
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:384
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:450
attributes.h
AVCOL_SPC_CHROMA_DERIVED_NCL
@ AVCOL_SPC_CHROMA_DERIVED_NCL
Chromaticity-derived non-constant luminance system.
Definition: pixfmt.h:546
AviSynthContext::curr_frame
int curr_frame
Definition: avisynth.c:98
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:505
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:540
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:406
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:543
internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:128
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:428
AVCodecParameters::color_range
enum AVColorRange color_range
Video only.
Definition: codec_par.h:147
AVCOL_SPC_UNSPECIFIED
@ AVCOL_SPC_UNSPECIFIED
Definition: pixfmt.h:535
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:589
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:750
AVCOL_PRI_BT470M
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
Definition: pixfmt.h:483
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:415
AVCodecParameters::chroma_location
enum AVChromaLocation chroma_location
Definition: codec_par.h:151
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:420
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:524
AVCHROMA_LOC_CENTER
@ AVCHROMA_LOC_CENTER
MPEG-1 4:2:0, JPEG 4:2:0, H.263 4:2:0.
Definition: pixfmt.h:628
ff_avisynth_demuxer
const AVInputFormat ff_avisynth_demuxer
Definition: avisynth.c:1135
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:537
AV_PIX_FMT_YUVA422P12
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:451
AV_PIX_FMT_GBRAPF32
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:441
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:510
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:325
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:493
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:545
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:522
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:421
avisynth_open_file
static int avisynth_open_file(AVFormatContext *s)
Definition: avisynth.c:811
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:393
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:534
AVCOL_SPC_ICTCP
@ AVCOL_SPC_ICTCP
ITU-R BT.2100-0, ICtCp.
Definition: pixfmt.h:548
avs_planes_packed
static const int avs_planes_packed[1]
Definition: avisynth.c:107
AVCHROMA_LOC_BOTTOMLEFT
@ AVCHROMA_LOC_BOTTOMLEFT
Definition: pixfmt.h:631
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:419
w32dlfcn.h