src/core/vsapi.cpp

   1 /*
   2 * Copyright (c) 2012 Fredrik Mellbin
   3 *
   4 * This file is part of VapourSynth.
   5 *
   6 * VapourSynth is free software; you can redistribute it and/or
   7 * modify it under the terms of the GNU Lesser General Public
   8 * License as published by the Free Software Foundation; either
   9 * version 2.1 of the License, or (at your option) any later version.
  10 *
  11 * VapourSynth is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 * Lesser General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU Lesser General Public
  17 * License along with Libav; if not, write to the Free Software
  18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19 */
  20
  21 #include "vscore.h"
  22 #include "version.h"
  23
  24 void VS_CC configPlugin(const char *identifier, const char *defaultNamespace, const char *name, int apiVersion, int readOnly, VSPlugin *plugin) {
  25     plugin->configPlugin(identifier, defaultNamespace, name, apiVersion, readOnly);
  26 }
  27
  28 void VS_CC registerFunction(const char *name, const char *args, VSPublicFunction argsFunc, void *functionData, VSPlugin *plugin) {
  29     plugin->registerFunction(name, args, argsFunc, functionData);
  30 }
  31
  32 static const VSFormat *VS_CC getFormatPreset(int id, VSCore *core) {
  33     return core->getFormatPreset((VSPresetFormat)id);
  34 }
  35
  36 static const VSFormat *VS_CC registerFormat(int colorFamily, int sampleType, int bytesPerSample, int subSamplingW, int subSamplingH, VSCore *core) {
  37     return core->registerFormat((VSColorFamily)colorFamily, (VSSampleType)sampleType, bytesPerSample, subSamplingW, subSamplingH);
  38 }
  39
  40 static const VSFrameRef *VS_CC cloneFrameRef(const VSFrameRef *frame) {
  41     Q_ASSERT(frame);
  42     return new VSFrameRef(frame->frame);
  43 }
  44
  45 static const VSNodeRef *VS_CC cloneNodeRef(const VSNodeRef *node) {
  46     Q_ASSERT(node);
  47     return new VSNodeRef(node->clip);
  48 }
  49
  50 static int VS_CC getStride(const VSFrameRef *frame, int plane) {
  51     return frame->frame->getStride(plane);
  52 }
  53
  54 static const uint8_t *VS_CC getReadPtr(const VSFrameRef *frame, int plane) {
  55     return frame->frame->getReadPtr(plane);
  56 }
  57
  58 static uint8_t *VS_CC getWritePtr(VSFrameRef *frame, int plane) {
  59     return frame->frame->getWritePtr(plane);
  60 }
  61
  62 static void VS_CC getFrameAsync(int n, const VSNodeRef *clip, VSFrameDoneCallback fdc, void *userData) {
  63     PFrameContext g(new FrameContext(n, clip, fdc, userData));
  64     clip->clip->getFrame(g);
  65 }
  66
  67 struct GetFrameWaiter {
  68     QMutex b;
  69     QWaitCondition a;
  70     const VSFrameRef *r;
  71     char *errorMsg;
  72     int bufSize;
  73     GetFrameWaiter(char *errorMsg, int bufSize) : errorMsg(errorMsg), bufSize(bufSize) {}
  74 };
  75
  76 static void VS_CC frameWaiterCallback(void *userData, const VSFrameRef *frame, int n, const VSNodeRef *, const char *errorMsg) {
  77     GetFrameWaiter *g = (GetFrameWaiter *)userData;
  78     QMutexLocker l(&g->b);
  79     g->r = frame;
  80     memset(g->errorMsg, 0, g->bufSize);
  81     if (errorMsg)
  82         strncpy(g->errorMsg, errorMsg, g->bufSize - 1);
  83     g->a.wakeOne();
  84 }
  85
  86 static const VSFrameRef *VS_CC getFrame(int n, const VSNodeRef *clip, char *errorMsg, int bufSize) {
  87     GetFrameWaiter g(errorMsg, bufSize);
  88     QMutexLocker l(&g.b);
  89     getFrameAsync(n, clip, &frameWaiterCallback, &g);
  90     g.a.wait(&g.b);
  91     return g.r;
  92 }
  93
  94 static void VS_CC requestFrameFilter(int n, const VSNodeRef *clip, VSFrameContext *ctxHandle) {
  95     PFrameContext f(*(PFrameContext *)ctxHandle);
  96     PFrameContext g(new FrameContext(n, clip->clip.data(), f));
  97     clip->clip->getFrame(g);
  98 }
  99
 100 static const VSFrameRef *VS_CC getFrameFilter(int n, const VSNodeRef *clip, VSFrameContext *ctxHandle) {
 101     PFrameContext f(*(PFrameContext *)ctxHandle);
 102     PVideoFrame g = f->availableFrames.value(FrameKey(clip->clip.data(), n));
 103
 104     if (g)
 105         return new VSFrameRef(g);
 106     else
 107         return NULL;
 108 }
 109
 110 static void VS_CC freeFrame(const VSFrameRef *frame) {
 111     delete frame;
 112 }
 113
 114 static void VS_CC freeNode(const VSNodeRef *clip) {
 115     delete clip;
 116 }
 117
 118 static VSFrameRef *VS_CC newVideoFrame(const VSFormat *f, int width, int height, const VSFrameRef *propSrc, VSCore *core) {
 119     Q_ASSERT(f);
 120     return new VSFrameRef(core->newVideoFrame(f, width, height, propSrc ? propSrc->frame.data() : NULL));
 121 }
 122
 123 static VSFrameRef *VS_CC copyFrame(const VSFrameRef *frame, VSCore *core) {
 124     return new VSFrameRef(core->copyFrame(frame->frame));
 125 }
 126
 127 static void VS_CC copyFrameProps(const VSFrameRef *src, VSFrameRef *dst, VSCore *core) {
 128     core->copyFrameProps(src->frame, dst->frame);
 129 }
 130
 131 static const VSNodeRef *VS_CC createFilter(const VSMap *in, VSMap *out, const char *name, VSFilterInit init, VSFilterGetFrame getFrame, VSFilterFree free, int filterMode, int flags, void *instanceData, VSCore *core) {
 132     return new VSNodeRef(core->createFilter(in, out, name, init, getFrame, free, static_cast<VSFilterMode>(filterMode), flags, instanceData));
 133 }
 134
 135 static void VS_CC setError(VSMap *map, const char *errorMessage) {
 136     map->clear();
 137     VSVariant l(VSVariant::vData);
 138     l.s.append(errorMessage ? errorMessage : "Error: no error specified");
 139     map->insert("_Error", l);
 140 }
 141
 142 static const char *VS_CC getError(const VSMap *map) {
 143     if (map->contains("_Error"))
 144         return (*map)["_Error"].s[0].constData();
 145     else
 146         return NULL;
 147 }
 148
 149 static void VS_CC setFilterError(const char *errorMessage, VSFrameContext *context) {
 150     PFrameContext f(*(PFrameContext *)context);
 151     f->setError(errorMessage);
 152 }
 153
 154 //property access functions
 155 static const VSVideoInfo *VS_CC getVideoInfo(const VSNodeRef *c) {
 156     return &c->clip->getVideoInfo();
 157 }
 158
 159 static void VS_CC setVideoInfo(const VSVideoInfo *vi, VSNode *c) {
 160     c->setVideoInfo(*vi);
 161 }
 162
 163 static const VSFormat *VS_CC getFrameFormat(const VSFrameRef *f) {
 164     return f->frame->getFormat();
 165 }
 166
 167 static int VS_CC getFrameWidth(const VSFrameRef *f, int plane) {
 168     return f->frame->getWidth(plane);
 169 }
 170
 171 static int VS_CC getFrameHeight(const VSFrameRef *f, int plane) {
 172     return f->frame->getHeight(plane);
 173 }
 174
 175 static const VSMap *VS_CC getFramePropsRO(const VSFrameRef *frame) {
 176     return &frame->frame->getConstProperties();
 177 }
 178
 179 static VSMap *VS_CC getFramePropsRW(VSFrameRef *frame) {
 180     return &frame->frame->getProperties();
 181 }
 182
 183 static int VS_CC propNumKeys(const VSMap *props) {
 184     return props->keys().count();
 185 }
 186
 187 static const char *VS_CC propGetKey(const VSMap *props, int index) {
 188     if (index < 0 || index >= props->count())
 189         qFatal("Out of bound index");
 190
 191     return props->keys()[index].constData();
 192 }
 193
 194 static int VS_CC propNumElements(const VSMap *props, const char *name) {
 195     if (!props->contains(name))
 196         return -1;
 197
 198     const VSVariant &val = (*props)[name];
 199     return val.count();
 200 }
 201
 202 static char VS_CC propGetType(const VSMap *props, const char *name) {
 203     if (!props->contains(name))
 204         return 'u';
 205
 206     const char a[] = { 'u', 'i', 'f', 's', 'c', 'v', 'm'};
 207     const VSVariant &val = (*props)[name];
 208     return a[val.vtype];
 209 }
 210
 211 static int getPropErrorCheck(const VSMap *props, const char *name, int index, int *error, int type) {
 212     int err = 0;
 213
 214     if (vsapi.getError(props))
 215         qFatal(QByteArray("Attempted to read from a map with error set: ") + vsapi.getError(props));
 216
 217     if (!props->contains(name))
 218         err |= peUnset;
 219
 220     if (!err && props->value(name).vtype != type)
 221         err |= peType;
 222
 223     int c = propNumElements(props, name);
 224
 225     if (!err && c <= index || index < 0)
 226         err |= peIndex;
 227
 228     if (err && !error)
 229         qFatal(QByteArray("Property read unsuccessful but no error output: ") + name);
 230
 231     if (error)
 232         *error = err;
 233
 234     return err;
 235 }
 236
 237 static int64_t VS_CC propGetInt(const VSMap *props, const char *name, int index, int *error) {
 238     int err = getPropErrorCheck(props, name, index, error, VSVariant::vInt);
 239
 240     if (err)
 241         return 0;
 242
 243     const VSVariant &l = (*props)[name];
 244     return l.i[index];
 245 }
 246
 247 static double VS_CC propGetFloat(const VSMap *props, const char *name, int index, int *error) {
 248     int err = getPropErrorCheck(props, name, index, error, VSVariant::vFloat);
 249
 250     if (err)
 251         return 0;
 252
 253     const VSVariant &l = (*props)[name];
 254     return l.f[index];
 255 }
 256
 257 static const char *VS_CC propGetData(const VSMap *props, const char *name, int index, int *error) {
 258     int err = getPropErrorCheck(props, name, index, error, VSVariant::vData);
 259
 260     if (err)
 261         return 0;
 262
 263     const VSVariant &l = (*props)[name];
 264     return l.s[index].constData();
 265 }
 266
 267 static int VS_CC propGetDataSize(const VSMap *props, const char *name, int index, int *error) {
 268     int err = getPropErrorCheck(props, name, index, error, VSVariant::vData);
 269
 270     if (err)
 271         return 0;
 272
 273     const VSVariant &l = (*props)[name];
 274     return l.s[index].size();
 275 }
 276
 277 static const VSNodeRef *VS_CC propGetNode(const VSMap *props, const char *name, int index, int *error) {
 278     int err = getPropErrorCheck(props, name, index, error, VSVariant::vNode);
 279
 280     if (err)
 281         return 0;
 282
 283     const VSVariant &l = (*props)[name];
 284     return new VSNodeRef(l.c[index]);
 285 }
 286
 287 static const VSFrameRef *VS_CC propGetFrame(const VSMap *props, const char *name, int index, int *error) {
 288     int err = getPropErrorCheck(props, name, index, error, VSVariant::vFrame);
 289
 290     if (err)
 291         return 0;
 292
 293     const VSVariant &l = (*props)[name];
 294     return new VSFrameRef(l.v[index]);
 295 }
 296
 297 static int VS_CC propDeleteKey(VSMap *props, const char *name) {
 298     return props->remove(name);
 299 }
 300
 301 static void sharedPropSet(VSMap *props, const char *name, int &append) {
 302     if (append != paReplace && append != paAppend && append != paTouch)
 303         qFatal("Invalid prop append mode given");
 304
 305     if (append == paReplace) {
 306         props->remove(name);
 307         append = paAppend;
 308     }
 309 }
 310
 311 static int VS_CC propSetInt(VSMap *props, const char *name, int64_t i, int append) {
 312     sharedPropSet(props, name, append);
 313     if (props->contains(name)) {
 314         VSVariant &l = (*props)[name];
 315
 316         if (l.vtype != VSVariant::vInt)
 317             return 1;
 318         else if (append == paAppend)
 319             l.i.append(i);
 320     } else {
 321         VSVariant l(VSVariant::vInt);
 322         if (append == paAppend)
 323             l.i.append(i);
 324         props->insert(name, l);
 325     }
 326
 327     return 0;
 328 }
 329
 330 static int VS_CC propSetFloat(VSMap *props, const char *name, double d, int append) {
 331     sharedPropSet(props, name, append);
 332     if (props->contains(name)) {
 333         VSVariant &l = (*props)[name];
 334
 335         if (l.vtype != VSVariant::vFloat)
 336             return 1;
 337         else if (append == paAppend)
 338             l.f.append(d);
 339     } else {
 340         VSVariant l(VSVariant::vFloat);
 341         if (append == paAppend)
 342             l.f.append(d);
 343         props->insert(name, l);
 344     }
 345
 346     return 0;
 347 }
 348
 349 static int VS_CC propSetData(VSMap *props, const char *name, const char *d, int length, int append) {
 350     sharedPropSet(props, name, append);
 351     if (props->contains(name)) {
 352         VSVariant &l = (*props)[name];
 353
 354         if (l.vtype != VSVariant::vData)
 355             return 1;
 356         else if (append == paAppend)
 357             l.s.append(d);
 358     } else {
 359         VSVariant l(VSVariant::vData);
 360         if (append == paAppend)
 361             l.s.append(length >= 0 ? QByteArray(d, length) : QByteArray(d));
 362         props->insert(name, l);
 363     }
 364
 365     return 0;
 366 }
 367
 368 static int VS_CC propSetNode(VSMap *props, const char *name, const VSNodeRef *clip, int append) {
 369     sharedPropSet(props, name, append);
 370     if (props->contains(name)) {
 371         VSVariant &l = (*props)[name];
 372
 373         if (l.vtype != VSVariant::vNode)
 374             return 1;
 375         else if (append == paAppend)
 376             l.c.append(clip->clip);
 377     } else {
 378         VSVariant l(VSVariant::vNode);
 379         if (append == paAppend)
 380             l.c.append(clip->clip);
 381         props->insert(name, l);
 382     }
 383
 384     return 0;
 385 }
 386
 387 static int VS_CC propSetFrame(VSMap *props, const char *name, const VSFrameRef *frame, int append) {
 388     sharedPropSet(props, name, append);
 389     if (props->contains(name)) {
 390         VSVariant &l = (*props)[name];
 391
 392         if (l.vtype != VSVariant::vFrame)
 393             return 1;
 394         else if (append == paAppend)
 395             l.v.append(frame->frame);
 396     } else {
 397         VSVariant l(VSVariant::vFrame);
 398         if (append == paAppend)
 399             l.v.append(frame->frame);
 400         props->insert(name, l);
 401     }
 402
 403     return 0;
 404 }
 405
 406 static VSMap *VS_CC invoke(VSPlugin *plugin, const char *name, const VSMap *args) {
 407     Q_ASSERT(plugin);
 408     return new VSMap(plugin->invoke(name, *args));
 409 }
 410
 411 static VSMap *VS_CC newMap() {
 412     return new VSMap();
 413 }
 414
 415 static void VS_CC freeMap(VSMap *map) {
 416     delete map;
 417 }
 418
 419 static void VS_CC clearMap(VSMap *map) {
 420     map->clear();
 421 }
 422
 423 static VSCore *VS_CC createCore(int *threads) {
 424     return new VSCore(*threads);
 425 }
 426
 427 static void VS_CC freeCore(VSCore *core) {
 428     delete core;
 429 }
 430
 431 const VSAPI *VS_CC getVapourSynthAPI(int version) {
 432     if (version == VAPOURSYNTH_API_VERSION)
 433         return &vsapi;
 434     else
 435         return NULL;
 436 }
 437
 438 static VSPlugin *VS_CC getPluginId(const char *identifier, VSCore *core) {
 439     return core->getPluginId(identifier);
 440 }
 441
 442 static VSPlugin *VS_CC getPluginNs(const char *ns, VSCore *core) {
 443     return core->getPluginNs(ns);
 444 }
 445
 446 static VSMap *VS_CC getPlugins(VSCore *core) {
 447     return new VSMap(core->getPlugins());
 448 }
 449
 450 static VSMap *VS_CC getFunctions(VSPlugin *plugin) {
 451     return new VSMap(plugin->getFunctions());
 452 }
 453
 454 static const VSVersion version = { VAPOURSYNTH_CORE_VERSION, VAPOURSYNTH_API_VERSION, VAPOURSYNTH_VERSION_STRING };
 455
 456 static const VSVersion *VS_CC getVersion() {
 457     return &version;
 458 }
 459
 460 static VSFuncRef *VS_CC propGetFunc(const VSMap *props, const char *name, int index, int *error) {
 461     int err = getPropErrorCheck(props, name, index, error, VSVariant::vMethod);
 462
 463     if (err)
 464         return 0;
 465
 466     const VSVariant &l = (*props)[name];
 467     return new VSFuncRef(l.m[index]);
 468 }
 469
 470 static int VS_CC propSetFunc(VSMap *props, const char *name, VSFuncRef *func, int append) {
 471     if (!append)
 472         props->remove(name);
 473
 474     if (props->contains(name)) {
 475         VSVariant &l = (*props)[name];
 476
 477         if (l.vtype != VSVariant::vMethod)
 478             return 1;
 479         else
 480             l.m.append(func->func);
 481     } else {
 482         VSVariant l(VSVariant::vMethod);
 483         l.m.append(func->func);
 484         props->insert(name, l);
 485     }
 486
 487     return 0;
 488 }
 489
 490 static void VS_CC callFunc(VSFuncRef *func, const VSMap *in, VSMap *out, VSCore *core, const VSAPI *vsapi) {
 491     func->func->call(in, out, core, vsapi);
 492 }
 493
 494 static VSFuncRef *VS_CC createFunc(VSPublicFunction func, void *userData, VSFreeFuncData free) {
 495     return new VSFuncRef(PExtFunction(new ExtFunction(func, userData, free)));
 496 }
 497
 498 static void VS_CC freeFunc(VSFuncRef *f) {
 499     delete f;
 500 }
 501
 502 static void VS_CC queryCompletedFrame(const VSNodeRef **node, int *n, VSFrameContext *frameCtx) {
 503     PFrameContext f(*(PFrameContext *)frameCtx);
 504     *node = f->lastCompletedNode;
 505     *n = f->lastCompletedN;
 506 }
 507
 508 static void VS_CC releaseFrameEarly(const VSNodeRef *node, int n, VSFrameContext *frameCtx) {
 509     PFrameContext f(*(PFrameContext *)frameCtx);
 510     f->availableFrames.remove(FrameKey(node->clip.data(), n));
 511 }
 512
 513 static VSFuncRef *VS_CC cloneFuncRef(VSFuncRef *f) {
 514     return new VSFuncRef(f->func);
 515 }
 516
 517 const VSAPI vsapi = {
 518     &createCore,
 519     &freeCore,
 520     &getVersion,
 521
 522     &cloneFrameRef,
 523     &cloneNodeRef,
 524     &cloneFuncRef,
 525
 526     &freeFrame,
 527     &freeNode,
 528     &freeFunc,
 529
 530     &newVideoFrame,
 531     &copyFrame,
 532     &copyFrameProps,
 533     &registerFunction,
 534     &getPluginId,
 535     &getPluginNs,
 536     &getPlugins,
 537     &getFunctions,
 538     &createFilter,
 539     &setError,
 540     &getError,
 541     &setFilterError,
 542     &invoke,
 543     &getFormatPreset,
 544     &registerFormat,
 545     &getFrame,
 546     &getFrameAsync,
 547     &getFrameFilter,
 548     &requestFrameFilter,
 549     &queryCompletedFrame,
 550     &releaseFrameEarly,
 551
 552     &getStride,
 553     &getReadPtr,
 554     &getWritePtr,
 555
 556     &createFunc,
 557     &callFunc,
 558
 559     &newMap,
 560     &freeMap,
 561     &clearMap,
 562
 563     &getVideoInfo,
 564     &setVideoInfo,
 565     &getFrameFormat,
 566     &getFrameWidth,
 567     &getFrameHeight,
 568     &getFramePropsRO,
 569     &getFramePropsRW,
 570
 571     &propNumKeys,
 572     &propGetKey,
 573     &propNumElements,
 574     &propGetType,
 575     &propGetInt,
 576     &propGetFloat,
 577     &propGetData,
 578     &propGetDataSize,
 579     &propGetNode,
 580     &propGetFrame,
 581     &propGetFunc,
 582     &propDeleteKey,
 583     &propSetInt,
 584     &propSetFloat,
 585     &propSetData,
 586     &propSetNode,
 587     &propSetFrame,
 588     &propSetFunc
 589 };