feat: Initial commit

.gitattributes

@@ -33,3 +33,20 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+clip/bpe_simple_vocab_16e6.txt.gz filter=lfs diff=lfs merge=lfs -text
+docs/finaloutput.png filter=lfs diff=lfs merge=lfs -text
+gfpgan/weights/detection_Resnet50_Final.pth filter=lfs diff=lfs merge=lfs -text
+gfpgan/weights/parsing_parsenet.pth filter=lfs diff=lfs merge=lfs -text
+models/CLIP filter=lfs diff=lfs merge=lfs -text
+models/CodeFormer filter=lfs diff=lfs merge=lfs -text
+models/DMDNet.pth filter=lfs diff=lfs merge=lfs -text
+models/GFPGANv1.4.pth filter=lfs diff=lfs merge=lfs -text
+models/inswapper_128.onnx filter=lfs diff=lfs merge=lfs -text
+mynewshinyroop/Lib/site-packages/_virtualenv.pth filter=lfs diff=lfs merge=lfs -text
+models/CLIP/rd64-uni-refined.pth filter=lfs diff=lfs merge=lfs -text
+models/CodeFormer/facelib/detection_Resnet50_Final.pth filter=lfs diff=lfs merge=lfs -text
+models/CodeFormer/realesrgan/RealESRGAN_x2plus.pth filter=lfs diff=lfs merge=lfs -text
+models/CodeFormer/codeformer.pth filter=lfs diff=lfs merge=lfs -text
+models/CodeFormer/facelib/parsing_parsenet.pth filter=lfs diff=lfs merge=lfs -text
+mynewshinyroop/Lib/site-packages/distutils-precedence.pth filter=lfs diff=lfs merge=lfs -text
+roop-unleashed.ipynb filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,5 @@
+__pycache__
+**/__pycache__
+
+.DS_Store
+

Dockerfile

@@ -0,0 +1,7 @@
+FROM python:3.11
+WORKDIR /usr/src/app
+RUN apt-get update && apt-get install -y libgl1-mesa-glx
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+CMD ["python", "run.py"]

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 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 Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are 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.
+
+  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.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  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 Affero 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. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  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 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 work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero 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 Affero 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 Affero 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 Affero 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 Affero 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 Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero 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 your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  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 AGPL, see
+<https://www.gnu.org/licenses/>.

README.md

@@ -1,10 +1,9 @@
 ---
-title: Docker Faceswap Sample
-emoji: 🏢
-colorFrom: green
-colorTo: purple
-sdk: docker
-pinned: false
+title: face-swap
+app_file: run.py
+sdk: gradio
+sdk_version: 3.40.1
 ---
+# roop-unleashed
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+WIP Version of roop-unleashed using Gradio UI

installer/installer.py

@@ -0,0 +1,83 @@
+import argparse
+import glob
+import os
+import shutil
+import site
+import subprocess
+import sys
+
+
+script_dir = os.getcwd()
+
+
+def run_cmd(cmd, capture_output=False, env=None):
+    # Run shell commands
+    return subprocess.run(cmd, shell=True, capture_output=capture_output, env=env)
+
+
+def check_env():
+    # If we have access to conda, we are probably in an environment
+    conda_not_exist = run_cmd("conda", capture_output=True).returncode
+    if conda_not_exist:
+        print("Conda is not installed. Exiting...")
+        sys.exit()
+    
+    # Ensure this is a new environment and not the base environment
+    if os.environ["CONDA_DEFAULT_ENV"] == "base":
+        print("Create an environment for this project and activate it. Exiting...")
+        sys.exit()
+
+
+def install_dependencies():
+    # Install Git and clone repo
+    run_cmd("conda install -y -k git")
+    run_cmd("git clone https://github.com/C0untFloyd/roop-unleashed.git")
+
+    # Install the webui dependencies
+    update_dependencies()
+
+
+def update_dependencies():
+    global MY_PATH
+    
+    os.chdir(MY_PATH)
+	# do a hard reset for to update even if there are local changes
+    run_cmd("git fetch --all")
+    run_cmd("git reset --hard origin/main")
+    run_cmd("git pull")
+    # Installs/Updates dependencies from all requirements.txt
+    run_cmd("python -m pip install -r requirements.txt")
+
+
+def start_app():
+    global MY_PATH
+    
+    os.chdir(MY_PATH)
+    # forward commandline arguments
+    sys.argv.pop(0)
+    args = ' '.join(sys.argv)
+    print("Launching App")
+    run_cmd(f'python run.py {args}')
+
+
+if __name__ == "__main__":
+    global MY_PATH
+    
+    MY_PATH = "roop-unleashed"
+
+    
+    # Verifies we are in a conda environment
+    check_env()
+
+    # If webui has already been installed, skip and run
+    if not os.path.exists(MY_PATH):
+        install_dependencies()
+    else:
+        # moved update from batch to here, because of batch limitations
+        updatechoice = input("Check for Updates? [y/n]").lower()
+        if updatechoice == "y":
+           update_dependencies()
+
+    # Run the model with webui
+    os.chdir(script_dir)
+    start_app()

installer/windows_run.bat

@@ -0,0 +1,80 @@
+@echo off
+REM Please set the following commandline arguments to your prefered settings
+set COMMANDLINE_ARGS=--execution-provider cuda --frame-processor face_swapper face_enhancer --video-encoder libvpx-vp9
+
+cd /D "%~dp0"
+
+echo "%CD%"| findstr /C:" " >nul && echo This script relies on Miniconda which can not be silently installed under a path with spaces. && goto end
+
+set PATH=%PATH%;%SystemRoot%\system32
+
+@rem config
+set INSTALL_DIR=%cd%\installer_files
+set CONDA_ROOT_PREFIX=%cd%\installer_files\conda
+set INSTALL_ENV_DIR=%cd%\installer_files\env
+set MINICONDA_DOWNLOAD_URL=https://repo.anaconda.com/miniconda/Miniconda3-latest-Windows-x86_64.exe
+set FFMPEG_DOWNLOAD_URL=https://github.com/GyanD/codexffmpeg/releases/download/2023-06-21-git-1bcb8a7338/ffmpeg-2023-06-21-git-1bcb8a7338-essentials_build.zip
+set INSTALL_FFMPEG_DIR=%cd%\installer_files\ffmpeg
+set conda_exists=F
+
+@rem figure out whether git and conda needs to be installed
+call "%CONDA_ROOT_PREFIX%\_conda.exe" --version >nul 2>&1
+if "%ERRORLEVEL%" EQU "0" set conda_exists=T
+
+@rem (if necessary) install git and conda into a contained environment
+@rem download conda
+if "%conda_exists%" == "F" (
+	echo Downloading Miniconda from %MINICONDA_DOWNLOAD_URL% to %INSTALL_DIR%\miniconda_installer.exe
+
+	mkdir "%INSTALL_DIR%"
+	call curl -Lk "%MINICONDA_DOWNLOAD_URL%" > "%INSTALL_DIR%\miniconda_installer.exe" || ( echo. && echo Miniconda failed to download. && goto end )
+
+	echo Installing Miniconda to %CONDA_ROOT_PREFIX%
+	start /wait "" "%INSTALL_DIR%\miniconda_installer.exe" /InstallationType=JustMe /NoShortcuts=1 /AddToPath=0 /RegisterPython=0 /NoRegistry=1 /S /D=%CONDA_ROOT_PREFIX%
+
+	@rem test the conda binary
+	echo Miniconda version:
+	call "%CONDA_ROOT_PREFIX%\_conda.exe" --version || ( echo. && echo Miniconda not found. && goto end )
+)
+
+@rem create the installer env
+if not exist "%INSTALL_ENV_DIR%" (
+  echo Packages to install: %PACKAGES_TO_INSTALL%
+  call "%CONDA_ROOT_PREFIX%\_conda.exe" create --no-shortcuts -y -k --prefix "%INSTALL_ENV_DIR%" python=3.10 || ( echo. && echo Conda environment creation failed. && goto end )
+)
+
+if not exist "%INSTALL_FFMPEG_DIR%" (
+	echo Downloading ffmpeg from %FFMPEG_DOWNLOAD_URL% to %INSTALL_DIR%
+ 	call curl -Lk "%FFMPEG_DOWNLOAD_URL%" > "%INSTALL_DIR%\ffmpeg.zip" || ( echo. && echo ffmpeg failed to download. && goto end )
+	call powershell -command "Expand-Archive -Force '%INSTALL_DIR%\ffmpeg.zip' '%INSTALL_DIR%\'"
+
+	cd "installer_files"
+	setlocal EnableExtensions EnableDelayedExpansion
+
+	for /f "tokens=*" %%f in ('dir /s /b /ad "ffmpeg*"') do (
+		ren "%%f" "ffmpeg"
+	)
+	endlocal
+	setx PATH "%INSTALL_FFMPEG_DIR%\bin\;%PATH%"
+	echo To use videos, you need to restart roop after this installation. 
+	cd ..
+)
+
+@rem check if conda environment was actually created
+if not exist "%INSTALL_ENV_DIR%\python.exe" ( echo. && echo ERROR: Conda environment is empty. && goto end )
+
+@rem activate installer env
+call "%CONDA_ROOT_PREFIX%\condabin\conda.bat" activate "%INSTALL_ENV_DIR%" || ( echo. && echo Miniconda hook not found. && goto end )
+
+@rem setup installer env
+echo Launching roop unleashed - please edit windows_run.bat to customize commandline arguments
+call python installer.py %COMMANDLINE_ARGS%
+
+echo.
+echo Done!
+
+:end
+pause
+
+
+

jaa.py

@@ -0,0 +1,355 @@
+"""
+Jaa.py Plugin Framework
+Author: Janvarev Vladislav
+
+Jaa.py - minimalistic one-file plugin framework with no dependencies.
+Main functions:
+- run all plugins files from "plugins" folder, base on filename
+- save each plugin options in "options" folder in JSON text files for further editing
+
+- Plugins
+must located in plugins/ folder
+must have "start(core)" function, that returns manifest dict
+manifest must contain keys "name" and "version"
+can contain "default_options"
+- if contain - options will be saved in "options" folder and reload instead next time
+- if contain - "start_with_options(core,manifest)" function will run with manifest with "options" key
+manifest will be processed in "process_plugin_manifest" function if you override it
+
+- Options (for plugins)
+are saved under "options" folder in JSON format
+created at first run plugin with "default_options"
+updated when plugin change "version"
+
+- Example usage:
+class VoiceAssCore(JaaCore): # class must override JaaCore
+    def __init__(self):
+        JaaCore.__init__(self,__file__)
+  ...
+
+main = VoiceAssCore()
+main.init_plugins(["core"]) # 1 param - first plugins to be initialized
+                            # Good if you need some "core" options/plugin to be loaded before others
+                            # not necessary starts with "plugin_" prefix
+
+also can be run like
+
+main.init_plugins()
+
+- Requirements
+Python 3.5+ (due to dict mix in final_options calc), can be relaxed
+"""
+
+import os
+import traceback
+import json
+
+# here we trying to use termcolor to highlight plugin info and errors during load
+try:
+    from termcolor import cprint
+except Exception as e:
+    # not found? making a stub!
+    def cprint(p,color=None):
+        if color == None:
+            print(p)
+        else:
+            print(str(color).upper(),p)
+
+version = "2.2.0"
+
+class JaaCore:
+    verbose = False
+
+    def __init__(self,root_file = __file__):
+        self.jaaPluginPrefix = "plugin_"
+        self.jaaVersion = version
+        self.jaaRootFolder = os.path.dirname(root_file)
+        self.jaaOptionsPath = self.jaaRootFolder+os.path.sep+"plugin_options"
+        self.jaaShowTracebackOnPluginErrors = False
+        if self.verbose:
+            cprint("JAA.PY v{0} class created!".format(version),"blue")
+
+    # ------------- plugins -----------------
+    def init_plugins(self, list_first_plugins = []):
+        self.plugin_manifests = {}
+
+        # 1. run first plugins first!
+        for modname in list_first_plugins:
+            self.init_plugin(modname)
+
+        # 2. run all plugins from plugins folder
+        from os import listdir
+        from os.path import isfile, join
+        pluginpath = self.jaaRootFolder+"/plugins"
+        files = [f for f in listdir(pluginpath) if isfile(join(pluginpath, f))]
+
+        for fil in files:
+            # print fil[:-3]
+            if fil.startswith(self.jaaPluginPrefix) and fil.endswith(".py"):
+                modfile = fil[:-3]
+                self.init_plugin(modfile)
+
+
+
+    def init_plugin(self,modname):
+        # import
+        try:
+            mod = self.import_plugin("plugins."+modname)
+        except Exception as e:
+            self.print_error("JAA PLUGIN ERROR: {0} error on load: {1}".format(modname, str(e)))
+            return False
+
+        # run start function
+        try:
+            res = mod.start(self)
+        except Exception as e:
+            self.print_error("JAA PLUGIN ERROR: {0} error on start: {1}".format(modname, str(e)))
+            return False
+
+        # if plugin has an options
+        if "default_options" in res:
+            try:
+                # saved options try to read
+                saved_options = {}
+                try:
+                    with open(self.jaaOptionsPath+'/'+modname+'.json', 'r', encoding="utf-8") as f:
+                        s = f.read()
+                    saved_options = json.loads(s)
+                    #print("Saved options", saved_options)
+                except Exception as e:
+                    pass
+
+                res["default_options"]["v"] = res["version"]
+
+
+                # only string needs Python 3.5
+                final_options = {**res["default_options"], **saved_options}
+
+                # if no option found or version is differ from mod version
+                if len(saved_options) == 0 or saved_options["v"] != res["version"]:
+                    final_options["v"] = res["version"]
+                    self.save_plugin_options(modname,final_options)
+
+                res["options"] = final_options
+
+                try:
+                    res2 = mod.start_with_options(self,res)
+                    if res2 != None:
+                        res = res2
+                except Exception as e:
+                    self.print_error("JAA PLUGIN ERROR: {0} error on start_with_options processing: {1}".format(modname, str(e)))
+                    return False
+
+            except Exception as e:
+                self.print_error("JAA PLUGIN ERROR: {0} error on options processing: {1}".format(modname, str(e)))
+                return False
+
+
+        # processing plugin manifest
+        try:
+            # set up name and version
+            plugin_name = res["name"]
+            plugin_version = res["version"]
+
+
+            self.process_plugin_manifest(modname,res)
+
+        except Exception as e:
+            print("JAA PLUGIN ERROR: {0} error on process startup options: {1}".format(modname, str(e)))
+            return False
+
+        self.plugin_manifests[modname] = res
+
+        self.on_succ_plugin_start(modname,plugin_name,plugin_version)
+        return True
+
+    def on_succ_plugin_start(self, modname, plugin_name, plugin_version):
+        if self.verbose:
+            cprint("JAA PLUGIN: {1} {2} ({0}) started!".format(modname, plugin_name, plugin_version))
+
+    def print_error(self,p):
+        cprint(p,"red")
+        if self.jaaShowTracebackOnPluginErrors:
+            traceback.print_exc()
+
+    def import_plugin(self, module_name):
+        import sys
+
+        __import__(module_name)
+
+        if module_name in sys.modules:
+            return sys.modules[module_name]
+        return None
+
+    def save_plugin_options(self,modname,options):
+        # check folder exists
+        if not os.path.exists(self.jaaOptionsPath):
+            os.makedirs(self.jaaOptionsPath)
+
+        str_options = json.dumps(options, sort_keys=True, indent=4, ensure_ascii=False)
+        with open(self.jaaOptionsPath+'/'+modname+'.json', 'w', encoding="utf-8") as f:
+            f.write(str_options)
+            f.close()
+
+    # process manifest must be overrided in inherit class
+    def process_plugin_manifest(self,modname,manifest):
+        print("JAA PLUGIN: {0} manifest dummy procession (override 'process_plugin_manifest' function)".format(modname))
+        return
+
+    def plugin_manifest(self,pluginname):
+        if pluginname in self.plugin_manifests:
+            return self.plugin_manifests[pluginname]
+        return {}
+
+    def plugin_options(self,pluginname):
+        manifest = self.plugin_manifest(pluginname)
+        if "options" in manifest:
+            return manifest["options"]
+        return None
+
+    # ------------ gradio stuff --------------
+    def gradio_save(self,pluginname):
+        print("Saving options for {0}!".format(pluginname))
+        self.save_plugin_options(pluginname,self.plugin_options(pluginname))
+
+    def gradio_upd(self, pluginname, option, val):
+        options = self.plugin_options(pluginname)
+
+        # special case
+        if isinstance(options[option], (list, dict)) and isinstance(val, str):
+            import json
+            try:
+                options[option] = json.loads(val)
+            except Exception as e:
+                print(e)
+                pass
+        else:
+            options[option] = val
+        print(option,val,options)
+
+    def gradio_render_settings_interface(self, title:str="Settings manager", required_fields_to_show_plugin:list=["default_options"]):
+        import gradio as gr
+
+        with gr.Blocks() as gr_interface:
+            gr.Markdown("# {0}".format(title))
+            for pluginname in self.plugin_manifests:
+                manifest = self.plugin_manifests[pluginname]
+
+                # calculate if we show plugin
+                is_show_plugin = False
+                if len(required_fields_to_show_plugin) == 0:
+                    is_show_plugin = True
+                else:
+                    for k in required_fields_to_show_plugin:
+                        if manifest.get(k) is not None:
+                            is_show_plugin = True
+
+                if is_show_plugin:
+                    with gr.Tab(pluginname):
+                        gr.Markdown("## {0} v{1}".format(manifest["name"],manifest["version"]))
+                        if manifest.get("description") is not None:
+                            gr.Markdown(manifest.get("description"))
+
+                        if manifest.get("url") is not None:
+                            gr.Markdown("**URL:** [{0}]({0})".format(manifest.get("url")))
+
+
+                        if "options" in manifest:
+                            options = manifest["options"]
+                            if len(options) > 1: # not only v
+                                text_button = gr.Button("Save options".format(pluginname))
+                                #options_int_list = []
+                                for option in options:
+
+                                    #gr.Label(label=option)
+                                    if option != "v":
+                                        val = options[option]
+                                        label = option
+
+                                        if manifest.get("options_label") is not None:
+                                            if manifest.get("options_label").get(option) is not None:
+                                                label = option+": "+manifest.get("options_label").get(option)
+
+
+                                        if isinstance(val, (bool, )):
+                                            gr_elem = gr.Checkbox(value=val,label=label)
+                                        elif isinstance(val, (dict,list)):
+                                            import json
+                                            gr_elem = gr.Textbox(value=json.dumps(val,ensure_ascii=False), label=label)
+                                        else:
+                                            gr_elem = gr.Textbox(value=val, label=label)
+
+                                        def handler(x,pluginname=pluginname,option=option):
+                                            self.gradio_upd(pluginname, option, x)
+
+                                        gr_elem.change(handler, gr_elem, None)
+
+                                def handler_save(pluginname=pluginname):
+                                    self.gradio_save(pluginname)
+
+                                text_button.click(handler_save,inputs=None,outputs=None)
+                        else:
+                            gr.Markdown("_No options for this plugin_")
+
+        return gr_interface
+
+
+def load_options(options_file=None,py_file=None,default_options={}):
+    # 1. calculating options filename
+    if options_file == None:
+        if py_file == None:
+            raise Exception('JAA: Options or PY file is not defined, cant calc options filename')
+        else:
+            options_file = py_file[:-3]+'.json'
+
+    # 2. try to read saved options
+    saved_options = {}
+    try:
+        with open(options_file, 'r', encoding="utf-8") as f:
+            s = f.read()
+        saved_options = json.loads(s)
+        #print("Saved options", saved_options)
+    except Exception as e:
+        pass
+
+    # 3. calculating final options
+
+    # only string needs Python 3.5
+    final_options = {**default_options, **saved_options}
+
+    # 4. calculating hash from def options to check - is file rewrite needed?
+    import hashlib
+    hash = hashlib.md5((json.dumps(default_options, sort_keys=True)).encode('utf-8')).hexdigest()
+
+    # 5. if no option file found or hash was from other default options
+    if len(saved_options) == 0 or not ("hash" in saved_options.keys()) or saved_options["hash"] != hash:
+        final_options["hash"] = hash
+        #self.save_plugin_options(modname,final_options)
+
+        # saving in file
+        str_options = json.dumps(final_options, sort_keys=True, indent=4, ensure_ascii=False)
+        with open(options_file, 'w', encoding="utf-8") as f:
+            f.write(str_options)
+            f.close()
+
+    return final_options
+
+"""
+The MIT License (MIT)
+Copyright (c) 2021 Janvarev Vladislav
+
+Permission is hereby granted, free of charge, to any person obtaining a copy 
+of this software and associated documentation files (the “Software”), to deal 
+in the Software without restriction, including without limitation the rights to use, 
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, 
+and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or 
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE 
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+"""

main.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+
+from roop import core
+
+if __name__ == '__main__':
+    core.run()

models/CLIP/rd64-uni-refined.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a4956f9a7978a75630b08c9d6ec075b7c51cf43b4751b686e3a011d4012ddc9d
+size 4720707

models/CodeFormer/codeformer.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1009e537e0c2a07d4cabce6355f53cb66767cd4b4297ec7a4a64ca4b8a5684b7
+size 376637898

models/CodeFormer/facelib/detection_Resnet50_Final.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d1de9c2944f2ccddca5f5e010ea5ae64a39845a86311af6fdf30841b0a5a16d
+size 109497761

models/CodeFormer/facelib/parsing_parsenet.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d558d8d0e42c20224f13cf5a29c79eba2d59913419f945545d8cf7b72920de2
+size 85331193

models/CodeFormer/realesrgan/RealESRGAN_x2plus.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:49fafd45f8fd7aa8d31ab2a22d14d91b536c34494a5cfe31eb5d89c2fa266abb
+size 67061725

models/DMDNet.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70daeb4b1fd10f241043b587d892a941f2651d7322db02f06ff64b166537f65c
+size 603684323

models/GFPGANv1.4.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2cd4703ab14f4d01fd1383a8a8b266f9a5833dacee8e6a79d3bf21a1b6be5ad
+size 348632874

models/inswapper_128.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4a3f08c753cb72d04e10aa0f7dbe3deebbf39567d4ead6dce08e98aa49e16af
+size 554253681

requirements-ci.txt

@@ -0,0 +1,14 @@
+numpy==1.23.5
+opencv-python==4.7.0.72
+onnx==1.14.0
+insightface==0.7.3
+psutil==5.9.5
+tk==0.1.0
+customtkinter==5.2.0
+torch==2.0.1
+torchvision==0.15.2
+onnxruntime==1.15.0
+protobuf==4.23.2
+tqdm==4.65.0
+codeformer-pip==0.0.4
+gfpgan==1.3.8

requirements.txt

@@ -0,0 +1,22 @@
+--extra-index-url https://download.pytorch.org/whl/cu118
+
+numpy==1.24.2
+gradio==3.38.0
+opencv-python==4.7.0.72
+onnx==1.14.0
+insightface==0.7.3
+psutil==5.9.5
+pillow==9.5.0
+torch==2.0.1+cu118; sys_platform != 'darwin'
+torch==2.0.1; sys_platform == 'darwin'
+torchvision==0.15.2+cu118; sys_platform != 'darwin'
+torchvision==0.15.2; sys_platform == 'darwin'
+onnxruntime==1.15.0; sys_platform == 'darwin' and platform_machine != 'arm64'
+onnxruntime-silicon==1.13.1; sys_platform == 'darwin' and platform_machine == 'arm64'
+onnxruntime-gpu==1.15.0; sys_platform != 'darwin'
+protobuf==4.23.2
+tqdm==4.65.0
+codeformer-pip==0.0.4
+gfpgan==1.3.8
+ftfy
+regex

roop/capturer.py

@@ -0,0 +1,32 @@
+from typing import Optional
+import cv2
+
+from roop.typing import Frame
+
+def get_image_frame(filename: str):
+    try:
+        frame = cv2.imread(filename)
+        return frame
+    except:
+        print(f"Exception reading {filename}")
+    return None
+
+
+
+    
+def get_video_frame(video_path: str, frame_number: int = 0) -> Optional[Frame]:
+    capture = cv2.VideoCapture(video_path)
+    frame_total = capture.get(cv2.CAP_PROP_FRAME_COUNT)
+    capture.set(cv2.CAP_PROP_POS_FRAMES, min(frame_total, frame_number - 1))
+    has_frame, frame = capture.read()
+    capture.release()
+    if has_frame:
+        return frame
+    return None
+
+
+def get_video_frame_total(video_path: str) -> int:
+    capture = cv2.VideoCapture(video_path)
+    video_frame_total = int(capture.get(cv2.CAP_PROP_FRAME_COUNT))
+    capture.release()
+    return video_frame_total

roop/core.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+
+import os
+import sys
+import shutil
+# single thread doubles cuda performance - needs to be set before torch import
+if any(arg.startswith('--execution-provider') for arg in sys.argv):
+    os.environ['OMP_NUM_THREADS'] = '1'
+
+import warnings
+from typing import List
+import platform
+import signal
+import argparse
+import torch
+import onnxruntime
+
+import roop.globals
+import roop.metadata
+import roop.utilities as util
+import roop.ui as ui
+from settings import Settings
+from roop.face_helper import extract_face_images
+from chain_img_processor import ChainImgProcessor, ChainVideoProcessor, ChainBatchImageProcessor
+
+clip_text = None
+
+
+if 'ROCMExecutionProvider' in roop.globals.execution_providers:
+    del torch
+
+warnings.filterwarnings('ignore', category=FutureWarning, module='insightface')
+warnings.filterwarnings('ignore', category=UserWarning, module='torchvision')
+
+
+def parse_args() -> None:
+    signal.signal(signal.SIGINT, lambda signal_number, frame: destroy())
+    program = argparse.ArgumentParser(formatter_class=lambda prog: argparse.HelpFormatter(prog, max_help_position=100))
+    program.add_argument('-s', '--source', help='select a source image', dest='source_path')
+    program.add_argument('-t', '--target', help='select a target image or video', dest='target_path')
+    program.add_argument('-o', '--output', help='select output file or directory', dest='output_path')
+    program.add_argument('-f', '--folder', help='select a target folder with images or videos to batch process', dest='target_folder_path')
+    program.add_argument('--frame-processor', help='frame processors (choices: face_swapper, face_enhancer, ...)', dest='frame_processor', default=['face_swapper'], nargs='+')
+    program.add_argument('--keep-fps', help='keep target fps', dest='keep_fps', action='store_true')
+    program.add_argument('--keep-frames', help='keep temporary frames', dest='keep_frames', action='store_true')
+    program.add_argument('--skip-audio', help='skip target audio', dest='skip_audio', action='store_true')
+    program.add_argument('--many-faces', help='process every face', dest='many_faces', action='store_true')
+    program.add_argument('--source-face_index', help='index position of source face in image', dest='source_face_index', type=int, default=0)
+    program.add_argument('--target-face_index', help='index position of target face in image', dest='target_face_index', type=int, default=0)
+    program.add_argument('--video-encoder', help='adjust output video encoder', dest='video_encoder', default='libx264', choices=['libx264', 'libx265', 'libvpx-vp9'])
+    program.add_argument('--video-quality', help='adjust output video quality', dest='video_quality', type=int, default=18, choices=range(52), metavar='[0-51]')
+    program.add_argument('--max-memory', help='maximum amount of RAM in GB', dest='max_memory', type=int, default=suggest_max_memory())
+    program.add_argument('--execution-provider', help='available execution provider (choices: cpu, ...)', dest='execution_provider', default=['cpu'], choices=suggest_execution_providers(), nargs='+')
+    program.add_argument('--execution-threads', help='number of execution threads', dest='execution_threads', type=int, default=suggest_execution_threads())
+    program.add_argument('-v', '--version', action='version', version=f'{roop.metadata.name} {roop.metadata.version}')
+
+    args = program.parse_args()
+
+    roop.globals.source_path = args.source_path
+    roop.globals.target_path = args.target_path
+    roop.globals.output_path = util.normalize_output_path(roop.globals.source_path, roop.globals.target_path, args.output_path)
+    roop.globals.target_folder_path = args.target_folder_path
+    roop.globals.headless = args.source_path or args.target_path or args.output_path
+    # Always enable all processors when using GUI
+    if not roop.globals.headless:
+        roop.globals.frame_processors = ['face_swapper', 'face_enhancer']
+    else:
+        roop.globals.frame_processors = args.frame_processor
+
+    roop.globals.keep_fps = args.keep_fps
+    roop.globals.keep_frames = args.keep_frames
+    roop.globals.skip_audio = args.skip_audio
+    roop.globals.many_faces = args.many_faces
+    roop.globals.source_face_index = args.source_face_index
+    roop.globals.target_face_index = args.target_face_index
+    roop.globals.video_encoder = args.video_encoder
+    roop.globals.video_quality = args.video_quality
+    roop.globals.max_memory = args.max_memory
+    roop.globals.execution_providers = decode_execution_providers(args.execution_provider)
+    roop.globals.execution_threads = args.execution_threads
+
+
+def encode_execution_providers(execution_providers: List[str]) -> List[str]:
+    return [execution_provider.replace('ExecutionProvider', '').lower() for execution_provider in execution_providers]
+
+
+def decode_execution_providers(execution_providers: List[str]) -> List[str]:
+    return [provider for provider, encoded_execution_provider in zip(onnxruntime.get_available_providers(), encode_execution_providers(onnxruntime.get_available_providers()))
+            if any(execution_provider in encoded_execution_provider for execution_provider in execution_providers)]
+
+
+def suggest_max_memory() -> int:
+    if platform.system().lower() == 'darwin':
+        return 4
+    return 16
+
+
+def suggest_execution_providers() -> List[str]:
+    return encode_execution_providers(onnxruntime.get_available_providers())
+
+
+def suggest_execution_threads() -> int:
+    if 'DmlExecutionProvider' in roop.globals.execution_providers:
+        return 1
+    if 'ROCMExecutionProvider' in roop.globals.execution_providers:
+        return 1
+    return 8
+
+
+def limit_resources() -> None:
+    # prevent tensorflow memory leak
+    # gpus = tensorflow.config.experimental.list_physical_devices('GPU')
+    # for gpu in gpus:
+        # tensorflow.config.experimental.set_virtual_device_configuration(gpu, [
+            # tensorflow.config.experimental.VirtualDeviceConfiguration(memory_limit=1024)
+        # ])
+    # limit memory usage
+    if roop.globals.max_memory:
+        memory = roop.globals.max_memory * 1024 ** 3
+        if platform.system().lower() == 'darwin':
+            memory = roop.globals.max_memory * 1024 ** 6
+        if platform.system().lower() == 'windows':
+            import ctypes
+            kernel32 = ctypes.windll.kernel32
+            kernel32.SetProcessWorkingSetSize(-1, ctypes.c_size_t(memory), ctypes.c_size_t(memory))
+        else:
+            import resource
+            resource.setrlimit(resource.RLIMIT_DATA, (memory, memory))
+
+
+def release_resources() -> None:
+    if 'CUDAExecutionProvider' in roop.globals.execution_providers:
+        torch.cuda.empty_cache()
+
+
+def pre_check() -> bool:
+    if sys.version_info < (3, 9):
+        update_status('Python version is not supported - please upgrade to 3.9 or higher.')
+        return False
+    
+    download_directory_path = util.resolve_relative_path('../models')
+    util.conditional_download(download_directory_path, ['https://huggingface.co/countfloyd/deepfake/resolve/main/inswapper_128.onnx'])
+    util.conditional_download(download_directory_path, ['https://huggingface.co/countfloyd/deepfake/resolve/main/GFPGANv1.4.pth'])
+    util.conditional_download(download_directory_path, ['https://github.com/csxmli2016/DMDNet/releases/download/v1/DMDNet.pth'])
+    download_directory_path = util.resolve_relative_path('../models/CLIP')
+    util.conditional_download(download_directory_path, ['https://huggingface.co/countfloyd/deepfake/resolve/main/rd64-uni-refined.pth'])
+    download_directory_path = util.resolve_relative_path('../models/CodeFormer')
+    util.conditional_download(download_directory_path, ['https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/codeformer.pth'])
+    download_directory_path = util.resolve_relative_path('../models/CodeFormer/facelib')
+    util.conditional_download(download_directory_path, ['https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/detection_Resnet50_Final.pth'])
+    util.conditional_download(download_directory_path, ['https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/parsing_parsenet.pth'])
+    download_directory_path = util.resolve_relative_path('../models/CodeFormer/realesrgan')
+    util.conditional_download(download_directory_path, ['https://github.com/sczhou/CodeFormer/releases/download/v0.1.0/RealESRGAN_x2plus.pth'])
+
+    if not shutil.which('ffmpeg'):
+       update_status('ffmpeg is not installed.')
+    return True
+
+
+def update_status(message: str, scope: str = 'ROOP.CORE') -> None:
+    print(f'[{scope}] {message}')
+    # if not roop.globals.headless:
+        # ui.update_status(message)
+
+
+
+def start() -> None:
+    if roop.globals.headless:
+        faces = extract_face_images(roop.globals.source_path,  (False, 0))
+        roop.globals.SELECTED_FACE_DATA_INPUT = faces[roop.globals.source_face_index]
+        faces = extract_face_images(roop.globals.target_path,  (False, util.has_image_extension(roop.globals.target_path)))
+        roop.globals.SELECTED_FACE_DATA_OUTPUT = faces[roop.globals.target_face_index]
+        if 'face_enhancer' in roop.globals.frame_processors:
+            roop.globals.selected_enhancer = 'GFPGAN'
+       
+    batch_process(None, False, None)
+
+
+def InitPlugins():
+    if not roop.globals.IMAGE_CHAIN_PROCESSOR:
+        roop.globals.IMAGE_CHAIN_PROCESSOR = ChainImgProcessor()
+        roop.globals.BATCH_IMAGE_CHAIN_PROCESSOR = ChainBatchImageProcessor()
+        roop.globals.VIDEO_CHAIN_PROCESSOR = ChainVideoProcessor()
+        roop.globals.IMAGE_CHAIN_PROCESSOR.init_with_plugins()
+        roop.globals.BATCH_IMAGE_CHAIN_PROCESSOR.init_with_plugins()
+        roop.globals.VIDEO_CHAIN_PROCESSOR.init_with_plugins()
+
+
+def get_processing_plugins(use_clip):
+    processors = "faceswap"
+    if use_clip:
+        processors += ",txt2clip"
+    
+    if roop.globals.selected_enhancer == 'GFPGAN':
+        processors += ",gfpgan"
+    elif roop.globals.selected_enhancer == 'Codeformer':
+        processors += ",codeformer"
+    elif roop.globals.selected_enhancer == 'DMDNet':
+        processors += ",dmdnet"
+    
+    return processors
+
+
+def live_swap(frame, swap_mode, use_clip, clip_text):
+    if frame is None:
+        return frame
+
+    InitPlugins()
+    processors = get_processing_plugins(use_clip)
+
+
+    temp_frame, _ = roop.globals.IMAGE_CHAIN_PROCESSOR.run_chain(frame,  
+                                                    {"swap_mode": swap_mode,
+                                                        "original_frame": frame,
+                                                        "blend_ratio": roop.globals.blend_ratio,
+                                                        "face_distance_threshold": roop.globals.distance_threshold,
+                                                        "input_face_datas": [roop.globals.SELECTED_FACE_DATA_INPUT], "target_face_datas": [roop.globals.SELECTED_FACE_DATA_OUTPUT],
+                                                        "clip_prompt": clip_text},
+                                                        processors)
+    return temp_frame
+
+
+
+def params_gen_func(proc, frame):
+    global clip_text
+
+    return {"original_frame": frame, "blend_ratio": roop.globals.blend_ratio,
+             "swap_mode": roop.globals.face_swap_mode, "face_distance_threshold": roop.globals.distance_threshold, 
+             "input_face_datas": [roop.globals.SELECTED_FACE_DATA_INPUT], "target_face_datas": [roop.globals.SELECTED_FACE_DATA_OUTPUT],
+             "clip_prompt": clip_text}
+
+def batch_process(files, use_clip, new_clip_text) -> None:
+    global clip_text
+
+    InitPlugins()
+    processors = get_processing_plugins(use_clip)
+
+    clip_text = new_clip_text
+
+    imagefiles = []
+    imagefinalnames = []
+    videofiles = []
+    videofinalnames = []
+    need_join = False
+
+    if files is None:
+        need_join = True
+        if roop.globals.target_folder_path is None:
+            roop.globals.target_folder_path = os.path.dirname(roop.globals.target_path)
+            files = [os.path.basename(roop.globals.target_path)]
+            roop.globals.output_path = os.path.dirname(roop.globals.output_path)
+        else:
+            files = [f for f in os.listdir(roop.globals.target_folder_path) if os.path.isfile(os.path.join(roop.globals.target_folder_path, f))]
+            
+        update_status('Sorting videos/images')
+
+
+    for f in files:
+        if need_join:
+            fullname = os.path.join(roop.globals.target_folder_path, f)
+        else:
+            fullname = f
+        if util.has_image_extension(fullname):
+            imagefiles.append(fullname)
+            imagefinalnames.append(util.get_destfilename_from_path(fullname, roop.globals.output_path, f'_fake.{roop.globals.CFG.output_image_format}'))
+        elif util.is_video(fullname) or util.has_extension(fullname, ['gif']):
+            videofiles.append(fullname)
+            videofinalnames.append(util.get_destfilename_from_path(fullname, roop.globals.output_path, f'_fake.{roop.globals.CFG.output_video_format}'))
+
+
+    if(len(imagefiles) > 0):
+        update_status('Processing image(s)')
+        roop.globals.BATCH_IMAGE_CHAIN_PROCESSOR.run_batch_chain(imagefiles, imagefinalnames, roop.globals.execution_threads, processors, params_gen_func)
+    if(len(videofiles) > 0):
+        for index,v in enumerate(videofiles):
+            update_status(f'Processing video {v}')
+            fps = util.detect_fps(v)
+            if roop.globals.keep_frames:
+                update_status('Creating temp resources...')
+                util.create_temp(v)
+                update_status('Extracting frames...')
+                util.extract_frames(v)
+                temp_frame_paths = util.get_temp_frame_paths(v)
+                roop.globals.BATCH_IMAGE_CHAIN_PROCESSOR.run_batch_chain(temp_frame_paths, temp_frame_paths, roop.globals.execution_threads, processors, params_gen_func)
+                update_status(f'Creating video with {fps} FPS...')
+                util.create_video(v, videofinalnames[index], fps)
+            else:
+                update_status(f'Creating video with {fps} FPS...')
+                roop.globals.VIDEO_CHAIN_PROCESSOR.run_video_chain(v,videofinalnames[index], fps, roop.globals.execution_threads, processors, params_gen_func, roop.globals.target_path)
+            if os.path.isfile(videofinalnames[index]):
+                if util.has_extension(v, ['gif']):
+                    gifname = roop.utilities.get_destfilename_from_path(v, './output', '_fake.gif')
+                    update_status('Creating final GIF')
+                    util.create_gif_from_video(videofinalnames[index], gifname)
+                elif not roop.globals.skip_audio:
+                    finalname = roop.utilities.get_destfilename_from_path(videofinalnames[index], roop.globals.output_path, f'_final.{roop.globals.CFG.output_video_format}')
+                    util.restore_audio(videofinalnames[index], v, finalname)
+                    if os.path.isfile(videofinalnames[index]):
+                        os.remove(videofinalnames[index])
+            else:
+                update_status('Failed!')
+
+            
+    update_status('Finished')
+    roop.globals.target_folder_path = None
+
+
+def destroy() -> None:
+    if roop.globals.target_path:
+        util.clean_temp(roop.globals.target_path)
+    sys.exit()
+
+
+def run() -> None:
+    parse_args()
+    if not pre_check():
+        return
+    limit_resources()
+    roop.globals.CFG = Settings('config.yaml')
+    if roop.globals.headless:
+        start()
+    else:
+        ui.run()

roop/face_analyser.py

@@ -0,0 +1,65 @@
+import threading
+from typing import Any
+import insightface
+
+import roop.globals
+from roop.typing import Frame
+import cv2
+from PIL import Image
+from roop.capturer import get_video_frame
+
+FACE_ANALYSER = None
+THREAD_LOCK = threading.Lock()
+
+
+def get_face_analyser() -> Any:
+    global FACE_ANALYSER
+
+    with THREAD_LOCK:
+        if FACE_ANALYSER is None:
+            FACE_ANALYSER = insightface.app.FaceAnalysis(name='buffalo_l', providers=roop.globals.execution_providers)
+            FACE_ANALYSER.prepare(ctx_id=0, det_size=(640, 640))
+    return FACE_ANALYSER
+
+
+def get_first_face(frame: Frame) -> Any:
+    faces = get_face_analyser().get(frame)
+    try:
+        return min(faces, key=lambda x: x.bbox[0])
+    #   return sorted(faces, reverse=True, key=lambda x: (x.bbox[2] - x.bbox[0]) * (x.bbox[3] - x.bbox[1]))[0]
+    except ValueError:
+        return None
+
+
+def get_all_faces(frame: Frame) -> Any:
+    try:
+        faces = get_face_analyser().get(frame)
+        return sorted(faces, key = lambda x : x.bbox[0])
+    except IndexError:
+        return None
+
+def extract_face_images(source_filename, video_info):
+    face_data = []
+    source_image = None
+    
+    if video_info[0]:
+        frame = get_video_frame(source_filename, video_info[1])
+        if frame is not None:
+            source_image = frame
+        else:
+            return face_data
+    else:
+        source_image = cv2.imread(source_filename)
+
+        
+    faces = get_all_faces(source_image)
+
+    i = 0
+    for face in faces:
+        (startX, startY, endX, endY) = face['bbox'].astype("int")
+        face_temp = source_image[startY:endY, startX:endX]
+        if face_temp.size < 1:
+            continue
+        i += 1
+        face_data.append([face, face_temp])
+    return face_data

roop/face_helper.py

@@ -0,0 +1,90 @@
+import threading
+from typing import Any
+import insightface
+
+import roop.globals
+from roop.typing import Frame, Face
+
+import cv2
+from PIL import Image
+from roop.capturer import get_video_frame
+from roop.utilities import resolve_relative_path, conditional_download
+
+FACE_ANALYSER = None
+THREAD_LOCK_ANALYSER = threading.Lock()
+THREAD_LOCK_SWAPPER = threading.Lock()
+FACE_SWAPPER = None
+
+
+def get_face_analyser() -> Any:
+    global FACE_ANALYSER
+
+    with THREAD_LOCK_ANALYSER:
+        if FACE_ANALYSER is None:
+            FACE_ANALYSER = insightface.app.FaceAnalysis(name='buffalo_l', providers=roop.globals.execution_providers)
+            FACE_ANALYSER.prepare(ctx_id=0, det_size=(640, 640))
+    return FACE_ANALYSER
+
+
+def get_one_face(frame: Frame) -> Any:
+    try:
+        face = get_face_analyser().get(frame)
+        return min(face, key=lambda x: x.bbox[0])
+    except ValueError:
+        return None
+
+
+def get_many_faces(frame: Frame) -> Any:
+    try:
+        faces = get_face_analyser().get(frame)
+        return sorted(faces, key = lambda x : x.bbox[0])
+    except IndexError:
+        return None
+
+def extract_face_images(source_filename, video_info):
+    face_data = []
+    source_image = None
+    
+    if video_info[0]:
+        frame = get_video_frame(source_filename, video_info[1])
+        if frame is not None:
+            source_image = frame
+        else:
+            return face_data
+    else:
+        source_image = cv2.imread(source_filename)
+
+        
+    faces = get_many_faces(source_image)
+
+    i = 0
+    for face in faces:
+        (startX, startY, endX, endY) = face['bbox'].astype("int")
+        face_temp = source_image[startY:endY, startX:endX]
+        if face_temp.size < 1:
+            continue
+        i += 1
+        face_data.append([face, face_temp])
+    return face_data
+
+
+
+
+def get_face_swapper() -> Any:
+    global FACE_SWAPPER
+
+    with THREAD_LOCK_SWAPPER:
+        if FACE_SWAPPER is None:
+            model_path = resolve_relative_path('../models/inswapper_128.onnx')
+            FACE_SWAPPER = insightface.model_zoo.get_model(model_path, providers=roop.globals.execution_providers)
+    return FACE_SWAPPER
+
+
+def pre_check() -> bool:
+    download_directory_path = resolve_relative_path('../models')
+    conditional_download(download_directory_path, ['https://huggingface.co/countfloyd/deepfake/resolve/main/inswapper_128.onnx'])
+    return True
+
+
+def swap_face(source_face: Face, target_face: Face, temp_frame: Frame) -> Frame:
+    return get_face_swapper().get(temp_frame, target_face, source_face, paste_back=True)

roop/globals.py

@@ -0,0 +1,41 @@
+from settings import Settings
+from typing import List
+
+source_path = None
+target_path = None
+output_path = None
+target_folder_path = None
+
+frame_processors: List[str] = []
+keep_fps = None
+keep_frames = None
+skip_audio = None
+many_faces = None
+use_batch = None
+source_face_index = 0
+target_face_index = 0
+face_position = None
+video_encoder = None
+video_quality = None
+max_memory = None
+execution_providers: List[str] = []
+execution_threads = None
+headless = None
+log_level = 'error'
+selected_enhancer = None
+face_swap_mode = None
+blend_ratio = 0.5
+distance_threshold = 0.65
+
+FACE_ENHANCER = None
+
+SELECTED_FACE_DATA_INPUT = None
+SELECTED_FACE_DATA_OUTPUT = None
+
+IMAGE_CHAIN_PROCESSOR = None
+VIDEO_CHAIN_PROCESSOR = None
+BATCH_IMAGE_CHAIN_PROCESSOR = None
+
+CFG: Settings = None
+
+

roop/metadata.py

@@ -0,0 +1,2 @@
+name = 'roop unleashed'
+version = '2.6.6'

roop/processors/frame/core.py

@@ -0,0 +1,100 @@
+import os
+import sys
+import importlib
+import psutil
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from queue import Queue
+from types import ModuleType
+from typing import Any, List, Callable
+from roop.typing import Face
+from tqdm import tqdm
+
+import roop
+
+FRAME_PROCESSORS_MODULES: List[ModuleType] = []
+FRAME_PROCESSORS_INTERFACE = [
+    'pre_check',
+    'pre_start',
+    'process_frame',
+    'process_frames',
+    'process_image',
+    'process_video',
+    'post_process'
+]
+
+
+def load_frame_processor_module(frame_processor: str) -> Any:
+    try:
+        module_name = f'roop.processors.frame.{frame_processor}'
+        print(f'Loading {module_name}')
+        frame_processor_module = importlib.import_module(module_name)
+        for method_name in FRAME_PROCESSORS_INTERFACE:
+            if not hasattr(frame_processor_module, method_name):
+                raise NotImplementedError
+    except ModuleNotFoundError:
+        sys.exit(f'Frame processor {frame_processor} not found.')
+    except NotImplementedError:
+        sys.exit(f'Frame processor {frame_processor} not implemented correctly.')
+    return frame_processor_module
+
+
+def get_frame_processors_modules(frame_processors: List[str]) -> List[ModuleType]:
+    global FRAME_PROCESSORS_MODULES
+
+    if not FRAME_PROCESSORS_MODULES:
+        for frame_processor in frame_processors:
+            frame_processor_module = load_frame_processor_module(frame_processor)
+            FRAME_PROCESSORS_MODULES.append(frame_processor_module)
+    return FRAME_PROCESSORS_MODULES
+
+
+def multi_process_frame(is_batch: bool, source_face: Face, target_face: Face, temp_frame_paths: List[str], process_frames: Callable[[str, List[str], Any], None], update: Callable[[], None]) -> None:
+    with ThreadPoolExecutor(max_workers=roop.globals.execution_threads) as executor:
+        futures = []
+        queue = create_queue(temp_frame_paths)
+        queue_per_future = max(len(temp_frame_paths) // roop.globals.execution_threads, 1)
+        while not queue.empty():
+            future = executor.submit(process_frames, is_batch, source_face, target_face, pick_queue(queue, queue_per_future), update)
+            futures.append(future)
+        for future in as_completed(futures):
+            future.result()
+
+
+def create_queue(temp_frame_paths: List[str]) -> Queue[str]:
+    queue: Queue[str] = Queue()
+    for frame_path in temp_frame_paths:
+        queue.put(frame_path)
+    return queue
+
+
+def pick_queue(queue: Queue[str], queue_per_future: int) -> List[str]:
+    queues = []
+    for _ in range(queue_per_future):
+        if not queue.empty():
+            queues.append(queue.get())
+    return queues
+
+def process_batch(source_face: Face, target_face: Face, frame_paths: list[str], process_frames: Callable[[str, List[str], Any], None]) -> None:
+    progress_bar_format = '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}]'
+    total = len(frame_paths)
+    with tqdm(total=total, desc='Processing', unit='frame', dynamic_ncols=True, bar_format=progress_bar_format) as progress:
+        multi_process_frame(True, source_face, target_face, frame_paths, process_frames, lambda: update_progress(progress))
+
+
+def process_video(source_face: Face, target_face: Face, frame_paths: list[str], process_frames: Callable[[str, List[str], Any], None]) -> None:
+    progress_bar_format = '{l_bar}{bar}| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, {rate_fmt}{postfix}]'
+    total = len(frame_paths)
+    with tqdm(total=total, desc='Processing', unit='frame', dynamic_ncols=True, bar_format=progress_bar_format) as progress:
+        multi_process_frame(False, source_face, target_face, frame_paths, process_frames, lambda: update_progress(progress))
+
+
+def update_progress(progress: Any = None) -> None:
+    process = psutil.Process(os.getpid())
+    memory_usage = process.memory_info().rss / 1024 / 1024 / 1024
+    progress.set_postfix({
+        'memory_usage': '{:.2f}'.format(memory_usage).zfill(5) + 'GB',
+        'execution_providers': roop.globals.execution_providers,
+        'execution_threads': roop.globals.execution_threads
+    })
+    progress.refresh()
+    progress.update(1)

roop/processors/frame/face_swapper.py

@@ -0,0 +1,123 @@
+from typing import Any, List, Callable
+import cv2
+import insightface
+import threading
+
+import roop.globals
+import roop.processors.frame.core
+from roop.core import update_status
+from roop.face_analyser import get_first_face, get_all_faces
+from roop.typing import Face, Frame
+from roop.utilities import conditional_download, resolve_relative_path, is_image, is_video, compute_cosine_distance, get_destfilename_from_path
+
+FACE_SWAPPER = None
+THREAD_LOCK = threading.Lock()
+NAME = 'ROOP.FACE-SWAPPER'
+
+DIST_THRESHOLD = 0.65
+
+
+def get_face_swapper() -> Any:
+    global FACE_SWAPPER
+
+    with THREAD_LOCK:
+        if FACE_SWAPPER is None:
+            model_path = resolve_relative_path('../models/inswapper_128.onnx')
+            FACE_SWAPPER = insightface.model_zoo.get_model(model_path, providers=roop.globals.execution_providers)
+    return FACE_SWAPPER
+
+
+def pre_check() -> bool:
+    download_directory_path = resolve_relative_path('../models')
+    conditional_download(download_directory_path, ['https://huggingface.co/henryruhs/roop/resolve/main/inswapper_128.onnx'])
+    return True
+
+
+def pre_start() -> bool:
+    if not is_image(roop.globals.source_path):
+        update_status('Select an image for source path.', NAME)
+        return False
+    elif not get_first_face(cv2.imread(roop.globals.source_path)):
+        update_status('No face in source path detected.', NAME)
+        return False
+    if not is_image(roop.globals.target_path) and not is_video(roop.globals.target_path):
+        update_status('Select an image or video for target path.', NAME)
+        return False
+    return True
+
+
+def post_process() -> None:
+    global FACE_SWAPPER
+
+    FACE_SWAPPER = None
+
+
+def swap_face(source_face: Face, target_face: Face, temp_frame: Frame) -> Frame:
+    return get_face_swapper().get(temp_frame, target_face, source_face, paste_back=True)
+
+
+def process_frame(source_face: Face, target_face: Face, temp_frame: Frame) -> Frame:
+    global DIST_THRESHOLD
+
+    if roop.globals.many_faces:
+        many_faces = get_all_faces(temp_frame)
+        if many_faces:
+            for target_face in many_faces:
+                if target_face['det_score'] > 0.65:
+                    temp_frame = swap_face(source_face, target_face, temp_frame)
+    else:
+        if target_face:
+            target_embedding = target_face.embedding
+            many_faces = get_all_faces(temp_frame)
+            target_face = None
+            for dest_face in many_faces:
+                dest_embedding = dest_face.embedding
+                if compute_cosine_distance(target_embedding, dest_embedding) <= DIST_THRESHOLD:
+                    target_face = dest_face
+                    break
+            if target_face:
+                temp_frame = swap_face(source_face, target_face, temp_frame)
+            return temp_frame
+                    
+        target_face = get_first_face(temp_frame)
+        if target_face:
+            temp_frame = swap_face(source_face, target_face, temp_frame)
+    return temp_frame
+
+
+
+def process_frames(is_batch: bool, source_face: Face, target_face: Face, temp_frame_paths: List[str], update: Callable[[], None]) -> None:
+    for temp_frame_path in temp_frame_paths:
+        temp_frame = cv2.imread(temp_frame_path)
+        if temp_frame is not None:
+            result = process_frame(source_face, target_face, temp_frame)
+            if result is not None:
+                if is_batch:
+                    tf = get_destfilename_from_path(temp_frame_path, roop.globals.output_path, '_fake.png')
+                    cv2.imwrite(tf, result)
+                else:
+                    cv2.imwrite(temp_frame_path, result)
+        if update:
+            update()
+
+
+def process_image(source_face: Any, target_face: Any, target_path: str, output_path: str) -> None:
+    global DIST_THRESHOLD
+
+    target_frame = cv2.imread(target_path)
+    if target_frame is not None:
+        result = process_frame(source_face, target_face, target_frame)
+        if result is not None:
+            cv2.imwrite(output_path, result)
+
+
+def process_video(source_face: Any, target_face: Any, temp_frame_paths: List[str]) -> None:
+    global DIST_THRESHOLD
+
+    roop.processors.frame.core.process_video(source_face, target_face, temp_frame_paths, process_frames)
+
+
+def process_batch_images(source_face: Any, target_face: Any, temp_frame_paths: List[str]) -> None:
+    global DIST_THRESHOLD
+
+    roop.processors.frame.core.process_batch(source_face, target_face, temp_frame_paths, process_frames)

roop/typing.py

@@ -0,0 +1,7 @@
+from typing import Any
+
+from insightface.app.common import Face
+import numpy
+
+Face = Face
+Frame = numpy.ndarray[Any, Any]

roop/ui.json

@@ -0,0 +1,158 @@
+{
+  "CTk": {
+    "fg_color": ["gray95", "gray10"]
+  },
+  "CTkToplevel": {
+    "fg_color": ["gray95", "gray10"]
+  },
+  "CTkFrame": {
+    "corner_radius": 6,
+    "border_width": 0,
+    "fg_color": ["gray90", "gray13"],
+    "top_fg_color": ["gray85", "gray16"],
+    "border_color": ["gray65", "gray28"]
+  },
+  "CTkButton": {
+    "corner_radius": 6,
+    "border_width": 0,
+    "fg_color": ["#3a7ebf", "#1f538d"],
+    "hover_color": ["#325882", "#14375e"],
+    "border_color": ["#3E454A", "#949A9F"],
+    "text_color": ["#DCE4EE", "#DCE4EE"],
+    "text_color_disabled": ["gray74", "gray60"]
+  },
+  "CTkLabel": {
+    "corner_radius": 0,
+    "fg_color": "transparent",
+    "text_color": ["gray14", "gray84"]
+  },
+  "CTkEntry": {
+    "corner_radius": 6,
+    "border_width": 2,
+    "fg_color": ["#F9F9FA", "#343638"],
+    "border_color": ["#979DA2", "#565B5E"],
+    "text_color": ["gray14", "gray84"],
+    "placeholder_text_color": ["gray52", "gray62"]
+  },
+  "CTkCheckbox": {
+    "corner_radius": 6,
+    "border_width": 3,
+    "fg_color": ["#3a7ebf", "#1f538d"],
+    "border_color": ["#3E454A", "#949A9F"],
+    "hover_color": ["#325882", "#14375e"],
+    "checkmark_color": ["#DCE4EE", "gray90"],
+    "text_color": ["gray14", "gray84"],
+    "text_color_disabled": ["gray60", "gray45"]
+  },
+  "CTkSwitch": {
+    "corner_radius": 1000,
+    "border_width": 3,
+    "button_length": 0,
+    "fg_color": ["#939BA2", "#4A4D50"],
+    "progress_color": ["#3a7ebf", "#1f538d"],
+    "button_color": ["gray36", "#D5D9DE"],
+    "button_hover_color": ["gray20", "gray100"],
+    "text_color": ["gray14", "gray84"],
+    "text_color_disabled": ["gray60", "gray45"]
+  },
+  "CTkRadiobutton": {
+    "corner_radius": 1000,
+    "border_width_checked": 6,
+    "border_width_unchecked": 3,
+    "fg_color": ["#3a7ebf", "#1f538d"],
+    "border_color": ["#3E454A", "#949A9F"],
+    "hover_color": ["#325882", "#14375e"],
+    "text_color": ["gray14", "gray84"],
+    "text_color_disabled": ["gray60", "gray45"]
+  },
+  "CTkProgressBar": {
+    "corner_radius": 1000,
+    "border_width": 0,
+    "fg_color": ["#939BA2", "#4A4D50"],
+    "progress_color": ["#3a7ebf", "#1f538d"],
+    "border_color": ["gray", "gray"]
+  },
+  "CTkSlider": {
+    "corner_radius": 1000,
+    "button_corner_radius": 1000,
+    "border_width": 6,
+    "button_length": 0,
+    "fg_color": ["#939BA2", "#4A4D50"],
+    "progress_color": ["gray40", "#AAB0B5"],
+    "button_color": ["#3a7ebf", "#1f538d"],
+    "button_hover_color": ["#325882", "#14375e"]
+  },
+  "CTkOptionMenu": {
+    "corner_radius": 6,
+    "fg_color": ["#3a7ebf", "#1f538d"],
+    "button_color": ["#325882", "#14375e"],
+    "button_hover_color": ["#234567", "#1e2c40"],
+    "text_color": ["#DCE4EE", "#DCE4EE"],
+    "text_color_disabled": ["gray74", "gray60"]
+  },
+  "CTkComboBox": {
+    "corner_radius": 6,
+    "border_width": 2,
+    "fg_color": ["#F9F9FA", "#343638"],
+    "border_color": ["#979DA2", "#565B5E"],
+    "button_color": ["#979DA2", "#565B5E"],
+    "button_hover_color": ["#6E7174", "#7A848D"],
+    "text_color": ["gray14", "gray84"],
+    "text_color_disabled": ["gray50", "gray45"]
+  },
+  "CTkScrollbar": {
+    "corner_radius": 1000,
+    "border_spacing": 4,
+    "fg_color": "transparent",
+    "button_color": ["gray55", "gray41"],
+    "button_hover_color": ["gray40", "gray53"]
+  },
+  "CTkSegmentedButton": {
+    "corner_radius": 6,
+    "border_width": 2,
+    "fg_color": ["#979DA2", "gray29"],
+    "selected_color": ["#3a7ebf", "#1f538d"],
+    "selected_hover_color": ["#325882", "#14375e"],
+    "unselected_color": ["#979DA2", "gray29"],
+    "unselected_hover_color": ["gray70", "gray41"],
+    "text_color": ["#DCE4EE", "#DCE4EE"],
+    "text_color_disabled": ["gray74", "gray60"]
+  },
+  "CTkTextbox": {
+    "corner_radius": 6,
+    "border_width": 0,
+    "fg_color": ["gray100", "gray20"],
+    "border_color": ["#979DA2", "#565B5E"],
+    "text_color": ["gray14", "gray84"],
+    "scrollbar_button_color": ["gray55", "gray41"],
+    "scrollbar_button_hover_color": ["gray40", "gray53"]
+  },
+  "CTkScrollableFrame": {
+    "label_fg_color": ["gray80", "gray21"]
+  },
+  "DropdownMenu": {
+    "fg_color": ["gray90", "gray20"],
+    "hover_color": ["gray75", "gray28"],
+    "text_color": ["gray14", "gray84"]
+  },
+  "CTkFont": {
+    "macOS": {
+      "family": "Avenir",
+      "size": 12,
+      "weight": "normal"
+    },
+    "Windows": {
+      "family": "Corbel",
+      "size": 12,
+      "weight": "normal"
+    },
+    "Linux": {
+      "family": "Montserrat",
+      "size": 12,
+      "weight": "normal"
+    }
+  },
+  "RoopDonate": {
+    "text_color": ["#3a7ebf", "gray60"]
+  }
+}

roop/ui.py

@@ -0,0 +1,678 @@
+import os
+import time
+import gradio as gr
+import cv2
+import pathlib
+import shutil
+import roop.globals
+import roop.metadata
+import roop.utilities as util
+
+from roop.face_helper import extract_face_images
+from roop.capturer import get_video_frame, get_video_frame_total, get_image_frame
+
+restart_server = False
+live_cam_active = False
+
+RECENT_DIRECTORY_SOURCE = None
+RECENT_DIRECTORY_TARGET = None
+RECENT_DIRECTORY_OUTPUT = None
+
+SELECTION_FACES_DATA = None
+
+last_image = None
+
+input_thumbs = []
+target_thumbs = []
+
+
+IS_INPUT = True
+SELECTED_FACE_INDEX = 0
+
+SELECTED_INPUT_FACE_INDEX = 0
+SELECTED_TARGET_FACE_INDEX = 0
+
+roop.globals.keep_fps = None
+roop.globals.keep_frames = None
+roop.globals.skip_audio = None
+roop.globals.use_batch = None
+
+input_faces = None
+target_faces = None
+face_selection = None
+fake_cam_image = None
+
+current_cam_image = None
+cam_swapping = False
+
+selected_preview_index = 0
+
+
+def prepare_environment():
+    roop.globals.output_path = os.path.abspath(os.path.join(os.getcwd(), "output"))
+    os.makedirs(roop.globals.output_path, exist_ok=True)
+    os.environ["TEMP"] = os.environ["TMP"] = os.path.abspath(os.path.join(os.getcwd(), "temp"))
+    os.makedirs(os.environ["TEMP"], exist_ok=True)
+    os.environ["GRADIO_TEMP_DIR"] = os.environ["TEMP"]
+
+
+def run():
+    from roop.core import suggest_execution_providers
+    global input_faces, target_faces, face_selection, fake_cam_image, restart_server, live_cam_active, on_settings_changed
+
+    prepare_environment()
+
+    available_themes = ["Default", "gradio/glass", "gradio/monochrome", "gradio/seafoam", "gradio/soft", "gstaff/xkcd", "freddyaboulton/dracula_revamped", "ysharma/steampunk"]
+    image_formats = ['jpg','png', 'webp']
+    video_formats = ['avi','mkv', 'mp4', 'webm']
+    video_codecs = ['libx264', 'libx265', 'libvpx-vp9', 'h264_nvenc', 'hevc_nvenc']
+    providerlist = suggest_execution_providers()
+    
+    server_name = roop.globals.CFG.server_name
+    if server_name is None or len(server_name) < 1:
+        server_name = None
+    server_port = roop.globals.CFG.server_port
+    if server_port <= 0:
+        server_port = None
+        
+    settings_controls = []
+
+    live_cam_active = False
+    run_server = True
+
+    while run_server:
+        with gr.Blocks(title=f'{roop.metadata.name} {roop.metadata.version}', theme=roop.globals.CFG.selected_theme, css="span {color: var(--block-info-text-color)}") as ui:
+            with gr.Row(variant='panel'):
+                    gr.Markdown(f"### [{roop.metadata.name} {roop.metadata.version}](https://github.com/C0untFloyd/roop-unleashed)")
+                    gr.HTML(util.create_version_html(), elem_id="versions")
+            with gr.Tab("Face Swap"):
+                with gr.Row():
+                    with gr.Column():
+                        input_faces = gr.Gallery(label="Input faces", allow_preview=True, preview=True, height=128, object_fit="scale-down")
+                        with gr.Row():
+                                bt_remove_selected_input_face = gr.Button("Remove selected")
+                                bt_clear_input_faces = gr.Button("Clear all", variant='stop')
+                        bt_srcimg = gr.Image(label='Source Face Image', type='filepath', tool=None)
+                    with gr.Column():
+                        target_faces = gr.Gallery(label="Target faces", allow_preview=True, preview=True, height=128, object_fit="scale-down")
+                        with gr.Row():
+                                bt_remove_selected_target_face = gr.Button("Remove selected")
+                        bt_destfiles = gr.Files(label='Target File(s)', file_count="multiple", elem_id='filelist')
+                with gr.Row():
+                    with gr.Column(visible=False) as dynamic_face_selection:
+                        face_selection = gr.Gallery(label="Detected faces", allow_preview=True, preview=True, height=256, object_fit="scale-down")
+                        with gr.Row():
+                            bt_faceselect = gr.Button("Use selected face")
+                            bt_cancelfaceselect = gr.Button("Cancel")
+            
+                with gr.Row():
+                    with gr.Column():
+                        selected_face_detection = gr.Dropdown(["First found", "All faces", "Selected face", "All female", "All male"], value="First found", label="Select face swapping method")
+                        max_face_distance = gr.Slider(0.01, 1.0, value=0.65, label="Max Face Similarity Threshold")
+                    with gr.Column():
+                        roop.globals.keep_fps = gr.Checkbox(label="Keep FPS", value=True)
+                        roop.globals.keep_frames = gr.Checkbox(label="Keep Frames", value=False)
+                        roop.globals.skip_audio = gr.Checkbox(label="Skip audio", value=False)
+                with gr.Row():
+                    with gr.Column():
+                        selected_enhancer = gr.Dropdown(["None", "Codeformer", "DMDNet", "GFPGAN"], value="None", label="Select post-processing")
+                        with gr.Accordion(label="Masking", open=True):
+                            chk_useclip = gr.Checkbox(label="Use Text to Clip Masking", value=False)
+                            clip_text = gr.Textbox(label="List of objects to mask and restore back on fake image", placeholder="hands,hair")
+                            
+                    with gr.Column():
+                        blend_ratio = gr.Slider(0.0, 1.0, value=0.65, label="Original/Enhanced image blend ratio")
+                with gr.Row(variant='panel'):
+                    with gr.Column():
+                        bt_start = gr.Button("Start", variant='primary')
+                    with gr.Column():
+                        gr.Markdown(' ')
+                    with gr.Column():
+                        fake_preview = gr.Checkbox(label="Face swap frames", value=False)
+                    with gr.Column():
+                        bt_refresh_preview = gr.Button("Refresh", variant='secondary')
+                with gr.Row(variant='panel'):
+                    with gr.Column():
+                        with gr.Accordion(label="Results", open=True):
+                            resultfiles = gr.Files(label='Processed File(s)', interactive=False)
+                            resultimage = gr.Image(type='filepath', interactive=False)
+                    with gr.Column():
+                        with gr.Accordion(label="Preview Original/Fake Frame", open=True):
+                            previewimage = gr.Image(label="Preview Image", interactive=False)
+                            with gr.Column():
+                                preview_frame_num = gr.Slider(0, 0, value=0, label="Frame Number", step=1.0)
+                                bt_use_face_from_preview = gr.Button("Use Face from this Frame", variant='primary')
+                        
+            with gr.Tab("Live Cam"):
+                cam_toggle = gr.Checkbox(label='Activate', value=live_cam_active)
+                if live_cam_active:
+                    with gr.Row():
+                        with gr.Column():
+                            cam = gr.Webcam(label='Camera', source='webcam', interactive=True, streaming=False)
+                        with gr.Column():
+                            fake_cam_image = gr.Image(label='Fake Camera Output', interactive=False)
+
+
+            with gr.Tab("Extras"):
+                with gr.Row():
+                    files_to_process = gr.Files(label='File(s) to process', file_count="multiple")
+                with gr.Row(variant='panel'):
+                    with gr.Accordion(label="Post process", open=False):
+                        with gr.Column():
+                            selected_post_enhancer = gr.Dropdown(["None", "Codeformer", "GFPGAN"], value="None", label="Select post-processing")
+                        with gr.Column():
+                            gr.Button("Start").click(fn=lambda: gr.Info('Not yet implemented...'))
+                with gr.Row(variant='panel'):
+                    with gr.Accordion(label="Video/GIF", open=False):
+                        with gr.Row(variant='panel'):
+                            with gr.Column():
+                                gr.Markdown("""
+                                            # Cut video
+                                            Be aware that this means re-encoding the video which might take a longer time.
+                                            Encoding uses your configuration from the Settings Tab.
+    """)
+                            with gr.Column():
+                                cut_start_time = gr.Slider(0, 100000, value=0, label="Start Frame", step=1.0, interactive=True)
+                            with gr.Column():
+                                cut_end_time = gr.Slider(1, 100000, value=1, label="End Frame", step=1.0, interactive=True)
+                            with gr.Column():
+                                start_cut_video = gr.Button("Start")
+
+    #                     with gr.Row(variant='panel'):
+    #                         with gr.Column():
+    #                             gr.Markdown("""
+    #                                         # Join videos
+    #                                         This also re-encodes the videos like cutting above.
+    # """)
+    #                         with gr.Column():
+    #                             start_join_videos = gr.Button("Start")
+                        with gr.Row(variant='panel'):
+                            gr.Markdown("Extract frames from video")
+                            start_extract_frames = gr.Button("Start")
+                        with gr.Row(variant='panel'):
+                            gr.Markdown("Create video from image files")
+                            gr.Button("Start").click(fn=lambda: gr.Info('Not yet implemented...'))
+                        with gr.Row(variant='panel'):
+                            gr.Markdown("Create GIF from video")
+                            start_create_gif = gr.Button("Create GIF")
+                with gr.Row():
+                    extra_files_output = gr.Files(label='Resulting output files', file_count="multiple")
+                        
+            
+            with gr.Tab("Settings"):
+                with gr.Row():
+                    with gr.Column():
+                        themes = gr.Dropdown(available_themes, label="Theme", info="Change needs complete restart", value=roop.globals.CFG.selected_theme)
+                    with gr.Column():
+                        settings_controls.append(gr.Checkbox(label="Public Server", value=roop.globals.CFG.server_share, elem_id='server_share', interactive=True))
+                        settings_controls.append(gr.Checkbox(label='Clear output folder before each run', value=roop.globals.CFG.clear_output, elem_id='clear_output', interactive=True))
+                    with gr.Column():
+                        input_server_name = gr.Textbox(label="Server Name", lines=1, info="Leave blank to run locally", value=roop.globals.CFG.server_name)
+                    with gr.Column():
+                        input_server_port = gr.Number(label="Server Port", precision=0, info="Leave at 0 to use default", value=roop.globals.CFG.server_port)
+                with gr.Row():
+                    with gr.Column():
+                        max_threads = gr.Slider(1, 64, value=roop.globals.CFG.max_threads, label="Max. Number of Threads", info='default: 8', step=1.0, interactive=True)
+                        settings_controls.append(gr.Dropdown(image_formats, label="Image Output Format", info='default: png', value=roop.globals.CFG.output_image_format, elem_id='output_image_format', interactive=True))
+                        button_clean_temp = gr.Button("Clean temp folder")
+                    with gr.Column():
+                        settings_controls.append(gr.Dropdown(providerlist, label="Provider", value=roop.globals.CFG.provider, elem_id='provider', interactive=True))
+                        settings_controls.append(gr.Dropdown(video_formats, label="Video Output Format", info='default: mp4', value=roop.globals.CFG.output_video_format, elem_id='output_video_format', interactive=True))
+                        button_apply_settings = gr.Button("Apply Settings")
+                    with gr.Column():
+                        settings_controls.append(gr.Dropdown(video_codecs, label="Video Codec", info='default: libx264', value=roop.globals.CFG.output_video_codec, elem_id='output_video_codec', interactive=True))
+                        video_quality = gr.Slider(0, 100, value=roop.globals.CFG.video_quality, label="Video Quality (crf)", info='default: 14', step=1.0, interactive=True)
+                    with gr.Column():
+                        button_apply_restart = gr.Button("Restart Server", variant='primary')
+
+            input_faces.select(on_select_input_face, None, None)
+            bt_remove_selected_input_face.click(fn=remove_selected_input_face, outputs=[input_faces])
+            bt_srcimg.change(fn=on_srcimg_changed, show_progress='full', inputs=bt_srcimg, outputs=[dynamic_face_selection, face_selection, input_faces])
+
+
+            target_faces.select(on_select_target_face, None, None)
+            bt_remove_selected_target_face.click(fn=remove_selected_target_face, outputs=[target_faces])
+
+            bt_destfiles.select(fn=on_destfiles_selected, inputs=[bt_destfiles], outputs=[previewimage, preview_frame_num])
+            bt_destfiles.clear(fn=on_clear_destfiles, outputs=[target_faces])
+            resultfiles.select(fn=on_resultfiles_selected, inputs=[resultfiles], outputs=[resultimage])
+
+            face_selection.select(on_select_face, None, None)
+            bt_faceselect.click(fn=on_selected_face, outputs=[dynamic_face_selection, face_selection, input_faces, target_faces])
+            bt_clear_input_faces.click(fn=on_clear_input_faces, outputs=[input_faces])
+
+            bt_start.click(fn=start_swap, 
+                inputs=[selected_enhancer, selected_face_detection, roop.globals.keep_fps, roop.globals.keep_frames,
+                         roop.globals.skip_audio, max_face_distance, blend_ratio, bt_destfiles, chk_useclip, clip_text],
+                outputs=[resultfiles, resultimage])
+            
+            previewinputs = [preview_frame_num, bt_destfiles, fake_preview, selected_enhancer, selected_face_detection,
+                                max_face_distance, blend_ratio, bt_destfiles, chk_useclip, clip_text] 
+            bt_refresh_preview.click(fn=on_preview_frame_changed, inputs=previewinputs, outputs=[previewimage])            
+            fake_preview.change(fn=on_preview_frame_changed, inputs=previewinputs, outputs=[previewimage])
+            preview_frame_num.change(fn=on_preview_frame_changed, inputs=previewinputs, outputs=[previewimage], show_progress='hidden')
+            bt_use_face_from_preview.click(fn=on_use_face_from_selected, show_progress='full', inputs=[bt_destfiles, preview_frame_num], outputs=[dynamic_face_selection, face_selection, target_faces])
+
+            
+            # Live Cam
+            cam_toggle.change(fn=on_cam_toggle, inputs=[cam_toggle])
+            if live_cam_active:
+                cam.stream(on_stream_swap_cam, inputs=[cam, selected_enhancer, blend_ratio], outputs=[fake_cam_image], show_progress="hidden")
+
+            # Extras
+            start_cut_video.click(fn=on_cut_video, inputs=[files_to_process, cut_start_time, cut_end_time], outputs=[extra_files_output])
+            # start_join_videos.click(fn=on_join_videos, inputs=[files_to_process], outputs=[extra_files_output])
+            start_extract_frames.click(fn=on_extract_frames, inputs=[files_to_process], outputs=[extra_files_output])
+            start_create_gif.click(fn=on_create_gif, inputs=[files_to_process], outputs=[extra_files_output])
+
+            # Settings
+            for s in settings_controls:
+                s.select(fn=on_settings_changed)
+            max_threads.input(fn=lambda a,b='max_threads':on_settings_changed_misc(a,b), inputs=[max_threads])
+            video_quality.input(fn=lambda a,b='video_quality':on_settings_changed_misc(a,b), inputs=[video_quality])
+
+            button_clean_temp.click(fn=clean_temp, outputs=[bt_srcimg, input_faces, target_faces, bt_destfiles])
+            button_apply_settings.click(apply_settings, inputs=[themes, input_server_name, input_server_port])
+            button_apply_restart.click(restart)
+
+
+
+        restart_server = False
+        try:
+            ui.queue().launch(inbrowser=True, server_name=server_name, server_port=server_port, prevent_thread_lock=True, show_error=True)
+        except:
+            restart_server = True
+            run_server = False
+        try:
+            while restart_server == False:
+                time.sleep(5.0)
+        except (KeyboardInterrupt, OSError):
+            print("Keyboard interruption in main thread... closing server.")
+            run_server = False
+        ui.close()
+
+def on_settings_changed_misc(new_val, attribname):
+    if hasattr(roop.globals.CFG, attribname):
+        setattr(roop.globals.CFG, attribname, new_val)
+    else:
+        print("Didn't find attrib!")
+        
+
+
+def on_settings_changed(evt: gr.SelectData):
+    attribname = evt.target.elem_id
+    if isinstance(evt.target, gr.Checkbox):
+        if hasattr(roop.globals.CFG, attribname):
+            setattr(roop.globals.CFG, attribname, evt.selected)
+            return
+    elif isinstance(evt.target, gr.Dropdown):
+        if hasattr(roop.globals.CFG, attribname):
+            setattr(roop.globals.CFG, attribname, evt.value)
+            return
+            
+    raise gr.Error(f'Unhandled Setting for {evt.target}')
+
+
+
+def on_srcimg_changed(imgsrc, progress=gr.Progress()):
+    global RECENT_DIRECTORY_SOURCE, SELECTION_FACES_DATA, IS_INPUT, input_faces, face_selection, input_thumbs, last_image
+    
+    IS_INPUT = True
+
+    if imgsrc == None or last_image == imgsrc:
+        return gr.Column.update(visible=False), None, input_thumbs
+    
+    last_image = imgsrc
+    
+    progress(0, desc="Retrieving faces from image", )      
+    source_path = imgsrc
+    thumbs = []
+    if util.is_image(source_path):
+        roop.globals.source_path = source_path
+        RECENT_DIRECTORY_SOURCE = os.path.dirname(roop.globals.source_path)
+        SELECTION_FACES_DATA = extract_face_images(roop.globals.source_path,  (False, 0))
+        progress(0.5, desc="Retrieving faces from image")      
+        for f in SELECTION_FACES_DATA:
+            image = convert_to_gradio(f[1])
+            thumbs.append(image)
+            
+    progress(1.0, desc="Retrieving faces from image")      
+    if len(thumbs) < 1:
+        raise gr.Error('No faces detected!')
+
+    if len(thumbs) == 1:
+        roop.globals.SELECTED_FACE_DATA_INPUT = SELECTION_FACES_DATA[0][0]
+        input_thumbs.append(thumbs[0])
+        return gr.Column.update(visible=False), None, input_thumbs
+       
+    return gr.Column.update(visible=True), thumbs, gr.Gallery.update(visible=True)
+
+def on_select_input_face(evt: gr.SelectData):
+    global SELECTED_INPUT_FACE_INDEX
+
+    SELECTED_INPUT_FACE_INDEX = evt.index
+
+def remove_selected_input_face():
+    global input_thumbs, SELECTED_INPUT_FACE_INDEX
+
+    if len(input_thumbs) > SELECTED_INPUT_FACE_INDEX:
+        f = input_thumbs.pop(SELECTED_INPUT_FACE_INDEX)
+        del f
+
+    return input_thumbs
+
+def on_select_target_face(evt: gr.SelectData):
+    global SELECTED_TARGET_FACE_INDEX
+
+    SELECTED_TARGET_FACE_INDEX = evt.index
+
+def remove_selected_target_face():
+    global target_thumbs, SELECTED_TARGET_FACE_INDEX
+
+    if len(target_thumbs) > SELECTED_TARGET_FACE_INDEX:
+        f = target_thumbs.pop(SELECTED_TARGET_FACE_INDEX)
+        del f
+    return target_thumbs
+
+
+
+
+
+def on_use_face_from_selected(files, frame_num):
+    global IS_INPUT, SELECTION_FACES_DATA
+
+    IS_INPUT = False
+    thumbs = []
+    
+    roop.globals.target_path = files[selected_preview_index].name
+    if util.is_image(roop.globals.target_path) and not roop.globals.target_path.lower().endswith(('gif')):
+        SELECTION_FACES_DATA = extract_face_images(roop.globals.target_path,  (False, 0))
+        if len(SELECTION_FACES_DATA) > 0:
+            for f in SELECTION_FACES_DATA:
+                image = convert_to_gradio(f[1])
+                thumbs.append(image)
+        else:
+            gr.Info('No faces detected!')
+            roop.globals.target_path = None
+                
+    elif util.is_video(roop.globals.target_path) or roop.globals.target_path.lower().endswith(('gif')):
+        selected_frame = frame_num
+        SELECTION_FACES_DATA = extract_face_images(roop.globals.target_path, (True, selected_frame))
+        if len(SELECTION_FACES_DATA) > 0:
+            for f in SELECTION_FACES_DATA:
+                image = convert_to_gradio(f[1])
+                thumbs.append(image)
+        else:
+            gr.Info('No faces detected!')
+            roop.globals.target_path = None
+
+    if len(thumbs) == 1:
+        roop.globals.SELECTED_FACE_DATA_OUTPUT = SELECTION_FACES_DATA[0][0]
+        target_thumbs.append(thumbs[0])
+        return gr.Row.update(visible=False), None, target_thumbs
+
+    return gr.Row.update(visible=True), thumbs, gr.Gallery.update(visible=True)
+
+
+
+def on_select_face(evt: gr.SelectData):  # SelectData is a subclass of EventData
+    global SELECTED_FACE_INDEX
+    SELECTED_FACE_INDEX = evt.index
+    
+
+def on_selected_face():
+    global IS_INPUT, SELECTED_FACE_INDEX, SELECTION_FACES_DATA, input_thumbs, target_thumbs
+    
+    fd = SELECTION_FACES_DATA[SELECTED_FACE_INDEX]
+    image = convert_to_gradio(fd[1])
+    if IS_INPUT:
+        roop.globals.SELECTED_FACE_DATA_INPUT = fd[0]
+        input_thumbs.append(image)
+        return gr.Column.update(visible=False), None, input_thumbs, gr.Gallery.update(visible=True)
+    else:
+        roop.globals.SELECTED_FACE_DATA_OUTPUT = fd[0]
+        target_thumbs.append(image)
+        return gr.Column.update(visible=False), None, gr.Gallery.update(visible=True), target_thumbs
+    
+#        bt_faceselect.click(fn=on_selected_face, outputs=[dynamic_face_selection, face_selection, input_faces, target_faces])
+
+
+
+
+def on_preview_frame_changed(frame_num, files, fake_preview, enhancer, detection, face_distance, blend_ratio, target_files, use_clip, clip_text):
+    from roop.core import live_swap
+
+    filename = files[selected_preview_index].name
+    if util.is_video(filename) or filename.lower().endswith('gif'):
+        current_frame = get_video_frame(filename, frame_num)
+    else:
+        current_frame = get_image_frame(filename)
+    if current_frame is None:
+        return None 
+
+    if not fake_preview or roop.globals.SELECTED_FACE_DATA_INPUT is None:
+        return convert_to_gradio(current_frame)
+
+    roop.globals.face_swap_mode = translate_swap_mode(detection)
+    roop.globals.selected_enhancer = enhancer
+    roop.globals.distance_threshold = face_distance
+    roop.globals.blend_ratio = blend_ratio
+
+    if use_clip and clip_text is None or len(clip_text) < 1:
+        use_clip = False
+
+    roop.globals.execution_threads = roop.globals.CFG.max_threads
+    current_frame = live_swap(current_frame, roop.globals.face_swap_mode, use_clip, clip_text)
+    if current_frame is None:
+        return None 
+    return convert_to_gradio(current_frame)
+
+    
+
+
+def on_clear_input_faces():
+    global input_thumbs
+    
+    input_thumbs = []
+    roop.globals.SELECTED_FACE_DATA_INPUT = None
+    return input_thumbs
+
+def on_clear_destfiles():
+    global target_thumbs
+
+    roop.globals.SELECTED_FACE_DATA_OUTPUT = None
+    target_thumbs = []
+    return target_thumbs    
+
+
+
+def translate_swap_mode(dropdown_text):
+    if dropdown_text == "Selected face":
+        return "selected"
+    elif dropdown_text == "First found":
+        return "first"
+    elif dropdown_text == "All female":
+        return "all_female"
+    elif dropdown_text == "All male":
+        return "all_male"
+    
+    return "all"
+        
+
+
+def start_swap(enhancer, detection, keep_fps, keep_frames, skip_audio, face_distance, blend_ratio, target_files, use_clip, clip_text):
+    from roop.core import batch_process
+
+    if target_files is None or len(target_files) <= 0:
+        return None, None
+    
+    if roop.globals.CFG.clear_output:
+        shutil.rmtree(roop.globals.output_path)
+        
+    prepare_environment()
+
+    roop.globals.selected_enhancer = enhancer
+    roop.globals.target_path = None
+    roop.globals.distance_threshold = face_distance
+    roop.globals.blend_ratio = blend_ratio
+    roop.globals.keep_fps = keep_fps
+    roop.globals.keep_frames = keep_frames
+    roop.globals.skip_audio = skip_audio
+    roop.globals.face_swap_mode = translate_swap_mode(detection)
+    if use_clip and clip_text is None or len(clip_text) < 1:
+        use_clip = False
+    
+    if roop.globals.face_swap_mode == 'selected':
+        if roop.globals.SELECTED_FACE_DATA_OUTPUT is None or len(roop.globals.SELECTED_FACE_DATA_OUTPUT) < 1:
+            gr.Error('No Target Face selected!')
+            return None, None
+            
+    roop.globals.execution_threads = roop.globals.CFG.max_threads
+    roop.globals.video_encoder = roop.globals.CFG.output_video_codec
+    roop.globals.video_quality = roop.globals.CFG.video_quality
+
+    batch_process([file.name for file in target_files], use_clip, clip_text)
+    outdir = pathlib.Path(roop.globals.output_path)
+    outfiles = [item for item in outdir.iterdir() if item.is_file()]
+    if len(outfiles) > 0:
+        return outfiles, outfiles[0]
+    return None, None
+
+   
+    
+def on_destfiles_selected(evt: gr.SelectData, target_files):
+    global selected_preview_index
+
+    selected_preview_index = evt.index
+    filename = target_files[selected_preview_index].name
+    if util.is_video(filename) or filename.lower().endswith('gif'):
+        current_frame = get_video_frame(filename, 0)
+        total_frames = get_video_frame_total(filename)
+    else:
+        current_frame = get_image_frame(filename)
+        total_frames = 0
+    
+    current_frame = convert_to_gradio(current_frame)
+    return current_frame, gr.Slider.update(value=0, maximum=total_frames)
+    
+
+def on_resultfiles_selected(evt: gr.SelectData, files):
+    selected_index = evt.index
+    filename = files[selected_index].name
+    if util.is_video(filename) or filename.lower().endswith('gif'):
+        current_frame = get_video_frame(filename, 0)
+    else:
+        current_frame = get_image_frame(filename)
+    return convert_to_gradio(current_frame)
+
+    
+        
+def on_cam_toggle(state):
+    global live_cam_active, restart_server
+
+    live_cam_active = state
+    gr.Warning('Server will be restarted for this change!')
+    restart_server = True
+
+
+def on_stream_swap_cam(camimage, enhancer, blend_ratio):
+    from roop.core import live_swap
+    global current_cam_image, cam_counter, cam_swapping, fake_cam_image
+
+    roop.globals.selected_enhancer = enhancer
+    roop.globals.blend_ratio = blend_ratio
+
+    if not cam_swapping and roop.globals.SELECTED_FACE_DATA_INPUT is not None:
+        cam_swapping = True
+        current_cam_image = live_swap(camimage, "all", False, None)
+        cam_swapping = False
+    
+    return current_cam_image
+
+
+def on_cut_video(files, cut_start_frame, cut_end_frame):
+    resultfiles = []
+    for tf in files:
+        f = tf.name
+        # destfile = get_destfilename_from_path(f, resolve_relative_path('./output'), '_cut')
+        destfile = util.get_destfilename_from_path(f, './output', '_cut')
+        util.cut_video(f, destfile, cut_start_frame, cut_end_frame)
+        if os.path.isfile(destfile):
+            resultfiles.append(destfile)
+        else:
+            gr.Error('Cutting video failed!')
+    return resultfiles
+
+def on_join_videos(files):
+    filenames = []
+    for f in files:
+        filenames.append(f.name)
+    destfile = util.get_destfilename_from_path(filenames[0], './output', '_join')        
+    util.join_videos(filenames, destfile)
+    resultfiles = []
+    if os.path.isfile(destfile):
+        resultfiles.append(destfile)
+    else:
+        gr.Error('Joining videos failed!')
+    return resultfiles
+
+
+
+
+def on_extract_frames(files):
+    resultfiles = []
+    for tf in files:
+        f = tf.name
+        resfolder = util.extract_frames(f)
+        for file in os.listdir(resfolder):
+            outfile = os.path.join(resfolder, file)
+            if os.path.isfile(outfile):
+                resultfiles.append(outfile)
+    return resultfiles
+
+
+def on_create_gif(files):
+    for tf in files:
+        f = tf.name
+        gifname = util.get_destfilename_from_path(f, './output', '.gif')
+        util.create_gif_from_video(f, gifname)
+    
+    return gifname
+
+
+
+
+
+def clean_temp():
+    global input_thumbs, target_thumbs
+    
+    shutil.rmtree(os.environ["TEMP"])
+    prepare_environment()
+   
+    input_thumbs = []
+    roop.globals.SELECTED_FACE_DATA_INPUT = None
+    roop.globals.SELECTED_FACE_DATA_OUTPUT = None
+    target_thumbs = []
+    gr.Info('Temp Files removed')
+    return None,None,None,None
+
+
+def apply_settings(themes, input_server_name, input_server_port):
+    roop.globals.CFG.selected_theme = themes
+    roop.globals.CFG.server_name = input_server_name
+    roop.globals.CFG.server_port = input_server_port
+    roop.globals.CFG.save()
+    gr.Info('Settings saved')
+
+def restart():
+    global restart_server
+    restart_server = True
+
+
+
+
+# Gradio wants Images in RGB
+def convert_to_gradio(image):
+    if image is None:
+        return None
+    return cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

roop/ui_tk.py

@@ -0,0 +1,429 @@
+import os
+import customtkinter as ctk
+import webbrowser
+import cv2
+import roop.globals
+import roop.metadata
+
+from typing import Callable, Tuple
+from PIL import Image, ImageOps
+from roop.face_helper import get_many_faces, get_one_face, extract_face_images
+from roop.capturer import get_video_frame, get_video_frame_total
+from roop.utilities import is_image, is_video, resolve_relative_path, open_with_default_app, compute_cosine_distance, has_extension
+
+ROOT = None
+ROOT_HEIGHT = 550
+ROOT_WIDTH = 600
+
+PREVIEW = None
+PREVIEW_MAX_HEIGHT = 700
+PREVIEW_MAX_WIDTH = 1200
+IMAGE_BUTTON_WIDTH = 200
+IMAGE_BUTTON_HEIGHT = 200
+
+RECENT_DIRECTORY_SOURCE = None
+RECENT_DIRECTORY_TARGET = None
+RECENT_DIRECTORY_OUTPUT = None
+
+preview_label = None
+preview_slider = None
+source_label = None
+target_label = None
+status_label = None
+FACE_BUTTONS = []
+INPUT_FACES_DATA = None
+OUTPUT_FACES_DATA = None
+
+
+def init(start: Callable, destroy: Callable) -> ctk.CTk:
+    global ROOT, PREVIEW, FACE_SELECT
+
+    ROOT = create_root(start, destroy)
+    PREVIEW = create_preview(ROOT)
+    FACE_SELECT = create_select_faces_win(ROOT)
+    return ROOT
+
+
+
+def create_root(start: Callable, destroy: Callable) -> ctk.CTk:
+    global source_button, target_button, status_label
+
+    ctk.deactivate_automatic_dpi_awareness()
+    ctk.set_appearance_mode('system')
+    ctk.set_default_color_theme(resolve_relative_path('ui.json'))
+    root = ctk.CTk()
+    root.minsize(ROOT_WIDTH, ROOT_HEIGHT)
+    root.title(f'{roop.metadata.name} {roop.metadata.version}')
+    root.configure()
+    root.protocol('WM_DELETE_WINDOW', lambda: destroy())
+
+    base_x1 = 0.075
+    base_x2 = 0.575
+    base_y = 0.635
+    
+    source_button = ctk.CTkButton(root, text='Select image with face(s)', width=IMAGE_BUTTON_WIDTH, height=IMAGE_BUTTON_HEIGHT, compound='top', anchor='center', command=lambda: select_source_path())
+    source_button.place(relx=base_x1, rely=0.05)
+
+    target_button = ctk.CTkButton(root, text='Select target image/video', width=IMAGE_BUTTON_WIDTH, height=IMAGE_BUTTON_HEIGHT, compound='top', anchor='center', command=lambda: select_target_path())
+    target_button.place(relx=base_x2, rely=0.05)
+
+    enhance_label = ctk.CTkLabel(root, text='Select face enhancement engine', anchor='w')
+    enhance_label.place(relx=base_x1, rely=0.49)
+    enhance_label.configure(text_color=ctk.ThemeManager.theme.get('RoopDonate').get('text_color'))
+    
+    enhancer_cb = ctk.CTkComboBox(root, values=["None", "Codeformer", "DMDNet (unavailable)", "GFPGAN"], width=IMAGE_BUTTON_WIDTH, command=select_enhancer)
+    enhancer_cb.set("None")
+    enhancer_cb.place(relx=base_x1, rely=0.532)
+    
+    keep_fps_value = ctk.BooleanVar(value=roop.globals.keep_fps)
+    keep_fps_checkbox = ctk.CTkSwitch(root, text='Keep fps', variable=keep_fps_value, command=lambda: setattr(roop.globals, 'keep_fps', not roop.globals.keep_fps))
+    keep_fps_checkbox.place(relx=base_x1, rely=base_y)
+
+    keep_frames_value = ctk.BooleanVar(value=roop.globals.keep_frames)
+    keep_frames_switch = ctk.CTkSwitch(root, text='Keep frames', variable=keep_frames_value, command=lambda: setattr(roop.globals, 'keep_frames', keep_frames_value.get()))
+    keep_frames_switch.place(relx=base_x1, rely=0.68)
+
+    skip_audio_value = ctk.BooleanVar(value=roop.globals.skip_audio)
+    skip_audio_switch = ctk.CTkSwitch(root, text='Skip audio', variable=skip_audio_value, command=lambda: setattr(roop.globals, 'skip_audio', skip_audio_value.get()))
+    skip_audio_switch.place(relx=base_x2, rely=base_y)
+
+    many_faces_value = ctk.BooleanVar(value=roop.globals.many_faces)
+    many_faces_switch = ctk.CTkSwitch(root, text='Many faces', variable=many_faces_value, command=lambda: setattr(roop.globals, 'many_faces', many_faces_value.get()))
+    many_faces_switch.place(relx=base_x2, rely=0.68)
+
+    use_batch_value = ctk.BooleanVar(value=roop.globals.use_batch)
+    use_batch_switch = ctk.CTkSwitch(root, text='Batch process folder', variable=use_batch_value, command=lambda: setattr(roop.globals, 'use_batch', use_batch_value.get()))
+    use_batch_switch.place(relx=base_x1, rely=0.725)
+
+
+
+    base_y = 0.84
+  
+    start_button = ctk.CTkButton(root, text='Start', command=lambda: select_output_path(start))
+    start_button.place(relx=base_x1, rely=base_y, relwidth=0.15, relheight=0.05)
+
+    stop_button = ctk.CTkButton(root, text='Destroy', command=lambda: destroy())
+    stop_button.place(relx=0.35, rely=base_y, relwidth=0.15, relheight=0.05)
+
+    preview_button = ctk.CTkButton(root, text='Preview', command=lambda: toggle_preview())
+    preview_button.place(relx=0.55, rely=base_y, relwidth=0.15, relheight=0.05)
+
+    result_button = ctk.CTkButton(root, text='Show Result', command=lambda: show_result())
+    result_button.place(relx=0.75, rely=base_y, relwidth=0.15, relheight=0.05)
+
+    status_label = ctk.CTkLabel(root, text=None, justify='center')
+    status_label.place(relx=base_x1, rely=0.9, relwidth=0.8)
+
+    donate_label = ctk.CTkLabel(root, text='Visit the Github Page', justify='center', cursor='hand2')
+    donate_label.place(relx=0.1, rely=0.95, relwidth=0.8)
+    donate_label.configure(text_color=ctk.ThemeManager.theme.get('RoopDonate').get('text_color'))
+    donate_label.bind('<Button>', lambda event: webbrowser.open('https://github.com/C0untFloyd/roop-unleashed'))
+
+    return root
+
+def create_preview(parent) -> ctk.CTkToplevel:
+    global preview_label, preview_slider
+
+def create_preview(parent: ctk.CTkToplevel) -> ctk.CTkToplevel:
+    global preview_label, preview_slider
+
+    preview = ctk.CTkToplevel(parent)
+    preview.withdraw()
+    preview.title('Preview')
+    preview.configure()
+    preview.protocol('WM_DELETE_WINDOW', lambda: toggle_preview())
+    preview.resizable(width=False, height=False)
+
+    preview_label = ctk.CTkLabel(preview, text=None)
+    preview_label.pack(fill='both', expand=True)
+
+    preview_slider = ctk.CTkSlider(preview, from_=0, to=0, command=lambda frame_value: update_preview(frame_value))
+
+    return preview
+
+def update_status(text: str) -> None:
+    status_label.configure(text=text)
+    ROOT.update()
+
+def update_status(text: str) -> None:
+    status_label.configure(text=text)
+    ROOT.update()
+
+
+def select_source_path() -> None:
+    global RECENT_DIRECTORY_SOURCE, INPUT_FACES_DATA
+
+    PREVIEW.withdraw()
+    source_path = ctk.filedialog.askopenfilename(title='Select source image', initialdir=RECENT_DIRECTORY_SOURCE)
+    image = None
+    if is_image(source_path):
+        roop.globals.source_path = source_path
+        RECENT_DIRECTORY_SOURCE = os.path.dirname(roop.globals.source_path)
+        INPUT_FACES_DATA = extract_face_images(roop.globals.source_path,  (False, 0))
+        if len(INPUT_FACES_DATA) > 0:
+            if len(INPUT_FACES_DATA) == 1:
+                image = render_face_from_frame(INPUT_FACES_DATA[0][1], (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT))
+                roop.globals.SELECTED_FACE_DATA_INPUT = INPUT_FACES_DATA[0][0]
+            else:
+                show_face_selection(INPUT_FACES_DATA, True)
+        else:
+            print('No face found!')
+            roop.globals.source_path = None
+    else:
+        roop.globals.source_path = None
+    source_button.configure(image=image)
+    source_button._draw()
+
+
+def select_target_path() -> None:
+    global RECENT_DIRECTORY_TARGET, OUTPUT_FACES_DATA
+
+    PREVIEW.withdraw()
+    target_path = ctk.filedialog.askopenfilename(title='Select target image or video', initialdir=RECENT_DIRECTORY_TARGET)
+    image = None
+    if is_image(target_path) and not target_path.lower().endswith(('gif')):
+        roop.globals.target_path = target_path
+        RECENT_DIRECTORY_TARGET = os.path.dirname(roop.globals.target_path)
+        if roop.globals.many_faces:
+            roop.globals.SELECTED_FACE_DATA_OUTPUT = None
+            image = render_image_preview(target_path, (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT))
+        else:
+            OUTPUT_FACES_DATA = extract_face_images(roop.globals.target_path, (False, 0))
+            if len(OUTPUT_FACES_DATA) > 0:
+                if len(OUTPUT_FACES_DATA) == 1:
+                    image = render_face_from_frame(OUTPUT_FACES_DATA[0][1], (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT))
+                    roop.globals.SELECTED_FACE_DATA_OUTPUT = OUTPUT_FACES_DATA[0][0]
+                    if roop.globals.SELECTED_FACE_DATA_INPUT is not None:
+                        emb1 = roop.globals.SELECTED_FACE_DATA_INPUT.embedding
+                        emb2 = roop.globals.SELECTED_FACE_DATA_OUTPUT.embedding
+                        dist = compute_cosine_distance(emb1, emb2)
+                        print(f'Similarity Distance between Source->Target={dist}')
+                else:
+                    show_face_selection(OUTPUT_FACES_DATA, False)
+            else:
+                print('No face found!')
+                roop.globals.target_path = None
+
+    elif is_video(target_path) or target_path.lower().endswith(('gif')):
+        roop.globals.target_path = target_path
+        RECENT_DIRECTORY_TARGET = os.path.dirname(roop.globals.target_path)
+        if roop.globals.many_faces:
+            roop.globals.SELECTED_FACE_DATA_OUTPUT = None
+            image = render_video_preview(target_path, (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT))
+        else:
+            max_frame = get_video_frame_total(roop.globals.target_path)
+            dialog = ctk.CTkInputDialog(text=f"Please input frame number with target face (1 - {max_frame})", title="Extract Face from Video")
+            selected_frame = dialog.get_input()
+            try:
+                selected_frame = int(selected_frame)
+            except:
+                selected_frame = 1
+            
+            selected_frame = max(selected_frame, 1)
+            selected_frame = min(selected_frame, max_frame)
+            OUTPUT_FACES_DATA = extract_face_images(roop.globals.target_path, (True, selected_frame))
+            if len(OUTPUT_FACES_DATA) > 0:
+                if len(OUTPUT_FACES_DATA) == 1:
+                    image = render_face_from_frame(OUTPUT_FACES_DATA[0][1], (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT))
+                    roop.globals.SELECTED_FACE_DATA_OUTPUT = OUTPUT_FACES_DATA[0][0]
+                else:
+                    show_face_selection(OUTPUT_FACES_DATA, False)
+            else:
+                roop.globals.target_path = None
+        
+    else:
+        roop.globals.target_path = None
+
+    target_button.configure(image=image)
+    target_button._draw()
+
+
+
+def select_output_path(start):
+    global RECENT_DIRECTORY_OUTPUT
+
+
+def params_gen_func(proc, frame):
+    return {"original_frame": frame, "blend_ratio": 0.5, "swap_mode": "all", "input_face_datas": [roop.globals.SELECTED_FACE_DATA_INPUT], "target_face_datas": [roop.globals.SELECTED_FACE_DATA_OUTPUT]}
+
+
+def select_output_path(start: Callable[[], None]) -> None:
+    global RECENT_DIRECTORY_OUTPUT
+
+    if roop.globals.use_batch:
+        roop.globals.target_folder_path = ctk.filedialog.askdirectory(title='Select folder to batch process')
+        print(f'Batch process folder set to {roop.globals.target_folder_path}')
+    else:
+        roop.globals.target_folder_path = None
+
+    if roop.globals.target_folder_path is not None:
+        output_path = ctk.filedialog.askdirectory(title='Select output folder')
+    elif is_image(roop.globals.target_path) and has_extension(roop.globals.target_path, ['gif']) == False:
+        output_path = ctk.filedialog.asksaveasfilename(title='Save image output file', defaultextension='.png', initialfile='output.png', initialdir=RECENT_DIRECTORY_OUTPUT)
+    elif is_video(roop.globals.target_path) or has_extension(roop.globals.target_path, ['gif']) == True:
+        output_path = ctk.filedialog.asksaveasfilename(title='Save video output file', defaultextension='.mp4', initialfile='output.mp4', initialdir=RECENT_DIRECTORY_OUTPUT)
+    else:
+        output_path = None
+
+    if output_path:
+        roop.globals.output_path = output_path
+        RECENT_DIRECTORY_OUTPUT = os.path.dirname(roop.globals.output_path)
+        start()
+
+
+def select_enhancer(choice):
+    roop.globals.selected_enhancer = choice
+
+
+def show_result():
+    open_with_default_app(roop.globals.output_path)
+    
+
+
+def render_image_preview(image_path: str, size: Tuple[int, int]) -> ctk.CTkImage:
+    image = Image.open(image_path)
+    if size:
+        image = ImageOps.fit(image, size, Image.LANCZOS)
+    return ctk.CTkImage(image, size=image.size)
+
+
+def render_face_from_frame(face, size: Tuple[int, int] = None) -> ctk.CTkImage:
+    image = Image.fromarray(cv2.cvtColor(face, cv2.COLOR_BGR2RGB))
+    image = ImageOps.fit(image, (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT), Image.LANCZOS)
+    return ctk.CTkImage(image, size=image.size)
+
+
+def render_video_preview(video_path: str, size: Tuple[int, int], frame_number: int = 0) -> ctk.CTkImage:
+    capture = cv2.VideoCapture(video_path)
+    if frame_number:
+        capture.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+    has_frame, frame = capture.read()
+    if has_frame:
+        image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
+        if size:
+            image = ImageOps.fit(image, size, Image.LANCZOS)
+        return ctk.CTkImage(image, size=image.size)
+    capture.release()
+    cv2.destroyAllWindows()
+
+
+def toggle_preview() -> None:
+    if PREVIEW.state() == 'normal':
+        PREVIEW.withdraw()
+    elif roop.globals.source_path and roop.globals.target_path:
+        init_preview()
+        update_preview()
+        PREVIEW.deiconify()
+
+
+def init_preview() -> None:
+    if is_image(roop.globals.target_path):
+        preview_slider.pack_forget()
+    if is_video(roop.globals.target_path):
+        video_frame_total = get_video_frame_total(roop.globals.target_path)
+        preview_slider.configure(to=video_frame_total)
+        preview_slider.pack(fill='x')
+        preview_slider.set(0)
+
+
+def update_preview(frame_number: int = 0) -> None:
+    if roop.globals.source_path and roop.globals.target_path:
+        temp_frame = get_video_frame(roop.globals.target_path, frame_number)
+        swap_mode = "selected"
+        processors = "faceswap"
+        if roop.globals.selected_enhancer == 'GFPGAN':
+            processors += ",gfpgan"
+        elif roop.globals.selected_enhancer == 'Codeformer':
+            processors += ",codeformer"
+
+        temp_frame, _ = roop.globals.IMAGE_CHAIN_PROCESSOR.run_chain(temp_frame,  
+                                                        {"swap_mode": swap_mode,
+                                                            "input_face_datas": [roop.globals.SELECTED_FACE_DATA_INPUT], "target_face_datas": [roop.globals.SELECTED_FACE_DATA_OUTPUT]},
+                                                            processors)
+        image = Image.fromarray(cv2.cvtColor(temp_frame, cv2.COLOR_BGR2RGB))
+        image = ImageOps.contain(image, (PREVIEW_MAX_WIDTH, PREVIEW_MAX_HEIGHT), Image.LANCZOS)
+        image = ctk.CTkImage(image, size=image.size)
+        preview_label.configure(image=image)
+
+
+def create_select_faces_win(parent) -> ctk.CTkToplevel:
+    global scrollable_frame
+
+    face_win = ctk.CTkToplevel(parent)
+    face_win.minsize(800, 400)
+    face_win.title('Select Face(s)')
+    face_win.configure()
+    face_win.withdraw()
+    face_win.protocol('WM_DELETE_WINDOW', lambda: cancel_face_selection())
+    scrollable_frame = ctk.CTkScrollableFrame(face_win, orientation='horizontal', label_text='Choose face by clicking on it', width=(IMAGE_BUTTON_WIDTH + 40)*3, height=IMAGE_BUTTON_HEIGHT+32)
+    scrollable_frame.grid(row=0, column=0, padx=20, pady=20)
+    scrollable_frame.place(relx=0.05, rely=0.05)
+    cancel_button = ctk.CTkButton(face_win, text='Cancel', command=lambda: cancel_face_selection())
+    cancel_button.place(relx=0.05, rely=0.85, relwidth=0.075, relheight=0.075)
+
+    return face_win
+
+def cancel_face_selection() -> None:
+    toggle_face_selection();
+    ROOT.wm_attributes('-disabled', False)
+    ROOT.focus()
+
+def select_face(index, is_input) -> None:
+    global source_button, target_button, INPUT_FACES_DATA, OUTPUT_FACES_DATA
+
+    if is_input:
+        roop.globals.SELECTED_FACE_DATA_INPUT = INPUT_FACES_DATA[index][0]
+        image = render_face_from_frame(INPUT_FACES_DATA[index][1], (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT))
+        source_button.configure(image=image)
+        source_button._draw()
+    else:
+        roop.globals.SELECTED_FACE_DATA_OUTPUT = OUTPUT_FACES_DATA[index][0]
+        image = render_face_from_frame(OUTPUT_FACES_DATA[index][1], (IMAGE_BUTTON_WIDTH, IMAGE_BUTTON_HEIGHT))
+        target_button.configure(image=image)
+        target_button._draw()
+        if roop.globals.SELECTED_FACE_DATA_INPUT is not None:
+            emb1 = roop.globals.SELECTED_FACE_DATA_INPUT.embedding
+            emb2 = roop.globals.SELECTED_FACE_DATA_OUTPUT.embedding
+            dist = compute_cosine_distance(emb1, emb2)
+            print(f'Similarity Distance between Source->Target={dist}')
+
+    toggle_face_selection();
+    ROOT.wm_attributes('-disabled', False)
+    ROOT.focus()
+
+
+
+def toggle_face_selection() -> None:
+    if FACE_SELECT.state() == 'normal':
+        FACE_SELECT.withdraw()
+    else:
+        FACE_SELECT.deiconify()
+
+
+def show_face_selection(faces, is_input):
+    global FACE_BUTTONS, scrollable_frame
+
+    ROOT.wm_attributes('-disabled', True)
+
+    if len(FACE_BUTTONS) > 0:
+        for b in FACE_BUTTONS:
+            try:
+                # b.place_forget()
+                b.destroy()
+            except:
+                continue
+        FACE_BUTTONS.clear()
+
+    for i,face in enumerate(faces):
+        image = render_face_from_frame(face[1], (128, 128))
+        score = face[0]['det_score']
+        age = face[0]['age']
+        button_text = f'Score: {score} - Sex: {face[0].sex} - Age: {age}'
+        face_button = ctk.CTkButton(scrollable_frame, text=button_text, width=128, height=128, compound='top', anchor='center', command=lambda faceindex=i: select_face(index=faceindex, is_input=is_input))
+        face_button.grid(row=0, column=i, pady=5, padx=5)
+        face_button.configure(image=image)
+        face_button._draw()
+        FACE_BUTTONS.append(face_button)
+
+    FACE_SELECT.deiconify()
+

roop/utilities.py

@@ -0,0 +1,243 @@
+import glob
+import mimetypes
+import os
+import platform
+import shutil
+import ssl
+import subprocess
+import sys
+import urllib
+import torch
+import gradio
+import tempfile
+
+from pathlib import Path
+from typing import List, Any
+from tqdm import tqdm
+from scipy.spatial import distance
+
+import roop.globals
+
+TEMP_FILE = 'temp.mp4'
+TEMP_DIRECTORY = 'temp'
+
+# monkey patch ssl for mac
+if platform.system().lower() == 'darwin':
+    ssl._create_default_https_context = ssl._create_unverified_context
+
+
+def run_ffmpeg(args: List[str]) -> bool:
+    commands = ['ffmpeg', '-hide_banner', '-hwaccel', 'auto', '-y', '-loglevel', roop.globals.log_level]
+    commands.extend(args)
+    print (" ".join(commands))
+    try:
+        subprocess.check_output(commands, stderr=subprocess.STDOUT)
+        return True
+    except Exception:
+        pass
+    return False
+
+
+def detect_fps(target_path: str) -> float:
+    command = ['ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=r_frame_rate', '-of', 'default=noprint_wrappers=1:nokey=1', target_path]
+    output = subprocess.check_output(command).decode().strip().split('/')
+    try:
+        numerator, denominator = map(int, output)
+        return numerator / denominator
+    except Exception:
+        pass
+    return 24.0
+
+def cut_video(original_video: str, cut_video: str, start_frame: int, end_frame: int):
+    fps = detect_fps(original_video)
+    start_time = start_frame / fps
+    num_frames = end_frame - start_frame
+
+    run_ffmpeg(['-ss',  str(start_time), '-i', original_video, '-c:v', roop.globals.video_encoder, '-c:a', 'aac', '-frames:v', str(num_frames), cut_video])
+
+def join_videos(videos: List[str], dest_filename: str):
+    inputs = []
+    filter = ''
+    for i,v in enumerate(videos):
+        inputs.append('-i')
+        inputs.append(v)
+        filter += f'[{i}:v:0][{i}:a:0]'
+    run_ffmpeg([" ".join(inputs), '-filter_complex', f'"{filter}concat=n={len(videos)}:v=1:a=1[outv][outa]"', '-map', '"[outv]"', '-map', '"[outa]"', dest_filename])    
+
+def extract_frames(target_path: str) -> None:
+    create_temp(target_path)
+    temp_directory_path = get_temp_directory_path(target_path)
+    run_ffmpeg(['-i', target_path, '-pix_fmt', 'rgb24', os.path.join(temp_directory_path, f'%04d.{roop.globals.CFG.output_image_format}')])
+    return temp_directory_path
+
+
+def create_video(target_path: str, dest_filename: str, fps: float = 24.0) -> None:
+    temp_directory_path = get_temp_directory_path(target_path)
+    run_ffmpeg(['-r', str(fps), '-i', os.path.join(temp_directory_path, f'%04d.{roop.globals.CFG.output_image_format}'), '-c:v', roop.globals.video_encoder, '-crf', str(roop.globals.video_quality), '-pix_fmt', 'yuv420p', '-vf', 'colorspace=bt709:iall=bt601-6-625:fast=1', '-y', dest_filename])
+    return dest_filename
+
+
+def create_gif_from_video(video_path: str, gif_path):
+    from roop.capturer import get_video_frame
+
+    fps = detect_fps(video_path)
+    frame = get_video_frame(video_path)
+
+    run_ffmpeg(['-i', video_path, '-vf', f'fps={fps},scale={frame.shape[0]}:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse', '-loop', '0', gif_path])
+
+
+def restore_audio(intermediate_video: str, original_video: str, final_video: str) -> None:
+    run_ffmpeg(['-i', intermediate_video, '-i', original_video, '-c:v', 'copy', '-map', '0:v:0', '-map', '1:a:0', '-y', final_video])
+
+
+def get_temp_frame_paths(target_path: str) -> List[str]:
+    temp_directory_path = get_temp_directory_path(target_path)
+    return glob.glob((os.path.join(glob.escape(temp_directory_path), f'*.{roop.globals.CFG.output_image_format}')))
+
+
+def get_temp_directory_path(target_path: str) -> str:
+    target_name, _ = os.path.splitext(os.path.basename(target_path))
+    target_directory_path = os.path.dirname(target_path)
+    return os.path.join(target_directory_path, TEMP_DIRECTORY, target_name)
+
+
+def get_temp_output_path(target_path: str) -> str:
+    temp_directory_path = get_temp_directory_path(target_path)
+    return os.path.join(temp_directory_path, TEMP_FILE)
+
+
+def normalize_output_path(source_path: str, target_path: str, output_path: str) -> Any:
+    if source_path and target_path:
+        source_name, _ = os.path.splitext(os.path.basename(source_path))
+        target_name, target_extension = os.path.splitext(os.path.basename(target_path))
+        if os.path.isdir(output_path):
+            return os.path.join(output_path, source_name + '-' + target_name + target_extension)
+    return output_path
+
+
+def get_destfilename_from_path(srcfilepath: str, destfilepath: str, extension: str) -> str:
+    fn, ext = os.path.splitext(os.path.basename(srcfilepath))
+    if '.' in extension:
+        return os.path.join(destfilepath, f'{fn}{extension}')
+    return os.path.join(destfilepath, f'{fn}{extension}{ext}')
+
+
+
+
+def create_temp(target_path: str) -> None:
+    temp_directory_path = get_temp_directory_path(target_path)
+    Path(temp_directory_path).mkdir(parents=True, exist_ok=True)
+
+
+def move_temp(target_path: str, output_path: str) -> None:
+    temp_output_path = get_temp_output_path(target_path)
+    if os.path.isfile(temp_output_path):
+        if os.path.isfile(output_path):
+            os.remove(output_path)
+        shutil.move(temp_output_path, output_path)
+
+
+def clean_temp(target_path: str) -> None:
+    temp_directory_path = get_temp_directory_path(target_path)
+    parent_directory_path = os.path.dirname(temp_directory_path)
+    if not roop.globals.keep_frames and os.path.isdir(temp_directory_path):
+        shutil.rmtree(temp_directory_path)
+    if os.path.exists(parent_directory_path) and not os.listdir(parent_directory_path):
+        os.rmdir(parent_directory_path)
+
+
+def has_image_extension(image_path: str) -> bool:
+    return image_path.lower().endswith(('png', 'jpg', 'jpeg', 'webp'))
+
+def has_extension(filepath: str, extensions: List[str]) -> bool:
+    return filepath.lower().endswith(tuple(extensions))
+
+
+def is_image(image_path: str) -> bool:
+    if image_path and os.path.isfile(image_path):
+        mimetype, _ = mimetypes.guess_type(image_path)
+        return bool(mimetype and mimetype.startswith('image/'))
+    return False
+
+
+def is_video(video_path: str) -> bool:
+    if video_path and os.path.isfile(video_path):
+        mimetype, _ = mimetypes.guess_type(video_path)
+        return bool(mimetype and mimetype.startswith('video/'))
+    return False
+
+
+def conditional_download(download_directory_path: str, urls: List[str]) -> None:
+    if not os.path.exists(download_directory_path):
+        os.makedirs(download_directory_path)
+    for url in urls:
+        download_file_path = os.path.join(download_directory_path, os.path.basename(url))
+        if not os.path.exists(download_file_path):
+            request = urllib.request.urlopen(url) # type: ignore[attr-defined]
+            total = int(request.headers.get('Content-Length', 0))
+            with tqdm(total=total, desc=f'Downloading {url}', unit='B', unit_scale=True, unit_divisor=1024) as progress:
+                urllib.request.urlretrieve(url, download_file_path, reporthook=lambda count, block_size, total_size: progress.update(block_size)) # type: ignore[attr-defined]
+
+
+def resolve_relative_path(path: str) -> str:
+    return os.path.abspath(os.path.join(os.path.dirname(__file__), path))
+
+def get_device() -> str:
+    if 'CUDAExecutionProvider' in roop.globals.execution_providers:
+        return 'cuda'
+    if 'CoreMLExecutionProvider' in roop.globals.execution_providers:
+        return 'mps'
+    return 'cpu'
+    
+
+# Taken from https://stackoverflow.com/a/68842705
+def get_platform():
+    if sys.platform == 'linux':
+        try:
+            proc_version = open('/proc/version').read()
+            if 'Microsoft' in proc_version:
+                return 'wsl'
+        except:
+            pass
+    return sys.platform
+
+def open_with_default_app(filename):
+    if filename == None:
+        return
+    platform = get_platform()
+    if platform == 'darwin':
+        subprocess.call(('open', filename))
+    elif platform in ['win64', 'win32']:
+        os.startfile(filename.replace('/','\\'))
+    elif platform == 'wsl':
+        subprocess.call('cmd.exe /C start'.split() + [filename])
+    else:                                   # linux variants
+        subprocess.call(('xdg-open', filename))
+
+def prepare_for_batch(target_files):
+    print("Preparing temp files")
+    tempfolder = os.path.join(tempfile.gettempdir(), "rooptmp")
+    if os.path.exists(tempfolder):
+        shutil.rmtree(tempfolder)
+    Path(tempfolder).mkdir(parents=True, exist_ok=True)
+    for f in target_files:
+        newname = os.path.basename(f.name)
+        shutil.move(f.name, os.path.join(tempfolder, newname))
+    return tempfolder
+    
+
+
+def create_version_html():
+    python_version = ".".join([str(x) for x in sys.version_info[0:3]])
+    versions_html = f"""
+python: <span title="{sys.version}">{python_version}</span>
+•
+torch: {getattr(torch, '__long_version__',torch.__version__)}
+•
+gradio: {gradio.__version__}
+"""
+    return versions_html
+
+
+def compute_cosine_distance(emb1, emb2):
+    return distance.cosine(emb1, emb2)