VapourSynth 65__zip → 70__zip

{VapourSynth-65 → vapoursynth-70}/src/cython/vapoursynth.pyx

@@ -1,4 +1,4 @@
-#  Copyright (c) 2012-2021 Fredrik Mellbin
+#  Copyright (c) 2012-2024 Fredrik Mellbin
 #
 #  This file is part of VapourSynth.
 #
@@ -66,7 +66,7 @@ __all__ = [
     'YUV420P8', 'YUV420P9', 'YUV420P10', 'YUV420P12', 'YUV420P14', 'YUV420P16',
     'YUV422P8', 'YUV422P9', 'YUV422P10', 'YUV422P12', 'YUV422P14', 'YUV422P16',
     'YUV440P8',
-    'YUV444P8', 'YUV444P9', 'YUV444P10', 'YUV444P12', 'YUV444P14', 'YUV444P16', 'YUV444PH', 'YUV444PS',
+    'YUV444P8', 'YUV444P9', 'YUV444P10', 'YUV444P12', 'YUV444P14', 'YUV444P16', 'YUV420PH', 'YUV420PS', 'YUV422PH', 'YUV422PS', 'YUV444PH', 'YUV444PS',
   'NONE',
 
   'FLOAT', 'INTEGER',
@@ -83,9 +83,163 @@ __all__ = [
   'core',
 ]
 
-__version__ = namedtuple("VapourSynthVersion", "release_major release_minor")(VS_CURRENT_RELEASE, 0)
-__api_version__ = namedtuple("VapourSynthAPIVersion", "api_major api_minor")(VAPOURSYNTH_API_MAJOR, VAPOURSYNTH_API_MINOR)
+class MediaType(IntEnum):
+    VIDEO = mtVideo
+    AUDIO = mtAudio
+
+class ColorFamily(IntEnum):
+    UNDEFINED = cfUndefined
+    GRAY = cfGray
+    RGB = cfRGB
+    YUV = cfYUV
+
+class SampleType(IntEnum):
+    INTEGER = stInteger
+    FLOAT = stFloat
+
+class PresetVideoFormat(IntEnum):
+    NONE = pfNone
+
+    GRAY8 = pfGray8
+    GRAY9 = pfGray9
+    GRAY10 = pfGray10
+    GRAY12 = pfGray12
+    GRAY14 = pfGray14
+    GRAY16 = pfGray16
+    GRAY32 = pfGray32
+
+    GRAYH = pfGrayH
+    GRAYS = pfGrayS
+
+    YUV410P8 = pfYUV410P8
+    YUV411P8 = pfYUV411P8
+    YUV440P8 = pfYUV440P8
+
+    YUV420P8 = pfYUV420P8
+    YUV422P8 = pfYUV422P8
+    YUV444P8 = pfYUV444P8
+
+    YUV420P9 = pfYUV420P9
+    YUV422P9 = pfYUV422P9
+    YUV444P9 = pfYUV444P9
+
+    YUV420P10 = pfYUV420P10
+    YUV422P10 = pfYUV422P10
+    YUV444P10 = pfYUV444P10
+
+    YUV420P12 = pfYUV420P12
+    YUV422P12 = pfYUV422P12
+    YUV444P12 = pfYUV444P12
+
+    YUV420P14 = pfYUV420P14
+    YUV422P14 = pfYUV422P14
+    YUV444P14 = pfYUV444P14
+
+    YUV420P16 = pfYUV420P16
+    YUV422P16 = pfYUV422P16
+    YUV444P16 = pfYUV444P16
+
+    YUV420PH = pfYUV420PH
+    YUV420PS = pfYUV420PS
+    
+    YUV422PH = pfYUV422PH
+    YUV422PS = pfYUV422PS
+
+    YUV444PH = pfYUV444PH
+    YUV444PS = pfYUV444PS
+
+    RGB24 = pfRGB24
+    RGB27 = pfRGB27
+    RGB30 = pfRGB30
+    RGB36 = pfRGB36
+    RGB42 = pfRGB42
+    RGB48 = pfRGB48
+
+    RGBH = pfRGBH
+    RGBS = pfRGBS
+
+class FilterMode(IntEnum):
+    PARALLEL = fmParallel
+    PARALLEL_REQUESTS = fmParallelRequests
+    UNORDERED = fmUnordered
+    FRAME_STATE = fmFrameState 
+
+class AudioChannels(IntEnum):
+    FRONT_LEFT = acFrontLeft
+    FRONT_RIGHT = acFrontRight
+    FRONT_CENTER = acFrontCenter
+    LOW_FREQUENCY = acLowFrequency
+    BACK_LEFT = acBackLeft
+    BACK_RIGHT = acBackRight
+    FRONT_LEFT_OF_CENTER = acFrontLeftOFCenter
+    FRONT_RIGHT_OF_CENTER = acFrontRightOFCenter
+    BACK_CENTER = acBackCenter
+    SIDE_LEFT = acSideLeft
+    SIDE_RIGHT = acSideRight
+    TOP_CENTER = acTopCenter
+    TOP_FRONT_LEFT = acTopFrontLeft
+    TOP_FRONT_CENTER = acTopFrontCenter
+    TOP_FRONT_RIGHT = acTopFrontRight
+    TOP_BACK_LEFT = acTopBackLeft
+    TOP_BACK_CENTER = acTopBackCenter
+    TOP_BACK_RIGHT = acTopBackRight
+    STEREO_LEFT = acStereoLeft
+    STEREO_RIGHT = acStereoRight
+    WIDE_LEFT = acWideLeft
+    WIDE_RIGHT = acWideRight
+    SURROUND_DIRECT_LEFT = acSurroundDirectLeft
+    SURROUND_DIRECT_RIGHT = acSurroundDirectRight
+    LOW_FREQUENCY2 = acLowFrequency2
+
+class MessageType(IntFlag):
+    MESSAGE_TYPE_DEBUG = mtDebug
+    MESSAGE_TYPE_INFORMATION = mtInformation
+    MESSAGE_TYPE_WARNING = mtWarning
+    MESSAGE_TYPE_CRITICAL = mtCritical
+    MESSAGE_TYPE_FATAL = mtFatal
+
+class CoreCreationFlags(IntFlag):
+    ENABLE_GRAPH_INSPECTION = ccfEnableGraphInspection
+    DISABLE_AUTO_LOADING = ccfDisableAutoLoading
+    DISABLE_LIBRARY_UNLOADING = ccfDisableLibraryUnloading
+
+# In this file
+globals().update(MediaType.__members__)
+globals().update(ColorFamily.__members__)
+globals().update(SampleType.__members__)
+globals().update(PresetVideoFormat.__members__)
+globals().update(FilterMode.__members__)
+globals().update(AudioChannels.__members__)
+globals().update(MessageType.__members__)
+globals().update(CoreCreationFlags.__members__)
+
+# From vsconstants.pxd
+globals().update(ColorRange.__members__)
+globals().update(ChromaLocation.__members__)
+globals().update(FieldBased.__members__)
+globals().update(MatrixCoefficients.__members__)
+globals().update(TransferCharacteristics.__members__)
+globals().update(ColorPrimaries.__members__)
+
+class VapourSynthVersion(typing.NamedTuple):
+    release_major: int
+    release_minor: int
 
+    def __str__(self):
+        if self.release_minor:
+            return f'R{self.release_major}.{self.release_minor}'
+        return f'R{self.release_major}'
+
+class VapourSynthAPIVersion(typing.NamedTuple):
+    api_major: int
+    api_minor: int
+
+    def __str__(self):
+        return f'R{self.api_major}.{self.api_minor}'
+
+
+__version__ = VapourSynthVersion(VS_CURRENT_RELEASE, 0)
+__api_version__ = VapourSynthAPIVersion(VAPOURSYNTH_API_MAJOR, VAPOURSYNTH_API_MINOR)
 
 @final
 cdef class EnvironmentData(object):
@@ -201,7 +355,7 @@ cdef void _unset_logger(EnvironmentData env):
 cdef void __stdcall _logCb(int msgType, const char *msg, void *userData) noexcept nogil:
     with gil:
         message = msg.decode("utf-8")
-        (<object>userData)(MessageType(msgType), message)
+        (<object>userData)(msgType, message)
 
 cdef void __stdcall _logFree(void* userData) noexcept nogil:
     with gil:
@@ -326,7 +480,7 @@ def _try_enable_introspection(version=None):
         return False
 
     cdef StandaloneEnvironmentPolicy standalone_policy = StandaloneEnvironmentPolicy.__new__(StandaloneEnvironmentPolicy)
-    standalone_policy._flags = int(CoreCreationFlags.ccfEnableGraphInspection)
+    standalone_policy._flags = ccfEnableGraphInspection;
     register_policy(standalone_policy)
 
     return True
@@ -848,7 +1002,7 @@ cdef void dictToMap(dict ndict, VSMap *inm, VSCore *core, const VSAPI *funcs) ex
         ckey = key.encode('utf-8')
         val = ndict[key]
 
-        if isinstance(val, (str, bytes, bytearray, RawNode, RawFrame)):
+        if isinstance(val, (str, bytes, bytearray, RawNode, RawFrame, enum.Flag)):
             val = [val]
         else:
             try:
@@ -896,7 +1050,7 @@ cdef void typedDictToMap(dict ndict, dict atypes, VSMap *inm, VSCore *core, cons
         if val is None:
             continue
 
-        if isinstance(val, (str, bytes, bytearray, enum.Flag, RawNode, RawFrame)) or not isinstance(val, Iterable):
+        if isinstance(val, (str, bytes, bytearray, enum.Flag, RawNode, RawFrame, enum.Flag)) or not isinstance(val, Iterable):
             val = [val]
 
         for v in val:
@@ -1098,7 +1252,7 @@ cdef class FrameProps(object):
         cdef bytes b = name.encode('utf-8')
         cdef const VSAPI *funcs = self.funcs
         val = value
-        if isinstance(val, (str, bytes, bytearray, RawNode, RawFrame)):
+        if isinstance(val, (str, bytes, bytearray, RawNode, RawFrame, enum.Flag)):
             val = [val]
         else:
             try:
@@ -1518,7 +1672,7 @@ cdef class _frame:
         cdef:
             unsigned mask
 
-        if lib.getFrameType(frame) is VIDEO:
+        if lib.getFrameType(frame) == mtVideo:
             mask = 1 << index+1
         else:
             mask = ~1  # there's only one plane in audio frames
@@ -1578,14 +1732,14 @@ cdef class _video:
         self.base.itemsize = format.bytesPerSample
         self.base.strides[1] = format.bytesPerSample
 
-        if format.sampleType == INTEGER:
+        if format.sampleType == stInteger:
             if format.bytesPerSample == 1:
                 self.base.format = 'B'
             elif format.bytesPerSample == 2:
                 self.base.format = 'H'
             elif format.bytesPerSample == 4:
                 self.base.format = 'I'
-        elif format.sampleType == FLOAT:
+        elif format.sampleType == stFloat:
             if format.bytesPerSample == 2:
                 self.base.format = 'e'
             elif format.bytesPerSample == 4:
@@ -1750,12 +1904,12 @@ cdef class _audio:
         self = _1dview_contig.__new__(_1dview_contig)
         self.base.itemsize = format.bytesPerSample
 
-        if format.sampleType == INTEGER:
+        if format.sampleType == stInteger:
             if format.bytesPerSample == 2:
                 self.base.format = 'H'
             elif format.bytesPerSample == 4:
                 self.base.format = 'I'
-        elif format.sampleType == FLOAT:
+        elif format.sampleType == stFloat:
             if format.bytesPerSample == 4:
                 self.base.format = 'f'
 
@@ -1921,11 +2075,14 @@ cdef class RawNode(object):
 
             gc.collect()
 
+    def clear_cache(self):
+        self.funcs.clearNodeCache(self.node)
+
     # Inspect API
     cdef bint _inspectable(self):
         if self.funcs.getAPIVersion() != VAPOURSYNTH_API_VERSION:
             return False
-        return bool(self.core.flags & CoreCreationFlags.ccfEnableGraphInspection)
+        return bool(self.core.flags & ccfEnableGraphInspection)
 
     def is_inspectable(self, version=None):
         if version != 0:
@@ -1933,11 +2090,30 @@ cdef class RawNode(object):
         return self._inspectable()
 
     @property
-    def _node_name(self):
-        if not self._inspectable():
-            raise Error("This node is not inspectable")
+    def node_name(self):
         return self.funcs.getNodeName(self.node).decode("utf-8")
 
+    property timings:
+        def __get__(self):
+            return self.funcs.getNodeProcessingTime(self.node, False)
+        
+        def __set__(self, bint value):
+            if value != 0:
+                raise ValueError('You can only set timings to 0, to reset its counter!')
+
+            self.funcs.getNodeProcessingTime(self.node, True)
+
+    @property
+    def mode(self):
+        return FilterMode(self.funcs.getNodeFilterMode(self.node))
+
+    @property
+    def dependencies(self):
+        return tuple(
+            createNode(self.funcs.addNodeRef(self.funcs.getNodeDependency(self.node, idx).source), self.funcs, self.core)
+            for idx in range(self.funcs.getNumNodeDependencies(self.node))
+        )
+
     @property
     def _name(self):
         if not self._inspectable():
@@ -1952,28 +2128,6 @@ cdef class RawNode(object):
 
         return mapToDict(self.funcs.getNodeCreationFunctionArguments(self.node, 0), False)
 
-    @property
-    def _timings(self):
-        if not self._inspectable():
-            raise Error("This node is not inspectable")
-        return self.funcs.getNodeFilterTime(self.node)
-
-    @property
-    def _mode(self):
-        if not self._inspectable():
-            raise Error("This node is not inspectable")
-        return FilterMode(self.funcs.getNodeFilterMode(self.node))
-
-    @property
-    def _dependencies(self):
-        if not self._inspectable():
-            raise Error("This node is not inspectable")
-
-        return tuple(
-            createNode(self.funcs.addNodeRef(self.funcs.getNodeDependencies(self.node)[idx].source), self.funcs, self.core)
-            for idx in range(self.funcs.getNumNodeDependencies(self.node))
-        )
-
     def __eq__(self, other):
         if other is self:
             return True
@@ -2019,7 +2173,7 @@ cdef class VideoNode(RawNode):
                 (<Plugin>obj).injected_arg = self
             return obj
         except AttributeError:
-            raise AttributeError(f'There is no attribute or namespace named {name}') from None
+            raise AttributeError(f'There is no attribute or namespace named {name}. Did you mistype a plugin namespace or forget to install a plugin?') from None
 
     cdef ensure_valid_frame_number(self, int n):
         if n < 0:
@@ -2028,13 +2182,13 @@ cdef class VideoNode(RawNode):
             raise ValueError('Requesting frame number is beyond the last frame')
 
     def get_frame(self, int n):
-        cdef char errorMsg[512]
+        cdef char errorMsg[4096]
         cdef char *ep = errorMsg
         cdef const VSFrame *f
         self.ensure_valid_frame_number(n)
 
         with nogil:
-            f = self.funcs.getFrame(n, self.node, errorMsg, 500)
+            f = self.funcs.getFrame(n, self.node, errorMsg, 4096)
         if f == NULL:
             if (errorMsg[0]):
                 raise Error(ep.decode('utf-8'))
@@ -2049,10 +2203,10 @@ cdef class VideoNode(RawNode):
                 raise Error('Alpha clip dimensions must match the main video')
             if (self.num_frames != alpha.num_frames):
                 raise Error('Alpha clip length must match the main video')
-            if (self.vi.format.colorFamily != UNDEFINED) and (alpha.vi.format.colorFamily != UNDEFINED):
-                if (alpha.vi.format.colorFamily != GRAY) or (alpha.vi.format.sampleType != self.vi.format.sampleType) or (alpha.vi.format.bitsPerSample != self.vi.format.bitsPerSample):
+            if (self.vi.format.colorFamily != cfUndefined) and (alpha.vi.format.colorFamily != cfUndefined):
+                if (alpha.vi.format.colorFamily != cfGray) or (alpha.vi.format.sampleType != self.vi.format.sampleType) or (alpha.vi.format.bitsPerSample != self.vi.format.bitsPerSample):
                     raise Error('Alpha clip format must match the main video')
-            elif (self.vi.format.colorFamily != UNDEFINED) or (alpha.vi.format.colorFamily != UNDEFINED):
+            elif (self.vi.format.colorFamily != cfUndefined) or (alpha.vi.format.colorFamily != cfUndefined):
                 raise Error('Format must be either known or unknown for both alpha and main clip')
 
         _get_output_dict("set_output")[index] = VideoOutputTuple(self, alpha, alt_output)
@@ -2071,11 +2225,11 @@ cdef class VideoNode(RawNode):
             progress_update(0, len(self))
 
         if y4m:
-            if self.format.color_family == GRAY:
+            if self.format.color_family == cfGray:
                 y4mformat = 'mono'
                 if self.format.bits_per_sample > 8:
                     y4mformat = y4mformat + str(self.format.bits_per_sample)
-            elif self.format.color_family == YUV:
+            elif self.format.color_family == cfYUV:
                 if self.format.subsampling_w == 1 and self.format.subsampling_h == 1:
                     y4mformat = '420'
                 elif self.format.subsampling_w == 1 and self.format.subsampling_h == 0:
@@ -2228,7 +2382,7 @@ cdef VideoNode createVideoNode(VSNode *node, const VSAPI *funcs, Core core):
     instance.funcs = funcs
     instance.vi = funcs.getVideoInfo(node)
 
-    if (instance.vi.format.colorFamily != UNDEFINED):
+    if (instance.vi.format.colorFamily != cfUndefined):
         instance.format = createVideoFormat(&instance.vi.format, funcs, core.core)
     else:
         instance.format = None
@@ -2270,7 +2424,7 @@ cdef class AudioNode(RawNode):
         except AttributeError:
             err = True
         if err:
-            raise AttributeError('There is no attribute or namespace named ' + name)
+            raise AttributeError(f'There is no attribute or namespace named {name}. Did you mistype a plugin namespace or forget to install a plugin?')
 
     cdef ensure_valid_frame_number(self, int n):
         if n < 0:
@@ -2279,13 +2433,13 @@ cdef class AudioNode(RawNode):
             raise ValueError('Requesting frame number is beyond the last frame')
 
     def get_frame(self, int n):
-        cdef char errorMsg[512]
+        cdef char errorMsg[4096]
         cdef char *ep = errorMsg
         cdef const VSFrame *f
         self.ensure_valid_frame_number(n)
 
         with nogil:
-            f = self.funcs.getFrame(n, self.node, errorMsg, 500)
+            f = self.funcs.getFrame(n, self.node, errorMsg, 4096)
         if f == NULL:
             if (errorMsg[0]):
                 raise Error(ep.decode('utf-8'))
@@ -2433,17 +2587,64 @@ cdef LogHandle createLogHandle(object handler_func):
 
 cdef void __stdcall log_handler_wrapper(int msgType, const char *msg, void *userData) noexcept nogil:
     with gil:
-        (<LogHandle>userData).handler_func(MessageType(msgType), msg.decode('utf-8'))
+        (<LogHandle>userData).handler_func(msgType, msg.decode('utf-8'))
 
 cdef void __stdcall log_handler_free(void *userData) noexcept nogil:
     with gil:
         Py_DECREF(<LogHandle>userData)
 
+
+cdef class CoreTimings(object):
+    cdef Core core
+
+    cdef object __weakref__
+
+    def __init__(self):
+        raise Error('Class cannot be instantiated directly')
+
+    property enabled:
+        def __get__(self):
+            return bool(self.core.funcs.getCoreNodeTiming(self.core.core))
+
+        def __set__(self, bint enabled):
+            self.core.funcs.setCoreNodeTiming(self.core.core, enabled)
+
+    property freed_nodes:
+        def __get__(self):
+            return self.core.funcs.getFreedNodeProcessingTime(self.core.core, False)
+        
+        def __set__(self, bint value):
+            if value != 0:
+                raise ValueError('You can only set freed_nodes to 0, to reset its counter!')
+
+            self.core.funcs.getFreedNodeProcessingTime(self.core.core, True)
+
+    def __repr__(self):
+        return _construct_repr(
+            self, enabled=self.enabled, freed_nodes=self.freed_nodes
+        )
+
+    def __str__(self):
+        return (
+            'CoreTimings\n'
+            f'\tEnabled: {self.enabled}\n'
+            f'\tFreed Nodes Time: {self.freed_nodes}\n'
+        )
+
+cdef CoreTimings createCoreTimings(Core core):
+    cdef CoreTimings instance = CoreTimings.__new__(CoreTimings)
+    instance.core = core
+
+    return instance
+
+
 cdef class Core(object):
     cdef int creationFlags
     cdef VSCore *core
     cdef const VSAPI *funcs
 
+    cdef readonly object timings
+
     cdef object __weakref__
 
     def __init__(self):
@@ -2478,6 +2679,12 @@ cdef class Core(object):
             new_size = new_size * 1024 * 1024
             self.funcs.setMaxCacheSize(new_size, self.core)
 
+    @property
+    def used_cache_size(self):
+        cdef VSCoreInfo v
+        self.funcs.getCoreInfo(self.core, &v)
+        return v.usedFramebufferSize
+
     @property
     def flags(self):
         return self.creationFlags
@@ -2491,7 +2698,7 @@ cdef class Core(object):
         if plugin:
             return createPlugin(plugin, self.funcs, self)
         else:
-            raise AttributeError('No attribute with the name ' + name + ' exists. Did you mistype a plugin namespace?')
+            raise AttributeError('No attribute with the name ' + name + ' exists. Did you mistype a plugin namespace or forget to install a plugin?')
 
     def plugins(self):
         cdef VSPlugin *plugin = self.funcs.getNextPlugin(NULL, self.core)
@@ -2500,7 +2707,7 @@ cdef class Core(object):
             plugin = self.funcs.getNextPlugin(plugin, self.core)
             yield tmp
 
-    def query_video_format(self, ColorFamily color_family, SampleType sample_type, int bits_per_sample, int subsampling_w = 0, int subsampling_h = 0):
+    def query_video_format(self, int color_family, int sample_type, int bits_per_sample, int subsampling_w = 0, int subsampling_h = 0):
         cdef VSVideoFormat fmt
         if not self.funcs.queryVideoFormat(&fmt, color_family, sample_type, bits_per_sample, subsampling_w, subsampling_h, self.core):
             raise Error('Invalid format specified')
@@ -2521,11 +2728,11 @@ cdef class Core(object):
         cdef VSFrame* ref = self.funcs.newVideoFrame(&fmt, width, height, NULL, self.core)
         return createVideoFrame(ref, self.funcs, self.core)
 
-    def log_message(self, MessageType message_type, str message):
+    def log_message(self, int message_type, str message):
         self.funcs.logMessage(message_type, message.encode('utf-8'), self.core)
 
     def add_log_handler(self, handler_func):
-        handler_func(MESSAGE_TYPE_DEBUG, 'New message handler installed from python')
+        handler_func(mtDebug, 'New message handler installed from python')
         cdef LogHandle lh = createLogHandle(handler_func)
         Py_INCREF(lh)
         lh.handle = self.funcs.addLogHandler(log_handler_wrapper, log_handler_free, <void *>lh, self.core)
@@ -2534,15 +2741,33 @@ cdef class Core(object):
     def remove_log_handler(self, LogHandle handle):
         return self.funcs.removeLogHandler(handle.handle, self.core)
 
-    def version(self):
+    def clear_cache(self):
+        self.funcs.clearCoreCaches(self.core)
+
+    @property
+    def core_version(self):
         cdef VSCoreInfo v
         self.funcs.getCoreInfo(self.core, &v)
-        return (<const char *>v.versionString).decode('utf-8')
 
-    def version_number(self):
+        return VapourSynthVersion(v.core, 0)
+
+    @property
+    def api_version(self):
         cdef VSCoreInfo v
         self.funcs.getCoreInfo(self.core, &v)
-        return v.core
+
+        api_major = (v.api >> 16)
+        api_minor = v.api - (api_major << 16)
+
+        return VapourSynthAPIVersion(api_major, api_minor)
+
+    def version(self):
+        warnings.warn('core.version() is deprecated, use str(core)!', DeprecationWarning)
+        return str(self)
+
+    def version_number(self):
+        warnings.warn('core.version_number() is deprecated, use core.core_version.release_major!', DeprecationWarning)
+        return self.core_version.release_major
 
     def __dir__(self):
         plugins = []
@@ -2551,38 +2776,37 @@ cdef class Core(object):
         return super(Core, self).__dir__() + plugins
 
     def __repr__(self):
-        cdef VSCoreInfo v
-        self.funcs.getCoreInfo(self.core, &v)
-
-        api_major = (v.api >> 16)
-        api_minor = v.api - (api_major << 16)
-
-        api_v = api_major + api_minor / 10
-
         return _construct_repr(
-            self, core_version=v.core, api_version=api_v, num_threads=v.numThreads,
-            max_cache_size=(<int64_t>v.maxFramebufferSize + 1024 * 1024 - 1) // <int64_t>(1024 * 1024)
+            self, core_version=self.core_version, api_version=self.api_version,
+            num_threads=self.num_threads, max_cache_size=self.max_cache_size,
+            used_cache_size=self.used_cache_size
         )
 
     def __str__(self):
-        version_lines = [x.strip() for x in self.version().splitlines()]
+        cdef VSCoreInfo v
+        self.funcs.getCoreInfo(self.core, &v)
+
+        versionString = (<const char *>v.versionString).decode('utf-8')
+
+        version_lines = [x.strip() for x in versionString.splitlines()]
         copyright = '\n'.join(version_lines[:2])
         version = '\n\t'.join(version_lines[2:])
 
         return (
-            f'{copyright}\n\t{version}\n'
+            f'{copyright}\n'
+            f'\t{version}\n'
             f'\tNumber of Threads: {self.num_threads:d}\n'
             f'\tMax Cache Size: {self.max_cache_size:d}\n'
         )
 
 cdef object createNode(VSNode *node, const VSAPI *funcs, Core core):
-    if funcs.getNodeType(node) == VIDEO:
+    if funcs.getNodeType(node) == mtVideo:
         return createVideoNode(node, funcs, core)
     else:
         return createAudioNode(node, funcs, core)
 
 cdef object createConstFrame(const VSFrame *f, const VSAPI *funcs, VSCore *core):
-    if funcs.getFrameType(f) == VIDEO:
+    if funcs.getFrameType(f) == mtVideo:
         return createConstVideoFrame(f, funcs, core)
     else:
         return createConstAudioFrame(f, funcs, core)
@@ -2591,17 +2815,36 @@ cdef Core createCore(EnvironmentData env):
     cdef Core instance = Core.__new__(Core)
     instance.funcs = getVapourSynthAPI(VAPOURSYNTH_API_VERSION)
     if instance.funcs == NULL:
-        raise Error('Failed to obtain VapourSynth API pointer. System does not support SSE2 or is the Python module and loaded core library mismatched?')
+        raise Error('Failed to obtain VapourSynth API pointer. Is the Python module and loaded core library mismatched?')
     instance.core = instance.funcs.createCore(env.coreCreationFlags)
+    instance.timings = createCoreTimings(instance)
     instance.creationFlags = env.coreCreationFlags
+    if instance.core_version.release_major <> VS_CURRENT_RELEASE:
+        instance.log_message(mtWarning, f'Version mismatch: The VapourSynth Python module version is R{__version__.release_major:d} but the VapourSynth core library is R{instance.core_version.release_major:d}. This usually indicates a broken install.')
     return instance
 
 cdef Core createCore2(VSCore *core):
     cdef Core instance = Core.__new__(Core)
+    cdef VSMap *min
+    cdef VSMap *mout
+    cdef VSPlugin *plugin
+    cdef VSNode *node
     instance.funcs = getVapourSynthAPI(VAPOURSYNTH_API_VERSION)
     if instance.funcs == NULL:
-        raise Error('Failed to obtain VapourSynth API pointer. System does not support SSE2 or is the Python module and loaded core library mismatched?')
+        raise Error('Failed to obtain VapourSynth API pointer. Is the Python module and loaded core library mismatched?')
     instance.core = core
+    instance.timings = createCoreTimings(instance)
+    if instance.core_version.release_major <> VS_CURRENT_RELEASE:
+        instance.log_message(mtWarning, f'Version mismatch: The VapourSynth Python module version is R{__version__.release_major:d} but the VapourSynth core library is R{instance.core_version.release_major:d}. This usually indicates a broken install.')
+    plugin = instance.funcs.getPluginByID('com.vapoursynth.std', core)
+    min = instance.funcs.createMap()
+    mout = instance.funcs.invoke(plugin, "BlankClip", min)
+    instance.funcs.freeMap(min)
+    node = instance.funcs.mapGetNode(mout, "clip", 0, NULL)
+    instance.funcs.freeMap(mout)
+    if instance.funcs.getNodeCreationFunctionName(node, 0) <> NULL:
+        instance.creationFlags = ccfEnableGraphInspection
+    instance.funcs.freeNode(node)
     return instance
 
 cdef Core _get_core(threads = None):
@@ -2625,8 +2868,21 @@ cdef class _CoreProxy(object):
     def core(self):
         return _get_core()
 
+    @property
+    def core_version(self):
+        return __version__
+
+    @property
+    def api_version(self):
+        return __api_version__
+
+    def version(self):
+        warnings.warn('core.version() is deprecated, use str(core)!', DeprecationWarning)
+        return str(self)
+
     def version_number(self):
-        return __version__[0]
+        warnings.warn('core.version_number() is deprecated, use core.core_version.release_major!', DeprecationWarning)
+        return self.core_version.release_major
 
     def __dir__(self):
         d = dir(self.core)
@@ -2649,13 +2905,12 @@ cdef class _CoreProxy(object):
 
         return _construct_repr(self, core=core_repr)
 
-
     def __str__(self):
         if _env_current() is None:
             return (
                 'Uninitialized Environment:\n'
-                f'\tCore R{__version__[0]}\n'
-                f'\tAPI R{__api_version__[0]}.{__api_version__[1]}\n'
+                f'\tCore {__version__:s}\n'
+                f'\tAPI {__api_version__:s}\n'
                 '\tOptions: Unknown\n'
                 '\tNumber of Threads: Unknown\n'
                 '\tMax Cache Size: Unknown\n'
@@ -2705,6 +2960,14 @@ cdef class Plugin(object):
         ver_minor = (ver_major > -1) and (ver - (ver_major << 16)) or 0
 
         return PluginVersion(ver_major, ver_minor)
+        
+    @property
+    def plugin_path(self):
+        cdef const char *ppath = self.funcs.getPluginPath(self.plugin)
+        if ppath:
+            return ppath.decode('utf-8')
+        else:
+            return None
 
     def __dir__(self):
         attrs = []
@@ -2908,7 +3171,7 @@ def _showwarning(message, category, filename, lineno, file=None, line=None):
 
         s = warnings.formatwarning(message, category, filename, lineno, line)
         core = vsscript_get_core_internal(env)
-        core.log_message(MESSAGE_TYPE_WARNING, s)
+        core.log_message(mtWarning, s)
 
 class PythonVSScriptLoggingBridge(logging.Handler):
 
@@ -3312,6 +3575,25 @@ cdef public api int vpy4_getAltOutputMode(VSScript *se, int index) nogil:
         if isinstance(output, VideoOutputTuple):
             return output[2]
         return 0
+        
+cdef public api int vpy4_getAvailableOutputNodes(VSScript *se, int size, int *dst) nogil:
+    cdef int dstidx = 0
+    with gil:
+        pyenvdict = <dict>se.pyenvdict
+        nodes = None
+        try:
+            nodes = _get_vsscript_policy().get_environment(se.id).outputs
+        except:
+            return 0
+    
+        if size > 0:
+            for key in nodes:
+                dst[dstidx] = key
+                dstidx = dstidx + 1
+                if size - dstidx <= 0:
+                    break
+        
+        return len(nodes)
 
 cdef public api int vpy_clearOutput(VSScript *se, int index) nogil:
     with gil: