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