libavformat/vapoursynth.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 /**
  20 * @file
  21 * VapourSynth demuxer
  22 *
  23 * Synthesizes vapour (?)
  24 */
  25
  26 #include <limits.h>
  27
  28 #include <vapoursynth/VSScript4.h>
  29
  30 #include "libavutil/avassert.h"
  31 #include "libavutil/avstring.h"
  32 #include "libavutil/eval.h"
  33 #include "libavutil/frame.h"
  34 #include "libavutil/imgutils.h"
  35 #include "libavutil/mem.h"
  36 #include "libavutil/opt.h"
  37 #include "libavutil/pixdesc.h"
  38 #include "avformat.h"
  39 #include "demux.h"
  40 #include "internal.h"
  41
  42 /* Platform-specific directives. */
  43 #ifdef _WIN32
  44   #include <windows.h>
  45   #include "compat/w32dlfcn.h"
  46   #include "libavutil/wchar_filename.h"
  47   #undef EXTERN_C
  48   #define VSSCRIPT_LIB "VSScript.dll"
  49 #else
  50   #include <dlfcn.h>
  51   #define VSSCRIPT_NAME "libvapoursynth-script"
  52   #define VSSCRIPT_LIB VSSCRIPT_NAME SLIBSUF
  53 #endif
  54
  55 struct VSState {
  56     const VSSCRIPTAPI *vssapi;
  57     VSScript *vss;
  58 };
  59
  60 typedef const VSSCRIPTAPI *(*VSScriptGetAPIFunc)(int version);
  61
  62 typedef struct VSContext {
  63     const AVClass *class;
  64
  65     AVBufferRef *vss_state;
  66
  67     const VSSCRIPTAPI *vssapi;
  68     const VSAPI *vsapi;
  69     void *vslibrary;
  70
  71     VSNode *outnode;
  72     int is_cfr;
  73     int current_frame;
  74
  75     int c_order[4];
  76
  77     /* options */
  78     int64_t max_script_size;
  79 } VSContext;
  80
  81 #define OFFSET(x) offsetof(VSContext, x)
  82 #define A AV_OPT_FLAG_AUDIO_PARAM
  83 #define D AV_OPT_FLAG_DECODING_PARAM
  84 static const AVOption options[] = {
  85     {"max_script_size",    "set max file size supported (in bytes)", OFFSET(max_script_size),    AV_OPT_TYPE_INT64, {.i64 = 1 * 1024 * 1024}, 0,    SIZE_MAX - 1, A|D},
  86     {NULL}
  87 };
  88
  89 static av_cold void* vs_load_library(VSScriptGetAPIFunc *get_vssapi)
  90 {
  91     void *vslibrary = NULL;
  92 #ifdef _WIN32
  93     const HKEY hkeys[] = {HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE};
  94     LONG r;
  95     WCHAR vss_path[512];
  96     DWORD buf_size = sizeof(vss_path) - 2;
  97     char *vss_path_utf8;
  98     int i;
  99
 100     for (i = 0; i < FF_ARRAY_ELEMS(hkeys); i++) {
 101         if ((r = RegGetValueW(hkeys[i], L"SOFTWARE\\VapourSynth",
 102                       L"VSScriptDLL", RRF_RT_REG_SZ, NULL,
 103                       &vss_path, &buf_size)) == ERROR_SUCCESS)
 104             break;
 105     }
 106     if (r == ERROR_SUCCESS && wchartoutf8(vss_path, &vss_path_utf8) == 0) {
 107         vslibrary = dlopen(vss_path_utf8, RTLD_NOW | RTLD_GLOBAL);
 108         av_free(vss_path_utf8);
 109     }
 110     else
 111 #endif
 112     vslibrary = dlopen(VSSCRIPT_LIB, RTLD_NOW | RTLD_GLOBAL);
 113
 114     if (vslibrary != NULL) {
 115         if (!(*get_vssapi = (VSScriptGetAPIFunc)dlsym(vslibrary, "getVSScriptAPI"))) {
 116             dlclose(vslibrary);
 117             return NULL;
 118         }
 119     }
 120     return vslibrary;
 121 }
 122
 123 static void free_vss_state(void *opaque, uint8_t *data)
 124 {
 125     struct VSState *vss = opaque;
 126
 127     if (vss->vss) {
 128         vss->vssapi->freeScript(vss->vss);
 129     }
 130 }
 131
 132 static av_cold int read_close_vs(AVFormatContext *s)
 133 {
 134     VSContext *vs = s->priv_data;
 135
 136     if (vs->outnode)
 137         vs->vsapi->freeNode(vs->outnode);
 138
 139     av_buffer_unref(&vs->vss_state);
 140
 141     vs->vsapi = NULL;
 142     vs->outnode = NULL;
 143
 144     if (vs->vslibrary)
 145         dlclose(vs->vslibrary);
 146
 147     return 0;
 148 }
 149
 150 static av_cold int is_native_endian(enum AVPixelFormat pixfmt)
 151 {
 152     enum AVPixelFormat other = av_pix_fmt_swap_endianness(pixfmt);
 153     const AVPixFmtDescriptor *pd;
 154     if (other == AV_PIX_FMT_NONE || other == pixfmt)
 155         return 1; // not affected by byte order
 156     pd = av_pix_fmt_desc_get(pixfmt);
 157     return pd && (!!HAVE_BIGENDIAN == !!(pd->flags & AV_PIX_FMT_FLAG_BE));
 158 }
 159
 160 static av_cold enum AVPixelFormat match_pixfmt(const VSVideoFormat *vsf, int c_order[4])
 161 {
 162     static const int yuv_order[4] = {0, 1, 2, 0};
 163     static const int rgb_order[4] = {1, 2, 0, 0};
 164     const AVPixFmtDescriptor *pd;
 165
 166     for (pd = av_pix_fmt_desc_next(NULL); pd; pd = av_pix_fmt_desc_next(pd)) {
 167         int is_rgb, is_yuv, i;
 168         const int *order;
 169         enum AVPixelFormat pixfmt;
 170
 171         pixfmt = av_pix_fmt_desc_get_id(pd);
 172
 173         if (pd->flags & (AV_PIX_FMT_FLAG_BAYER | AV_PIX_FMT_FLAG_ALPHA |
 174                          AV_PIX_FMT_FLAG_HWACCEL | AV_PIX_FMT_FLAG_BITSTREAM |
 175                          AV_PIX_FMT_FLAG_XYZ))
 176             continue;
 177
 178         if (pd->log2_chroma_w != vsf->subSamplingW ||
 179             pd->log2_chroma_h != vsf->subSamplingH)
 180             continue;
 181
 182         is_rgb = vsf->colorFamily == cfRGB;
 183         if (is_rgb != !!(pd->flags & AV_PIX_FMT_FLAG_RGB))
 184             continue;
 185
 186         is_yuv = vsf->colorFamily == cfYUV ||
 187                  vsf->colorFamily == cfGray;
 188         if (!is_rgb && !is_yuv)
 189             continue;
 190
 191         if (vsf->sampleType != ((pd->flags & AV_PIX_FMT_FLAG_FLOAT) ? stFloat : stInteger))
 192             continue;
 193
 194         if (av_pix_fmt_count_planes(pixfmt) != vsf->numPlanes)
 195             continue;
 196
 197         if (!is_native_endian(pixfmt))
 198             continue;
 199
 200         order = is_yuv ? yuv_order : rgb_order;
 201
 202         for (i = 0; i < pd->nb_components; i++) {
 203             const AVComponentDescriptor *c = &pd->comp[i];
 204             if (order[c->plane] != i ||
 205                 c->offset != 0 || c->shift != 0 ||
 206                 c->step != vsf->bytesPerSample ||
 207                 c->depth != vsf->bitsPerSample)
 208                 goto cont;
 209         }
 210
 211         // Use it.
 212         memcpy(c_order, order, sizeof(int[4]));
 213         return pixfmt;
 214
 215     cont: ;
 216     }
 217
 218     return AV_PIX_FMT_NONE;
 219 }
 220
 221 static av_cold int read_header_vs(AVFormatContext *s)
 222 {
 223     AVStream *st;
 224     AVIOContext *pb = s->pb;
 225     VSContext *vs = s->priv_data;
 226     VSScriptGetAPIFunc get_vssapi;
 227     int64_t sz = avio_size(pb);
 228     char *buf = NULL;
 229     char dummy;
 230     char vsfmt[32];
 231     const VSVideoInfo *info;
 232     struct VSState *vss_state;
 233     int err = 0;
 234
 235     if (!(vs->vslibrary = vs_load_library(&get_vssapi))) {
 236         av_log(s, AV_LOG_ERROR, "Could not open " VSSCRIPT_LIB ". "
 237                                 "Check VapourSynth installation.\n");
 238         err = AVERROR_EXTERNAL;
 239         goto done;
 240     }
 241
 242     if (!(vs->vssapi = get_vssapi(VSSCRIPT_API_VERSION))) {
 243         av_log(s, AV_LOG_ERROR, "Failed to initialize VSScript (possibly PYTHONPATH not set).\n");
 244         err = AVERROR_EXTERNAL;
 245         goto done;
 246     }
 247
 248     if (!(vs->vsapi = vs->vssapi->getVSAPI(VAPOURSYNTH_API_VERSION))) {
 249         av_log(s, AV_LOG_ERROR, "Could not get VSAPI. "
 250                                 "Check VapourSynth installation.\n");
 251         err = AVERROR_EXTERNAL;
 252         goto done;
 253     }
 254
 255     vss_state = av_mallocz(sizeof(*vss_state));
 256     if (!vss_state) {
 257         err = AVERROR(ENOMEM);
 258         goto done;
 259     }
 260     vss_state->vssapi = vs->vssapi;
 261
 262     vs->vss_state = av_buffer_create(NULL, 0, free_vss_state, vss_state, 0);
 263     if (!vs->vss_state) {
 264         err = AVERROR(ENOMEM);
 265         av_free(vss_state);
 266         goto done;
 267     }
 268
 269     if (!(vss_state->vss = vs->vssapi->createScript(NULL))) {
 270         av_log(s, AV_LOG_ERROR, "Failed to create script instance.\n");
 271         err = AVERROR_EXTERNAL;
 272         goto done;
 273     }
 274
 275     if (sz < 0 || sz > vs->max_script_size) {
 276         if (sz < 0)
 277             av_log(s, AV_LOG_WARNING, "Could not determine file size\n");
 278         sz = vs->max_script_size;
 279     }
 280
 281     buf = av_malloc(sz + 1);
 282     if (!buf) {
 283         err = AVERROR(ENOMEM);
 284         goto done;
 285     }
 286     sz = avio_read(pb, buf, sz);
 287
 288     if (sz < 0) {
 289         av_log(s, AV_LOG_ERROR, "Could not read script.\n");
 290         err = sz;
 291         goto done;
 292     }
 293
 294     // Data left means our buffer (the max_script_size option) is too small
 295     if (avio_read(pb, &dummy, 1) == 1) {
 296         av_log(s, AV_LOG_ERROR, "File size is larger than max_script_size option "
 297                "value %"PRIi64", consider increasing the max_script_size option\n",
 298                vs->max_script_size);
 299         err = AVERROR_BUFFER_TOO_SMALL;
 300         goto done;
 301     }
 302
 303     buf[sz] = '\0';
 304     if (vs->vssapi->evaluateBuffer(vss_state->vss, buf, s->url)) {
 305         const char *msg = vs->vssapi->getError(vss_state->vss);
 306         av_log(s, AV_LOG_ERROR, "Failed to parse script: %s\n", msg ? msg : "(unknown)");
 307         err = AVERROR_EXTERNAL;
 308         goto done;
 309     }
 310
 311     vs->outnode = vs->vssapi->getOutputNode(vss_state->vss, 0);
 312     if (!vs->outnode) {
 313         av_log(s, AV_LOG_ERROR, "Could not get script output node.\n");
 314         err = AVERROR_EXTERNAL;
 315         goto done;
 316     }
 317
 318     st = avformat_new_stream(s, NULL);
 319     if (!st) {
 320         err = AVERROR(ENOMEM);
 321         goto done;
 322     }
 323
 324     info = vs->vsapi->getVideoInfo(vs->outnode);
 325
 326     if (!info->format.colorFamily || !info->width || !info->height) {
 327         av_log(s, AV_LOG_ERROR, "Non-constant input format not supported.\n");
 328         err = AVERROR_PATCHWELCOME;
 329         goto done;
 330     }
 331
 332     if (info->fpsDen) {
 333         vs->is_cfr = 1;
 334         avpriv_set_pts_info(st, 64, info->fpsDen, info->fpsNum);
 335         st->duration = info->numFrames;
 336     } else {
 337         // VFR. Just set "something".
 338         avpriv_set_pts_info(st, 64, 1, AV_TIME_BASE);
 339         s->ctx_flags |= AVFMTCTX_UNSEEKABLE;
 340     }
 341
 342     st->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 343     st->codecpar->codec_id = AV_CODEC_ID_WRAPPED_AVFRAME;
 344     st->codecpar->width = info->width;
 345     st->codecpar->height = info->height;
 346     st->codecpar->format = match_pixfmt(&info->format, vs->c_order);
 347
 348     if (st->codecpar->format == AV_PIX_FMT_NONE) {
 349         av_log(s, AV_LOG_ERROR, "Unsupported VS pixel format %s\n",
 350                vs->vsapi->getVideoFormatName(&info->format, vsfmt) ? vsfmt : "(unknown)");
 351         err = AVERROR_EXTERNAL;
 352         goto done;
 353     }
 354     av_log(s, AV_LOG_VERBOSE, "VS format %s -> pixfmt %s\n",
 355            vs->vsapi->getVideoFormatName(&info->format, vsfmt) ? vsfmt : "(unknown)",
 356            av_get_pix_fmt_name(st->codecpar->format));
 357
 358 done:
 359     av_free(buf);
 360     return err;
 361 }
 362
 363 static void free_frame(void *opaque, uint8_t *data)
 364 {
 365     AVFrame *frame = (AVFrame *)data;
 366
 367     av_frame_free(&frame);
 368 }
 369
 370 static int get_vs_prop_int(AVFormatContext *s, const VSMap *map, const char *name, int def)
 371 {
 372     VSContext *vs = s->priv_data;
 373     int64_t res;
 374     int err = 1;
 375
 376     res = vs->vsapi->mapGetInt(map, name, 0, &err);
 377     return err || res < INT_MIN || res > INT_MAX ? def : res;
 378 }
 379
 380 struct vsframe_ref_data {
 381     const VSAPI *vsapi;
 382     const VSFrame *frame;
 383     AVBufferRef *vss_state;
 384 };
 385
 386 static void free_vsframe_ref(void *opaque, uint8_t *data)
 387 {
 388     struct vsframe_ref_data *d = opaque;
 389
 390     if (d->frame)
 391         d->vsapi->freeFrame(d->frame);
 392
 393     av_buffer_unref(&d->vss_state);
 394
 395     av_free(d);
 396 }
 397
 398 static int read_packet_vs(AVFormatContext *s, AVPacket *pkt)
 399 {
 400     VSContext *vs = s->priv_data;
 401     AVStream *st = s->streams[0];
 402     AVFrame *frame = NULL;
 403     char vserr[80];
 404     const VSFrame *vsframe;
 405     const VSVideoInfo *info = vs->vsapi->getVideoInfo(vs->outnode);
 406     const VSMap *props;
 407     const AVPixFmtDescriptor *desc;
 408     AVBufferRef *vsframe_ref = NULL;
 409     struct vsframe_ref_data *ref_data;
 410     int err = 0;
 411     int i;
 412
 413     if (vs->current_frame >= info->numFrames)
 414         return AVERROR_EOF;
 415
 416     ref_data = av_mallocz(sizeof(*ref_data));
 417     if (!ref_data) {
 418         err = AVERROR(ENOMEM);
 419         goto end;
 420     }
 421
 422     // (the READONLY flag is important because the ref is reused for plane data)
 423     vsframe_ref = av_buffer_create(NULL, 0, free_vsframe_ref, ref_data, AV_BUFFER_FLAG_READONLY);
 424     if (!vsframe_ref) {
 425         err = AVERROR(ENOMEM);
 426         av_free(ref_data);
 427         goto end;
 428     }
 429
 430     vsframe = vs->vsapi->getFrame(vs->current_frame, vs->outnode, vserr, sizeof(vserr));
 431     if (!vsframe) {
 432         av_log(s, AV_LOG_ERROR, "Error getting frame: %s\n", vserr);
 433         err = AVERROR_EXTERNAL;
 434         goto end;
 435     }
 436
 437     ref_data->vsapi = vs->vsapi;
 438     ref_data->frame = vsframe;
 439
 440     ref_data->vss_state = av_buffer_ref(vs->vss_state);
 441     if (!ref_data->vss_state) {
 442         err = AVERROR(ENOMEM);
 443         goto end;
 444     }
 445
 446     props = vs->vsapi->getFramePropertiesRO(vsframe);
 447
 448     frame = av_frame_alloc();
 449     if (!frame) {
 450         err = AVERROR(ENOMEM);
 451         goto end;
 452     }
 453
 454     frame->format       = st->codecpar->format;
 455     frame->width        = st->codecpar->width;
 456     frame->height       = st->codecpar->height;
 457     frame->colorspace   = st->codecpar->color_space;
 458
 459     // Values according to ISO/IEC 14496-10.
 460     frame->colorspace       = get_vs_prop_int(s, props, "_Matrix",      frame->colorspace);
 461     frame->color_primaries  = get_vs_prop_int(s, props, "_Primaries",   frame->color_primaries);
 462     frame->color_trc        = get_vs_prop_int(s, props, "_Transfer",    frame->color_trc);
 463
 464     if (get_vs_prop_int(s, props, "_ColorRange", 1) == 0)
 465         frame->color_range = AVCOL_RANGE_JPEG;
 466
 467     frame->sample_aspect_ratio.num = get_vs_prop_int(s, props, "_SARNum", 0);
 468     frame->sample_aspect_ratio.den = get_vs_prop_int(s, props, "_SARDen", 1);
 469
 470     av_assert0(vs->vsapi->getFrameWidth(vsframe, 0) == frame->width);
 471     av_assert0(vs->vsapi->getFrameHeight(vsframe, 0) == frame->height);
 472
 473     desc = av_pix_fmt_desc_get(frame->format);
 474
 475     for (i = 0; i < info->format.numPlanes; i++) {
 476         int p = vs->c_order[i];
 477         ptrdiff_t plane_h = frame->height;
 478
 479         frame->data[i] = (void *)vs->vsapi->getReadPtr(vsframe, p);
 480         frame->linesize[i] = vs->vsapi->getStride(vsframe, p);
 481
 482         frame->buf[i] = av_buffer_ref(vsframe_ref);
 483         if (!frame->buf[i]) {
 484             err = AVERROR(ENOMEM);
 485             goto end;
 486         }
 487
 488         // Each plane needs an AVBufferRef that indicates the correct plane
 489         // memory range. VapourSynth doesn't even give us the memory range,
 490         // so make up a bad guess to make FFmpeg happy (even if almost nothing
 491         // checks the memory range).
 492         if (i == 1 || i == 2)
 493             plane_h = AV_CEIL_RSHIFT(plane_h, desc->log2_chroma_h);
 494         frame->buf[i]->data = frame->data[i];
 495         frame->buf[i]->size = frame->linesize[i] * plane_h;
 496     }
 497
 498     pkt->buf = av_buffer_create((uint8_t*)frame, sizeof(*frame),
 499                                 free_frame, NULL, 0);
 500     if (!pkt->buf) {
 501         err = AVERROR(ENOMEM);
 502         goto end;
 503     }
 504
 505     frame = NULL; // pkt owns it now
 506
 507     pkt->data   = pkt->buf->data;
 508     pkt->size   = pkt->buf->size;
 509     pkt->flags |= AV_PKT_FLAG_TRUSTED;
 510
 511     if (vs->is_cfr)
 512         pkt->pts = vs->current_frame;
 513
 514     vs->current_frame++;
 515
 516 end:
 517     av_frame_free(&frame);
 518     av_buffer_unref(&vsframe_ref);
 519     return err;
 520 }
 521
 522 static int read_seek_vs(AVFormatContext *s, int stream_idx, int64_t ts, int flags)
 523 {
 524     VSContext *vs = s->priv_data;
 525
 526     if (!vs->is_cfr)
 527         return AVERROR(ENOSYS);
 528
 529     vs->current_frame = FFMIN(FFMAX(0, ts), s->streams[0]->duration);
 530     return 0;
 531 }
 532
 533 static av_cold int probe_vs(const AVProbeData *p)
 534 {
 535     // Explicitly do not support this. VS scripts are written in Python, and
 536     // can run arbitrary code on the user's system.
 537     return 0;
 538 }
 539
 540 static const AVClass class_vs = {
 541     .class_name = "VapourSynth demuxer",
 542     .item_name  = av_default_item_name,
 543     .option     = options,
 544     .version    = LIBAVUTIL_VERSION_INT,
 545 };
 546
 547 const FFInputFormat ff_vapoursynth_demuxer = {
 548     .p.name         = "vapoursynth",
 549     .p.long_name    = NULL_IF_CONFIG_SMALL("VapourSynth demuxer"),
 550     .p.priv_class   = &class_vs,
 551     .priv_data_size = sizeof(VSContext),
 552     .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
 553     .read_probe     = probe_vs,
 554     .read_header    = read_header_vs,
 555     .read_packet    = read_packet_vs,
 556     .read_close     = read_close_vs,
 557     .read_seek      = read_seek_vs,
 558 };