FFmpeg  4.4
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  #undef EXTERN_C
38  #define AVISYNTH_LIB "avisynth"
39 #else
40  #include <dlfcn.h>
41  #define AVISYNTH_NAME "libavisynth"
42  #define AVISYNTH_LIB AVISYNTH_NAME SLIBSUF
43 #endif
44 
45 /* Endianness guards for audio */
46 #if HAVE_BIGENDIAN
47  #define PCM(format) (AV_CODEC_ID_PCM_ ## format ## BE)
48 #else
49  #define PCM(format) (AV_CODEC_ID_PCM_ ## format ## LE)
50 #endif
51 
52 #include <avisynth/avisynth_c.h>
53 
54 typedef struct AviSynthLibrary {
55  void *library;
56 #define AVSC_DECLARE_FUNC(name) name ## _func name
57  AVSC_DECLARE_FUNC(avs_bit_blt);
58  AVSC_DECLARE_FUNC(avs_clip_get_error);
59  AVSC_DECLARE_FUNC(avs_create_script_environment);
60  AVSC_DECLARE_FUNC(avs_delete_script_environment);
61  AVSC_DECLARE_FUNC(avs_get_audio);
62  AVSC_DECLARE_FUNC(avs_get_error);
63  AVSC_DECLARE_FUNC(avs_get_frame);
64  AVSC_DECLARE_FUNC(avs_get_version);
65  AVSC_DECLARE_FUNC(avs_get_video_info);
66  AVSC_DECLARE_FUNC(avs_invoke);
67  AVSC_DECLARE_FUNC(avs_is_color_space);
68  AVSC_DECLARE_FUNC(avs_release_clip);
69  AVSC_DECLARE_FUNC(avs_release_value);
70  AVSC_DECLARE_FUNC(avs_release_video_frame);
71  AVSC_DECLARE_FUNC(avs_take_clip);
72  AVSC_DECLARE_FUNC(avs_bits_per_pixel);
73  AVSC_DECLARE_FUNC(avs_get_height_p);
74  AVSC_DECLARE_FUNC(avs_get_pitch_p);
75  AVSC_DECLARE_FUNC(avs_get_read_ptr_p);
76  AVSC_DECLARE_FUNC(avs_get_row_size_p);
77  AVSC_DECLARE_FUNC(avs_is_planar_rgb);
78  AVSC_DECLARE_FUNC(avs_is_planar_rgba);
79 #undef AVSC_DECLARE_FUNC
81 
82 typedef struct AviSynthContext {
83  AVS_ScriptEnvironment *env;
84  AVS_Clip *clip;
85  const AVS_VideoInfo *vi;
86 
87  /* avisynth_read_packet_video() iterates over this. */
88  int n_planes;
89  const int *planes;
90 
93  int64_t curr_sample;
94 
95  int error;
96 
97  /* Linked list pointers. */
100 
101 static const int avs_planes_packed[1] = { 0 };
102 static const int avs_planes_grey[1] = { AVS_PLANAR_Y };
103 static const int avs_planes_yuv[3] = { AVS_PLANAR_Y, AVS_PLANAR_U,
104  AVS_PLANAR_V };
105 static const int avs_planes_rgb[3] = { AVS_PLANAR_G, AVS_PLANAR_B,
106  AVS_PLANAR_R };
107 static const int avs_planes_yuva[4] = { AVS_PLANAR_Y, AVS_PLANAR_U,
108  AVS_PLANAR_V, AVS_PLANAR_A };
109 static const int avs_planes_rgba[4] = { AVS_PLANAR_G, AVS_PLANAR_B,
110  AVS_PLANAR_R, AVS_PLANAR_A };
111 
112 /* A conflict between C++ global objects, atexit, and dynamic loading requires
113  * us to register our own atexit handler to prevent double freeing. */
115 static int avs_atexit_called = 0;
116 
117 /* Linked list of AviSynthContexts. An atexit handler destroys this list. */
119 
120 static av_cold void avisynth_atexit_handler(void);
121 
123 {
124  avs_library.library = dlopen(AVISYNTH_LIB, RTLD_NOW | RTLD_LOCAL);
125  if (!avs_library.library)
126  return AVERROR_UNKNOWN;
127 
128 #define LOAD_AVS_FUNC(name, continue_on_fail) \
129  avs_library.name = (name ## _func) \
130  dlsym(avs_library.library, #name); \
131  if (!continue_on_fail && !avs_library.name) \
132  goto fail;
133 
134  LOAD_AVS_FUNC(avs_bit_blt, 0);
135  LOAD_AVS_FUNC(avs_clip_get_error, 0);
136  LOAD_AVS_FUNC(avs_create_script_environment, 0);
137  LOAD_AVS_FUNC(avs_delete_script_environment, 0);
138  LOAD_AVS_FUNC(avs_get_audio, 0);
139  LOAD_AVS_FUNC(avs_get_error, 1); // New to AviSynth 2.6
140  LOAD_AVS_FUNC(avs_get_frame, 0);
141  LOAD_AVS_FUNC(avs_get_version, 0);
142  LOAD_AVS_FUNC(avs_get_video_info, 0);
143  LOAD_AVS_FUNC(avs_invoke, 0);
144  LOAD_AVS_FUNC(avs_is_color_space, 1);
145  LOAD_AVS_FUNC(avs_release_clip, 0);
146  LOAD_AVS_FUNC(avs_release_value, 0);
147  LOAD_AVS_FUNC(avs_release_video_frame, 0);
148  LOAD_AVS_FUNC(avs_take_clip, 0);
149  LOAD_AVS_FUNC(avs_bits_per_pixel, 1);
150  LOAD_AVS_FUNC(avs_get_height_p, 1);
151  LOAD_AVS_FUNC(avs_get_pitch_p, 1);
152  LOAD_AVS_FUNC(avs_get_read_ptr_p, 1);
153  LOAD_AVS_FUNC(avs_get_row_size_p, 1);
154  LOAD_AVS_FUNC(avs_is_planar_rgb, 1);
155  LOAD_AVS_FUNC(avs_is_planar_rgba, 1);
156 #undef LOAD_AVS_FUNC
157 
158  atexit(avisynth_atexit_handler);
159  return 0;
160 
161 fail:
162  dlclose(avs_library.library);
163  return AVERROR_UNKNOWN;
164 }
165 
166 /* Note that avisynth_context_create and avisynth_context_destroy
167  * do not allocate or free the actual context! That is taken care of
168  * by libavformat. */
170 {
171  AviSynthContext *avs = s->priv_data;
172  int ret;
173 
174  if (!avs_library.library)
175  if (ret = avisynth_load_library())
176  return ret;
177 
178  avs->env = avs_library.avs_create_script_environment(3);
179  if (avs_library.avs_get_error) {
180  const char *error = avs_library.avs_get_error(avs->env);
181  if (error) {
182  av_log(s, AV_LOG_ERROR, "%s\n", error);
183  return AVERROR_UNKNOWN;
184  }
185  }
186 
187  if (!avs_ctx_list) {
188  avs_ctx_list = avs;
189  } else {
190  avs->next = avs_ctx_list;
191  avs_ctx_list = avs;
192  }
193 
194  return 0;
195 }
196 
198 {
199  if (avs_atexit_called)
200  return;
201 
202  if (avs == avs_ctx_list) {
203  avs_ctx_list = avs->next;
204  } else {
206  while (prev->next != avs)
207  prev = prev->next;
208  prev->next = avs->next;
209  }
210 
211  if (avs->clip) {
212  avs_library.avs_release_clip(avs->clip);
213  avs->clip = NULL;
214  }
215  if (avs->env) {
216  avs_library.avs_delete_script_environment(avs->env);
217  avs->env = NULL;
218  }
219 }
220 
222 {
224 
225  while (avs) {
226  AviSynthContext *next = avs->next;
228  avs = next;
229  }
230  dlclose(avs_library.library);
231 
232  avs_atexit_called = 1;
233 }
234 
235 /* Create AVStream from audio and video data. */
237 {
238  AviSynthContext *avs = s->priv_data;
239  int planar = 0; // 0: packed, 1: YUV, 2: Y8, 3: Planar RGB, 4: YUVA, 5: Planar RGBA
240 
243  st->codecpar->width = avs->vi->width;
244  st->codecpar->height = avs->vi->height;
245 
246  st->avg_frame_rate = (AVRational) { avs->vi->fps_numerator,
247  avs->vi->fps_denominator };
248  st->start_time = 0;
249  st->duration = avs->vi->num_frames;
250  st->nb_frames = avs->vi->num_frames;
251  avpriv_set_pts_info(st, 32, avs->vi->fps_denominator, avs->vi->fps_numerator);
252 
253  av_log(s, AV_LOG_TRACE, "avs_is_field_based: %d\n", avs_is_field_based(avs->vi));
254  av_log(s, AV_LOG_TRACE, "avs_is_parity_known: %d\n", avs_is_parity_known(avs->vi));
255 
256  /* The following typically only works when assumetff (-bff) and
257  * assumefieldbased is used in-script. Additional
258  * logic using GetParity() could deliver more accurate results
259  * but also decodes a frame which we want to avoid. */
261  if (avs_is_field_based(avs->vi)) {
262  if (avs_is_tff(avs->vi)) {
264  }
265  else if (avs_is_bff(avs->vi)) {
267  }
268  }
269 
270  switch (avs->vi->pixel_type) {
271  /* 10~16-bit YUV pix_fmts (AviSynth+) */
272  case AVS_CS_YUV444P10:
274  planar = 1;
275  break;
276  case AVS_CS_YUV422P10:
278  planar = 1;
279  break;
280  case AVS_CS_YUV420P10:
282  planar = 1;
283  break;
284  case AVS_CS_YUV444P12:
286  planar = 1;
287  break;
288  case AVS_CS_YUV422P12:
290  planar = 1;
291  break;
292  case AVS_CS_YUV420P12:
294  planar = 1;
295  break;
296  case AVS_CS_YUV444P14:
298  planar = 1;
299  break;
300  case AVS_CS_YUV422P14:
302  planar = 1;
303  break;
304  case AVS_CS_YUV420P14:
306  planar = 1;
307  break;
308  case AVS_CS_YUV444P16:
310  planar = 1;
311  break;
312  case AVS_CS_YUV422P16:
314  planar = 1;
315  break;
316  case AVS_CS_YUV420P16:
318  planar = 1;
319  break;
320  /* 8~16-bit YUV pix_fmts with Alpha (AviSynth+) */
321  case AVS_CS_YUVA444:
323  planar = 4;
324  break;
325  case AVS_CS_YUVA422:
327  planar = 4;
328  break;
329  case AVS_CS_YUVA420:
331  planar = 4;
332  break;
333  case AVS_CS_YUVA444P10:
335  planar = 4;
336  break;
337  case AVS_CS_YUVA422P10:
339  planar = 4;
340  break;
341  case AVS_CS_YUVA420P10:
343  planar = 4;
344  break;
345  case AVS_CS_YUVA422P12:
347  planar = 4;
348  break;
349  case AVS_CS_YUVA444P16:
351  planar = 4;
352  break;
353  case AVS_CS_YUVA422P16:
355  planar = 4;
356  break;
357  case AVS_CS_YUVA420P16:
359  planar = 4;
360  break;
361  /* Planar RGB pix_fmts (AviSynth+) */
362  case AVS_CS_RGBP:
364  planar = 3;
365  break;
366  case AVS_CS_RGBP10:
368  planar = 3;
369  break;
370  case AVS_CS_RGBP12:
372  planar = 3;
373  break;
374  case AVS_CS_RGBP14:
376  planar = 3;
377  break;
378  case AVS_CS_RGBP16:
380  planar = 3;
381  break;
382  /* Single precision floating point Planar RGB (AviSynth+) */
383  case AVS_CS_RGBPS:
385  planar = 3;
386  break;
387  /* Planar RGB pix_fmts with Alpha (AviSynth+) */
388  case AVS_CS_RGBAP:
390  planar = 5;
391  break;
392  case AVS_CS_RGBAP10:
394  planar = 5;
395  break;
396  case AVS_CS_RGBAP12:
398  planar = 5;
399  break;
400  case AVS_CS_RGBAP16:
402  planar = 5;
403  break;
404  /* Single precision floating point Planar RGB with Alpha (AviSynth+) */
405  case AVS_CS_RGBAPS:
407  planar = 5;
408  break;
409  /* 10~16-bit gray pix_fmts (AviSynth+) */
410  case AVS_CS_Y10:
412  planar = 2;
413  break;
414  case AVS_CS_Y12:
416  planar = 2;
417  break;
418  case AVS_CS_Y14:
420  planar = 2;
421  break;
422  case AVS_CS_Y16:
424  planar = 2;
425  break;
426  /* Single precision floating point gray (AviSynth+) */
427  case AVS_CS_Y32:
429  planar = 2;
430  break;
431  /* pix_fmts added in AviSynth 2.6 */
432  case AVS_CS_YV24:
434  planar = 1;
435  break;
436  case AVS_CS_YV16:
438  planar = 1;
439  break;
440  case AVS_CS_YV411:
442  planar = 1;
443  break;
444  case AVS_CS_Y8:
446  planar = 2;
447  break;
448  /* 16-bit packed RGB pix_fmts (AviSynth+) */
449  case AVS_CS_BGR48:
451  break;
452  case AVS_CS_BGR64:
454  break;
455  /* AviSynth 2.5 pix_fmts */
456  case AVS_CS_BGR24:
458  break;
459  case AVS_CS_BGR32:
461  break;
462  case AVS_CS_YUY2:
464  break;
465  case AVS_CS_YV12:
467  planar = 1;
468  break;
469  case AVS_CS_I420: // Is this even used anywhere?
471  planar = 1;
472  break;
473  default:
475  "unknown AviSynth colorspace %d\n", avs->vi->pixel_type);
476  avs->error = 1;
477  return AVERROR_UNKNOWN;
478  }
479 
480  switch (planar) {
481  case 5: // Planar RGB + Alpha
482  avs->n_planes = 4;
483  avs->planes = avs_planes_rgba;
484  break;
485  case 4: // YUV + Alpha
486  avs->n_planes = 4;
487  avs->planes = avs_planes_yuva;
488  break;
489  case 3: // Planar RGB
490  avs->n_planes = 3;
491  avs->planes = avs_planes_rgb;
492  break;
493  case 2: // Y8
494  avs->n_planes = 1;
495  avs->planes = avs_planes_grey;
496  break;
497  case 1: // YUV
498  avs->n_planes = 3;
499  avs->planes = avs_planes_yuv;
500  break;
501  default:
502  avs->n_planes = 1;
503  avs->planes = avs_planes_packed;
504  }
505  return 0;
506 }
507 
509 {
510  AviSynthContext *avs = s->priv_data;
511 
513  st->codecpar->sample_rate = avs->vi->audio_samples_per_second;
514  st->codecpar->channels = avs->vi->nchannels;
515  st->duration = avs->vi->num_audio_samples;
516  avpriv_set_pts_info(st, 64, 1, avs->vi->audio_samples_per_second);
517 
518  switch (avs->vi->sample_type) {
519  case AVS_SAMPLE_INT8:
521  break;
522  case AVS_SAMPLE_INT16:
523  st->codecpar->codec_id = PCM(S16);
524  break;
525  case AVS_SAMPLE_INT24:
526  st->codecpar->codec_id = PCM(S24);
527  break;
528  case AVS_SAMPLE_INT32:
529  st->codecpar->codec_id = PCM(S32);
530  break;
531  case AVS_SAMPLE_FLOAT:
532  st->codecpar->codec_id = PCM(F32);
533  break;
534  default:
536  "unknown AviSynth sample type %d\n", avs->vi->sample_type);
537  avs->error = 1;
538  return AVERROR_UNKNOWN;
539  }
540  return 0;
541 }
542 
544 {
545  AviSynthContext *avs = s->priv_data;
546  AVStream *st;
547  int ret;
548  int id = 0;
549 
550  if (avs_has_video(avs->vi)) {
551  st = avformat_new_stream(s, NULL);
552  if (!st)
553  return AVERROR_UNKNOWN;
554  st->id = id++;
555  if (ret = avisynth_create_stream_video(s, st))
556  return ret;
557  }
558  if (avs_has_audio(avs->vi)) {
559  st = avformat_new_stream(s, NULL);
560  if (!st)
561  return AVERROR_UNKNOWN;
562  st->id = id++;
563  if (ret = avisynth_create_stream_audio(s, st))
564  return ret;
565  }
566  return 0;
567 }
568 
570 {
571  AviSynthContext *avs = s->priv_data;
572  AVS_Value arg, val;
573  int ret;
574 #ifdef _WIN32
575  char filename_ansi[MAX_PATH * 4];
576  wchar_t filename_wc[MAX_PATH * 4];
577 #endif
578 
579  if (ret = avisynth_context_create(s))
580  return ret;
581 
582 #ifdef _WIN32
583  /* Convert UTF-8 to ANSI code page */
584  MultiByteToWideChar(CP_UTF8, 0, s->url, -1, filename_wc, MAX_PATH * 4);
585  WideCharToMultiByte(CP_THREAD_ACP, 0, filename_wc, -1, filename_ansi,
586  MAX_PATH * 4, NULL, NULL);
587  arg = avs_new_value_string(filename_ansi);
588 #else
589  arg = avs_new_value_string(s->url);
590 #endif
591  val = avs_library.avs_invoke(avs->env, "Import", arg, 0);
592  if (avs_is_error(val)) {
593  av_log(s, AV_LOG_ERROR, "%s\n", avs_as_error(val));
594  ret = AVERROR_UNKNOWN;
595  goto fail;
596  }
597  if (!avs_is_clip(val)) {
598  av_log(s, AV_LOG_ERROR, "AviSynth script did not return a clip\n");
599  ret = AVERROR_UNKNOWN;
600  goto fail;
601  }
602 
603  avs->clip = avs_library.avs_take_clip(val, avs->env);
604  avs->vi = avs_library.avs_get_video_info(avs->clip);
605 
606  /* On Windows, FFmpeg supports AviSynth interface version 6 or higher.
607  * This includes AviSynth 2.6 RC1 or higher, and AviSynth+ r1718 or higher,
608  * and excludes 2.5 and the 2.6 alphas. */
609 
610  if (avs_library.avs_get_version(avs->clip) < 6) {
612  "AviSynth version is too old. Please upgrade to either AviSynth 2.6 >= RC1 or AviSynth+ >= r1718.\n");
613  ret = AVERROR_UNKNOWN;
614  goto fail;
615  }
616 
617  /* Release the AVS_Value as it will go out of scope. */
618  avs_library.avs_release_value(val);
619 
620  if (ret = avisynth_create_stream(s))
621  goto fail;
622 
623  return 0;
624 
625 fail:
627  return ret;
628 }
629 
631  AVPacket *pkt, int *discard)
632 {
633  AviSynthContext *avs = s->priv_data;
634 
635  avs->curr_stream++;
636  avs->curr_stream %= s->nb_streams;
637 
638  *st = s->streams[avs->curr_stream];
639  if ((*st)->discard == AVDISCARD_ALL)
640  *discard = 1;
641  else
642  *discard = 0;
643 
644  return;
645 }
646 
647 /* Copy AviSynth clip data into an AVPacket. */
649  int discard)
650 {
651  AviSynthContext *avs = s->priv_data;
652  AVS_VideoFrame *frame;
653  unsigned char *dst_p;
654  const unsigned char *src_p;
655  int n, i, plane, rowsize, planeheight, pitch, bits, ret;
656  const char *error;
657 
658  if (avs->curr_frame >= avs->vi->num_frames)
659  return AVERROR_EOF;
660 
661  /* This must happen even if the stream is discarded to prevent desync. */
662  n = avs->curr_frame++;
663  if (discard)
664  return 0;
665 
666  bits = avs_library.avs_bits_per_pixel(avs->vi);
667 
668  /* Without the cast to int64_t, calculation overflows at about 9k x 9k
669  * resolution. */
670  pkt->size = (((int64_t)avs->vi->width *
671  (int64_t)avs->vi->height) * bits) / 8;
672  if (!pkt->size)
673  return AVERROR_UNKNOWN;
674 
675  if ((ret = av_new_packet(pkt, pkt->size)) < 0)
676  return ret;
677 
678  pkt->pts = n;
679  pkt->dts = n;
680  pkt->duration = 1;
681  pkt->stream_index = avs->curr_stream;
682 
683  frame = avs_library.avs_get_frame(avs->clip, n);
684  error = avs_library.avs_clip_get_error(avs->clip);
685  if (error) {
686  av_log(s, AV_LOG_ERROR, "%s\n", error);
687  avs->error = 1;
689  return AVERROR_UNKNOWN;
690  }
691 
692  dst_p = pkt->data;
693  for (i = 0; i < avs->n_planes; i++) {
694  plane = avs->planes[i];
695  src_p = avs_library.avs_get_read_ptr_p(frame, plane);
696  pitch = avs_library.avs_get_pitch_p(frame, plane);
697 
698  rowsize = avs_library.avs_get_row_size_p(frame, plane);
699  planeheight = avs_library.avs_get_height_p(frame, plane);
700 
701  /* Flip RGB video. */
702  if (avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR) ||
703  avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR48) ||
704  avs_library.avs_is_color_space(avs->vi, AVS_CS_BGR64)) {
705  src_p = src_p + (planeheight - 1) * pitch;
706  pitch = -pitch;
707  }
708 
709  avs_library.avs_bit_blt(avs->env, dst_p, rowsize, src_p, pitch,
710  rowsize, planeheight);
711  dst_p += rowsize * planeheight;
712  }
713 
714  avs_library.avs_release_video_frame(frame);
715  return 0;
716 }
717 
719  int discard)
720 {
721  AviSynthContext *avs = s->priv_data;
722  AVRational fps, samplerate;
723  int samples, ret;
724  int64_t n;
725  const char *error;
726 
727  if (avs->curr_sample >= avs->vi->num_audio_samples)
728  return AVERROR_EOF;
729 
730  fps.num = avs->vi->fps_numerator;
731  fps.den = avs->vi->fps_denominator;
732  samplerate.num = avs->vi->audio_samples_per_second;
733  samplerate.den = 1;
734 
735  if (avs_has_video(avs->vi)) {
736  if (avs->curr_frame < avs->vi->num_frames)
737  samples = av_rescale_q(avs->curr_frame, samplerate, fps) -
738  avs->curr_sample;
739  else
740  samples = av_rescale_q(1, samplerate, fps);
741  } else {
742  samples = 1000;
743  }
744 
745  /* After seeking, audio may catch up with video. */
746  if (samples <= 0) {
747  pkt->size = 0;
748  pkt->data = NULL;
749  return 0;
750  }
751 
752  if (avs->curr_sample + samples > avs->vi->num_audio_samples)
753  samples = avs->vi->num_audio_samples - avs->curr_sample;
754 
755  /* This must happen even if the stream is discarded to prevent desync. */
756  n = avs->curr_sample;
757  avs->curr_sample += samples;
758  if (discard)
759  return 0;
760 
761  pkt->size = avs_bytes_per_channel_sample(avs->vi) *
762  samples * avs->vi->nchannels;
763  if (!pkt->size)
764  return AVERROR_UNKNOWN;
765 
766  if ((ret = av_new_packet(pkt, pkt->size)) < 0)
767  return ret;
768 
769  pkt->pts = n;
770  pkt->dts = n;
771  pkt->duration = samples;
772  pkt->stream_index = avs->curr_stream;
773 
774  avs_library.avs_get_audio(avs->clip, pkt->data, n, samples);
775  error = avs_library.avs_clip_get_error(avs->clip);
776  if (error) {
777  av_log(s, AV_LOG_ERROR, "%s\n", error);
778  avs->error = 1;
780  return AVERROR_UNKNOWN;
781  }
782  return 0;
783 }
784 
786 {
787  int ret;
788 
789  // Calling library must implement a lock for thread-safe opens.
790  if (ret = ff_lock_avformat())
791  return ret;
792 
793  if (ret = avisynth_open_file(s)) {
795  return ret;
796  }
797 
799  return 0;
800 }
801 
803 {
804  AviSynthContext *avs = s->priv_data;
805  AVStream *st;
806  int discard = 0;
807  int ret;
808 
809  if (avs->error)
810  return AVERROR_UNKNOWN;
811 
812  /* If either stream reaches EOF, try to read the other one before
813  * giving up. */
814  avisynth_next_stream(s, &st, pkt, &discard);
815  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
816  ret = avisynth_read_packet_video(s, pkt, discard);
817  if (ret == AVERROR_EOF && avs_has_audio(avs->vi)) {
818  avisynth_next_stream(s, &st, pkt, &discard);
819  return avisynth_read_packet_audio(s, pkt, discard);
820  }
821  } else {
822  ret = avisynth_read_packet_audio(s, pkt, discard);
823  if (ret == AVERROR_EOF && avs_has_video(avs->vi)) {
824  avisynth_next_stream(s, &st, pkt, &discard);
825  return avisynth_read_packet_video(s, pkt, discard);
826  }
827  }
828 
829  return ret;
830 }
831 
833 {
834  if (ff_lock_avformat())
835  return AVERROR_UNKNOWN;
836 
837  avisynth_context_destroy(s->priv_data);
839  return 0;
840 }
841 
842 static int avisynth_read_seek(AVFormatContext *s, int stream_index,
843  int64_t timestamp, int flags)
844 {
845  AviSynthContext *avs = s->priv_data;
846  AVStream *st;
847  AVRational fps, samplerate;
848 
849  if (avs->error)
850  return AVERROR_UNKNOWN;
851 
852  fps = (AVRational) { avs->vi->fps_numerator,
853  avs->vi->fps_denominator };
854  samplerate = (AVRational) { avs->vi->audio_samples_per_second, 1 };
855 
856  st = s->streams[stream_index];
857  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
858  /* AviSynth frame counts are signed int. */
859  if ((timestamp >= avs->vi->num_frames) ||
860  (timestamp > INT_MAX) ||
861  (timestamp < 0))
862  return AVERROR_EOF;
863  avs->curr_frame = timestamp;
864  if (avs_has_audio(avs->vi))
865  avs->curr_sample = av_rescale_q(timestamp, samplerate, fps);
866  } else {
867  if ((timestamp >= avs->vi->num_audio_samples) || (timestamp < 0))
868  return AVERROR_EOF;
869  /* Force frame granularity for seeking. */
870  if (avs_has_video(avs->vi)) {
871  avs->curr_frame = av_rescale_q(timestamp, fps, samplerate);
872  avs->curr_sample = av_rescale_q(avs->curr_frame, samplerate, fps);
873  } else {
874  avs->curr_sample = timestamp;
875  }
876  }
877 
878  return 0;
879 }
880 
882  .name = "avisynth",
883  .long_name = NULL_IF_CONFIG_SMALL("AviSynth script"),
884  .priv_data_size = sizeof(AviSynthContext),
889  .extensions = "avs",
890 };
static double val(void *priv, double ch)
Definition: aeval.c:76
Macro definitions for various function/variable attributes.
#define av_cold
Definition: attributes.h:88
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;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);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
Main libavformat public API header.
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
static av_cold int avisynth_context_create(AVFormatContext *s)
Definition: avisynth.c:169
static const int avs_planes_yuv[3]
Definition: avisynth.c:103
#define AVISYNTH_LIB
Definition: avisynth.c:42
static int avisynth_create_stream(AVFormatContext *s)
Definition: avisynth.c:543
static av_cold int avisynth_load_library(void)
Definition: avisynth.c:122
static int avisynth_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: avisynth.c:842
static int avisynth_create_stream_video(AVFormatContext *s, AVStream *st)
Definition: avisynth.c:236
static const int avs_planes_rgb[3]
Definition: avisynth.c:105
#define LOAD_AVS_FUNC(name, continue_on_fail)
static av_cold int avisynth_read_header(AVFormatContext *s)
Definition: avisynth.c:785
static void avisynth_next_stream(AVFormatContext *s, AVStream **st, AVPacket *pkt, int *discard)
Definition: avisynth.c:630
static const int avs_planes_grey[1]
Definition: avisynth.c:102
static av_cold void avisynth_atexit_handler(void)
Definition: avisynth.c:221
AVInputFormat ff_avisynth_demuxer
Definition: avisynth.c:881
static int avisynth_read_packet_video(AVFormatContext *s, AVPacket *pkt, int discard)
Definition: avisynth.c:648
static AviSynthContext * avs_ctx_list
Definition: avisynth.c:118
static av_cold void avisynth_context_destroy(AviSynthContext *avs)
Definition: avisynth.c:197
static int avs_atexit_called
Definition: avisynth.c:115
static int avisynth_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: avisynth.c:802
static const int avs_planes_yuva[4]
Definition: avisynth.c:107
static int avisynth_create_stream_audio(AVFormatContext *s, AVStream *st)
Definition: avisynth.c:508
static av_cold int avisynth_read_close(AVFormatContext *s)
Definition: avisynth.c:832
#define PCM(format)
Definition: avisynth.c:49
static AviSynthLibrary avs_library
Definition: avisynth.c:114
static int avisynth_open_file(AVFormatContext *s)
Definition: avisynth.c:569
static const int avs_planes_rgba[4]
Definition: avisynth.c:109
static const int avs_planes_packed[1]
Definition: avisynth.c:101
static int avisynth_read_packet_audio(AVFormatContext *s, AVPacket *pkt, int discard)
Definition: avisynth.c:718
#define flags(name, subs,...)
Definition: cbs_av1.c:561
#define s(width, name)
Definition: cbs_vp9.c:257
#define fail()
Definition: checkasm.h:133
@ AV_FIELD_TT
Definition: codec_par.h:39
@ AV_FIELD_BB
Definition: codec_par.h:40
@ AV_FIELD_UNKNOWN
Definition: codec_par.h:37
#define NULL
Definition: coverity.c:32
static AVFrame * frame
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:62
@ AV_CODEC_ID_PCM_U8
Definition: codec_id.h:318
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4505
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
#define AVERROR_EOF
End of file.
Definition: error.h:55
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:220
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
int i
Definition: input.c:407
common internal api header.
const char * arg
Definition: jacosubdec.c:66
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4941
int ff_unlock_avformat(void)
Definition: utils.c:84
int ff_lock_avformat(void)
Definition: utils.c:79
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
static int read_seek(AVFormatContext *ctx, int stream_index, int64_t timestamp, int flags)
Definition: libcdio.c:153
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:420
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:410
#define AV_PIX_FMT_GBRPF32
Definition: pixfmt.h:428
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
#define AV_PIX_FMT_GBRAP16
Definition: pixfmt.h:421
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
#define AV_PIX_FMT_BGR48
Definition: pixfmt.h:390
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:441
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_GRAY12
Definition: pixfmt.h:381
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:431
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
@ 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_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
#define AV_PIX_FMT_YUVA422P12
Definition: pixfmt.h:439
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:380
#define AV_PIX_FMT_GRAY14
Definition: pixfmt.h:382
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
#define AV_PIX_FMT_BGRA64
Definition: pixfmt.h:394
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:419
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
#define AV_PIX_FMT_GBRAPF32
Definition: pixfmt.h:429
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:372
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
enum AVFieldOrder field_order
Video only.
Definition: codec_par.h:141
int channels
Audio only.
Definition: codec_par.h:166
int width
Video only.
Definition: codec_par.h:126
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
int sample_rate
Audio only.
Definition: codec_par.h:170
Format I/O context.
Definition: avformat.h:1232
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
This structure stores compressed data.
Definition: packet.h:346
int stream_index
Definition: packet.h:371
int size
Definition: packet.h:370
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:368
uint8_t * data
Definition: packet.h:369
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int num
Numerator.
Definition: rational.h:59
int den
Denominator.
Definition: rational.h:60
Stream structure.
Definition: avformat.h:873
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:924
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
int id
Format-specific stream ID.
Definition: avformat.h:880
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:912
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:946
AVS_Clip * clip
Definition: avisynth.c:84
int64_t curr_sample
Definition: avisynth.c:93
AVS_ScriptEnvironment * env
Definition: avisynth.c:83
const AVS_VideoInfo * vi
Definition: avisynth.c:85
const int * planes
Definition: avisynth.c:89
struct AviSynthContext * next
Definition: avisynth.c:98
void * library
Definition: avisynth.c:55
AVSC_DECLARE_FUNC(avs_bits_per_pixel)
AVSC_DECLARE_FUNC(avs_get_video_info)
AVSC_DECLARE_FUNC(avs_get_read_ptr_p)
AVSC_DECLARE_FUNC(avs_is_planar_rgb)
AVSC_DECLARE_FUNC(avs_get_frame)
AVSC_DECLARE_FUNC(avs_release_video_frame)
AVSC_DECLARE_FUNC(avs_get_height_p)
AVSC_DECLARE_FUNC(avs_clip_get_error)
AVSC_DECLARE_FUNC(avs_release_value)
AVSC_DECLARE_FUNC(avs_get_version)
AVSC_DECLARE_FUNC(avs_take_clip)
AVSC_DECLARE_FUNC(avs_is_planar_rgba)
AVSC_DECLARE_FUNC(avs_delete_script_environment)
AVSC_DECLARE_FUNC(avs_get_error)
AVSC_DECLARE_FUNC(avs_create_script_environment)
AVSC_DECLARE_FUNC(avs_invoke)
AVSC_DECLARE_FUNC(avs_get_audio)
AVSC_DECLARE_FUNC(avs_get_pitch_p)
AVSC_DECLARE_FUNC(avs_is_color_space)
AVSC_DECLARE_FUNC(avs_bit_blt)
AVSC_DECLARE_FUNC(avs_release_clip)
AVSC_DECLARE_FUNC(avs_get_row_size_p)
#define av_log(a,...)
static void error(const char *err)
AVPacket * pkt
Definition: movenc.c:59
uint8_t bits
Definition: vp3data.h:141