Initial script
parent
88b1f70096
commit
fe1aaef33f
|
|
@ -0,0 +1,161 @@
|
|||
# ---> Python
|
||||
# Byte-compiled / optimized / DLL files
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
*$py.class
|
||||
|
||||
# C extensions
|
||||
*.so
|
||||
|
||||
# Distribution / packaging
|
||||
.Python
|
||||
build/
|
||||
develop-eggs/
|
||||
dist/
|
||||
downloads/
|
||||
eggs/
|
||||
.eggs/
|
||||
lib/
|
||||
lib64/
|
||||
parts/
|
||||
sdist/
|
||||
var/
|
||||
wheels/
|
||||
share/python-wheels/
|
||||
*.egg-info/
|
||||
.installed.cfg
|
||||
*.egg
|
||||
MANIFEST
|
||||
|
||||
# PyInstaller
|
||||
# Usually these files are written by a python script from a template
|
||||
# before PyInstaller builds the exe, so as to inject date/other infos into it.
|
||||
*.manifest
|
||||
*.spec
|
||||
|
||||
# Installer logs
|
||||
pip-log.txt
|
||||
pip-delete-this-directory.txt
|
||||
|
||||
# Unit test / coverage reports
|
||||
htmlcov/
|
||||
.tox/
|
||||
.nox/
|
||||
.coverage
|
||||
.coverage.*
|
||||
.cache
|
||||
nosetests.xml
|
||||
coverage.xml
|
||||
*.cover
|
||||
*.py,cover
|
||||
.hypothesis/
|
||||
.pytest_cache/
|
||||
cover/
|
||||
|
||||
# Translations
|
||||
*.mo
|
||||
*.pot
|
||||
|
||||
# Django stuff:
|
||||
*.log
|
||||
local_settings.py
|
||||
db.sqlite3
|
||||
db.sqlite3-journal
|
||||
|
||||
# Flask stuff:
|
||||
instance/
|
||||
.webassets-cache
|
||||
|
||||
# Scrapy stuff:
|
||||
.scrapy
|
||||
|
||||
# Sphinx documentation
|
||||
docs/_build/
|
||||
|
||||
# PyBuilder
|
||||
.pybuilder/
|
||||
target/
|
||||
|
||||
# Jupyter Notebook
|
||||
.ipynb_checkpoints
|
||||
|
||||
# IPython
|
||||
profile_default/
|
||||
ipython_config.py
|
||||
|
||||
# pyenv
|
||||
# For a library or package, you might want to ignore these files since the code is
|
||||
# intended to run in multiple environments; otherwise, check them in:
|
||||
# .python-version
|
||||
|
||||
# pipenv
|
||||
# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
|
||||
# However, in case of collaboration, if having platform-specific dependencies or dependencies
|
||||
# having no cross-platform support, pipenv may install dependencies that don't work, or not
|
||||
# install all needed dependencies.
|
||||
#Pipfile.lock
|
||||
|
||||
# poetry
|
||||
# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
|
||||
# This is especially recommended for binary packages to ensure reproducibility, and is more
|
||||
# commonly ignored for libraries.
|
||||
# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
|
||||
#poetry.lock
|
||||
|
||||
# pdm
|
||||
# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
|
||||
#pdm.lock
|
||||
# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
|
||||
# in version control.
|
||||
# https://pdm.fming.dev/#use-with-ide
|
||||
.pdm.toml
|
||||
|
||||
# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
|
||||
__pypackages__/
|
||||
|
||||
# Celery stuff
|
||||
celerybeat-schedule
|
||||
celerybeat.pid
|
||||
|
||||
# SageMath parsed files
|
||||
*.sage.py
|
||||
|
||||
# Environments
|
||||
.env
|
||||
.venv
|
||||
env/
|
||||
venv/
|
||||
ENV/
|
||||
env.bak/
|
||||
venv.bak/
|
||||
|
||||
# Spyder project settings
|
||||
.spyderproject
|
||||
.spyproject
|
||||
|
||||
# Rope project settings
|
||||
.ropeproject
|
||||
|
||||
# mkdocs documentation
|
||||
/site
|
||||
|
||||
# mypy
|
||||
.mypy_cache/
|
||||
.dmypy.json
|
||||
dmypy.json
|
||||
|
||||
# Pyre type checker
|
||||
.pyre/
|
||||
|
||||
# pytype static type analyzer
|
||||
.pytype/
|
||||
|
||||
# Cython debug symbols
|
||||
cython_debug/
|
||||
|
||||
# PyCharm
|
||||
# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
|
||||
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
|
||||
# and can be added to the global gitignore or merged into this file. For a more nuclear
|
||||
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
|
||||
#.idea/
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
@ECHO OFF
|
||||
REM TestWrapper.bat
|
||||
cd /D "%~dp0"
|
||||
SET args='%1'
|
||||
:More
|
||||
SHIFT
|
||||
IF '%1' == '' GOTO Done
|
||||
SET args=%args%,'%1'
|
||||
GOTO More
|
||||
:Done
|
||||
cd Programs
|
||||
Powershell.exe -noprofile -command "& {.\Script.ps1 %args%}"
|
||||
pause
|
||||
exit
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
@ECHO OFF
|
||||
REM TestWrapper.bat
|
||||
cd /D "%~dp0"
|
||||
SET args='%1'
|
||||
:More
|
||||
SHIFT
|
||||
IF '%1' == '' GOTO Done
|
||||
SET args=%args%,'%1'
|
||||
GOTO More
|
||||
:Done
|
||||
cd Programs
|
||||
Powershell.exe -noprofile -command "& {.\Script_Web.ps1 %args%}"
|
||||
pause
|
||||
exit
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
Version 2, December 2004
|
||||
|
||||
Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim or modified copies of this license document, and changing it is allowed as long as the name is changed.
|
||||
|
||||
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. You just DO WHAT THE FUCK YOU WANT TO.
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,702 @@
|
|||
A. HISTORY OF THE SOFTWARE
|
||||
==========================
|
||||
|
||||
Python was created in the early 1990s by Guido van Rossum at Stichting
|
||||
Mathematisch Centrum (CWI, see https://www.cwi.nl) in the Netherlands
|
||||
as a successor of a language called ABC. Guido remains Python's
|
||||
principal author, although it includes many contributions from others.
|
||||
|
||||
In 1995, Guido continued his work on Python at the Corporation for
|
||||
National Research Initiatives (CNRI, see https://www.cnri.reston.va.us)
|
||||
in Reston, Virginia where he released several versions of the
|
||||
software.
|
||||
|
||||
In May 2000, Guido and the Python core development team moved to
|
||||
BeOpen.com to form the BeOpen PythonLabs team. In October of the same
|
||||
year, the PythonLabs team moved to Digital Creations, which became
|
||||
Zope Corporation. In 2001, the Python Software Foundation (PSF, see
|
||||
https://www.python.org/psf/) was formed, a non-profit organization
|
||||
created specifically to own Python-related Intellectual Property.
|
||||
Zope Corporation was a sponsoring member of the PSF.
|
||||
|
||||
All Python releases are Open Source (see https://opensource.org for
|
||||
the Open Source Definition). Historically, most, but not all, Python
|
||||
releases have also been GPL-compatible; the table below summarizes
|
||||
the various releases.
|
||||
|
||||
Release Derived Year Owner GPL-
|
||||
from compatible? (1)
|
||||
|
||||
0.9.0 thru 1.2 1991-1995 CWI yes
|
||||
1.3 thru 1.5.2 1.2 1995-1999 CNRI yes
|
||||
1.6 1.5.2 2000 CNRI no
|
||||
2.0 1.6 2000 BeOpen.com no
|
||||
1.6.1 1.6 2001 CNRI yes (2)
|
||||
2.1 2.0+1.6.1 2001 PSF no
|
||||
2.0.1 2.0+1.6.1 2001 PSF yes
|
||||
2.1.1 2.1+2.0.1 2001 PSF yes
|
||||
2.1.2 2.1.1 2002 PSF yes
|
||||
2.1.3 2.1.2 2002 PSF yes
|
||||
2.2 and above 2.1.1 2001-now PSF yes
|
||||
|
||||
Footnotes:
|
||||
|
||||
(1) GPL-compatible doesn't mean that we're distributing Python under
|
||||
the GPL. All Python licenses, unlike the GPL, let you distribute
|
||||
a modified version without making your changes open source. The
|
||||
GPL-compatible licenses make it possible to combine Python with
|
||||
other software that is released under the GPL; the others don't.
|
||||
|
||||
(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
|
||||
because its license has a choice of law clause. According to
|
||||
CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
|
||||
is "not incompatible" with the GPL.
|
||||
|
||||
Thanks to the many outside volunteers who have worked under Guido's
|
||||
direction to make these releases possible.
|
||||
|
||||
|
||||
B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
|
||||
===============================================================
|
||||
|
||||
Python software and documentation are licensed under the
|
||||
Python Software Foundation License Version 2.
|
||||
|
||||
Starting with Python 3.8.6, examples, recipes, and other code in
|
||||
the documentation are dual licensed under the PSF License Version 2
|
||||
and the Zero-Clause BSD license.
|
||||
|
||||
Some software incorporated into Python is under different licenses.
|
||||
The licenses are listed with code falling under that license.
|
||||
|
||||
|
||||
PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
|
||||
--------------------------------------------
|
||||
|
||||
1. This LICENSE AGREEMENT is between the Python Software Foundation
|
||||
("PSF"), and the Individual or Organization ("Licensee") accessing and
|
||||
otherwise using this software ("Python") in source or binary form and
|
||||
its associated documentation.
|
||||
|
||||
2. Subject to the terms and conditions of this License Agreement, PSF hereby
|
||||
grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
|
||||
analyze, test, perform and/or display publicly, prepare derivative works,
|
||||
distribute, and otherwise use Python alone or in any derivative version,
|
||||
provided, however, that PSF's License Agreement and PSF's notice of copyright,
|
||||
i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
|
||||
2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023 Python Software Foundation;
|
||||
All Rights Reserved" are retained in Python alone or in any derivative version
|
||||
prepared by Licensee.
|
||||
|
||||
3. In the event Licensee prepares a derivative work that is based on
|
||||
or incorporates Python or any part thereof, and wants to make
|
||||
the derivative work available to others as provided herein, then
|
||||
Licensee hereby agrees to include in any such work a brief summary of
|
||||
the changes made to Python.
|
||||
|
||||
4. PSF is making Python available to Licensee on an "AS IS"
|
||||
basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
|
||||
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
|
||||
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
|
||||
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
|
||||
INFRINGE ANY THIRD PARTY RIGHTS.
|
||||
|
||||
5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
|
||||
FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
|
||||
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
|
||||
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
|
||||
|
||||
6. This License Agreement will automatically terminate upon a material
|
||||
breach of its terms and conditions.
|
||||
|
||||
7. Nothing in this License Agreement shall be deemed to create any
|
||||
relationship of agency, partnership, or joint venture between PSF and
|
||||
Licensee. This License Agreement does not grant permission to use PSF
|
||||
trademarks or trade name in a trademark sense to endorse or promote
|
||||
products or services of Licensee, or any third party.
|
||||
|
||||
8. By copying, installing or otherwise using Python, Licensee
|
||||
agrees to be bound by the terms and conditions of this License
|
||||
Agreement.
|
||||
|
||||
|
||||
BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
|
||||
-------------------------------------------
|
||||
|
||||
BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
|
||||
|
||||
1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
|
||||
office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
|
||||
Individual or Organization ("Licensee") accessing and otherwise using
|
||||
this software in source or binary form and its associated
|
||||
documentation ("the Software").
|
||||
|
||||
2. Subject to the terms and conditions of this BeOpen Python License
|
||||
Agreement, BeOpen hereby grants Licensee a non-exclusive,
|
||||
royalty-free, world-wide license to reproduce, analyze, test, perform
|
||||
and/or display publicly, prepare derivative works, distribute, and
|
||||
otherwise use the Software alone or in any derivative version,
|
||||
provided, however, that the BeOpen Python License is retained in the
|
||||
Software, alone or in any derivative version prepared by Licensee.
|
||||
|
||||
3. BeOpen is making the Software available to Licensee on an "AS IS"
|
||||
basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
|
||||
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
|
||||
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
|
||||
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
|
||||
INFRINGE ANY THIRD PARTY RIGHTS.
|
||||
|
||||
4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
|
||||
SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
|
||||
AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
|
||||
DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
|
||||
|
||||
5. This License Agreement will automatically terminate upon a material
|
||||
breach of its terms and conditions.
|
||||
|
||||
6. This License Agreement shall be governed by and interpreted in all
|
||||
respects by the law of the State of California, excluding conflict of
|
||||
law provisions. Nothing in this License Agreement shall be deemed to
|
||||
create any relationship of agency, partnership, or joint venture
|
||||
between BeOpen and Licensee. This License Agreement does not grant
|
||||
permission to use BeOpen trademarks or trade names in a trademark
|
||||
sense to endorse or promote products or services of Licensee, or any
|
||||
third party. As an exception, the "BeOpen Python" logos available at
|
||||
http://www.pythonlabs.com/logos.html may be used according to the
|
||||
permissions granted on that web page.
|
||||
|
||||
7. By copying, installing or otherwise using the software, Licensee
|
||||
agrees to be bound by the terms and conditions of this License
|
||||
Agreement.
|
||||
|
||||
|
||||
CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
|
||||
---------------------------------------
|
||||
|
||||
1. This LICENSE AGREEMENT is between the Corporation for National
|
||||
Research Initiatives, having an office at 1895 Preston White Drive,
|
||||
Reston, VA 20191 ("CNRI"), and the Individual or Organization
|
||||
("Licensee") accessing and otherwise using Python 1.6.1 software in
|
||||
source or binary form and its associated documentation.
|
||||
|
||||
2. Subject to the terms and conditions of this License Agreement, CNRI
|
||||
hereby grants Licensee a nonexclusive, royalty-free, world-wide
|
||||
license to reproduce, analyze, test, perform and/or display publicly,
|
||||
prepare derivative works, distribute, and otherwise use Python 1.6.1
|
||||
alone or in any derivative version, provided, however, that CNRI's
|
||||
License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
|
||||
1995-2001 Corporation for National Research Initiatives; All Rights
|
||||
Reserved" are retained in Python 1.6.1 alone or in any derivative
|
||||
version prepared by Licensee. Alternately, in lieu of CNRI's License
|
||||
Agreement, Licensee may substitute the following text (omitting the
|
||||
quotes): "Python 1.6.1 is made available subject to the terms and
|
||||
conditions in CNRI's License Agreement. This Agreement together with
|
||||
Python 1.6.1 may be located on the internet using the following
|
||||
unique, persistent identifier (known as a handle): 1895.22/1013. This
|
||||
Agreement may also be obtained from a proxy server on the internet
|
||||
using the following URL: http://hdl.handle.net/1895.22/1013".
|
||||
|
||||
3. In the event Licensee prepares a derivative work that is based on
|
||||
or incorporates Python 1.6.1 or any part thereof, and wants to make
|
||||
the derivative work available to others as provided herein, then
|
||||
Licensee hereby agrees to include in any such work a brief summary of
|
||||
the changes made to Python 1.6.1.
|
||||
|
||||
4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
|
||||
basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
|
||||
IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
|
||||
DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
|
||||
FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
|
||||
INFRINGE ANY THIRD PARTY RIGHTS.
|
||||
|
||||
5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
|
||||
1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
|
||||
A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
|
||||
OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
|
||||
|
||||
6. This License Agreement will automatically terminate upon a material
|
||||
breach of its terms and conditions.
|
||||
|
||||
7. This License Agreement shall be governed by the federal
|
||||
intellectual property law of the United States, including without
|
||||
limitation the federal copyright law, and, to the extent such
|
||||
U.S. federal law does not apply, by the law of the Commonwealth of
|
||||
Virginia, excluding Virginia's conflict of law provisions.
|
||||
Notwithstanding the foregoing, with regard to derivative works based
|
||||
on Python 1.6.1 that incorporate non-separable material that was
|
||||
previously distributed under the GNU General Public License (GPL), the
|
||||
law of the Commonwealth of Virginia shall govern this License
|
||||
Agreement only as to issues arising under or with respect to
|
||||
Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this
|
||||
License Agreement shall be deemed to create any relationship of
|
||||
agency, partnership, or joint venture between CNRI and Licensee. This
|
||||
License Agreement does not grant permission to use CNRI trademarks or
|
||||
trade name in a trademark sense to endorse or promote products or
|
||||
services of Licensee, or any third party.
|
||||
|
||||
8. By clicking on the "ACCEPT" button where indicated, or by copying,
|
||||
installing or otherwise using Python 1.6.1, Licensee agrees to be
|
||||
bound by the terms and conditions of this License Agreement.
|
||||
|
||||
ACCEPT
|
||||
|
||||
|
||||
CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
|
||||
--------------------------------------------------
|
||||
|
||||
Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
|
||||
The Netherlands. All rights reserved.
|
||||
|
||||
Permission to use, copy, modify, and distribute this software and its
|
||||
documentation for any purpose and without fee is hereby granted,
|
||||
provided that the above copyright notice appear in all copies and that
|
||||
both that copyright notice and this permission notice appear in
|
||||
supporting documentation, and that the name of Stichting Mathematisch
|
||||
Centrum or CWI not be used in advertising or publicity pertaining to
|
||||
distribution of the software without specific, written prior
|
||||
permission.
|
||||
|
||||
STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
|
||||
THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
||||
FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
|
||||
FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
|
||||
OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
ZERO-CLAUSE BSD LICENSE FOR CODE IN THE PYTHON DOCUMENTATION
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
PERFORMANCE OF THIS SOFTWARE.
|
||||
|
||||
|
||||
|
||||
Additional Conditions for this Windows binary build
|
||||
---------------------------------------------------
|
||||
|
||||
This program is linked with and uses Microsoft Distributable Code,
|
||||
copyrighted by Microsoft Corporation. The Microsoft Distributable Code
|
||||
is embedded in each .exe, .dll and .pyd file as a result of running
|
||||
the code through a linker.
|
||||
|
||||
If you further distribute programs that include the Microsoft
|
||||
Distributable Code, you must comply with the restrictions on
|
||||
distribution specified by Microsoft. In particular, you must require
|
||||
distributors and external end users to agree to terms that protect the
|
||||
Microsoft Distributable Code at least as much as Microsoft's own
|
||||
requirements for the Distributable Code. See Microsoft's documentation
|
||||
(included in its developer tools and on its website at microsoft.com)
|
||||
for specific details.
|
||||
|
||||
Redistribution of the Windows binary build of the Python interpreter
|
||||
complies with this agreement, provided that you do not:
|
||||
|
||||
- alter any copyright, trademark or patent notice in Microsoft's
|
||||
Distributable Code;
|
||||
|
||||
- use Microsoft's trademarks in your programs' names or in a way that
|
||||
suggests your programs come from or are endorsed by Microsoft;
|
||||
|
||||
- distribute Microsoft's Distributable Code to run on a platform other
|
||||
than Microsoft operating systems, run-time technologies or application
|
||||
platforms; or
|
||||
|
||||
- include Microsoft Distributable Code in malicious, deceptive or
|
||||
unlawful programs.
|
||||
|
||||
These restrictions apply only to the Microsoft Distributable Code as
|
||||
defined above, not to Python itself or any programs running on the
|
||||
Python interpreter. The redistribution of the Python interpreter and
|
||||
libraries is governed by the Python Software License included with this
|
||||
file, or by other licenses as marked.
|
||||
|
||||
|
||||
|
||||
--------------------------------------------------------------------------
|
||||
|
||||
This program, "bzip2", the associated library "libbzip2", and all
|
||||
documentation, are copyright (C) 1996-2019 Julian R Seward. All
|
||||
rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product
|
||||
documentation would be appreciated but is not required.
|
||||
|
||||
3. Altered source versions must be plainly marked as such, and must
|
||||
not be misrepresented as being the original software.
|
||||
|
||||
4. The name of the author may not be used to endorse or promote
|
||||
products derived from this software without specific prior written
|
||||
permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
|
||||
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
||||
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
|
||||
GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
||||
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
||||
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
Julian Seward, jseward@acm.org
|
||||
bzip2/libbzip2 version 1.0.8 of 13 July 2019
|
||||
|
||||
--------------------------------------------------------------------------
|
||||
|
||||
libffi - Copyright (c) 1996-2022 Anthony Green, Red Hat, Inc and others.
|
||||
See source files for details.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
``Software''), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
|
||||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
https://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
This software is copyrighted by the Regents of the University of
|
||||
California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
|
||||
Corporation and other parties. The following terms apply to all files
|
||||
associated with the software unless explicitly disclaimed in
|
||||
individual files.
|
||||
|
||||
The authors hereby grant permission to use, copy, modify, distribute,
|
||||
and license this software and its documentation for any purpose, provided
|
||||
that existing copyright notices are retained in all copies and that this
|
||||
notice is included verbatim in any distributions. No written agreement,
|
||||
license, or royalty fee is required for any of the authorized uses.
|
||||
Modifications to this software may be copyrighted by their authors
|
||||
and need not follow the licensing terms described here, provided that
|
||||
the new terms are clearly indicated on the first page of each file where
|
||||
they apply.
|
||||
|
||||
IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
|
||||
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
||||
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
|
||||
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
|
||||
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
|
||||
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
|
||||
MODIFICATIONS.
|
||||
|
||||
GOVERNMENT USE: If you are acquiring this software on behalf of the
|
||||
U.S. government, the Government shall have only "Restricted Rights"
|
||||
in the software and related documentation as defined in the Federal
|
||||
Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
|
||||
are acquiring the software on behalf of the Department of Defense, the
|
||||
software shall be classified as "Commercial Computer Software" and the
|
||||
Government shall have only "Restricted Rights" as defined in Clause
|
||||
252.227-7014 (b) (3) of DFARs. Notwithstanding the foregoing, the
|
||||
authors grant the U.S. Government and others acting in its behalf
|
||||
permission to use and distribute the software in accordance with the
|
||||
terms specified in this license.
|
||||
|
||||
This software is copyrighted by the Regents of the University of
|
||||
California, Sun Microsystems, Inc., Scriptics Corporation, ActiveState
|
||||
Corporation, Apple Inc. and other parties. The following terms apply to
|
||||
all files associated with the software unless explicitly disclaimed in
|
||||
individual files.
|
||||
|
||||
The authors hereby grant permission to use, copy, modify, distribute,
|
||||
and license this software and its documentation for any purpose, provided
|
||||
that existing copyright notices are retained in all copies and that this
|
||||
notice is included verbatim in any distributions. No written agreement,
|
||||
license, or royalty fee is required for any of the authorized uses.
|
||||
Modifications to this software may be copyrighted by their authors
|
||||
and need not follow the licensing terms described here, provided that
|
||||
the new terms are clearly indicated on the first page of each file where
|
||||
they apply.
|
||||
|
||||
IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
|
||||
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
||||
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
|
||||
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
|
||||
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
|
||||
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
|
||||
MODIFICATIONS.
|
||||
|
||||
GOVERNMENT USE: If you are acquiring this software on behalf of the
|
||||
U.S. government, the Government shall have only "Restricted Rights"
|
||||
in the software and related documentation as defined in the Federal
|
||||
Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
|
||||
are acquiring the software on behalf of the Department of Defense, the
|
||||
software shall be classified as "Commercial Computer Software" and the
|
||||
Government shall have only "Restricted Rights" as defined in Clause
|
||||
252.227-7013 (b) (3) of DFARs. Notwithstanding the foregoing, the
|
||||
authors grant the U.S. Government and others acting in its behalf
|
||||
permission to use and distribute the software in accordance with the
|
||||
terms specified in this license.
|
||||
|
||||
Copyright (c) 1993-1999 Ioi Kim Lam.
|
||||
Copyright (c) 2000-2001 Tix Project Group.
|
||||
Copyright (c) 2004 ActiveState
|
||||
|
||||
This software is copyrighted by the above entities
|
||||
and other parties. The following terms apply to all files associated
|
||||
with the software unless explicitly disclaimed in individual files.
|
||||
|
||||
The authors hereby grant permission to use, copy, modify, distribute,
|
||||
and license this software and its documentation for any purpose, provided
|
||||
that existing copyright notices are retained in all copies and that this
|
||||
notice is included verbatim in any distributions. No written agreement,
|
||||
license, or royalty fee is required for any of the authorized uses.
|
||||
Modifications to this software may be copyrighted by their authors
|
||||
and need not follow the licensing terms described here, provided that
|
||||
the new terms are clearly indicated on the first page of each file where
|
||||
they apply.
|
||||
|
||||
IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
|
||||
FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
||||
ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
|
||||
DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
|
||||
POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
|
||||
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT. THIS SOFTWARE
|
||||
IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
|
||||
NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
|
||||
MODIFICATIONS.
|
||||
|
||||
GOVERNMENT USE: If you are acquiring this software on behalf of the
|
||||
U.S. government, the Government shall have only "Restricted Rights"
|
||||
in the software and related documentation as defined in the Federal
|
||||
Acquisition Regulations (FARs) in Clause 52.227.19 (c) (2). If you
|
||||
are acquiring the software on behalf of the Department of Defense, the
|
||||
software shall be classified as "Commercial Computer Software" and the
|
||||
Government shall have only "Restricted Rights" as defined in Clause
|
||||
252.227-7013 (c) (1) of DFARs. Notwithstanding the foregoing, the
|
||||
authors grant the U.S. Government and others acting in its behalf
|
||||
permission to use and distribute the software in accordance with the
|
||||
terms specified in this license.
|
||||
|
||||
----------------------------------------------------------------------
|
||||
|
||||
Parts of this software are based on the Tcl/Tk software copyrighted by
|
||||
the Regents of the University of California, Sun Microsystems, Inc.,
|
||||
and other parties. The original license terms of the Tcl/Tk software
|
||||
distribution is included in the file docs/license.tcltk.
|
||||
|
||||
Parts of this software are based on the HTML Library software
|
||||
copyrighted by Sun Microsystems, Inc. The original license terms of
|
||||
the HTML Library software distribution is included in the file
|
||||
docs/license.html_lib.
|
||||
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
global-include *.dll portable.vs .keep VSPipe.exe
|
||||
global-exclude VapourSynth.dll
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
param ( [string[]] $Paths )
|
||||
|
||||
Write-Host ""
|
||||
|
||||
$Paths | foreach {
|
||||
$Path = $_
|
||||
|
||||
$WithoutExtension = [IO.Path]::ChangeExtension($Path, '')
|
||||
|
||||
$ScriptFile = $WithoutExtension + "script.vpy"
|
||||
$ArchiveFile = $WithoutExtension + "archive.mkv"
|
||||
|
||||
Write-Host "==============================================================================="
|
||||
Write-Host ""
|
||||
Write-Host " Input video: $Path"
|
||||
Write-Host " Script file: $ScriptFile"
|
||||
Write-Host " Output video: $ArchiveFile"
|
||||
Write-Host ""
|
||||
Write-Host ""
|
||||
|
||||
(Get-Content template.vpy).replace('[INPUTFILE]', $Path.replace('\', '/')) | Set-Content -LiteralPath "$ScriptFile"
|
||||
|
||||
.\ffmpeg.exe -hide_banner -y -f vapoursynth -i "$ScriptFile" -i "$Path" -map 0:v:0 -map 1:a:0 -c:v libx265 -profile:v main10 -crf 17.4 -x265-params "me=star:subme=5:limit-modes=1:rect=1:amp=1:max-merge=5:no-early-skip=1:bframes=16:ref=6:rc-lookahead=60:limit-refs=0:rd=6:rdoq-level=2:psy-rdoq=1.00:sao=0" -c:a copy "$ArchiveFile"
|
||||
|
||||
Remove-Item $ScriptFile
|
||||
Remove-Item "$($Path).lwi"
|
||||
|
||||
.\Script_Web.ps1 "$ArchiveFile"
|
||||
|
||||
Write-Host "==============================================================================="
|
||||
}
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
param ( [string[]] $Paths )
|
||||
|
||||
$Paths | foreach {
|
||||
$Path = $_
|
||||
|
||||
$WithoutExtension = [IO.Path]::ChangeExtension($Path, '')
|
||||
|
||||
$WebFile = $WithoutExtension.replace('archive', 'web') + "webm"
|
||||
$PictureFile = $WithoutExtension.replace('archive', 'web') + "png"
|
||||
|
||||
Write-Host "==============================================================================="
|
||||
Write-Host ""
|
||||
Write-Host " Input video: $Path"
|
||||
Write-Host " Web video: $WebFile"
|
||||
Write-Host ""
|
||||
Write-Host ""
|
||||
|
||||
# .\ffmpeg.exe -hide_banner -y -i "$Path" -vf zscale=1280:720:filter=spline36 -c:v libsvtav1 -preset 5 -crf 28 -svtav1-params "enable-qm=1:fast-decode=1" -c:a libopus -b:a 192k -f matroska "$WebFile";
|
||||
|
||||
ffmpeg -hide_banner -y -ss 00:10:00 -i "$WebFile" -vframes 1 "$PictureFile"
|
||||
|
||||
Write-Host ""
|
||||
Write-Host "Done"
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,4 @@
|
|||
# Sphinx build info version 1
|
||||
# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
|
||||
config: 632bdf4b310a3f3964e4f568bada4510
|
||||
tags: 645f666f9bcd5a90fca523b33c5a78b7
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,272 @@
|
|||
VSHelper4.h
|
||||
===========
|
||||
|
||||
Table of contents
|
||||
#################
|
||||
|
||||
Introduction_
|
||||
|
||||
|
||||
Macros_
|
||||
VSH_STD_PLUGIN_ID_
|
||||
|
||||
VSH_RESIZE_PLUGIN_ID_
|
||||
|
||||
VSH_TEXT_PLUGIN_ID_
|
||||
|
||||
VS_RESTRICT_
|
||||
|
||||
`VSH_ALIGNED_MALLOC <VSH_ALIGNED_MALLOC_c_>`_
|
||||
|
||||
`VSH_ALIGNED_FREE <VSH_ALIGNED_FREE_c_>`_
|
||||
|
||||
VSMIN_
|
||||
|
||||
VSMAX_
|
||||
|
||||
|
||||
Functions_
|
||||
`vsh_aligned_malloc <vsh_aligned_malloc_cpp_>`_
|
||||
|
||||
`vsh_aligned_free <vsh_aligned_free_cpp_>`_
|
||||
|
||||
isConstantFormat_
|
||||
|
||||
isSameVideoFormat_
|
||||
|
||||
isSameVideoPresetFormat_
|
||||
|
||||
isSameVideoInfo_
|
||||
|
||||
isSameAudioFormat_
|
||||
|
||||
isSameAudioInfo_
|
||||
|
||||
muldivRational_
|
||||
|
||||
addRational_
|
||||
|
||||
reduceRational_
|
||||
|
||||
int64ToIntS_
|
||||
|
||||
doubleToFloatS_
|
||||
|
||||
bitblt_
|
||||
|
||||
areValidDimensions_
|
||||
|
||||
|
||||
Introduction
|
||||
############
|
||||
|
||||
This is a collection of helpful macros and functions. Note that all functions (not macros)
|
||||
are either prefixed with `vsh_` in C mode or placed in the `vsh` namespace for C++. This documentation
|
||||
will use the C++ names for these function.
|
||||
|
||||
|
||||
Macros
|
||||
######
|
||||
|
||||
VSH_STD_PLUGIN_ID
|
||||
-----------------
|
||||
Macro defined to the internal std plugin id provided for convenience.
|
||||
|
||||
|
||||
VSH_RESIZE_PLUGIN_ID
|
||||
--------------------
|
||||
Macro defined to the internal resizer plugin id provided for convenience.
|
||||
|
||||
|
||||
VSH_TEXT_PLUGIN_ID
|
||||
------------------
|
||||
Macro defined to the internal std plugin id provided for convenience.
|
||||
|
||||
|
||||
VS_RESTRICT
|
||||
-----------
|
||||
|
||||
Attempts to provide a portable definition of the C99 ``restrict`` keyword,
|
||||
or its C++ counterpart.
|
||||
|
||||
|
||||
.. _vsh_aligned_malloc_c:
|
||||
|
||||
VSH_ALIGNED_MALLOC
|
||||
------------------
|
||||
|
||||
VSH_ALIGNED_MALLOC(pptr, size, alignment)
|
||||
|
||||
Expands to _aligned_malloc() in Windows, and posix_memalign() elsewhere. Note that
|
||||
the arguments are in the style of posix_memalign().
|
||||
|
||||
*pptr* is a pointer to a pointer.
|
||||
|
||||
|
||||
.. _vsh_aligned_free_c:
|
||||
|
||||
VSH_ALIGNED_FREE
|
||||
----------------
|
||||
|
||||
VSH_ALIGNED_FREE(ptr)
|
||||
|
||||
Expands to _aligned_free() in Windows, and free() elsewhere.
|
||||
|
||||
*ptr* is a pointer.
|
||||
|
||||
|
||||
VSMIN
|
||||
-----
|
||||
|
||||
VSMIN(a, b)
|
||||
|
||||
Returns the minimum of the two numbers.
|
||||
|
||||
|
||||
VSMAX
|
||||
-----
|
||||
|
||||
VSMAX(a, b)
|
||||
|
||||
Returns the maximum of the two numbers.
|
||||
|
||||
|
||||
Functions
|
||||
#########
|
||||
|
||||
.. _vsh_aligned_malloc_cpp:
|
||||
|
||||
vsh_aligned_malloc
|
||||
------------------
|
||||
|
||||
.. cpp:function:: T* vsh::vsh_aligned_malloc(size_t size, size_t alignment)
|
||||
|
||||
A templated aligned malloc for C++. It uses the same functions as the
|
||||
`VSH_ALIGNED_MALLOC <VSH_ALIGNED_MALLOC_c_>`_ macro but is easier to use.
|
||||
|
||||
|
||||
.. _vsh_aligned_free_cpp:
|
||||
|
||||
vsh_aligned_free
|
||||
----------------
|
||||
|
||||
.. cpp:function:: void vsh::vsh_aligned_free(void *ptr)
|
||||
|
||||
This simply uses the `VSH_ALIGNED_FREE <VSH_ALIGNED_FREE_c_>`_ macro.
|
||||
|
||||
|
||||
isConstantFormat
|
||||
----------------
|
||||
|
||||
.. cpp:function:: static inline bool vsh::isConstantFormat(const VSVideoInfo *vi)
|
||||
|
||||
Checks if a clip's format and dimensions are known (and therefore constant).
|
||||
|
||||
|
||||
isSameVideoFormat
|
||||
-----------------
|
||||
|
||||
.. cpp:function:: static inline bool vsh::isSameVideoFormat(const VSVideoInfo *v1, const VSVideoInfo *v2)
|
||||
|
||||
Checks if two clips have the same video format. If the format is
|
||||
unknown in both, it will be considered the same.
|
||||
|
||||
|
||||
isSameVideoPresetFormat
|
||||
-----------------------
|
||||
|
||||
.. cpp:function:: static inline bool vsh::isSameVideoPresetFormat(unsigned presetFormat, const VSVideoFormat *v, VSCore *core, const VSAPI *vsapi)
|
||||
|
||||
Checks if a clip has the same video format as the preset.
|
||||
|
||||
|
||||
isSameVideoInfo
|
||||
---------------
|
||||
|
||||
.. cpp:function:: static inline bool vsh::isSameVideoInfo(const VSVideoInfo *v1, const VSVideoInfo *v2)
|
||||
|
||||
Checks if two clips have the same video format and dimensions. If the format is
|
||||
unknown in both, it will be considered the same. This is also true for the
|
||||
dimensions. Framerate is not taken into consideration when comparing.
|
||||
|
||||
|
||||
|
||||
isSameAudioFormat
|
||||
-----------------
|
||||
|
||||
.. cpp:function:: static inline bool vsh::isSameAudioFormat(const VSAudioInfo *v1, const VSAudioInfo *v2)
|
||||
|
||||
Checks if two clips have the same audio format.
|
||||
|
||||
|
||||
isSameAudioInfo
|
||||
---------------
|
||||
|
||||
.. cpp:function:: static inline bool vsh::isSameAudioInfo(const VSAudioInfo *v1, const VSAudioInfo *v2)
|
||||
|
||||
Checks if two clips have the same audio format and samplerate.
|
||||
|
||||
|
||||
muldivRational
|
||||
--------------
|
||||
|
||||
.. cpp:function:: static inline void vsh::muldivRational(int64_t *num, int64_t *den, int64_t mul, int64_t div)
|
||||
|
||||
Multiplies two rational numbers and reduces the result, i.e.
|
||||
*num*\ /\ *den* \* *mul*\ /\ *div*. The result is stored in *num* and *den*.
|
||||
|
||||
The caller must ensure that *div* is not 0.
|
||||
|
||||
|
||||
reduceRational
|
||||
--------------
|
||||
|
||||
.. cpp:function:: static inline void vsh::reduceRational(int64_t *num, int64_t *den)
|
||||
|
||||
Reduces a rational number.
|
||||
|
||||
|
||||
addRational
|
||||
-----------
|
||||
|
||||
.. cpp:function:: static inline void vsh::addRational(int64_t *num, int64_t *den, int64_t addnum, int64_t addden)
|
||||
|
||||
Adds two rational numbers and reduces the result, i.e.
|
||||
*num*\ /\ *den* + *addnum*\ /\ *addden*. The result is stored in *num* and *den*.
|
||||
|
||||
|
||||
int64ToIntS
|
||||
-----------
|
||||
|
||||
.. cpp:function:: static inline int vsh::int64ToIntS(int64_t i)
|
||||
|
||||
Converts an int64_t to int with signed saturation. It's useful to silence
|
||||
warnings when reading integer properties from a VSMap and to avoid unexpected behavior on int overflow.
|
||||
|
||||
|
||||
doubleToFloatS
|
||||
--------------
|
||||
|
||||
.. cpp:function:: static inline int vsh::doubleToFloatS(double d)
|
||||
|
||||
Converts a double to float. It's useful to silence
|
||||
warnings when reading double properties from a VSMap and mostly exists to mirror `int64ToIntS`_.
|
||||
|
||||
|
||||
bitblt
|
||||
------
|
||||
|
||||
.. cpp:function:: static inline void vsh::bitblt(void *dstp, int dst_stride, const void *srcp, int src_stride, size_t row_size, size_t height)
|
||||
|
||||
Copies bytes from one plane to another. Basically, it is memcpy in a loop.
|
||||
|
||||
*row_size* is in bytes.
|
||||
|
||||
|
||||
areValidDimensions
|
||||
------------------
|
||||
|
||||
.. cpp:function:: static inline bool vsh::areValidDimensions(const VSFormat *fi, int width, int height)
|
||||
|
||||
Checks if the given dimensions are valid for a particular format, with regards
|
||||
to chroma subsampling.
|
||||
|
|
@ -0,0 +1,292 @@
|
|||
VSScript4.h
|
||||
===========
|
||||
|
||||
Table of contents
|
||||
#################
|
||||
|
||||
Introduction_
|
||||
|
||||
|
||||
Structs_
|
||||
VSScript_
|
||||
|
||||
VSScriptAPI_
|
||||
|
||||
|
||||
Functions_
|
||||
getVSScriptAPI_
|
||||
|
||||
getApiVersion_
|
||||
|
||||
getVSAPI_
|
||||
|
||||
createScript_
|
||||
|
||||
getCore_
|
||||
|
||||
evaluateBuffer_
|
||||
|
||||
evaluateFile_
|
||||
|
||||
getError_
|
||||
|
||||
getExitCode_
|
||||
|
||||
getVariable_
|
||||
|
||||
setVariables_
|
||||
|
||||
getOutputNode_
|
||||
|
||||
getOutputAlphaNode_
|
||||
|
||||
getAltOutputMode_
|
||||
|
||||
freeScript_
|
||||
|
||||
evalSetWorkingDir_
|
||||
|
||||
|
||||
Introduction
|
||||
############
|
||||
|
||||
VSScript provides a convenient wrapper for VapourSynth's scripting interface(s), allowing the evaluation of VapourSynth scripts and retrieval of output clips.
|
||||
|
||||
For reasons unknown, the VSScript library is called ``VSScript`` in Windows and ``vapoursynth-script`` everywhere else.
|
||||
|
||||
At this time, VapourSynth scripts can be written only in Python (version 3).
|
||||
|
||||
Here are a few users of the VSScript library:
|
||||
|
||||
* `vspipe <https://github.com/vapoursynth/vapoursynth/blob/master/src/vspipe/vspipe.cpp>`_
|
||||
|
||||
* `vsvfw <https://github.com/vapoursynth/vapoursynth/blob/master/src/vfw/vsvfw.cpp>`_
|
||||
|
||||
* `an example program <https://github.com/vapoursynth/vapoursynth/blob/master/sdk/vsscript_example.c>`_
|
||||
|
||||
* the video player `mpv <https://github.com/mpv-player/mpv/blob/master/video/filter/vf_vapoursynth.c>`_
|
||||
|
||||
.. note::
|
||||
If libvapoursynth-script is loaded with dlopen(), the RTLD_GLOBAL flag must be used. If not, Python won't be able to import binary modules. This is due to Python's design.
|
||||
|
||||
|
||||
Structs
|
||||
#######
|
||||
|
||||
VSScript
|
||||
--------
|
||||
|
||||
A script environment. All evaluation and communication with evaluated scripts happens through a VSScript object.
|
||||
|
||||
|
||||
VSScriptAPI
|
||||
-----------
|
||||
|
||||
This struct is the way to access VSScript's public API.
|
||||
|
||||
|
||||
Functions
|
||||
#########
|
||||
|
||||
getVSScriptAPI
|
||||
--------------
|
||||
|
||||
.. c:function:: const VSSCRIPTAPI *getVSScriptAPI(int version)
|
||||
|
||||
Returns a struct containing function pointer for the api. Will return NULL is the specified *version* isn't supported.
|
||||
|
||||
It is recommended to always pass *VSSCRIPT_API_VERSION*.
|
||||
|
||||
|
||||
getApiVersion
|
||||
-------------
|
||||
|
||||
.. c:function:: int getApiVersion()
|
||||
|
||||
Returns the api version provided by vsscript.
|
||||
|
||||
|
||||
getVSAPI
|
||||
--------
|
||||
|
||||
.. c:function:: const VSAPI *getVSAPI(int version)
|
||||
|
||||
Retrieves the VSAPI struct. Exists mostly as a convenience so the vapoursynth module doesn't have to be explicitly loaded.
|
||||
|
||||
This could return NULL if the VapourSynth library doesn't provide the requested version.
|
||||
|
||||
|
||||
createScript
|
||||
------------
|
||||
|
||||
.. c:function:: VSScript *createScript(VSCore *core)
|
||||
|
||||
Creates an empty script environment that can be used to evaluate scripts. Passing a pre-created *core* can be usful to have custom core creation flags, log callbacks or plugins pre-loaded. Passing NULL will automatically create a new core with default settings.
|
||||
|
||||
Takes over ownership of the *core* regardless of success or failure. Returns NULL on error.
|
||||
|
||||
|
||||
getCore
|
||||
-------
|
||||
|
||||
.. c:function:: VSCore *getCore(VSScript *handle)
|
||||
|
||||
Retrieves the VapourSynth core that was created in the script environment. If a VapourSynth core has not been created yet, it will be created now, with the default options (see the :doc:`../pythonreference`).
|
||||
|
||||
VSScript retains ownership of the returned core object.
|
||||
|
||||
Returns NULL on error.
|
||||
|
||||
|
||||
|
||||
|
||||
evaluateBuffer
|
||||
--------------
|
||||
|
||||
.. c:function:: int evaluateBuffer(VSScript *handle, const char *buffer, const char *scriptFilename)
|
||||
|
||||
Evaluates a script contained in a C string. Can be called multiple times on the same script environment to successively add more processing.
|
||||
|
||||
*handle*
|
||||
Pointer to a script environment.
|
||||
|
||||
*buffer*
|
||||
The entire script to evaluate, as a C string.
|
||||
|
||||
*scriptFilename*
|
||||
A name for the script, which will be displayed in error messages. If this is NULL, the name "<string>" will be used.
|
||||
|
||||
The special ``__file__`` variable will be set to *scriptFilename*'s absolute path if this is not NULL.
|
||||
|
||||
Returns non-zero in case of errors. The error message can be retrieved with getError_\ (). If the script calls *sys.exit(code)* the exit code can be retrieved with getExitCode_\ (). The working directory behavior can be changed by calling evalSetWorkingDir_\ () before this function.
|
||||
|
||||
|
||||
evaluateFile
|
||||
------------
|
||||
|
||||
.. c:function:: int evaluateFile(VSScript **handle, const char *scriptFilename)
|
||||
|
||||
Evaluates a script contained in a file. This is a convenience function which reads the script from a file for you. It will only read the first 16 MiB which should be enough for everyone.
|
||||
|
||||
Behaves the same as evaluateBuffer\ ().
|
||||
|
||||
|
||||
getError
|
||||
--------
|
||||
|
||||
.. c:function:: const char *getError(VSScript *handle)
|
||||
|
||||
Returns the error message from a script environment, or NULL, if there is no error.
|
||||
|
||||
It is okay to pass NULL.
|
||||
|
||||
VSScript retains ownership of the pointer and it is only guaranteed to be valid until the next vsscript operation on the *handle*.
|
||||
|
||||
|
||||
getExitCode
|
||||
-----------
|
||||
|
||||
.. c:function:: int getExitCode(VSScript *handle)
|
||||
|
||||
Returns the exit code if the script calls *sys.exit(code)*, or 0, if the script fails for other reasons or calls *sys.exit(0)*.
|
||||
|
||||
It is okay to pass NULL.
|
||||
|
||||
|
||||
getVariable
|
||||
-----------
|
||||
|
||||
.. c:function:: int getVariable(VSScript *handle, const char *name, VSMap *dst)
|
||||
|
||||
Retrieves a variable from the script environment.
|
||||
|
||||
If a VapourSynth core has not been created yet in the script environment, one will be created now, with the default options (see the :doc:`../pythonreference`).
|
||||
|
||||
*name*
|
||||
Name of the variable to retrieve.
|
||||
|
||||
*dst*
|
||||
Map where the variable's value will be placed, with the key *name*.
|
||||
|
||||
Returns non-zero on error.
|
||||
|
||||
|
||||
setVariables
|
||||
------------
|
||||
|
||||
.. c:function:: int vsscript_setVariable(VSScript *handle, const VSMap *vars)
|
||||
|
||||
Sets variables in the script environment.
|
||||
|
||||
The variables are now available to the script.
|
||||
|
||||
If a VapourSynth core has not been created yet in the script environment, one will be created now, with the default options (see the :doc:`../pythonreference`).
|
||||
|
||||
*vars*
|
||||
Map containing the variables to set.
|
||||
|
||||
Returns non-zero on error.
|
||||
|
||||
|
||||
getOutputNode
|
||||
-------------
|
||||
|
||||
.. c:function:: VSNode *getOutputNode(VSScript *handle, int index)
|
||||
|
||||
Retrieves a node from the script environment. A node in the script must have been marked for output with the requested *index*.
|
||||
|
||||
The returned node has its reference count incremented by one.
|
||||
|
||||
Returns NULL if there is no node at the requested index.
|
||||
|
||||
|
||||
getOutputAlphaNode
|
||||
------------------
|
||||
|
||||
.. c:function:: VSNode *getOutputAlphaNode(VSScript *handle, int index)
|
||||
|
||||
Retrieves an alpha node from the script environment. A node with associated alpha in the script must have been marked for output with the requested *index*.
|
||||
|
||||
The returned node has its reference count incremented by one.
|
||||
|
||||
Returns NULL if there is no alpha node at the requested index.
|
||||
|
||||
|
||||
getAltOutputMode
|
||||
----------------
|
||||
|
||||
.. c:function:: int getAltOutputMode(VSScript *handle, int index)
|
||||
|
||||
Retrieves the alternative output mode settings from the script. This value has no fixed meaning but in vspipe and vsvfw it
|
||||
indicates that alternate output formats should be used when multiple ones are available. It is up to the client application to define the exact meaning or simply disregard it completely.
|
||||
|
||||
Returns 0 if there is no alt output mode set.
|
||||
|
||||
|
||||
freeScript
|
||||
----------
|
||||
|
||||
.. c:function:: void freeScript(VSScript *handle)
|
||||
|
||||
Frees a script environment. *handle* is no longer usable.
|
||||
|
||||
* Cancels any clips set for output in the script environment.
|
||||
|
||||
* Clears any variables set in the script environment.
|
||||
|
||||
* Clears the error message from the script environment, if there is one.
|
||||
|
||||
* Frees the VapourSynth core used in the script environment, if there is one.
|
||||
|
||||
Since this function frees the VapourSynth core, it must be called only after all frame requests are finished and all objects obtained from the script have been freed (frames, nodes, etc).
|
||||
|
||||
It is safe to pass NULL.
|
||||
|
||||
|
||||
evalSetWorkingDir
|
||||
-----------------
|
||||
|
||||
.. c:function:: void evalSetWorkingDir(VSScript *handle, int setCWD)
|
||||
|
||||
Set whether or not the working directory is temporarily changed to the same
|
||||
location as the script file when evaluateFile is called. Off by default.
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
VapourSynth C API Reference
|
||||
===========================
|
||||
|
||||
See the example filters in the sdk dir. Reading simplefilters.c, which contains
|
||||
several built-in functions, can also be very helpful.
|
||||
|
||||
Public Headers
|
||||
##############
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 1
|
||||
:glob:
|
||||
|
||||
api/*
|
||||
|
||||
Common Pitfalls
|
||||
###############
|
||||
|
||||
There are several minor pitfalls related to the threading and design that have to be taken into consideration. Most of them usually aren't a problem but here's a small checklist of things you have to watch out for sometimes.
|
||||
|
||||
General API
|
||||
-----------
|
||||
You may not pass objects (clips, functions and so on) owned by one core as arguments to filters in another core. A manual full deep copy of the data you want to pass on is required. This is generally not a problem since you should never need more than one core per filter graph.
|
||||
|
||||
Plugins
|
||||
-------
|
||||
Plugin code may run more multithreaded than it initially appears. *VapourSynthPluginInit* is the only function always guaranteed to not run in parallel. This means that the constructor and destructor of a filter may be run in parallel for several instances. Use proper synchronization if you need to initialize shared data.
|
||||
|
||||
The *GetFrame* function is a bit more complicated so see the reference of the constants. Do however note that the parallelism is per instance. Even if a filter is *fmUnordered* or *fmSerial* other instances may enter *GetFrame* simultaneously.
|
||||
|
||||
There are two common misconseptions about which mode should be used. A simple rule is that *fmSerial* should never be used. And source filters (those returning a frame on *arInitial*) that need locking should use *fmUnordered*.
|
||||
|
||||
Reserved Frame Properties
|
||||
#########################
|
||||
|
||||
All frames contain a map of key--value pairs. It is recommended that these
|
||||
properties are named using only a-z, A-Z, 0-9 using CamelCase. There is a
|
||||
special category of keys starting with _ which have strictly defined meanings
|
||||
specified below. It is acceptable to not set any of these keys if they are
|
||||
unknown. It is also a fatal error to set them to a value not specified below.
|
||||
|
||||
int _ChromaLocation
|
||||
|
||||
Chroma sample position in YUV formats.
|
||||
|
||||
0=left, 1=center, 2=topleft, 3=top, 4=bottomleft, 5=bottom.
|
||||
|
||||
int _ColorRange
|
||||
|
||||
Full or limited range (PC/TV range). Primarily used with YUV formats.
|
||||
|
||||
0=full range, 1=limited range.
|
||||
|
||||
int _Primaries
|
||||
|
||||
Color primaries as specified in ITU-T H.265 Table E.3.
|
||||
|
||||
int _Matrix
|
||||
|
||||
Matrix coefficients as specified in ITU-T H.265 Table E.5.
|
||||
|
||||
int _Transfer
|
||||
|
||||
Transfer characteristics as specified in ITU-T H.265 Table E.4.
|
||||
|
||||
int _FieldBased
|
||||
|
||||
If the frame is composed of two independent fields (interlaced).
|
||||
|
||||
0=frame based (progressive), 1=bottom field first, 2=top field first.
|
||||
|
||||
float _AbsoluteTime
|
||||
|
||||
The frame's absolute timestamp in seconds if reported by the source filter.
|
||||
Should only be set by the source filter and not be modified. Use durations
|
||||
for all operations that depend on frame length.
|
||||
|
||||
int _DurationNum, int _DurationDen
|
||||
|
||||
The frame's duration in seconds as a rational number. Filters that
|
||||
modify the framerate should also change these values.
|
||||
|
||||
This fraction should always be normalized.
|
||||
|
||||
bint _Combed
|
||||
|
||||
Whether or not the frame needs postprocessing, usually hinted from field
|
||||
matching filters.
|
||||
|
||||
int _Field
|
||||
|
||||
If the frame was produced by something like core.std.SeparateFields,
|
||||
this property signals which field was used to generate this frame.
|
||||
|
||||
0=from bottom field, 1=from top field.
|
||||
|
||||
string _PictType
|
||||
|
||||
A single character describing the frame type. It uses the common
|
||||
IPB letters but other letters may also be used for formats with
|
||||
additional frame types.
|
||||
|
||||
int _SARNum, int _SARDen
|
||||
|
||||
Pixel (sample) aspect ratio as a rational number.
|
||||
|
||||
bint _SceneChangeNext
|
||||
|
||||
If 1, this frame is the last frame of the current scene. The next frame starts a new scene.
|
||||
|
||||
bint _SceneChangePrev
|
||||
|
||||
If 1, this frame starts a new scene.
|
||||
|
||||
frame _Alpha
|
||||
|
||||
A clip's alpha channel can be attached to the clip one frame at a
|
||||
time using this property.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
Applications and Libraries
|
||||
==========================
|
||||
|
||||
Applications
|
||||
############
|
||||
|
||||
* `D2V Witch <https://github.com/dubhater/D2VWitch>`_ -- creates indexes that can be opened by d2vsource
|
||||
* `Hybrid <https://www.selur.de/>`_ `(Doom9) <https://forum.doom9.org/showthread.php?t=153035>`__ -- encoding GUI with VapourSynth support
|
||||
* `mpv.net <https://github.com/stax76/mpv.net>`_ -- a media player with VapourSynth built-in
|
||||
* `SmoothVideo Project <https://www.svp-team.com/wiki/Main_Page>`_ -- a plugin/video player component for realtime frame interpolation
|
||||
* `StaxRip <https://github.com/staxrip/staxrip>`_ -- encoding GUI with extended VapourSynth scripting support
|
||||
* `VapourSynth Editor <https://github.com/YomikoR/VapourSynth-Editor>`_ `(Doom9) <https://forum.doom9.org/showthread.php?t=170965>`__ -- an editor with syntax completion and fast preview support
|
||||
* `VapourSynth Editor 2 <https://bitbucket.org/gundamftw/vapoursynth-editor-2/>`_ `(Doom9) <https://forum.doom9.org/showthread.php?t=181708>`__ -- a spiritual successor to VapourSynth Editor
|
||||
* `VirtualDub2 <https://sourceforge.net/projects/vdfiltermod/>`_ `(Doom9) <https://forum.doom9.org/showthread.php?t=172021>`__ -- VirtualDub with added support for high bitdepth colorspaces, useful for previewing
|
||||
* `vsmkv <https://github.com/fluxamp/vsmkv>`_ -- a FUSE-based virtual filesystem for exporting VapourSynth scripts as uncompressed videos in the Matroska (MKV) file format
|
||||
* `vspreview <https://github.com/Irrational-Encoding-Wizardry/vs-preview>`_ -- an advanced standalone previewer written in python with too many features to list
|
||||
* `vspreview-rs <https://github.com/quietvoid/vspreview-rs>`_ `(Doom9) <https://forum.doom9.org/showthread.php?t=183903>`__ -- minimal VapourSynth script previewer
|
||||
* `Wobbly <https://github.com/dubhater/Wobbly>`_ `(Doom9) <https://forum.doom9.org/showthread.php?t=172496>`__ -- IVTC assistant similar to YATTA
|
||||
* `Yuuno <https://git.encode.moe/irrational-encoding-wizardry/yuuno>`_ -- incorporates VapourSynth into Jupyter
|
||||
|
||||
Libraries
|
||||
#########
|
||||
|
||||
* `VapourSynth.nim <https://forum.doom9.org/showthread.php?p=1905351>`_ -- Bindings for the Nim programming language
|
||||
* `vapoursynth-rs <https://crates.io/crates/vapoursynth>`_ -- VapourSynth Rust wrapper
|
||||
* `vsxx <https://github.com/sekrit-twc/vsxx>`_ -- VapourSynth C++ API wrapper
|
||||
|
||||
Tools
|
||||
#####
|
||||
|
||||
* GitHub Action `install-vapoursynth <https://github.com/marketplace/actions/install-vapoursynth>`_ -- Installs vapoursynth in your GitHub Action.
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
Function Reference
|
||||
==================
|
||||
|
||||
General Functions
|
||||
#################
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 2
|
||||
:glob:
|
||||
|
||||
functions/general/*
|
||||
|
||||
Video Functions
|
||||
###############
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 2
|
||||
:glob:
|
||||
|
||||
functions/video/*
|
||||
|
||||
Text
|
||||
****
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 2
|
||||
:glob:
|
||||
|
||||
functions/video/text/*
|
||||
|
||||
Audio Functions
|
||||
###############
|
||||
|
||||
.. toctree::
|
||||
:maxdepth: 2
|
||||
:glob:
|
||||
|
||||
functions/audio/*
|
||||
|
|
@ -0,0 +1,5 @@
|
|||
AssumeSampleRate
|
||||
================
|
||||
|
||||
.. function:: AssumeSampleRate(anode clip[, anode src, int samplerate])
|
||||
:module: std
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
AudioGain
|
||||
=========
|
||||
|
||||
.. function:: AudioGain(anode clip, float[] gain)
|
||||
:module: std
|
||||
|
||||
AudioGain can either change the volume of individual channels
|
||||
if a separate *gain* for each channel is given or if only a single
|
||||
*gain* value is supplied it's applied to all channels.
|
||||
|
||||
Negative *gain* values are allowed. Applying a too large gain will
|
||||
lead to clipping in integer formats.
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
AudioLoop
|
||||
=========
|
||||
|
||||
.. function:: AudioLoop(anode clip[, int times=0])
|
||||
:module: std
|
||||
|
||||
Returns a clip with the frames or samples repeated over and over again. If *times* is
|
||||
less than 1 the clip will be repeated until the maximum clip length is
|
||||
reached, otherwise it will be repeated *times* times.
|
||||
|
||||
In Python, std.AudioLoop can also be invoked :ref:`using the multiplication operator <pythonreference>`.
|
||||
|
|
@ -0,0 +1,38 @@
|
|||
AudioMix
|
||||
========
|
||||
|
||||
.. function:: AudioMix(anode[] clips, float[] matrix, int[] channels_out)
|
||||
:module: std
|
||||
|
||||
AudioMix can mix and combine channels from different clips in the most
|
||||
general way possible.
|
||||
|
||||
Most of the returned clip's properties are implicitly determined from the
|
||||
first clip given to *clips*.
|
||||
|
||||
The *clips* parameter takes one or more clips with the same format. If the clips
|
||||
are different lengths they'll be zero extended to that of the longest.
|
||||
|
||||
The argument *matrix* applies the coefficients to each channel of each input clip where
|
||||
the channels are in the numerical order of their channel constants. For example a stereo clip
|
||||
will have its channels presented in the order FRONT_LEFT and then FRONT_RIGHT.
|
||||
|
||||
Output channels and order is determined by the *channels_out* array
|
||||
between input index and output channel happens on the order of lowest output channel
|
||||
identifier to the highest.
|
||||
|
||||
|
||||
|
||||
Below are some examples of useful operations.
|
||||
|
||||
Downmix stereo audio to mono::
|
||||
|
||||
AudioMix(clips=clip, matrix=[0.5, 0.5], channels_out=[vs.FRONT_CENTER])
|
||||
|
||||
Downmix 5.1 audio::
|
||||
|
||||
AudioMix(clips=clip, matrix=[1, 0, 0.7071, 0, 0.7071, 0, 0, 1, 0.7071, 0, 0, 0.7071], channels_out=[vs.FRONT_LEFT, vs.FRONT_RIGHT])
|
||||
|
||||
Copy stereo audio to 5.1 and zero the other channels::
|
||||
|
||||
AudioMix(clips=c, matrix=[1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0], channels_out=[vs.FRONT_LEFT, vs.FRONT_RIGHT, vs.FRONT_CENTER, vs.LOW_FREQUENCY, vs.BACK_LEFT, vs.BACK_RIGHT])
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
AudioReverse
|
||||
============
|
||||
|
||||
.. function:: AudioReverse(anode clip)
|
||||
:module: std
|
||||
|
||||
Returns a clip with the frame or sample order reversed. For example, a clip with 3
|
||||
frames would have the frame order 2, 1, 0.
|
||||
|
||||
In Python, std.AudioReverse can also be invoked by :ref:`slicing a clip <pythonreference>`.
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
AudioSplice
|
||||
===========
|
||||
|
||||
.. function:: AudioSplice(anode[] clips)
|
||||
:module: std
|
||||
|
||||
Returns a clip with all *clips* appended in the given order.
|
||||
|
||||
Splicing clips with different formats or dimensions is
|
||||
considered an error unless *mismatch* is true.
|
||||
|
||||
In Python, std.AudioSplice can also be invoked :ref:`using the addition operator <pythonreference>`.
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
AudioTrim
|
||||
=========
|
||||
|
||||
.. function:: AudioTrim(anode clip[, int first=0, int last, int length])
|
||||
:module: std
|
||||
|
||||
AudioTrim performs exactly the same operation on audio clips but the unit is
|
||||
obviously samples instead of frames.
|
||||
|
||||
In Python, std.AudioTrim can also be invoked by :ref:`slicing a clip <pythonreference>`.
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
BlankAudio
|
||||
==========
|
||||
|
||||
.. function:: BlankAudio([anode clip, int[] channels=[FRONT_LEFT, FRONT_RIGHT], int bits=16, int sampletype=INTEGER, int samplerate=44100, int length=(10*samplerate), bint keep=0])
|
||||
:module: std
|
||||
|
||||
Generates a new empty clip. This can be useful to have when editing audio
|
||||
or for testing. The default is a 10 second long 44.1kHz 16 bit stereo clip.
|
||||
Instead of specifying every property individually, BlankAudio can also copy
|
||||
the properties from *clip*. If both an argument such as *sampletype*, and *clip*
|
||||
are set, then *sampletype* will take precedence.
|
||||
|
||||
The *channels* argument is a list of channel constants. Specifying the same channel twice
|
||||
is not allowed.
|
||||
|
||||
The possible *sampletype* values are currently INTEGER (0) and FLOAT (1).
|
||||
|
||||
If *keep* is set, a reference to the same frame is returned on every request.
|
||||
Otherwise a new frame is generated every time. There should usually be no
|
||||
reason to change this setting.
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
SetAudioCache
|
||||
=============
|
||||
|
||||
.. function:: SetAudioCache(anode clip[, int mode, int fixedsize, int maxsize, int historysize])
|
||||
:module: std
|
||||
|
||||
see SetVideoCache
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
ShuffleChannels
|
||||
===============
|
||||
|
||||
.. function:: ShuffleChannels(anode[] clips, int[] channels_in, int[] channels_out)
|
||||
:module: std
|
||||
|
||||
ShuffleChannels can extract and combine channels from different clips in the most
|
||||
general way possible.
|
||||
|
||||
Most of the returned clip's properties are implicitly determined from the
|
||||
first clip given to *clips*.
|
||||
|
||||
The *clips* parameter takes one or more clips with the same format. If the clips
|
||||
are different lengths they'll be zero extended to that of the longest.
|
||||
|
||||
The argument *channels_in* controls which of the input clips' channels to use and
|
||||
takes a channel constants as its argument. Specifying a non-existent channel
|
||||
is an error. If more *channels_in* than *clips* values are specified then the last
|
||||
clip in the *clips* list is reused as a source. In addition to the channel constant
|
||||
it's also possible to specify the nth channel by using negative numbers.
|
||||
|
||||
The output channel mapping is determined by *channels_out* and corresponds to the
|
||||
input channel order. The number of *channels_out* entries must be the same as the
|
||||
number of *channels_in* entries. Specifying the same output channel twice is an error.
|
||||
|
||||
|
||||
|
||||
Below are some examples of useful operations.
|
||||
|
||||
Extract the left channel (assuming it exists)::
|
||||
|
||||
ShuffleChannels(clips=clip, channels_in=vs.FRONT_LEFT, channels_out=vs.FRONT_LEFT)
|
||||
|
||||
Swap left and right audio channels in a stereo clip::
|
||||
|
||||
ShuffleChannels(clips=clip, channels_in=[vs.FRONT_RIGHT, vs.FRONT_LEFT], channels_out=[vs.FRONT_LEFT, vs.FRONT_RIGHT])
|
||||
|
||||
Swap left and right audio channels in a stereo clip (alternate ordering of arguments)::
|
||||
|
||||
ShuffleChannels(clips=clip, channels_in=[vs.FRONT_LEFT, vs.FRONT_RIGHT], channels_out=[vs.FRONT_RIGHT, vs.FRONT_LEFT])
|
||||
|
||||
Swap left and right audio channels in a stereo clip (alternate indexing)::
|
||||
|
||||
ShuffleChannels(clips=clip, channels_in=[-2, -1], channels_out=[vs.FRONT_LEFT, vs.FRONT_RIGHT])
|
||||
|
||||
Merge 2 mono audio clips into a single stereo clip::
|
||||
|
||||
ShuffleChannels(clips=[clipa, clipb], channels_in=[vs.FRONT_LEFT, vs.FRONT_LEFT], channels_out=[vs.FRONT_LEFT, vs.FRONT_RIGHT])
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
SplitChannels
|
||||
=============
|
||||
|
||||
.. function:: SplitChannels(anode clip)
|
||||
:module: std
|
||||
|
||||
SplitChannels returns each audio channel of the input as
|
||||
a separate clip.
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
LoadAllPlugins
|
||||
==============
|
||||
|
||||
.. function:: LoadAllPlugins(string path)
|
||||
:module: std
|
||||
|
||||
Loads all native VapourSynth plugins found in the
|
||||
specified *path*. Plugins that fail to load are
|
||||
silently skipped.
|
||||
|
||||
Beware of Python's escape character, this will fail::
|
||||
|
||||
LoadPlugin(path='c:\plugins')
|
||||
|
||||
Correct ways::
|
||||
|
||||
LoadPlugin(path='c:/plugins')
|
||||
LoadPlugin(path=r'c:\plugins')
|
||||
LoadPlugin(path='c:\\plugins\\')
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
LoadPlugin
|
||||
==========
|
||||
|
||||
.. function:: LoadPlugin(string path, bint altsearchpath = False)
|
||||
:module: std
|
||||
|
||||
Load a native VapourSynth plugin. If successful, the loaded plugin's
|
||||
functions will end up in their own namespace.
|
||||
|
||||
Returns an error if a plugin with the same identifier or namespace already
|
||||
has been loaded. This is to prevent naming collisions or multiple versions
|
||||
of the same plugin being loaded at once.
|
||||
|
||||
Plugins are normally loaded with a very specific search order for
|
||||
dependencies. Setting *altsearchpath* modifies this behavior to also
|
||||
include dlls in the PATH.
|
||||
|
||||
Beware of Python's escape character, this will fail::
|
||||
|
||||
LoadPlugin(path='c:\plugins\filter.dll')
|
||||
|
||||
Correct ways::
|
||||
|
||||
LoadPlugin(path='c:/plugins/filter.dll')
|
||||
LoadPlugin(path=r'c:\plugins\filter.dll')
|
||||
LoadPlugin(path='c:\\plugins\\filter.dll')
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
LoadPlugin (Avisynth Compatibility)
|
||||
===================================
|
||||
|
||||
.. function:: LoadPlugin(string path)
|
||||
:module: avs
|
||||
|
||||
Load an Avisynth 2.5 (32 bit only), 2.6 (32 and 64 bit) or Avisynth+ (32 and 64 bit) plugin.
|
||||
If successful, the loaded plugin's functions will end up in the avs namespace. Note that
|
||||
in the case of Avisynth+ there's no way to use the formats combined with alpha or
|
||||
higher bitdepth packed RGB. Coincidentally there are no plugins that use this in a
|
||||
meaningful way yet.
|
||||
|
||||
The compatibility module can work with a large number of Avisynth's plugins.
|
||||
However, the wrapping is not complete, so the following things will cause
|
||||
problems:
|
||||
|
||||
* The plugin expects YUY2 or RGB32 input. In this case provide input in
|
||||
either YUV422P8 or RGB24 format pass compatpack=True as an argument
|
||||
to the Avisynth function.
|
||||
* The plugin tries to call env->invoke().
|
||||
These calls are ignored when it is safe to do so, but otherwise they
|
||||
will most likely trigger a fatal error.
|
||||
* Plugins trying to read global variables.
|
||||
There are no global variables.
|
||||
|
||||
If there are function name collisions functions will have a number appended
|
||||
to them to make them distinct. For example if three functions are named
|
||||
*func* then they will be named *func*, *func_2* and *func_3*. This means
|
||||
that Avisynth functions that have multiple overloads (rare) will give
|
||||
each overload a different name.
|
||||
|
||||
Note that if you are really insane you can load Avisynth's VirtualDub plugin
|
||||
loader and use VirtualDub plugins as well. Function overloads are very common
|
||||
when dealing with VirtualDub.
|
||||
|
||||
Beware of Python's escape character, this will fail::
|
||||
|
||||
LoadPlugin(path='c:\plugins\filter.dll')
|
||||
|
||||
Correct ways::
|
||||
|
||||
LoadPlugin(path='c:/plugins/filter.dll')
|
||||
LoadPlugin(path=r'c:\plugins\filter.dll')
|
||||
LoadPlugin(path='c:\\plugins\\filter.dll')
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
SetMaxCPU
|
||||
=========
|
||||
|
||||
.. function:: SetMaxCPU(string cpu)
|
||||
:module: std
|
||||
|
||||
This function is only intended for testing and debugging purposes
|
||||
and sets the maximum used instruction set for optimized functions.
|
||||
|
||||
Possible values for x86: "avx2", "sse2", "none"
|
||||
|
||||
Other platforms: "none"
|
||||
|
||||
By default all supported cpu features are used.
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
AddBorders
|
||||
==========
|
||||
|
||||
.. function:: AddBorders(vnode clip[, int left=0, int right=0, int top=0, int bottom=0, float[] color=<black>])
|
||||
:module: std
|
||||
|
||||
Adds borders to frames. The arguments specify the number of pixels to add on
|
||||
each side. They must obey the subsampling restrictions.
|
||||
The newly added borders will be set to *color*.
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
AssumeFPS
|
||||
=========
|
||||
|
||||
.. function:: AssumeFPS(vnode clip[, vnode src, int fpsnum, int fpsden=1])
|
||||
:module: std
|
||||
|
||||
Returns a clip with the framerate changed. This does not in any way modify
|
||||
the frames, only their metadata.
|
||||
|
||||
The framerate to assign can either be read from another clip, *src*, or given
|
||||
as a rational number with *fpsnum* and *fpsden*.
|
||||
|
||||
It is an error to specify both *src* and *fpsnum*.
|
||||
|
||||
AssumeFPS overwrites the frame properties ``_DurationNum`` and
|
||||
``_DurationDen`` with the frame duration computed from the new frame rate.
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
AverageFrames
|
||||
=============
|
||||
|
||||
.. function:: AverageFrames(vnode[] clips, float[] weights[, float scale, bint scenechange, int[] planes])
|
||||
:module: std
|
||||
|
||||
AverageFrames has two main modes depending on whether one or multiple *clips* are supplied.
|
||||
The filter is named AverageFrames since using ones for weights is an easy way to average
|
||||
many frames together but it can also be seen as a temporal or multiple frame convolution.
|
||||
|
||||
If multiple *clips* are supplied then the frames from each of the *clips* are multiplied by
|
||||
the respective *weights*, summed together and divided by *scale* before being output. Note
|
||||
that only integer *weights* and *scale* are allowed for integer input formats.
|
||||
|
||||
If a single *clip* is supplied then an odd number of *weights* are needed and they will instead
|
||||
be temporally centered on the current frame of the *clip*. The rest works as multiple *clip* mode
|
||||
with the only difference being that *scenechange* can be set to avoid averaging frames over scene
|
||||
changes. If this happens then all the weights beyond a scene change are instead applied to the frame
|
||||
right before it.
|
||||
|
||||
At most 31 *weights* can be supplied.
|
||||
|
|
@ -0,0 +1,34 @@
|
|||
Binarize/BinarizeMask
|
||||
=====================
|
||||
|
||||
.. function:: Binarize(vnode clip[, float[] threshold, float[] v0, float[] v1, int[] planes=[0, 1, 2]])
|
||||
BinarizeMask(vnode clip[, float[] threshold, float[] v0, float[] v1, int[] planes=[0, 1, 2]])
|
||||
:module: std
|
||||
|
||||
Turns every pixel in the image into either *v0*, if it's below
|
||||
*threshold*, or *v1*, otherwise. The *BinarizeMask* version is intended
|
||||
for use on mask clips where all planes have the same value range and
|
||||
only differs in the default values of *v0* and *v1*.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*threshold*
|
||||
Defaults to the middle point of range allowed by the format.
|
||||
Can be specified for each plane individually.
|
||||
|
||||
*v0*
|
||||
Value given to pixels that are below *threshold*. Can be specified
|
||||
for each plane individually. Defaults to the lower bound of the format.
|
||||
|
||||
*v1*
|
||||
Value given to pixels that are greater than or equal to *threshold*.
|
||||
Defaults to the maximum value allowed by the format. Can be specified
|
||||
for each plane individually. Defaults to the upper bound of the format.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
BlankClip
|
||||
=========
|
||||
|
||||
.. function:: BlankClip([vnode clip, int width=640, int height=480, int format=vs.RGB24, int length=(10*fpsnum)/fpsden, int fpsnum=24, int fpsden=1, float[] color=<black>, bint keep=0, bint varsize=0, bint varformat=0])
|
||||
:module: std
|
||||
|
||||
Generates a new empty clip. This can be useful to have when editing video or
|
||||
for testing. The default is a 640x480 RGB24 24fps 10 second long black clip.
|
||||
Instead of specifying every property individually, BlankClip can also copy
|
||||
the properties from *clip*. If both an argument such as *width*, and *clip*
|
||||
are set, then *width* will take precedence.
|
||||
|
||||
If *keep* is set, a reference to the same frame is returned on every request.
|
||||
Otherwise a new frame is generated every time. There should usually be no
|
||||
reason to change this setting.
|
||||
|
||||
If *varsize* is set, a clip with variable size will be returned. The frames
|
||||
themselves will still have the size given by the width and height arguments.
|
||||
|
||||
If *varformat* is set, a clip with variable format will be returned.
|
||||
The frames themselves will have the format given by the format argument.
|
||||
|
||||
It is never an error to use BlankClip.
|
||||
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
BoxBlur
|
||||
=======
|
||||
|
||||
.. function:: BoxBlur(vnode clip[, int[] planes, int hradius = 1, int hpasses = 1, int vradius = 1, int vpasses = 1])
|
||||
:module: std
|
||||
|
||||
Performs a box blur which is fast even for large radius values. Using multiple *passes* can be used to fairly cheaply
|
||||
approximate a gaussian blur. A *radius* of 0 means no processing is performed.
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
ClipToProp
|
||||
==========
|
||||
|
||||
.. function:: ClipToProp(vnode clip, vnode mclip[, string prop='_Alpha'])
|
||||
:module: std
|
||||
|
||||
Stores each frame of *mclip* as a frame property named *prop* in *clip*. This
|
||||
is primarily intended to attach mask/alpha clips to another clip so that
|
||||
editing operations will apply to both. Unlike most other filters the output
|
||||
length is derived from the second argument named *mclip*.
|
||||
|
||||
If the attached *mclip* does not represent the alpha channel, you should set
|
||||
*prop* to something else.
|
||||
|
||||
It is the inverse of PropToClip().
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
Convolution
|
||||
===========
|
||||
|
||||
.. function:: Convolution(vnode clip, float[] matrix[, float bias=0.0, float divisor=0.0, int[] planes=[0, 1, 2], bint saturate=True, string mode="s"])
|
||||
:module: std
|
||||
|
||||
Performs a spatial convolution.
|
||||
|
||||
Here is how a 3x3 convolution is done. Each pixel in the 3x3
|
||||
neighbourhood is multiplied by the corresponding coefficient in
|
||||
*matrix*. The results of the nine multiplications are added together,
|
||||
then this sum is divided by *divisor*. Next, *bias* is added, and the
|
||||
result is rounded to the nearest larger integer. If this integer
|
||||
result is negative and the *saturate* parameter is False, it is
|
||||
multiplied by -1. Finally, the result is clamped to the format's range
|
||||
of valid values.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*matrix*
|
||||
Coefficients for the convolution.
|
||||
|
||||
When *mode* is "s", this must be an array of 9 or 25 numbers, for
|
||||
a 3x3 or 5x5 convolution, respectively.
|
||||
|
||||
When *mode* is not "s", this must be an array of 3 to 25 numbers,
|
||||
with an odd number of elements.
|
||||
|
||||
The values of the coefficients must be between -1023 and 1023
|
||||
(inclusive). The coefficients are rounded to integers when
|
||||
the input is an integer format.
|
||||
|
||||
This is how the elements of *matrix* correspond to the pixels in
|
||||
a 3x3 neighbourhood::
|
||||
|
||||
1 2 3
|
||||
4 5 6
|
||||
7 8 9
|
||||
|
||||
It's the same principle for the other types of convolutions. The
|
||||
middle element of *matrix* always corresponds to the center pixel.
|
||||
|
||||
*bias*
|
||||
Value to add to the final result of the convolution (before clamping
|
||||
the result to the format's range of valid values).
|
||||
|
||||
*divisor*
|
||||
Divide the output of the convolution by this value (before adding
|
||||
*bias*).
|
||||
|
||||
If this parameter is 0.0 (the default), the output of the convolution
|
||||
will be divided by the sum of the elements of *matrix*, or by 1.0,
|
||||
if the sum is 0.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
||||
*saturate*
|
||||
The final result is clamped to the format's range of valid values
|
||||
(0 .. (2**bitdepth)-1). Therefore, if this parameter is True,
|
||||
negative values become 0. If this parameter is False, it's instead
|
||||
the absolute value that is clamped and returned.
|
||||
|
||||
*mode*
|
||||
Selects the type of convolution. Possible values are "s", for square,
|
||||
"h" for horizontal, "v" for vertical, and "hv" or "vh" for both
|
||||
horizontal and vertical.
|
||||
|
||||
How to apply a simple blur equivalent to Avisynth's Blur(1):
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
Convolution(matrix=[1, 2, 1, 2, 4, 2, 1, 2, 1])
|
||||
|
||||
How to apply a stronger blur equivalent to Avisynth's Blur(1.58):
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
Convolution(matrix=[1, 1, 1, 1, 1, 1, 1, 1, 1])
|
||||
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
CopyFrameProps
|
||||
==============
|
||||
|
||||
.. function:: CopyFrameProps(vnode clip, vnode prop_src)
|
||||
:module: std
|
||||
|
||||
Returns *clip* but with all the frame properties replaced with the
|
||||
ones from the clip in *prop_src*. Note that if *clip* is longer
|
||||
than *prop_src* then the last existing frame's properties will be
|
||||
used instead.
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
Crop/CropAbs
|
||||
===============
|
||||
|
||||
.. function:: Crop(vnode clip[, int left=0, int right=0, int top=0, int bottom=0])
|
||||
CropAbs(vnode clip, int width, int height[, int left=0, int top=0])
|
||||
:module: std
|
||||
|
||||
Crops the frames in a clip.
|
||||
|
||||
Crop is the simplest to use of the two. The arguments specify how many
|
||||
pixels to crop from each side. This function used to be called CropRel
|
||||
which is still an alias for it.
|
||||
|
||||
CropAbs, on the other hand, is special, because it can accept clips with
|
||||
variable frame sizes and crop out a fixed size area, thus making it a fixed
|
||||
size clip.
|
||||
|
||||
Both functions return an error if the whole picture is cropped away, if the
|
||||
cropped area extends beyond the input or if the subsampling restrictions
|
||||
aren't met.
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
Deflate/Inflate
|
||||
===============
|
||||
|
||||
.. function:: Deflate(vnode clip[, int[] planes=[0, 1, 2], float threshold])
|
||||
:module: std
|
||||
|
||||
Replaces each pixel with the average of the eight pixels in its 3x3
|
||||
neighbourhood, but only if that average is less than the center pixel.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
||||
*threshold*
|
||||
Allows to limit how much pixels are changed. Output pixels will not
|
||||
become less than ``input - threshold``. The default is no limit.
|
||||
|
||||
|
||||
.. function:: Inflate(vnode clip[, int[] planes=[0, 1, 2], int threshold=65535])
|
||||
:module: std
|
||||
|
||||
Replaces each pixel with the average of the eight pixels in its 3x3
|
||||
neighbourhood, but only if that average is greater than the center
|
||||
pixel.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
||||
*threshold*
|
||||
Allows to limit how much pixels are changed. Output pixels will not
|
||||
become greater than ``input + threshold``. The default is no limit.
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
DeleteFrames
|
||||
============
|
||||
|
||||
.. function:: DeleteFrames(vnode clip, int[] frames)
|
||||
:module: std
|
||||
|
||||
Deletes the specified frames.
|
||||
|
||||
All frame numbers apply to the input clip.
|
||||
|
||||
Returns an error if the same frame is deleted twice or if all frames in a clip are deleted.
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
DoubleWeave
|
||||
===========
|
||||
|
||||
.. function:: DoubleWeave(vnode clip[, bint tff])
|
||||
:module: std
|
||||
|
||||
Weaves the fields back together from a clip with interleaved fields.
|
||||
|
||||
Since VapourSynth only has a weak notion of field order internally, *tff*
|
||||
may have to be set. Setting *tff* to true means top fields first and false
|
||||
means bottom fields first. Note that the ``_Field`` frame property, if present
|
||||
and in a valid combination, takes precedence over *tff*.
|
||||
|
||||
DoubleWeave's output has the same number of frames as the input. One must
|
||||
use DoubleWeave together with SelectEvery to undo the effect of
|
||||
SeparateFields::
|
||||
|
||||
sep = core.std.SeparateFields(source)
|
||||
...
|
||||
woven = core.std.DoubleWeave(sep)
|
||||
woven = core.std.SelectEvery(woven, 2, 0)
|
||||
|
||||
The ``_Field`` frame property is deleted and ``_FieldBased`` is set accordingly.
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
DuplicateFrames
|
||||
===============
|
||||
|
||||
.. function:: DuplicateFrames(vnode clip, int[] frames)
|
||||
:module: std
|
||||
|
||||
Duplicates the specified frames.
|
||||
|
||||
A frame may be duplicated several times.
|
||||
|
||||
All frame numbers apply to the input clip.
|
||||
|
|
@ -0,0 +1,118 @@
|
|||
Expr
|
||||
====
|
||||
|
||||
.. function:: Expr(vnode[] clips, string[] expr[, int format])
|
||||
:module: std
|
||||
|
||||
Expr evaluates an expression per pixel for up to 26 input *clips*.
|
||||
The expression, *expr*, is written using reverse polish notation and can be
|
||||
specified for each plane individually.
|
||||
The expression given for the previous plane is used if the *expr* array
|
||||
contains fewer expressions than the input clip has planes.
|
||||
In practice this means that a single expression will be applied to all planes
|
||||
by default.
|
||||
|
||||
Specifying an empty string as the expression enables a fast plane copy from
|
||||
the first specified clip, when possible. If it is not possible due to the
|
||||
output *format* being incompatible, the plane contents will be undefined.
|
||||
|
||||
Since the expression is evaluated at runtime, there are a few pitfalls. In
|
||||
order to keep speed up, the input ranges are not normalized to the usual
|
||||
floating point ranges. Instead they are left as is, meaning that an 8 bit
|
||||
clip will have values in the 0-255 range and a 10 bit clip will have values
|
||||
in the 0-1023 range.
|
||||
Note that floating point clips are even more difficult, as most channels are
|
||||
stored in the 0-1 range with the exception of U, V, Co and Cg planes, which
|
||||
are in the -0.5-0.5 range.
|
||||
If you mix clips with different input formats this must be taken into
|
||||
consideration.
|
||||
|
||||
When the output format uses integer samples, the result of the expression is
|
||||
clamped to the [0, 2**bits_per_sample-1] range.
|
||||
When the output format uses float samples, the result of the expression is
|
||||
stored without any clamping.
|
||||
|
||||
By default the output *format* is the same as the first input clip's format.
|
||||
You can override it by setting *format*. The only restriction is that the
|
||||
output *format* must have the same subsampling as the input *clips* and be
|
||||
8..16 bit integer or 32 bit float. 16 bit float is also supported on cpus
|
||||
with the f16c instructions.
|
||||
|
||||
Logical operators are also a bit special, since everything is done in
|
||||
floating point arithmetic.
|
||||
All values greater than 0 are considered true for the purpose of comparisons.
|
||||
Logical operators return 0.0 for false and 1.0 for true in their operations.
|
||||
|
||||
Since the expression is being evaluated at runtime, there are also the stack
|
||||
manipulation operators, *swap* and *dup*. The former swaps the topmost and
|
||||
second topmost values, and the latter duplicates the topmost stack value.
|
||||
|
||||
These operators also have *swapN* and *dupN* forms that allow a value N
|
||||
steps up in the stack to be swapped or duplicated. The top value of the stack
|
||||
has index zero meaning that *dup* is equivalent to *dup0* and *swap* is
|
||||
equivalent to *swap1*. This is because *swapN* always swaps with the topmost
|
||||
value at index 0.
|
||||
|
||||
Expressions are converted to byte-code or machine-code by an optimizing
|
||||
compiler and are not guaranteed to evaluate in the order originally written.
|
||||
The compiler assumes that all input values are finite (i.e neither NaN nor
|
||||
INF) and that no operator will produce a non-finite value. Such expressions
|
||||
are invalid. This is especially important for the transcendental operators:
|
||||
|
||||
* exp - expression must not overflow (i.e. x <= 88)
|
||||
* log - input must be finite and non-negative (i.e. x >= 0 && x <= 3e+38)
|
||||
* pow - base must be finite and non-negative. Result must not overflow (i.e. x >= 0 && x <= 3e+38; 1e-38 <= result <= 3e+38)
|
||||
|
||||
Clip load operators::
|
||||
|
||||
x-z, a-w
|
||||
|
||||
The operators taking one argument are::
|
||||
|
||||
exp log sqrt sin cos abs not dup dupN
|
||||
|
||||
The operators taking two arguments are::
|
||||
|
||||
+ - * / max min pow > < = >= <= and or xor swap swapN
|
||||
|
||||
The operators taking three arguments are::
|
||||
|
||||
?
|
||||
|
||||
For example these operations::
|
||||
|
||||
a b c ?
|
||||
|
||||
d e <
|
||||
|
||||
f abs
|
||||
|
||||
Are equivalent to these operations in C::
|
||||
|
||||
a ? b : c
|
||||
|
||||
d < e
|
||||
|
||||
abs(f)
|
||||
|
||||
The sin/cos operators are approximated to within 2e-6 absolute error for
|
||||
inputs with magnitude up to 1e5, and there is no accuracy guarantees for
|
||||
inputs whose magnitude is larger than 2e5.
|
||||
|
||||
How to average the Y planes of 3 YUV clips and pass through the UV planes
|
||||
unchanged (assuming same format)::
|
||||
|
||||
std.Expr(clips=[clipa, clipb, clipc], expr=["x y + z + 3 /", "", ""])
|
||||
|
||||
How to average the Y planes of 3 YUV clips and pass through the UV planes
|
||||
unchanged (different formats)::
|
||||
|
||||
std.Expr(clips=[clipa16bit, clipb10bit, clipa8bit],
|
||||
expr=["x y 64 * + z 256 * + 3 /", ""])
|
||||
|
||||
Setting the output format because the resulting values are illegal in a 10
|
||||
bit clip (note that the U and V planes will contain junk since direct copy
|
||||
isn't possible)::
|
||||
|
||||
std.Expr(clips=[clipa10bit, clipb16bit, clipa8bit],
|
||||
expr=["x 64 * y + z 256 * + 3 /", ""], format=vs.YUV420P16)
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
FlipVertical/FlipHorizontal
|
||||
===========================
|
||||
|
||||
.. function:: FlipVertical(vnode clip)
|
||||
FlipHorizontal(vnode clip)
|
||||
:module: std
|
||||
|
||||
Flips the *clip* in the vertical or horizontal direction.
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
FrameEval
|
||||
=========
|
||||
|
||||
.. function:: FrameEval(vnode clip, func eval[, vnode[] prop_src, vnode[] clip_src])
|
||||
:module: std
|
||||
|
||||
Allows an arbitrary function to be evaluated every frame. The function gets
|
||||
the frame number, *n*, as input and should return a clip the output frame can
|
||||
be requested from.
|
||||
|
||||
The *clip* argument is only used to get the output format from since there is
|
||||
no reliable automatic way to deduce it.
|
||||
|
||||
When using the argument *prop_src* the function will also have an argument,
|
||||
*f*, containing the current frames. This is mainly so frame properties can be
|
||||
accessed and used to make decisions. Note that *f* will only be a list if
|
||||
more than one *prop_src* clip is provided.
|
||||
|
||||
The *clip_src* argument only exists as a way to hint which clips are referenced in the
|
||||
*eval* function which can improve caching and graph generation. Its use is encouraged
|
||||
but not required.
|
||||
|
||||
This function can be used to accomplish the same things as Animate,
|
||||
ScriptClip and all the other conditional filters in Avisynth. Note that to
|
||||
modify per frame properties you should use *ModifyFrame*.
|
||||
|
||||
How to animate a BlankClip to fade from white to black. This is the simplest
|
||||
use case without using the *prop_src* argument::
|
||||
|
||||
import vapoursynth as vs
|
||||
import functools
|
||||
|
||||
base_clip = vs.core.std.BlankClip(format=vs.YUV420P8, length=1000, color=[255, 128, 128])
|
||||
|
||||
def animator(n, clip):
|
||||
if n > 255:
|
||||
return clip
|
||||
else:
|
||||
return vs.core.std.BlankClip(format=vs.YUV420P8, length=1000, color=[n, 128, 128])
|
||||
|
||||
animated_clip = vs.core.std.FrameEval(base_clip, functools.partial(animator, clip=base_clip))
|
||||
animated_clip.set_output()
|
||||
|
||||
How to perform a simple per frame auto white balance. It shows how to access
|
||||
calculated frame properties and use them for conditional filtering::
|
||||
|
||||
import vapoursynth as vs
|
||||
import functools
|
||||
import math
|
||||
|
||||
def GrayWorld1Adjust(n, f, clip, core):
|
||||
small_number = 0.000000001
|
||||
red = f[0].props['PlaneStatsAverage']
|
||||
green = f[1].props['PlaneStatsAverage']
|
||||
blue = f[2].props['PlaneStatsAverage']
|
||||
max_rgb = max(red, green, blue)
|
||||
red_corr = max_rgb/max(red, small_number)
|
||||
green_corr = max_rgb/max(green, small_number)
|
||||
blue_corr = max_rgb/max(blue, small_number)
|
||||
norm = max(blue, math.sqrt(red_corr*red_corr + green_corr*green_corr + blue_corr*blue_corr) / math.sqrt(3), small_number)
|
||||
r_gain = red_corr/norm
|
||||
g_gain = green_corr/norm
|
||||
b_gain = blue_corr/norm
|
||||
return core.std.Expr(clip, expr=['x ' + repr(r_gain) + ' *', 'x ' + repr(g_gain) + ' *', 'x ' + repr(b_gain) + ' *'])
|
||||
|
||||
def GrayWorld1(clip, matrix_s=None):
|
||||
rgb_clip = vs.core.resize.Bilinear(clip, format=vs.RGB24)
|
||||
r_avg = vs.core.std.PlaneStats(rgb_clip, plane=0)
|
||||
g_avg = vs.core.std.PlaneStats(rgb_clip, plane=1)
|
||||
b_avg = vs.core.std.PlaneStats(rgb_clip, plane=2)
|
||||
adjusted_clip = vs.core.std.FrameEval(rgb_clip, functools.partial(GrayWorld1Adjust, clip=rgb_clip, core=vs.core), prop_src=[r_avg, g_avg, b_avg])
|
||||
return vs.core.resize.Bilinear(adjusted_clip, format=clip.format.id, matrix_s=matrix_s)
|
||||
|
||||
vs.core.std.LoadPlugin(path='BestSource.dll')
|
||||
main = vs.core.bs.VideoSource(source='...')
|
||||
main = GrayWorld1(main)
|
||||
main.set_output()
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
FreezeFrames
|
||||
============
|
||||
|
||||
.. function:: FreezeFrames(vnode clip, int[] first, int[] last, int[] replacement)
|
||||
:module: std
|
||||
|
||||
FreezeFrames replaces all the frames in the [*first*,\ *last*] range
|
||||
(inclusive) with *replacement*.
|
||||
|
||||
A single call to FreezeFrames can freeze any number of ranges::
|
||||
|
||||
core.std.FreezeFrames(input, first=[0, 100, 231], last=[15, 112, 300], replacement=[8, 50, 2])
|
||||
|
||||
This replaces [0,15] with 8, [100,112] with 50, and [231,300] with 2 (the
|
||||
original frame number 2, not frame number 2 after it was replaced with
|
||||
number 8 by the first range).
|
||||
|
||||
The frame ranges must not overlap.
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
Interleave
|
||||
==========
|
||||
|
||||
.. function:: Interleave(vnode[] clips[, bint extend=0, bint mismatch=0, bint modify_duration=True])
|
||||
:module: std
|
||||
|
||||
Returns a clip with the frames from all *clips* interleaved. For example,
|
||||
Interleave(clips=[A, B]) will return A.Frame 0, B.Frame 0, A.Frame 1,
|
||||
B.Frame...
|
||||
|
||||
The *extend* argument controls whether or not all input clips will be treated
|
||||
as if they have the same length as the longest clip.
|
||||
|
||||
Interleaving clips with different formats or dimensions is considered an
|
||||
error unless *mismatch* is true.
|
||||
|
||||
If *modify_duration* is set then the output clip's frame rate is the first
|
||||
input clip's frame rate multiplied by the number of input clips. The frame durations are divided
|
||||
by the number of input clips. Otherwise the first input clip's frame rate is used.
|
||||
|
|
@ -0,0 +1,21 @@
|
|||
Invert/InvertMask
|
||||
=================
|
||||
|
||||
.. function:: Invert(vnode clip[, int[] planes=[0, 1, 2]])
|
||||
InvertMask(vnode clip[, int[] planes=[0, 1, 2]])
|
||||
:module: std
|
||||
|
||||
Inverts the pixel values. Specifically, it subtracts the value of the
|
||||
input pixel from the format's maximum allowed value. The *InvertMask*
|
||||
version is intended for use on mask clips where all planes have the
|
||||
same maximum value regardless of the colorspace.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
Levels
|
||||
======
|
||||
|
||||
.. function:: Levels(vnode clip[, float min_in, float max_in, float gamma=1.0, float min_out, float max_out, int[] planes=[0, 1, 2]])
|
||||
:module: std
|
||||
|
||||
Adjusts brightness, contrast, and gamma.
|
||||
|
||||
The range [*min_in*, *max_in*] is remapped into [*min_out*, *max_out*]. Note that the
|
||||
range behavior is unintuitive for YUV float formats since the assumed range will be
|
||||
0-1 even for the UV-planes.
|
||||
|
||||
For example, to convert from limited range YUV to full range (8 bit)::
|
||||
|
||||
clip = std.Levels(clip, min_in=16, max_in=235, min_out=0, max_out=255, planes=0)
|
||||
clip = std.Levels(clip, min_in=16, max_in=240, min_out=0, max_out=255, planes=[1,2])
|
||||
|
||||
The default value of *max_in* and *max_out* is the format's minimum and maximum
|
||||
allowed values respectively. Note that all input is clamped to the input range
|
||||
to prevent out of range output.
|
||||
|
||||
.. warning::
|
||||
The default ranges are 0-1 for floating point formats. This may have an undesired
|
||||
effect on YUV formats.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*gamma*
|
||||
Controls the degree of non-linearity of the conversion. Values
|
||||
greater than 1.0 brighten the output, while values less than 1.0
|
||||
darken it.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
Limiter
|
||||
=======
|
||||
|
||||
.. function:: Limiter(vnode clip[, float[] min, float[] max, int[] planes=[0, 1, 2]])
|
||||
:module: std
|
||||
|
||||
Limits the pixel values to the range [*min*, *max*].
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*min*
|
||||
Lower bound. Defaults to the lowest allowed value for the input. Can be specified for each plane individually.
|
||||
|
||||
*max*
|
||||
Upper bound. Defaults to the highest allowed value for the input. Can be specified for each plane individually.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
Loop
|
||||
====
|
||||
|
||||
.. function:: Loop(vnode clip[, int times=0])
|
||||
:module: std
|
||||
|
||||
Returns a clip with the frames or samples repeated over and over again. If *times* is
|
||||
less than 1 the clip will be repeated until the maximum clip length is
|
||||
reached, otherwise it will be repeated *times* times.
|
||||
|
||||
In Python, std.Loop can also be invoked :ref:`using the multiplication operator <pythonreference>`.
|
||||
|
|
@ -0,0 +1,39 @@
|
|||
Lut
|
||||
===
|
||||
|
||||
.. function:: Lut(vnode clip[, int[] planes, int[] lut, float[] lutf, func function, int bits, bint floatout])
|
||||
:module: std
|
||||
|
||||
Applies a look-up table to the given clip. The lut can be specified as either an array
|
||||
of 2^bits_per_sample values or given as a *function* having an argument named
|
||||
*x* to be evaluated. Either *lut*, *lutf* or *function* must be used. The lut will be
|
||||
applied to the planes listed in *planes* and the other planes will simply be
|
||||
passed through unchanged. By default all *planes* are processed.
|
||||
|
||||
If *floatout* is set then the output will be floating point instead, and either
|
||||
*lutf* needs to be set or *function* always needs to return floating point
|
||||
values.
|
||||
|
||||
How to limit YUV range (by passing an array):
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
luty = []
|
||||
for x in range(2**clip.format.bits_per_sample):
|
||||
luty.append(max(min(x, 235), 16))
|
||||
lutuv = []
|
||||
for x in range(2**clip.format.bits_per_sample):
|
||||
lutuv.append(max(min(x, 240), 16))
|
||||
ret = Lut(clip=clip, planes=0, lut=luty)
|
||||
limited_clip = Lut(clip=ret, planes=[1, 2], lut=lutuv)
|
||||
|
||||
How to limit YUV range (using a function):
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
def limity(x):
|
||||
return max(min(x, 235), 16)
|
||||
def limituv(x):
|
||||
return max(min(x, 240), 16)
|
||||
ret = Lut(clip=clip, planes=0, function=limity)
|
||||
limited_clip = Lut(clip=ret, planes=[1, 2], function=limituv)
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
Lut2
|
||||
====
|
||||
|
||||
.. function:: Lut2(vnode clipa, vnode clipb[, int[] planes, int[] lut, float[] lutf, func function, int bits, bint floatout])
|
||||
:module: std
|
||||
|
||||
Applies a look-up table that takes into account the pixel values of two clips. The
|
||||
*lut* needs to contain 2^(clip1.bits_per_sample + clip2.bits_per_sample)
|
||||
entries and will be applied to the planes listed in *planes*. Alternatively
|
||||
a *function* taking *x* and *y* as arguments can be used to make the lut.
|
||||
The other planes will be passed through unchanged. By default all *planes*
|
||||
are processed.
|
||||
|
||||
Lut2 also takes an optional bit depth parameter, *bits*, which defaults to
|
||||
the bit depth of the first input clip, and specifies the bit depth of the
|
||||
output clip. The user is responsible for understanding the effects of bit
|
||||
depth conversion, specifically from higher bit depths to lower bit depths,
|
||||
as no scaling or clamping is applied.
|
||||
|
||||
If *floatout* is set then the output will be floating point instead, and either
|
||||
*lutf* needs to be set or *function* always needs to return floating point
|
||||
values.
|
||||
|
||||
How to average 2 clips:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
lut = []
|
||||
for y in range(2 ** clipy.format.bits_per_sample):
|
||||
for x in range(2 ** clipx.format.bits_per_sample):
|
||||
lut.append((x + y)//2)
|
||||
Lut2(clipa=clipa, clipb=clipb, lut=lut)
|
||||
|
||||
How to average 2 clips with a 10-bit output:
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
def f(x, y):
|
||||
return (x*4 + y)//2
|
||||
Lut2(clipa=clipa8bit, clipb=clipb10bit, function=f, bits=10)
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
MakeDiff
|
||||
========
|
||||
|
||||
.. function:: MakeDiff(vnode clipa, vnode clipb[, int[] planes])
|
||||
:module: std
|
||||
|
||||
Calculates the difference between *clipa* and *clipb* and clamps the result.
|
||||
By default all *planes* are processed. This function is usually used together with *MergeDiff*, which can be used to add back the difference.
|
||||
|
||||
Unsharp masking of luma::
|
||||
|
||||
blur_clip = core.std.Convolution(clip, matrix=[1, 2, 1, 2, 4, 2, 1, 2, 1], planes=[0])
|
||||
diff_clip = core.std.MakeDiff(clip, blur_clip, planes=[0])
|
||||
sharpened_clip = core.std.MergeDiff(clip, diff_clip, planes=[0])
|
||||
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
MakeFullDiff
|
||||
============
|
||||
|
||||
.. function:: MakeFullDiff(vnode clipa, vnode clipb)
|
||||
:module: std
|
||||
|
||||
Calculates the difference between *clipa* and *clipb* and outputs a clip with a one higher bitdepth to avoid the clamping or wraparound issues
|
||||
that would otherwise happen with filters like *MakeDiff* when forming a difference.
|
||||
This function is usually used together with *MergeFullDiff*, which can be used to add back the difference.
|
||||
|
||||
Unsharp mask::
|
||||
|
||||
blur_clip = core.std.Convolution(clip, matrix=[1, 2, 1, 2, 4, 2, 1, 2, 1])
|
||||
diff_clip = core.std.MakeFullDiff(clip, blur_clip)
|
||||
sharpened_clip = core.std.MergeFullDiff(clip, diff_clip)
|
||||
|
||||
|
|
@ -0,0 +1,35 @@
|
|||
MaskedMerge
|
||||
===========
|
||||
|
||||
.. function:: MaskedMerge(vnode clipa, vnode clipb, vnode mask[, int[] planes, bint first_plane=0, bint premultiplied=0])
|
||||
:module: std
|
||||
|
||||
MaskedMerge merges *clipa* with *clipb* using the per pixel weights in the *mask*,
|
||||
where 0 means that *clipa* is returned unchanged.
|
||||
The *mask* clip is assumed to be full range for all planes and in the
|
||||
0-1 interval for float formats regardless of the colorspace.
|
||||
If *mask* is a grayscale clip or if *first_plane* is true, the mask's first
|
||||
plane will be used as the mask for merging all planes. The mask will be
|
||||
bilinearly resized if necessary.
|
||||
|
||||
If *premultiplied* is set the blending is performed as if *clipb* has been pre-multiplied
|
||||
with alpha. In pre-multiplied mode it is an error to try to merge two frames with
|
||||
mismatched full and limited range since it will most likely cause horrible unintended
|
||||
color shifts. In the other mode it's just a very, very bad idea.
|
||||
|
||||
By default all planes will be
|
||||
processed, but it is also possible to specify a list of the *planes* to merge
|
||||
in the output. The unprocessed planes will be copied from the first clip.
|
||||
|
||||
*clipa* and *clipb* must have the same dimensions and format, and the *mask* must be the
|
||||
same format as the clips or the grayscale equivalent.
|
||||
|
||||
How to apply a mask to the first plane::
|
||||
|
||||
MaskedMerge(clipa=A, clipb=B, mask=Mask, planes=0)
|
||||
|
||||
How to apply the first plane of a mask to the second and third plane::
|
||||
|
||||
MaskedMerge(clipa=A, clipb=B, mask=Mask, planes=[1, 2], first_plane=True)
|
||||
|
||||
The frame properties are copied from *clipa*.
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
Median
|
||||
======
|
||||
|
||||
.. function:: Median(vnode clip[, int[] planes=[0, 1, 2]])
|
||||
:module: std
|
||||
|
||||
Replaces each pixel with the median of the nine pixels in its 3x3
|
||||
neighbourhood. In other words, the nine pixels are sorted from lowest
|
||||
to highest, and the middle value is picked.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
|
@ -0,0 +1,29 @@
|
|||
Merge
|
||||
=====
|
||||
|
||||
.. function:: Merge(vnode clipa, vnode clipb[, float[] weight = 0.5])
|
||||
:module: std
|
||||
|
||||
Merges *clipa* and *clipb* using the specified *weight* for each plane. The default
|
||||
is to use a 0.5 *weight* for all planes. A zero *weight* means that *clipa*
|
||||
is returned unchanged and 1 means that *clipb* is returned unchanged. If a
|
||||
single *weight* is specified, it will be used for all planes. If two weights
|
||||
are given then the second value will be used for the third plane as well.
|
||||
|
||||
Values outside the 0-1 range are considered to be an error. Specifying more
|
||||
weights than planes in the clips is also an error. The clips must have the
|
||||
same dimensions and format.
|
||||
|
||||
How to merge luma::
|
||||
|
||||
Merge(clipa=A, clipb=B, weight=[1, 0])
|
||||
|
||||
How to merge chroma::
|
||||
|
||||
Merge(clipa=A, clipb=B, weight=[0, 1])
|
||||
|
||||
The average of two clips::
|
||||
|
||||
Merge(clipa=A, clipb=B)
|
||||
|
||||
The frame properties are copied from *clipa*.
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
MergeDiff
|
||||
=========
|
||||
|
||||
.. function:: MergeDiff(vnode clipa, vnode clipb[, int[] planes])
|
||||
:module: std
|
||||
|
||||
Merges back the difference in *clipb* to *clipa* and clamps the result.
|
||||
By default all *planes* are processed. This function is usually used together with *MakeDiff*, which is normally used to calculate the difference.
|
||||
|
||||
Unsharp masking of luma::
|
||||
|
||||
blur_clip = core.std.Convolution(clip, matrix=[1, 2, 1, 2, 4, 2, 1, 2, 1], planes=[0])
|
||||
diff_clip = core.std.MakeDiff(clip, blur_clip, planes=[0])
|
||||
sharpened_clip = core.std.MergeDiff(clip, diff_clip, planes=[0])
|
||||
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
MergeFullDiff
|
||||
=============
|
||||
|
||||
.. function:: MergeFullDiff(vnode clipa, vnode clipb)
|
||||
:module: std
|
||||
|
||||
Merges back the difference in *clipb* to *clipa*. Note that the bitdepth of *clipb* has to be one higher than that of *clip*.
|
||||
This function is usually used together with *MakeFullDiff*, which is normally used to calculate the difference.
|
||||
|
||||
Unsharp mask::
|
||||
|
||||
blur_clip = core.std.Convolution(clip, matrix=[1, 2, 1, 2, 4, 2, 1, 2, 1])
|
||||
diff_clip = core.std.MakeFullDiff(clip, blur_clip)
|
||||
sharpened_clip = core.std.MergeFullDiff(clip, diff_clip)
|
||||
|
||||
|
|
@ -0,0 +1,69 @@
|
|||
Minimum/Maximum
|
||||
===============
|
||||
|
||||
.. function:: Minimum(vnode clip[, int[] planes=[0, 1, 2], float threshold, bint[] coordinates=[1, 1, 1, 1, 1, 1, 1, 1]])
|
||||
:module: std
|
||||
|
||||
Replaces each pixel with the smallest value in its 3x3 neighbourhood.
|
||||
This operation is also known as erosion.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
||||
*threshold*
|
||||
Allows to limit how much pixels are changed. Output pixels will not
|
||||
become less than ``input - threshold``. The default is no limit.
|
||||
|
||||
*coordinates*
|
||||
Specifies which pixels from the 3x3 neighbourhood are considered.
|
||||
If an element of this array is 0, the corresponding pixel is not
|
||||
considered when finding the minimum value. This must contain exactly
|
||||
8 numbers.
|
||||
|
||||
Here is how each number corresponds to a pixel in the 3x3
|
||||
neighbourhood::
|
||||
|
||||
1 2 3
|
||||
4 5
|
||||
6 7 8
|
||||
|
||||
|
||||
.. function:: Maximum(vnode clip[, int[] planes=[0, 1, 2], float threshold, bint[] coordinates=[1, 1, 1, 1, 1, 1, 1, 1]])
|
||||
:module: std
|
||||
|
||||
Replaces each pixel with the largest value in its 3x3 neighbourhood.
|
||||
This operation is also known as dilation.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
||||
*threshold*
|
||||
Allows to limit how much pixels are changed. Output pixels will not
|
||||
become less than ``input - threshold``. The default is no limit.
|
||||
|
||||
*coordinates*
|
||||
Specifies which pixels from the 3x3 neighbourhood are considered.
|
||||
If an element of this array is 0, the corresponding pixel is not
|
||||
considered when finding the maximum value. This must contain exactly
|
||||
8 numbers.
|
||||
|
||||
Here is how each number corresponds to a pixel in the 3x3
|
||||
neighbourhood::
|
||||
|
||||
1 2 3
|
||||
4 5
|
||||
6 7 8
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
ModifyFrame
|
||||
===========
|
||||
|
||||
.. function:: ModifyFrame(vnode clip, clip[] clips, func selector)
|
||||
:module: std
|
||||
|
||||
The *selector* function is called for every single frame and can modify the
|
||||
properties of one of the frames gotten from *clips*. The additional *clips*'
|
||||
properties should only be read and not modified because only one modified
|
||||
frame can be returned.
|
||||
|
||||
You must first copy the input frame to make it modifiable. Any frame may be
|
||||
returned as long as it has the same format as the *clip*.
|
||||
Failure to do so will produce an error. If for conditional reasons you do not
|
||||
need to modify the current frame's properties, you can simply pass it through.
|
||||
The selector function is passed *n*, the current frame number, and *f*, which
|
||||
is a frame or a list of frames if there is more than one clip specified.
|
||||
|
||||
If you do not need to modify frame properties but only read them, you should
|
||||
probably be using *FrameEval* instead.
|
||||
|
||||
How to set the property FrameNumber to the current frame number::
|
||||
|
||||
def set_frame_number(n, f):
|
||||
fout = f.copy()
|
||||
fout.props['FrameNumber'] = n
|
||||
return fout
|
||||
...
|
||||
ModifyFrame(clip=clip, clips=clip, selector=set_frame_number)
|
||||
|
||||
How to remove a property::
|
||||
|
||||
def remove_property(n, f):
|
||||
fout = f.copy()
|
||||
del fout.props['FrameNumber']
|
||||
return fout
|
||||
...
|
||||
ModifyFrame(clip=clip, clips=clip, selector=remove_property)
|
||||
|
||||
An example of how to copy certain properties from one clip to another
|
||||
(clip1 and clip2 have the same format)::
|
||||
|
||||
def transfer_property(n, f):
|
||||
fout = f[1].copy()
|
||||
fout.props['FrameNumber'] = f[0].props['FrameNumber']
|
||||
fout.props['_Combed'] = f[0].props['_Combed']
|
||||
return fout
|
||||
...
|
||||
ModifyFrame(clip=clip1, clips=[clip1, clip2], selector=transfer_property)
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
PEMVerifier
|
||||
===========
|
||||
|
||||
.. function:: PEMVerifier(vnode clip[, float[] upper, float[] lower])
|
||||
:module: std
|
||||
|
||||
The *PEMVerifier* is used to check for out-of-bounds pixel values during filter
|
||||
development. It is a public function so badly coded filters won't go
|
||||
unnoticed.
|
||||
|
||||
If no values are set, then *upper* and *lower* default to the max and min values
|
||||
allowed in the current format. If an out of bounds value is
|
||||
encountered a frame error is set and the coordinates of the first bad pixel
|
||||
are included in the error message.
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
PlaneStats
|
||||
==========
|
||||
|
||||
.. function:: PlaneStats(vnode clipa[, vnode clipb, int plane=0, string prop='PlaneStats'])
|
||||
:module: std
|
||||
|
||||
This function calculates the min, max and average normalized value of all
|
||||
the pixels in the specified *plane* and stores the values in the frame properties
|
||||
named *prop*\ Min, *prop*\ Max and *prop*\ Average.
|
||||
|
||||
If *clipb* is supplied, the absolute normalized difference between the two clips
|
||||
will be stored in *prop*\ Diff as well.
|
||||
|
||||
The normalization means that the average and the diff will always be floats
|
||||
between 0 and 1, no matter what the input format is.
|
||||
|
|
@ -0,0 +1,14 @@
|
|||
PreMultiply
|
||||
===========
|
||||
|
||||
.. function:: PreMultiply(vnode clip, vnode alpha)
|
||||
:module: std
|
||||
|
||||
PreMultiply simply multiplies *clip* and *alpha* in order to make it more suitable for
|
||||
later operations. This will yield much better results when resizing and a clip with an
|
||||
alpha channel and :doc:`MaskedMerge <maskedmerge>` can use it as input. The *alpha* clip
|
||||
must be the grayscale format equivalent of *clip*.
|
||||
|
||||
Note that limited range pre-multiplied contents excludes the offset. For example with
|
||||
8 bit input 60 luma and 128 alpha would be calculated as ((60 - 16) * 128)/255 + 16
|
||||
and not (60 * 128)/255.
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
Prewitt/Sobel
|
||||
===================
|
||||
|
||||
.. function:: Prewitt(vnode clip[, int[] planes=[0, 1, 2], float scale=1])
|
||||
:module: std
|
||||
|
||||
Creates an edge mask using the Prewitt operator.
|
||||
|
||||
.. function:: Sobel(vnode clip[, int[] planes=[0, 1, 2], float scale=1])
|
||||
:module: std
|
||||
|
||||
Creates an edge mask using the Sobel operator.
|
||||
|
||||
*clip*
|
||||
Clip to process. It must have integer sample type and bit depth
|
||||
between 8 and 16, or float sample type and bit depth of 32. If
|
||||
there are any frames with other formats, an error will be
|
||||
returned.
|
||||
|
||||
*planes*
|
||||
Specifies which planes will be processed. Any unprocessed planes
|
||||
will be simply copied.
|
||||
|
||||
*scale*
|
||||
Multiply all pixels by scale before outputting. This can be used to
|
||||
increase or decrease the intensity of edges in the output.
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
PropToClip
|
||||
==========
|
||||
|
||||
.. function:: PropToClip(vnode clip[, string prop='_Alpha'])
|
||||
:module: std
|
||||
|
||||
Extracts a clip from the frames attached to the frame property *prop* in
|
||||
*clip*.
|
||||
This function is mainly used to extract a mask/alpha clip that was stored in
|
||||
another one.
|
||||
|
||||
It is the inverse of ClipToProp().
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
RemoveFrameProps
|
||||
================
|
||||
|
||||
.. function:: RemoveFrameProps(vnode clip[, string props[]])
|
||||
:module: std
|
||||
|
||||
Returns *clip* but with all the frame properties named in
|
||||
*props* removed. If *props* is unset them all frame properties
|
||||
are removed.
|
||||
|
|
@ -0,0 +1,286 @@
|
|||
Resize
|
||||
======
|
||||
|
||||
.. function:: Bilinear(vnode clip[, int width, int height, int format, enum matrix, enum transfer, enum primaries, enum range, enum chromaloc, enum matrix_in, enum transfer_in, enum primaries_in, enum range_in, enum chromaloc_in, float filter_param_a, float filter_param_b, string resample_filter_uv, float filter_param_a_uv, float filter_param_b_uv, string dither_type="none", string cpu_type, float src_left, float src_top, float src_width, float src_height, float nominal_luminance])
|
||||
Bicubic(vnode clip[, ...])
|
||||
Point(vnode clip[, ...])
|
||||
Lanczos(vnode clip[, ...])
|
||||
Spline16(vnode clip[, ...])
|
||||
Spline36(vnode clip[, ...])
|
||||
Spline64(vnode clip[, ...])
|
||||
Bob(vnode clip, string filter="bicubic", bint tff[, ...])
|
||||
:module: resize
|
||||
|
||||
In VapourSynth the resizers have several functions. In addition to scaling,
|
||||
they also do colorspace conversions and conversions to and from the compat
|
||||
formats. Resize converts a clip of known or unknown format to another clip
|
||||
of known or unknown format, changing only the parameters specified by the
|
||||
user. The resize filters can handle varying size and format input clips
|
||||
and turn them into constant format clips.
|
||||
|
||||
If you do not know which resizer to choose, then try Bicubic. It usually
|
||||
makes a good neutral default.
|
||||
|
||||
*Bob* can be used as a rudimentary deinterlacer.
|
||||
|
||||
Arguments denoted as type *enum* may be specified by numerical index (see
|
||||
ITU-T H.265 Annex E.3) or by name. Enums specified by name have their
|
||||
argument name suffixed with "_s". For example, a destination matrix of
|
||||
BT 709 can be specified either with ``matrix=1`` or with ``matrix_s="709"``.
|
||||
|
||||
Note that *matrix* is not an optional argument when converting to YUV.
|
||||
Also note that if no matrix is specified in an input YUV frame's properties
|
||||
then *matrix_in* also needs to be set.
|
||||
|
||||
The function will return an error if the subsampling restrictions aren't
|
||||
followed.
|
||||
|
||||
If you get an error like::
|
||||
|
||||
Resize error 3074: no path between colorspaces (2/2/2 => 1/1/1).
|
||||
May need to specify additional colorspace parameters.
|
||||
|
||||
It usually means the matrix/transfer/primaries are unknown and you have to
|
||||
specify the input colorspace parameters yourself. Note: 2 means "unspecified"
|
||||
according to the ITU-T recommendation.
|
||||
|
||||
Resizing is performed per-field for interlaced images, as indicated by the
|
||||
*_FieldBased* frame property. Source filters may sometimes mark progressive
|
||||
video as interlaced, which can result in sub-optimal resampling quality
|
||||
unless *_FieldBased* is cleared.
|
||||
|
||||
*clip*:
|
||||
|
||||
Accepts all kinds of input.
|
||||
|
||||
*width*, *height*:
|
||||
|
||||
Output image dimensions.
|
||||
|
||||
*filter*:
|
||||
|
||||
Scaling method for deinterlacing. See *resample_filter_uv* for accepted values.
|
||||
|
||||
*tff*:
|
||||
|
||||
Field order for deinterlacing. Used when the *_FieldBased* property is not set.
|
||||
|
||||
*format*:
|
||||
|
||||
Output format id.
|
||||
|
||||
*matrix*, *transfer*, *primaries*:
|
||||
|
||||
Output colorspace specification. If not provided, the corresponding attributes from
|
||||
the input clip will be selected, except for YCoCg and RGB color families, where the
|
||||
corresponding matrix is set by default.
|
||||
|
||||
*range*:
|
||||
|
||||
Output pixel range. For integer formats, this allows selection of the legal code
|
||||
values. Even when set, out of range values (BTB/WTW) may be generated. If the input
|
||||
format is of a different color family, the default range is studio/limited for YUV
|
||||
and full-range for RGB.
|
||||
|
||||
*chromaloc*:
|
||||
|
||||
Output chroma location. For subsampled formats, specifies the chroma location. If
|
||||
the input format is 4:4:4 or RGB and the output is subsampled, the default location
|
||||
is left-aligned, as per MPEG. Possible chroma locations (ITU-T H.265 Figure E.1):
|
||||
*left*, *center*, *top_left*, *top*, *bottom_left*, *bottom*
|
||||
|
||||
*matrix_in*, *transfer_in*, *primaries_in*, *range_in*, *chromaloc_in*:
|
||||
|
||||
Input colorspace/format specification. If the corresponding frame property is set
|
||||
to a value other than unspecified, the frame property is used instead of this parameter.
|
||||
Default values are set for certain color families. See the equivalent output arguments
|
||||
for more information.
|
||||
|
||||
*filter_param_a*, *filter_param_b*:
|
||||
|
||||
Parameters for the scaler used for RGB and Y-channel. For the bicubic filter,
|
||||
filter_param_a/b represent the "b" and "c" parameters. For the lanczos filter,
|
||||
filter_param_a represents the number of taps.
|
||||
|
||||
*resample_filter_uv*:
|
||||
|
||||
Scaling method for UV channels. It defaults to the same as for the Y-channel. The
|
||||
following values can be used with *resample_filter_uv*: *point*, *bilinear*, *bicubic*,
|
||||
*spline16*, *spline36*, *lanczos*.
|
||||
|
||||
*filter_param_a_uv*, *filter_param_b_uv*:
|
||||
|
||||
Parameters for the scaler used for UV channels.
|
||||
|
||||
*dither_type*:
|
||||
|
||||
Dithering method. Dithering is used only for conversions resulting in an integer
|
||||
format. The following dithering methods are available: *none*, *ordered*, *random*,
|
||||
*error_diffusion*.
|
||||
|
||||
*cpu_type*:
|
||||
|
||||
Only used for testing.
|
||||
|
||||
*src_left*, *src_top*, *src_width*, *src_height*:
|
||||
|
||||
Used to select the source region of the input to use. Can also be used to shift the image.
|
||||
Defaults to the whole image.
|
||||
|
||||
*nominal_luminance*:
|
||||
|
||||
Determines the physical brightness of the value 1.0. The unit is in cd/m^2.
|
||||
|
||||
To convert to YV12::
|
||||
|
||||
Bicubic(clip=clip, format=vs.YUV420P8, matrix_s="709")
|
||||
|
||||
To resize and convert YUV with color information frame properties to planar RGB::
|
||||
|
||||
Bicubic(clip=clip, width=1920, height=1080, format=vs.RGB24)
|
||||
|
||||
To resize and convert YUV without color information frame properties to planar RGB::
|
||||
|
||||
Bicubic(clip=clip, width=1920, height=1080, format=vs.RGB24, matrix_in_s="709")
|
||||
|
||||
The following tables list values of selected colorspace enumerations and
|
||||
their abbreviated names. (Numerical value in parentheses.) For all possible values,
|
||||
see ITU-T H.265.
|
||||
|
||||
Matrix coefficients (ITU-T H.265 Table E.5)::
|
||||
|
||||
rgb (0) Identity
|
||||
The identity matrix.
|
||||
Typically used for GBR (often referred to as RGB);
|
||||
however, may also be used for YZX (often referred to as
|
||||
XYZ);
|
||||
709 (1) KR = 0.2126; KB = 0.0722
|
||||
ITU-R Rec. BT.709-5
|
||||
unspec (2) Unspecified
|
||||
Image characteristics are unknown or are determined by the
|
||||
application.
|
||||
fcc (4)
|
||||
470bg (5) KR = 0.299; KB = 0.114
|
||||
ITU-R Rec. BT.470-6 System B, G (historical)
|
||||
(functionally the same as the value 6 (170m))
|
||||
170m (6) KR = 0.299; KB = 0.114
|
||||
SMPTE 170M (2004)
|
||||
(functionally the same as the value 5 (470bg))
|
||||
240m (7) SMPTE 240M
|
||||
ycgco (8) YCgCo
|
||||
2020ncl (9) KR = 0.2627; KB = 0.0593
|
||||
Rec. ITU-R BT.2020 non-constant luminance system
|
||||
2020cl (10) KR = 0.2627; KB = 0.0593
|
||||
Rec. ITU-R BT.2020 constant luminance system
|
||||
chromancl (12) Chromaticity derived non-constant luminance system
|
||||
chromacl (13) Chromaticity derived constant luminance system
|
||||
ictcp (14) ICtCp
|
||||
|
||||
Transfer characteristics (ITU-T H.265 Table E.4)::
|
||||
|
||||
709 (1) V = a * Lc0.45 - ( a - 1 ) for 1 >= Lc >= b
|
||||
V = 4.500 * Lc for b > Lc >= 0
|
||||
Rec. ITU-R BT.709-5
|
||||
(functionally the same as the values 6 (601),
|
||||
14 (2020_10) and 15 (2020_12))
|
||||
unspec (2) Unspecified
|
||||
Image characteristics are unknown or are determined by the
|
||||
application.
|
||||
470m (4) ITU-R Rec. BT.470-6 System M
|
||||
470bg (5) ITU-R Rec. BT.470-6 System B, G (historical)
|
||||
601 (6) V = a * Lc0.45 - ( a - 1 ) for 1 >= Lc >= b
|
||||
V = 4.500 * Lc for b > Lc >= 0
|
||||
Rec. ITU-R BT.601-6 525 or 625
|
||||
(functionally the same as the values 1 (709),
|
||||
14 (2020_10) and 15 (2020_12))
|
||||
240m (7) SMPTE 240M
|
||||
linear (8) V = Lc for all values of Lc
|
||||
Linear transfer characteristics
|
||||
log100 (9) Log 1:100 contrast
|
||||
log316 (10) Log 1:316 contrast
|
||||
xvycc (11) IEC 61966-2-4
|
||||
srgb (13) IEC 61966-2-1
|
||||
2020_10 (14) V = a * Lc0.45 - ( a - 1 ) for 1 >= Lc >= b
|
||||
V = 4.500 * Lc for b > Lc >= 0
|
||||
Rec. ITU-R BT.2020
|
||||
(functionally the same as the values 1 (709),
|
||||
6 (601) and 15 (2020_12))
|
||||
2020_12 (15) V = a * Lc0.45 - ( a - 1 ) for 1 >= Lc >= b
|
||||
V = 4.500 * Lc for b > Lc >= 0
|
||||
Rec. ITU-R BT.2020
|
||||
(functionally the same as the values 1 (709),
|
||||
6 (601) and 14 (2020_10))
|
||||
st2084 (16) SMPTE ST 2084
|
||||
std-b67 (18) ARIB std-b67
|
||||
|
||||
Color primaries (ITU-T H.265 Table E.3)::
|
||||
|
||||
709 (1) primary x y
|
||||
green 0.300 0.600
|
||||
blue 0.150 0.060
|
||||
red 0.640 0.330
|
||||
white D65 0.3127 0.3290
|
||||
Rec. ITU-R BT.709-5
|
||||
unspec (2) Unspecified
|
||||
Image characteristics are unknown or are determined by the
|
||||
application.
|
||||
470m (4) ITU-R Rec. BT.470-6 System M
|
||||
470bg (5) ITU-R Rec. BT.470-6 System B, G (historical)
|
||||
170m (6) primary x y
|
||||
green 0.310 0.595
|
||||
blue 0.155 0.070
|
||||
red 0.630 0.340
|
||||
white D65 0.3127 0.3290
|
||||
SMPTE 170M (2004)
|
||||
(functionally the same as the value 7 (240m))
|
||||
240m (7) primary x y
|
||||
green 0.310 0.595
|
||||
blue 0.155 0.070
|
||||
red 0.630 0.340
|
||||
white D65 0.3127 0.3290
|
||||
SMPTE 240M (1999)
|
||||
(functionally the same as the value 6 (170m))
|
||||
film (8)
|
||||
2020 (9) primary x y
|
||||
green 0.170 0.797
|
||||
blue 0.131 0.046
|
||||
red 0.708 0.292
|
||||
white D65 0.3127 0.3290
|
||||
Rec. ITU-R BT.2020
|
||||
st428 (10) Commonly known as xyz
|
||||
xyz (10) Alias for st428
|
||||
st431-2 (11) DCI-P3 with traditional white point
|
||||
st432-1 (12) DCI-P3
|
||||
jedec-p22 (22) E.B.U. STANDARD FOR CHROMATICITY TOLERANCES FOR STUDIO MONITORS (3213-E)
|
||||
Also known as JEDEC P22
|
||||
|
||||
Pixel range (ITU-T H.265 Eq E-4 to E-15)::
|
||||
|
||||
limited (0) Studio (TV) legal range, 16-235 in 8 bits.
|
||||
Y = Clip1Y( Round( ( 1 << ( BitDepthY - 8 ) ) *
|
||||
( 219 * E'Y + 16 ) ) )
|
||||
Cb = Clip1C( Round( ( 1 << ( BitDepthC - 8 ) ) *
|
||||
( 224 * E'PB + 128 ) ) )
|
||||
Cr = Clip1C( Round( ( 1 << ( BitDepthC - 8 ) ) *
|
||||
( 224 * E'PR + 128 ) ) )
|
||||
|
||||
R = Clip1Y( ( 1 << ( BitDepthY - 8 ) ) *
|
||||
( 219 * E'R + 16 ) )
|
||||
G = Clip1Y( ( 1 << ( BitDepthY - 8 ) ) *
|
||||
( 219 * E'G + 16 ) )
|
||||
B = Clip1Y( ( 1 << ( BitDepthY - 8 ) ) *
|
||||
( 219 * E'B + 16 ) )
|
||||
full (1) Full (PC) dynamic range, 0-255 in 8 bits.
|
||||
Y = Clip1Y( Round( ( ( 1 << BitDepthY ) - 1 ) * E'Y ) )
|
||||
Cb = Clip1C( Round( ( ( 1 << BitDepthC ) - 1 ) * E'PB +
|
||||
( 1 << ( BitDepthC - 1 ) ) ) )
|
||||
Cr = Clip1C( Round( ( ( 1 << BitDepthC ) - 1 ) * E'PR +
|
||||
( 1 << ( BitDepthC - 1 ) ) ) )
|
||||
|
||||
R = Clip1Y( ( ( 1 << BitDepthY ) - 1 ) * E'R )
|
||||
G = Clip1Y( ( ( 1 << BitDepthY ) - 1 ) * E'G )
|
||||
B = Clip1Y( ( ( 1 << BitDepthY ) - 1 ) * E'B )
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
Reverse
|
||||
=======
|
||||
|
||||
.. function:: Reverse(vnode clip)
|
||||
:module: std
|
||||
|
||||
Returns a clip with the frame or sample order reversed. For example, a clip with 3
|
||||
frames would have the frame order 2, 1, 0.
|
||||
|
||||
In Python, std.Reverse can also be invoked by :ref:`slicing a clip <pythonreference>`.
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
SelectEvery
|
||||
===========
|
||||
|
||||
.. function:: SelectEvery(vnode clip, int cycle, int[] offsets[, bint modify_duration=True])
|
||||
:module: std
|
||||
|
||||
Returns a clip with only some of the frames in every *cycle* selected. The
|
||||
*offsets* given must be between 0 and *cycle* - 1.
|
||||
|
||||
Below are some examples of useful operations.
|
||||
|
||||
Return even numbered frames, starting with 0::
|
||||
|
||||
SelectEvery(clip=clip, cycle=2, offsets=0)
|
||||
|
||||
Return odd numbered frames, starting with 1::
|
||||
|
||||
SelectEvery(clip=clip, cycle=2, offsets=1)
|
||||
|
||||
Fixed pattern 1 in 5 decimation, first frame in every cycle removed::
|
||||
|
||||
SelectEvery(clip=clip, cycle=5, offsets=[1, 2, 3, 4])
|
||||
|
||||
Duplicate every fourth frame::
|
||||
|
||||
SelectEvery(clip=clip, cycle=4, offsets=[0, 1, 2, 3, 3])
|
||||
|
||||
In Python, std.SelectEvery can also be invoked by :ref:`slicing a clip <pythonreference>`.
|
||||
|
||||
If *modify_duration* is set the clip's frame rate is multiplied by the number
|
||||
of offsets and divided by *cycle*. The frame durations are adjusted in the same manner.
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
SeparateFields
|
||||
==============
|
||||
|
||||
.. function:: SeparateFields(vnode clip[, bint tff, bint modify_duration=True])
|
||||
:module: std
|
||||
|
||||
Returns a clip with the fields separated and interleaved.
|
||||
|
||||
The *tff* argument only has an effect when the field order isn't set for a frame.
|
||||
Setting *tff* to true means top field first and false means bottom field
|
||||
first.
|
||||
|
||||
If *modify_duration* is set then the output clip's frame rate is double that of the input clip.
|
||||
The frame durations will also be halved.
|
||||
|
||||
The ``_FieldBased`` frame property is deleted. The ``_Field`` frame
|
||||
property is added.
|
||||
|
||||
If no field order is specified in ``_FieldBased`` or *tff* an error
|
||||
will be returned.
|
||||
|
|
@ -0,0 +1,25 @@
|
|||
SetFieldBased
|
||||
=============
|
||||
|
||||
.. function:: SetFieldBased(vnode clip, int value)
|
||||
:module: std
|
||||
|
||||
This is a convenience function. See *SetFrameProps* if you want to
|
||||
set other properties.
|
||||
|
||||
SetFieldBased sets ``_FieldBased`` to *value* and deletes
|
||||
the ``_Field`` frame property. The possible values are:
|
||||
|
||||
0 = Frame Based
|
||||
|
||||
1 = Bottom Field First
|
||||
|
||||
2 = Top Field First
|
||||
|
||||
For example, if you have source material that's progressive but has
|
||||
been encoded as interlaced you can set it to be treated as frame based
|
||||
(not interlaced) to improve resizing quality::
|
||||
|
||||
clip = core.bs.VideoSource("rule6.mkv")
|
||||
clip = core.std.SetFieldBased(clip, 0)
|
||||
clip = clip.resize.Bilinear(clip, width=320, height=240)
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
SetFrameProp
|
||||
============
|
||||
|
||||
.. function:: SetFrameProp(vnode clip, string prop[, int[] intval, float[] floatval, string[] data])
|
||||
:module: std
|
||||
|
||||
Adds a frame property to every frame in *clip*.
|
||||
|
||||
If there is already a property with the name *prop* in the frames,
|
||||
it will be overwritten.
|
||||
|
||||
The type of the property added depends on which of the *intval*,
|
||||
*floatval*, or *data* parameters is used.
|
||||
|
||||
The *data* parameter can only be used to add NULL-terminated strings,
|
||||
not arbitrary binary data.
|
||||
|
||||
For example, to set the field order to top field first::
|
||||
|
||||
clip = c.std.SetFrameProp(clip, prop="_FieldBased", intval=2)
|
||||
|
|
@ -0,0 +1,13 @@
|
|||
SetFrameProps
|
||||
=============
|
||||
|
||||
.. function:: SetFrameProps(vnode clip, ...)
|
||||
:module: std
|
||||
|
||||
Adds the specified values as a frame property of every frame
|
||||
in *clip*. If a frame property with the same key already exists
|
||||
it will be replaced.
|
||||
|
||||
For example, to set the field order to top field first::
|
||||
|
||||
clip = c.std.SetFrameProps(clip, _FieldBased=2)
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
SetVideoCache
|
||||
=============
|
||||
|
||||
.. function:: SetVideoCache(vnode clip[, int mode, int fixedsize, int maxsize, int historysize])
|
||||
:module: std
|
||||
|
||||
Every filter node has a cache associated with it that
|
||||
may or may not be enabled depending on the dependencies
|
||||
and request patterns. This function allows all automatic
|
||||
behavior to be overridden.
|
||||
|
||||
The *mode* option has 3 possible options where 0 always
|
||||
disables caching, 1 always enables the cache and -1
|
||||
uses the automatically calculated settings. Note that
|
||||
setting *mode* to -1 will reset the other values to
|
||||
their defaults as well.
|
||||
|
||||
The other options are fairly self-explanatory where
|
||||
setting *fixedsize* prevents the cache from over time
|
||||
altering its *maxsize* based on request history. The
|
||||
final *historysize* argument controls how many previous
|
||||
and no longer cached requests should be considered when
|
||||
adjusting *maxsize*, generally this value should not
|
||||
be touched at all.
|
||||
|
||||
Note that setting *mode* will reset all other options
|
||||
to their defaults.
|
||||
|
|
@ -0,0 +1,48 @@
|
|||
ShufflePlanes
|
||||
=============
|
||||
|
||||
.. function:: ShufflePlanes(vnode[] clips, int[] planes, int colorfamily)
|
||||
:module: std
|
||||
|
||||
ShufflePlanes can extract and combine planes from different clips in the most
|
||||
general way possible.
|
||||
This is both good and bad, as there are almost no error checks.
|
||||
|
||||
Most of the returned clip's properties are implicitly determined from the
|
||||
first clip given to *clips*.
|
||||
|
||||
The *clips* parameter takes between one and three clips for color families
|
||||
with three planes. In this case clips=[A] is equivalent to clips=[A, A, A]
|
||||
and clips=[A, B] is equivalent to clips=[A, B, B]. For the GRAY color
|
||||
family, which has one plane, it takes exactly one clip.
|
||||
|
||||
The argument *planes* controls which of the input clips' planes to use.
|
||||
Zero indexed. The first number refers to the first input clip, the second
|
||||
number to the second clip, the third number to the third clip.
|
||||
|
||||
The only thing that needs to be specified is *colorfamily*, which controls which
|
||||
color family (YUV, RGB, GRAY) the output clip will be.
|
||||
Properties such as subsampling are determined from the relative size of the
|
||||
given planes to combine.
|
||||
|
||||
ShufflePlanes accepts clips with variable format and dimensions only when
|
||||
extracting a single plane.
|
||||
|
||||
Below are some examples of useful operations.
|
||||
|
||||
Extract plane with index X. X=0 will mean luma in a YUV clip and R in an RGB
|
||||
clip. Likewise 1 will return the U and G channels, respectively::
|
||||
|
||||
ShufflePlanes(clips=clip, planes=X, colorfamily=vs.GRAY)
|
||||
|
||||
Swap U and V in a YUV clip::
|
||||
|
||||
ShufflePlanes(clips=clip, planes=[0, 2, 1], colorfamily=vs.YUV)
|
||||
|
||||
Merge 3 grayscale clips into a YUV clip::
|
||||
|
||||
ShufflePlanes(clips=[Yclip, Uclip, Vclip], planes=[0, 0, 0], colorfamily=vs.YUV)
|
||||
|
||||
Cast a YUV clip to RGB::
|
||||
|
||||
ShufflePlanes(clips=[YUVclip], planes=[0, 1, 2], colorfamily=vs.RGB)
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
Splice
|
||||
======
|
||||
|
||||
.. function:: Splice(vnode[] clips[, bint mismatch=0])
|
||||
:module: std
|
||||
|
||||
Returns a clip with all *clips* appended in the given order.
|
||||
|
||||
Splicing clips with different formats or dimensions is
|
||||
considered an error unless *mismatch* is true.
|
||||
|
||||
In Python, std.Splice can also be invoked :ref:`using the addition operator <pythonreference>`.
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
SplitPlanes
|
||||
===========
|
||||
|
||||
.. function:: SplitPlanes(vnode clip)
|
||||
:module: std
|
||||
|
||||
SplitPlanes returns each plane of the input as
|
||||
separate clips.
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
StackVertical/StackHorizontal
|
||||
=============================
|
||||
|
||||
.. function:: StackVertical(vnode[] clips)
|
||||
StackHorizontal(vnode[] clips)
|
||||
:module: std
|
||||
|
||||
Stacks all given *clips* together. The same format is a requirement. For
|
||||
StackVertical all clips also need to be the same width and for
|
||||
StackHorizontal all clips need to be the same height.
|
||||
|
||||
The frame properties are copied from the first clip.
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
ClipInfo
|
||||
========
|
||||
|
||||
.. function:: ClipInfo(vnode clip[, int alignment=7, int scale=1]])
|
||||
:module: text
|
||||
|
||||
Prints information about the *clip*, such as the format and framerate.
|
||||
|
||||
This is a convenience function for *Text*.
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
CoreInfo
|
||||
========
|
||||
|
||||
.. function:: CoreInfo([vnode clip=std.BlankClip(), int alignment=7, int scale=1])
|
||||
:module: text
|
||||
|
||||
Prints information about the VapourSynth core, such as version and memory
|
||||
use. If no *clip* is supplied, a default blank one is used.
|
||||
|
||||
This is a convenience function for *Text*.
|
||||
|
|
@ -0,0 +1,9 @@
|
|||
FrameNum
|
||||
========
|
||||
|
||||
.. function:: FrameNum(vnode clip[, int alignment=7, int scale=1])
|
||||
:module: text
|
||||
|
||||
Prints the current frame number.
|
||||
|
||||
This is a convenience function for *Text*.
|
||||
|
|
@ -0,0 +1,10 @@
|
|||
FrameProps
|
||||
==========
|
||||
|
||||
.. function:: FrameProps(vnode clip[, string props=[], int alignment=7, int scale=1])
|
||||
:module: text
|
||||
|
||||
Prints all properties attached to the frames, or if the *props* array is
|
||||
given only those properties.
|
||||
|
||||
This is a convenience function for *Text*.
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
Text
|
||||
====
|
||||
|
||||
.. function:: Text(vnode clip, string text[, int alignment=7, int scale=1])
|
||||
:module: text
|
||||
|
||||
Text is a simple text printing filter. It doesn't use any external libraries
|
||||
for drawing the text. It uses a built-in bitmap font: the not-bold, 8×16
|
||||
version of Terminus. The font was not modified, only converted from PCF to an
|
||||
array of bytes.
|
||||
|
||||
The font covers Windows-1252, which is a superset of ISO-8859-1 (aka latin1).
|
||||
Unprintable characters get turned into underscores. Long lines get wrapped in
|
||||
a dumb way. Lines that end up too low to fit in the frame are silently
|
||||
dropped.
|
||||
|
||||
The *alignment* parameter takes a number from 1 to 9, corresponding to the
|
||||
positions of the keys on a numpad.
|
||||
|
||||
The *scale* parameter sets an integer scaling factor for the bitmap font.
|
||||
|
||||
*ClipInfo*, *CoreInfo*, *FrameNum*, and *FrameProps* are convenience functions
|
||||
based on *Text*.
|
||||
|
|
@ -0,0 +1,18 @@
|
|||
Transpose
|
||||
=========
|
||||
|
||||
.. function:: Transpose(vnode clip)
|
||||
:module: std
|
||||
|
||||
Flips the contents of the frames in the same way as a matrix transpose would
|
||||
do. Combine it with FlipVertical or FlipHorizontal to synthesize a left or
|
||||
right rotation. Calling Transpose twice in a row is the same as doing nothing
|
||||
(but slower).
|
||||
|
||||
Here is a picture to illustrate what Transpose does::
|
||||
|
||||
0 5 55
|
||||
0 1 1 2 3 1 8 89
|
||||
5 8 13 21 34 => 1 13 144
|
||||
55 89 144 233 377 2 21 233
|
||||
3 34 377
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
Trim
|
||||
====
|
||||
|
||||
.. function:: Trim(vnode clip[, int first=0, int last, int length])
|
||||
:module: std
|
||||
|
||||
Trim returns a clip with only the frames between the arguments *first* and
|
||||
*last*, or a clip of *length* frames, starting at *first*.
|
||||
Trim is inclusive so Trim(clip, first=3, last=3) will return one frame. If
|
||||
neither *last* nor *length* is specified, no frames are removed from the end
|
||||
of the clip.
|
||||
|
||||
Specifying both *last* and *length* is considered to be an error.
|
||||
Likewise is calling Trim in a way that returns no frames, as 0 frame clips are
|
||||
not allowed in VapourSynth.
|
||||
|
||||
In Python, std.Trim can also be invoked by :ref:`slicing a clip <pythonreference>`.
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
Turn180
|
||||
=======
|
||||
|
||||
.. function:: Turn180(vnode clip)
|
||||
:module: std
|
||||
|
||||
Turns the frames in a clip 180 degrees (to the left, not to the right).
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
Getting Started
|
||||
===============
|
||||
|
||||
So you managed to install VapourSynth. Now what?
|
||||
|
||||
If you don't know the basics of Python, you may want to check out a
|
||||
`tutorial <https://learnxinyminutes.com/docs/python3/>`_.
|
||||
|
||||
You can "play around" in the python interpreter if you want, but that's not how
|
||||
most scripts are created.
|
||||
|
||||
Example Script
|
||||
##############
|
||||
|
||||
It all starts with a *.vpy* script.
|
||||
Here's a sample script to be inspired by, it assumes that `BestSource <https://github.com/vapoursynth/bestsource>`_
|
||||
is installed and :doc:`auto-loaded <installation>`.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from vapoursynth import core # Get an instance of the core
|
||||
clip = core.bs.VideoSource(source='filename.mkv') # Load a video track in mkv file
|
||||
clip = core.std.FlipHorizontal(clip) # Flip the video clip in the horizontal direction
|
||||
clip.set_output() # Set the video clip to be accessible for output
|
||||
|
||||
Audio is also supported, use `BestSource <https://github.com/vapoursynth/bestsource>`_ to load your audio file.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from vapoursynth import core # Get an instance of the core
|
||||
clip = core.bs.AudioSource(source='filename.mkv') # Load an audio track in mkv file
|
||||
clip = core.std.AudioGain(clip,gain=2.0) # Gain all channels 2x
|
||||
clip.set_output() # Set the audio clip to be accessible for output
|
||||
|
||||
You can combine 2 operations in one script.
|
||||
|
||||
.. code-block:: python
|
||||
|
||||
from vapoursynth import core
|
||||
video = core.bs.VideoSource(source='filename.mkv')
|
||||
audio = core.bs.AudioSource(source='filename.mkv')
|
||||
video = core.std.FlipHorizontal(video)
|
||||
audio = core.std.AudioGain(audio,gain=2.0)
|
||||
video.set_output(index=0)
|
||||
audio.set_output(index=1)
|
||||
|
||||
Remember that most VapourSynth objects have a quite nice string representation
|
||||
in Python, so if you want to know more about an instance just call ``print()``.
|
||||
|
||||
Preview
|
||||
#######
|
||||
|
||||
It's possible to directly open the script in `VapourSynth Editor <https://github.com/YomikoR/VapourSynth-Editor>`_
|
||||
or `VirtualDub FilterMod <https://sourceforge.net/projects/vdfiltermod/>`_ for previewing.
|
||||
|
||||
Output with VSPipe
|
||||
##################
|
||||
|
||||
VSPipe is very useful to pipe the output to various applications, for example x264 and flac for encoding.
|
||||
|
||||
Here are some examples of command lines that automatically pass on most video and audio attributes.
|
||||
|
||||
For x264::
|
||||
|
||||
vspipe -c y4m script.vpy - | x264 --demuxer y4m - --output encoded.264
|
||||
|
||||
For flac::
|
||||
|
||||
vspipe -c wav script.vpy - | flac - -o encoded.flac
|
||||
|
||||
For FFmpeg::
|
||||
|
||||
vspipe -c y4m script.vpy - | ffmpeg -i - encoded.mkv
|
||||
|
||||
For mpv::
|
||||
|
||||
vspipe -c y4m script.vpy - | mpv -
|
||||
vspipe -c wav script.vpy - | mpv -
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue