TheThing/church_archive_script
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Initial script

Browse source
This commit is contained in:
Jonatan Nilsson 2023-11-29 16:12:35 +00:00
parent 88b1f70096
commit fe1aaef33f
298 changed files with 52122 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

161
.gitignore vendored Normal file
View file

@ -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/

14
Encode.bat Normal file
View file

@ -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

14
Encode_Web.bat Normal file
View file

@ -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

11
LICENSE Normal file
View file

@ -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.

BIN
Programs/7z.dll Normal file
View file

Binary file not shown.

BIN
Programs/7z.exe Normal file
View file

Binary file not shown.

BIN
Programs/AVFS.exe Normal file
View file

Binary file not shown.

702
Programs/LICENSE.txt Normal file
View file

@ -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.

2
Programs/MANIFEST.in Normal file
View file

@ -0,0 +1,2 @@
global-include *.dll portable.vs .keep VSPipe.exe
global-exclude VapourSynth.dll

31
Programs/Script.ps1 Normal file
View file

@ -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 "==============================================================================="
}

24
Programs/Script_Web.ps1 Normal file
View file

@ -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"
}

BIN
Programs/VSPipe.exe Normal file
View file

Binary file not shown.

BIN
Programs/VSScript.dll Normal file
View file

Binary file not shown.

BIN
Programs/VSScriptPython38.dll Normal file
View file

Binary file not shown.

BIN
Programs/VSVFW.dll Normal file
View file

Binary file not shown.

BIN
Programs/VapourSynth.dll Normal file
View file

Binary file not shown.

BIN
Programs/concrt140.dll Normal file
View file

Binary file not shown.

4
Programs/doc/.buildinfo Normal file
View file

@ -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

2937
Programs/doc/_sources/api/vapoursynth4.h.rst.txt Normal file
View file

File diff suppressed because it is too large Load diff

272
Programs/doc/_sources/api/vshelper4.h.rst.txt Normal file
View file

@ -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.

292
Programs/doc/_sources/api/vsscript4.h.rst.txt Normal file
View file

@ -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.

118
Programs/doc/_sources/apireference.rst.txt Normal file
View file

@ -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.

31
Programs/doc/_sources/applications.rst.txt Normal file
View file

@ -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.

38
Programs/doc/_sources/functions.rst.txt Normal file
View file

@ -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/*

5
Programs/doc/_sources/functions/audio/assumesamplerate.rst.txt Normal file
View file

@ -0,0 +1,5 @@
AssumeSampleRate
================
.. function:: AssumeSampleRate(anode clip[, anode src, int samplerate])
:module: std

12
Programs/doc/_sources/functions/audio/audiogain.rst.txt Normal file
View file

@ -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.

11
Programs/doc/_sources/functions/audio/audioloop.rst.txt Normal file
View file

@ -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>`.

38
Programs/doc/_sources/functions/audio/audiomix.rst.txt Normal file
View file

@ -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])

10
Programs/doc/_sources/functions/audio/audioreverse.rst.txt Normal file
View file

@ -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>`.

12
Programs/doc/_sources/functions/audio/audiosplice.rst.txt Normal file
View file

@ -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>`.

10
Programs/doc/_sources/functions/audio/audiotrim.rst.txt Normal file
View file

@ -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>`.

20
Programs/doc/_sources/functions/audio/blankaudio.rst.txt Normal file
View file

@ -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.

7
Programs/doc/_sources/functions/audio/setaudiocache.rst.txt Normal file
View file

@ -0,0 +1,7 @@
SetAudioCache
=============
.. function:: SetAudioCache(anode clip[, int mode, int fixedsize, int maxsize, int historysize])
:module: std
see SetVideoCache

48
Programs/doc/_sources/functions/audio/shufflechannels.rst.txt Normal file
View file

@ -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])

8
Programs/doc/_sources/functions/audio/splitchannels.rst.txt Normal file
View file

@ -0,0 +1,8 @@
SplitChannels
=============
.. function:: SplitChannels(anode clip)
:module: std
SplitChannels returns each audio channel of the input as
a separate clip.

19
Programs/doc/_sources/functions/general/loadallplugins.rst.txt Normal file
View file

@ -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\\')

26
Programs/doc/_sources/functions/general/loadplugin.rst.txt Normal file
View file

@ -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')

44
Programs/doc/_sources/functions/general/loadpluginavs.rst.txt Normal file
View file

@ -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')

14
Programs/doc/_sources/functions/general/setmaxcpu.rst.txt Normal file
View file

@ -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.

9
Programs/doc/_sources/functions/video/addborders.rst.txt Normal file
View file

@ -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*.

16
Programs/doc/_sources/functions/video/assumefps.rst.txt Normal file
View file

@ -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.

21
Programs/doc/_sources/functions/video/averageframes.rst.txt Normal file
View file

@ -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.

34
Programs/doc/_sources/functions/video/binarize_binarizemask.rst.txt Normal file
View file

@ -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.

24
Programs/doc/_sources/functions/video/blankclip.rst.txt Normal file
View file

@ -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.

8
Programs/doc/_sources/functions/video/boxblur.rst.txt Normal file
View file

@ -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.

15
Programs/doc/_sources/functions/video/cliptoprop.rst.txt Normal file
View file

@ -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().

85
Programs/doc/_sources/functions/video/convolution.rst.txt Normal file
View file

@ -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])

10
Programs/doc/_sources/functions/video/copyframeprops.rst.txt Normal file
View file

@ -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.

20
Programs/doc/_sources/functions/video/crop_cropabs.rst.txt Normal file
View file

@ -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.

44
Programs/doc/_sources/functions/video/deflate_inflate.rst.txt Normal file
View file

@ -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.

11
Programs/doc/_sources/functions/video/deleteframes.rst.txt Normal file
View file

@ -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.

23
Programs/doc/_sources/functions/video/doubleweave.rst.txt Normal file
View file

@ -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.

11
Programs/doc/_sources/functions/video/duplicateframes.rst.txt Normal file
View file

@ -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.

118
Programs/doc/_sources/functions/video/expr.rst.txt Normal file
View file

@ -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)

8
Programs/doc/_sources/functions/video/flipvertical_fliphorizontal.rst.txt Normal file
View file

@ -0,0 +1,8 @@
FlipVertical/FlipHorizontal
===========================
.. function:: FlipVertical(vnode clip)
FlipHorizontal(vnode clip)
:module: std
Flips the *clip* in the vertical or horizontal direction.

77
Programs/doc/_sources/functions/video/frameeval.rst.txt Normal file
View file

@ -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()

18
Programs/doc/_sources/functions/video/freezeframes.rst.txt Normal file
View file

@ -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.

19
Programs/doc/_sources/functions/video/interleave.rst.txt Normal file
View file

@ -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.

21
Programs/doc/_sources/functions/video/invert_invertmask.rst.txt Normal file
View file

@ -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.

39
Programs/doc/_sources/functions/video/levels.rst.txt Normal file
View file

@ -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.

23
Programs/doc/_sources/functions/video/limiter.rst.txt Normal file
View file

@ -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.

11
Programs/doc/_sources/functions/video/loop.rst.txt Normal file
View file

@ -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>`.

39
Programs/doc/_sources/functions/video/lut.rst.txt Normal file
View file

@ -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)

40
Programs/doc/_sources/functions/video/lut2.rst.txt Normal file
View file

@ -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)

15
Programs/doc/_sources/functions/video/makediff.rst.txt Normal file
View file

@ -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])

16
Programs/doc/_sources/functions/video/makefulldiff.rst.txt Normal file
View file

@ -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)

35
Programs/doc/_sources/functions/video/maskedmerge.rst.txt Normal file
View file

@ -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*.

19
Programs/doc/_sources/functions/video/median.rst.txt Normal file
View file

@ -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.

29
Programs/doc/_sources/functions/video/merge.rst.txt Normal file
View file

@ -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*.

15
Programs/doc/_sources/functions/video/mergediff.rst.txt Normal file
View file

@ -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])

15
Programs/doc/_sources/functions/video/mergefulldiff.rst.txt Normal file
View file

@ -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)

69
Programs/doc/_sources/functions/video/minimum_maximum.rst.txt Normal file
View file

@ -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

49
Programs/doc/_sources/functions/video/modifyframe.rst.txt Normal file
View file

@ -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)

14
Programs/doc/_sources/functions/video/pemverifier.rst.txt Normal file
View file

@ -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.

15
Programs/doc/_sources/functions/video/planestats.rst.txt Normal file
View file

@ -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.

14
Programs/doc/_sources/functions/video/premultiply.rst.txt Normal file
View file

@ -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.

26
Programs/doc/_sources/functions/video/prewitt_sobel.rst.txt Normal file
View file

@ -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.

12
Programs/doc/_sources/functions/video/proptoclip.rst.txt Normal file
View file

@ -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().

9
Programs/doc/_sources/functions/video/removeframeprops.rst.txt Normal file
View file

@ -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.

286
Programs/doc/_sources/functions/video/resize.rst.txt Normal file
View file

@ -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 )

10
Programs/doc/_sources/functions/video/reverse.rst.txt Normal file
View file

@ -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>`.

31
Programs/doc/_sources/functions/video/selectevery.rst.txt Normal file
View file

@ -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.

20
Programs/doc/_sources/functions/video/separatefields.rst.txt Normal file
View file

@ -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.

25
Programs/doc/_sources/functions/video/setfieldbased.rst.txt Normal file
View file

@ -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)

20
Programs/doc/_sources/functions/video/setframeprop.rst.txt Normal file
View file

@ -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)

13
Programs/doc/_sources/functions/video/setframeprops.rst.txt Normal file
View file

@ -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)

27
Programs/doc/_sources/functions/video/setvideocache.rst.txt Normal file
View file

@ -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.

48
Programs/doc/_sources/functions/video/shuffleplanes.rst.txt Normal file
View file

@ -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)

12
Programs/doc/_sources/functions/video/splice.rst.txt Normal file
View file

@ -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>`.

8
Programs/doc/_sources/functions/video/splitplanes.rst.txt Normal file
View file

@ -0,0 +1,8 @@
SplitPlanes
===========
.. function:: SplitPlanes(vnode clip)
:module: std
SplitPlanes returns each plane of the input as
separate clips.

12
Programs/doc/_sources/functions/video/stackvertical_stackhorizontal.rst.txt Normal file
View file

@ -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.

9
Programs/doc/_sources/functions/video/text/clipinfo.rst.txt Normal file
View file

@ -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*.

10
Programs/doc/_sources/functions/video/text/coreinfo.rst.txt Normal file
View file

@ -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*.

9
Programs/doc/_sources/functions/video/text/framenum.rst.txt Normal file
View file

@ -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*.

10
Programs/doc/_sources/functions/video/text/frameprops.rst.txt Normal file
View file

@ -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*.

23
Programs/doc/_sources/functions/video/text/text.rst.txt Normal file
View file

@ -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*.

18
Programs/doc/_sources/functions/video/transpose.rst.txt Normal file
View file

@ -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

17
Programs/doc/_sources/functions/video/trim.rst.txt Normal file
View file

@ -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>`.

7
Programs/doc/_sources/functions/video/turn180.rst.txt Normal file
View file

@ -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).

78
Programs/doc/_sources/gettingstarted.rst.txt Normal file
View file

@ -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