Mirror from https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite

.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+permissions:
+  issues: write
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'Kosinkadink' }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@v1
+        with:
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }} ## Add your own personal access token to your Github Repository secrets and reference it here.

.gitignore

@@ -0,0 +1,162 @@
+# 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/
+# VIM swap files
+*.swp

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -0,0 +1,110 @@
+# ComfyUI-VideoHelperSuite
+Nodes related to video workflows
+
+## I/O Nodes
+### Load Video
+Converts a video file into a series of images
+- video: The video file to be loaded
+- force_rate: Discards or duplicates frames as needed to hit a target frame rate. Disabled by setting to 0. This can be used to quickly match a suggested frame rate like the 8 fps of AnimateDiff.
+- force_size: Allows for quick resizing to a number of suggested sizes. Several options allow you to set only width or height and determine the other from aspect ratio.
+- frame_load_cap: The maximum number of frames which will be returned. This could also be thought of as the maximum batch size.
+- skip_first_frames: How many frames to skip from the start of the video after adjusting for a forced frame rate. By incrementing this number by the frame_load_cap, you can easily process a longer input video in parts. 
+- select_every_nth: Allows for skipping a number of frames without considering the base frame rate or risking frame duplication. Often useful when working with animated gifs
+A path variant of the Load Video node exists that allows loading videos from external paths
+![step](https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite/assets/4284322/b5fc993c-5c9b-4608-afa4-48ae2e1380ef)
+![resize](https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite/assets/4284322/98d2e78e-1c44-443c-a8fe-0dab0b5947f3)
+If [Advanced Previews](#advanced-previews) is enabled in the options menu of the web ui, the preview will reflect the current settings on the node.
+### Load Image Sequence
+Loads all image files from a subfolder. Options are similar to Load Video.
+- image_load_cap: The maximum number of images which will be returned. This could also be thought of as the maximum batch size.
+- skip_first_images: How many images to skip. By incrementing this number by image_load_cap, you can easily divide a long sequence of images into multiple batches.
+- select_every_nth: Allows for skipping a number of images between every returned frame.
+
+A path variant of Load Image sequence also exists.
+### Video Combine
+Combines a series of images into an output video  
+If the optional audio input is provided, it will also be combined into the output video
+- frame_rate: How many of the input frames are displayed per second.  A higher frame rate means that the output video plays faster and has less duration. This should usually be kept to 8 for AnimateDiff, or matched to the force_rate of a Load Video node.
+- loop_count: How many additional times the video should repeat
+- filename_prefix: The base file name used for output.
+  - You can save output to a subfolder: `subfolder/video`
+  - Like the builtin Save Image node, you can add timestamps. `%date:yyyy-MM-ddThh:mm:ss%` might become 2023-10-31T6:45:25
+- format: The file format to use. Advanced information on configuring or adding additional video formats can be found in the [Video Formats](#video-formats) section.
+- pingpong: Causes the input to be played back in the reverse to create a clean loop.
+- save_output: Whether the image should be put into the output directory or the temp directory.
+Returns: a `VHS_FILENAMES` which consists of a boolean indicating if save_output is enabled and a list of the full filepaths of all generated outputs in the order created. Accordingly `output[1][-1]` will be the most complete output.
+ 
+Depending on the format chosen, additional options may become available, including
+- crf: Describes the quality of the output video. A lower number gives a higher quality video and a larger file size, while a higher number gives a lower quality video with a smaller size. Scaling varies by codec, but visually lossless output generally occurs around 20.
+- save_metadata: Includes a copy of the workflow in the output video which can be loaded by dragging and dropping the video, just like with images.
+- pix_fmt: Changes how the pixel data is stored. `yuv420p10le` has higher color quality, but won't work on all devices
+### Load Audio
+Provides a way to load standalone audio files.
+- seek_seconds: An optional start time for the audio file in seconds.
+
+## Latent/Image Nodes
+A number of utility nodes exist for managing latents. For each, there is an equivalent node which works on images.
+### Split Batch
+Divides the latents into two sets. The first `split_index` latents go to output A and the remainder to output B. If less then `split_index` latents are provided as input, all are passed to output A and output B is empty.
+### Merge Batch
+Combines two groups of latents into a single output. The order of the output is the latents in A followed by the latents in B.  
+If the input groups are not the same size, the node provides options for rescaling the latents before merging.
+### Select Every Nth
+The first of every `select_every_nth` input is passed and the remainder are discarded
+### Get Count
+### Duplicate Batch
+
+## Video Previews
+Load Video (Upload), Load Video (Path), Load Images (Upload), Load Images (Path) and Video Combine provide animated previews.  
+Nodes with previews provide additional functionality when right clicked
+- Open preview
+- Save preview
+- Pause preview: Can improve performance with very large videos
+- Hide preview: Can improve performance, save space
+- Sync preview: Restarts all previews for side-by-side comparisons
+
+### Advanced Previews
+Advanced Previews must be manually enabled by clicking the settings gear next to Queue Prompt and checking the box for VHS Advanced Previews.  
+If enabled, videos which are displayed in the ui will be converted with ffmpeg on request. This has several benefits
+- Previews for Load Video nodes will reflect the settings on the node such as skip_first_frames and frame_load_cap
+  - This makes it easy to select an exact portion of an input video and sync it with outputs
+- It can use substantially less bandwidth if running the server remotely
+- It can greatly improve the browser performance by downsizing videos to the in ui resolution, particularly useful with animated gifs
+- It allows for previews of videos that would not normally be playable in browser.
+- Can be limited to subdirectories of ComyUI if `VHS_STRICT_PATHS` is set as an environment variable.
+
+This fucntionality is disabled since it comes with several downsides
+- There is a delay before videos show in the browser. This delay can become quite large if the input video is long
+- The preview videos are lower quality (The original can always be viewed with Right Click -> Open preview)
+
+## Video Formats
+Those familiar with ffmpeg are able to add json files to the video_formats folders to add new output types to Video Combine. 
+Consider the following example for av1-webm
+```json
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "libsvtav1",
+        "-pix_fmt", "yuv420p10le",
+        "-crf", ["crf","INT", {"default": 23, "min": 0, "max": 100, "step": 1}]
+    ],
+    "audio_pass": ["-c:a", "libopus"],
+     "extension": "webm",
+     "environment": {"SVT_LOG": "1"}
+}
+```
+Most configuration takes place in `main_pass`, which is a list of arguments that are passed to ffmpeg. 
+- `"-n"` designates that the command should fail if a file of the same name already exists. This should never happen, but if some bug were to occur, it would ensure other files aren't overwritten.
+- `"-c:v", "libsvtav1"` designates that the video should be encoded with an av1 codec using the new SVT-AV1 encoder. SVT-AV1 is much faster than libaom-av1, but may not exist in older versions of ffmpeg. Alternatively, av1_nvenc could be used for gpu encoding with newer nvidia cards. 
+- `"-pix_fmt", "yuv420p10le"` designates the standard pixel format with 10-bit color. It's important that some pixel format be specified to ensure a nonconfigurable input pix_fmt isn't used.
+
+`audio pass` contains a list of arguments which are passed to ffmpeg when audio is passed into Video Combine
+
+`extension` designates both the file extension and the container format that is used. If some of the above options are omitted from `main_pass` it can affect what default options are chosen.  
+`environment` can optionally be provided to set environment variables during execution. For av1 it's used to reduce the verbosity of logging so that only major errors are displayed.  
+`input_color_depth` effects the format in which pixels are passed to the ffmpeg subprocess. Current valid options are `8bit` and `16bit`. The later will produce higher quality output, but is experimental.
+
+Fields can be exposed in the webui as a widget using a format similar to what is used in the creation of custom nodes. In the above example, the argument for `-crf` will be exposed as a format widget in the webui. Format widgets are a list of up to 3 terms
+- The name of the widget that will be displayed in the web ui
+- Either a primitive such as "INT" or "BOOLEAN", or a list of string options
+- A dictionary of options

__init__.py

@@ -0,0 +1,9 @@
+from .videohelpersuite.nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+import folder_paths
+from .videohelpersuite.server import server
+from .videohelpersuite import documentation
+from .videohelpersuite import latent_preview
+
+WEB_DIRECTORY = "./web"
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
+documentation.format_descriptions(NODE_CLASS_MAPPINGS)

pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "comfyui-videohelpersuite"
+description = "Nodes related to video workflows"
+version = "1.7.7"
+license = { file = "LICENSE" }
+dependencies = ["opencv-python", "imageio-ffmpeg"]
+
+[project.urls]
+Repository = "https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite"
+
+#  Used by Comfy Registry https://comfyregistry.org
+[tool.comfy]
+PublisherId = "kosinkadink"
+DisplayName = "ComfyUI-VideoHelperSuite"
+Icon = ""

requirements.txt

@@ -0,0 +1,2 @@
+opencv-python
+imageio-ffmpeg

testframework/README.md

@@ -0,0 +1,5 @@
+Code to automate execution of the tests and evaluate the results.  
+Distributed as a `custom node`,  and can be installed by copying or simlinking to the `custom_nodes` directory.  
+Requires that ffprobe be available and added to the path. Note that imageio-ffmpeg does not bundle ffprobe.
+
+When installed, it adds a new sidebar tab to automate running one, or a folder of tests. This requires that the `Use new menu and workflow management` setting not be disabled

testframework/__init__.py

@@ -0,0 +1,6 @@
+from . import server
+NODE_CLASS_MAPPINGS = {}
+NODE_DISPLAY_NAME_MAPPINGS = {}
+
+WEB_DIRECTORY = "./web"
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]

testframework/server.py

@@ -0,0 +1,60 @@
+import subprocess
+import json
+import os
+import torch
+import shutil
+
+import server
+import folder_paths
+
+web = server.web
+
+@server.PromptServer.instance.routes.post("/VHS_test")
+async def test(request):
+    try:
+        req_data = await request.json()
+        output = req_data['output']['gifs'][0]
+        filename = output['filename']
+        typ = output['type']
+        base_args = ["ffprobe", "-v", "error", '-count_packets', "-show_entries", "stream", "-of", "json"]
+        video = folder_paths.get_annotated_filepath(f'{filename} [{typ}]')
+        vprobe = json.loads(subprocess.run(base_args + ['-select_streams', 'v:0', video],
+                             capture_output=True, check=True).stdout)['streams'][0]
+        aprobe = json.loads(subprocess.run(base_args + ['-select_streams', 'a:0', video],
+                             capture_output=True, check=True).stdout)['streams']
+        probe = {'video': vprobe}
+        if len(aprobe) > 0:
+            probe['audio'] = aprobe[0]
+        errors = []
+        compare = None
+        for test in req_data['tests']:
+            if test['type'] == 'compare':
+                compare = test
+                continue
+            key = test['key']
+            expected = test['value']
+            actual = probe[test['type']][key]
+            if expected != actual:
+                #Consider always dumping type?
+                errors.append(f'{key}: {expected} != {actual}')
+        if len(errors) == 0 and compare is not None:
+            if not os.path.exists(compare['filename']):
+                os.makedirs(os.path.split(compare['filename'])[0], exist_ok=True)
+                shutil.copy(video, compare['filename'])
+                print("Missing comparison file has been initialized from output:", os.path.abspath(compare['filename']))
+            else:
+                #NOTE: This does not include the full memory optimizations of VHS
+                #Tests should be small
+                #TODO: Figure out way to do opacity comparison. May need to do blending in python
+                #(easy, but slower and more memory intensive)
+                diff = subprocess.run(['ffmpeg', '-v', 'error', '-i', video, '-i', compare['filename'], '-filter_complex', 'blend=all_mode=grainextract', '-pix_fmt', 'rgb24', '-f', 'rawvideo', '-'], stdout=subprocess.PIPE, check=True).stdout
+                diff = torch.frombuffer(diff, dtype=torch.uint8).to(dtype=torch.float32).div_(255)
+                #diff = diff.reshape((-1,4))
+                d = (diff-0.5).abs().sum()/diff.size(0)
+                if d > compare['tolerance']:
+                    errors.append(f'Similarity is outside specified tolerance: {d}')
+                else:
+                    print('d:', d)
+        return web.json_response(errors)
+    except Exception as e:
+        return web.json_response(str(e))

testframework/web/js/testRunner.js

@@ -0,0 +1,96 @@
+
+import {app} from "../../../scripts/app.js";
+import {api} from "../../../scripts/api.js";
+
+let watched_nodes = {}
+let resolve = undefined
+let testURL = api.apiURL("/VHS_test")
+let errors = []
+api.addEventListener("executed", async function ({detail}) {
+    if (watched_nodes && watched_nodes[detail?.node]) {
+        if (detail?.output?.unfinished_batch) {
+            return
+        }
+        let requestBody = {tests: watched_nodes[detail.node], output: detail.output}
+        try {
+            let req = await fetch(api.apiURL("/VHS_test"),
+                {method: "POST", body: JSON.stringify(requestBody)});
+            let testResult = await req.json()
+            if (testResult.length != 0) {
+                errors.push(testResult)
+            }
+        } catch(e) {
+            errors.push(e)
+        }
+        if (!(watched_nodes.length -= 1)) {
+            resolve()
+        }
+    }
+});
+
+const workflowService = app.extensionManager.workflow
+
+async function runTest(file) {
+    if (!file?.name?.endsWith(".json")) {
+        return false
+    }
+    let workflow = JSON.parse(await file.text())
+    await app.loadGraphData(workflow)
+    //NOTE: API is not used so workflow data is actually processed
+    watched_nodes = workflow.tests
+    errors = []
+    let p = new Promise((r) => resolve = r)
+    await app.queuePrompt()
+    //block until execution completes
+    await p
+    watched_nodes = {}
+    if (errors.length > 0) {
+        app.ui.dialog.show("Failed " + errors.length + " tests:\n" + errors)
+        return true
+    }
+    await workflowService.closeWorkflow(workflowService.activeWorkflow, {warnIfUnsaved: false})
+    return false
+}
+let iconOverride = document.createElement("style")
+iconOverride.innerHTML = `.VHSTestIcon:before {content: '🧪';}`
+document.body.append(iconOverride)
+
+let testSidebar = {id: 'VHStest', title: 'VHS Test', icon: 'VHSTestIcon', type: 'custom',
+    render: (e) => {
+        e.innerHTML = `Select a folder containing tests
+        <input>
+        Or select a single test
+        <input>
+            `
+
+        const folderInput = e.children[0]
+        const fileInput = e.children[1]
+        Object.assign(folderInput, {
+            type: "file",
+            webkitdirectory: true,
+            onchange: async function() {
+                const startTime = Date.now()
+                let failedTests = false
+                for(const file of this.files) {
+                    failedTests ||= await runTest(file)
+                }
+                this.value=""
+                if (!failedTests) {
+                    console.log("All tests passed in " + ((Date.now() - startTime)/1000) + "s")
+                }
+            },
+        });
+        Object.assign(fileInput, {
+            type: "file",
+            accept: ".json",
+            onchange: async function() {
+                if (this.files.length) {
+                    if(!(await runTest(this.files[0]))) {
+                        console.log("Test complete")
+                    }
+                    this.value=""
+                }
+            },
+        });
+    }}
+app.extensionManager.registerSidebarTab(testSidebar)

tests/README.md

@@ -0,0 +1 @@
+Workflows for automated testing of VHS. Most include an additional tests key to check the properties or perform comparisons on node outputs

tests/audio.json

@@ -0,0 +1,313 @@
+{
+  "id": "07b812b5-5037-4878-90bc-32d3a1f36619",
+  "revision": 0,
+  "last_node_id": 7,
+  "last_link_id": 5,
+  "nodes": [
+    {
+      "id": 5,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        732,
+        -23
+      ],
+      "size": [
+        210,
+        334
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 2
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 3
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/webm",
+        "pix_fmt": "yuv420p",
+        "crf": 20,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {}
+        }
+      }
+    },
+    {
+      "id": 6,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        503,
+        363
+      ],
+      "size": [
+        210,
+        334
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 4
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": 5
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "trim_to_audio": false,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {}
+        }
+      }
+    },
+    {
+      "id": 4,
+      "type": "VHS_LoadVideoPath",
+      "pos": [
+        29,
+        16
+      ],
+      "size": [
+        221.27618408203125,
+        413.1552734375
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            2,
+            4
+          ]
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            3
+          ]
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideoPath"
+      },
+      "widgets_values": {
+        "video": "input/bigbuckbunny.mp4",
+        "force_rate": 8,
+        "custom_width": 0,
+        "custom_height": 0,
+        "frame_load_cap": 30,
+        "skip_first_frames": 0,
+        "select_every_nth": 1,
+        "format": "AnimateDiff",
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "input/bigbuckbunny.mp4",
+            "type": "path",
+            "format": "video/mp4",
+            "force_rate": 8,
+            "custom_width": 0,
+            "custom_height": 0,
+            "frame_load_cap": 30,
+            "skip_first_frames": 0,
+            "select_every_nth": 1
+          }
+        }
+      }
+    },
+    {
+      "id": 7,
+      "type": "VHS_LoadAudio",
+      "pos": [
+        83,
+        564
+      ],
+      "size": [
+        218.93820190429688,
+        126
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            5
+          ]
+        },
+        {
+          "name": "duration",
+          "type": "FLOAT",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadAudio"
+      },
+      "widgets_values": {
+        "audio_file": "input/bigbuckbunny.mp4",
+        "seek_seconds": 0,
+        "duration": 5
+      }
+    }
+  ],
+  "links": [
+    [
+      2,
+      4,
+      0,
+      5,
+      0,
+      "IMAGE"
+    ],
+    [
+      3,
+      4,
+      2,
+      5,
+      1,
+      "AUDIO"
+    ],
+    [
+      4,
+      4,
+      0,
+      6,
+      0,
+      "IMAGE"
+    ],
+    [
+      5,
+      7,
+      0,
+      6,
+      1,
+      "AUDIO"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "frontendVersion": "1.25.0",
+    "VHS_latentpreview": true,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": true,
+    "VHS_KeepIntermediate": true
+  },
+  "version": 0.4,
+  "tests": {
+      "5": [{"type": "audio", "key": "nb_read_packets", "value": "177"}],
+      "6": [{"type": "audio", "key": "nb_read_packets", "value": "176"}],
+      "length": 2
+  }
+}

tests/batch4x4.json

@@ -0,0 +1,535 @@
+{
+  "last_node_id": 18,
+  "last_link_id": 28,
+  "nodes": [
+    {
+      "id": 16,
+      "type": "SolidMask",
+      "pos": [
+        38,
+        1066
+      ],
+      "size": {
+        "0": 315,
+        "1": 106
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": [
+            18
+          ],
+          "slot_index": 0,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "SolidMask"
+      },
+      "widgets_values": [
+        1,
+        512,
+        512
+      ]
+    },
+    {
+      "id": 15,
+      "type": "ImageCompositeMasked",
+      "pos": [
+        412.0800030517579,
+        591.4099975585939
+      ],
+      "size": {
+        "0": 315,
+        "1": 146
+      },
+      "flags": {},
+      "order": 5,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "destination",
+          "type": "IMAGE",
+          "link": 16
+        },
+        {
+          "name": "source",
+          "type": "IMAGE",
+          "link": 17
+        },
+        {
+          "name": "mask",
+          "type": "MASK",
+          "link": 18
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            19
+          ],
+          "slot_index": 0,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ImageCompositeMasked"
+      },
+      "widgets_values": [
+        0,
+        0,
+        false
+      ]
+    },
+    {
+      "id": 18,
+      "type": "VHS_BatchManager",
+      "pos": [
+        329.8000881958008,
+        -87.40008056640622
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "VHS_BatchManager",
+          "type": "VHS_BatchManager",
+          "links": [
+            24,
+            25,
+            26,
+            27
+          ],
+          "slot_index": 0,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_BatchManager"
+      },
+      "widgets_values": {
+        "frames_per_batch": 4,
+        "count": 2
+      }
+    },
+    {
+      "id": 10,
+      "type": "VHS_LoadVideoPath",
+      "pos": [
+        24,
+        102
+      ],
+      "size": [
+        320,
+        420.7188019966722
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": 25,
+          "slot_index": 0
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            16,
+            22
+          ],
+          "slot_index": 0,
+          "shape": 3
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [
+            28
+          ],
+          "slot_index": 2,
+          "shape": 3
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideoPath"
+      },
+      "widgets_values": {
+        "video": "input/bigbuckbunny.mp4",
+        "force_rate": 8,
+        "force_size": "512x?",
+        "custom_width": 512,
+        "custom_height": 512,
+        "frame_load_cap": 16,
+        "skip_first_frames": 64,
+        "select_every_nth": 1,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "frame_load_cap": 16,
+            "skip_first_frames": 64,
+            "force_rate": 8,
+            "filename": "input/bigbuckbunny.mp4",
+            "type": "path",
+            "format": "video/mp4",
+            "select_every_nth": 1,
+            "force_size": "512x?"
+          }
+        }
+      }
+    },
+    {
+      "id": 14,
+      "type": "VHS_LoadVideoPath",
+      "pos": [
+        26,
+        598
+      ],
+      "size": [
+        320,
+        444.7188019966722
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": 26,
+          "slot_index": 0
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            17
+          ],
+          "slot_index": 0,
+          "shape": 3
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "audio",
+          "type": "VHS_AUDIO",
+          "links": [],
+          "slot_index": 2,
+          "shape": 3
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideoPath"
+      },
+      "widgets_values": {
+        "video": "input/bigbuckbunny.mp4",
+        "force_rate": 8,
+        "force_size": "Custom Width",
+        "custom_width": 384,
+        "custom_height": 512,
+        "frame_load_cap": 16,
+        "skip_first_frames": 64,
+        "select_every_nth": 1,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "frame_load_cap": 16,
+            "skip_first_frames": 64,
+            "force_rate": 8,
+            "filename": "input/bigbuckbunny.mp4",
+            "type": "path",
+            "format": "video/mp4",
+            "select_every_nth": 1,
+            "force_size": "512x?"
+          }
+        }
+      }
+    },
+    {
+      "id": 11,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        762,
+        646
+      ],
+      "size": [
+        320,
+        492.75
+      ],
+      "flags": {},
+      "order": 6,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 19
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": 28
+        },
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": 27,
+          "slot_index": 2
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00005-audio.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4",
+            "frame_rate": 8
+          }
+        }
+      }
+    },
+    {
+      "id": 17,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        756,
+        100
+      ],
+      "size": [
+        320,
+        492.75
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 22
+        },
+        {
+          "name": "audio",
+          "type": "VHS_AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": 24,
+          "slot_index": 2
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/webm",
+        "pix_fmt": "yuv420p",
+        "crf": 20,
+        "save_metadata": true,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00004.webm",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/webm",
+            "frame_rate": 8
+          }
+        }
+      }
+    }
+  ],
+  "links": [
+    [
+      16,
+      10,
+      0,
+      15,
+      0,
+      "IMAGE"
+    ],
+    [
+      17,
+      14,
+      0,
+      15,
+      1,
+      "IMAGE"
+    ],
+    [
+      18,
+      16,
+      0,
+      15,
+      2,
+      "MASK"
+    ],
+    [
+      19,
+      15,
+      0,
+      11,
+      0,
+      "IMAGE"
+    ],
+    [
+      22,
+      10,
+      0,
+      17,
+      0,
+      "IMAGE"
+    ],
+    [
+      24,
+      18,
+      0,
+      17,
+      2,
+      "VHS_BatchManager"
+    ],
+    [
+      25,
+      18,
+      0,
+      10,
+      0,
+      "VHS_BatchManager"
+    ],
+    [
+      26,
+      18,
+      0,
+      14,
+      0,
+      "VHS_BatchManager"
+    ],
+    [
+      27,
+      18,
+      0,
+      11,
+      2,
+      "VHS_BatchManager"
+    ],
+    [
+      28,
+      10,
+      2,
+      11,
+      1,
+      "VHS_AUDIO"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4,
+  "tests": {
+      "17": [{"type": "video", "key": "nb_read_packets", "value": "16"}],
+      "11": [{"type": "video", "key": "nb_read_packets", "value": "16"},
+          {"type": "compare", "filename": "custom_nodes/ComfyUI-VideoHelperSuite/tests/outputs/batch.mp4", "tolerance": 0.02}
+      ],
+      "length": 1
+  }
+}

tests/converted-format-input.json

@@ -0,0 +1,253 @@
+{
+  "last_node_id": 19,
+  "last_link_id": 20,
+  "nodes": [
+    {
+      "id": 18,
+      "type": "PrimitiveNode",
+      "pos": [
+        318,
+        618
+      ],
+      "size": [
+        210,
+        82
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            18
+          ],
+          "widget": {
+            "name": "crf"
+          }
+        }
+      ],
+      "properties": {
+        "Run widget replace on values": false
+      },
+      "widgets_values": [
+        60,
+        "fixed"
+      ]
+    },
+    {
+      "id": 11,
+      "type": "LoadImage",
+      "pos": [
+        260.4530029296875,
+        233.2003173828125
+      ],
+      "size": [
+        315,
+        314
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            19
+          ],
+          "slot_index": 0
+        },
+        {
+          "name": "MASK",
+          "type": "MASK",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "LoadImage"
+      },
+      "widgets_values": [
+        "example.png",
+        "image"
+      ]
+    },
+    {
+      "id": 17,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        733.3749389648438,
+        338.28924560546875
+      ],
+      "size": [
+        222.91415405273438,
+        522.9141845703125
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 19
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": null,
+          "shape": 7
+        },
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null,
+          "shape": 7
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null,
+          "shape": 7
+        },
+        {
+          "name": "crf",
+          "type": "INT",
+          "link": 18,
+          "widget": {
+            "name": "crf"
+          }
+        },
+        {
+          "name": "pix_fmt",
+          "type": [
+            "yuv420p",
+            "yuv420p10le"
+          ],
+          "link": 20,
+          "widget": {
+            "name": "pix_fmt"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p10le",
+        "crf": 60,
+        "save_metadata": true,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4",
+            "frame_rate": 8
+          },
+          "muted": false
+        }
+      }
+    },
+    {
+      "id": 19,
+      "type": "PrimitiveNode",
+      "pos": [
+        300,
+        760
+      ],
+      "size": [
+        290,
+        110
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "COMBO",
+          "type": "COMBO",
+          "links": [
+            20
+          ],
+          "widget": {
+            "name": "pix_fmt"
+          }
+        }
+      ],
+      "properties": {
+        "Run widget replace on values": false
+      },
+      "widgets_values": [
+        "yuv420p10le",
+        "fixed",
+        ""
+      ]
+    }
+  ],
+  "links": [
+    [
+      18,
+      18,
+      0,
+      17,
+      4,
+      "INT"
+    ],
+    [
+      19,
+      11,
+      0,
+      17,
+      0,
+      "IMAGE"
+    ],
+    [
+      20,
+      19,
+      0,
+      17,
+      5,
+      [
+        "yuv420p",
+        "yuv420p10le"
+      ]
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "ds": {
+      "scale": 0.8264462809917354,
+      "offset": [
+        45.8650452880864,
+        -157.46987175292935
+      ]
+    }
+  },
+  "version": 0.4,
+  "tests": {
+      "17": [{"type": "video", "key": "pix_fmt", "value": "yuv420p10le"}
+      ],
+      "length": 1
+  }
+}

tests/converted-input.json

@@ -0,0 +1,307 @@
+{
+  "last_node_id": 20,
+  "last_link_id": 23,
+  "nodes": [
+    {
+      "id": 18,
+      "type": "VHS_VideoInfoLoaded",
+      "pos": [
+        424,
+        427
+      ],
+      "size": {
+        "0": 304.79998779296875,
+        "1": 106
+      },
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "link": 19
+        }
+      ],
+      "outputs": [
+        {
+          "name": "fps🟦",
+          "type": "FLOAT",
+          "links": [
+            20
+          ],
+          "slot_index": 0,
+          "shape": 3
+        },
+        {
+          "name": "frame_count🟦",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "duration🟦",
+          "type": "FLOAT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "width🟦",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "height🟦",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoInfoLoaded"
+      },
+      "widgets_values": {}
+    },
+    {
+      "id": 17,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        783,
+        223
+      ],
+      "size": [
+        315,
+        286
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 21
+        },
+        {
+          "name": "audio",
+          "type": "VHS_AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "frame_rate",
+          "type": "FLOAT",
+          "link": 20,
+          "widget": {
+            "name": "frame_rate"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4"
+          }
+        }
+      }
+    },
+    {
+      "id": 16,
+      "type": "VHS_LoadVideoPath",
+      "pos": [
+        96,
+        230
+      ],
+      "size": [
+        315,
+        449.5
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "frame_load_cap",
+          "type": "INT",
+          "link": 23,
+          "slot_index": 1,
+          "widget": {
+            "name": "frame_load_cap"
+          }
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            21
+          ],
+          "slot_index": 0,
+          "shape": 3
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "audio",
+          "type": "VHS_AUDIO",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": [
+            19
+          ],
+          "slot_index": 3,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideoPath"
+      },
+      "widgets_values": {
+        "video": "input/leader.webm",
+        "force_rate": 0,
+        "force_size": "Disabled",
+        "custom_width": 512,
+        "custom_height": 512,
+        "frame_load_cap": 64,
+        "skip_first_frames": 0,
+        "select_every_nth": 1,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "frame_load_cap": 64,
+            "skip_first_frames": 0,
+            "force_rate": 0,
+            "filename": "input/leader.webm",
+            "type": "path",
+            "format": "video/webm",
+            "select_every_nth": 1
+          }
+        }
+      }
+    },
+    {
+      "id": 20,
+      "type": "PrimitiveNode",
+      "pos": [
+        -240,
+        170
+      ],
+      "size": {
+        "0": 210,
+        "1": 80
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "INT",
+          "type": "INT",
+          "links": [
+            23
+          ],
+          "widget": {
+            "name": "frame_load_cap"
+          }
+        }
+      ],
+      "properties": {
+        "Run widget replace on values": false
+      },
+      "widgets_values": [
+        64,
+        "fixed"
+      ]
+    }
+  ],
+  "links": [
+    [
+      19,
+      16,
+      3,
+      18,
+      0,
+      "VHS_VIDEOINFO"
+    ],
+    [
+      20,
+      18,
+      0,
+      17,
+      3,
+      "FLOAT"
+    ],
+    [
+      21,
+      16,
+      0,
+      17,
+      0,
+      "IMAGE"
+    ],
+    [
+      23,
+      20,
+      0,
+      16,
+      1,
+      "INT"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4,
+  "tests": {
+      "17": [{"type": "video", "key": "width", "value": 1440},
+          {"type": "video", "key": "height", "value": 1080},
+          {"type": "video", "key": "nb_read_packets", "value": "64"}
+      ],
+      "length": 1
+  }
+}

tests/loop.json

@@ -0,0 +1,178 @@
+{
+  "last_node_id": 3,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VHS_LoadVideo",
+      "pos": {
+        "0": 54,
+        "1": 89
+      },
+      "size": [
+        260,
+        460
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            1
+          ],
+          "slot_index": 0,
+          "shape": 3
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "audio",
+          "type": "VHS_AUDIO",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideo"
+      },
+      "widgets_values": {
+        "video": "leader.webm",
+        "force_rate": 8,
+        "force_size": "Disabled",
+        "custom_width": 304,
+        "custom_height": 312,
+        "frame_load_cap": 16,
+        "skip_first_frames": 1,
+        "select_every_nth": 1,
+        "choose video to upload": "image",
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "frame_load_cap": 16,
+            "skip_first_frames": 1,
+            "force_rate": 8,
+            "filename": "leader.webm",
+            "type": "input",
+            "format": "video/mp4",
+            "force_size": "410.4x?",
+            "select_every_nth": 1
+          }
+        }
+      }
+    },
+    {
+      "id": 3,
+      "type": "VHS_VideoCombine",
+      "pos": {
+        "0": 629,
+        "1": 222
+      },
+      "size": [
+        320,
+        550
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 1
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 1,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/h264-mp4",
+        "pix_fmt": "yuv420p",
+        "crf": 19,
+        "save_metadata": true,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00005.mp4",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/h264-mp4",
+            "frame_rate": 8
+          }
+        }
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      3,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4,
+  "tests": {
+      "3": [{"type": "video", "key": "nb_read_packets", "value": "32"}],
+      "length": 1
+  }
+}

tests/old-prores.json

@@ -0,0 +1,423 @@
+{
+  "id": "bc7448ba-118f-4226-95ab-32227992f954",
+  "revision": 0,
+  "last_node_id": 6,
+  "last_link_id": 4,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VHS_LoadVideo",
+      "pos": [
+        54,
+        89
+      ],
+      "size": [
+        245.1999969482422,
+        492.7751770019531
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "slot_index": 0,
+          "links": [
+            1,
+            2,
+            3,
+            4
+          ]
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": null
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideo"
+      },
+      "widgets_values": {
+        "video": "leader.webm",
+        "force_rate": 8,
+        "custom_width": 512,
+        "custom_height": 0,
+        "frame_load_cap": 64,
+        "skip_first_frames": 1,
+        "select_every_nth": 1,
+        "format": "AnimateDiff",
+        "choose video to upload": "image",
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "frame_load_cap": 64,
+            "skip_first_frames": 0,
+            "force_rate": 8,
+            "filename": "leader.webm",
+            "type": "input",
+            "format": "video/mp4",
+            "select_every_nth": 1
+          }
+        }
+      }
+    },
+    {
+      "id": 4,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        630.9500122070312,
+        136.90997314453125
+      ],
+      "size": [
+        315,
+        497.25
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 2
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/ProRes",
+        "profile": "2",
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00004.mov",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/ProRes",
+            "frame_rate": 8,
+            "workflow": "AnimateDiff_00004.png"
+          }
+        }
+      }
+    },
+    {
+      "id": 3,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        635.0499267578125,
+        -407.1000061035156
+      ],
+      "size": [
+        315,
+        497.25
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 1
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/ProRes",
+        "profile": "1",
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001.mov",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/ProRes",
+            "frame_rate": 8,
+            "workflow": "AnimateDiff_00001.png"
+          }
+        }
+      }
+    },
+    {
+      "id": 5,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        974.6401977539062,
+        -409.33984375
+      ],
+      "size": [
+        315,
+        497.25
+      ],
+      "flags": {},
+      "order": 3,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 3
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/ProRes",
+        "profile": "3",
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00002.mov",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/ProRes",
+            "frame_rate": 8,
+            "workflow": "AnimateDiff_00002.png"
+          }
+        }
+      }
+    },
+    {
+      "id": 6,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        968.7000122070312,
+        138.7698974609375
+      ],
+      "size": [
+        315,
+        497.25
+      ],
+      "flags": {},
+      "order": 4,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 4
+        },
+        {
+          "name": "audio",
+          "shape": 7,
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "shape": 7,
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "shape": 7,
+          "type": "VAE",
+          "link": null
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/ProRes",
+        "profile": "4",
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00003.mov",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/ProRes",
+            "frame_rate": 8
+          }
+        }
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      3,
+      0,
+      "IMAGE"
+    ],
+    [
+      2,
+      1,
+      0,
+      4,
+      0,
+      "IMAGE"
+    ],
+    [
+      3,
+      1,
+      0,
+      5,
+      0,
+      "IMAGE"
+    ],
+    [
+      4,
+      1,
+      0,
+      6,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {
+    "frontendVersion": "1.17.0",
+    "VHS_latentpreview": true,
+    "VHS_latentpreviewrate": 0,
+    "VHS_MetadataImage": true,
+    "VHS_KeepIntermediate": true
+  },
+  "version": 0.4,
+  "tests": {
+      "6": [{"type": "video", "key": "pix_fmt", "value": "yuv444p12le"}],
+      "length": 1
+  }
+}

tests/old-vae-conversion.json

@@ -0,0 +1,229 @@
+{
+  "last_node_id": 10,
+  "last_link_id": 9,
+  "nodes": [
+    {
+      "id": 7,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        746,
+        309
+      ],
+      "size": [
+        320,
+        468.7188019966722
+      ],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "LATENT",
+          "link": 9
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "link": null
+        },
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 8
+        }
+      ],
+      "outputs": [
+        {
+          "name": "Filenames",
+          "type": "VHS_FILENAMES",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/webm",
+        "crf": 20,
+        "save_metadata": true,
+        "pingpong": false,
+        "save_output": false,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "filename": "AnimateDiff_00001.webm",
+            "subfolder": "",
+            "type": "temp",
+            "format": "video/webm",
+            "frame_rate": 8
+          }
+        }
+      }
+    },
+    {
+      "id": 6,
+      "type": "VHS_LoadVideoPath",
+      "pos": [
+        171,
+        239
+      ],
+      "size": [
+        320,
+        420.7188019966722
+      ],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "meta_batch",
+          "type": "VHS_BatchManager",
+          "link": null
+        },
+        {
+          "name": "vae",
+          "type": "VAE",
+          "link": 7,
+          "slot_index": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "LATENT",
+          "type": "LATENT",
+          "links": [
+            9
+          ],
+          "slot_index": 0,
+          "shape": 3
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "audio",
+          "type": "AUDIO",
+          "links": [],
+          "slot_index": 2,
+          "shape": 3
+        },
+        {
+          "name": "video_info",
+          "type": "VHS_VIDEOINFO",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideoPath"
+      },
+      "widgets_values": {
+        "video": "input/bigbuckbunny.mp4",
+        "force_rate": 8,
+        "force_size": "Disabled",
+        "custom_width": 512,
+        "custom_height": 512,
+        "frame_load_cap": 64,
+        "skip_first_frames": 0,
+        "select_every_nth": 1,
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "frame_load_cap": 64,
+            "skip_first_frames": 0,
+            "force_rate": 8,
+            "filename": "input/bigbuckbunny.mp4",
+            "type": "path",
+            "format": "video/mp4",
+            "select_every_nth": 1
+          }
+        }
+      }
+    },
+    {
+      "id": 10,
+      "type": "VAELoader",
+      "pos": [
+        -42,
+        88
+      ],
+      "size": {
+        "0": 315,
+        "1": 58
+      },
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "VAE",
+          "type": "VAE",
+          "links": [
+            7,
+            8
+          ],
+          "shape": 3,
+          "slot_index": 0
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VAELoader"
+      },
+      "widgets_values": [
+        "taesd"
+      ]
+    }
+  ],
+  "links": [
+    [
+      7,
+      10,
+      0,
+      6,
+      1,
+      "VAE"
+    ],
+    [
+      8,
+      10,
+      0,
+      7,
+      3,
+      "VAE"
+    ],
+    [
+      9,
+      6,
+      0,
+      7,
+      0,
+      "LATENT"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4,
+  "tests": {
+      "7": [{"type": "video", "key": "width", "value": 1920},
+          {"type": "video", "key": "height", "value": 1080},
+          {"type": "video", "key": "nb_read_packets", "value": "64"}
+      ],
+      "length": 1
+  }
+}

tests/simple.json

@@ -0,0 +1,134 @@
+{
+  "last_node_id": 3,
+  "last_link_id": 1,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "VHS_LoadVideo",
+      "pos": [
+        54,
+        89
+      ],
+      "size": [
+        235.1999969482422,
+        384.56999829610186
+      ],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "outputs": [
+        {
+          "name": "IMAGE",
+          "type": "IMAGE",
+          "links": [
+            1
+          ],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "frame_count",
+          "type": "INT",
+          "links": null,
+          "shape": 3
+        },
+        {
+          "name": "audio",
+          "type": "VHS_AUDIO",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "VHS_LoadVideo"
+      },
+      "widgets_values": {
+        "video": "leader.webm",
+        "force_rate": 8,
+        "force_size": "Custom Width",
+        "custom_width": 304,
+        "custom_height": 312,
+        "frame_load_cap": 16,
+        "skip_first_frames": 1,
+        "select_every_nth": 1,
+        "choose video to upload": "image",
+        "videopreview": {
+          "hidden": false,
+          "paused": false,
+          "params": {
+            "frame_load_cap": 0,
+            "skip_first_frames": 0,
+            "force_rate": 0,
+            "filename": "leader.webm",
+            "type": "input",
+            "format": "video/mp4",
+            "force_size": "410.4x?",
+            "select_every_nth": 1
+          }
+        }
+      }
+    },
+    {
+      "id": 3,
+      "type": "VHS_VideoCombine",
+      "pos": [
+        629,
+        222
+      ],
+      "size": {
+        "0": 315,
+        "1": 250
+      },
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "images",
+          "type": "IMAGE",
+          "link": 1
+        }
+      ],
+      "outputs": [],
+      "properties": {
+        "Node name for S&R": "VHS_VideoCombine"
+      },
+      "widgets_values": {
+        "frame_rate": 8,
+        "loop_count": 0,
+        "filename_prefix": "AnimateDiff",
+        "format": "video/webm",
+        "pingpong": false,
+        "save_image": false,
+        "crf": 20,
+        "save_metadata": false,
+        "audio_file": "",
+        "videopreview": {
+          "hidden": false,
+          "paused": false
+        }
+      }
+    }
+  ],
+  "links": [
+    [
+      1,
+      1,
+      0,
+      3,
+      0,
+      "IMAGE"
+    ]
+  ],
+  "groups": [],
+  "config": {},
+  "extra": {},
+  "version": 0.4,
+  "tests": {
+      "3": [{"type": "video", "key": "width", "value": 304},
+          {"type": "video", "key": "height", "value": 232},
+          {"type": "compare", "filename": "custom_nodes/ComfyUI-VideoHelperSuite/tests/outputs/simple.webm", "tolerance": 0.02}
+      ],
+      "length": 1
+  }
+}

video_formats/16bit-png.json

@@ -0,0 +1,9 @@
+{
+    "main_pass":
+    [
+        "-n",
+        "-pix_fmt", "rgba64"
+    ],
+    "input_color_depth": "16bit",
+    "extension": "%03d.png"
+}

video_formats/8bit-png.json

@@ -0,0 +1,7 @@
+{
+    "main_pass":
+    [
+        "-n"
+    ],
+    "extension": "%03d.png"
+}

video_formats/ProRes.json

@@ -0,0 +1,22 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "prores_ks",
+        "-profile:v", [["$profile"]],
+        ["profile", {
+            "lt": [[]], "1": [[]], "standard": [[]], "2": [[]], "hq": [[]], "3": [[]],
+            "4": ["has_alpha", {"True": [["-pix_fmt", "yuva444p10le"]],
+                "False": [["-pix_fmt", "yuv444p10le"]]}],
+            "4444": ["has_alpha", {"True": [["-pix_fmt", "yuva444p10le"]],
+                "False": [["-pix_fmt", "yuv444p10le"]]}],
+            "4444xq": ["has_alpha", {"True": [["-pix_fmt", "yuva444p10le"]],
+                "False": [["-pix_fmt", "yuv444p10le"]]}]
+        }],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "pcm_s16le"],
+    "extension": "mov",
+    "extra_widgets": [["profile", ["lt", "standard", "hq", "4444", "4444xq"], {"default": "hq"}]]
+}

video_formats/av1-webm.json

@@ -0,0 +1,16 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "libsvtav1",
+        "-pix_fmt", ["pix_fmt", ["yuv420p10le", "yuv420p"]],
+        "-crf", ["crf","INT", {"default": 23, "min": 0, "max": 100, "step": 1}],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "libopus"],
+    "input_color_depth": ["input_color_depth", ["8bit", "16bit"]],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "webm",
+    "environment": {"SVT_LOG": "1"}
+}

video_formats/ffmpeg-gif.json

@@ -0,0 +1,8 @@
+{
+    "main_pass":
+    [
+        "-n",
+        "-filter_complex", ["dither", ["bayer", "heckbert", "floyd_steinberg", "sierra2", "sierra2_4a", "sierra3", "burkes", "atkinson", "none"], {"default": "sierra2_4a"}, "[0:v] split [a][b]; [a] palettegen=reserve_transparent=on:transparency_color=ffffff [p]; [b][p] paletteuse=dither=$val"]
+    ],
+    "extension": "gif"
+}

video_formats/ffv1-mkv.json

@@ -0,0 +1,17 @@
+{
+    "main_pass": [
+        "-n",
+        "-c:v", "ffv1",
+        "-level", ["level", ["0", "1", "3"], {"default": "3"}],
+        "-coder", ["coder", ["0", "1", "2"], {"default": "1"}],
+        "-context", ["context", ["0", "1"], {"default": "1"}],
+        "-g", ["gop_size", "INT", {"default": 1, "min": 1, "max": 300, "step": 1}],
+        "-slices", ["slices", ["4", "6", "9", "12", "16", "20", "24", "30"], {"default": "16"}],
+        "-slicecrc", ["slicecrc", ["0", "1"], {"default": "1"}],
+        "-pix_fmt", ["pix_fmt", ["bgra", "rgba64le", "yuv420p", "yuv422p", "yuv444p", "yuva420p", "yuva422p", "yuva444p", "yuv420p10le", "yuv422p10le", "yuv444p10le", "yuv420p12le", "yuv422p12le", "yuv444p12le", "yuv420p14le", "yuv422p14le", "yuv444p14le", "yuv420p16le", "yuv422p16le", "yuv444p16le", "gray", "gray10le", "gray12le", "gray16le"], {"default": "bgra"}]
+    ],
+    "audio_pass": ["-c:a", "flac"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "trim_to_audio": ["trim_to_audio", "BOOLEAN", {"default": false}],
+    "extension": "mkv"
+}

video_formats/gifski.json

@@ -0,0 +1,12 @@
+{
+    "main_pass":
+    [
+        "-pix_fmt", "yuv444p",
+        "-vf", "scale=out_color_matrix=bt709:out_range=pc",
+        "-color_range", "pc"
+    ],
+    "extension": "gif",
+    "gifski_pass": [
+        "-Q", ["quality","INT", {"default": 90, "min": 1, "max": 100, "step": 1}]
+    ]
+}

video_formats/h264-mp4.json

@@ -0,0 +1,15 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "libx264",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "yuv420p10le"]],
+        "-crf", ["crf","INT", {"default": 19, "min": 0, "max": 100, "step": 1}],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "trim_to_audio": ["trim_to_audio", "BOOLEAN", {"default": false}],
+    "extension": "mp4"
+}

video_formats/h265-mp4.json

@@ -0,0 +1,17 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "libx265",
+        "-vtag", "hvc1",
+        "-pix_fmt", ["pix_fmt", ["yuv420p10le", "yuv420p"]],
+        "-crf", ["crf","INT", {"default": 22, "min": 0, "max": 100, "step": 1}],
+        "-preset", "medium",
+        "-x265-params", "log-level=quiet",
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

video_formats/nvenc_av1-mp4.json

@@ -0,0 +1,15 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "av1_nvenc",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "p010le"]],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "bitrate": ["bitrate","INT", {"default": 10, "min": 1, "max": 999, "step": 1 }],
+    "megabit": ["megabit","BOOLEAN", {"default": true}],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

video_formats/nvenc_h264-mp4.json

@@ -0,0 +1,15 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "h264_nvenc",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "p010le"]],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "bitrate": ["bitrate","INT", {"default": 10, "min": 1, "max": 999, "step": 1 }],
+    "megabit": ["megabit","BOOLEAN", {"default": true}],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

video_formats/nvenc_hevc-mp4.json

@@ -0,0 +1,16 @@
+{
+    "main_pass":
+    [
+        "-n", "-c:v", "hevc_nvenc",
+        "-vtag", "hvc1",
+        "-pix_fmt", ["pix_fmt", ["yuv420p", "p010le"]],
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "aac"],
+    "bitrate": ["bitrate","INT", {"default": 10, "min": 1, "max": 999, "step": 1 }],
+    "megabit": ["megabit","BOOLEAN", {"default": true}],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "extension": "mp4"
+}

video_formats/webm.json

@@ -0,0 +1,16 @@
+{
+    "main_pass":
+    [
+        "-n",
+        "-pix_fmt", ["pix_fmt",["yuv420p","yuva420p"]],
+        "-crf", ["crf","INT", {"default": 20, "min": 0, "max": 100, "step": 1}],
+        "-b:v", "0",
+        "-vf", "scale=out_color_matrix=bt709",
+        "-color_range", "tv", "-colorspace", "bt709", "-color_primaries", "bt709", "-color_trc", "bt709"
+    ],
+    "fake_trc": "bt709",
+    "audio_pass": ["-c:a", "libvorbis"],
+    "save_metadata": ["save_metadata", "BOOLEAN", {"default": true}],
+    "trim_to_audio": ["trim_to_audio", "BOOLEAN", {"default": false}],
+    "extension": "webm"
+}

videohelpersuite/batched_nodes.py

@@ -0,0 +1,56 @@
+import torch
+from nodes import VAEEncode
+from comfy.utils import ProgressBar
+
+
+class VAEDecodeBatched:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "samples": ("LATENT", ),
+                "vae": ("VAE", ),
+                "per_batch": ("INT", {"default": 16, "min": 1})
+                }
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/batched nodes"
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "decode"
+
+    def decode(self, vae, samples, per_batch):
+        decoded = []
+        pbar = ProgressBar(samples["samples"].shape[0])
+        for start_idx in range(0, samples["samples"].shape[0], per_batch):
+            decoded.append(vae.decode(samples["samples"][start_idx:start_idx+per_batch]))
+            pbar.update(per_batch)
+        return (torch.cat(decoded, dim=0), )
+
+
+class VAEEncodeBatched:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "pixels": ("IMAGE", ), "vae": ("VAE", ),
+                "per_batch": ("INT", {"default": 16, "min": 1})
+                }
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/batched nodes"
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "encode"
+
+    def encode(self, vae, pixels, per_batch):
+        t = []
+        pbar = ProgressBar(pixels.shape[0])
+        for start_idx in range(0, pixels.shape[0], per_batch):
+            try:
+                sub_pixels = vae.vae_encode_crop_pixels(pixels[start_idx:start_idx+per_batch])
+            except:
+                sub_pixels = VAEEncode.vae_encode_crop_pixels(pixels[start_idx:start_idx+per_batch])
+            t.append(vae.encode(sub_pixels[:,:,:,:3]))
+            pbar.update(per_batch)
+        return ({"samples": torch.cat(t, dim=0)}, )

videohelpersuite/documentation.py

@@ -0,0 +1,616 @@
+from .logger import logger
+
+def image(src):
+    return f'<img src={src} loading=lazy style="width: 0px; min-width: 100%">'
+def video(src):
+    return f'<video preload="none" src={src} muted loop controls controlslist="nodownload noremoteplayback noplaybackrate" style="width: 0px; min-width: 100%" class="VHS_loopedvideo">'
+def short_desc(desc):
+    return f'<div id=VHS_shortdesc>{desc}</div>'
+
+def format_each(desc, **kwargs):
+    if isinstance(desc, dict):
+        res = {}
+        for k,v in desc.items():
+            res[format_each(k, **kwargs)] = format_each(v, **kwargs)
+        return res
+    if isinstance(desc, list):
+        res = []
+        for v in desc:
+            res.append(format_each(v, **kwargs))
+        return res
+    return desc.format(**kwargs)
+def format_type(desc, lower, lowers=None, upper=None, uppers=None, cap=None):
+    """Utility function for nodes with image/latent/mask variants"""
+    if lowers is None:
+        lowers = lower + 's'
+    if cap is None:
+        cap = lower.capitalize()
+    if upper is None:
+        upper = lower.upper()
+    if uppers is None:
+        uppers = lowers.upper()
+    return format_each(desc, lower=lower, lowers=lowers, upper=upper, uppers=uppers, cap=cap)
+
+common_descriptions = {
+  'merge_strategy': [
+      'Determines what the output resolution will be if input resolutions don\'t match',
+      {'match A': 'Always use the resolution for A',
+      'match B': 'Always use the resolution for B',
+      'match smaller': 'Pick the smaller resolution by area',
+      'match larger': 'Pick the larger resolution by area',
+      }],
+  'scale_method': [
+    'Determines what method to use if scaling is required',
+ ],
+  'crop_method': 'When sizes don\'t match, should the resized image have it\'s aspect ratio changed, or be cropped to maintain aspect ratio',
+  'VHS_PATH': [
+    'This is a VHS_PATH input. When edited, it provides a list of possible valid files or directories',
+    video('https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite/assets/4284322/729b7185-1fca-41d8-bc8d-a770bb2a5ce6'),
+    'The current top-most completion may be selected with Tab',
+    'You can navigate up a directory by pressing Ctrl+B (or Ctrl+W if supported by browser)',
+    'The filter on suggested file types can be disabled by pressing Ctrl+G.',
+    'If converted to an input, this functions as a string',
+      ],
+    "GetCount": ['Get {cap} Count 🎥🅥🅗🅢', short_desc('Return the number of {lowers} in an input as an INT'),
+    {'Inputs': {
+        '{lowers}': 'The input {lower}',
+        },
+     'Outputs': {
+         'count': 'The number of {lowers} in the input',
+        },
+    }],
+    "SelectEveryNth": ['Select Every Nth {cap} 🎥🅥🅗🅢', short_desc('Keep only 1 {lower} for every interval'),
+    {'Inputs': {
+        '{lowers}': 'The input {lower}',
+        },
+     'Outputs': {
+         '{upper}': 'The output {lowers}',
+         'count': 'The number of {lowers} in the input',
+        },
+     'Widgets':{
+         'select_every_nth': 'The interval from which one frame is kept. 1 means no frames are skipped.',
+         'skip_first_{lowers}': 'A number of frames which that is skipped from the start. This applies before select_every_nth. As a result, multiple copies of the node can each have a different skip_first_frames to divide the {lower} into groups'
+        },
+    }],
+}
+
+descriptions = {
+  'VHS_VideoCombine': ['Video Combine 🎥🅥🅗🅢', short_desc('Combine an image sequence into a video'), {
+    'Inputs': {
+        'images': 'The images to be turned into a video',
+        'audio':'(optional) audio to add to the video',
+        'meta_batch': '(optional) Connect to a Meta Batch manager to divide extremely long image sequences into sub batches. See the documentation for Meta Batch Manager',
+        'vae':['(optional) If provided, the node will take latents as input instead of images. This drastically reduces the required RAM (not VRAM) when working with long (100+ frames) sequences',
+               "Unlike on Load Video, this isn't always a strict upgrade over using a standalone VAE Decode.",
+               "If you have multiple Video Combine outputs, then the VAE decode will be performed for each output node increasing execution time",
+               "If you make any change to output settings on the Video Combine (such as changing the output format), the VAE decode will be performed again as the decoded result is (by design) not cached",
+               ]
+        },
+    'Widgets':{
+        'frame_rate': 'The frame rate which will be used for the output video. Consider converting this to an input and connecting this to a Load Video with Video Info(Loaded)->fps. When including audio, failure to properly set this will result in audio desync',
+        'loop_count': 'The number of additional times the video should repeat. Can cause performance issues when used with long (100+ frames) sequences',
+        'filename_prefix': 'A prefix to add to the name of the output filename. This can include subfolders or format strings.',
+        'format': 'The output format to use. Formats starting with, \'image\' are saved with PIL, but formats starting with \'video\' utilize the video_formats system. \'video\' options require ffmpeg and selecting one frequently adds additional options to the node.',
+        'pingpong': 'Play the video normally, then repeat the video in reverse so that it \'pingpongs\' back and forth. This is frequently used to minimize the appearance of skips on very short animations.',
+        'save_output': 'Specifies if output files should be saved to the output folder, or the temporary output folder',
+         'videopreview': 'Displays a preview for the processed result. If advanced previews is enabled, the output is always converted to a format viewable from the browser. If the video has audio, it will also be previewed when moused over. Additional preview options can be accessed with right click.',
+        },
+    'Common Format Widgets': {
+        'crf': 'Determines how much to prioritize quality over filesize. Numbers vary between formats, but on each format that includes it, the default value provides visually loss less output',
+        'pix_fmt': ['The pixel format to use for output. Alternative options will often have higher quality at the cost of increased file size and reduced compatibility with external software.', {
+            'yuv420p': 'The most common and default format',
+            'yuv420p10le': 'Use 10 bit color depth. This can improve color quality when combined with 16bit input color depth',
+            'yuva420p': 'Include transparency in the output video'
+            }],
+        'input_color_depth': 'VHS supports outputting 16bit images. While this produces higher quality output, the difference usually isn\'t visible without postprocessing and it significantly increases file size and processing time.',
+        'save_metadata': 'Determines if metadata for the workflow should be included in the output video file',
+        }
+    }],
+  'VHS_LoadVideo': ['Load Video 🎥🅥🅗🅢', short_desc('Loads a video from the input folder'),
+    {'Inputs': {
+        'meta_batch': '(optional) Connect to a Meta Batch manager to divide extremely long sequences into sub batches. See the documentation for Meta Batch Manager',
+        'vae': ['(optional) If provided the node will output latents instead of images. This drastically reduces the required RAM (not VRAM) when working with long (100+ frames) sequences',
+                'Using this is strongly encouraged unless connecting to a node that requires a blue image connection such as Apply Controllnet',
+                ],
+        },
+     'Outputs': {
+         'IMAGE': 'The loaded images',
+         'frame_count': 'The length of images just returned',
+         'audio': 'The audio from the loaded video',
+         'video_info': 'Exposes additional info about the video such as the source frame rate, or the total length',
+         'LATENT': 'The loaded images pre-converted to latents. Only available when a vae is connected',
+         },
+     'Widgets': {
+         'video': 'The video file to be loaded. Lists all files with a video extension in the ComfyUI/Input folder',
+         'force_rate': 'Drops or duplicates frames so that the produced output has the target frame rate. Many motion models are trained on videos of a specific frame rate and will give better results if input matches that frame rate. If set to 0, all frames are returned. May give unusual results with inputs that have a variable frame rate like animated gifs. Reducing this value can also greatly reduce the execution time and memory requirements.',
+         'force_size': 'Previously was used to provide suggested resolutions. Instead, custom_width and custom_height can be disabled by setting to 0.',
+         'custom_width': 'Allows for an arbitrary width to be entered, cropping to maintain aspect ratio if both are set',
+         'custom_height': 'Allows for an arbitrary height to be entered, cropping to maintain aspect ratio if both are set',
+         'frame_load_cap': 'The maximum number of frames to load. If 0, all frames are loaded.',
+         'skip_first_frames': 'A number of frames which are discarded before producing output.',
+         'select_every_nth': 'Similar to frame rate. Keeps only the first of every n frames and discard the rest. Has better compatibility with variable frame rate inputs such as gifs. When combined with force_rate, select_every_nth_applies after force_rate so the resulting output has a frame rate equivalent to force_rate/select_every_nth. select_every_nth does not apply to skip_first_frames',
+         'format': 'Updates other widgets so that only values supported by the given format can be entered and provides recommended defaults.',
+         'choose video to upload': 'An upload button is provided to upload local files to the input folder',
+         'videopreview': 'Displays a preview for the selected video input. If advanced previews is enabled, this preview will reflect the frame_load_cap, force_rate, skip_first_frames, and select_every_nth values chosen. If the video has audio, it will also be previewed when moused over. Additional preview options can be accessed with right click.',
+         }
+        }],
+  'VHS_LoadVideoFFmpeg': ['Load Video FFmpeg 🎥🅥🅗🅢', short_desc('Loads a video from the input folder using ffmpeg instead of opencv'),
+    'Provides faster execution speed, transparency support, and allows specifying start time in seconds',
+    {'Inputs': {
+        'meta_batch': '(optional) Connect to a Meta Batch manager to divide extremely long sequences into sub batches. See the documentation for Meta Batch Manager',
+        'vae': ['(optional) If provided the node will output latents instead of images. This drastically reduces the required RAM (not VRAM) when working with long (100+ frames) sequences',
+                'Using this is strongly encouraged unless connecting to a node that requires a blue image connection such as Apply Controllnet',
+                ],
+        },
+     'Outputs': {
+         'IMAGE': 'The loaded images',
+         'mask': 'Transparency data from the loaded video',
+         'audio': 'The audio from the loaded video',
+         'video_info': 'Exposes additional info about the video such as the source frame rate, or the total length',
+         'LATENT': 'The loaded images pre-converted to latents. Only available when a vae is connected',
+         },
+     'Widgets': {
+         'video': 'The video file to be loaded. Lists all files with a video extension in the ComfyUI/Input folder',
+         'force_rate': 'Drops or duplicates frames so that the produced output has the target frame rate. Many motion models are trained on videos of a specific frame rate and will give better results if input matches that frame rate. If set to 0, all frames are returned. May give unusual results with inputs that have a variable frame rate like animated gifs. Reducing this value can also greatly reduce the execution time and memory requirements.',
+         'force_size': 'Previously was used to provide suggested resolutions. Instead, custom_width and custom_height can be disabled by setting to 0.',
+         'custom_width': 'Allows for an arbitrary width to be entered, cropping to maintain aspect ratio if both are set',
+         'custom_height': 'Allows for an arbitrary height to be entered, cropping to maintain aspect ratio if both are set',
+         'frame_load_cap': 'The maximum number of frames to load. If 0, all frames are loaded.',
+         'start_time': 'A timestamp, in seconds from the start of the video, to start loading frames from. ',
+         'format': 'Updates other widgets so that only values supported by the given format can be entered and provides recommended defaults.',
+         'choose video to upload': 'An upload button is provided to upload local files to the input folder',
+         'videopreview': 'Displays a preview for the selected video input. If advanced previews is enabled, this preview will reflect the frame_load_cap, force_rate, skip_first_frames, and select_every_nth values chosen. If the video has audio, it will also be previewed when moused over. Additional preview options can be accessed with right click.',
+         }
+        }],
+  'VHS_LoadVideoPath': ['Load Video (Path) 🎥🅥🅗🅢', short_desc('Loads a video from an arbitrary path'),
+    {'Inputs': {
+        'meta_batch': '(optional) Connect to a Meta Batch manager to divide extremely long sequences into sub batches. See the documentation for Meta Batch Manager',
+        'vae': ['(optional) If provided the node will output latents instead of images. This drastically reduces the required RAM (not VRAM) when working with long (100+ frames) sequences',
+                'Using this is strongly encouraged unless connecting to a node that requires a blue image connection such as Apply Controllnet',
+                ],
+        },
+     'Outputs': {
+         'IMAGE': 'The loaded images',
+         'frame_count': 'The length of images just returned',
+         'audio': 'The audio from the loaded video',
+         'video_info': 'Exposes additional info about the video such as the source frame rate, or the total length',
+         'LATENT': 'The loaded images pre-converted to latents. Only available when a vae is connected',
+         },
+     'Widgets': {
+         'video': ['The video file to be loaded.', 'You can also select an image to load it as a single frame'] + common_descriptions['VHS_PATH'],
+         'force_rate': 'Drops or duplicates frames so that the produced output has the target frame rate. Many motion models are trained on videos of a specific frame rate and will give better results if input matches that frame rate. If set to 0, all frames are returned. May give unusual results with inputs that have a variable frame rate like animated gifs. Reducing this value can also greatly reduce the execution time and memory requirements.',
+         'force_size': 'Previously was used to provide suggested resolutions. Instead, custom_width and custom_height can be disabled by setting to 0.',
+         'custom_width': 'Allows for an arbitrary width to be entered, cropping to maintain aspect ratio if both are set',
+         'custom_height': 'Allows for an arbitrary height to be entered, cropping to maintain aspect ratio if both are set',
+         'frame_load_cap': 'The maximum number of frames to load. If 0, all frames are loaded.',
+         'skip_first_frames': 'A number of frames which are discarded before producing output.',
+         'select_every_nth': 'Similar to frame rate. Keeps only the first of every n frames and discard the rest. Has better compatibility with variable frame rate inputs such as gifs. When combined with force_rate, select_every_nth_applies after force_rate so the resulting output has a frame rate equivalent to force_rate/select_every_nth. select_every_nth does not apply to skip_first_frames',
+         'format': 'Updates other widgets so that only values supported by the given format can be entered and provides recommended defaults.',
+         'videopreview': 'Displays a preview for the selected video input. Will only be shown if Advanced Previews is enabled. This preview will reflect the frame_load_cap, force_rate, skip_first_frames, and select_every_nth values chosen. If the video has audio, it will also be previewed when moused over. Additional preview options can be accessed with right click.',
+         }
+        }],
+  'VHS_LoadVideoFFmpegPath': ['Load Video FFmpeg (Path) 🎥🅥🅗🅢', short_desc('Loads a video from an arbitrary path using ffmpeg instead of opencv'),
+    'Provides faster execution speed, transparency support, and allows specifying start time in seconds',
+    {'Inputs': {
+        'meta_batch': '(optional) Connect to a Meta Batch manager to divide extremely long sequences into sub batches. See the documentation for Meta Batch Manager',
+        'vae': ['(optional) If provided the node will output latents instead of images. This drastically reduces the required RAM (not VRAM) when working with long (100+ frames) sequences',
+                'Using this is strongly encouraged unless connecting to a node that requires a blue image connection such as Apply Controllnet',
+                ],
+        },
+     'Outputs': {
+         'IMAGE': 'The loaded images',
+         'mask': 'Transparency data from the loaded video',
+         'audio': 'The audio from the loaded video',
+         'video_info': 'Exposes additional info about the video such as the source frame rate, or the total length',
+         'LATENT': 'The loaded images pre-converted to latents. Only available when a vae is connected',
+         },
+     'Widgets': {
+         'video': ['The video file to be loaded.', 'You can also select an image to load it as a single frame'] + common_descriptions['VHS_PATH'],
+         'force_rate': 'Drops or duplicates frames so that the produced output has the target frame rate. Many motion models are trained on videos of a specific frame rate and will give better results if input matches that frame rate. If set to 0, all frames are returned. May give unusual results with inputs that have a variable frame rate like animated gifs. Reducing this value can also greatly reduce the execution time and memory requirements.',
+         'force_size': 'Previously was used to provide suggested resolutions. Instead, custom_width and custom_height can be disabled by setting to 0.',
+         'custom_width': 'Allows for an arbitrary width to be entered, cropping to maintain aspect ratio if both are set',
+         'custom_height': 'Allows for an arbitrary height to be entered, cropping to maintain aspect ratio if both are set',
+         'frame_load_cap': 'The maximum number of frames to load. If 0, all frames are loaded.',
+         'skip_first_frames': 'A number of frames which are discarded before producing output.',
+         'select_every_nth': 'Similar to frame rate. Keeps only the first of every n frames and discard the rest. Has better compatibility with variable frame rate inputs such as gifs. When combined with force_rate, select_every_nth_applies after force_rate so the resulting output has a frame rate equivalent to force_rate/select_every_nth. select_every_nth does not apply to skip_first_frames',
+         'format': 'Updates other widgets so that only values supported by the given format can be entered and provides recommended defaults.',
+         'videopreview': 'Displays a preview for the selected video input. Will only be shown if Advanced Previews is enabled. This preview will reflect the frame_load_cap, force_rate, skip_first_frames, and select_every_nth values chosen. If the video has audio, it will also be previewed when moused over. Additional preview options can be accessed with right click.',
+         }
+        }],
+  'VHS_LoadImages': ['Load Images 🎥🅥🅗🅢', short_desc('Loads a sequence of images from a subdirectory of the input folder'),
+    {'Inputs': {
+        'meta_batch': '(optional) Connect to a Meta Batch manager to divide extremely long sequences into sub batches. See the documentation for Meta Batch Manager',
+        },
+     'Outputs': {
+         'IMAGE': 'The loaded images',
+         'MASK': 'The alpha channel of the loaded images.',
+         'frame_count': 'The length of images just returned',
+         },
+     'Widgets': {
+         'directory': 'The directory images will be loaded from. Filtered to process jpg, png, ppm, bmp, tif, and webp files',
+         'image_load_cap': 'The maximum number of images to load. If 0, all images are loaded.',
+         'start_time': 'A timestamp, in seconds from the start of the video, to start loading frames from. ',
+         'choose folder to upload': 'An upload button is provided to upload a local folder containing images to the input folder',
+         'videopreview': 'Displays a preview for the selected video input. Will only be shown if Advanced Previews is enabled. This preview will reflect the image_load_cap, skip_first_images, and select_every_nth values chosen. Additional preview options can be accessed with right click.',
+         }
+        }],
+  'VHS_LoadImagesPath': ['Load Images (Path) 🎥🅥🅗🅢', short_desc('Loads a sequence of images from an arbitrary path'),
+    {'Inputs': {
+        'meta_batch': '(optional) Connect to a Meta Batch manager to divide extremely long sequences into sub batches. See the documentation for Meta Batch Manager',
+        },
+     'Outputs': {
+         'IMAGE': 'The loaded images',
+         'MASK': 'The alpha channel of the loaded images.',
+         'frame_count': 'The length of images just returned',
+         },
+     'Widgets': {
+         'directory': ['The directory images will be loaded from. Filtered to process jpg, png, ppm, bmp, tif, and webp files'] + common_descriptions['VHS_PATH'],
+         'image_load_cap': 'The maximum number of images to load. If 0, all images are loaded.',
+         'skip_first_images': 'A number of images which are discarded before producing output.',
+         'select_every_nth': 'Keeps only the first of every n frames and discard the rest.',
+         'videopreview': 'Displays a preview for the selected video input. Will only be shown if Advanced Previews is enabled. This preview will reflect the image_load_cap, skip_first_images, and select_every_nth values chosen. Additional preview options can be accessed with right click.',
+         }
+        }],
+  'VHS_LoadImagePath': ['Load Image (Path) 🎥🅥🅗🅢', short_desc('Load a single image from a given path'),
+    {'Inputs': {
+        'vae': '(optional) If provided the node will output latents instead of images.',
+        },
+     'Outputs': {
+         'IMAGE': 'The loaded images',
+         'MASK': 'The alpha channel of the loaded images.',
+         },
+     'Widgets': {
+         'image': ['The image file to be loaded.'] + common_descriptions['VHS_PATH'],
+         'force_size': ['Allows for conveniently scaling the input without requiring an additional node. Provides options to maintain aspect ratio or conveniently target common training formats for Animate Diff', {'custom_width': 'Allows for an arbitrary width to be entered, cropping to maintain aspect ratio if both are set',
+               'custom_height': 'Allows for an arbitrary height to be entered, cropping to maintain aspect ratio if both are set'}],
+         'videopreview': 'Displays a preview for the selected video input. Will only be shown if Advanced Previews is enabled. This preview will reflect the image_load_cap, skip_first_images, and select_every_nth values chosen. Additional preview options can be accessed with right click.',
+         }
+        }],
+  "VHS_LoadAudio": ['Load Audio (Path) 🎥🅥🅗🅢', short_desc('Loads an audio file from an arbitrary path'),
+    {'Outputs': {
+         'audio': 'The loaded audio',
+         },
+     'Widgets': {
+         'audio_file': ['The audio file to be loaded.'] + common_descriptions['VHS_PATH'],
+         'seek_seconds': 'An offset from the start of the sound file that the audio should start from',
+         }
+        }],
+  "VHS_LoadAudioUpload": ['Load Audio (Upload) 🎥🅥🅗🅢', short_desc('Loads an audio file from the input directory'),
+    "Very similar in functionality to the built-in LoadAudio. It was originally added before VHS swapped to use Comfy's internal AUDIO format, but provides the additional options for start time and duration",
+    {'Outputs': {
+         'audio': 'The loaded audio',
+         },
+     'Widgets': {
+         'audio': 'The audio file to be loaded.',
+         'start_time': 'An offset from the start of the sound file that the audio should start from',
+         'duration': 'A maximum limit for the audio. Disabled if 0',
+         'choose audio to upload': 'An upload button is provided to upload an audio file to the input folder',
+         }
+        }],
+  "VHS_AudioToVHSAudio": ['Audio to legacy VHS_AUDIO 🎥🅥🅗🅢', short_desc('utility function for compatibility with external nodes'),
+    "VHS used to use an internal VHS_AUDIO format for routing audio between inputs and outputs. This format was intended to only be used internally and was designed with a focus on performance over ease of use. Since ComfyUI now has an internal AUDIO format, VHS now uses this format. However, some custom node packs were made that are external to both ComfyUI and VHS that use VHS_AUDIO. This node was added so that those external nodes can still function",
+    {'Inputs': {
+        'audio': 'An input in the standardized AUDIO format',
+        },
+     'Outputs': {
+         'vhs_audio': 'An output in the legacy VHS_AUDIO format for use with external nodes',
+         },
+        }],
+  "VHS_VHSAudioToAudio": ['Legacy VHS_AUDIO to Audio 🎥🅥🅗🅢', short_desc('utility function for compatibility with external nodes'),
+    "VHS used to use an internal VHS_AUDIO format for routing audio between inputs and outputs. This format was intended to only be used internally and was designed with a focus on performance over ease of use. Since ComfyUI now has an internal AUDIO format, VHS now uses this format. However, some custom node packs were made that are external to both ComfyUI and VHS that use VHS_AUDIO. This node was added so that those external nodes can still function",
+    {'Inputs': {
+        'vhs_audio': 'An input in the legacy VHS_AUDIO format produced by an external node',
+        },
+     'Outputs': {
+         'vhs_audio': 'An output in the standardized AUDIO format',
+         },
+        }],
+  "VHS_PruneOutputs": ['Prune Outputs 🎥🅥🅗🅢', short_desc('Automates deletion of undesired outputs from a Video Combine node.'),
+    'Video Combine produces a number of file outputs in addition to the final output. Some of these, such as a video file without audio included, are implementation limitations and are not feasible to solve. As an alternative, the Prune Outputs node is added to automate the deletion of these file outputs if they are not desired',
+    {'Inputs': {
+        'filenames': 'A connection from a Video Combine node to indicate which outputs should be pruned',
+        },
+     'Widgets': {
+         'options': ['Which files should be deleted',
+             {'Intermediate': 'Delete any files that were required for intermediate processing but are not the final output, like the no-audio output file when audio is included',
+              'Intermediate and Utility': 'Delete all produced files that aren\'t the final output, including the first frame png',
+         }]}
+     }],
+  "VHS_BatchManager": ['Meta Batch Manager 🎥🅥🅗🅢', short_desc('Split the processing of a very long video into sets of smaller Meta Batches'),
+    "The Meta Batch Manager allows for extremely long input videos to be processed when all other methods for fitting the content in RAM fail. It does not effect VRAM usage.",
+    "It must be connected to at least one Input (a Load Video or Load Images) AND at least one Video Combine",
+    image("https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite/assets/4284322/7cb3fb7e-59d8-4cb2-a09f-9c6698de8b1f"),
+    "It functions by holding both the inputs and ouputs open between executions, and automatically requeue's the workflow until one of the inputs is unable to provide additional images.",
+    "Because each sub execution only contains a subset of the total frames, each sub execution creates a hard window which temporal smoothing can not be applied across. This results in jumps in the output.",
+    {'Outputs': {
+         'meta_batch': 'Add all connected nodes to this Meta Batch',
+         },
+     'Widgets': {
+         'frames_per_batch': 'How many frames to process for each sub execution. If loading as image, each frame will use about 50MB of RAM (not VRAM), and this can safely be set in the 100-1000 range, depending on available memory. When loading and combining from latent space (no blue image noodles exist), this value can be much higher, around the 2,000 to 20,000 range',
+         }
+        }],
+  "VHS_VideoInfo": ['Video Info 🎥🅥🅗🅢', short_desc('Splits information on a video into a numerous outputs'),
+    {'Inputs': {
+        'video_info': 'A connection to a Load Video node',
+        },
+     'Outputs': {
+         'source_fps🟨': 'The frame rate of the video',
+         'source_frame_count🟨': 'How many total frames the video contains before accounting for frame rate or select_every_nth',
+         'source_duration🟨': 'The length of images just returned in seconds',
+         'source_width🟨': 'The width',
+         'source_height🟨': 'The height',
+         'loaded_fps🟦': 'The frame rate after accounting for force_rate and select_every_nth. This output is of particular use as it can be connected to the converted frame_rate input of a Video Combine node to ensure audio remains synchronized.',
+         'loaded_frame_count🟦': 'The number of frames returned by the current execution. Identical to the frame_count returned by the node itself',
+         'loaded_duration🟦': 'The duration in seconds of returned images after accounting for frame_load_cap',
+         'loaded_width🟦': 'The width of the video after scaling. These coordinates are in image space even if loading to latent space',
+         'loaded_height🟦': 'The height of the video after scaling. These coordinates are in image space even if loading to latent space',
+         },
+        }],
+  "VHS_VideoInfoSource": ['Video Info Source 🎥🅥🅗🅢', short_desc('Splits information on a video into a numerous outputs describing the file itself without accounting for load options'),
+    {'Inputs': {
+        'video_info': 'A connection to a Load Video node',
+        },
+     'Outputs': {
+         'source_fps🟨': 'The frame rate of the video',
+         'source_frame_count🟨': 'How many total frames the video contains before accounting for frame rate or select_every_nth',
+         'source_duration🟨': 'The length of images just returned in seconds',
+         'source_width🟨': 'The original width',
+         'source_height🟨': 'The original height',
+         }
+     }],
+  "VHS_VideoInfoLoaded": ['Video Info Loaded 🎥🅥🅗🅢', short_desc('Splits information on a video into a numerous outputs describing the file itself after accounting for load options'),
+    {'Inputs': {
+        'video_info': 'A connection to a Load Video node',
+        },
+     'Outputs': {
+         'loaded_fps🟦': 'The frame rate after accounting for force_rate and select_every_nth. This output is of particular use as it can be connected to the converted frame_rate input of a Video Combine node to ensure audio remains synchronized.',
+         'loaded_frame_count🟦': 'The number of frames returned by the current execution. Identical to the frame_count returned by the node itself',
+         'loaded_duration🟦': 'The duration in seconds of returned images after accounting for frame_load_cap',
+         'loaded_width🟦': 'The width of the video after scaling. This is the dimension of the corresponding image even if loading as a latent directly',
+         'loaded_height🟦': 'The height of the video after scaling. This is the dimension of the corresponding image even if loading as a latent directly',
+         }
+     }],
+  "VHS_SelectFilename": ['VAE Select Filename 🎥🅥🅗🅢', short_desc('Select a single filename from the VHS_FILENAMES output by a Video Combine and return it as a string'),
+    'Take care when combining this node with Prune Outputs. The VHS_FILENAMES object is immutable and will always contain the full list of output files, but execution order is undefined behavior (currently, Prune Outputs will generally execute first) and SelectFilename may return a path to a file that no longer exists.',
+    {'Inputs': {
+        'filenames': 'A VHS_FILENAMES from a Video Combine node',
+        },
+     'Outputs': {
+         'filename': 'A string representation of the full output path for the chosen file',
+        },
+     'Widgets': {
+         'index': 'The index of which file should be selected. The default, -1, chooses the most complete output',
+        },
+     }],
+    # Batched Nodes
+  "VHS_VAEEncodeBatched": ['VAE Encode Batched 🎥🅥🅗🅢', short_desc('Encode images as latents with a manually specified batch size.'),
+    "Some people have ran into VRAM issues when encoding or decoding large batches of images. As a workaround, this node lets you manually set a batch size when encoding images.",
+    "Unless these issues have been encountered, it is simpler to use the native VAE Encode or to encode directly from a Load Video",
+    {'Inputs': {
+        'pixels': 'The images to be encoded.',
+        'vae': 'The VAE to use when encoding.',
+        },
+     'Outputs': {
+         'LATENT': 'The encoded latents.',
+        },
+     'Widgets': {
+         'per_batch': 'The maximum number of images to encode in each batch.',
+        },
+     }],
+  "VHS_VAEDecodeBatched": ['VAE Decode Batched 🎥🅥🅗🅢', short_desc('Decode latents to images with a manually specified batch size'),
+    "Some people have ran into VRAM issues when encoding or decoding large batches of images. As a workaround, this node lets you manually set a batch size when decoding latents.",
+    "Unless these issues have been encountered, it is simpler to use the native VAE Decode or to decode from a Video Combine directly",
+    {'Inputs': {
+        'samples': 'The latents to be decoded.',
+        'vae': 'The VAE to use when decoding.',
+        },
+     'Outputs': {
+         'IMAGE': 'The decoded images.',
+        },
+     'Widgets': {
+         'per_batch': 'The maximum number of images to decode in each batch.',
+        },
+     }],
+    # Latent and Image nodes
+  "VHS_SplitLatents": ['Split Latents 🎥🅥🅗🅢', short_desc('Split a set of latents into two groups'),
+    {'Inputs': {
+        'latents': 'The latents to be split.',
+        },
+     'Outputs': {
+         'LATENT_A': 'The first group of latents',
+         'A_count': 'The number of latents in group A. This will be equal to split_index unless the latents input has length less than split_index',
+         'LATENT_B': 'The second group of latents',
+         'B_count': 'The number of latents in group B'
+        },
+     'Widgets': {
+        'split_index': 'The index of the first latent that will be in the second output groups.',
+        },
+
+    }],
+    "VHS_SplitImages": ['Split Images 🎥🅥🅗🅢', short_desc('Split a set of images into two groups'),
+    {'Inputs': {
+        'images': 'The images to be split.',
+        },
+     'Outputs': {
+         'IMAGE_A': 'The first group of images',
+         'A_count': 'The number of images in group A. This will be equal to split_index unless the images input has length less than split_index',
+         'IMAGE_B': 'The second group of images',
+         'B_count': 'The number of images in group B'
+        },
+     'Widgets': {
+        'split_index': 'The index of the first latent that will be in the second output groups.',
+        },
+
+    }],
+    "VHS_SplitMasks": ['Split Masks 🎥🅥🅗🅢', short_desc('Split a set of masks into two groups'),
+    {'Inputs': {
+        'mask': 'The masks to be split.',
+        },
+     'Outputs': {
+         'MASK_A': 'The first group of masks',
+         'A_count': 'The number of masks in group A. This will be equal to split_index unless the mask input has length less than split_index',
+         'MASK_B': 'The second group of masks',
+         'B_count': 'The number of masks in group B'
+        },
+     'Widgets': {
+        'split_index': 'The index of the first latent that will be in the second output groups.',
+        },
+
+    }],
+    "VHS_MergeLatents": ['Merge Latents 🎥🅥🅗🅢', short_desc('Combine two groups of latents into a single group of latents'),
+    {'Inputs': {
+        'latents_A': 'The first group of latents',
+        'latents_B': 'The first group of latents',
+        },
+     'Outputs': {
+         'LATENT': 'The combined group of latents',
+         'count': 'The length of the combined group',
+        },
+     'Widgets': {
+        'merge_strategy': common_descriptions['merge_strategy'],
+        'scale_method': common_descriptions['scale_method'],
+        'crop': common_descriptions['crop_method'],
+        },
+
+    }],
+    "VHS_MergeImages": ['Merge Images 🎥🅥🅗🅢', short_desc('Combine two groups of images into a single group of images'),
+    {'Inputs': {
+        'images_A': 'The first group of images',
+        'images_B': 'The first group of images',
+        },
+     'Outputs': {
+         'IMAGE': 'The combined group of images',
+         'count': 'The length of the combined group',
+        },
+     'Widgets': {
+        'merge_strategy': common_descriptions['merge_strategy'],
+        'scale_method': common_descriptions['scale_method'],
+        'crop': common_descriptions['crop_method'],
+        },
+
+    }],
+    "VHS_MergeMasks": ['Merge Masks 🎥🅥🅗🅢', short_desc('Combine two groups of masks into a single group of masks'),
+    {'Inputs': {
+        'mask_A': 'The first group of masks',
+        'mask_B': 'The first group of masks',
+        },
+     'Outputs': {
+         'MASK': 'The combined group of masks',
+         'count': 'The length of the combined group',
+        },
+     'Widgets': {
+        'merge_strategy': common_descriptions['merge_strategy'],
+        'scale_method': common_descriptions['scale_method'],
+        'crop': common_descriptions['crop_method'],
+        },
+
+    }],
+    "VHS_GetLatentCount": format_type(common_descriptions['GetCount'], 'latent'),
+    "VHS_GetImageCount": format_type(common_descriptions['GetCount'], 'image'),
+    "VHS_GetMaskCount": format_type(common_descriptions['GetCount'], 'mask'),
+    "VHS_DuplicateLatents": ['Repeat Latents 🎥🅥🅗🅢', short_desc('Append copies of a latent to itself so it repeats'),
+    {'Inputs': {
+        'latents': 'The latents to be repeated',
+        },
+     'Outputs': {
+         'LATENT': 'The latent with repeats',
+         'count': 'The number of latents in the output. Equal to the length of the input latent * multiply_by',
+        },
+     'Widgets': {
+        'multiply_by': 'Controls the number of times the latent should repeat. 1, the default, means no change.',
+        },
+    }],
+    "VHS_DuplicateImages": ['Repeat Images 🎥🅥🅗🅢', short_desc('Append copies of a image to itself so it repeats'),
+    {'Inputs': {
+        'IMAGES': 'The image to be repeated',
+        },
+     'Outputs': {
+         'IMAGE': 'The image with repeats',
+         'count': 'The number of image in the output. Equal to the length of the input image * multiply_by',
+        },
+     'Widgets': {
+        'multiply_by': 'Controls the number of times the mask should repeat. 1, the default, means no change.',
+        },
+    }],
+    "VHS_DuplicateMasks": ['Repeat Masks 🎥🅥🅗🅢', short_desc('Append copies of a mask to itself so it repeats'),
+    {'Inputs': {
+        'masks': 'The masks to be repeated',
+        },
+     'Outputs': {
+         'LATENT': 'The mask with repeats',
+         'count': 'The number of mask in the output. Equal to the length of the input mask * multiply_by',
+        },
+     'Widgets': {
+        'multiply_by': 'Controls the number of times the mask should repeat. 1, the default, means no change.',
+        },
+    }],
+    "VHS_SelectEveryNthLatent": format_type(common_descriptions['SelectEveryNth'], 'latent'),
+    "VHS_SelectEveryNthImage": format_type(common_descriptions['SelectEveryNth'], 'image'),
+    #TODO: fix discrepency of input being mask instead of masks?
+    "VHS_SelectEveryNthMask": format_type(common_descriptions['SelectEveryNth'], 'mask', lowers='mask'),
+    #TODO: port documentation for select nodes to new system
+    #"VHS_SelectLatents": None,
+    #"VHS_SelectImages": None,
+    #"VHS_SelectMasks": None,
+  "VHS_Unbatch": ['Unbatch 🎥🅥🅗🅢', short_desc('Unbatch a list of items into a single concatenated item'),
+    "Useful for when you want a single video output from a complex workflow",
+    "Has no relation to the Meta Batch system of VHS",
+    {'Inputs': {
+        'batched': 'Any input which may or may not be batched',
+        },
+     'Outputs': {
+         'unbatched': 'A single output element. Torch tensors are concatenated across dim 0, all other types are added which functions as concatenation for strings and arrays, but may give undesired results for other types',
+        },
+    }],
+  "VHS_SelectLatest": ['Select Latest 🎥🅥🅗🅢', short_desc('Experimental virtual node to select the most recently modified file from a given folder'),
+    "Assists in the creation of workflows where outputs from one execution are used elsewhere in subsequent executions.",
+    {'Inputs': {
+        'filename_prefix': 'A path which can consist of a combination of folders and a prefix which candidate files must match',
+        'filename_postfix': 'A string which chich the selected file must end with. Useful for limiting to a target extension.',
+        },
+     'Outputs': {
+         'Filename': 'A string representing a file path to the most recently modified file.',
+        },
+    }],
+}
+
+def as_html(entry, depth=0):
+    if isinstance(entry, dict):
+        size = 0.8 if depth < 2 else 1
+        html = ''
+        for k in entry:
+            if k == "collapsed":
+                continue
+            collapse_single = k.endswith("_collapsed")
+            if collapse_single:
+                name = k[:-len("_collapsed")]
+            else:
+                name = k
+            collapse_flag = ' VHS_precollapse' if entry.get("collapsed", False) or collapse_single else ''
+            html += f'<div vhs_title=\"{name}\" style=\"display: flex; font-size: {size}em\" class=\"VHS_collapse{collapse_flag}\"><div style=\"color: #AAA; height: 1.5em;\">[<span style=\"font-family: monospace\">-</span>]</div><div style=\"width: 100%\">{name}: {as_html(entry[k], depth=depth+1)}</div></div>'
+        return html
+    if isinstance(entry, list):
+        if depth == 0:
+            depth += 1
+            size = .8
+        else:
+            size = 1
+        html = ''
+        html += entry[0]
+        for i in entry[1:]:
+            html += f'<div style=\"font-size: {size}em\">{as_html(i, depth=depth)}</div>'
+        return html
+    return str(entry)
+
+def format_descriptions(nodes):
+    for k in descriptions:
+        if k.endswith("_collapsed"):
+            k = k[:-len("_collapsed")]
+        nodes[k].DESCRIPTION = as_html(descriptions[k])
+    undocumented_nodes = []
+    for k in nodes:
+        if not hasattr(nodes[k], "DESCRIPTION"):
+            undocumented_nodes.append(k)
+    if len(undocumented_nodes) > 0:
+        logger.warning('Some nodes have not been documented %s', undocumented_nodes)
+

videohelpersuite/image_latent_nodes.py

@@ -0,0 +1,554 @@
+from torch import Tensor
+import torch
+
+import comfy.utils
+
+from .utils import BIGMIN, BIGMAX, select_indexes_from_str, convert_str_to_indexes, select_indexes
+
+
+class MergeStrategies:
+    MATCH_A = "match A"
+    MATCH_B = "match B"
+    MATCH_SMALLER = "match smaller"
+    MATCH_LARGER = "match larger"
+
+    list_all = [MATCH_A, MATCH_B, MATCH_SMALLER, MATCH_LARGER]
+
+
+class ScaleMethods:
+    NEAREST_EXACT = "nearest-exact"
+    BILINEAR = "bilinear"
+    AREA = "area"
+    BICUBIC = "bicubic"
+    BISLERP = "bislerp"
+
+    list_all = [NEAREST_EXACT, BILINEAR, AREA, BICUBIC, BISLERP]
+
+
+class CropMethods:
+    DISABLED = "disabled"
+    CENTER = "center"
+
+    list_all = [DISABLED, CENTER]
+
+
+class SplitLatents:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "latents": ("LATENT",),
+                    "split_index": ("INT", {"default": 0, "step": 1, "min": BIGMIN, "max": BIGMAX}),
+                },
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/latent"
+
+    RETURN_TYPES = ("LATENT", "INT", "LATENT", "INT")
+    RETURN_NAMES = ("LATENT_A", "A_count", "LATENT_B", "B_count")
+    FUNCTION = "split_latents"
+
+    def split_latents(self, latents: dict[str, Tensor], split_index: int):
+        latents_len = len(latents["samples"])
+        group_a = latents.copy()
+        group_b = latents.copy()
+        for key, val in latents.items():
+            if type(val) == Tensor and len(val) == latents_len:
+                group_a[key] = latents[key][:split_index]
+                group_b[key] = latents[key][split_index:]
+        return (group_a, group_a["samples"].size(0), group_b, group_b["samples"].size(0))
+
+
+class SplitImages:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "images": ("IMAGE",),
+                    "split_index": ("INT", {"default": 0, "step": 1, "min": BIGMIN, "max": BIGMAX}),
+                },
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/image"
+
+    RETURN_TYPES = ("IMAGE", "INT", "IMAGE", "INT")
+    RETURN_NAMES = ("IMAGE_A", "A_count", "IMAGE_B", "B_count")
+    FUNCTION = "split_images"
+
+    def split_images(self, images: Tensor, split_index: int):
+        group_a = images[:split_index]
+        group_b = images[split_index:]
+        return (group_a, group_a.size(0), group_b, group_b.size(0))
+
+
+class SplitMasks:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "mask": ("MASK",),
+                    "split_index": ("INT", {"default": 0, "step": 1, "min": BIGMIN, "max": BIGMAX}),
+                },
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/mask"
+
+    RETURN_TYPES = ("MASK", "INT", "MASK", "INT")
+    RETURN_NAMES = ("MASK_A", "A_count", "MASK_B", "B_count")
+    FUNCTION = "split_masks"
+
+    def split_masks(self, mask: Tensor, split_index: int):
+        group_a = mask[:split_index]
+        group_b = mask[split_index:]
+        return (group_a, group_a.size(0), group_b, group_b.size(0))
+
+
+class MergeLatents:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "latents_A": ("LATENT",),
+                "latents_B": ("LATENT",),
+                "merge_strategy": (MergeStrategies.list_all,),
+                "scale_method": (ScaleMethods.list_all,),
+                "crop": (CropMethods.list_all,),
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/latent"
+
+    RETURN_TYPES = ("LATENT", "INT",)
+    RETURN_NAMES = ("LATENT", "count",)
+    FUNCTION = "merge"
+
+    def merge(self, latents_A: dict, latents_B: dict, merge_strategy: str, scale_method: str, crop: str):
+        latents = []
+        latents_A = latents_A.copy()["samples"]
+        latents_B = latents_B.copy()["samples"]
+
+        # TODO: handle other properties on latents besides just "samples"
+        # if not same dimensions, do scaling
+        if latents_A.shape[3] != latents_B.shape[3] or latents_A.shape[2] != latents_B.shape[2]:
+            A_size = latents_A.shape[3] * latents_A.shape[2]
+            B_size = latents_B.shape[3] * latents_B.shape[2]
+            # determine which to use
+            use_A_as_template = True
+            if merge_strategy == MergeStrategies.MATCH_A:
+                pass
+            elif merge_strategy == MergeStrategies.MATCH_B:
+                use_A_as_template = False
+            elif merge_strategy in (MergeStrategies.MATCH_SMALLER, MergeStrategies.MATCH_LARGER):
+                if A_size <= B_size:
+                    use_A_as_template = True if merge_strategy == MergeStrategies.MATCH_SMALLER else False
+            # apply scaling
+            if use_A_as_template:
+                latents_B = comfy.utils.common_upscale(latents_B, latents_A.shape[3], latents_A.shape[2], scale_method, crop)
+            else:
+                latents_A = comfy.utils.common_upscale(latents_A, latents_B.shape[3], latents_B.shape[2], scale_method, crop)
+
+        latents.append(latents_A)
+        latents.append(latents_B)
+
+        merged = {"samples": torch.cat(latents, dim=0)}
+        return (merged, len(merged["samples"]),)
+
+
+class MergeImages:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "images_A": ("IMAGE",),
+                "images_B": ("IMAGE",),
+                "merge_strategy": (MergeStrategies.list_all,),
+                "scale_method": (ScaleMethods.list_all,),
+                "crop": (CropMethods.list_all,),
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/image"
+
+    RETURN_TYPES = ("IMAGE", "INT",)
+    RETURN_NAMES = ("IMAGE", "count",)
+    FUNCTION = "merge"
+
+    def merge(self, images_A: Tensor, images_B: Tensor, merge_strategy: str, scale_method: str, crop: str):
+        images = []
+        # if not same dimensions, do scaling
+        if images_A.shape[3] != images_B.shape[3] or images_A.shape[2] != images_B.shape[2]:
+            images_A = images_A.movedim(-1,1)
+            images_B = images_B.movedim(-1,1)
+
+            A_size = images_A.shape[3] * images_A.shape[2]
+            B_size = images_B.shape[3] * images_B.shape[2]
+            # determine which to use
+            use_A_as_template = True
+            if merge_strategy == MergeStrategies.MATCH_A:
+                pass
+            elif merge_strategy == MergeStrategies.MATCH_B:
+                use_A_as_template = False
+            elif merge_strategy in (MergeStrategies.MATCH_SMALLER, MergeStrategies.MATCH_LARGER):
+                if A_size <= B_size:
+                    use_A_as_template = True if merge_strategy == MergeStrategies.MATCH_SMALLER else False
+            # apply scaling
+            if use_A_as_template:
+                images_B = comfy.utils.common_upscale(images_B, images_A.shape[3], images_A.shape[2], scale_method, crop)
+            else:
+                images_A = comfy.utils.common_upscale(images_A, images_B.shape[3], images_B.shape[2], scale_method, crop)
+            images_A = images_A.movedim(1,-1)
+            images_B = images_B.movedim(1,-1)
+
+        images.append(images_A)
+        images.append(images_B)
+        all_images = torch.cat(images, dim=0)
+        return (all_images, all_images.size(0),)
+
+
+class MergeMasks:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask_A": ("MASK",),
+                "mask_B": ("MASK",),
+                "merge_strategy": (MergeStrategies.list_all,),
+                "scale_method": (ScaleMethods.list_all,),
+                "crop": (CropMethods.list_all,),
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/mask"
+
+    RETURN_TYPES = ("MASK", "INT",)
+    RETURN_NAMES = ("MASK", "count",)
+    FUNCTION = "merge"
+
+    def merge(self, mask_A: Tensor, mask_B: Tensor, merge_strategy: str, scale_method: str, crop: str):
+        masks = []
+        # if not same dimensions, do scaling
+        if mask_A.shape[2] != mask_B.shape[2] or mask_A.shape[1] != mask_B.shape[1]:
+            A_size = mask_A.shape[2] * mask_A.shape[1]
+            B_size = mask_B.shape[2] * mask_B.shape[1]
+            # determine which to use
+            use_A_as_template = True
+            if merge_strategy == MergeStrategies.MATCH_A:
+                pass
+            elif merge_strategy == MergeStrategies.MATCH_B:
+                use_A_as_template = False
+            elif merge_strategy in (MergeStrategies.MATCH_SMALLER, MergeStrategies.MATCH_LARGER):
+                if A_size <= B_size:
+                    use_A_as_template = True if merge_strategy == MergeStrategies.MATCH_SMALLER else False
+            # add dimension where image channels would be expected to work with common_upscale
+            mask_A = torch.unsqueeze(mask_A, 1)
+            mask_B = torch.unsqueeze(mask_B, 1)
+            # apply scaling
+            if use_A_as_template:
+                mask_B = comfy.utils.common_upscale(mask_B, mask_A.shape[3], mask_A.shape[2], scale_method, crop)
+            else:
+                mask_A = comfy.utils.common_upscale(mask_A, mask_B.shape[3], mask_B.shape[2], scale_method, crop)
+            # undo dimension increase
+            mask_A = torch.squeeze(mask_A, 1)
+            mask_B = torch.squeeze(mask_B, 1)
+
+        masks.append(mask_A)
+        masks.append(mask_B)
+        all_masks = torch.cat(masks, dim=0)
+        return (all_masks, all_masks.size(0),)
+
+
+class SelectEveryNthLatent:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "latents": ("LATENT",),
+                    "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+                    "skip_first_latents": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                },
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/latent"
+
+    RETURN_TYPES = ("LATENT", "INT",)
+    RETURN_NAMES = ("LATENT", "count",)
+    FUNCTION = "select_latents"
+
+    def select_latents(self, latents: dict[str, Tensor], select_every_nth: int, skip_first_latents: int):
+        latents = latents.copy()
+        latents_len = len(latents["samples"])
+        for key, val in latents.items():
+            if type(val) == Tensor and len(val) == latents_len:
+                latents[key] = val[skip_first_latents::select_every_nth]
+        return (latents, latents["samples"].size(0))
+    
+
+class SelectEveryNthImage:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "images": ("IMAGE",),
+                    "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+                    "skip_first_images": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                    
+                },
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/image"
+
+    RETURN_TYPES = ("IMAGE", "INT",)
+    RETURN_NAMES = ("IMAGE", "count",)
+    FUNCTION = "select_images"
+
+    def select_images(self, images: Tensor, select_every_nth: int, skip_first_images: int):
+        sub_images = images[skip_first_images::select_every_nth]
+        return (sub_images, sub_images.size(0))
+    
+
+class SelectEveryNthMask:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "mask": ("MASK",),
+                    "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+                    "skip_first_masks": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                },
+            }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/mask"
+
+    RETURN_TYPES = ("MASK", "INT",)
+    RETURN_NAMES = ("MASK", "count",)
+    FUNCTION = "select_masks"
+
+    def select_masks(self, mask: Tensor, select_every_nth: int, skip_first_masks: int):
+        sub_mask = mask[skip_first_masks::select_every_nth]
+        return (sub_mask, sub_mask.size(0))
+
+
+class GetLatentCount:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "latents": ("LATENT",),
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/latent"
+
+    RETURN_TYPES = ("INT",)
+    RETURN_NAMES = ("count",)
+    FUNCTION = "count_input"
+
+    def count_input(self, latents: dict):
+        return (latents["samples"].size(0),)
+
+
+class GetImageCount:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/image"
+
+    RETURN_TYPES = ("INT",)
+    RETURN_NAMES = ("count",)
+    FUNCTION = "count_input"
+
+    def count_input(self, images: Tensor):
+        return (images.size(0),)
+    
+
+class GetMaskCount:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/mask"
+
+    RETURN_TYPES = ("INT",)
+    RETURN_NAMES = ("count",)
+    FUNCTION = "count_input"
+
+    def count_input(self, mask: Tensor):
+        return (mask.size(0),)
+
+
+class RepeatLatents:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "latents": ("LATENT",),
+                "multiply_by": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1})
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/latent"
+
+    RETURN_TYPES = ("LATENT", "INT",)
+    RETURN_NAMES = ("LATENT", "count",)
+    FUNCTION = "duplicate_input"
+
+    def duplicate_input(self, latents: dict[str, Tensor], multiply_by: int):
+        latents = latents.copy()
+        latents_len = len(latents["samples"])
+        for key, val in latents.items():
+            if type(val) == Tensor and len(val) == latents_len:
+                full_latents = []
+                for _ in range(0, multiply_by):
+                    full_latents.append(latents[key])
+                latents[key] = torch.cat(full_latents, dim=0)
+        return (latents, latents["samples"].size(0),)
+
+
+class RepeatImages:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "images": ("IMAGE",),
+                "multiply_by": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1})
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/image"
+
+    RETURN_TYPES = ("IMAGE", "INT",)
+    RETURN_NAMES = ("IMAGE", "count",)
+    FUNCTION = "duplicate_input"
+
+    def duplicate_input(self, images: Tensor, multiply_by: int):
+        full_images = []
+        for n in range(0, multiply_by):
+            full_images.append(images)
+        new_images = torch.cat(full_images, dim=0)
+        return (new_images, new_images.size(0),)
+
+
+class RepeatMasks:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "mask": ("MASK",),
+                "multiply_by": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1})
+            }
+        }
+    
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/mask"
+
+    RETURN_TYPES = ("MASK", "INT",)
+    RETURN_NAMES = ("MASK", "count",)
+    FUNCTION = "duplicate_input"
+
+    def duplicate_input(self, mask: Tensor, multiply_by: int):
+        full_masks = []
+        for n in range(0, multiply_by):
+            full_masks.append(mask)
+        new_mask = torch.cat(full_masks, dim=0)
+        return (new_mask, new_mask.size(0),)
+
+
+select_description = """Use comma-separated indexes to select items in the given order.
+Supports negative indexes, python-style ranges (end index excluded),
+as well as range step.
+
+Acceptable entries (assuming 16 items provided, so idxs 0 to 15 exist):
+0         -> Returns [0]
+-1        -> Returns [15]
+0, 1, 13  -> Returns [0, 1, 13]
+0:5, 13   -> Returns [0, 1, 2, 3, 4, 13]
+0:-1      -> Returns [0, 1, 2, ..., 13, 14]
+0:5:-1    -> Returns [4, 3, 2, 1, 0]
+0:5:2     -> Returns [0, 2, 4]
+::-1     -> Returns [15, 14, 13, ..., 2, 1, 0]
+"""
+class SelectLatents:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "latent": ("LATENT",),
+                    "indexes": ("STRING", {"default": "0"}),
+                    "err_if_missing": ("BOOLEAN", {"default": True}),
+                    "err_if_empty": ("BOOLEAN", {"default": True}),
+                },
+            }
+    
+    DESCRIPTION = select_description
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/latent"
+
+    RETURN_TYPES = ("LATENT",)
+    FUNCTION = "select"
+
+    def select(self, latent: dict[str, Tensor], indexes: str, err_if_missing: bool, err_if_empty: bool):
+        # latents are a dict and may contain different stuff (like noise_mask), so need to account for it all
+        latent = latent.copy()
+        latents_len = len(latent["samples"])
+        real_idxs = convert_str_to_indexes(indexes, latents_len, allow_missing=not err_if_missing)
+        if err_if_empty and len(real_idxs) == 0:
+            raise Exception(f"Nothing was selected based on indexes found in '{indexes}'.")
+        for key, val in latent.items():
+            if type(val) == Tensor and len(val) == latents_len:
+                latent[key] = select_indexes(val, real_idxs)
+        return (latent,)
+
+
+class SelectImages:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "image": ("IMAGE",),
+                    "indexes": ("STRING", {"default": "0"}),
+                    "err_if_missing": ("BOOLEAN", {"default": True}),
+                    "err_if_empty": ("BOOLEAN", {"default": True}),
+                },
+            }
+    
+    DESCRIPTION = select_description
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/image"
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "select"
+
+    def select(self, image: Tensor, indexes: str, err_if_missing: bool, err_if_empty: bool):
+        to_return = select_indexes_from_str(input_obj=image, indexes=indexes,
+                                        err_if_missing=err_if_missing, err_if_empty=err_if_empty)
+        to_return_type = type(to_return)
+        return (to_return,)
+
+
+class SelectMasks:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "mask": ("MASK",),
+                    "indexes": ("STRING", {"default": "0"}),
+                    "err_if_missing": ("BOOLEAN", {"default": True}),
+                    "err_if_empty": ("BOOLEAN", {"default": True}),
+                },
+            }
+    
+    DESCRIPTION = select_description
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/mask"
+
+    RETURN_TYPES = ("MASK",)
+    FUNCTION = "select"
+
+    def select(self, mask: Tensor, indexes: str, err_if_missing: bool, err_if_empty: bool):
+        return (select_indexes_from_str(input_obj=mask, indexes=indexes,
+                                        err_if_missing=err_if_missing, err_if_empty=err_if_empty),)

videohelpersuite/latent_preview.py

@@ -0,0 +1,111 @@
+from PIL import Image
+import time
+import io
+import struct
+from threading import Thread
+import torch.nn.functional as F
+import torch
+
+import latent_preview
+import server
+serv = server.PromptServer.instance
+
+from .utils import hook
+
+rates_table = {'Mochi': 24//6, 'LTXV': 24//8, 'HunyuanVideo': 24//4,
+               'Cosmos1CV8x8x8': 24//8, 'Wan21': 16//4, 'Wan22': 24//4}
+
+class WrappedPreviewer(latent_preview.LatentPreviewer):
+    def __init__(self, previewer, rate=8):
+        self.first_preview = True
+        self.last_time = 0
+        self.c_index = 0
+        self.rate = rate
+        if hasattr(previewer, 'taesd'):
+            self.taesd = previewer.taesd
+        elif hasattr(previewer, 'latent_rgb_factors'):
+            self.latent_rgb_factors = previewer.latent_rgb_factors
+            self.latent_rgb_factors_bias = previewer.latent_rgb_factors_bias
+        else:
+            raise Exception('Unsupported preview type for VHS animated previews')
+
+    def decode_latent_to_preview_image(self, preview_format, x0):
+        if x0.ndim == 5:
+            #Keep batch major
+            x0 = x0.movedim(2,1)
+            x0 = x0.reshape((-1,)+x0.shape[-3:])
+        num_images = x0.size(0)
+        new_time = time.time()
+        num_previews = int((new_time - self.last_time) * self.rate)
+        self.last_time = self.last_time + num_previews/self.rate
+        if num_previews > num_images:
+            num_previews = num_images
+        elif num_previews <= 0:
+            return None
+        if self.first_preview:
+            self.first_preview = False
+            serv.send_sync('VHS_latentpreview', {'length':num_images, 'rate': self.rate, 'id': serv.last_node_id})
+            self.last_time = new_time + 1/self.rate
+        if self.c_index + num_previews > num_images:
+            x0 = x0.roll(-self.c_index, 0)[:num_previews]
+        else:
+            x0 = x0[self.c_index:self.c_index + num_previews]
+        Thread(target=self.process_previews, args=(x0, self.c_index,
+                                                   num_images)).run()
+        self.c_index = (self.c_index + num_previews) % num_images
+        return None
+    def process_previews(self, image_tensor, ind, leng):
+        image_tensor = self.decode_latent_to_preview(image_tensor)
+        if image_tensor.size(1) > 512 or image_tensor.size(2) > 512:
+            image_tensor = image_tensor.movedim(-1,0)
+            if image_tensor.size(2) < image_tensor.size(3):
+                height = (512 * image_tensor.size(2)) // image_tensor.size(3)
+                image_tensor = F.interpolate(image_tensor, (height,512), mode='bilinear')
+            else:
+                width = (512 * image_tensor.size(3)) // image_tensor.size(2)
+                image_tensor = F.interpolate(image_tensor, (512, width), mode='bilinear')
+            image_tensor = image_tensor.movedim(0,-1)
+        previews_ubyte = (((image_tensor + 1.0) / 2.0).clamp(0, 1)  # change scale from -1..1 to 0..1
+                         .mul(0xFF)  # to 0..255
+                         ).to(device="cpu", dtype=torch.uint8)
+        for preview in previews_ubyte:
+            i = Image.fromarray(preview.numpy())
+            message = io.BytesIO()
+            message.write((1).to_bytes(length=4, byteorder='big')*2)
+            message.write(ind.to_bytes(length=4, byteorder='big'))
+            message.write(struct.pack('16p', serv.last_node_id.encode('ascii')))
+            i.save(message, format="JPEG", quality=95, compress_level=1)
+            #NOTE: send sync already uses call_soon_threadsafe
+            serv.send_sync(server.BinaryEventTypes.PREVIEW_IMAGE,
+                           message.getvalue(), serv.client_id)
+            ind = (ind + 1) % leng
+    def decode_latent_to_preview(self, x0):
+        if hasattr(self, 'taesd'):
+            x_sample = self.taesd.decode(x0).movedim(1, 3)
+            return x_sample
+        else:
+            self.latent_rgb_factors = self.latent_rgb_factors.to(dtype=x0.dtype, device=x0.device)
+            if self.latent_rgb_factors_bias is not None:
+                self.latent_rgb_factors_bias = self.latent_rgb_factors_bias.to(dtype=x0.dtype, device=x0.device)
+            latent_image = F.linear(x0.movedim(1, -1), self.latent_rgb_factors,
+                                    bias=self.latent_rgb_factors_bias)
+            return latent_image
+
+@hook(latent_preview, 'get_previewer')
+def get_latent_video_previewer(device, latent_format, *args, **kwargs):
+    node_id = serv.last_node_id
+    previewer = get_latent_video_previewer.__wrapped__(device, latent_format, *args, **kwargs)
+    try:
+        extra_info = next(serv.prompt_queue.currently_running.values().__iter__()) \
+                [3]['extra_pnginfo']['workflow']['extra']
+        prev_setting = extra_info.get('VHS_latentpreview', False)
+        if extra_info.get('VHS_latentpreviewrate', 0) != 0:
+            rate_setting = extra_info['VHS_latentpreviewrate']
+        else:
+            rate_setting = rates_table.get(latent_format.__class__.__name__, 8)
+    except:
+        #For safety since there's lots of keys, any of which can fail
+        prev_setting = False
+    if not prev_setting or not hasattr(previewer, "decode_latent_to_preview"):
+        return previewer
+    return WrappedPreviewer(previewer, rate_setting)

videohelpersuite/load_images_nodes.py

@@ -0,0 +1,206 @@
+import os
+import hashlib
+import numpy as np
+import torch
+from PIL import Image, ImageOps
+import itertools
+
+import folder_paths
+from comfy.k_diffusion.utils import FolderOfImages
+from comfy.utils import common_upscale, ProgressBar
+from .logger import logger
+from .utils import BIGMAX, calculate_file_hash, get_sorted_dir_files_from_directory, validate_path, strip_path
+
+
+def is_changed_load_images(directory: str, image_load_cap: int = 0, skip_first_images: int = 0, select_every_nth: int = 1, **kwargs):
+    if not os.path.isdir(directory):
+            return False
+        
+    dir_files = get_sorted_dir_files_from_directory(directory, skip_first_images, select_every_nth, FolderOfImages.IMG_EXTENSIONS)
+    if image_load_cap != 0:
+        dir_files = dir_files[:image_load_cap]
+
+    m = hashlib.sha256()
+    for filepath in dir_files:
+        m.update(calculate_file_hash(filepath).encode()) # strings must be encoded before hashing
+    return m.digest().hex()
+
+
+def validate_load_images(directory: str):
+    if not os.path.isdir(directory):
+            return f"Directory '{directory}' cannot be found."
+    dir_files = os.listdir(directory)
+    if len(dir_files) == 0:
+        return f"No files in directory '{directory}'."
+
+    return True
+
+def images_generator(directory: str, image_load_cap: int = 0, skip_first_images: int = 0, select_every_nth: int = 1, meta_batch=None, unique_id=None):
+    if not os.path.isdir(directory):
+        raise FileNotFoundError(f"Directory '{directory} cannot be found.")
+    dir_files = get_sorted_dir_files_from_directory(directory, skip_first_images, select_every_nth, FolderOfImages.IMG_EXTENSIONS)
+
+    if len(dir_files) == 0:
+        raise FileNotFoundError(f"No files in directory '{directory}'.")
+    if image_load_cap > 0:
+        dir_files = dir_files[:image_load_cap]
+    sizes = {}
+    has_alpha = False
+    for image_path in dir_files:
+        i = Image.open(image_path)
+        #exif_transpose can only ever rotate, but rotating can swap width/height
+        i = ImageOps.exif_transpose(i)
+        has_alpha |= 'A' in i.getbands()
+        count = sizes.get(i.size, 0)
+        sizes[i.size] = count +1
+    size = max(sizes.items(), key=lambda x: x[1])[0]
+    yield size[0], size[1], has_alpha
+    if meta_batch is not None:
+        yield min(image_load_cap, len(dir_files)) or len(dir_files)
+
+    iformat = "RGBA" if has_alpha else "RGB"
+    def load_image(file_path):
+        i = Image.open(file_path)
+        i = ImageOps.exif_transpose(i)
+        i = i.convert(iformat)
+        i = np.array(i, dtype=np.float32)
+        #This nonsense provides a nearly 50% speedup on my system
+        torch.from_numpy(i).div_(255)
+        if i.shape[0] != size[1] or i.shape[1] != size[0]:
+            i = torch.from_numpy(i).movedim(-1, 0).unsqueeze(0)
+            i = common_upscale(i, size[0], size[1], "lanczos", "center")
+            i = i.squeeze(0).movedim(0, -1).numpy()
+        if has_alpha:
+            i[:,:,-1] = 1 - i[:,:,-1]
+        return i
+
+    total_images = len(dir_files)
+    processed_images = 0
+    pbar = ProgressBar(total_images)
+    images =  map(load_image, dir_files)
+    try:
+        prev_image = next(images)
+        while True:
+            next_image = next(images)
+            yield prev_image
+            processed_images += 1
+            pbar.update_absolute(processed_images, total_images)
+            prev_image = next_image
+    except StopIteration:
+        pass
+    if meta_batch is not None:
+        meta_batch.inputs.pop(unique_id)
+        meta_batch.has_closed_inputs = True
+    if prev_image is not None:
+        yield prev_image
+
+
+def load_images(directory: str, image_load_cap: int = 0, skip_first_images: int = 0, select_every_nth: int = 1, meta_batch=None, unique_id=None):
+    if meta_batch is None or unique_id not in meta_batch.inputs:
+        gen = images_generator(directory, image_load_cap, skip_first_images, select_every_nth, meta_batch, unique_id)
+        (width, height, has_alpha) = next(gen)
+        if meta_batch is not None:
+            meta_batch.inputs[unique_id] = (gen, width, height, has_alpha)
+            meta_batch.total_frames = min(meta_batch.total_frames, next(gen))
+    else:
+        gen, width, height, has_alpha = meta_batch.inputs[unique_id]
+
+    if meta_batch is not None:
+        gen = itertools.islice(gen, meta_batch.frames_per_batch)
+    images = torch.from_numpy(np.fromiter(gen, np.dtype((np.float32, (height, width, 3 + has_alpha)))))
+    if has_alpha:
+        #tensors are not continuous. Rewrite will be required if this is an issue
+        masks = images[:,:,:,3]
+        images = images[:,:,:,:3]
+    else:
+        masks = torch.zeros((images.size(0), 64, 64), dtype=torch.float32, device="cpu")
+    if len(images) == 0:
+        raise FileNotFoundError(f"No images could be loaded from directory '{directory}'.")
+    return images, masks, images.size(0)
+
+class LoadImagesFromDirectoryUpload:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        directories = []
+        for item in os.listdir(input_dir):
+            if not os.path.isfile(os.path.join(input_dir, item)) and item != "clipspace":
+                directories.append(item)
+        return {
+            "required": {
+                "directory": (directories,),
+            },
+            "optional": {
+                "image_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                "skip_first_images": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+                "meta_batch": ("VHS_BatchManager",),
+            },
+            "hidden": {
+                "unique_id": "UNIQUE_ID"
+            },
+        }
+    
+    RETURN_TYPES = ("IMAGE", "MASK", "INT")
+    RETURN_NAMES = ("IMAGE", "MASK", "frame_count")
+    FUNCTION = "load_images"
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    def load_images(self, directory: str, **kwargs):
+        directory = folder_paths.get_annotated_filepath(strip_path(directory))
+        return load_images(directory, **kwargs)
+    
+    @classmethod
+    def IS_CHANGED(s, directory: str, **kwargs):
+        directory = folder_paths.get_annotated_filepath(strip_path(directory))
+        return is_changed_load_images(directory, **kwargs)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, directory: str, **kwargs):
+        directory = folder_paths.get_annotated_filepath(strip_path(directory))
+        return validate_load_images(directory)
+
+
+class LoadImagesFromDirectoryPath:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "directory": ("STRING", {"placeholder": "X://path/to/images", "vhs_path_extensions": []}),
+            },
+            "optional": {
+                "image_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                "skip_first_images": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+                "meta_batch": ("VHS_BatchManager",),
+            },
+            "hidden": {
+                "unique_id": "UNIQUE_ID"
+            },
+        }
+    
+    RETURN_TYPES = ("IMAGE", "MASK", "INT")
+    RETURN_NAMES = ("IMAGE", "MASK", "frame_count")
+    FUNCTION = "load_images"
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    def load_images(self, directory: str, **kwargs):
+        directory = strip_path(directory)
+        if directory is None or validate_load_images(directory) != True:
+            raise Exception("directory is not valid: " + directory)
+
+        return load_images(directory, **kwargs)
+    
+    @classmethod
+    def IS_CHANGED(s, directory: str, **kwargs):
+        if directory is None:
+            return "input"
+        return is_changed_load_images(directory, **kwargs)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, directory: str, **kwargs):
+        if directory is None:
+            return True
+        return validate_load_images(strip_path(directory))

videohelpersuite/load_video_nodes.py

@@ -0,0 +1,671 @@
+import os
+import itertools
+import numpy as np
+import torch
+from PIL import Image, ImageOps
+import cv2
+import psutil
+import subprocess
+import re
+import time
+
+import folder_paths
+from comfy.utils import common_upscale, ProgressBar
+import nodes
+from comfy.k_diffusion.utils import FolderOfImages
+from .logger import logger
+from .utils import BIGMAX, DIMMAX, calculate_file_hash, get_sorted_dir_files_from_directory,\
+        lazy_get_audio, hash_path, validate_path, strip_path, try_download_video,  \
+        is_url, imageOrLatent, ffmpeg_path, ENCODE_ARGS, floatOrInt
+
+
+video_extensions = ['webm', 'mp4', 'mkv', 'gif', 'mov']
+
+VHSLoadFormats = {
+    'None': {},
+    'AnimateDiff': {'target_rate': 8, 'dim': (8,0,512,512)},
+    'Mochi': {'target_rate': 24, 'dim': (16,0,848,480), 'frames':(6,1)},
+    'LTXV': {'target_rate': 24, 'dim': (32,0,768,512), 'frames':(8,1)},
+    'Hunyuan': {'target_rate': 24, 'dim': (16,0,848,480), 'frames':(4,1)},
+    'Cosmos': {'target_rate': 24, 'dim': (16,0,1280,704), 'frames':(8,1)},
+    'Wan': {'target_rate': 16, 'dim': (8,0,832,480), 'frames':(4,1)},
+}
+"""
+External plugins may add additional formats to nodes.VHSLoadFormats
+In addition to shorthand options, direct widget names will map a given dict to options.
+Adding a third arguement to a frames tuple can enable strict checks on number
+of loaded frames, i.e (8,1,True)
+"""
+if not hasattr(nodes, 'VHSLoadFormats'):
+    nodes.VHSLoadFormats = {}
+
+def get_load_formats():
+    #TODO: check if {**extra_config.VHSLoafFormats, **VHSLoadFormats} has minimum version
+    formats = {}
+    formats.update(nodes.VHSLoadFormats)
+    formats.update(VHSLoadFormats)
+    return (list(formats.keys()),
+            {'default': 'AnimateDiff', 'formats': formats})
+def get_format(format):
+    if format in VHSLoadFormats:
+        return VHSLoadFormats[format]
+    return nodes.VHSLoadFormats.get(format, {})
+
+def is_gif(filename) -> bool:
+    file_parts = filename.split('.')
+    return len(file_parts) > 1 and file_parts[-1] == "gif"
+
+
+def target_size(width, height, custom_width, custom_height, downscale_ratio=8) -> tuple[int, int]:
+    if downscale_ratio is None:
+        downscale_ratio = 8
+    if custom_width == 0 and custom_height ==  0:
+        pass
+    elif custom_height == 0:
+        height *= custom_width/width
+        width = custom_width
+    elif custom_width == 0:
+        width *= custom_height/height
+        height = custom_height
+    else:
+        width = custom_width
+        height = custom_height
+    width = int(width/downscale_ratio + 0.5) * downscale_ratio
+    height = int(height/downscale_ratio + 0.5) * downscale_ratio
+    return (width, height)
+
+def cv_frame_generator(video, force_rate, frame_load_cap, skip_first_frames,
+                       select_every_nth, meta_batch=None, unique_id=None):
+    video_cap = cv2.VideoCapture(video)
+    if not video_cap.isOpened() or not video_cap.grab():
+        raise ValueError(f"{video} could not be loaded with cv.")
+
+    # extract video metadata
+    fps = video_cap.get(cv2.CAP_PROP_FPS)
+    width = int(video_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(video_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    total_frames = int(video_cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    duration = total_frames / fps
+
+    width = 0
+
+    if width <=0 or height <=0:
+        _, frame = video_cap.retrieve()
+        height, width, _ = frame.shape
+
+    # set video_cap to look at start_index frame
+    total_frame_count = 0
+    total_frames_evaluated = -1
+    frames_added = 0
+    base_frame_time = 1 / fps
+    prev_frame = None
+
+    if force_rate == 0:
+        target_frame_time = base_frame_time
+    else:
+        target_frame_time = 1/force_rate
+
+    if total_frames > 0:
+        if force_rate != 0:
+            yieldable_frames = int(total_frames / fps * force_rate)
+        else:
+            yieldable_frames = total_frames
+        if select_every_nth:
+            yieldable_frames //= select_every_nth
+        if frame_load_cap != 0:
+            yieldable_frames =  min(frame_load_cap, yieldable_frames)
+    else:
+        yieldable_frames = 0
+    yield (width, height, fps, duration, total_frames, target_frame_time, yieldable_frames)
+    pbar = ProgressBar(yieldable_frames)
+    time_offset=target_frame_time
+    while video_cap.isOpened():
+        if time_offset < target_frame_time:
+            is_returned = video_cap.grab()
+            # if didn't return frame, video has ended
+            if not is_returned:
+                break
+            time_offset += base_frame_time
+        if time_offset < target_frame_time:
+            continue
+        time_offset -= target_frame_time
+        # if not at start_index, skip doing anything with frame
+        total_frame_count += 1
+        if total_frame_count <= skip_first_frames:
+            continue
+        else:
+            total_frames_evaluated += 1
+
+        # if should not be selected, skip doing anything with frame
+        if total_frames_evaluated%select_every_nth != 0:
+            continue
+
+        # opencv loads images in BGR format (yuck), so need to convert to RGB for ComfyUI use
+        # follow up: can videos ever have an alpha channel?
+        # To my testing: No. opencv has no support for alpha
+        unused, frame = video_cap.retrieve()
+        frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+        # convert frame to comfyui's expected format
+        # TODO: frame contains no exif information. Check if opencv2 has already applied
+        frame = np.array(frame, dtype=np.float32)
+        torch.from_numpy(frame).div_(255)
+        if prev_frame is not None:
+            inp  = yield prev_frame
+            if inp is not None:
+                #ensure the finally block is called
+                return
+        prev_frame = frame
+        frames_added += 1
+        if pbar is not None:
+            pbar.update_absolute(frames_added, yieldable_frames)
+        # if cap exists and we've reached it, stop processing frames
+        if frame_load_cap > 0 and frames_added >= frame_load_cap:
+            break
+    if meta_batch is not None:
+        meta_batch.inputs.pop(unique_id)
+        meta_batch.has_closed_inputs = True
+    if prev_frame is not None:
+        yield prev_frame
+
+def ffmpeg_frame_generator(video, force_rate, frame_load_cap, start_time,
+                           custom_width, custom_height, downscale_ratio=8,
+                           meta_batch=None, unique_id=None):
+    args_input = ["-i", video]
+    args_dummy = [ffmpeg_path] + args_input +['-c', 'copy', '-frames:v', '1', "-f", "null", "-"]
+    size_base = None
+    fps_base = None
+    try:
+        dummy_res = subprocess.run(args_dummy, stdout=subprocess.DEVNULL,
+                                 stderr=subprocess.PIPE, check=True)
+    except subprocess.CalledProcessError as e:
+        raise Exception("An error occurred in the ffmpeg subprocess:\n" \
+                + e.stderr.decode(*ENCODE_ARGS))
+    lines = dummy_res.stderr.decode(*ENCODE_ARGS)
+    if "Video: vp9 " in lines:
+        args_input = ["-c:v", "libvpx-vp9"] + args_input
+        args_dummy = [ffmpeg_path] + args_input +['-c', 'copy', '-frames:v', '1', "-f", "null", "-"]
+        try:
+            dummy_res = subprocess.run(args_dummy, stdout=subprocess.DEVNULL,
+                                     stderr=subprocess.PIPE, check=True)
+        except subprocess.CalledProcessError as e:
+            raise Exception("An error occurred in the ffmpeg subprocess:\n" \
+                    + e.stderr.decode(*ENCODE_ARGS))
+        lines = dummy_res.stderr.decode(*ENCODE_ARGS)
+
+    for line in lines.split('\n'):
+        match = re.search("^ *Stream .* Video.*, ([1-9]|\\d{2,})x(\\d+)", line)
+        if match is not None:
+            size_base = [int(match.group(1)), int(match.group(2))]
+            fps_match = re.search(", ([\\d\\.]+) fps", line)
+            if fps_match:
+                fps_base = float(fps_match.group(1))
+            else:
+                fps_base = 1
+            alpha = re.search("(yuva|rgba|bgra)", line) is not None
+            break
+    else:
+        raise Exception("Failed to parse video/image information. FFMPEG output:\n" + lines)
+
+    durs_match = re.search("Duration: (\\d+:\\d+:\\d+\\.\\d+),", lines)
+    if durs_match:
+        durs = durs_match.group(1).split(':')
+        duration = int(durs[0])*360 + int(durs[1])*60 + float(durs[2])
+    else:
+        duration = 0
+
+    if start_time > 0:
+        if start_time > 4:
+            post_seek = ['-ss', '4']
+            args_input = ['-ss', str(start_time - 4)] + args_input
+        else:
+            post_seek = ['-ss', str(start_time)]
+    else:
+        post_seek = []
+    args_all_frames = [ffmpeg_path, "-v", "error", "-an"] + \
+            args_input + ["-pix_fmt", "rgba64le"] + post_seek
+
+    vfilters = []
+    if force_rate != 0:
+        vfilters.append("fps=fps="+str(force_rate))
+    if custom_width != 0 or custom_height != 0:
+        size = target_size(size_base[0], size_base[1], custom_width,
+                           custom_height, downscale_ratio=downscale_ratio)
+        ar = float(size[0])/float(size[1])
+        if abs(size_base[0]*ar-size_base[1]) >= 1:
+            #Aspect ratio is changed. Crop to new aspect ratio before scale
+            vfilters.append(f"crop=if(gt({ar}\\,a)\\,iw\\,ih*{ar}):if(gt({ar}\\,a)\\,iw/{ar}\\,ih)")
+        size_arg = ':'.join(map(str,size))
+        vfilters.append(f"scale={size_arg}")
+    else:
+        size = size_base
+    if len(vfilters) > 0:
+        args_all_frames += ["-vf", ",".join(vfilters)]
+    yieldable_frames = (force_rate or fps_base)*duration
+    if frame_load_cap > 0:
+        args_all_frames += ["-frames:v", str(frame_load_cap)]
+        yieldable_frames = min(yieldable_frames, frame_load_cap)
+    yield (size_base[0], size_base[1], fps_base, duration, fps_base * duration,
+           1/(force_rate or fps_base), yieldable_frames, size[0], size[1], alpha)
+
+    args_all_frames += ["-f", "rawvideo", "-"]
+    pbar = ProgressBar(yieldable_frames)
+    try:
+        with subprocess.Popen(args_all_frames, stdout=subprocess.PIPE) as proc:
+            #Manually buffer enough bytes for an image
+            bpi = size[0] * size[1] * 8
+            current_bytes = bytearray(bpi)
+            current_offset=0
+            prev_frame = None
+            while True:
+                bytes_read = proc.stdout.read(bpi - current_offset)
+                if bytes_read is None:#sleep to wait for more data
+                    time.sleep(.1)
+                    continue
+                if len(bytes_read) == 0:#EOF
+                    break
+                current_bytes[current_offset:len(bytes_read)] = bytes_read
+                current_offset+=len(bytes_read)
+                if current_offset == bpi:
+                    if prev_frame is not None:
+                        yield prev_frame
+                        pbar.update(1)
+                    prev_frame = np.frombuffer(current_bytes, dtype=np.dtype(np.uint16).newbyteorder("<")).reshape(size[1], size[0], 4) / (2**16-1)
+                    if not alpha:
+                        prev_frame = prev_frame[:, :, :-1]
+                    current_offset = 0
+    except BrokenPipeError as e:
+        raise Exception("An error occured in the ffmpeg subprocess:\n" \
+                + proc.stderr.read().decode(*ENCODE_ARGS))
+    if meta_batch is not None:
+        meta_batch.inputs.pop(unique_id)
+        meta_batch.has_closed_inputs = True
+    if prev_frame is not None:
+        yield prev_frame
+
+#Python 3.12 adds an itertools.batched, but it's easily replicated for legacy support
+def batched(it, n):
+    while batch := tuple(itertools.islice(it, n)):
+        yield batch
+def batched_vae_encode(images, vae, frames_per_batch):
+    for batch in batched(images, frames_per_batch):
+        image_batch = torch.from_numpy(np.array(batch))
+        yield from vae.encode(image_batch).numpy()
+def resized_cv_frame_gen(custom_width, custom_height, downscale_ratio, **kwargs):
+    gen = cv_frame_generator(**kwargs)
+    info =  next(gen)
+    width, height = info[0], info[1]
+    frames_per_batch = (1920 * 1080 * 16) // (width * height) or 1
+    if kwargs.get('meta_batch', None) is not None:
+        frames_per_batch = min(frames_per_batch, kwargs['meta_batch'].frames_per_batch)
+    if custom_width != 0 or custom_height != 0 or downscale_ratio is not None:
+        new_size = target_size(width, height, custom_width, custom_height, downscale_ratio)
+        yield (*info, new_size[0], new_size[1], False)
+        if new_size[0] != width or new_size[1] != height:
+            def rescale(frame):
+                s = torch.from_numpy(np.fromiter(frame, np.dtype((np.float32, (height, width, 3)))))
+                s = s.movedim(-1,1)
+                s = common_upscale(s, new_size[0], new_size[1], "lanczos", "center")
+                return s.movedim(1,-1).numpy()
+            yield from itertools.chain.from_iterable(map(rescale, batched(gen, frames_per_batch)))
+            return
+    else:
+        yield (*info, info[0], info[1], False)
+    yield from gen
+
+def load_video(meta_batch=None, unique_id=None, memory_limit_mb=None, vae=None,
+               generator=resized_cv_frame_gen, format='None',  **kwargs):
+    if 'force_size' in kwargs:
+        kwargs.pop('force_size')
+        logger.warn("force_size has been removed. Did you reload the webpage after updating?")
+    format = get_format(format)
+    kwargs['video'] = strip_path(kwargs['video'])
+    if vae is not None:
+        downscale_ratio = getattr(vae, "downscale_ratio", 8)
+    else:
+        downscale_ratio = format.get('dim', (1,))[0]
+    if meta_batch is None or unique_id not in meta_batch.inputs:
+        gen = generator(meta_batch=meta_batch, unique_id=unique_id, downscale_ratio=downscale_ratio, **kwargs)
+        (width, height, fps, duration, total_frames, target_frame_time, yieldable_frames, new_width, new_height, alpha) = next(gen)
+
+        if meta_batch is not None:
+            meta_batch.inputs[unique_id] = (gen, width, height, fps, duration, total_frames, target_frame_time, yieldable_frames, new_width, new_height, alpha)
+            if yieldable_frames:
+                meta_batch.total_frames = min(meta_batch.total_frames, yieldable_frames)
+
+    else:
+        (gen, width, height, fps, duration, total_frames, target_frame_time, yieldable_frames, new_width, new_height, alpha) = meta_batch.inputs[unique_id]
+
+    memory_limit = None
+    if memory_limit_mb is not None:
+        memory_limit *= 2 ** 20
+    else:
+        #TODO: verify if garbage collection should be performed here.
+        #leaves ~128 MB unreserved for safety
+        try:
+            memory_limit = (psutil.virtual_memory().available + psutil.swap_memory().free) - 2 ** 27
+        except:
+            logger.warn("Failed to calculate available memory. Memory load limit has been disabled")
+            memory_limit = BIGMAX
+    if vae is not None:
+        #space required to load as f32, exist as latent with wiggle room, decode to f32
+        max_loadable_frames = int(memory_limit//(width*height*3*(4+4+1/10)))
+    else:
+        #TODO: use better estimate for when vae is not None
+        #Consider completely ignoring for load_latent case?
+        max_loadable_frames = int(memory_limit//(width*height*3*(.1)))
+    if meta_batch is not None:
+        if 'frames' in format:
+            if meta_batch.frames_per_batch % format['frames'][0] != format['frames'][1]:
+                error = (meta_batch.frames_per_batch - format['frames'][1]) % format['frames'][0]
+                suggested = meta_batch.frames_per_batch - error
+                if error > format['frames'][0] / 2:
+                    suggested += format['frames'][0]
+                raise RuntimeError(f"The chosen frames per batch is incompatible with the selected format. Try {suggested}")
+        if meta_batch.frames_per_batch > max_loadable_frames:
+            raise RuntimeError(f"Meta Batch set to {meta_batch.frames_per_batch} frames but only {max_loadable_frames} can fit in memory")
+        gen = itertools.islice(gen, meta_batch.frames_per_batch)
+    else:
+        original_gen = gen
+        gen = itertools.islice(gen, max_loadable_frames)
+    frames_per_batch = (1920 * 1080 * 16) // (width * height) or 1
+    if vae is not None:
+        gen = batched_vae_encode(gen, vae, frames_per_batch)
+        vw,vh = new_width//downscale_ratio, new_height//downscale_ratio
+        channels = getattr(vae, 'latent_channels', 4)
+        images = torch.from_numpy(np.fromiter(gen, np.dtype((np.float32, (channels,vh,vw)))))
+    else:
+        #Some minor wizardry to eliminate a copy and reduce max memory by a factor of ~2
+        images = torch.from_numpy(np.fromiter(gen, np.dtype((np.float32, (new_height, new_width, 4 if alpha else 3)))))
+    if meta_batch is None and memory_limit is not None:
+        try:
+            next(original_gen)
+            raise RuntimeError(f"Memory limit hit after loading {len(images)} frames. Stopping execution.")
+        except StopIteration:
+            pass
+    if len(images) == 0:
+        raise RuntimeError("No frames generated")
+    if 'frames' in format and len(images) % format['frames'][0] != format['frames'][1]:
+        err_msg = f"The number of frames loaded {len(images)}, does not match the requirements of the currently selected format."
+        if len(format['frames']) > 2 and format['frames'][2]:
+            raise RuntimeError(err_msg)
+        div, mod = format['frames'][:2]
+        frames = (len(images) - mod) // div * div + mod
+        images = images[:frames]
+        #Commenting out log message since it's displayed in UI. consider further
+        #logger.warn(err_msg + f" Output has been truncated to {len(images)} frames.")
+    if 'start_time' in kwargs:
+        start_time = kwargs['start_time']
+    else:
+        start_time = kwargs['skip_first_frames'] * target_frame_time
+    target_frame_time *= kwargs.get('select_every_nth', 1)
+    #Setup lambda for lazy audio capture
+    audio = lazy_get_audio(kwargs['video'], start_time, kwargs['frame_load_cap']*target_frame_time)
+    #Adjust target_frame_time for select_every_nth
+    video_info = {
+        "source_fps": fps,
+        "source_frame_count": total_frames,
+        "source_duration": duration,
+        "source_width": width,
+        "source_height": height,
+        "loaded_fps": 1/target_frame_time,
+        "loaded_frame_count": len(images),
+        "loaded_duration": len(images) * target_frame_time,
+        "loaded_width": new_width,
+        "loaded_height": new_height,
+    }
+    if vae is None:
+        return (images, len(images), audio, video_info)
+    else:
+        return ({"samples": images}, len(images), audio, video_info)
+
+
+
+class LoadVideoUpload:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        files = []
+        for f in os.listdir(input_dir):
+            if os.path.isfile(os.path.join(input_dir, f)):
+                file_parts = f.split('.')
+                if len(file_parts) > 1 and (file_parts[-1].lower() in video_extensions):
+                    files.append(f)
+        return {"required": {
+                    "video": (sorted(files),),
+                    "force_rate": (floatOrInt, {"default": 0, "min": 0, "max": 60, "step": 1, "disable": 0}),
+                    "custom_width": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                    "custom_height": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                    "frame_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1, "disable": 0}),
+                    "skip_first_frames": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                    "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+                    },
+                "optional": {
+                    "meta_batch": ("VHS_BatchManager",),
+                    "vae": ("VAE",),
+                     "format": get_load_formats(),
+                },
+                "hidden": {
+                    "force_size": "STRING",
+                    "unique_id": "UNIQUE_ID"
+                },
+                }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = (imageOrLatent, "INT", "AUDIO", "VHS_VIDEOINFO")
+    RETURN_NAMES = ("IMAGE", "frame_count", "audio", "video_info")
+
+    FUNCTION = "load_video"
+
+    def load_video(self, **kwargs):
+        kwargs['video'] = folder_paths.get_annotated_filepath(strip_path(kwargs['video']))
+        return load_video(**kwargs)
+
+    @classmethod
+    def IS_CHANGED(s, video, **kwargs):
+        image_path = folder_paths.get_annotated_filepath(video)
+        return calculate_file_hash(image_path)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, video):
+        if not folder_paths.exists_annotated_filepath(video):
+            return "Invalid video file: {}".format(video)
+        return True
+
+
+class LoadVideoPath:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "video": ("STRING", {"placeholder": "X://insert/path/here.mp4", "vhs_path_extensions": video_extensions}),
+                "force_rate": (floatOrInt, {"default": 0, "min": 0, "max": 60, "step": 1, "disable": 0}),
+                "custom_width": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                "custom_height": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                "frame_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1, "disable": 0}),
+                "skip_first_frames": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1}),
+                "select_every_nth": ("INT", {"default": 1, "min": 1, "max": BIGMAX, "step": 1}),
+            },
+            "optional": {
+                "meta_batch": ("VHS_BatchManager",),
+                "vae": ("VAE",),
+                "format": get_load_formats(),
+            },
+            "hidden": {
+                "force_size": "STRING",
+                "unique_id": "UNIQUE_ID"
+            },
+        }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = (imageOrLatent, "INT", "AUDIO", "VHS_VIDEOINFO")
+    RETURN_NAMES = ("IMAGE", "frame_count", "audio", "video_info")
+
+    FUNCTION = "load_video"
+
+    def load_video(self, **kwargs):
+        if kwargs['video'] is None or validate_path(kwargs['video']) != True:
+            raise Exception("video is not a valid path: " + kwargs['video'])
+        if is_url(kwargs['video']):
+            kwargs['video'] = try_download_video(kwargs['video']) or kwargs['video']
+        return load_video(**kwargs)
+
+    @classmethod
+    def IS_CHANGED(s, video, **kwargs):
+        return hash_path(video)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, video):
+        return validate_path(video, allow_none=True)
+
+class LoadVideoFFmpegUpload:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        files = []
+        for f in os.listdir(input_dir):
+            if os.path.isfile(os.path.join(input_dir, f)):
+                file_parts = f.split('.')
+                if len(file_parts) > 1 and (file_parts[-1].lower() in video_extensions):
+                    files.append(f)
+        return {"required": {
+                    "video": (sorted(files),),
+                    "force_rate": (floatOrInt, {"default": 0, "min": 0, "max": 60, "step": 1, "disable": 0}),
+                    "custom_width": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                    "custom_height": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                    "frame_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1, "disable": 0}),
+                    "start_time": ("FLOAT", {"default": 0, "min": 0, "max": BIGMAX, "step": .001, "widgetType": "VHSTIMESTAMP"}),
+                    },
+                "optional": {
+                    "meta_batch": ("VHS_BatchManager",),
+                    "vae": ("VAE",),
+                     "format": get_load_formats(),
+                },
+                "hidden": {
+                    "force_size": "STRING",
+                    "unique_id": "UNIQUE_ID"
+
+                },
+                }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = (imageOrLatent, "MASK", "AUDIO", "VHS_VIDEOINFO")
+    RETURN_NAMES = ("IMAGE", "mask", "audio", "video_info")
+
+    FUNCTION = "load_video"
+
+    def load_video(self, **kwargs):
+        kwargs['video'] = folder_paths.get_annotated_filepath(strip_path(kwargs['video']))
+        image, _, audio, video_info =  load_video(**kwargs, generator=ffmpeg_frame_generator)
+        if image.size(3) == 4:
+            return (image[:,:,:,:3], 1-image[:,:,:,3], audio, video_info)
+        return (image, torch.zeros(image.size(0), 64, 64, device="cpu"), audio, video_info)
+
+    @classmethod
+    def IS_CHANGED(s, video, **kwargs):
+        image_path = folder_paths.get_annotated_filepath(video)
+        return calculate_file_hash(image_path)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, video):
+        if not folder_paths.exists_annotated_filepath(video):
+            return "Invalid video file: {}".format(video)
+        return True
+
+
+class LoadVideoFFmpegPath:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "video": ("STRING", {"placeholder": "X://insert/path/here.mp4", "vhs_path_extensions": video_extensions}),
+                "force_rate": (floatOrInt, {"default": 0, "min": 0, "max": 60, "step": 1, "disable": 0}),
+                "custom_width": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                "custom_height": ("INT", {"default": 0, "min": 0, "max": DIMMAX, 'disable': 0}),
+                "frame_load_cap": ("INT", {"default": 0, "min": 0, "max": BIGMAX, "step": 1, "disable": 0}),
+                "start_time": ("FLOAT", {"default": 0, "min": 0, "max": BIGMAX, "step": .001, "widgetType": "VHSTIMESTAMP"}),
+            },
+            "optional": {
+                "meta_batch": ("VHS_BatchManager",),
+                "vae": ("VAE",),
+                "format": get_load_formats(),
+            },
+            "hidden": {
+                "force_size": "STRING",
+                "unique_id": "UNIQUE_ID"
+            },
+        }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = (imageOrLatent, "MASK", "AUDIO", "VHS_VIDEOINFO")
+    RETURN_NAMES = ("IMAGE", "mask", "audio", "video_info")
+
+    FUNCTION = "load_video"
+
+    def load_video(self, **kwargs):
+        if kwargs['video'] is None or validate_path(kwargs['video']) != True:
+            raise Exception("video is not a valid path: " + kwargs['video'])
+        if is_url(kwargs['video']):
+            kwargs['video'] = try_download_video(kwargs['video']) or kwargs['video']
+        image, _, audio, video_info =  load_video(**kwargs, generator=ffmpeg_frame_generator)
+        if isinstance(image, dict):
+            return (image, None, audio, video_info)
+        if image.size(3) == 4:
+            return (image[:,:,:,:3], 1-image[:,:,:,3], audio, video_info)
+        return (image, torch.zeros(image.size(0), 64, 64, device="cpu"), audio, video_info)
+
+    @classmethod
+    def IS_CHANGED(s, video, **kwargs):
+        return hash_path(video)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, video):
+        return validate_path(video, allow_none=True)
+
+class LoadImagePath:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("STRING", {"placeholder": "X://insert/path/here.png", "vhs_path_extensions": list(FolderOfImages.IMG_EXTENSIONS)}),
+                "custom_width": ("INT", {"default": 0, "min": 0, "max": DIMMAX, "step": 8, 'disable': 0}),
+                "custom_height": ("INT", {"default": 0, "min": 0, "max": DIMMAX, "step": 8, 'disable': 0}),
+            },
+            "optional": {
+                "vae": ("VAE",),
+            },
+            "hidden": {
+                "force_size": "STRING",
+            },
+        }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = (imageOrLatent, "MASK")
+    RETURN_NAMES = ("IMAGE", "mask")
+
+    FUNCTION = "load_image"
+
+    def load_image(self, **kwargs):
+        if kwargs['image'] is None or validate_path(kwargs['image']) != True:
+            raise Exception("image is not a valid path: " + kwargs['image'])
+        kwargs.update({'video':  kwargs['image'], 'force_rate': 0, 'frame_load_cap': 0,
+                      'start_time': 0})
+        kwargs.pop('image')
+        image, _, _, _ =  load_video(**kwargs, generator=ffmpeg_frame_generator)
+        if isinstance(image, dict):
+            return (image, None)
+        if image.size(3) == 4:
+            return (image[:,:,:,:3], 1-image[:,:,:,3])
+        return (image, torch.zeros(image.size(0), 64, 64, device="cpu"))
+
+    @classmethod
+    def IS_CHANGED(s, image, **kwargs):
+        return hash_path(image)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, image):
+        return validate_path(image, allow_none=True)

videohelpersuite/logger.py

@@ -0,0 +1,36 @@
+import sys
+import copy
+import logging
+
+
+class ColoredFormatter(logging.Formatter):
+    COLORS = {
+        "DEBUG": "\033[0;36m",  # CYAN
+        "INFO": "\033[0;32m",  # GREEN
+        "WARNING": "\033[0;33m",  # YELLOW
+        "ERROR": "\033[0;31m",  # RED
+        "CRITICAL": "\033[0;37;41m",  # WHITE ON RED
+        "RESET": "\033[0m",  # RESET COLOR
+    }
+
+    def format(self, record):
+        colored_record = copy.copy(record)
+        levelname = colored_record.levelname
+        seq = self.COLORS.get(levelname, self.COLORS["RESET"])
+        colored_record.levelname = f"{seq}{levelname}{self.COLORS['RESET']}"
+        return super().format(colored_record)
+
+
+# Create a new logger
+logger = logging.getLogger("VideoHelperSuite")
+logger.propagate = False
+
+# Add handler if we don't have one.
+if not logger.handlers:
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(ColoredFormatter("[%(name)s] - %(levelname)s - %(message)s"))
+    logger.addHandler(handler)
+
+# Configure logger
+loglevel = logging.INFO
+logger.setLevel(loglevel)

videohelpersuite/nodes.py

@@ -0,0 +1,1111 @@
+import os
+import sys
+import json
+import subprocess
+import numpy as np
+import re
+import datetime
+from typing import List
+import torch
+from PIL import Image, ExifTags
+from PIL.PngImagePlugin import PngInfo
+from pathlib import Path
+from string import Template
+import itertools
+import functools
+
+import folder_paths
+from .logger import logger
+from .image_latent_nodes import *
+from .load_video_nodes import LoadVideoUpload, LoadVideoPath, LoadVideoFFmpegUpload, LoadVideoFFmpegPath, LoadImagePath
+from .load_images_nodes import LoadImagesFromDirectoryUpload, LoadImagesFromDirectoryPath
+from .batched_nodes import VAEEncodeBatched, VAEDecodeBatched
+from .utils import ffmpeg_path, get_audio, hash_path, validate_path, requeue_workflow, \
+        gifski_path, calculate_file_hash, strip_path, try_download_video, is_url, \
+        imageOrLatent, BIGMAX, merge_filter_args, ENCODE_ARGS, floatOrInt, cached, \
+        ContainsAll
+from comfy.utils import ProgressBar
+
+if 'VHS_video_formats' not in folder_paths.folder_names_and_paths:
+    folder_paths.folder_names_and_paths["VHS_video_formats"] = ((),{".json"})
+if len(folder_paths.folder_names_and_paths['VHS_video_formats'][1]) == 0:
+    folder_paths.folder_names_and_paths["VHS_video_formats"][1].add(".json")
+audio_extensions = ['mp3', 'mp4', 'wav', 'ogg']
+
+def flatten_list(l):
+    ret = []
+    for e in l:
+        if isinstance(e, list):
+            ret.extend(e)
+        else:
+            ret.append(e)
+    return ret
+
+def iterate_format(video_format, for_widgets=True):
+    """Provides an iterator over widgets, or arguments"""
+    def indirector(cont, index):
+        if isinstance(cont[index], list) and (not for_widgets
+          or len(cont[index])> 1 and not isinstance(cont[index][1], dict)):
+            inp = yield cont[index]
+            if inp is not None:
+                cont[index] = inp
+                yield
+    for k in video_format:
+        if k == "extra_widgets":
+            if for_widgets:
+                yield from video_format["extra_widgets"]
+        elif k.endswith("_pass"):
+            for i in range(len(video_format[k])):
+                yield from indirector(video_format[k], i)
+            if not for_widgets:
+                video_format[k] = flatten_list(video_format[k])
+        else:
+            yield from indirector(video_format, k)
+
+base_formats_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "video_formats")
+@cached(5)
+def get_video_formats():
+    format_files = {}
+    for format_name in folder_paths.get_filename_list("VHS_video_formats"):
+        format_files[format_name] = folder_paths.get_full_path("VHS_video_formats", format_name)
+    for item in os.scandir(base_formats_dir):
+        if not item.is_file() or not item.name.endswith('.json'):
+            continue
+        format_files[item.name[:-5]] = item.path
+    formats = []
+    format_widgets = {}
+    for format_name, path in format_files.items():
+        with open(path, 'r') as stream:
+            video_format = json.load(stream)
+        if "gifski_pass" in video_format and gifski_path is None:
+            #Skip format
+            continue
+        widgets = list(iterate_format(video_format))
+        formats.append("video/" + format_name)
+        if (len(widgets) > 0):
+            format_widgets["video/"+ format_name] = widgets
+    return formats, format_widgets
+
+def apply_format_widgets(format_name, kwargs):
+    if os.path.exists(os.path.join(base_formats_dir, format_name + ".json")):
+        video_format_path = os.path.join(base_formats_dir, format_name + ".json")
+    else:
+        video_format_path = folder_paths.get_full_path("VHS_video_formats", format_name)
+    with open(video_format_path, 'r') as stream:
+        video_format = json.load(stream)
+    for w in iterate_format(video_format):
+        if w[0] not in kwargs:
+            if len(w) > 2 and 'default' in w[2]:
+                default = w[2]['default']
+            else:
+                if type(w[1]) is list:
+                    default = w[1][0]
+                else:
+                    #NOTE: This doesn't respect max/min, but should be good enough as a fallback to a fallback to a fallback
+                    default = {"BOOLEAN": False, "INT": 0, "FLOAT": 0, "STRING": ""}[w[1]]
+            kwargs[w[0]] = default
+            logger.warn(f"Missing input for {w[0][0]} has been set to {default}")
+    wit = iterate_format(video_format, False)
+    for w in wit:
+        while isinstance(w, list):
+            if len(w) == 1:
+                #TODO: mapping=kwargs should be safer, but results in key errors, investigate why
+                w = [Template(x).substitute(**kwargs) for x in w[0]]
+                break
+            elif isinstance(w[1], dict):
+                w = w[1][str(kwargs[w[0]])]
+            elif len(w) > 3:
+                w = Template(w[3]).substitute(val=kwargs[w[0]])
+            else:
+                w = str(kwargs[w[0]])
+        wit.send(w)
+    return video_format
+
+def tensor_to_int(tensor, bits):
+    tensor = tensor.cpu().numpy() * (2**bits-1) + 0.5
+    return np.clip(tensor, 0, (2**bits-1))
+def tensor_to_shorts(tensor):
+    return tensor_to_int(tensor, 16).astype(np.uint16)
+def tensor_to_bytes(tensor):
+    return tensor_to_int(tensor, 8).astype(np.uint8)
+
+def ffmpeg_process(args, video_format, video_metadata, file_path, env):
+
+    res = None
+    frame_data = yield
+    total_frames_output = 0
+    if video_format.get('save_metadata', 'False') != 'False':
+        os.makedirs(folder_paths.get_temp_directory(), exist_ok=True)
+        metadata = json.dumps(video_metadata)
+        metadata_path = os.path.join(folder_paths.get_temp_directory(), "metadata.txt")
+        #metadata from file should  escape = ; # \ and newline
+        metadata = metadata.replace("\\","\\\\")
+        metadata = metadata.replace(";","\\;")
+        metadata = metadata.replace("#","\\#")
+        metadata = metadata.replace("=","\\=")
+        metadata = metadata.replace("\n","\\\n")
+        metadata = "comment=" + metadata
+        with open(metadata_path, "w") as f:
+            f.write(";FFMETADATA1\n")
+            f.write(metadata)
+        m_args = args[:1] + ["-i", metadata_path] + args[1:] + ["-metadata", "creation_time=now"]
+        with subprocess.Popen(m_args + [file_path], stderr=subprocess.PIPE,
+                              stdin=subprocess.PIPE, env=env) as proc:
+            try:
+                while frame_data is not None:
+                    proc.stdin.write(frame_data)
+                    #TODO: skip flush for increased speed
+                    frame_data = yield
+                    total_frames_output+=1
+                proc.stdin.flush()
+                proc.stdin.close()
+                res = proc.stderr.read()
+            except BrokenPipeError as e:
+                err = proc.stderr.read()
+                #Check if output file exists. If it does, the re-execution
+                #will also fail. This obscures the cause of the error
+                #and seems to never occur concurrent to the metadata issue
+                if os.path.exists(file_path):
+                    raise Exception("An error occurred in the ffmpeg subprocess:\n" \
+                            + err.decode(*ENCODE_ARGS))
+                #Res was not set
+                print(err.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+                logger.warn("An error occurred when saving with metadata")
+    if res != b'':
+        with subprocess.Popen(args + [file_path], stderr=subprocess.PIPE,
+                              stdin=subprocess.PIPE, env=env) as proc:
+            try:
+                while frame_data is not None:
+                    proc.stdin.write(frame_data)
+                    frame_data = yield
+                    total_frames_output+=1
+                proc.stdin.flush()
+                proc.stdin.close()
+                res = proc.stderr.read()
+            except BrokenPipeError as e:
+                res = proc.stderr.read()
+                raise Exception("An error occurred in the ffmpeg subprocess:\n" \
+                        + res.decode(*ENCODE_ARGS))
+    yield total_frames_output
+    if len(res) > 0:
+        print(res.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+
+def gifski_process(args, dimensions, frame_rate, video_format, file_path, env):
+    frame_data = yield
+    with subprocess.Popen(args + video_format['main_pass'] + ['-f', 'yuv4mpegpipe', '-'],
+                          stderr=subprocess.PIPE, stdin=subprocess.PIPE,
+                          stdout=subprocess.PIPE, env=env) as procff:
+        with subprocess.Popen([gifski_path] + video_format['gifski_pass']
+                              + ['-W', f'{dimensions[0]}', '-H', f'{dimensions[1]}']
+                              + ['-r', f'{frame_rate}']
+                              + ['-q', '-o', file_path, '-'], stderr=subprocess.PIPE,
+                              stdin=procff.stdout, stdout=subprocess.PIPE,
+                              env=env) as procgs:
+            try:
+                while frame_data is not None:
+                    procff.stdin.write(frame_data)
+                    frame_data = yield
+                procff.stdin.flush()
+                procff.stdin.close()
+                resff = procff.stderr.read()
+                resgs = procgs.stderr.read()
+                outgs = procgs.stdout.read()
+            except BrokenPipeError as e:
+                procff.stdin.close()
+                resff = procff.stderr.read()
+                resgs = procgs.stderr.read()
+                raise Exception("An error occurred while creating gifski output\n" \
+                        + "Make sure you are using gifski --version >=1.32.0\nffmpeg: " \
+                        + resff.decode(*ENCODE_ARGS) + '\ngifski: ' + resgs.decode(*ENCODE_ARGS))
+    if len(resff) > 0:
+        print(resff.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+    if len(resgs) > 0:
+        print(resgs.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+    #should always be empty as the quiet flag is passed
+    if len(outgs) > 0:
+        print(outgs.decode(*ENCODE_ARGS))
+
+def to_pingpong(inp):
+    if not hasattr(inp, "__getitem__"):
+        inp = list(inp)
+    yield from inp
+    for i in range(len(inp)-2,0,-1):
+        yield inp[i]
+
+class VideoCombine:
+    @classmethod
+    def INPUT_TYPES(s):
+        ffmpeg_formats, format_widgets = get_video_formats()
+        format_widgets["image/webp"] = [['lossless', "BOOLEAN", {'default': True}]]
+        return {
+            "required": {
+                "images": (imageOrLatent,),
+                "frame_rate": (
+                    floatOrInt,
+                    {"default": 8, "min": 1, "step": 1},
+                ),
+                "loop_count": ("INT", {"default": 0, "min": 0, "max": 100, "step": 1}),
+                "filename_prefix": ("STRING", {"default": "AnimateDiff"}),
+                "format": (["image/gif", "image/webp"] + ffmpeg_formats, {'formats': format_widgets}),
+                "pingpong": ("BOOLEAN", {"default": False}),
+                "save_output": ("BOOLEAN", {"default": True}),
+            },
+            "optional": {
+                "audio": ("AUDIO",),
+                "meta_batch": ("VHS_BatchManager",),
+                "vae": ("VAE",),
+            },
+            "hidden": ContainsAll({
+                "prompt": "PROMPT",
+                "extra_pnginfo": "EXTRA_PNGINFO",
+                "unique_id": "UNIQUE_ID"
+            }),
+        }
+
+    RETURN_TYPES = ("VHS_FILENAMES",)
+    RETURN_NAMES = ("Filenames",)
+    OUTPUT_NODE = True
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+    FUNCTION = "combine_video"
+
+    def combine_video(
+        self,
+        frame_rate: int,
+        loop_count: int,
+        images=None,
+        latents=None,
+        filename_prefix="AnimateDiff",
+        format="image/gif",
+        pingpong=False,
+        save_output=True,
+        prompt=None,
+        extra_pnginfo=None,
+        audio=None,
+        unique_id=None,
+        manual_format_widgets=None,
+        meta_batch=None,
+        vae=None,
+        **kwargs
+    ):
+        if latents is not None:
+            images = latents
+        if images is None:
+            return ((save_output, []),)
+        if vae is not None:
+            if isinstance(images, dict):
+                images = images['samples']
+            else:
+                vae = None
+
+        if isinstance(images, torch.Tensor) and images.size(0) == 0:
+            return ((save_output, []),)
+        num_frames = len(images)
+        pbar = ProgressBar(num_frames)
+        if vae is not None:
+            downscale_ratio = getattr(vae, "downscale_ratio", 8)
+            width = images.size(-1)*downscale_ratio
+            height = images.size(-2)*downscale_ratio
+            frames_per_batch = (1920 * 1080 * 16) // (width * height) or 1
+            #Python 3.12 adds an itertools.batched, but it's easily replicated for legacy support
+            def batched(it, n):
+                while batch := tuple(itertools.islice(it, n)):
+                    yield batch
+            def batched_encode(images, vae, frames_per_batch):
+                for batch in batched(iter(images), frames_per_batch):
+                    image_batch = torch.from_numpy(np.array(batch))
+                    yield from vae.decode(image_batch)
+            images = batched_encode(images, vae, frames_per_batch)
+            first_image = next(images)
+            #repush first_image
+            images = itertools.chain([first_image], images)
+            #A single image has 3 dimensions. Discard higher dimensions
+            while len(first_image.shape) > 3:
+                first_image = first_image[0]
+        else:
+            first_image = images[0]
+            images = iter(images)
+        # get output information
+        output_dir = (
+            folder_paths.get_output_directory()
+            if save_output
+            else folder_paths.get_temp_directory()
+        )
+        (
+            full_output_folder,
+            filename,
+            _,
+            subfolder,
+            _,
+        ) = folder_paths.get_save_image_path(filename_prefix, output_dir)
+        output_files = []
+
+        metadata = PngInfo()
+        video_metadata = {}
+        if prompt is not None:
+            metadata.add_text("prompt", json.dumps(prompt))
+            video_metadata["prompt"] = json.dumps(prompt)
+        if extra_pnginfo is not None:
+            for x in extra_pnginfo:
+                metadata.add_text(x, json.dumps(extra_pnginfo[x]))
+                video_metadata[x] = extra_pnginfo[x]
+            extra_options = extra_pnginfo.get('workflow', {}).get('extra', {})
+        else:
+            extra_options = {}
+        metadata.add_text("CreationTime", datetime.datetime.now().isoformat(" ")[:19])
+
+        if meta_batch is not None and unique_id in meta_batch.outputs:
+            (counter, output_process) = meta_batch.outputs[unique_id]
+        else:
+            # comfy counter workaround
+            max_counter = 0
+
+            # Loop through the existing files
+            matcher = re.compile(f"{re.escape(filename)}_(\\d+)\\D*\\..+", re.IGNORECASE)
+            for existing_file in os.listdir(full_output_folder):
+                # Check if the file matches the expected format
+                match = matcher.fullmatch(existing_file)
+                if match:
+                    # Extract the numeric portion of the filename
+                    file_counter = int(match.group(1))
+                    # Update the maximum counter value if necessary
+                    if file_counter > max_counter:
+                        max_counter = file_counter
+
+            # Increment the counter by 1 to get the next available value
+            counter = max_counter + 1
+            output_process = None
+
+        # save first frame as png to keep metadata
+        first_image_file = f"{filename}_{counter:05}.png"
+        file_path = os.path.join(full_output_folder, first_image_file)
+        if extra_options.get('VHS_MetadataImage', True) != False:
+            Image.fromarray(tensor_to_bytes(first_image)).save(
+                file_path,
+                pnginfo=metadata,
+                compress_level=4,
+            )
+        output_files.append(file_path)
+
+        format_type, format_ext = format.split("/")
+        if format_type == "image":
+            if meta_batch is not None:
+                raise Exception("Pillow('image/') formats are not compatible with batched output")
+            image_kwargs = {}
+            if format_ext == "gif":
+                image_kwargs['disposal'] = 2
+            if format_ext == "webp":
+                #Save timestamp information
+                exif = Image.Exif()
+                exif[ExifTags.IFD.Exif] = {36867: datetime.datetime.now().isoformat(" ")[:19]}
+                image_kwargs['exif'] = exif
+                image_kwargs['lossless'] = kwargs.get("lossless", True)
+            file = f"{filename}_{counter:05}.{format_ext}"
+            file_path = os.path.join(full_output_folder, file)
+            if pingpong:
+                images = to_pingpong(images)
+            def frames_gen(images):
+                for i in images:
+                    pbar.update(1)
+                    yield Image.fromarray(tensor_to_bytes(i))
+            frames = frames_gen(images)
+            # Use pillow directly to save an animated image
+            next(frames).save(
+                file_path,
+                format=format_ext.upper(),
+                save_all=True,
+                append_images=frames,
+                duration=round(1000 / frame_rate),
+                loop=loop_count,
+                compress_level=4,
+                **image_kwargs
+            )
+            output_files.append(file_path)
+        else:
+            # Use ffmpeg to save a video
+            if ffmpeg_path is None:
+                raise ProcessLookupError(f"ffmpeg is required for video outputs and could not be found.\nIn order to use video outputs, you must either:\n- Install imageio-ffmpeg with pip,\n- Place a ffmpeg executable in {os.path.abspath('')}, or\n- Install ffmpeg and add it to the system path.")
+
+            if manual_format_widgets is not None:
+                logger.warn("Format args can now be passed directly. The manual_format_widgets argument is now deprecated")
+                kwargs.update(manual_format_widgets)
+
+            has_alpha = first_image.shape[-1] == 4
+            kwargs["has_alpha"] = has_alpha
+            video_format = apply_format_widgets(format_ext, kwargs)
+            dim_alignment = video_format.get("dim_alignment", 2)
+            if (first_image.shape[1] % dim_alignment) or (first_image.shape[0] % dim_alignment):
+                #output frames must be padded
+                to_pad = (-first_image.shape[1] % dim_alignment,
+                          -first_image.shape[0] % dim_alignment)
+                padding = (to_pad[0]//2, to_pad[0] - to_pad[0]//2,
+                           to_pad[1]//2, to_pad[1] - to_pad[1]//2)
+                padfunc = torch.nn.ReplicationPad2d(padding)
+                def pad(image):
+                    image = image.permute((2,0,1))#HWC to CHW
+                    padded = padfunc(image.to(dtype=torch.float32))
+                    return padded.permute((1,2,0))
+                images = map(pad, images)
+                dimensions = (-first_image.shape[1] % dim_alignment + first_image.shape[1],
+                              -first_image.shape[0] % dim_alignment + first_image.shape[0])
+                logger.warn("Output images were not of valid resolution and have had padding applied")
+            else:
+                dimensions = (first_image.shape[1], first_image.shape[0])
+            if pingpong:
+                if meta_batch is not None:
+                    logger.error("pingpong is incompatible with batched output")
+                images = to_pingpong(images)
+                if num_frames > 2:
+                    num_frames += num_frames -2
+                    pbar.total = num_frames
+            if loop_count > 0:
+                loop_args = ["-vf", "loop=loop=" + str(loop_count)+":size=" + str(num_frames)]
+            else:
+                loop_args = []
+            if video_format.get('input_color_depth', '8bit') == '16bit':
+                images = map(tensor_to_shorts, images)
+                if has_alpha:
+                    i_pix_fmt = 'rgba64'
+                else:
+                    i_pix_fmt = 'rgb48'
+            else:
+                images = map(tensor_to_bytes, images)
+                if has_alpha:
+                    i_pix_fmt = 'rgba'
+                else:
+                    i_pix_fmt = 'rgb24'
+            file = f"{filename}_{counter:05}.{video_format['extension']}"
+            file_path = os.path.join(full_output_folder, file)
+            bitrate_arg = []
+            bitrate = video_format.get('bitrate')
+            if bitrate is not None:
+                bitrate_arg = ["-b:v", str(bitrate) + "M" if video_format.get('megabit') == 'True' else str(bitrate) + "K"]
+            args = [ffmpeg_path, "-v", "error", "-f", "rawvideo", "-pix_fmt", i_pix_fmt,
+                    # The image data is in an undefined generic RGB color space, which in practice means sRGB.
+                    # sRGB has the same primaries and matrix as BT.709, but a different transfer function (gamma),
+                    # called by the sRGB standard name IEC 61966-2-1. However, video hosting platforms like YouTube
+                    # standardize on full BT.709 and will convert the colors accordingly. This last minute change
+                    # in colors can be confusing to users. We can counter it by lying about the transfer function
+                    # on a per format basis, i.e. for video we will lie to FFmpeg that it is already BT.709. Also,
+                    # because the input data is in RGB (not YUV) it is more efficient (fewer scale filter invocations)
+                    # to specify the input color space as RGB and then later, if the format actually wants YUV,
+                    # to convert it to BT.709 YUV via FFmpeg's -vf "scale=out_color_matrix=bt709".
+                    "-color_range", "pc", "-colorspace", "rgb", "-color_primaries", "bt709",
+                    "-color_trc", video_format.get("fake_trc", "iec61966-2-1"),
+                    "-s", f"{dimensions[0]}x{dimensions[1]}", "-r", str(frame_rate), "-i", "-"] \
+                    + loop_args
+
+            images = map(lambda x: x.tobytes(), images)
+            env=os.environ.copy()
+            if  "environment" in video_format:
+                env.update(video_format["environment"])
+
+            if "pre_pass" in video_format:
+                if meta_batch is not None:
+                    #Performing a prepass requires keeping access to all frames.
+                    #Potential solutions include keeping just output frames in
+                    #memory or using 3 passes with intermediate file, but
+                    #very long gifs probably shouldn't be encouraged
+                    raise Exception("Formats which require a pre_pass are incompatible with Batch Manager.")
+                images = [b''.join(images)]
+                os.makedirs(folder_paths.get_temp_directory(), exist_ok=True)
+                in_args_len = args.index("-i") + 2 # The index after ["-i", "-"]
+                pre_pass_args = args[:in_args_len] + video_format['pre_pass']
+                merge_filter_args(pre_pass_args)
+                try:
+                    subprocess.run(pre_pass_args, input=images[0], env=env,
+                                   capture_output=True, check=True)
+                except subprocess.CalledProcessError as e:
+                    raise Exception("An error occurred in the ffmpeg prepass:\n" \
+                            + e.stderr.decode(*ENCODE_ARGS))
+            if "inputs_main_pass" in video_format:
+                in_args_len = args.index("-i") + 2 # The index after ["-i", "-"]
+                args = args[:in_args_len] + video_format['inputs_main_pass'] + args[in_args_len:]
+
+            if output_process is None:
+                if 'gifski_pass' in video_format:
+                    format = 'image/gif'
+                    output_process = gifski_process(args, dimensions, frame_rate, video_format, file_path, env)
+                    audio = None
+                else:
+                    args += video_format['main_pass'] + bitrate_arg
+                    merge_filter_args(args)
+                    output_process = ffmpeg_process(args, video_format, video_metadata, file_path, env)
+                #Proceed to first yield
+                output_process.send(None)
+                if meta_batch is not None:
+                    meta_batch.outputs[unique_id] = (counter, output_process)
+
+            for image in images:
+                pbar.update(1)
+                output_process.send(image)
+            if meta_batch is not None:
+                requeue_workflow((meta_batch.unique_id, not meta_batch.has_closed_inputs))
+            if meta_batch is None or meta_batch.has_closed_inputs:
+                #Close pipe and wait for termination.
+                try:
+                    total_frames_output = output_process.send(None)
+                    output_process.send(None)
+                except StopIteration:
+                    pass
+                if meta_batch is not None:
+                    meta_batch.outputs.pop(unique_id)
+                    if len(meta_batch.outputs) == 0:
+                        meta_batch.reset()
+            else:
+                #batch is unfinished
+                #TODO: Check if empty output breaks other custom nodes
+                return {"ui": {"unfinished_batch": [True]}, "result": ((save_output, []),)}
+
+            output_files.append(file_path)
+
+
+            a_waveform = None
+            if audio is not None:
+                try:
+                    #safely check if audio produced by VHS_LoadVideo actually exists
+                    a_waveform = audio['waveform']
+                except:
+                    pass
+            if a_waveform is not None:
+                # Create audio file if input was provided
+                output_file_with_audio = f"{filename}_{counter:05}-audio.{video_format['extension']}"
+                output_file_with_audio_path = os.path.join(full_output_folder, output_file_with_audio)
+                if "audio_pass" not in video_format:
+                    logger.warn("Selected video format does not have explicit audio support")
+                    video_format["audio_pass"] = ["-c:a", "libopus"]
+
+
+                # FFmpeg command with audio re-encoding
+                #TODO: expose audio quality options if format widgets makes it in
+                #Reconsider forcing apad/shortest
+                channels = audio['waveform'].size(1)
+                min_audio_dur = total_frames_output / frame_rate + 1
+                if video_format.get('trim_to_audio', 'False') != 'False':
+                    apad = []
+                else:
+                    apad = ["-af", "apad=whole_dur="+str(min_audio_dur)]
+                mux_args = [ffmpeg_path, "-v", "error", "-n", "-i", file_path,
+                            "-ar", str(audio['sample_rate']), "-ac", str(channels),
+                            "-f", "f32le", "-i", "-", "-c:v", "copy"] \
+                            + video_format["audio_pass"] \
+                            + apad + ["-shortest", output_file_with_audio_path]
+
+                audio_data = audio['waveform'].squeeze(0).transpose(0,1) \
+                        .numpy().tobytes()
+                merge_filter_args(mux_args, '-af')
+                try:
+                    res = subprocess.run(mux_args, input=audio_data,
+                                         env=env, capture_output=True, check=True)
+                except subprocess.CalledProcessError as e:
+                    raise Exception("An error occured in the ffmpeg subprocess:\n" \
+                            + e.stderr.decode(*ENCODE_ARGS))
+                if res.stderr:
+                    print(res.stderr.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+                output_files.append(output_file_with_audio_path)
+                #Return this file with audio to the webui.
+                #It will be muted unless opened or saved with right click
+                file = output_file_with_audio
+        if extra_options.get('VHS_KeepIntermediate', True) == False:
+            for intermediate in output_files[1:-1]:
+                if os.path.exists(intermediate):
+                    os.remove(intermediate)
+        preview = {
+                "filename": file,
+                "subfolder": subfolder,
+                "type": "output" if save_output else "temp",
+                "format": format,
+                "frame_rate": frame_rate,
+                "workflow": first_image_file,
+                "fullpath": output_files[-1],
+            }
+        if num_frames == 1 and 'png' in format and '%03d' in file:
+            preview['format'] = 'image/png'
+            preview['filename'] = file.replace('%03d', '001')
+        return {"ui": {"gifs": [preview]}, "result": ((save_output, output_files),)}
+
+class LoadAudio:
+    @classmethod
+    def INPUT_TYPES(s):
+        #Hide ffmpeg formats if ffmpeg isn't available
+        return {
+            "required": {
+                "audio_file": ("STRING", {"default": "input/", "vhs_path_extensions": ['wav','mp3','ogg','m4a','flac']}),
+                },
+            "optional" : {
+                "seek_seconds": ("FLOAT", {"default": 0, "min": 0, "widgetType": "VHSTIMESTAMP"}),
+                "duration": ("FLOAT" , {"default": 0, "min": 0, "max": 10000000, "step": 0.01, "widgetType": "VHSTIMESTAMP"}),
+                          }
+        }
+
+    RETURN_TYPES = ("AUDIO", "FLOAT")
+    RETURN_NAMES = ("audio", "duration")
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/audio"
+    FUNCTION = "load_audio"
+    def load_audio(self, audio_file, seek_seconds=0, duration=0):
+        audio_file = strip_path(audio_file)
+        if audio_file is None or validate_path(audio_file) != True:
+            raise Exception("audio_file is not a valid path: " + audio_file)
+        if is_url(audio_file):
+            audio_file = try_download_video(audio_file) or audio_file
+        #Eagerly fetch the audio since the user must be using it if the
+        #node executes, unlike Load Video
+        audio = get_audio(audio_file, start_time=seek_seconds, duration=duration)
+        loaded_duration = audio['waveform'].size(2)/audio['sample_rate']
+        return (audio, loaded_duration)
+
+    @classmethod
+    def IS_CHANGED(s, audio_file, **kwargs):
+        return hash_path(audio_file)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, audio_file, **kwargs):
+        return validate_path(audio_file, allow_none=True)
+
+class LoadAudioUpload:
+    @classmethod
+    def INPUT_TYPES(s):
+        input_dir = folder_paths.get_input_directory()
+        files = []
+        for f in os.listdir(input_dir):
+            if os.path.isfile(os.path.join(input_dir, f)):
+                file_parts = f.split('.')
+                if len(file_parts) > 1 and (file_parts[-1] in audio_extensions):
+                    files.append(f)
+        return {"required": {
+                    "audio": (sorted(files),),},
+                "optional": {
+                    "start_time": ("FLOAT" , {"default": 0, "min": 0, "max": 10000000, "step": 0.01, "widgetType": "VHSTIMESTAMP"}),
+                    "duration": ("FLOAT" , {"default": 0, "min": 0, "max": 10000000, "step": 0.01, "widgetType": "VHSTIMESTAMP"}),
+                     },
+                }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/audio"
+
+    RETURN_TYPES = ("AUDIO", "FLOAT")
+    RETURN_NAMES = ("audio", "duration")
+    FUNCTION = "load_audio"
+
+    def load_audio(self, start_time=0, duration=0, **kwargs):
+        audio_file = folder_paths.get_annotated_filepath(strip_path(kwargs['audio']))
+        if audio_file is None or validate_path(audio_file) != True:
+            raise Exception("audio_file is not a valid path: " + audio_file)
+        
+        audio = get_audio(audio_file, start_time, duration)
+        loaded_duration = audio['waveform'].size(2)/audio['sample_rate']
+        return (audio, loaded_duration)
+
+    @classmethod
+    def IS_CHANGED(s, audio, **kwargs):
+        audio_file = folder_paths.get_annotated_filepath(strip_path(audio))
+        return hash_path(audio_file)
+
+    @classmethod
+    def VALIDATE_INPUTS(s, audio, **kwargs):
+        audio_file = folder_paths.get_annotated_filepath(strip_path(audio))
+        return validate_path(audio_file, allow_none=True)
+class AudioToVHSAudio:
+    """Legacy method for external nodes that utilized VHS_AUDIO,
+    VHS_AUDIO is deprecated as a format and should no longer be used"""
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"audio": ("AUDIO",)}}
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/audio"
+
+    RETURN_TYPES = ("VHS_AUDIO", )
+    RETURN_NAMES = ("vhs_audio",)
+    FUNCTION = "convert_audio"
+
+    def convert_audio(self, audio):
+        ar = str(audio['sample_rate'])
+        ac = str(audio['waveform'].size(1))
+        mux_args = [ffmpeg_path, "-f", "f32le", "-ar", ar, "-ac", ac,
+                    "-i", "-", "-f", "wav", "-"]
+
+        audio_data = audio['waveform'].squeeze(0).transpose(0,1) \
+                .numpy().tobytes()
+        try:
+            res = subprocess.run(mux_args, input=audio_data,
+                                 capture_output=True, check=True)
+        except subprocess.CalledProcessError as e:
+            raise Exception("An error occured in the ffmpeg subprocess:\n" \
+                    + e.stderr.decode(*ENCODE_ARGS))
+        if res.stderr:
+            print(res.stderr.decode(*ENCODE_ARGS), end="", file=sys.stderr)
+        return (lambda: res.stdout,)
+
+class VHSAudioToAudio:
+    """Legacy method for external nodes that utilized VHS_AUDIO,
+    VHS_AUDIO is deprecated as a format and should no longer be used"""
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"vhs_audio": ("VHS_AUDIO",)}}
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢/audio"
+
+    RETURN_TYPES = ("AUDIO", )
+    RETURN_NAMES = ("audio",)
+    FUNCTION = "convert_audio"
+
+    def convert_audio(self, vhs_audio):
+        if not vhs_audio or not vhs_audio():
+            raise Exception("audio input is not valid")
+        args = [ffmpeg_path, "-i", '-']
+        try:
+            res =  subprocess.run(args + ["-f", "f32le", "-"], input=vhs_audio(),
+                                  capture_output=True, check=True)
+            audio = torch.frombuffer(bytearray(res.stdout), dtype=torch.float32)
+        except subprocess.CalledProcessError as e:
+            raise Exception("An error occured in the ffmpeg subprocess:\n" \
+                    + e.stderr.decode(*ENCODE_ARGS))
+        match = re.search(', (\\d+) Hz, (\\w+), ',res.stderr.decode(*ENCODE_ARGS))
+        if match:
+            ar = int(match.group(1))
+            #NOTE: Just throwing an error for other channel types right now
+            #Will deal with issues if they come
+            ac = {"mono": 1, "stereo": 2}[match.group(2)]
+        else:
+            ar = 44100
+            ac = 2
+        audio = audio.reshape((-1,ac)).transpose(0,1).unsqueeze(0)
+        return ({'waveform': audio, 'sample_rate': ar},)
+
+class PruneOutputs:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "filenames": ("VHS_FILENAMES",),
+                    "options": (["Intermediate", "Intermediate and Utility"],)
+                    }
+                }
+
+    RETURN_TYPES = ()
+    OUTPUT_NODE = True
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+    FUNCTION = "prune_outputs"
+
+    def prune_outputs(self, filenames, options):
+        if len(filenames[1]) == 0:
+            return ()
+        assert(len(filenames[1]) <= 3 and len(filenames[1]) >= 2)
+        delete_list = []
+        if options in ["Intermediate", "Intermediate and Utility", "All"]:
+            delete_list += filenames[1][1:-1]
+        if options in ["Intermediate and Utility", "All"]:
+            delete_list.append(filenames[1][0])
+        if options in ["All"]:
+            delete_list.append(filenames[1][-1])
+
+        output_dirs = [folder_paths.get_output_directory(),
+                       folder_paths.get_temp_directory()]
+        for file in delete_list:
+            #Check that path is actually an output directory
+            if (os.path.commonpath([output_dirs[0], file]) != output_dirs[0]) \
+                    and (os.path.commonpath([output_dirs[1], file]) != output_dirs[1]):
+                        raise Exception("Tried to prune output from invalid directory: " + file)
+            if os.path.exists(file):
+                os.remove(file)
+        return ()
+
+class BatchManager:
+    def __init__(self, frames_per_batch=-1):
+        self.frames_per_batch = frames_per_batch
+        self.inputs = {}
+        self.outputs = {}
+        self.unique_id = None
+        self.has_closed_inputs = False
+        self.total_frames = float('inf')
+    def reset(self):
+        self.close_inputs()
+        for key in self.outputs:
+            if getattr(self.outputs[key][-1], "gi_suspended", False):
+                try:
+                    self.outputs[key][-1].send(None)
+                except StopIteration:
+                    pass
+        self.__init__(self.frames_per_batch)
+    def has_open_inputs(self):
+        return len(self.inputs) > 0
+    def close_inputs(self):
+        for key in self.inputs:
+            if getattr(self.inputs[key][-1], "gi_suspended", False):
+                try:
+                    self.inputs[key][-1].send(1)
+                except StopIteration:
+                    pass
+        self.inputs = {}
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "frames_per_batch": ("INT", {"default": 16, "min": 1, "max": BIGMAX, "step": 1})
+                    },
+                "hidden": {
+                    "prompt": "PROMPT",
+                    "unique_id": "UNIQUE_ID"
+                },
+                }
+
+    RETURN_TYPES = ("VHS_BatchManager",)
+    RETURN_NAMES = ("meta_batch",)
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+    FUNCTION = "update_batch"
+
+    def update_batch(self, frames_per_batch, prompt=None, unique_id=None):
+        if unique_id is not None and prompt is not None:
+            requeue = prompt[unique_id]['inputs'].get('requeue', 0)
+        else:
+            requeue = 0
+        if requeue == 0:
+            self.reset()
+            self.frames_per_batch = frames_per_batch
+            self.unique_id = unique_id
+        else:
+            num_batches = (self.total_frames+self.frames_per_batch-1)//frames_per_batch
+            print(f'Meta-Batch {requeue}/{num_batches}')
+        #onExecuted seems to not be called unless some message is sent
+        return (self,)
+
+
+class VideoInfo:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "video_info": ("VHS_VIDEOINFO",),
+                    }
+                }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = ("FLOAT","INT", "FLOAT", "INT", "INT", "FLOAT","INT", "FLOAT", "INT", "INT")
+    RETURN_NAMES = (
+        "source_fps🟨",
+        "source_frame_count🟨",
+        "source_duration🟨",
+        "source_width🟨",
+        "source_height🟨",
+        "loaded_fps🟦",
+        "loaded_frame_count🟦",
+        "loaded_duration🟦",
+        "loaded_width🟦",
+        "loaded_height🟦",
+    )
+    FUNCTION = "get_video_info"
+
+    def get_video_info(self, video_info):
+        keys = ["fps", "frame_count", "duration", "width", "height"]
+        
+        source_info = []
+        loaded_info = []
+
+        for key in keys:
+            source_info.append(video_info[f"source_{key}"])
+            loaded_info.append(video_info[f"loaded_{key}"])
+
+        return (*source_info, *loaded_info)
+
+
+class VideoInfoSource:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "video_info": ("VHS_VIDEOINFO",),
+                    }
+                }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = ("FLOAT","INT", "FLOAT", "INT", "INT",)
+    RETURN_NAMES = (
+        "fps🟨",
+        "frame_count🟨",
+        "duration🟨",
+        "width🟨",
+        "height🟨",
+    )
+    FUNCTION = "get_video_info"
+
+    def get_video_info(self, video_info):
+        keys = ["fps", "frame_count", "duration", "width", "height"]
+        
+        source_info = []
+
+        for key in keys:
+            source_info.append(video_info[f"source_{key}"])
+
+        return (*source_info,)
+
+
+class VideoInfoLoaded:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+                "required": {
+                    "video_info": ("VHS_VIDEOINFO",),
+                    }
+                }
+
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+
+    RETURN_TYPES = ("FLOAT","INT", "FLOAT", "INT", "INT",)
+    RETURN_NAMES = (
+        "fps🟦",
+        "frame_count🟦",
+        "duration🟦",
+        "width🟦",
+        "height🟦",
+    )
+    FUNCTION = "get_video_info"
+
+    def get_video_info(self, video_info):
+        keys = ["fps", "frame_count", "duration", "width", "height"]
+        
+        loaded_info = []
+
+        for key in keys:
+            loaded_info.append(video_info[f"loaded_{key}"])
+
+        return (*loaded_info,)
+
+class SelectFilename:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"filenames": ("VHS_FILENAMES",), "index": ("INT", {"default": -1, "step": 1, "min": -1})}}
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES =("Filename",)
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+    FUNCTION = "select_filename"
+
+    def select_filename(self, filenames, index):
+        return (filenames[1][index],)
+class Unbatch:
+    class Any(str):
+        def __ne__(self, other):
+            return False
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"batched": ("*",)}}
+    RETURN_TYPES = (Any('*'),)
+    INPUT_IS_LIST = True
+    RETURN_NAMES =("unbatched",)
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+    FUNCTION = "unbatch"
+    def unbatch(self, batched):
+        if isinstance(batched[0], torch.Tensor):
+            return (torch.cat(batched),)
+        if isinstance(batched[0], dict):
+            out = batched[0].copy()
+            if 'samples' in out:
+                out['samples'] = torch.cat([x['samples'] for x in batched])
+            if 'waveform' in out:
+                out['waveform'] = torch.cat([x['waveform'] for x in batched])
+            out.pop('batch_index', None)
+            return (out,)
+        return (functools.reduce(lambda x,y: x+y, batched),)
+    @classmethod
+    def VALIDATE_INPUTS(cls, input_types):
+        return True
+class SelectLatest:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"filename_prefix": ("STRING", {'default': 'output/AnimateDiff', 'vhs_path_extensions': []}),
+                             "filename_postfix": ("STRING", {"placeholder": ".webm"})}}
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES =("Filename",)
+    CATEGORY = "Video Helper Suite 🎥🅥🅗🅢"
+    FUNCTION = "select_latest"
+    EXPERIMENTAL = True
+
+    def select_latest(self, filename_prefix, filename_postfix):
+        assert False, "Not Reachable"
+
+NODE_CLASS_MAPPINGS = {
+    "VHS_VideoCombine": VideoCombine,
+    "VHS_LoadVideo": LoadVideoUpload,
+    "VHS_LoadVideoPath": LoadVideoPath,
+    "VHS_LoadVideoFFmpeg": LoadVideoFFmpegUpload,
+    "VHS_LoadVideoFFmpegPath": LoadVideoFFmpegPath,
+    "VHS_LoadImagePath": LoadImagePath,
+    "VHS_LoadImages": LoadImagesFromDirectoryUpload,
+    "VHS_LoadImagesPath": LoadImagesFromDirectoryPath,
+    "VHS_LoadAudio": LoadAudio,
+    "VHS_LoadAudioUpload": LoadAudioUpload,
+    "VHS_AudioToVHSAudio": AudioToVHSAudio,
+    "VHS_VHSAudioToAudio": VHSAudioToAudio,
+    "VHS_PruneOutputs": PruneOutputs,
+    "VHS_BatchManager": BatchManager,
+    "VHS_VideoInfo": VideoInfo,
+    "VHS_VideoInfoSource": VideoInfoSource,
+    "VHS_VideoInfoLoaded": VideoInfoLoaded,
+    "VHS_SelectFilename": SelectFilename,
+    # Batched Nodes
+    "VHS_VAEEncodeBatched": VAEEncodeBatched,
+    "VHS_VAEDecodeBatched": VAEDecodeBatched,
+    # Latent and Image nodes
+    "VHS_SplitLatents": SplitLatents,
+    "VHS_SplitImages": SplitImages,
+    "VHS_SplitMasks": SplitMasks,
+    "VHS_MergeLatents": MergeLatents,
+    "VHS_MergeImages": MergeImages,
+    "VHS_MergeMasks": MergeMasks,
+    "VHS_GetLatentCount": GetLatentCount,
+    "VHS_GetImageCount": GetImageCount,
+    "VHS_GetMaskCount": GetMaskCount,
+    "VHS_DuplicateLatents": RepeatLatents,
+    "VHS_DuplicateImages": RepeatImages,
+    "VHS_DuplicateMasks": RepeatMasks,
+    "VHS_SelectEveryNthLatent": SelectEveryNthLatent,
+    "VHS_SelectEveryNthImage": SelectEveryNthImage,
+    "VHS_SelectEveryNthMask": SelectEveryNthMask,
+    "VHS_SelectLatents": SelectLatents,
+    "VHS_SelectImages": SelectImages,
+    "VHS_SelectMasks": SelectMasks,
+    "VHS_Unbatch": Unbatch,
+    "VHS_SelectLatest": SelectLatest,
+}
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "VHS_VideoCombine": "Video Combine 🎥🅥🅗🅢",
+    "VHS_LoadVideo": "Load Video (Upload) 🎥🅥🅗🅢",
+    "VHS_LoadVideoPath": "Load Video (Path) 🎥🅥🅗🅢",
+    "VHS_LoadVideoFFmpeg": "Load Video FFmpeg (Upload) 🎥🅥🅗🅢",
+    "VHS_LoadVideoFFmpegPath": "Load Video FFmpeg (Path) 🎥🅥🅗🅢",
+    "VHS_LoadImagePath": "Load Image (Path) 🎥🅥🅗🅢",
+    "VHS_LoadImages": "Load Images (Upload) 🎥🅥🅗🅢",
+    "VHS_LoadImagesPath": "Load Images (Path) 🎥🅥🅗🅢",
+    "VHS_LoadAudio": "Load Audio (Path)🎥🅥🅗🅢",
+    "VHS_LoadAudioUpload": "Load Audio (Upload)🎥🅥🅗🅢",
+    "VHS_AudioToVHSAudio": "Audio to legacy VHS_AUDIO🎥🅥🅗🅢",
+    "VHS_VHSAudioToAudio": "Legacy VHS_AUDIO to Audio🎥🅥🅗🅢",
+    "VHS_PruneOutputs": "Prune Outputs 🎥🅥🅗🅢",
+    "VHS_BatchManager": "Meta Batch Manager 🎥🅥🅗🅢",
+    "VHS_VideoInfo": "Video Info 🎥🅥🅗🅢",
+    "VHS_VideoInfoSource": "Video Info (Source) 🎥🅥🅗🅢",
+    "VHS_VideoInfoLoaded": "Video Info (Loaded) 🎥🅥🅗🅢",
+    "VHS_SelectFilename": "Select Filename 🎥🅥🅗🅢",
+    # Batched Nodes
+    "VHS_VAEEncodeBatched": "VAE Encode Batched 🎥🅥🅗🅢",
+    "VHS_VAEDecodeBatched": "VAE Decode Batched 🎥🅥🅗🅢",
+    # Latent and Image nodes
+    "VHS_SplitLatents": "Split Latents 🎥🅥🅗🅢",
+    "VHS_SplitImages": "Split Images 🎥🅥🅗🅢",
+    "VHS_SplitMasks": "Split Masks 🎥🅥🅗🅢",
+    "VHS_MergeLatents": "Merge Latents 🎥🅥🅗🅢",
+    "VHS_MergeImages": "Merge Images 🎥🅥🅗🅢",
+    "VHS_MergeMasks": "Merge Masks 🎥🅥🅗🅢",
+    "VHS_GetLatentCount": "Get Latent Count 🎥🅥🅗🅢",
+    "VHS_GetImageCount": "Get Image Count 🎥🅥🅗🅢",
+    "VHS_GetMaskCount": "Get Mask Count 🎥🅥🅗🅢",
+    "VHS_DuplicateLatents": "Repeat Latents 🎥🅥🅗🅢",
+    "VHS_DuplicateImages": "Repeat Images 🎥🅥🅗🅢",
+    "VHS_DuplicateMasks": "Repeat Masks 🎥🅥🅗🅢",
+    "VHS_SelectEveryNthLatent": "Select Every Nth Latent 🎥🅥🅗🅢",
+    "VHS_SelectEveryNthImage": "Select Every Nth Image 🎥🅥🅗🅢",
+    "VHS_SelectEveryNthMask": "Select Every Nth Mask 🎥🅥🅗🅢",
+    "VHS_SelectLatents": "Select Latents 🎥🅥🅗🅢",
+    "VHS_SelectImages": "Select Images 🎥🅥🅗🅢",
+    "VHS_SelectMasks": "Select Masks 🎥🅥🅗🅢",
+    "VHS_Unbatch":  "Unbatch 🎥🅥🅗🅢",
+    "VHS_SelectLatest": "Select Latest 🎥🅥🅗🅢",
+}

videohelpersuite/server.py

@@ -0,0 +1,294 @@
+import server
+import folder_paths
+import os
+import subprocess
+import re
+
+import asyncio
+import av
+
+from .utils import is_url, get_sorted_dir_files_from_directory, ffmpeg_path, \
+        validate_sequence, is_safe_path, strip_path, try_download_video, ENCODE_ARGS
+from comfy.k_diffusion.utils import FolderOfImages
+
+
+web = server.web
+
+@server.PromptServer.instance.routes.get("/vhs/viewvideo")
+@server.PromptServer.instance.routes.get("/viewvideo")
+async def view_video(request):
+    query = request.rel_url.query
+    path_res = await resolve_path(query)
+    if isinstance(path_res, web.Response):
+        return path_res
+    file, filename, output_dir = path_res
+
+    if ffmpeg_path is None:
+        #Don't just return file, that provides  arbitrary read access to any file
+        if is_safe_path(output_dir, strict=True):
+            return web.FileResponse(path=file)
+
+    frame_rate = query.get('frame_rate', 8)
+    if query.get('format', 'video') == "folder":
+        os.makedirs(folder_paths.get_temp_directory(), exist_ok=True)
+        concat_file = os.path.join(folder_paths.get_temp_directory(), "image_sequence_preview.txt")
+        skip_first_images = int(query.get('skip_first_images', 0))
+        select_every_nth = int(query.get('select_every_nth', 1)) or 1
+        valid_images = get_sorted_dir_files_from_directory(file, skip_first_images, select_every_nth, FolderOfImages.IMG_EXTENSIONS)
+        if len(valid_images) == 0:
+            return web.Response(status=204)
+        with open(concat_file, "w") as f:
+            f.write("ffconcat version 1.0\n")
+            for path in valid_images:
+                f.write("file '" + os.path.abspath(path) + "'\n")
+                f.write("duration 0.125\n")
+        in_args = ["-safe", "0", "-i", concat_file]
+    else:
+        in_args = ["-i", file]
+        if '%' in file:
+            in_args = ['-framerate', str(frame_rate)] + in_args
+    #Do prepass to pull info
+    #breaks skip_first frames if this default is ever actually needed
+    base_fps = 30
+    try:
+        proc = await asyncio.create_subprocess_exec(ffmpeg_path, *in_args, '-t',
+                                   '0','-f', 'null','-', stdout=subprocess.PIPE,
+                                    stderr=subprocess.PIPE, stdin=subprocess.DEVNULL)
+        _, res_stderr = await proc.communicate()
+
+        match = re.search(': Video: (\\w+) .+, (\\d+) fps,', res_stderr.decode(*ENCODE_ARGS))
+        if match:
+            base_fps = float(match.group(2))
+            if match.group(1) == 'vp9':
+                #force libvpx for transparency
+                in_args = ['-c:v', 'libvpx-vp9'] + in_args
+    except subprocess.CalledProcessError as e:
+        print("An error occurred in the ffmpeg prepass:\n" \
+                + e.stderr.decode(*ENCODE_ARGS))
+        return web.Response(status=500)
+    vfilters = []
+    target_rate = float(query.get('force_rate', 0)) or base_fps
+    modified_rate = target_rate / (float(query.get('select_every_nth',1)) or 1)
+    start_time = 0
+    if 'start_time' in query:
+        start_time = float(query['start_time'])
+    elif float(query.get('skip_first_frames', 0)) > 0:
+        start_time = float(query.get('skip_first_frames'))/target_rate
+        if start_time > 1/modified_rate:
+            start_time += 1/modified_rate
+    if start_time > 0:
+        if start_time > 4:
+            post_seek = ['-ss', '4']
+            pre_seek = ['-ss', str(start_time - 4)]
+        else:
+            post_seek = ['-ss', str(start_time)]
+            pre_seek = []
+    else:
+        pre_seek = []
+        post_seek = []
+
+    args = [ffmpeg_path, "-v", "error"] + pre_seek + in_args + post_seek
+    if target_rate != 0:
+        args += ['-r', str(modified_rate)]
+    if query.get('force_size','Disabled') != "Disabled":
+        size = query['force_size'].split('x')
+        if size[0] == '?' or size[1] == '?':
+            size[0] = "-2" if size[0] == '?' else f"'min({size[0]},iw)'"
+            size[1] = "-2" if size[1] == '?' else f"'min({size[1]},ih)'"
+        else:
+            #Aspect ratio is likely changed. A more complex command is required
+            #to crop the output to the new aspect ratio
+            ar = float(size[0])/float(size[1])
+            vfilters.append(f"crop=if(gt({ar}\\,a)\\,iw\\,ih*{ar}):if(gt({ar}\\,a)\\,iw/{ar}\\,ih)")
+        size = ':'.join(size)
+        vfilters.append(f"scale={size}")
+    if len(vfilters) > 0:
+        args += ["-vf", ",".join(vfilters)]
+    if float(query.get('frame_load_cap', 0)) > 0:
+        args += ["-frames:v", query['frame_load_cap'].split('.')[0]]
+    #TODO:reconsider adding high frame cap/setting default frame cap on node
+    if query.get('deadline', 'realtime') == 'good':
+        deadline = 'good'
+    else:
+        deadline = 'realtime'
+
+    args += ['-c:v', 'libvpx-vp9','-deadline', deadline, '-cpu-used', '8', '-f', 'webm', '-']
+
+    try:
+        proc = await asyncio.create_subprocess_exec(*args, stdout=subprocess.PIPE,
+                                                    stdin=subprocess.DEVNULL)
+        try:
+            resp = web.StreamResponse()
+            resp.content_type = 'video/webm'
+            resp.headers["Content-Disposition"] = f"filename=\"{filename}\""
+            await resp.prepare(request)
+            while len(bytes_read := await proc.stdout.read(2**20)) != 0:
+                await resp.write(bytes_read)
+            #Of dubious value given frequency of kill calls, but more correct
+            await proc.wait()
+        except (ConnectionResetError, ConnectionError) as e:
+            proc.kill()
+    except BrokenPipeError as e:
+        pass
+    return resp
+@server.PromptServer.instance.routes.get("/vhs/viewaudio")
+async def view_audio(request):
+    query = request.rel_url.query
+    path_res = await resolve_path(query)
+    if isinstance(path_res, web.Response):
+        return path_res
+    file, filename, output_dir = path_res
+    if ffmpeg_path is None:
+        #Don't just return file, that provides  arbitrary read access to any file
+        if is_safe_path(output_dir, strict=True):
+            return web.FileResponse(path=file)
+
+    in_args = ["-i", file]
+    start_time = 0
+    if 'start_time' in query:
+        start_time = float(query['start_time'])
+    args = [ffmpeg_path, "-v", "error", '-vn'] + in_args + ['-ss', str(start_time)]
+    if float(query.get('duration', 0)) > 0:
+        args += ['-t', str(query['duration'])]
+    if query.get('deadline', 'realtime') == 'good':
+        deadline = 'good'
+    else:
+        deadline = 'realtime'
+
+    args += ['-c:a', 'libopus','-deadline', deadline, '-cpu-used', '8', '-f', 'webm', '-']
+    try:
+        proc = await asyncio.create_subprocess_exec(*args, stdout=subprocess.PIPE,
+                                                    stdin=subprocess.DEVNULL)
+        try:
+            resp = web.StreamResponse()
+            resp.content_type = 'audio/webm'
+            resp.headers["Content-Disposition"] = f"filename=\"{filename}\""
+            await resp.prepare(request)
+            while len(bytes_read := await proc.stdout.read(2**20)) != 0:
+                await resp.write(bytes_read)
+            #Of dubious value given frequency of kill calls, but more correct
+            await proc.wait()
+        except (ConnectionResetError, ConnectionError) as e:
+            proc.kill()
+    except BrokenPipeError as e:
+        pass
+    return resp
+
+query_cache = {}
+@server.PromptServer.instance.routes.get("/vhs/queryvideo")
+async def query_video(request):
+    query = request.rel_url.query
+    filepath = await resolve_path(query)
+    #TODO: cache lookup
+    if isinstance(filepath, web.Response):
+        return filepath
+    filepath = filepath[0]
+    if filepath.endswith(".webp"):
+        # ffmpeg doesn't support decoding animated WebP https://trac.ffmpeg.org/ticket/4907
+        return web.json_response({})
+    if filepath in query_cache and query_cache[filepath][0] == os.stat(filepath).st_mtime:
+        source = query_cache[filepath][1]
+    else:
+        source = {}
+        try:
+            with av.open(filepath) as cont:
+                stream = cont.streams.video[0]
+                source['fps'] = float(stream.average_rate)
+                source['duration'] = float(cont.duration / av.time_base)
+
+                if stream.codec_context.name == 'vp9':
+                    cc = av.Codec('libvpx-vp9', 'r').create()
+                else:
+                    cc = stream
+                def fit():
+                    for packet in cont.demux(video=0):
+                        yield from cc.decode(packet)
+                frame = next(fit())
+
+                source['size'] = [frame.width, frame.height]
+                source['alpha'] = 'a' in frame.format.name
+                source['frames'] = stream.metadata.get('NUMBER_OF_FRAMES', round(source['duration'] * source['fps']))
+                query_cache[filepath] = (os.stat(filepath).st_mtime, source)
+        except Exception:
+            pass
+    if not 'frames' in source:
+        return web.json_response({})
+    loaded = {}
+    loaded['duration'] = source['duration']
+    loaded['duration'] -= float(query.get('start_time',0))
+    loaded['fps'] = float(query.get('force_rate', 0)) or source.get('fps',1)
+    loaded['duration'] -= int(query.get('skip_first_frames', 0)) / loaded['fps']
+    loaded['fps'] /= int(query.get('select_every_nth', 1)) or 1
+    loaded['frames'] = round(loaded['duration'] * loaded['fps'])
+    return web.json_response({'source': source, 'loaded': loaded})
+
+async def resolve_path(query):
+    if "filename" not in query:
+        return web.Response(status=204)
+    filename = query["filename"]
+
+    #Path code misformats urls on windows and must be skipped
+    if is_url(filename):
+        file = await asyncio.to_thread(try_download_video, filename) or file
+        filname, output_dir = os.path.split(file)
+        return file, filename, output_dir
+    else:
+        filename, output_dir = folder_paths.annotated_filepath(filename)
+
+        type = query.get("type", "output")
+        if type == "path":
+            #special case for path_based nodes
+            #NOTE: output_dir may be empty, but non-None
+            output_dir, filename = os.path.split(strip_path(filename))
+        if output_dir is None:
+            output_dir = folder_paths.get_directory_by_type(type)
+
+        if output_dir is None:
+            return web.Response(status=204)
+
+        if not is_safe_path(output_dir):
+            return web.Response(status=204)
+
+        if "subfolder" in query:
+            output_dir = os.path.join(output_dir, query["subfolder"])
+
+        filename = os.path.basename(filename)
+        file = os.path.join(output_dir, filename)
+
+        if not os.path.exists(file):
+            return web.Response(status=204)
+        if query.get('format', 'video') == 'folder':
+            if not os.path.isdir(file):
+                return web.Response(status=204)
+        else:
+            if not os.path.isfile(file) and not validate_sequence(file):
+                    return web.Response(status=204)
+        return file, filename, output_dir
+
+@server.PromptServer.instance.routes.get("/vhs/getpath")
+@server.PromptServer.instance.routes.get("/getpath")
+async def get_path(request):
+    query = request.rel_url.query
+    if "path" not in query:
+        return web.Response(status=204)
+    #NOTE: path always ends in `/`, so this is functionally an lstrip
+    path = os.path.abspath(strip_path(query["path"]))
+
+    if not os.path.exists(path) or not is_safe_path(path):
+        return web.json_response([])
+
+    #Use get so None is default instead of keyerror
+    valid_extensions = query.get("extensions")
+    valid_items = []
+    for item in os.scandir(path):
+        try:
+            if item.is_dir():
+                valid_items.append(item.name + "/")
+                continue
+            if valid_extensions is None or item.name.split(".")[-1].lower() in valid_extensions:
+                valid_items.append(item.name)
+        except OSError:
+            #Broken symlinks can throw a very unhelpful "Invalid argument"
+            pass
+    valid_items.sort(key=lambda f: os.stat(os.path.join(path,f)).st_mtime)
+    return web.json_response(valid_items)

videohelpersuite/utils.py

@@ -0,0 +1,426 @@
+import hashlib
+import os
+from typing import Iterable
+import shutil
+import subprocess
+import re
+import time
+from collections.abc import Mapping
+from typing import Union
+import functools
+import torch
+from torch import Tensor
+
+import server
+from .logger import logger
+import folder_paths
+
+BIGMIN = -(2**53-1)
+BIGMAX = (2**53-1)
+
+DIMMAX = 8192
+
+ENCODE_ARGS = ("utf-8", 'backslashreplace')
+
+def ffmpeg_suitability(path):
+    try:
+        version = subprocess.run([path, "-version"], check=True,
+                                 capture_output=True).stdout.decode(*ENCODE_ARGS)
+    except:
+        return 0
+    score = 0
+    #rough layout of the importance of various features
+    simple_criterion = [("libvpx", 20),("264",10), ("265",3),
+                        ("svtav1",5),("libopus", 1)]
+    for criterion in simple_criterion:
+        if version.find(criterion[0]) >= 0:
+            score += criterion[1]
+    #obtain rough compile year from copyright information
+    copyright_index = version.find('2000-2')
+    if copyright_index >= 0:
+        copyright_year = version[copyright_index+6:copyright_index+9]
+        if copyright_year.isnumeric():
+            score += int(copyright_year)
+    return score
+
+class MultiInput(str):
+    def __new__(cls, string, allowed_types="*"):
+        res = super().__new__(cls, string)
+        res.allowed_types=allowed_types
+        return res
+    def __ne__(self, other):
+        if self.allowed_types == "*" or other == "*":
+            return False
+        return other not in self.allowed_types
+imageOrLatent = MultiInput("IMAGE", ["IMAGE", "LATENT"])
+floatOrInt = MultiInput("FLOAT", ["FLOAT", "INT"])
+
+class ContainsAll(dict):
+    def __contains__(self, other):
+        return True
+    def __getitem__(self, key):
+        return super().get(key, (None, {}))
+
+if "VHS_FORCE_FFMPEG_PATH" in os.environ:
+    ffmpeg_path = os.environ.get("VHS_FORCE_FFMPEG_PATH")
+else:
+    ffmpeg_paths = []
+    try:
+        from imageio_ffmpeg import get_ffmpeg_exe
+        imageio_ffmpeg_path = get_ffmpeg_exe()
+        ffmpeg_paths.append(imageio_ffmpeg_path)
+    except:
+        if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
+            raise
+        logger.warn("Failed to import imageio_ffmpeg")
+    if "VHS_USE_IMAGEIO_FFMPEG" in os.environ:
+        ffmpeg_path = imageio_ffmpeg_path
+    else:
+        system_ffmpeg = shutil.which("ffmpeg")
+        if system_ffmpeg is not None:
+            ffmpeg_paths.append(system_ffmpeg)
+        if os.path.isfile("ffmpeg"):
+            ffmpeg_paths.append(os.path.abspath("ffmpeg"))
+        if os.path.isfile("ffmpeg.exe"):
+            ffmpeg_paths.append(os.path.abspath("ffmpeg.exe"))
+        if len(ffmpeg_paths) == 0:
+            logger.error("No valid ffmpeg found.")
+            ffmpeg_path = None
+        elif len(ffmpeg_paths) == 1:
+            #Evaluation of suitability isn't required, can take sole option
+            #to reduce startup time
+            ffmpeg_path = ffmpeg_paths[0]
+        else:
+            ffmpeg_path = max(ffmpeg_paths, key=ffmpeg_suitability)
+gifski_path = os.environ.get("VHS_GIFSKI", None)
+if gifski_path is None:
+    gifski_path = os.environ.get("JOV_GIFSKI", None)
+    if gifski_path is None:
+        gifski_path = shutil.which("gifski")
+ytdl_path = os.environ.get("VHS_YTDL", None) or shutil.which('yt-dlp') \
+        or shutil.which('youtube-dl')
+download_history = {}
+def try_download_video(url):
+    if ytdl_path is None:
+        return None
+    if url in download_history:
+        return download_history[url]
+    os.makedirs(folder_paths.get_temp_directory(), exist_ok=True)
+    #Format information could be added to only download audio for Load Audio,
+    #but this gets hairy if same url is also used for video.
+    #Best to just always keep defaults
+    #dl_format = ['-f', 'ba'] if is_audio else []
+    try:
+        res = subprocess.run([ytdl_path, "--print", "after_move:filepath",
+                              "-P", folder_paths.get_temp_directory(), url],
+                             capture_output=True, check=True)
+        #strip newline
+        file = res.stdout.decode(*ENCODE_ARGS)[:-1]
+    except subprocess.CalledProcessError as e:
+        raise Exception("An error occurred in the yt-dl process:\n" \
+                + e.stderr.decode(*ENCODE_ARGS))
+        file = None
+    download_history[url] = file
+    return file
+
+def is_safe_path(path, strict=False):
+    if "VHS_STRICT_PATHS" not in os.environ and not strict:
+        return True
+    basedir = os.path.abspath('.')
+    try:
+        common_path = os.path.commonpath([basedir, path])
+    except:
+        #Different drive on windows
+        return False
+    return common_path == basedir
+
+def get_sorted_dir_files_from_directory(directory: str, skip_first_images: int=0, select_every_nth: int=1, extensions: Iterable=None):
+    directory = strip_path(directory)
+    dir_files = os.listdir(directory)
+    dir_files = sorted(dir_files)
+    dir_files = [os.path.join(directory, x) for x in dir_files]
+    dir_files = list(filter(lambda filepath: os.path.isfile(filepath), dir_files))
+    # filter by extension, if needed
+    if extensions is not None:
+        extensions = list(extensions)
+        new_dir_files = []
+        for filepath in dir_files:
+            ext = "." + filepath.split(".")[-1]
+            if ext.lower() in extensions:
+                new_dir_files.append(filepath)
+        dir_files = new_dir_files
+    # start at skip_first_images
+    dir_files = dir_files[skip_first_images:]
+    dir_files = dir_files[0::select_every_nth]
+    return dir_files
+
+
+# modified from https://stackoverflow.com/questions/22058048/hashing-a-file-in-python
+def calculate_file_hash(filename: str, hash_every_n: int = 1):
+    #Larger video files were taking >.5 seconds to hash even when cached,
+    #so instead the modified time from the filesystem is used as a hash
+    h = hashlib.sha256()
+    h.update(filename.encode())
+    h.update(str(os.path.getmtime(filename)).encode())
+    return h.hexdigest()
+
+prompt_queue = server.PromptServer.instance.prompt_queue
+def requeue_workflow_unchecked():
+    """Requeues the current workflow without checking for multiple requeues"""
+    currently_running = prompt_queue.currently_running
+    (_, _, prompt, extra_data, outputs_to_execute) = next(iter(currently_running.values()))
+
+    #Ensure batch_managers are marked stale
+    prompt = prompt.copy()
+    for uid in prompt:
+        if prompt[uid]['class_type'] == 'VHS_BatchManager':
+            prompt[uid]['inputs']['requeue'] = prompt[uid]['inputs'].get('requeue',0)+1
+
+    #execution.py has guards for concurrency, but server doesn't.
+    #TODO: Check that this won't be an issue
+    number = -server.PromptServer.instance.number
+    server.PromptServer.instance.number += 1
+    prompt_id = str(server.uuid.uuid4())
+    prompt_queue.put((number, prompt_id, prompt, extra_data, outputs_to_execute))
+
+requeue_guard = [None, 0, 0, {}]
+def requeue_workflow(requeue_required=(-1,True)):
+    assert(len(prompt_queue.currently_running) == 1)
+    global requeue_guard
+    (run_number, _, prompt, _, _) = next(iter(prompt_queue.currently_running.values()))
+    if requeue_guard[0] != run_number:
+        #Calculate a count of how many outputs are managed by a batch manager
+        managed_outputs=0
+        for bm_uid in prompt:
+            if prompt[bm_uid]['class_type'] == 'VHS_BatchManager':
+                for output_uid in prompt:
+                    if prompt[output_uid]['class_type'] in ["VHS_VideoCombine"]:
+                        for inp in prompt[output_uid]['inputs'].values():
+                            if inp == [bm_uid, 0]:
+                                managed_outputs+=1
+        requeue_guard = [run_number, 0, managed_outputs, {}]
+    requeue_guard[1] = requeue_guard[1]+1
+    requeue_guard[3][requeue_required[0]] = requeue_required[1]
+    if requeue_guard[1] == requeue_guard[2] and max(requeue_guard[3].values()):
+        requeue_workflow_unchecked()
+
+def get_audio(file, start_time=0, duration=0):
+    args = [ffmpeg_path, "-i", file]
+    if start_time > 0:
+        args += ["-ss", str(start_time)]
+    if duration > 0:
+        args += ["-t", str(duration)]
+    try:
+        #TODO: scan for sample rate and maintain
+        res =  subprocess.run(args + ["-f", "f32le", "-"],
+                              capture_output=True, check=True)
+        audio = torch.frombuffer(bytearray(res.stdout), dtype=torch.float32)
+        match = re.search(', (\\d+) Hz, (\\w+), ',res.stderr.decode(*ENCODE_ARGS))
+    except subprocess.CalledProcessError as e:
+        raise Exception(f"VHS failed to extract audio from {file}:\n" \
+                + e.stderr.decode(*ENCODE_ARGS))
+    if match:
+        ar = int(match.group(1))
+        #NOTE: Just throwing an error for other channel types right now
+        #Will deal with issues if they come
+        ac = {"mono": 1, "stereo": 2}[match.group(2)]
+    else:
+        ar = 44100
+        ac = 2
+    audio = audio.reshape((-1,ac)).transpose(0,1).unsqueeze(0)
+    return {'waveform': audio, 'sample_rate': ar}
+
+class LazyAudioMap(Mapping):
+    def __init__(self, file, start_time, duration):
+        self.file = file
+        self.start_time=start_time
+        self.duration=duration
+        self._dict=None
+    def __getitem__(self, key):
+        if self._dict is None:
+            self._dict = get_audio(self.file, self.start_time, self.duration)
+        return self._dict[key]
+    def __iter__(self):
+        if self._dict is None:
+            self._dict = get_audio(self.file, self.start_time, self.duration)
+        return iter(self._dict)
+    def __len__(self):
+        if self._dict is None:
+            self._dict = get_audio(self.file, self.start_time, self.duration)
+        return len(self._dict)
+def lazy_get_audio(file, start_time=0, duration=0, **kwargs):
+    return LazyAudioMap(file, start_time, duration)
+
+def is_url(url):
+    return url.split("://")[0] in ["http", "https"]
+
+def validate_sequence(path):
+    #Check if path is a valid ffmpeg sequence that points to at least one file
+    (path, file) = os.path.split(path)
+    if not os.path.isdir(path):
+        return False
+    match = re.search('%0?\\d+d', file)
+    if not match:
+        return False
+    seq = match.group()
+    if seq == '%d':
+        seq = '\\\\d+'
+    else:
+        seq = '\\\\d{%s}' % seq[1:-1]
+    file_matcher = re.compile(re.sub('%0?\\d+d', seq, file))
+    for file in os.listdir(path):
+        if file_matcher.fullmatch(file):
+            return True
+    return False
+
+def strip_path(path):
+    #This leaves whitespace inside quotes and only a single "
+    #thus ' ""test"' -> '"test'
+    #consider path.strip(string.whitespace+"\"")
+    #or weightier re.fullmatch("[\\s\"]*(.+?)[\\s\"]*", path).group(1)
+    path = path.strip()
+    if path.startswith("\""):
+        path = path[1:]
+    if path.endswith("\""):
+        path = path[:-1]
+    return path
+def hash_path(path):
+    if path is None:
+        return "input"
+    if is_url(path):
+        return "url"
+    if not os.path.isfile(path):
+        return "DNE"
+    return calculate_file_hash(strip_path(path))
+
+
+def validate_path(path, allow_none=False, allow_url=True):
+    if path is None:
+        return allow_none
+    if is_url(path):
+        #Probably not feasible to check if url resolves here
+        if not allow_url:
+            return "URLs are unsupported for this path"
+        return is_safe_path(path)
+    if not os.path.isfile(strip_path(path)):
+        return "Invalid file path: {}".format(path)
+    return is_safe_path(path)
+
+
+def validate_index(index: int, length: int=0, is_range: bool=False, allow_negative=False, allow_missing=False) -> int:
+    # if part of range, do nothing
+    if is_range:
+        return index
+    # otherwise, validate index
+    # validate not out of range - only when latent_count is passed in
+    if length > 0 and index > length-1 and not allow_missing:
+        raise IndexError(f"Index '{index}' out of range for {length} item(s).")
+    # if negative, validate not out of range
+    if index < 0:
+        if not allow_negative:
+            raise IndexError(f"Negative indeces not allowed, but was '{index}'.")
+        conv_index = length+index
+        if conv_index < 0 and not allow_missing:
+            raise IndexError(f"Index '{index}', converted to '{conv_index}' out of range for {length} item(s).")
+        index = conv_index
+    return index
+
+
+def convert_to_index_int(raw_index: str, length: int=0, is_range: bool=False, allow_negative=False, allow_missing=False) -> int:
+    try:
+        return validate_index(int(raw_index), length=length, is_range=is_range, allow_negative=allow_negative, allow_missing=allow_missing)
+    except ValueError as e:
+        raise ValueError(f"Index '{raw_index}' must be an integer.", e)
+
+
+def convert_str_to_indexes(indexes_str: str, length: int=0, allow_missing=False) -> list[int]:
+    if not indexes_str:
+        return []
+    int_indexes = list(range(0, length))
+    allow_negative = length > 0
+    chosen_indexes = []
+    # parse string - allow positive ints, negative ints, and ranges separated by ':'
+    groups = indexes_str.split(",")
+    groups = [g.strip() for g in groups]
+    for g in groups:
+        # parse range of indeces (e.g. 2:16)
+        if ':' in g:
+            index_range = g.split(":", 2)
+            index_range = [r.strip() for r in index_range]
+
+            start_index = index_range[0]
+            if len(start_index) > 0:
+                start_index = convert_to_index_int(start_index, length=length, is_range=True, allow_negative=allow_negative, allow_missing=allow_missing)
+            else:
+                start_index = 0
+            end_index = index_range[1]
+            if len(end_index) > 0:
+                end_index = convert_to_index_int(end_index, length=length, is_range=True, allow_negative=allow_negative, allow_missing=allow_missing)
+            else:
+                end_index = length
+            # support step as well, to allow things like reversing, every-other, etc.
+            step = 1
+            if len(index_range) > 2:
+                step = index_range[2]
+                if len(step) > 0:
+                    step = convert_to_index_int(step, length=length, is_range=True, allow_negative=True, allow_missing=True)
+                else:
+                    step = 1
+            # if latents were passed in, base indeces on known latent count
+            if len(int_indexes) > 0:
+                chosen_indexes.extend(int_indexes[start_index:end_index][::step])
+            # otherwise, assume indeces are valid
+            else:
+                chosen_indexes.extend(list(range(start_index, end_index, step)))
+        # parse individual indeces
+        else:
+            chosen_indexes.append(convert_to_index_int(g, length=length, allow_negative=allow_negative, allow_missing=allow_missing))
+    return chosen_indexes
+
+
+def select_indexes(input_obj: Union[Tensor, list], idxs: list):
+    if type(input_obj) == Tensor:
+        return input_obj[idxs]
+    else:
+        return [input_obj[i] for i in idxs]
+
+def merge_filter_args(args, ftype="-vf"):
+    #TODO This doesn't account for filter_complex
+    #Will likely need to convert all filters to filter complex in the future
+    #But that requires source/output deduplication
+    try:
+        start_index = args.index(ftype)+1
+        index = start_index
+        while True:
+            index = args.index(ftype, index)
+            args[start_index] += ',' + args[index+1]
+            args.pop(index)
+            args.pop(index)
+    except ValueError:
+        pass
+
+def select_indexes_from_str(input_obj: Union[Tensor, list], indexes: str, err_if_missing=True, err_if_empty=True):
+    real_idxs = convert_str_to_indexes(indexes, len(input_obj), allow_missing=not err_if_missing)
+    if err_if_empty and len(real_idxs) == 0:
+        raise Exception(f"Nothing was selected based on indexes found in '{indexes}'.")
+    return select_indexes(input_obj, real_idxs)
+
+def hook(obj, attr):
+    def dec(f):
+        f = functools.update_wrapper(f, getattr(obj,attr))
+        setattr(obj,attr,f)
+        return f
+    return dec
+
+def cached(duration):
+    def dec(f):
+        cached_ret = None
+        cache_time = 0
+        def cached_func():
+            nonlocal cache_time, cached_ret
+            if time.time() > cache_time + duration or cached_ret is None:
+                cache_time = time.time()
+                cached_ret = f()
+            return cached_ret
+        return cached_func
+    return dec

web/js/videoinfo.js

@@ -0,0 +1,101 @@
+import { app } from '../../../scripts/app.js'
+
+
+function getVideoMetadata(file) {
+    return new Promise((r) => {
+        const reader = new FileReader();
+        reader.onload = (event) => {
+            const videoData = new Uint8Array(event.target.result);
+            const dataView = new DataView(videoData.buffer);
+
+            let decoder = new TextDecoder();
+            // Check for known valid magic strings
+            if (dataView.getUint32(0) == 0x1A45DFA3) {
+                //webm/mkv (both use EBML/Matroska format)
+                //see http://wiki.webmproject.org/webm-metadata/global-metadata
+                //and https://www.matroska.org/technical/elements.html
+                //contrary to specs, tag seems consistently at start
+                //COMMENT + 0x4487 + packed length?
+                //length 0x8d8 becomes 0x48d8
+                //
+                //description for variable length ints https://github.com/ietf-wg-cellar/ebml-specification/blob/master/specification.markdown
+                let offset = 4 + 8; //COMMENT is 7 chars + 1 to realign
+                while(offset < videoData.length-16) {
+                    //Check for text tags
+                    if (dataView.getUint16(offset) == 0x4487) {
+                        //check that name of tag is COMMENT
+                        const name = String.fromCharCode(...videoData.slice(offset-7,offset));
+                        if (name === "COMMENT") {
+                            let vint = dataView.getUint32(offset+2);
+                            let n_octets = Math.clz32(vint)+1;
+                            if (n_octets < 4) {//250MB sanity cutoff
+                                let length = (vint >> (8*(4-n_octets))) & ~(1 << (7*n_octets));
+                                const content = decoder.decode(videoData.slice(offset+2+n_octets, offset+2+n_octets+length));
+                                let json = JSON.parse(content);
+                                r(json);
+                                return;
+                            }
+                        }
+                    }
+                    offset+=1;
+                }
+            } else if (dataView.getUint32(4) == 0x66747970 && dataView.getUint32(8) == 0x69736F6D) {
+                //mp4
+                //see https://developer.apple.com/documentation/quicktime-file-format
+                //Seems to make no guarantee for alignment
+                let offset = videoData.length-4;
+                while (offset > 16) {//rough safe guess
+                    if (dataView.getUint32(offset) == 0x64617461) {//any data tag
+                        if (dataView.getUint32(offset - 8) == 0xa9636d74) {//cmt data tag
+                            let type = dataView.getUint32(offset+4); //seemingly 1
+                            let locale = dataView.getUint32(offset+8); //seemingly 0
+                            let size = dataView.getUint32(offset-4) - 4*4;
+                            const content = decoder.decode(videoData.slice(offset+12, offset+12+size));
+                            const json = JSON.parse(content);
+                            r(json);
+                            return;
+                        }
+                    }
+
+                    offset-=1;
+                }
+            } else {
+                console.error("Unknown magic: " + dataView.getUint32(0))
+            }
+            r();
+            return;
+        };
+
+        reader.readAsArrayBuffer(file);
+    });
+}
+function isVideoFile(file) {
+    if (file?.name?.endsWith(".webm")) {
+        return true;
+    }
+    if (file?.name?.endsWith(".mp4")) {
+        return true;
+    }
+    if (file?.name?.endsWith(".mkv")) {
+        return true;
+    }
+
+    return false;
+}
+
+let originalHandleFile = app.handleFile;
+app.handleFile = handleFile;
+let fileInput = document.getElementById("comfy-file-input")
+//hijack comfy-file-input to allow webm/mp4/mkv
+fileInput.accept += ",video/webm,video/mp4,video/x-matroska";
+
+async function handleFile(file) {
+    if (file?.type?.startsWith("video/") || isVideoFile(file)) {
+        const videoInfo = await getVideoMetadata(file);
+        if (videoInfo?.workflow) {
+            await app.loadGraphData(videoInfo.workflow);
+            return
+        }
+    }
+    return await originalHandleFile.apply(this, arguments);
+}