fixed memory leak

修复排序清空缓存的bug

.gitignore

@@ -1,2 +1,3 @@
 node_modules
-.vscode
+.vscode
+.idea

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

@@ -0,0 +1,140 @@
+# GB28181插件
+
+该插件提供SIP server的服务，以及流媒体服务器能力，可以将NVR和摄像头的流抓到m7s中，可获取的设备的录像数据以及访问录像视频。也可以控制摄像头的旋转、缩放等。
+
+## 插件地址
+
+github.com/Monibuca/plugin-gb28181
+
+## 插件引入
+
+```go
+import (
+_ "github.com/Monibuca/plugin-gb28181"
+)
+```
+
+## 默认插件配置
+
+```toml
+[GB28181]
+Serial = "34020000002000000001"
+Realm = "3402000000"
+Expires = 3600
+ListenAddr = "127.0.0.1:5060"
+AutoCloseAfter = -1
+AutoInvite = false
+MediaPort = 58200
+CatalogInterval = 30
+RemoveBanInterval = 600
+Username = ""
+Password = ""
+UdpCacheSize = 0 
+TCP = false
+```
+
+- `ListenAddr`是监听的地址，这里需要注意的是必须要带上Server的IP地址，这个IP地址是向设备发送信息的时候需要带上的。
+- `Serial` Server（SIP）的编号
+- `Realm` Server（SIP）的域
+- `AutoCloseAfter` 如果设置大于等于0，则当某个流最后一个订阅者取消订阅时会延迟N秒，会自动发送bye，节省流量。如果为了响应及时，可以设置成-1，保持流的连接
+- `AutoInvite` 表示自动发起invite，当Server（SIP）接收到设备信息时，立即向设备发送invite命令获取流
+- `MediaPort` 表示用于接收设备流的端口号
+- `CatalogInterval` 定时获取设备目录的间隔，单位秒
+- `RemoveBanInterval` 定时移除注册失败的设备黑名单，单位秒，默认10分钟（600秒）
+- `Username` 国标用户名
+- `Password` 国标密码
+- `TCP` 是否开启TCP接收国标流，默认false
+- `UdpCacheSize` 表示UDP缓存大小，默认为0，不开启。仅当TCP关闭，切缓存大于0时才开启，会最多缓存最多N个包，并排序，修复乱序造成的无法播放问题，注意开启后，会有一定的性能损耗，并丢失部分包。
+
+**注意某些摄像机没有设置用户名的地方，摄像机会以自身的国标id作为用户名，这个时候m7s会忽略使用摄像机的用户名，忽略配置的用户名**
+如果设备配置了错误的用户名和密码，连续三次上报错误后，m7s会记录设备id，并在10分钟内禁止设备注册
+
+## 插件功能
+
+### 使用SIP协议接受NVR或其他GB28181设备的注册
+
+- 服务器启动时自动监听SIP协议端口，当有设备注册时，会记录该设备信息，可以从UI的列表中看到设备
+- 定时发送Catalog命令查询设备的目录信息，可获得通道数据或者子设备
+- 发送RecordInfo命令查询设备对录像数据
+- 发送Invite命令获取设备的实时视频或者录像视频
+- 发送PTZ命令来控制摄像头云台
+
+### 作为GB28281的流媒体服务器接受设备的媒体流
+
+- 当invite设备的**实时**视频流时，会在m7s中创建对应的流，StreamPath由设备编号和通道编号组成，即[设备编号]/[通道编号],如果有多个层级，通道编号是最后一个层级的编号
+- 当invite设备的**录像**视频流时，StreamPath由设备编号和通道编号以及录像的起止时间拼接而成即[设备编号]/[通道编号]/[开始时间]-[结束时间]
+
+### 如何设置UDP缓存大小
+
+通过wireshark抓包，分析rtp，然后看一下大概多少个包可以有序
+
+## 接口API
+
+### 罗列所有的gb28181协议的设备
+
+`/api/gb28181/list`
+设备的结构体如下
+
+```go
+type Device struct {
+*transaction.Core `json:"-"`
+ID                string
+RegisterTime      time.Time
+UpdateTime        time.Time
+Status            string
+Channels          []*Channel
+queryChannel      bool
+sn                int
+from              *sip.Contact
+to                *sip.Contact
+Addr              string
+SipIP             string //暴露的IP
+channelMap        map[string]*Channel
+channelMutex      sync.RWMutex
+}
+```
+
+> 根据golang的规则，小写字母开头的变量不会被序列化
+
+### 从设备拉取视频流
+
+`/api/gb28181/invite`
+
+参数名 | 必传 | 含义
+|----|---|---
+id|是 | 设备ID
+channel|是|通道编号
+startTime|否|开始时间（纯数字Unix时间戳）
+endTime|否|结束时间（纯数字Unix时间戳）
+
+返回200代表成功
+
+### 停止从设备拉流
+
+`/api/gb28181/bye`
+
+参数名 | 必传 | 含义
+|----|---|---
+id|是 | 设备ID
+channel|是|通道编号
+
+### 发送控制命令
+
+`/api/gb28181/control`
+
+参数名 | 必传 | 含义
+|----|---|---
+id|是 | 设备ID
+channel|是|通道编号
+ptzcmd|是|PTZ控制指令
+
+### 查询录像
+
+`/api/gb28181/query/records`
+
+参数名 | 必传 | 含义
+|----|---|---
+id|是 | 设备ID
+channel|是|通道编号
+startTime|否|开始时间（字符串，格式：2021-7-23T12:00:00）
+endTime|否|结束时间（字符串格式同上）

channel.go

@@ -0,0 +1,321 @@
+package gb28181
+
+import (
+	"fmt"
+	"math/rand"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/Monibuca/engine/v3"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
+	"github.com/Monibuca/plugin-gb28181/v3/transaction"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
+)
+
+type ChannelEx struct {
+	device          *Device
+	inviteRes       *sip.Message
+	recordInviteRes *sip.Message
+	RecordPublisher *Publisher
+	LivePublisher   *Publisher
+	LiveSubSP       string //实时子码流
+	Records         []*Record
+	RecordStartTime string
+	RecordEndTime   string
+	recordStartTime time.Time
+	recordEndTime   time.Time
+	state           int32
+	tcpPortIndex    uint16
+}
+
+// Channel 通道
+type Channel struct {
+	DeviceID     string
+	ParentID     string
+	Name         string
+	Manufacturer string
+	Model        string
+	Owner        string
+	CivilCode    string
+	Address      string
+	Parental     int
+	SafetyWay    int
+	RegisterWay  int
+	Secrecy      int
+	Status       string
+	Children     []*Channel
+	*ChannelEx   //自定义属性
+}
+
+func (c *Channel) CreateMessage(Method sip.Method) (requestMsg *sip.Message) {
+	requestMsg = c.device.CreateMessage(Method)
+	requestMsg.StartLine.Uri = sip.NewURI(c.DeviceID + "@" + c.device.to.Uri.Domain())
+	requestMsg.To = &sip.Contact{
+		Uri: requestMsg.StartLine.Uri,
+	}
+	requestMsg.From = &sip.Contact{
+		Uri:    sip.NewURI(config.Serial + "@" + config.Realm),
+		Params: map[string]string{"tag": utils.RandNumString(9)},
+	}
+	return
+}
+func (channel *Channel) QueryRecord(startTime, endTime string) int {
+	d := channel.device
+	channel.RecordStartTime = startTime
+	channel.RecordEndTime = endTime
+	channel.recordStartTime, _ = time.Parse(TIME_LAYOUT, startTime)
+	channel.recordEndTime, _ = time.Parse(TIME_LAYOUT, endTime)
+	channel.Records = nil
+	requestMsg := channel.CreateMessage(sip.MESSAGE)
+	requestMsg.ContentType = "Application/MANSCDP+xml"
+	requestMsg.Body = fmt.Sprintf(`<?xml version="1.0"?>
+<Query>
+<CmdType>RecordInfo</CmdType>
+<SN>%d</SN>
+<DeviceID>%s</DeviceID>
+<StartTime>%s</StartTime>
+<EndTime>%s</EndTime>
+<Secrecy>0</Secrecy>
+<Type>time</Type>
+</Query>`, d.sn, requestMsg.To.Uri.UserInfo(), startTime, endTime)
+	requestMsg.ContentLength = len(requestMsg.Body)
+	return d.SendMessage(requestMsg).Code
+}
+func (channel *Channel) Control(PTZCmd string) int {
+	d := channel.device
+	requestMsg := channel.CreateMessage(sip.MESSAGE)
+	requestMsg.ContentType = "Application/MANSCDP+xml"
+	requestMsg.Body = fmt.Sprintf(`<?xml version="1.0"?>
+<Control>
+<CmdType>DeviceControl</CmdType>
+<SN>%d</SN>
+<DeviceID>%s</DeviceID>
+<PTZCmd>%s</PTZCmd>
+</Control>`, d.sn, requestMsg.To.Uri.UserInfo(), PTZCmd)
+	requestMsg.ContentLength = len(requestMsg.Body)
+	return d.SendMessage(requestMsg).Code
+}
+
+/*
+f字段： f = v/编码格式/分辨率/帧率/码率类型/码率大小a/编码格式/码率大小/采样率
+各项具体含义：
+    v：后续参数为视频的参数；各参数间以 “/”分割；
+编码格式：十进制整数字符串表示
+1 –MPEG-4 2 –H.264 3 – SVAC 4 –3GP
+    分辨率：十进制整数字符串表示
+1 – QCIF 2 – CIF 3 – 4CIF 4 – D1 5 –720P 6 –1080P/I
+帧率：十进制整数字符串表示 0～99
+码率类型：十进制整数字符串表示
+1 – 固定码率（CBR）     2 – 可变码率（VBR）
+码率大小：十进制整数字符串表示 0～100000（如 1表示1kbps）
+    a：后续参数为音频的参数；各参数间以 “/”分割；
+编码格式：十进制整数字符串表示
+1 – G.711    2 – G.723.1     3 – G.729      4 – G.722.1
+码率大小：十进制整数字符串
+音频编码码率： 1 — 5.3 kbps （注：G.723.1中使用）
+   2 — 6.3 kbps （注：G.723.1中使用）
+   3 — 8 kbps （注：G.729中使用）
+   4 — 16 kbps （注：G.722.1中使用）
+   5 — 24 kbps （注：G.722.1中使用）
+   6 — 32 kbps （注：G.722.1中使用）
+   7 — 48 kbps （注：G.722.1中使用）
+   8 — 64 kbps（注：G.711中使用）
+采样率：十进制整数字符串表示
+	1 — 8 kHz（注：G.711/ G.723.1/ G.729中使用）
+	2—14 kHz（注：G.722.1中使用）
+	3—16 kHz（注：G.722.1中使用）
+	4—32 kHz（注：G.722.1中使用）
+	注1：字符串说明
+本节中使用的“十进制整数字符串”的含义为“0”～“4294967296” 之间的十进制数字字符串。
+注2：参数分割标识
+各参数间以“/”分割，参数间的分割符“/”不能省略；
+若两个分割符 “/”间的某参数为空时（即两个分割符 “/”直接将相连时）表示无该参数值；
+注3：f字段说明
+使用f字段时，应保证视频和音频参数的结构完整性，即在任何时候，f字段的结构都应是完整的结构：
+f = v/编码格式/分辨率/帧率/码率类型/码率大小a/编码格式/码率大小/采样率
+若只有视频时，音频中的各参数项可以不填写，但应保持 “a///”的结构:
+f = v/编码格式/分辨率/帧率/码率类型/码率大小a///
+若只有音频时也类似处理，视频中的各参数项可以不填写，但应保持 “v/”的结构：
+f = v/a/编码格式/码率大小/采样率
+f字段中视、音频参数段之间不需空格分割。
+可使用f字段中的分辨率参数标识同一设备不同分辨率的码流。
+*/
+func (channel *Channel) Invite(start, end string) (code int) {
+	if start == "" {
+		if !atomic.CompareAndSwapInt32(&channel.state, 0, 1) {
+			return 304
+		}
+		defer func() {
+			if code != 200 {
+				atomic.StoreInt32(&channel.state, 0)
+			}
+		}()
+		channel.Bye(true)
+	} else {
+		channel.Bye(false)
+	}
+	sint, err1 := strconv.ParseInt(start, 10, 0)
+	eint, err2 := strconv.ParseInt(end, 10, 0)
+	d := channel.device
+	streamPath := fmt.Sprintf("%s/%s", d.ID, channel.DeviceID)
+	s := "Play"
+	ssrc := make([]byte, 10)
+	if start != "" {
+		if err1 != nil || err2 != nil {
+			return 400
+		}
+		s = "Playback"
+		ssrc[0] = '1'
+		streamPath = fmt.Sprintf("%s/%s/%s-%s", d.ID, channel.DeviceID, start, end)
+	} else {
+		ssrc[0] = '0'
+	}
+
+	// size := 1
+	// fps := 15
+	// bitrate := 200
+	// fmt.Sprintf("f=v/2/%d/%d/1/%da///", size, fps, bitrate)
+	copy(ssrc[1:6], []byte(config.Serial[3:8]))
+	randNum := rand.Intn(10000)
+	copy(ssrc[6:], []byte(strconv.Itoa(randNum)))
+	protocol := ""
+	port := config.MediaPort
+	if config.TCP {
+		protocol = "TCP/"
+		port = config.MediaPort + channel.tcpPortIndex
+		if channel.tcpPortIndex++; channel.tcpPortIndex >= config.TCPMediaPortNum {
+			channel.tcpPortIndex = 0
+		}
+	}
+	sdpInfo := []string{
+		"v=0",
+		fmt.Sprintf("o=%s 0 0 IN IP4 %s", d.Serial, d.SipIP),
+		"s=" + s,
+		"u=" + channel.DeviceID + ":0",
+		"c=IN IP4 " + d.SipIP,
+		fmt.Sprintf("t=%d %d", sint, eint),
+		fmt.Sprintf("m=video %d %sRTP/AVP 96", port, protocol),
+		"a=recvonly",
+		"a=rtpmap:96 PS/90000",
+	}
+	if config.TCP {
+		sdpInfo = append(sdpInfo, "a=setup:passive", "a=connection:new")
+	}
+	invite := channel.CreateMessage(sip.INVITE)
+	invite.ContentType = "application/sdp"
+	invite.Contact = &sip.Contact{
+		Uri: sip.NewURI(fmt.Sprintf("%s@%s:%d", d.Serial, d.SipIP, d.SipPort)),
+	}
+	invite.Body = strings.Join(sdpInfo, "\r\n") + "\r\ny=" + string(ssrc) + "\r\n"
+	invite.ContentLength = len(invite.Body)
+	invite.Subject = fmt.Sprintf("%s:%s,%s:0", channel.DeviceID, ssrc, config.Serial)
+	response := d.SendMessage(invite)
+	fmt.Printf("invite response statuscode: %d\n", response.Code)
+	if response.Code == 200 {
+		ds := strings.Split(response.Data.Body, "\r\n")
+		_SSRC, _ := strconv.ParseInt(string(ssrc), 10, 0)
+		SSRC := uint32(_SSRC)
+		for _, l := range ds {
+			if ls := strings.Split(l, "="); len(ls) > 1 {
+				if ls[0] == "y" && len(ls[1]) > 0 {
+					_SSRC, _ = strconv.ParseInt(ls[1], 10, 0)
+					SSRC = uint32(_SSRC)
+					break
+				}
+			}
+		}
+		publisher := &Publisher{
+			Stream: &engine.Stream{
+				StreamPath:     streamPath,
+				AutoCloseAfter: &config.AutoCloseAfter,
+			},
+		}
+		if config.UdpCacheSize > 0 && !config.TCP {
+			publisher.udpCache = utils.NewPqRtp()
+		}
+		if start == "" {
+			publisher.Type = "GB28181 Live"
+			publisher.OnClose = func() {
+				publishers.Remove(SSRC)
+				channel.LivePublisher = nil
+				channel.ByeBye(channel.inviteRes)
+				channel.inviteRes = nil
+				atomic.StoreInt32(&channel.state, 0)
+				if config.AutoInvite {
+					go channel.Invite("", "")
+				}
+			}
+		} else {
+			publisher.Type = "GB28181 Record"
+			publisher.OnClose = func() {
+				publishers.Remove(SSRC)
+				channel.RecordPublisher = nil
+				channel.ByeBye(channel.recordInviteRes)
+				channel.recordInviteRes = nil
+			}
+		}
+		if !publisher.Publish() {
+			return 403
+		}
+		publishers.Add(SSRC, publisher)
+		if start == "" {
+			channel.inviteRes = response.Data
+			channel.LivePublisher = publisher
+		} else {
+			channel.RecordPublisher = publisher
+			channel.recordInviteRes = response.Data
+		}
+		ack := d.CreateMessage(sip.ACK)
+		ack.StartLine = &sip.StartLine{
+			Uri:    sip.NewURI(channel.DeviceID + "@" + d.to.Uri.Domain()),
+			Method: sip.ACK,
+		}
+		ack.From = response.Data.From
+		ack.To = response.Data.To
+		ack.CallID = response.Data.CallID
+		ack.CSeq.ID = invite.CSeq.ID
+		go d.Send(ack)
+	} else if start == "" && config.AutoInvite {
+		time.AfterFunc(time.Second*5, func() {
+			channel.Invite("", "")
+		})
+	}
+	return response.Code
+}
+func (channel *Channel) Bye(live bool) int {
+	if live && channel.inviteRes != nil {
+		defer func() {
+			channel.inviteRes = nil
+			if channel.LivePublisher != nil {
+				channel.LivePublisher.Close()
+			}
+		}()
+		return channel.ByeBye(channel.inviteRes).Code
+	}
+	if !live && channel.recordInviteRes != nil {
+		defer func() {
+			channel.recordInviteRes = nil
+			if channel.RecordPublisher != nil {
+				channel.RecordPublisher.Close()
+			}
+		}()
+		return channel.ByeBye(channel.recordInviteRes).Code
+	}
+	return 404
+}
+func (c *Channel) ByeBye(res *sip.Message) *transaction.Response {
+	if res == nil {
+		return nil
+	}
+	bye := c.device.CreateMessage(sip.BYE)
+	bye.StartLine = &sip.StartLine{
+		Uri:    sip.NewURI(c.DeviceID + "@" + c.device.to.Uri.Domain()),
+		Method: sip.BYE,
+	}
+	bye.From = res.From
+	bye.To = res.To
+	bye.CallID = res.CallID
+	return c.device.SendMessage(bye)
+}

device.go

@@ -0,0 +1,205 @@
+package gb28181
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/Monibuca/engine/v3"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
+	"github.com/Monibuca/plugin-gb28181/v3/transaction"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
+	// . "github.com/Monibuca/utils/v3"
+	// . "github.com/logrusorgru/aurora"
+)
+
+const TIME_LAYOUT = "2006-01-02T15:04:05"
+
+// Record 录像
+type Record struct {
+	//channel   *Channel
+	DeviceID  string
+	Name      string
+	FilePath  string
+	Address   string
+	StartTime string
+	EndTime   string
+	Secrecy   int
+	Type      string
+}
+
+func (r *Record) GetPublishStreamPath() string {
+	return fmt.Sprintf("%s/%s", r.DeviceID, r.StartTime)
+}
+
+type Device struct {
+	*transaction.Core `json:"-"`
+	ID                string
+	RegisterTime      time.Time
+	UpdateTime        time.Time
+	Status            string
+	Channels          []*Channel
+	sn                int
+	from              *sip.Contact
+	to                *sip.Contact
+	Addr              string
+	SipIP             string //暴露的IP
+	channelMap        map[string]*Channel
+	channelMutex      sync.RWMutex
+	subscriber        struct {
+		CallID  string
+		Timeout time.Time
+	}
+}
+
+func (d *Device) addChannel(channel *Channel) {
+	for _, c := range d.Channels {
+		if c.DeviceID == channel.DeviceID {
+			return
+		}
+	}
+	d.Channels = append(d.Channels, channel)
+}
+
+func (d *Device) CheckSubStream() {
+	d.channelMutex.Lock()
+	defer d.channelMutex.Unlock()
+	for _, c := range d.Channels {
+		if s := engine.FindStream("sub/" + c.DeviceID); s != nil {
+			c.LiveSubSP = s.StreamPath
+		} else {
+			c.LiveSubSP = ""
+		}
+	}
+}
+func (d *Device) UpdateChannels(list []*Channel) {
+	d.channelMutex.Lock()
+	defer d.channelMutex.Unlock()
+	for _, c := range list {
+		if _, ok := Ignores[c.DeviceID]; ok {
+			continue
+		}
+		if c.ParentID != "" {
+			path := strings.Split(c.ParentID, "/")
+			parentId := path[len(path)-1]
+			if parent, ok := d.channelMap[parentId]; ok {
+				parent.Children = append(parent.Children, c)
+			} else {
+				d.addChannel(c)
+			}
+		} else {
+			d.addChannel(c)
+		}
+		if old, ok := d.channelMap[c.DeviceID]; ok {
+			c.ChannelEx = old.ChannelEx
+			if len(old.Children) == 0 {
+				if config.PreFetchRecord {
+					n := time.Now()
+					n = time.Date(n.Year(), n.Month(), n.Day(), 0, 0, 0, 0, time.Local)
+					if len(c.Records) == 0 || (n.Format(TIME_LAYOUT) == c.RecordStartTime && n.Add(time.Hour*24-time.Second).Format(TIME_LAYOUT) == c.RecordEndTime) {
+						go c.QueryRecord(n.Format(TIME_LAYOUT), n.Add(time.Hour*24-time.Second).Format(TIME_LAYOUT))
+					}
+				}
+				if config.AutoInvite && c.LivePublisher == nil {
+					go c.Invite("", "")
+				}
+			}
+		} else {
+			c.ChannelEx = &ChannelEx{
+				device: d,
+			}
+			if config.AutoInvite {
+				go c.Invite("", "")
+			}
+		}
+		if s := engine.FindStream("sub/" + c.DeviceID); s != nil {
+			c.LiveSubSP = s.StreamPath
+		} else {
+			c.LiveSubSP = ""
+		}
+		d.channelMap[c.DeviceID] = c
+	}
+}
+func (d *Device) UpdateRecord(channelId string, list []*Record) {
+	d.channelMutex.RLock()
+	if c, ok := d.channelMap[channelId]; ok {
+		c.Records = append(c.Records, list...)
+	}
+	d.channelMutex.RUnlock()
+}
+
+func (d *Device) CreateMessage(Method sip.Method) (requestMsg *sip.Message) {
+	d.sn++
+	requestMsg = &sip.Message{
+		Mode:        sip.SIP_MESSAGE_REQUEST,
+		MaxForwards: 70,
+		UserAgent:   "Monibuca",
+		StartLine: &sip.StartLine{
+			Method: Method,
+			Uri:    d.to.Uri,
+		}, Via: &sip.Via{
+			Transport: "UDP",
+			Host:      d.Core.SipIP,
+			Port:      fmt.Sprintf("%d", d.SipPort),
+			Params: map[string]string{
+				"branch": fmt.Sprintf("z9hG4bK%s", utils.RandNumString(8)),
+				"rport":  "-1", //only key,no-value
+			},
+		}, From: &sip.Contact{Uri: d.from.Uri, Params: map[string]string{"tag": utils.RandNumString(9)}},
+		To: d.to, CSeq: &sip.CSeq{
+			ID:     uint32(d.sn),
+			Method: Method,
+		}, CallID: utils.RandNumString(10),
+		Addr: d.Addr,
+	}
+	return
+}
+func (d *Device) Subscribe() int {
+	requestMsg := d.CreateMessage(sip.SUBSCRIBE)
+	if d.subscriber.CallID != "" {
+		requestMsg.CallID = d.subscriber.CallID
+	}
+	requestMsg.Expires = 3600
+	requestMsg.Event = "Catalog"
+	d.subscriber.Timeout = time.Now().Add(time.Second * time.Duration(requestMsg.Expires))
+	requestMsg.ContentType = "Application/MANSCDP+xml"
+	requestMsg.Body = fmt.Sprintf(`<?xml version="1.0" encoding="gb2312"?>
+<Query>
+<CmdType>Catalog</CmdType>
+<SN>%d</SN>
+<DeviceID>%s</DeviceID>
+</Query>`, d.sn, requestMsg.To.Uri.UserInfo())
+	requestMsg.ContentLength = len(requestMsg.Body)
+	response := d.SendMessage(requestMsg)
+	if response.Code == 200 {
+		d.subscriber.CallID = requestMsg.CallID
+	} else {
+		d.subscriber.CallID = ""
+	}
+	return response.Code
+}
+func (d *Device) Query() {
+	for i := time.Duration(5); i < 100; i++ {
+		time.Sleep(time.Second * i)
+		requestMsg := d.CreateMessage(sip.MESSAGE)
+		requestMsg.ContentType = "Application/MANSCDP+xml"
+		requestMsg.Body = fmt.Sprintf(`<?xml version="1.0" encoding="gb2312"?>
+<Query>
+<CmdType>Catalog</CmdType>
+<SN>%d</SN>
+<DeviceID>%s</DeviceID>
+</Query>`, d.sn, requestMsg.To.Uri.UserInfo())
+		requestMsg.ContentLength = len(requestMsg.Body)
+		response := d.SendMessage(requestMsg)
+		if response.Data != nil && response.Data.Via.Params["received"] != "" {
+			d.SipIP = response.Data.Via.Params["received"]
+		}
+		if response.Code != 200 {
+			fmt.Printf("device %s send Catalog : %d\n", d.ID, response.Code)
+		} else {
+			d.Subscribe()
+			break
+		}
+	}
+}

go.mod

@@ -1,10 +1,13 @@
-module github.com/Monibuca/plugin-gb28181
+module github.com/Monibuca/plugin-gb28181/v3
 
 go 1.13
 
 require (
-	github.com/Monibuca/engine/v2 v2.2.2
-	github.com/Monibuca/plugin-rtp v1.0.0
+	github.com/Monibuca/engine/v3 v3.4.5
+	github.com/Monibuca/utils/v3 v3.0.5
+	github.com/agiledragon/gomonkey/v2 v2.2.0
 	github.com/logrusorgru/aurora v2.0.3+incompatible
-	golang.org/x/net v0.0.0-20201029221708-28c70e62bb1d
+	github.com/pion/rtp v1.7.4
+	golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2
+	golang.org/x/text v0.3.7
 )

go.sum

@@ -1,53 +1,98 @@
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
 github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/Monibuca/engine/v2 v2.2.0/go.mod h1:34EYjjV15G6myuHOKaJkO7y5tJ1Arq/NfC9Weacr2mc=
-github.com/Monibuca/engine/v2 v2.2.2 h1:ho5M3aFW9Mlj9Lb56Qvk0m+9L8yWc7RhwPh8dRWAeBk=
-github.com/Monibuca/engine/v2 v2.2.2/go.mod h1:34EYjjV15G6myuHOKaJkO7y5tJ1Arq/NfC9Weacr2mc=
-github.com/Monibuca/plugin-gb28181 v1.0.0-alpha3 h1:1oOSVIhkHxWZ5ALCVJG7P5MKxywNVm2zEwaHj+UqU1g=
-github.com/Monibuca/plugin-gb28181 v1.0.0-alpha3/go.mod h1:fyzQG2o13Df9VdCd4QrjbY0AFtcoKeIfnTMErVhWpLA=
-github.com/Monibuca/plugin-rtp v1.0.0 h1:yksNsIIGxoKX8UZirkAUK+mGZ/XoEeS2vqbIqtqXyCg=
-github.com/Monibuca/plugin-rtp v1.0.0/go.mod h1:0xkNm23a/BjVnEMz1zXyOqfEjoVmGe3PJqPNF1KyFGc=
-github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d h1:G0m3OIz70MZUWq3EgK3CesDbo8upS2Vm9/P3FtgI+Jk=
-github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d/go.mod h1:3eOhrUMpNV+6aFIbp5/iudMxNCF27Vw2OZgy4xEx0Fg=
+github.com/BurntSushi/toml v0.4.1 h1:GaI7EiDXDRfa8VshkTj7Fym7ha+y8/XxIgD2okUIjLw=
+github.com/BurntSushi/toml v0.4.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
+github.com/Monibuca/engine/v3 v3.4.5 h1:gPRsliBVC70EhKK7sJz/3LoNO7lfnXNC8uUaOIHZkUE=
+github.com/Monibuca/engine/v3 v3.4.5/go.mod h1:Dik9pFxU9TFI5vj8Sv5QXZM+ooCs2fm9P7Uhe4yYNkQ=
+github.com/Monibuca/utils/v3 v3.0.5 h1:w14x0HkWTbF4MmHbINLlOwe4VJNoSOeaQChMk5E/4es=
+github.com/Monibuca/utils/v3 v3.0.5/go.mod h1:RpNS95gapWs6gimwh8Xn2x72FN5tO7Powabj7dTFyvE=
+github.com/agiledragon/gomonkey/v2 v2.2.0 h1:QJWqpdEhGV/JJy70sZ/LDnhbSlMrqHAWHcNOjz1kyuI=
+github.com/agiledragon/gomonkey/v2 v2.2.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY=
+github.com/cnotch/apirouter v0.0.0-20200731232942-89e243a791f3/go.mod h1:5deJPLON/x/s2dLOQfuKS0lenhOIT4xX0pvtN/OEIuY=
+github.com/cnotch/ipchub v1.1.0 h1:hH0lh2mU3AZXPiqMwA0pdtqrwo7PFIMRGush9OobMUs=
+github.com/cnotch/ipchub v1.1.0/go.mod h1:2PbeBs2q2VxxTVCn1eYCDwpAWuVXbq1+N0FU7GimOH4=
+github.com/cnotch/loader v0.0.0-20200405015128-d9d964d09439/go.mod h1:oWpDagHB6p+Kqqq7RoRZKyC4XAXft50hR8pbTxdbYYs=
+github.com/cnotch/queue v0.0.0-20200326024423-6e88bdbf2ad4/go.mod h1:zOssjAlNusOxvtaqT+EMA+Iyi8rrtKr4/XfzN1Fgoeg=
+github.com/cnotch/queue v0.0.0-20201224060551-4191569ce8f6/go.mod h1:zOssjAlNusOxvtaqT+EMA+Iyi8rrtKr4/XfzN1Fgoeg=
+github.com/cnotch/scheduler v0.0.0-20200522024700-1d2da93eefc5/go.mod h1:F4GE3SZkJZ8an1Y0ZCqvSM3jeozNuKzoC67erG1PhIo=
+github.com/cnotch/xlog v0.0.0-20201208005456-cfda439cd3a0/go.mod h1:RW9oHsR79ffl3sR3yMGgxYupMn2btzdtJUwoxFPUE5E=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/emitter-io/address v1.0.0/go.mod h1:GfZb5+S/o8694B1GMGK2imUYQyn2skszMvGNA5D84Ug=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
 github.com/funny/slab v0.0.0-20180511031532-b1fad5e5d478 h1:Db9StoJ6RZN3YttC0Pm0I4Y5izITRYch3RMbT59BYN0=
 github.com/funny/slab v0.0.0-20180511031532-b1fad5e5d478/go.mod h1:0j1+svBH8ABEIPdUP0AIg4qedsybnXGJBakCEw8cfoo=
+github.com/funny/utest v0.0.0-20161029064919-43870a374500 h1:Z0r1CZnoIWFB/Uiwh1BU5FYmuFe6L5NPi6XWQEmsTRg=
 github.com/funny/utest v0.0.0-20161029064919-43870a374500/go.mod h1:mUn39tBov9jKnTWV1RlOYoNzxdBFHiSzXWdY1FoNGGg=
-github.com/go-ole/go-ole v1.2.4 h1:nNBDSCOigTSiarFpYE9J/KtEA1IOW4CNeqT9TQDqCxI=
-github.com/go-ole/go-ole v1.2.4/go.mod h1:XCwSNxSkXRo4vlyPy93sltvi/qJq0jqQhjqQNIwKuxM=
-github.com/logrusorgru/aurora v0.0.0-20200102142835-e9ef32dff381/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
+github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
+github.com/gorilla/websocket v1.4.2/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
+github.com/kelindar/process v0.0.0-20170730150328-69a29e249ec3/go.mod h1:+lTCLnZFXOkqwD8sLPl6u4erAc0cP8wFegQHfipz7KE=
+github.com/kelindar/rate v1.0.0/go.mod h1:AjT4G+hTItNwt30lucEGZIz8y7Uk5zPho6vurIZ+1Es=
+github.com/kelindar/tcp v1.0.0/go.mod h1:JB5hj1cshLU60XrLij2BBxW3JQ4hOye8vqbyvuKb52k=
 github.com/logrusorgru/aurora v2.0.3+incompatible h1:tOpm7WcpBTn4fjmVfgpQq0EfczGlG91VSDkswnjF5A8=
 github.com/logrusorgru/aurora v2.0.3+incompatible/go.mod h1:7rIyQOR62GCctdiQpZ/zOJlFyk6y+94wXzv6RNZgaR4=
-github.com/mask-pp/rtp-ps v1.0.0 h1:JFxuJL9N+gD1ldgJlAy3b7rYfY8wAVHi9ODNmdP4+EE=
-github.com/mask-pp/rtp-ps v1.0.0/go.mod h1:jCxsZ2G7z/jX+aqFypEWMePnhNrfnUiXUEKm6Xp0vgU=
-github.com/mattn/go-colorable v0.1.6 h1:6Su7aK7lXmJ/U79bYtBjLNaha4Fs1Rg9plHpcH+vvnE=
-github.com/mattn/go-colorable v0.1.6/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
+github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
+github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/pion/rtp v1.5.4 h1:PuNg6xqV3brIUihatcKZj1YDUs+M45L0ZbrZWYtkDxY=
-github.com/pion/rtp v1.5.4/go.mod h1:bg60AL5GotNOlYZsqycbhDtEV3TkfbpXG0KBiUq29Mg=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pion/randutil v0.1.0 h1:CFG1UdESneORglEsnimhUjf33Rwjubwj6xfiOXBa3mA=
+github.com/pion/randutil v0.1.0/go.mod h1:XcJrSMMbbMRhASFVOlj/5hQial/Y8oH/HVo7TBZq+j8=
+github.com/pion/rtp v1.6.2/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
+github.com/pion/rtp v1.7.4 h1:4dMbjb1SuynU5OpA3kz1zHK+u+eOCQjW3MAeVHf1ODA=
+github.com/pion/rtp v1.7.4/go.mod h1:bDb5n+BFZxXx0Ea7E5qe+klMuqiBrP+w8XSjiWtCUko=
+github.com/pixelbender/go-sdp v1.1.0/go.mod h1:6IBlz9+BrUHoFTea7gcp4S54khtOhjCW/nVDLhmZBAs=
 github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
 github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/shirou/gopsutil v2.20.1+incompatible h1:oIq9Cq4i84Hk8uQAUOG3eNdI/29hBawGrD5YRl6JRDY=
-github.com/shirou/gopsutil v2.20.1+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
+github.com/q191201771/naza v0.19.1 h1:4KLcxT2CHztO+7miPRtBG3FFgadSQYQw1gPPPKN7rnY=
+github.com/q191201771/naza v0.19.1/go.mod h1:5LeGupZZFtYP1g/S203n9vXoUNVdlRnPIfM6rExjqt0=
+github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
+github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
+github.com/sqs/goreturns v0.0.0-20181028201513-538ac6014518/go.mod h1:CKI4AZ4XmGV240rTHfO0hfE83S6/a3/Q1siZJ/vXf7A=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.6.1 h1:hDPOHmpOpP40lSULcqw7IrRb/u7w6RpDC9399XyoNd0=
+github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20201029221708-28c70e62bb1d h1:dOiJ2n2cMwGLce/74I/QHMbnpk5GfY7InR8rczoMqRM=
-golang.org/x/net v0.0.0-20201029221708-28c70e62bb1d/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2 h1:CIJ76btIcR3eFI5EgSo6k1qKw9KJexJuRLI9G7Hp5wE=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a h1:DcqTD9SDLc+1P/r1EmRBwnVsrOwW+kk2vWf9n+1sGhs=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae h1:/WDfKMnPU+m5M4xB+6x4kaepxRw6jWvR5iDRdvjHgy8=
 golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f h1:+Nyd8tzPX9R7BWHguqsrbFdRx3WQ/1ib8I44HXV5yTA=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da h1:b3NXsE2LusjYGGjL5bxEVZZORm/YEFFrWFjR8eFrw/c=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
 gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

main.go

@@ -1,36 +1,93 @@
 package gb28181
 
 import (
-	. "github.com/Monibuca/engine/v2"
-	"github.com/Monibuca/engine/v2/util"
-	"github.com/Monibuca/plugin-gb28181/transaction"
-	rtp "github.com/Monibuca/plugin-rtp"
-	. "github.com/logrusorgru/aurora"
+	"bufio"
+	"bytes"
+	"encoding/xml"
+	"io"
 	"log"
 	"net"
 	"net/http"
 	"strconv"
-	"strings"
 	"sync"
 	"time"
+
+	"github.com/Monibuca/engine/v3"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
+	"github.com/Monibuca/plugin-gb28181/v3/transaction"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
+	. "github.com/Monibuca/utils/v3"
+	. "github.com/logrusorgru/aurora"
+	"github.com/pion/rtp"
+	"golang.org/x/net/html/charset"
 )
 
-var Devices sync.Map
+var (
+	Devices             sync.Map
+	DeviceNonce         = make(map[string]string) //保存nonce防止设备伪造
+	DeviceRegisterCount = make(map[string]int)    //设备注册次数
+	Ignores             = make(map[string]struct{})
+	publishers          Publishers
+)
+
+const MaxRegisterCount = 3
+
+func FindChannel(deviceId string, channelId string) (c *Channel) {
+	if v, ok := Devices.Load(deviceId); ok {
+		d := v.(*Device)
+		d.channelMutex.RLock()
+		c = d.channelMap[channelId]
+		d.channelMutex.RUnlock()
+	}
+	return
+}
+
+type Publishers struct {
+	data map[uint32]*Publisher
+	sync.RWMutex
+}
+
+func (p *Publishers) Add(key uint32, pp *Publisher) {
+	p.Lock()
+	p.data[key] = pp
+	p.Unlock()
+}
+func (p *Publishers) Remove(key uint32) {
+	p.Lock()
+	delete(p.data, key)
+	p.Unlock()
+}
+func (p *Publishers) Get(key uint32) *Publisher {
+	p.RLock()
+	defer p.RUnlock()
+	return p.data[key]
+}
+
 var config = struct {
-	Serial     string
-	Realm      string
-	ListenAddr string
-	Expires    int
-	AutoInvite bool
-}{"34020000002000000001", "3402000000", "127.0.0.1:5060", 3600, true}
+	Serial            string
+	Realm             string
+	ListenAddr        string
+	Expires           int
+	MediaPort         uint16
+	AutoInvite        bool
+	AutoCloseAfter    int
+	Ignore            []string
+	TCP               bool
+	TCPMediaPortNum   uint16
+	RemoveBanInterval int
+	PreFetchRecord    bool
+	Username          string
+	Password          string
+	UdpCacheSize      int //udp排序缓存
+}{"34020000002000000001", "3402000000", "127.0.0.1:5060", 3600, 58200, false, -1, nil, false, 1, 600, false, "", "", 0}
 
 func init() {
-	InstallPlugin(&PluginConfig{
+	pc := engine.PluginConfig{
 		Name:   "GB28181",
 		Config: &config,
-		Type:   PLUGIN_PUBLISHER,
-		Run:    run,
-	})
+	}
+	pc.Install(run)
+	publishers.data = make(map[uint32]*Publisher)
 }
 
 func run() {
@@ -39,33 +96,54 @@ func run() {
 		log.Fatal(err)
 	}
 	Print(Green("server gb28181 start at"), BrightBlue(config.ListenAddr))
+	for _, id := range config.Ignore {
+		Ignores[id] = struct{}{}
+	}
+	useTCP := config.TCP
 	config := &transaction.Config{
 		SipIP:             ipAddr.IP.String(),
 		SipPort:           uint16(ipAddr.Port),
 		SipNetwork:        "UDP",
 		Serial:            config.Serial,
 		Realm:             config.Realm,
+		Username:          config.Username,
+		Password:          config.Password,
 		AckTimeout:        10,
 		MediaIP:           ipAddr.IP.String(),
 		RegisterValidity:  config.Expires,
 		RegisterInterval:  60,
 		HeartbeatInterval: 60,
 		HeartbeatRetry:    3,
-
-		AudioEnable:      true,
-		WaitKeyFrame:     true,
-		MediaPortMin:     58200,
-		MediaPortMax:     58300,
-		MediaIdleTimeout: 30,
+		AudioEnable:       true,
+		WaitKeyFrame:      true,
+		MediaIdleTimeout:  30,
+		RemoveBanInterval: config.RemoveBanInterval,
+		UdpCacheSize:      config.UdpCacheSize,
 	}
-	s := transaction.NewCore(config)
-	s.OnInvite = onPublish
-	http.HandleFunc("/gb28181/list", func(w http.ResponseWriter, r *http.Request) {
-		sse := util.NewSSE(w, r.Context())
+	http.HandleFunc("/api/gb28181/query/records", func(w http.ResponseWriter, r *http.Request) {
+		CORS(w, r)
+		id := r.URL.Query().Get("id")
+		channel := r.URL.Query().Get("channel")
+		startTime := r.URL.Query().Get("startTime")
+		endTime := r.URL.Query().Get("endTime")
+		if c := FindChannel(id, channel); c != nil {
+			w.WriteHeader(c.QueryRecord(startTime, endTime))
+		} else {
+			w.WriteHeader(404)
+		}
+	})
+	http.HandleFunc("/api/gb28181/list", func(w http.ResponseWriter, r *http.Request) {
+		CORS(w, r)
+		sse := NewSSE(w, r.Context())
 		for {
-			var list []*transaction.Device
-			s.Devices.Range(func(key, value interface{}) bool {
-				list = append(list, value.(*transaction.Device))
+			var list []*Device
+			Devices.Range(func(key, value interface{}) bool {
+				device := value.(*Device)
+				if time.Since(device.UpdateTime) > time.Duration(config.RegisterValidity)*time.Second {
+					Devices.Delete(key)
+				} else {
+					list = append(list, device)
+				}
 				return true
 			})
 			sse.WriteJSON(list)
@@ -76,90 +154,249 @@ func run() {
 			}
 		}
 	})
-	http.HandleFunc("/gb28181/control", func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Access-Control-Allow-Origin", "*")
+	http.HandleFunc("/api/gb28181/control", func(w http.ResponseWriter, r *http.Request) {
+		CORS(w, r)
 		id := r.URL.Query().Get("id")
-		channel ,err:= strconv.Atoi(r.URL.Query().Get("channel"))
-		if err!=nil{
-			w.WriteHeader(404)
-		}
+		channel := r.URL.Query().Get("channel")
 		ptzcmd := r.URL.Query().Get("ptzcmd")
-		if v, ok := s.Devices.Load(id); ok {
-			w.WriteHeader(v.(*transaction.Device).Control(channel,ptzcmd))
+		if c := FindChannel(id, channel); c != nil {
+			w.WriteHeader(c.Control(ptzcmd))
 		} else {
 			w.WriteHeader(404)
 		}
 	})
-	http.HandleFunc("/gb28181/invite", func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Access-Control-Allow-Origin", "*")
+	http.HandleFunc("/api/gb28181/invite", func(w http.ResponseWriter, r *http.Request) {
+		CORS(w, r)
+		query := r.URL.Query()
+		id := query.Get("id")
+		channel := r.URL.Query().Get("channel")
+		startTime := query.Get("startTime")
+		endTime := query.Get("endTime")
+		if c := FindChannel(id, channel); c != nil {
+			if startTime == "" && c.LivePublisher != nil {
+				w.WriteHeader(304) //直播流已存在
+			} else {
+				w.WriteHeader(c.Invite(startTime, endTime))
+			}
+		} else {
+			w.WriteHeader(404)
+		}
+	})
+	http.HandleFunc("/api/gb28181/bye", func(w http.ResponseWriter, r *http.Request) {
+		CORS(w, r)
 		id := r.URL.Query().Get("id")
-		channel ,err:= strconv.Atoi(r.URL.Query().Get("channel"))
-		if err != nil {
-			w.WriteHeader(404)
-		}
-		if v, ok := s.Devices.Load(id); ok {
-			w.WriteHeader(v.(*transaction.Device).Invite(channel))
+		channel := r.URL.Query().Get("channel")
+		live := r.URL.Query().Get("live")
+		if c := FindChannel(id, channel); c != nil {
+			w.WriteHeader(c.Bye(live != "false"))
 		} else {
 			w.WriteHeader(404)
 		}
 	})
-	http.HandleFunc("/gb28181/bye", func(w http.ResponseWriter, r *http.Request) {
-		w.Header().Set("Access-Control-Allow-Origin", "*")
-		id := r.URL.Query().Get("id")
-		channel ,err:= strconv.Atoi(r.URL.Query().Get("channel"))
-		if err != nil {
-			w.WriteHeader(404)
+	s := transaction.NewCore(config)
+	s.OnRegister = func(msg *sip.Message) {
+		id := msg.From.Uri.UserInfo()
+		storeDevice := func() {
+			var d *Device
+
+			if _d, loaded := Devices.LoadOrStore(id, &Device{
+				ID:           id,
+				RegisterTime: time.Now(),
+				UpdateTime:   time.Now(),
+				Status:       string(sip.REGISTER),
+				Core:         s,
+				from:         &sip.Contact{Uri: msg.StartLine.Uri, Params: make(map[string]string)},
+				to:           msg.To,
+				Addr:         msg.Via.GetSendBy(),
+				SipIP:        config.MediaIP,
+				channelMap:   make(map[string]*Channel),
+			}); loaded {
+				d = _d.(*Device)
+				d.UpdateTime = time.Now()
+				d.from = &sip.Contact{Uri: msg.StartLine.Uri, Params: make(map[string]string)}
+				d.to = msg.To
+				d.Addr = msg.Via.GetSendBy()
+			}
 		}
-		if v, ok := s.Devices.Load(id); ok {
-			w.WriteHeader(v.(*transaction.Device).Bye(channel))
-		} else {
-			w.WriteHeader(404)
+		// 不需要密码情况
+		if config.Username == "" && config.Password == "" {
+			storeDevice()
+			return
 		}
-	})
+		sendUnauthorized := func() {
+			response := msg.BuildResponseWithPhrase(401, "Unauthorized")
+			if DeviceNonce[id] == "" {
+				nonce := utils.RandNumString(32)
+				DeviceNonce[id] = nonce
+			}
+			response.WwwAuthenticate = sip.NewWwwAuthenticate(s.Realm, DeviceNonce[id], sip.DIGEST_ALGO_MD5)
+			s.Send(response)
+		}
+		// 需要密码情况 设备第一次上报，返回401和加密算法
+		if msg.Authorization == nil || msg.Authorization.GetUsername() == "" {
+			sendUnauthorized()
+			return
+		}
+		// 有些摄像头没有配置用户名的地方，用户名就是摄像头自己的国标id
+		username := config.Username
+		if msg.Authorization.GetUsername() == id {
+			username = id
+		}
+
+		if DeviceRegisterCount[id] >= MaxRegisterCount {
+			s.Send(msg.BuildResponse(403))
+			return
+		}
+
+		// 设备第二次上报，校验
+		if !msg.Authorization.Verify(username, config.Password, config.Realm, DeviceNonce[id]) {
+			sendUnauthorized()
+			DeviceRegisterCount[id] += 1
+			return
+		}
+		storeDevice()
+		delete(DeviceNonce, id)
+		delete(DeviceRegisterCount, id)
+	}
+	s.OnMessage = func(msg *sip.Message) bool {
+		if v, ok := Devices.Load(msg.From.Uri.UserInfo()); ok {
+			d := v.(*Device)
+			if d.Status == string(sip.REGISTER) {
+				d.Status = "ONLINE"
+				go d.Query()
+			}
+			d.UpdateTime = time.Now()
+			temp := &struct {
+				XMLName    xml.Name
+				CmdType    string
+				DeviceID   string
+				DeviceList []*Channel `xml:"DeviceList>Item"`
+				RecordList []*Record  `xml:"RecordList>Item"`
+			}{}
+			decoder := xml.NewDecoder(bytes.NewReader([]byte(msg.Body)))
+			decoder.CharsetReader = charset.NewReaderLabel
+			err := decoder.Decode(temp)
+			if err != nil {
+				err = utils.DecodeGbk(temp, []byte(msg.Body))
+				if err != nil {
+					log.Printf("decode catelog err: %s", err)
+				}
+			}
+			switch temp.XMLName.Local {
+			case "Notify":
+				switch temp.CmdType {
+				case "Keeyalive":
+					if d.subscriber.CallID != "" && time.Now().After(d.subscriber.Timeout) {
+						go d.Subscribe()
+					}
+					d.CheckSubStream()
+				case "Catalog":
+					d.UpdateChannels(temp.DeviceList)
+				}
+			case "Response":
+				switch temp.CmdType {
+				case "Catalog":
+					d.UpdateChannels(temp.DeviceList)
+				case "RecordInfo":
+					d.UpdateRecord(temp.DeviceID, temp.RecordList)
+				}
+			}
+			return true
+		}
+		return false
+	}
+	//OnStreamClosedHooks.AddHook(func(stream *Stream) {
+	//	Devices.Range(func(key, value interface{}) bool {
+	//		device:=value.(*Device)
+	//		for _,channel := range device.Channels {
+	//			if stream.StreamPath == channel.RecordSP {
+	//
+	//			}
+	//		}
+	//	})
+	//})
+	if useTCP {
+		listenMediaTCP()
+	} else {
+		go listenMediaUDP()
+	}
+	// go queryCatalog(config)
+	if config.Username != "" || config.Password != "" {
+		go removeBanDevice(config)
+	}
 	s.Start()
 }
-
-func onPublish(channel *transaction.Channel) (port int) {
-	rtpPublisher := new(rtp.RTP_PS)
-	if !rtpPublisher.Publish("gb28181/" + channel.DeviceID) {
-		return
-	}
-	rtpPublisher.Type = "GB28181"
-	addr, err := net.ResolveUDPAddr("udp", ":0")
-	if err != nil {
-		return
-	}
-	conn, err := net.ListenUDP("udp", addr)
-	if err != nil {
-		return
-	}
-	networkBuffer := 1048576
-	if err := conn.SetReadBuffer(networkBuffer); err != nil {
-		Printf("udp server video conn set read buffer error, %v", err)
-	}
-	if err := conn.SetWriteBuffer(networkBuffer); err != nil {
-		Printf("udp server video conn set write buffer error, %v", err)
-	}
-	la := conn.LocalAddr().String()
-	strPort := la[strings.LastIndex(la, ":")+1:]
-	if port, err = strconv.Atoi(strPort); err != nil {
-		return
-	}
-	go func() {
-		bufUDP := make([]byte, 1048576)
-		Printf("udp server start listen video port[%d]", port)
-		defer Printf("udp server stop listen video port[%d]", port)
-		for rtpPublisher.Err() == nil {
-			if err = conn.SetReadDeadline(time.Now().Add(time.Second*30));err!=nil{
-				return
+func listenMediaTCP() {
+	for i := uint16(0); i < config.TCPMediaPortNum; i++ {
+		addr := ":" + strconv.Itoa(int(config.MediaPort+i))
+		go ListenTCP(addr, func(conn net.Conn) {
+			var rtpPacket rtp.Packet
+			reader := bufio.NewReader(conn)
+			lenBuf := make([]byte, 2)
+			defer conn.Close()
+			var err error
+			for err == nil {
+				if _, err = io.ReadFull(reader, lenBuf); err != nil {
+					return
+				}
+				ps := make([]byte, BigEndian.Uint16(lenBuf))
+				if _, err = io.ReadFull(reader, ps); err != nil {
+					return
+				}
+				if err := rtpPacket.Unmarshal(ps); err != nil {
+					Println("gb28181 decode rtp error:", err)
+				} else if publisher := publishers.Get(rtpPacket.SSRC); publisher != nil && publisher.Err() == nil {
+					publisher.PushPS(&rtpPacket)
+				}
 			}
-			if n, _, err := conn.ReadFromUDP(bufUDP); err == nil {
-				rtpPublisher.PushPS(bufUDP[:n])
-			} else {
-				Println("udp server read video pack error", err)
-				rtpPublisher.Close()
+		})
+	}
+}
+func listenMediaUDP() {
+	var rtpPacket rtp.Packet
+	networkBuffer := 1048576
+	addr := ":" + strconv.Itoa(int(config.MediaPort))
+	conn, err := ListenUDP(addr, networkBuffer)
+	if err != nil {
+		Printf("listen udp %s err: %v", addr, err)
+		return
+	}
+	bufUDP := make([]byte, networkBuffer)
+	Printf("udp server start listen video port[%d]", config.MediaPort)
+	defer Printf("udp server stop listen video port[%d]", config.MediaPort)
+	for n, _, err := conn.ReadFromUDP(bufUDP); err == nil; n, _, err = conn.ReadFromUDP(bufUDP) {
+		ps := bufUDP[:n]
+		if err := rtpPacket.Unmarshal(ps); err != nil {
+			Println("gb28181 decode rtp error:", err)
+		}
+		if publisher := publishers.Get(rtpPacket.SSRC); publisher != nil && publisher.Err() == nil {
+			publisher.PushPS(&rtpPacket)
+		}
+	}
+}
+
+// func queryCatalog(config *transaction.Config) {
+// 	t := time.NewTicker(time.Duration(config.CatalogInterval) * time.Second)
+// 	for range t.C {
+// 		Devices.Range(func(key, value interface{}) bool {
+// 			device := value.(*Device)
+// 			if time.Since(device.UpdateTime) > time.Duration(config.RegisterValidity)*time.Second {
+// 				Devices.Delete(key)
+// 			} else if device.Channels != nil {
+// 				go device.Subscribe()
+// 			}
+// 			return true
+// 		})
+// 	}
+// }
+
+func removeBanDevice(config *transaction.Config) {
+	t := time.NewTicker(time.Duration(config.RemoveBanInterval) * time.Second)
+	for range t.C {
+		for id, cnt := range DeviceRegisterCount {
+			if cnt >= MaxRegisterCount {
+				delete(DeviceRegisterCount, id)
 			}
 		}
-	}()
-	return
+	}
 }

publisher.go

@@ -0,0 +1,103 @@
+package gb28181
+
+import (
+	"github.com/Monibuca/engine/v3"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
+	. "github.com/Monibuca/utils/v3"
+	"github.com/pion/rtp"
+)
+
+type Publisher struct {
+	*engine.Stream
+	parser    utils.DecPSPackage
+	pushVideo func(uint32, uint32, []byte)
+	pushAudio func(uint32, []byte)
+	lastSeq   uint16
+	udpCache  *utils.PriorityQueueRtp
+}
+
+func (p *Publisher) PushVideo(ts uint32, cts uint32, payload []byte) {
+	p.pushVideo(ts, cts, payload)
+}
+func (p *Publisher) PushAudio(ts uint32, payload []byte) {
+	p.pushAudio(ts, payload)
+}
+func (p *Publisher) Publish() (result bool) {
+	if result = p.Stream.Publish(); result {
+		p.pushVideo = func(ts uint32, cts uint32, payload []byte) {
+			var vt *engine.VideoTrack
+			switch p.parser.VideoStreamType {
+			case utils.StreamTypeH264:
+				vt = p.Stream.NewVideoTrack(7)
+			case utils.StreamTypeH265:
+				vt = p.Stream.NewVideoTrack(12)
+			default:
+				return
+			}
+			vt.PushAnnexB(ts, cts, payload)
+			p.pushVideo = vt.PushAnnexB
+		}
+		p.pushAudio = func(ts uint32, payload []byte) {
+			switch p.parser.AudioStreamType {
+			case utils.G711A:
+				at := p.Stream.NewAudioTrack(7)
+				at.SoundRate = 8000
+				at.SoundSize = 16
+				at.Channels = 1
+				at.ExtraData = []byte{(at.CodecID << 4) | (1 << 1)}
+				at.PushRaw(ts, payload)
+				p.pushAudio = at.PushRaw
+				// case utils.G711U:
+				// 	at := p.Stream.NewAudioTrack(8)
+				// 	at.SoundRate = 8000
+				// 	at.SoundSize = 16
+				// 	asc := at.CodecID << 4
+				// 	asc = asc + 1<<1
+				// 	at.ExtraData = []byte{asc}
+				// 	at.PushRaw(pack)
+				// 	p.pushAudio = at.PushRaw
+			}
+		}
+	}
+	return
+}
+func (p *Publisher) PushPS(rtp *rtp.Packet) {
+	originRtp := *rtp
+	if config.UdpCacheSize > 0 && config.TCP == false {
+		//序号小于第一个包的丢弃,rtp包序号达到65535后会从0开始，所以这里需要判断一下
+		if rtp.SequenceNumber < p.lastSeq && p.lastSeq-rtp.SequenceNumber < utils.MaxRtpDiff {
+			return
+		}
+		p.udpCache.Push(*rtp)
+		rtpTmp, _ := p.udpCache.Pop()
+		rtp = &rtpTmp
+	}
+	ps := rtp.Payload
+	if p.lastSeq != 0 {
+		// rtp序号不连续，丢弃PS
+		if p.lastSeq+1 != rtp.SequenceNumber {
+			if config.UdpCacheSize > 0 && config.TCP == false {
+				if p.udpCache.Len() < config.UdpCacheSize {
+					p.udpCache.Push(*rtp)
+					return
+				} else {
+					p.udpCache.Empty()
+					rtp = &originRtp // 还原rtp包，而不是使用缓存中，避免rtp序号断裂
+				}
+			}
+			p.parser.Reset()
+		}
+	}
+	p.lastSeq = rtp.SequenceNumber
+	p.Update()
+	if len(ps) >= 4 && BigEndian.Uint32(ps) == utils.StartCodePS {
+		if p.parser.Len() > 0 {
+			p.parser.Uint32()
+			p.parser.Read(rtp.Timestamp, p)
+			p.parser.Reset()
+		}
+		p.parser.Write(ps)
+	} else if p.parser.Len() > 0 {
+		p.parser.Write(ps)
+	}
+}

rtpsort_test.go

@@ -0,0 +1,114 @@
+package gb28181
+
+import (
+	"fmt"
+	"github.com/Monibuca/engine/v3"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
+	"github.com/agiledragon/gomonkey/v2"
+	"github.com/pion/rtp"
+	"reflect"
+	"testing"
+)
+
+// 测试rtp序号数据
+var items = []uint16{
+	65526, 65530, 65524, 65525, 65527, 65528, 65529,
+	0, 65533, 65531, 65532, 65534, 65535, 1,
+	3, 6, 5, 4, 2, 8, 7,
+}
+
+var items2 = []uint16{
+	11672, 11673, 11674, 11675, 11676, 11677, 11678,
+	11679, 11680, 11681, 11682, 11683, 11684, 11685,
+	11686, 11687, 11688, 11689, 11690, 11691, 11692,
+	11693, 11694, 11695, 11696, 11697, 11698, 11699,
+	11700, 11701, 11702, 11703, 11704, 11705, 11706,
+	11707, 11708, 11709, 11710, 11711, 11712,
+}
+
+func _pushPsWithCache(p *Publisher, rtp *rtp.Packet) {
+	originRtp := *rtp
+	if config.UdpCacheSize > 0 && !config.TCP {
+		//序号小于第一个包的丢弃,rtp包序号达到65535后会从0开始，所以这里需要判断一下
+		if rtp.SequenceNumber < p.lastSeq && p.lastSeq-rtp.SequenceNumber < utils.MaxRtpDiff {
+			return
+		}
+		p.udpCache.Push(*rtp)
+		rtpTmp, _ := p.udpCache.Pop()
+		rtp = &rtpTmp
+	}
+
+	if p.lastSeq != 0 {
+		// rtp序号不连续，丢弃PS
+		if p.lastSeq+1 != rtp.SequenceNumber {
+			if config.UdpCacheSize > 0 && !config.TCP {
+				if p.udpCache.Len() < config.UdpCacheSize {
+					p.udpCache.Push(*rtp)
+					return
+				} else {
+					p.udpCache.Empty()
+					rtp = &originRtp
+				}
+			}
+			p.parser.Reset()
+		}
+	}
+
+	p.lastSeq = rtp.SequenceNumber
+	fmt.Println("rtp.SequenceNumber:", rtp.SequenceNumber)
+
+}
+
+// 如果运行失败可以关闭gc,go test -gcflags=all=-l -v
+func TestRtpSort(t *testing.T) {
+	publisher := Publisher{
+		Stream: &engine.Stream{
+			StreamPath: "live/test",
+		},
+		udpCache: utils.NewPqRtp(),
+	}
+	config.UdpCacheSize = 7
+
+	patches := gomonkey.ApplyMethod(reflect.TypeOf(&publisher), "PushPS", _pushPsWithCache)
+	defer patches.Reset()
+
+	for i := 0; i < len(items); i++ {
+		rtpPacket := &rtp.Packet{Header: rtp.Header{SequenceNumber: items[i]}}
+		publisher.PushPS(rtpPacket)
+	}
+
+}
+
+// 如果运行失败可以关闭gc,go test -gcflags=all=-l -v
+// 测试有empty的情况
+func TestRtpSortWithEmpty(t *testing.T) {
+	publisher := Publisher{
+		Stream: &engine.Stream{
+			StreamPath: "live/test",
+		},
+		udpCache: utils.NewPqRtp(),
+	}
+	config.UdpCacheSize = 7
+	publisher.udpCache.Push(rtp.Packet{Header: rtp.Header{SequenceNumber: 11665}})
+	patches := gomonkey.ApplyMethod(reflect.TypeOf(&publisher), "PushPS", _pushPsWithCache)
+	defer patches.Reset()
+
+	for i := 0; i < len(items2); i++ {
+		rtpPacket := &rtp.Packet{Header: rtp.Header{SequenceNumber: items2[i]}}
+		publisher.PushPS(rtpPacket)
+	}
+
+}
+
+func TestPqSort(t *testing.T) {
+	pq := utils.NewPqRtp()
+	for i := 0; i < len(items); i++ {
+		rtpPacket := rtp.Packet{Header: rtp.Header{SequenceNumber: items[i]}}
+		pq.Push(rtpPacket)
+	}
+
+	for pq.Len() > 0 {
+		rtpPacket, _ := pq.Pop()
+		fmt.Println("packet seq:", rtpPacket.SequenceNumber)
+	}
+}

sip/head.go

@@ -1,6 +1,7 @@
 package sip
 
 import (
+	"crypto/md5"
 	"errors"
 	"fmt"
 	"strconv"
@@ -12,10 +13,10 @@ import (
 //windows    :     \n
 //Mac OS     :     \r
 const (
-	VERSION = "SIP/2.0" // sip version
-	CRLF     = "\r\n"     // 0x0D0A
-	CRLFCRLF = "\r\n\r\n" // 0x0D0A0D0A
-
+	VERSION         = "SIP/2.0"  // sip version
+	CRLF            = "\r\n"     // 0x0D0A
+	CRLFCRLF        = "\r\n\r\n" // 0x0D0A0D0A
+	DIGEST_ALGO_MD5 = "MD5"
 	//CRLF     = "\n"   // 0x0D
 	//CRLFCRLF = "\n\n" // 0x0D0D
 )
@@ -377,6 +378,9 @@ func (c *CSeq) Parse(str string) error {
 		return err
 	}
 	c.ID = uint32(n)
+	if len(arr1) < 2 {
+		return errors.New("no method: " + str)
+	}
 	c.Method = Method(arr1[1])
 	return nil
 }
@@ -440,28 +444,29 @@ type URI struct {
 	params  map[string]string // include branch/maddr/received/ttl/rport
 	headers map[string]string // include branch/maddr/received/ttl/rport
 }
+
 func (u *URI) Host() string {
 	return u.host
 }
 func (u *URI) UserInfo() string {
-	return strings.Split(u.host,"@")[0]
+	return strings.Split(u.host, "@")[0]
 }
 func (u *URI) Domain() string {
-	return strings.Split(u.host,"@")[1]
+	return strings.Split(u.host, "@")[1]
 }
 func (u *URI) IP() string {
-	t:=strings.Split(u.host,"@")
+	t := strings.Split(u.host, "@")
 	if len(t) == 1 {
-		return strings.Split(t[0],":")[0]
+		return strings.Split(t[0], ":")[0]
 	}
-	return strings.Split(t[1],":")[0]
+	return strings.Split(t[1], ":")[0]
 }
 func (u *URI) Port() string {
-	t:=strings.Split(u.host,"@")
+	t := strings.Split(u.host, "@")
 	if len(t) == 1 {
-		return strings.Split(t[0],":")[1]
+		return strings.Split(t[0], ":")[1]
 	}
-	return strings.Split(t[1],":")[1]
+	return strings.Split(t[1], ":")[1]
 }
 func (u *URI) String() string {
 	if u.scheme == "" {
@@ -546,8 +551,12 @@ func parseURI(str string) (ret URI, err error) {
 		arr1 := strings.Split(paramStr, ";")
 		for _, one := range arr1 {
 			tmp := strings.Split(one, "=")
-			k, v := tmp[0], tmp[1]
-			ret.params[k] = v
+			if len(tmp) == 2 {
+				k, v := tmp[0], tmp[1]
+				ret.params[k] = v
+			} else {
+				ret.params[tmp[0]] = ""
+			}
 		}
 	}
 
@@ -557,10 +566,139 @@ func parseURI(str string) (ret URI, err error) {
 		arr2 := strings.Split(paramStr, "&")
 		for _, one := range arr2 {
 			tmp := strings.Split(one, "=")
-			k, v := tmp[0], tmp[1]
+			var k, v string
+			if len(tmp) == 2 {
+				k, v = tmp[0], tmp[1]
+			} else {
+				k = tmp[0]
+			}
 			ret.headers[k] = v
 		}
 	}
 
 	return
 }
+
+type WwwAuthenticate struct {
+	realm     string
+	nonce     string
+	algorithm string
+	//opaque string // gb28181不需要这字段，海康有
+}
+
+func NewWwwAuthenticate(realm, nonce, algorithm string) *WwwAuthenticate {
+	return &WwwAuthenticate{
+		realm:     realm,
+		nonce:     nonce,
+		algorithm: algorithm,
+	}
+}
+
+// WWW-Authenticate: Digest realm="hik", nonce="a8afe6fcbee6331d89d3eb0d3d19ce39", opaque="a853e4f25298413f9bf3a9aa6767857d", algorithm=MD5
+func (w *WwwAuthenticate) String() string {
+	return fmt.Sprintf(`Digest realm="%s", nonce="%s", algorithm=%s`, w.realm, w.nonce, w.algorithm)
+}
+
+func (w *WwwAuthenticate) Parse(str string) error {
+	arr := strings.Split(str, ",")
+	for _, s := range arr {
+		tmp := strings.Split(s, "=")
+		if len(tmp) != 2 {
+			continue
+		}
+		v := strings.ReplaceAll(tmp[1], "\"", "")
+		if strings.Contains(tmp[0], "realm") {
+			w.realm = v
+		}
+		if strings.Contains(tmp[0], "nonce") {
+			w.nonce = v
+		}
+		if strings.Contains(tmp[0], "algorithm") {
+			w.algorithm = v
+		}
+	}
+	return nil
+}
+
+type Authorization struct {
+	username  string
+	realm     string
+	nonce     string
+	uri       string
+	response  string
+	algorithm string
+	//opaque string // gb28181不需要这字段，海康有
+}
+
+// Authorization: Digest username="admin", realm="hik", nonce="a8afe6fcbee6331d89d3eb0d3d19ce39", uri="sip:130909115229300920@10.64.49.44:7100", response="907ddb1bcc25174d7de4a96c947fb066", algorithm=MD5, opaque="a853e4f25298413f"
+func (a *Authorization) String() string {
+	return fmt.Sprintf(`Digest username="%s", realm="%s", nonce="%s", uri="%s", response="%s", algorithm=%s`,
+		a.username, a.realm, a.nonce, a.uri, a.response, a.algorithm)
+}
+
+func (a *Authorization) GetUsername() string {
+	return a.username
+}
+
+func (a *Authorization) Parse(str string) error {
+	arr := strings.Split(str, ",")
+	for _, s := range arr {
+		tmp := strings.Split(s, "=")
+		if len(tmp) != 2 {
+			continue
+		}
+		v := strings.ReplaceAll(tmp[1], "\"", "")
+		if strings.Contains(tmp[0], "username") {
+			a.username = v
+		}
+		if strings.Contains(tmp[0], "realm") {
+			a.realm = v
+		}
+		if strings.Contains(tmp[0], "nonce") {
+			a.nonce = v
+		}
+		if strings.Contains(tmp[0], "uri") {
+			a.uri = v
+		}
+		if strings.Contains(tmp[0], "response") {
+			a.response = v
+		}
+		if strings.Contains(tmp[0], "algorithm") {
+			a.algorithm = strings.Trim(v,"H:")
+		}
+	}
+	return nil
+}
+
+func (a *Authorization) Verify(username, passwd, realm, nonce string) bool {
+
+	//1、将 username,realm,password 依次组合获取 1 个字符串，并用算法加密的到密文 r1
+	s1 := fmt.Sprintf("%s:%s:%s", username, realm, passwd)
+	r1 := a.getDigest(s1)
+	//2、将 method，即REGISTER ,uri 依次组合获取 1 个字符串，并对这个字符串使用算法 加密得到密文 r2
+	s2 := fmt.Sprintf("REGISTER:%s", a.uri)
+	r2 := a.getDigest(s2)
+
+	if r1 == "" || r2 == "" {
+		fmt.Println("Authorization algorithm wrong")
+		return false
+	}
+	//3、将密文 1，nonce 和密文 2 依次组合获取 1 个字符串，并对这个字符串使用算法加密，获得密文 r3，即Response
+	s3 := fmt.Sprintf("%s:%s:%s", r1, nonce, r2)
+	r3 := a.getDigest(s3)
+
+	//4、计算服务端和客户端上报的是否相等
+	if r3 == a.response {
+		return true
+	}
+	return false
+}
+
+func (a *Authorization) getDigest(raw string) string {
+	switch a.algorithm {
+	case DIGEST_ALGO_MD5:
+		return fmt.Sprintf("%x", md5.Sum([]byte(raw)))
+	default: //如果没有算法，默认使用MD5
+		return fmt.Sprintf("%x", md5.Sum([]byte(raw)))
+	}
+}

sip/head_test.go

@@ -6,7 +6,7 @@ import (
 )
 
 func TestContact(t *testing.T) {
-	str1 := "\"Mr.Watson\" <sip:watson@worcester.bell-telephone.com>;q=0.7; expires=3600,\"Mr.Watson\" <mailto:watson@bell-telephone.com>";
+	str1 := "\"Mr.Watson\" <sip:watson@worcester.bell-telephone.com>;q=0.7; expires=3600,\"Mr.Watson\" <mailto:watson@bell-telephone.com>"
 	//str1 := `"Mr.Watson" <sip:watson@worcester.bell-telephone.com>;q=0.7;`
 	c := &Contact{}
 	err := c.Parse(str1)
@@ -112,3 +112,60 @@ y=0009093131`
 	fmt.Println("output:")
 	fmt.Println(string(out))
 }
+
+func TestAuthorization_Verify(t *testing.T) {
+	type fields struct {
+		username  string
+		realm     string
+		nonce     string
+		uri       string
+		response  string
+		algorithm string
+	}
+	type args struct {
+		username string
+		passwd   string
+		realm    string
+		nonce    string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   bool
+	}{
+		{
+			name:   "test1",
+			fields: fields{
+				username:  "34020000001320000001",
+				realm:     "3402000000",
+				nonce:     "1628819207",
+				uri:       "sip:34020000002000000001@172.165.0.10:15060",
+				response:  "fa2b30e05ea42dd0ab69ef05d3a06096",
+				algorithm: "MD5",
+			},
+			args:   args{
+				username: "34020000001320000001",
+				passwd:   "12345678",
+				realm:    "3402000000",
+				nonce:    "1628819207",
+			},
+			want:   true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			a := &Authorization{
+				username:  tt.fields.username,
+				realm:     tt.fields.realm,
+				nonce:     tt.fields.nonce,
+				uri:       tt.fields.uri,
+				response:  tt.fields.response,
+				algorithm: tt.fields.algorithm,
+			}
+			if got := a.Verify(tt.args.username, tt.args.passwd, tt.args.realm, tt.args.nonce); got != tt.want {
+				t.Errorf("Verify() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

sip/message.go

@@ -5,8 +5,9 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"time"
 
-	"github.com/Monibuca/plugin-gb28181/utils"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
 )
 
 //Content-Type: Application/MANSCDP+xml
@@ -20,26 +21,35 @@ import (
 type Message struct {
 	Mode Mode //0:REQUEST, 1:RESPONSE
 
-	StartLine     *StartLine
-	Via           *Via     //Via
-	From          *Contact //From
-	To            *Contact //To
-	CallID        string   //Call-ID
-	CSeq          *CSeq    //CSeq
-	Contact       *Contact //Contact
-	Authorization string   //Authorization
-	MaxForwards   int      //Max-Forwards
-	UserAgent     string   //User-Agent
-	Subject       string   //Subject
-	ContentType   string   //Content-Type
-	Expires       int      //Expires
-	ContentLength int      //Content-Length
-	Route         *Contact
-	Body          string
-	Addr          string
+	StartLine       *StartLine
+	Via             *Via           //Via
+	From            *Contact       //From
+	To              *Contact       //To
+	CallID          string         //Call-ID
+	CSeq            *CSeq          //CSeq
+	Contact         *Contact       //Contact
+	Authorization   *Authorization //Authorization
+	MaxForwards     int            //Max-Forwards
+	UserAgent       string         //User-Agent
+	Subject         string         //Subject
+	ContentType     string         //Content-Type
+	Expires         int            //Expires
+	ContentLength   int            //Content-Length
+	Route           *Contact
+	Body            string
+	Addr            string
+	Event           string
+	Date						time.Time
+	WwwAuthenticate *WwwAuthenticate //gb28181 密码验证 上级发给下级是WwwAuthenticate；下级发给上级是Authorization
 }
 
 func (m *Message) BuildResponse(code int) *Message {
+	return m.BuildResponseWithPhrase(code, "")
+}
+func (m *Message) BuildOK() *Message {
+	return m.BuildResponseWithPhrase(200, "OK")
+}
+func (m *Message) BuildResponseWithPhrase(code int, phrase string) *Message {
 	response := Message{
 		Mode:        SIP_MESSAGE_RESPONSE,
 		From:        m.From,
@@ -48,9 +58,12 @@ func (m *Message) BuildResponse(code int) *Message {
 		CSeq:        m.CSeq,
 		Via:         m.Via,
 		MaxForwards: m.MaxForwards,
+		UserAgent: "Monibuca",
 		StartLine: &StartLine{
-			Code: code,
+			Code:   code,
+			phrase: phrase,
 		},
+		Date: time.Now(),
 	}
 	return &response
 }
@@ -156,7 +169,7 @@ func (m *Message) GetBranch() string {
 
 	b, ok := m.Via.Params["branch"]
 	if !ok {
-		panic("invalid via paramas branch")
+		return ""
 	}
 
 	return b
@@ -219,8 +232,10 @@ func Decode(data []byte) (msg *Message, err error) {
 	}
 
 	headStr := strings.TrimSpace(msgArr[0])
-	if len(msgArr) > 1 {
-		msg.Body = strings.TrimSpace(msgArr[1])
+	if msgArrLen := len(msgArr); msgArrLen > 1 {
+		for i := 1; i < msgArrLen; i++ {
+			msg.Body += strings.TrimSpace(msgArr[i])
+		}
 	}
 
 	headStr = strings.Trim(headStr, CRLF)
@@ -354,13 +369,19 @@ func Decode(data []byte) (msg *Message, err error) {
 			msg.ContentLength = int(n)
 
 		case "authorization":
-			msg.Authorization = v
+			msg.Authorization = &Authorization{}
+			msg.Authorization.Parse(v)
 
 		case "content-type":
 			msg.ContentType = v
 		case "route":
 			//msg.Route = new(Contact)
 			//msg.Route.Parse(v)
+		case "www-authenticate":
+			msg.WwwAuthenticate = &WwwAuthenticate{}
+			msg.WwwAuthenticate.Parse(v)
+		case "event":
+			msg.Event = v
 		default:
 			fmt.Printf("invalid sip head: %s,%s\n", k, v)
 		}
@@ -426,6 +447,27 @@ func Encode(msg *Message) ([]byte, error) {
 		sb.WriteString(CRLF)
 	}
 
+	if msg.Subject != "" {
+		sb.WriteString("Subject: ")
+		sb.WriteString(msg.Subject)
+		sb.WriteString(CRLF)
+	}
+
+	if msg.WwwAuthenticate != nil {
+		sb.WriteString("WWW-Authenticate: ")
+		sb.WriteString(msg.WwwAuthenticate.String())
+		sb.WriteString(CRLF)
+	}
+	if !msg.Date.IsZero() {
+		sb.WriteString("Date: ")
+		sb.WriteString(msg.Date.Format("2006-01-02T15:04:05.999"))
+		sb.WriteString(CRLF)
+	}	
+	if msg.Event != "" {
+		sb.WriteString("Event: ")
+		sb.WriteString(msg.Event)
+		sb.WriteString(CRLF)
+	}
 	if msg.IsRequest() {
 		//request only
 
@@ -433,9 +475,9 @@ func Encode(msg *Message) ([]byte, error) {
 		sb.WriteString(strconv.Itoa(msg.MaxForwards))
 		sb.WriteString(CRLF)
 
-		if msg.Authorization != "" {
+		if msg.Authorization != nil {
 			sb.WriteString("Authorization: ")
-			sb.WriteString(msg.Authorization)
+			sb.WriteString(msg.Authorization.String())
 			sb.WriteString(CRLF)
 		}
 	} else {

sip/status.go

@@ -88,9 +88,8 @@ var errorMap = map[int]string{
 }
 
 func DumpError(code int) string {
-	if code == 0{
+	if code == 0 {
 		return "invalid status reason for request"
 	}
 	return fmt.Sprintf("%d %s", code, errorMap[code])
 }
-

transaction/config.go

@@ -42,6 +42,8 @@ type Config struct {
 	SipPort    uint16 //sip 服务器端口，默认 5060
 	Serial     string //sip 服务器 id, 默认 34020000002000000001
 	Realm      string //sip 服务器域，默认 3402000000
+	Username   string //sip 服务器账号
+	Password   string //sip 服务器密码
 
 	AckTimeout        uint16 //sip 服务应答超时，单位秒
 	RegisterValidity  int    //注册有效期，单位秒，默认 3600
@@ -50,11 +52,13 @@ type Config struct {
 	HeartbeatRetry    int    //心跳超时次数，默认 3
 
 	//媒体服务器配置
-	MediaIP          string //媒体服务器地址
-	MediaPort        uint16 //媒体服务器端口
-	MediaPortMin     uint16
-	MediaPortMax     uint16
-	MediaIdleTimeout uint16 //推流超时时间，超过则断开链接，让设备重连
-	AudioEnable      bool   //是否开启音频
-	WaitKeyFrame     bool   //是否等待关键帧，如果等待，则在收到第一个关键帧之前，忽略所有媒体流
+	MediaIP           string //媒体服务器地址
+	MediaPort         uint16 //媒体服务器端口
+	MediaPortMin      uint16
+	MediaPortMax      uint16
+	MediaIdleTimeout  uint16 //推流超时时间，超过则断开链接，让设备重连
+	AudioEnable       bool   //是否开启音频
+	WaitKeyFrame      bool   //是否等待关键帧，如果等待，则在收到第一个关键帧之前，忽略所有媒体流
+	RemoveBanInterval int    //移除禁止设备间隔
+	UdpCacheSize      int    //udp缓存大小
 }

transaction/core.go

@@ -1,20 +1,14 @@
 package transaction
 
 import (
-	"bytes"
 	"context"
-	"encoding/xml"
 	"fmt"
-	"io"
 	"net"
-	"os"
 	"sync"
 	"time"
 
-	"github.com/Monibuca/plugin-gb28181/sip"
-	"github.com/Monibuca/plugin-gb28181/transport"
-	"github.com/Monibuca/plugin-gb28181/utils"
-	"golang.org/x/net/html/charset"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
+	"github.com/Monibuca/plugin-gb28181/v3/transport"
 )
 
 //Core: transactions manager
@@ -23,12 +17,11 @@ type Core struct {
 	ctx          context.Context             //上下文
 	handlers     map[State]map[Event]Handler //每个状态都可以处理有限个事件。不必加锁。
 	transactions map[string]*Transaction     //管理所有 transactions,key:tid,value:transaction
-	mutex        sync.Mutex                  //transactions的锁
-	removeTa     chan string                 //要删除transaction的时候，通过chan传递tid
+	mutex        sync.RWMutex                //transactions的锁
 	tp           transport.ITransport        //transport
-	config       *Config                     //sip server配置信息
-	Devices      sync.Map
-	OnInvite     func(*Channel) int
+	*Config                                  //sip server配置信息
+	OnRegister   func(*sip.Message)
+	OnMessage    func(*sip.Message) bool
 }
 
 //初始化一个 Core，需要能响应请求，也要能发起请求
@@ -41,8 +34,7 @@ func NewCore(config *Config) *Core {
 	core := &Core{
 		handlers:     make(map[State]map[Event]Handler),
 		transactions: make(map[string]*Transaction),
-		removeTa:     make(chan string, 10),
-		config:       config,
+		Config:       config,
 		ctx:          context.Background(),
 	}
 	if config.SipNetwork == "TCP" {
@@ -63,7 +55,6 @@ func (c *Core) AddTransaction(ta *Transaction) {
 	c.mutex.Lock()
 	c.transactions[ta.id] = ta
 	c.mutex.Unlock()
-	go ta.Run()
 }
 
 //delete transaction
@@ -73,44 +64,22 @@ func (c *Core) DelTransaction(tid string) {
 	c.mutex.Unlock()
 }
 
-//创建事件:根据接收到的消息创建消息事件
-func (c *Core) NewInComingMessageEvent(m *sip.Message) *EventObj {
-	return &EventObj{
-		evt: getInComingMessageEvent(m),
-		tid: getMessageTransactionID(m),
-		msg: m,
-	}
-}
-
-//创建事件:根据发出的消息创建消息事件
-func (c *Core) NewOutGoingMessageEvent(m *sip.Message) *EventObj {
-	return &EventObj{
-		evt: getOutGoingMessageEvent(m),
-		tid: getMessageTransactionID(m),
-		msg: m,
-	}
-}
-
 //创建事物
 //填充此事物的参数：via、from、to、callID、cseq
-func (c *Core) initTransaction(ctx context.Context, obj *EventObj) *Transaction {
-	m := obj.msg
-
+func (c *Core) initTransaction(ctx context.Context, tid string, m *sip.Message) *Transaction {
 	//ack要么属于一个invite事物，要么由TU层直接管理，不通过事物管理。
 	if m.GetMethod() == sip.ACK {
 		fmt.Println("ack nerver create transaction")
 		return nil
 	}
 	ta := &Transaction{
-		id:       obj.tid,
+		id:       tid,
 		core:     c,
-		ctx:      ctx,
-		done:     make(chan struct{}),
-		event:    make(chan *EventObj, 10), //带缓冲的event channel
 		response: make(chan *Response),
 		startAt:  time.Now(),
 		endAt:    time.Now().Add(1000000 * time.Hour),
 	}
+	ta.Context, ta.cancel = context.WithTimeout(ctx, time.Second*5)
 	//填充其他transaction的信息
 	ta.via = m.Via
 	ta.from = m.From
@@ -214,27 +183,14 @@ func (c *Core) Start() {
 }
 
 func (c *Core) Handler() {
-	defer func() {
-		if err := recover(); err != nil {
-			fmt.Println("packet handler panic: ", err)
-			utils.PrintStack()
-			os.Exit(1)
-		}
-	}()
-
-	ch := c.tp.ReadPacketChan()
 	//阻塞读取消息
-	for {
-		//fmt.Println("PacketHandler ========== SIP Client")
-		select {
-		case tid := <-c.removeTa:
-			c.DelTransaction(tid)
-		case p := <-ch:
-			err := c.HandleReceiveMessage(p)
-			if err != nil {
-				fmt.Println("handler sip response message failed:", err.Error())
-				continue
-			}
+	for p := range c.tp.ReadPacketChan() {
+		if len(p.Data) < 5 {
+			continue
+		}
+		if err := c.HandleReceiveMessage(p); err != nil {
+			fmt.Println("handler sip response message failed:", err.Error())
+			continue
 		}
 	}
 }
@@ -248,21 +204,23 @@ func (c *Core) Handler() {
 //发送之后，就开启timer，超时重传，还要记录和修改每次超时时间。不超时的话，记得删掉timer
 //发送 register 消息
 func (c *Core) SendMessage(msg *sip.Message) *Response {
-	methond := msg.GetMethod()
-	fmt.Println("send message:", methond)
-
-	e := c.NewOutGoingMessageEvent(msg)
-
+	method := msg.GetMethod()
+	// data, _ := sip.Encode(msg)
+	// fmt.Println("send message:", method)
+	evt := getOutGoingMessageEvent(msg)
+	tid := getMessageTransactionID(msg)
 	//匹配事物
-	ta, ok := c.transactions[e.tid]
+	c.mutex.RLock()
+	ta, ok := c.transactions[tid]
+	c.mutex.RUnlock()
 	if !ok {
 		//新的请求
-		ta = c.initTransaction(c.ctx, e)
+		ta = c.initTransaction(c.ctx, tid, msg)
 
 		//如果是sip 消息事件，则将消息缓存，填充typo和state
 		if msg.IsRequest() {
 			//as uac
-			if msg.GetMethod() == sip.INVITE || msg.GetMethod() == sip.ACK {
+			if method == sip.INVITE || method == sip.ACK {
 				ta.typo = FSM_ICT
 				ta.state = ICT_PRE_CALLING
 			} else {
@@ -278,10 +236,19 @@ func (c *Core) SendMessage(msg *sip.Message) *Response {
 	}
 
 	//把event推到transaction
-	ta.event <- e
-
-	//等待事件结束，并返回
-	return <-ta.response
+	ta.Run(evt, msg)
+	<-ta.Done()
+	if ta.lastResponse != nil {
+		return &Response{
+			Code:    ta.lastResponse.GetStatusCode(),
+			Data:    ta.lastResponse,
+			Message: ta.lastResponse.GetReason(),
+		}
+	} else {
+		return &Response{
+			Code: 504,
+		}
+	}
 }
 
 //接收到的消息处理
@@ -290,14 +257,14 @@ func (c *Core) SendMessage(msg *sip.Message) *Response {
 //响应消息则需要匹配到请求，让请求的transaction来处理。
 //TODO：参考srs和osip的流程，以及文档，做最终处理。需要将逻辑分成两层：TU 层和 transaction 层
 func (c *Core) HandleReceiveMessage(p *transport.Packet) (err error) {
-	//fmt.Println("packet content:", string(p.Data))
+	// fmt.Println("packet content:", string(p.Data))
 	var msg *sip.Message
 	msg, err = sip.Decode(p.Data)
 	if err != nil {
 		fmt.Println("parse sip message failed:", err.Error())
 		return ErrorParse
 	}
-	if msg.Via == nil {
+	if msg.Via == nil || msg.From == nil {
 		return ErrorParse
 	}
 	//这里不处理超过MTU的包，不处理半包
@@ -307,9 +274,8 @@ func (c *Core) HandleReceiveMessage(p *transport.Packet) (err error) {
 	}
 
 	//fmt.Println("receive message:", msg.GetMethod())
-
-	e := c.NewInComingMessageEvent(msg)
-
+	evt := getInComingMessageEvent(msg)
+	tid := getMessageTransactionID(msg)
 	//一般应该是uas对于接收到的request做预处理
 	if msg.IsRequest() {
 		fixReceiveMessageViaParams(msg, p.Addr)
@@ -318,8 +284,9 @@ func (c *Core) HandleReceiveMessage(p *transport.Packet) (err error) {
 	}
 	//TODO：CANCEL、BYE 和 ACK 需要特殊处理，使用事物或者直接由TU层处理
 	//查找transaction
-	ta, ok := c.transactions[e.tid]
-
+	c.mutex.RLock()
+	ta, ok := c.transactions[tid]
+	c.mutex.RUnlock()
 	method := msg.GetMethod()
 	if msg.IsRequest() {
 		switch method {
@@ -327,50 +294,28 @@ func (c *Core) HandleReceiveMessage(p *transport.Packet) (err error) {
 			//TODO:this should be a ACK for 2xx (but could be a late ACK!)
 			return
 		case sip.BYE:
-			c.Send(msg.BuildResponse(200))
+			c.Send(msg.BuildOK())
 			return
 		case sip.MESSAGE:
-			if v, ok := c.Devices.Load(msg.From.Uri.UserInfo()); ok {
-				d := v.(*Device)
-				if d.Status == string(sip.REGISTER) {
-					d.Status = "ONLINE"
-				}
-				d.UpdateTime = time.Now()
-				temp := &struct {
-					XMLName    xml.Name
-					CmdType    string
-					DeviceList []Channel `xml:"DeviceList>Item"`
-				}{}
-				decoder := xml.NewDecoder(bytes.NewReader([]byte(msg.Body)))
-				decoder.CharsetReader = func(c string, i io.Reader) (io.Reader, error) {
-					return charset.NewReaderLabel(c, i)
-				}
-				decoder.Decode(temp)
-				switch temp.XMLName.Local {
-				case "Notify":
-					go d.Query()
-				case "Response":
-					switch temp.CmdType {
-					case "Catalog":
-						d.UpdateChannels(temp.DeviceList)
-					}
-				}
-				if ta == nil {
-					c.Send(msg.BuildResponse(200))
-				}
+			if c.OnMessage(msg) && ta == nil {
+				c.Send(msg.BuildOK())
 			}
 			if ta != nil {
-				ta.event <- c.NewOutGoingMessageEvent(msg.BuildResponse(200))
+				m := msg.BuildOK()
+				ta.Run(getOutGoingMessageEvent(m), m)
 			}
 		case sip.REGISTER:
 			if !ok {
-				ta = c.initTransaction(c.ctx, e)
+				ta = c.initTransaction(c.ctx, tid, msg)
 				ta.typo = FSM_NIST
 				ta.state = NIST_PROCEEDING
 				c.AddTransaction(ta)
 			}
-			c.AddDevice(msg)
-			ta.event <- c.NewOutGoingMessageEvent(msg.BuildResponse(200))
+			c.OnRegister(msg)
+			m := msg.BuildOK()
+			m.Contact = msg.Contact
+			m.Expires = msg.Expires
+			ta.Run(getOutGoingMessageEvent(m), m)
 		//case sip.INVITE:
 		//	ta.typo = FSM_IST
 		//	ta.state = IST_PRE_PROCEEDING
@@ -382,14 +327,7 @@ func (c *Core) HandleReceiveMessage(p *transport.Packet) (err error) {
 			return
 		}
 	} else if ok {
-		ta.event <- e
-		if msg.GetStatusCode() >= 200 {
-			ta.response <- &Response{
-				Code:    msg.GetStatusCode(),
-				Data:    msg,
-				Message: msg.GetReason(),
-			}
-		}
+		ta.Run(evt, msg)
 	}
 	//TODO：TU层处理：根据需要，创建，或者匹配 Dialog
 	//通过tag匹配到call和dialog
@@ -421,7 +359,7 @@ func (c *Core) Send(msg *sip.Message) error {
 		addr = fmt.Sprintf("%s:%s", host, port)
 	}
 
-	fmt.Println("dest addr:", addr)
+	// fmt.Println("dest addr:", addr)
 	var err1, err2 error
 	pkt := &transport.Packet{}
 	pkt.Data, err1 = sip.Encode(msg)
@@ -442,18 +380,3 @@ func (c *Core) Send(msg *sip.Message) error {
 	c.tp.WritePacket(pkt)
 	return nil
 }
-func (c *Core) AddDevice(msg *sip.Message) *Device {
-	v := &Device{
-		ID:           msg.From.Uri.UserInfo(),
-		RegisterTime: time.Now(),
-		UpdateTime:   time.Now(),
-		Status:       string(sip.REGISTER),
-		core:         c,
-		from:         &sip.Contact{Uri: msg.StartLine.Uri, Params: make(map[string]string)},
-		to:           msg.To,
-		host:         msg.Via.Host,
-		port:         msg.Via.Port,
-	}
-	c.Devices.Store(msg.From.Uri.UserInfo(), v)
-	return v
-}

transaction/device.go

@@ -1,182 +0,0 @@
-package transaction
-
-import (
-	"fmt"
-	"github.com/Monibuca/plugin-gb28181/sip"
-	"github.com/Monibuca/plugin-gb28181/utils"
-	"strings"
-	"time"
-)
-
-type Channel struct {
-	DeviceID     string
-	Name         string
-	Manufacturer string
-	Model        string
-	Owner        string
-	CivilCode    string
-	Address      string
-	Parental     int
-	SafetyWay    int
-	RegisterWay  int
-	Secrecy      int
-	Status       string
-	device       *Device
-	inviteRes    *sip.Message
-	Connected    bool
-}
-type Device struct {
-	ID           string
-	RegisterTime time.Time
-	UpdateTime   time.Time
-	Status       string
-	Channels     []Channel
-	core         *Core
-	sn           int
-	from         *sip.Contact
-	to           *sip.Contact
-	host         string
-	port         string
-}
-
-func (d *Device) UpdateChannels(list []Channel) {
-	for _, c := range list {
-		c.device = d
-		have := false
-		for i, o := range d.Channels {
-			if o.DeviceID == c.DeviceID {
-				c.inviteRes = o.inviteRes
-				c.Connected = o.inviteRes!=nil
-				d.Channels[i] = c
-				have = true
-				break
-			}
-		}
-		if !have {
-			d.Channels = append(d.Channels, c)
-		}
-	}
-}
-func (c *Channel) CreateMessage(Method sip.Method) (requestMsg *sip.Message) {
-	requestMsg = c.device.CreateMessage(Method)
-	requestMsg.StartLine.Uri = sip.NewURI(c.DeviceID + "@" + c.device.to.Uri.Domain())
-	requestMsg.To = &sip.Contact{
-		Uri: requestMsg.StartLine.Uri,
-	}
-	requestMsg.From = &sip.Contact{
-		Uri:    sip.NewURI(c.device.core.config.Serial + "@" + c.device.core.config.Realm),
-		Params: map[string]string{"tag": utils.RandNumString(9)},
-	}
-	return
-}
-func (d *Device) CreateMessage(Method sip.Method) (requestMsg *sip.Message) {
-	d.sn++
-	requestMsg = &sip.Message{
-		Mode:        sip.SIP_MESSAGE_REQUEST,
-		MaxForwards: 70,
-		UserAgent:   "Monibuca",
-		StartLine: &sip.StartLine{
-			Method: Method,
-			Uri:    d.to.Uri,
-		}, Via: &sip.Via{
-			Transport: "UDP",
-			Host:      d.core.config.SipIP,
-			Port:      fmt.Sprintf("%d", d.core.config.SipPort),
-			Params: map[string]string{
-				"branch": fmt.Sprintf("z9hG4bK%s", utils.RandNumString(8)),
-				"rport":  "-1", //only key,no-value
-			},
-		}, From: d.from,
-		To: d.to, CSeq: &sip.CSeq{
-			ID:     1,
-			Method: Method,
-		}, CallID: utils.RandNumString(10),
-		Addr: d.host + ":" + d.port,
-	}
-	requestMsg.From.Params["tag"] = utils.RandNumString(9)
-	return
-}
-func (d *Device) Query() int {
-	requestMsg := d.CreateMessage(sip.MESSAGE)
-	requestMsg.ContentType = "Application/MANSCDP+xml"
-	requestMsg.Body = fmt.Sprintf(`<?xml version="1.0"?>
-<Query>
-<CmdType>Catalog</CmdType>
-<SN>%d</SN>
-<DeviceID>%s</DeviceID>
-</Query>`, d.sn, requestMsg.To.Uri.UserInfo())
-	requestMsg.ContentLength = len(requestMsg.Body)
-	return d.core.SendMessage(requestMsg).Code
-}
-func (d *Device) Control(channelIndex int, PTZCmd string) int {
-	channel := &d.Channels[channelIndex]
-	requestMsg := channel.CreateMessage(sip.MESSAGE)
-	requestMsg.ContentType = "Application/MANSCDP+xml"
-	requestMsg.Body = fmt.Sprintf(`<?xml version="1.0"?>
-<Control>
-<CmdType>DeviceControl</CmdType>
-<SN>%d</SN>
-<DeviceID>%s</DeviceID>
-<PTZCmd>%s</PTZCmd>
-</Control>`, d.sn, requestMsg.To.Uri.UserInfo(), PTZCmd)
-	requestMsg.ContentLength = len(requestMsg.Body)
-	return d.core.SendMessage(requestMsg).Code
-}
-func (d *Device) Invite(channelIndex int) int {
-	channel := &d.Channels[channelIndex]
-	port := d.core.OnInvite(channel)
-	if port == 0 {
-		return 304
-	}
-	sdp := fmt.Sprintf(`v=0
-o=%s 0 0 IN IP4 %s
-s=Play
-c=IN IP4 %s
-t=0 0
-m=video %d RTP/AVP 96 98 97
-a=recvonly
-a=rtpmap:96 PS/90000
-a=rtpmap:97 MPEG4/90000
-a=rtpmap:98 H264/90000
-y=0200000001
-`, d.core.config.Serial, d.core.config.MediaIP, d.core.config.MediaIP, port)
-	sdp = strings.ReplaceAll(sdp, "\n", "\r\n")
-	invite := channel.CreateMessage(sip.INVITE)
-	invite.ContentType = "application/sdp"
-	invite.Contact = &sip.Contact{
-		Uri: sip.NewURI(fmt.Sprintf("%s@%s:%d", d.core.config.Serial, d.core.config.SipIP, d.core.config.SipPort)),
-	}
-	invite.Body = sdp
-	invite.ContentLength = len(sdp)
-	invite.Subject = fmt.Sprintf("%s:0200000001,34020000002020000001:0", channel.DeviceID)
-	response := d.core.SendMessage(invite)
-	fmt.Printf("invite response statuscode: %d\n", response.Code)
-	if response.Code == 200 {
-		channel.inviteRes = response.Data
-		channel.Connected = true
-		channel.Ack()
-	}
-	return response.Code
-}
-func (d *Device) Bye(channelIndex int) int{
-	channel := &d.Channels[channelIndex]
-	defer func() {
-		channel.inviteRes = nil
-		channel.Connected = false
-	}()
-	return channel.Bye().Code
-}
-func (c *Channel) Ack() {
-	ack := c.CreateMessage(sip.ACK)
-	ack.From = c.inviteRes.From
-	ack.To = c.inviteRes.To
-	ack.CallID = c.inviteRes.CallID
-	go c.device.core.Send(ack)
-}
-func (c *Channel) Bye() *Response{
-	bye := c.CreateMessage(sip.BYE)
-	bye.From = c.inviteRes.From
-	bye.To = c.inviteRes.To
-	bye.CallID = c.inviteRes.CallID
-	return c.device.core.SendMessage(bye)
-}

transaction/errors.go

@@ -6,8 +6,8 @@ import (
 
 //transaction 的错误定义
 var (
-	ErrorSyntax = errors.New("message syntax error")
-	ErrorCheck  = errors.New("message check failed")
-	ErrorParse  = errors.New("message parse failed")
-	ErrorUnknown  = errors.New("message unknown")
+	ErrorSyntax  = errors.New("message syntax error")
+	ErrorCheck   = errors.New("message check failed")
+	ErrorParse   = errors.New("message parse failed")
+	ErrorUnknown = errors.New("message unknown")
 )

transaction/fsm_ict.go

@@ -1,9 +1,7 @@
 package transaction
 
 import (
-	"github.com/Monibuca/plugin-gb28181/sip"
-	"fmt"
-	"time"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
 )
 
 /*
@@ -48,40 +46,30 @@ resp. to TU |  1xx             V                     |
 
                  Figure 5: INVITE client transaction
 */
-func ict_snd_invite(t *Transaction, e *EventObj) error {
-	msg := e.msg
+func ict_snd_invite(t *Transaction, evt Event, m *sip.Message) error {
 
-	t.isReliable = msg.IsReliable()
-	t.origRequest = msg
+	t.isReliable = m.IsReliable()
+	t.origRequest = m
 	t.state = ICT_CALLING
 
 	//发送出去之后，开启 timer
-	if msg.IsReliable() {
+	if m.IsReliable() {
 		//stop timer E in reliable transport
-		fmt.Println("Reliabel")
+		//fmt.Println("Reliabel")
 	} else {
-		fmt.Println("Not Reliable")
+		//fmt.Println("Not Reliable")
 		//发送定时器，每次加倍，没有上限？
 		t.timerA = NewSipTimer(T1, 0, func() {
-			t.event <- &EventObj{
-				evt: TIMEOUT_A,
-				tid: t.id,
+			if t.Err() == nil {
+				t.Run(TIMEOUT_A, nil)
 			}
 		})
 	}
-
-	//事物定时器
-	t.timerB = time.AfterFunc(TimeB, func() {
-		t.event <- &EventObj{
-			evt: TIMEOUT_B,
-			tid: t.id,
-		}
-	})
-
+	t.RunAfter(TimeB, TIMEOUT_B)
 	return nil
 }
 
-func osip_ict_timeout_a_event(t *Transaction, e *EventObj) error {
+func osip_ict_timeout_a_event(t *Transaction, evt Event, m *sip.Message) error {
 	err := t.SipSend(t.origRequest)
 	if err != nil {
 		//发送失败
@@ -93,54 +81,61 @@ func osip_ict_timeout_a_event(t *Transaction, e *EventObj) error {
 	return nil
 }
 
-func osip_ict_timeout_b_event(t *Transaction, e *EventObj) error {
+func osip_ict_timeout_b_event(t *Transaction, evt Event, m *sip.Message) error {
 	t.Terminate()
 	return nil
 }
 
-func ict_rcv_1xx(t *Transaction, e *EventObj) error {
-	t.lastResponse = e.msg
+func ict_rcv_1xx(t *Transaction, evt Event, m *sip.Message) error {
+	t.lastResponse = m
 	t.state = ICT_PROCEEDING
 	return nil
 }
-func ict_rcv_2xx(t *Transaction, e *EventObj) error {
-	t.lastResponse = e.msg
-
+func ict_rcv_2xx(t *Transaction, evt Event, m *sip.Message) error {
+	t.lastResponse = m
 	t.Terminate()
 
 	return nil
 }
-func ict_rcv_3456xx(t *Transaction, e *EventObj) error {
-	t.lastResponse = e.msg
-
+func ict_rcv_3456xx(t *Transaction, evt Event, m *sip.Message) error {
+	t.lastResponse = m
 	if t.state != ICT_COMPLETED {
 		/* not a retransmission */
 		/* automatic handling of ack! */
-		ack := ict_create_ack(t, e.msg)
+		ack := ict_create_ack(t, m)
 		t.ack = ack
 		_ = t.SipSend(t.ack)
 		t.Terminate()
 	}
-
-	/* start timer D (length is set to MAX (64*DEFAULT_T1 or 32000) */
-	t.timerD = time.AfterFunc(TimeD, func() {
-		t.event <- &EventObj{
-			evt: TIMEOUT_D,
-			tid: t.id,
-		}
-	})
-
+	t.RunAfter(TimeD, TIMEOUT_D)
 	t.state = ICT_COMPLETED
 
 	return nil
 }
 
 func ict_create_ack(t *Transaction, resp *sip.Message) *sip.Message {
-
-	return nil
+	return &sip.Message{
+		Mode: t.origRequest.Mode,
+		Addr: t.origRequest.Addr,
+		StartLine: &sip.StartLine{
+			Method: sip.ACK,
+			Uri:    t.origRequest.StartLine.Uri,
+		},
+		MaxForwards: t.origRequest.MaxForwards,
+		CallID:      t.callID,
+		Contact:     t.origRequest.Contact,
+		UserAgent:   t.origRequest.UserAgent,
+		Via:         t.via,
+		From:        t.from,
+		To:          t.to,
+		CSeq: &sip.CSeq{
+			ID:     1,
+			Method: sip.ACK,
+		},
+	}
 }
 
-func ict_retransmit_ack(t *Transaction, e *EventObj) error {
+func ict_retransmit_ack(t *Transaction, evt Event, m *sip.Message) error {
 	if t.ack == nil {
 		/* ??? we should make a new ACK and send it!!! */
 		return nil
@@ -154,7 +149,7 @@ func ict_retransmit_ack(t *Transaction, e *EventObj) error {
 	return nil
 }
 
-func osip_ict_timeout_d_event(t *Transaction, e *EventObj) error {
+func osip_ict_timeout_d_event(t *Transaction, evt Event, m *sip.Message) error {
 	t.Terminate()
 	return nil
 }

transaction/fsm_ist.go

@@ -1,26 +1,28 @@
 package transaction
 
-func ist_rcv_invite(t *Transaction, e *EventObj) error {
+import "github.com/Monibuca/plugin-gb28181/v3/sip"
+
+func ist_rcv_invite(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }
-func osip_ist_timeout_g_event(t *Transaction, e *EventObj) error {
+func osip_ist_timeout_g_event(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }
-func osip_ist_timeout_h_event(t *Transaction, e *EventObj) error {
+func osip_ist_timeout_h_event(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }
-func ist_snd_1xx(t *Transaction, e *EventObj) error {
+func ist_snd_1xx(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }
-func ist_snd_2xx(t *Transaction, e *EventObj) error {
+func ist_snd_2xx(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }
-func ist_snd_3456xx(t *Transaction, e *EventObj) error {
+func ist_snd_3456xx(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }
-func ist_rcv_ack(t *Transaction, e *EventObj) error {
+func ist_rcv_ack(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }
-func osip_ist_timeout_i_event(t *Transaction, e *EventObj) error {
+func osip_ist_timeout_i_event(t *Transaction, evt Event,m *sip.Message) error {
 	return nil
 }

transaction/fsm_nict.go

@@ -1,8 +1,7 @@
 package transaction
 
 import (
-	"fmt"
-	"time"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
 )
 
 /*
@@ -51,52 +50,43 @@ import (
 
                  Figure 6: non-INVITE client transaction
 */
-func nict_snd_request(t *Transaction, e *EventObj) error {
-	msg := e.msg
-	fmt.Println("nict request:", msg.GetMethod())
+func nict_snd_request(t *Transaction, evt Event, m *sip.Message) error {
+	//fmt.Println("nict request:", msg.GetMethod())
 
-	t.origRequest = msg
+	t.origRequest = m
 	t.state = NICT_TRYING
 
-	err := t.SipSend(msg)
+	err := t.SipSend(m)
 	if err != nil {
 		t.Terminate()
 		return err
 	}
 
 	//发送出去之后，开启 timer
-	if msg.IsReliable() {
+	if m.IsReliable() {
 		//stop timer E in reliable transport
-		fmt.Println("Reliabel")
+		//fmt.Println("Reliabel")
 	} else {
-		fmt.Println("Not Reliable")
+		//fmt.Println("Not Reliable")
 		//发送定时器
+
 		t.timerE = NewSipTimer(T1, T2, func() {
-			t.event <- &EventObj{
-				evt: TIMEOUT_E,
-				tid: t.id,
+			if t.Err() == nil {
+				t.Run(TIMEOUT_E, nil)
 			}
 		})
 	}
-
-	//事物定时器
-	t.timerF = time.AfterFunc(TimeF, func() {
-		t.event <- &EventObj{
-			evt: TIMEOUT_F,
-			tid: t.id,
-		}
-	})
-
+	t.RunAfter(TimeF, TIMEOUT_F)
 	return nil
 }
 
 //事物超时
-func osip_nict_timeout_f_event(t *Transaction, e *EventObj) error {
+func osip_nict_timeout_f_event(t *Transaction, evt Event, m *sip.Message) error {
 	t.Terminate()
 	return nil
 }
 
-func osip_nict_timeout_e_event(t *Transaction, e *EventObj) error {
+func osip_nict_timeout_e_event(t *Transaction, evt Event, m *sip.Message) error {
 	if t.state == NICT_TRYING {
 		//reset timer
 		t.timerE.Reset(t.timerE.timeout * 2)
@@ -115,8 +105,8 @@ func osip_nict_timeout_e_event(t *Transaction, e *EventObj) error {
 	return nil
 }
 
-func nict_rcv_1xx(t *Transaction, e *EventObj) error {
-	t.lastResponse = e.msg
+func nict_rcv_1xx(t *Transaction, evt Event, m *sip.Message) error {
+	t.lastResponse = m
 	t.state = NICT_PROCEEDING
 
 	//重置发送定时器
@@ -125,25 +115,20 @@ func nict_rcv_1xx(t *Transaction, e *EventObj) error {
 	return nil
 }
 
-func nict_rcv_23456xx(t *Transaction, e *EventObj) error {
-	t.lastResponse = e.msg
+func nict_rcv_23456xx(t *Transaction, evt Event, m *sip.Message) error {
+	t.lastResponse = m
 	t.state = NICT_COMPLETED
-
-	if e.msg.IsReliable() {
-		//不设置timerK
-	} else {
-		t.timerK = time.AfterFunc(T4, func() {
-			t.event <- &EventObj{
-				evt: TIMEOUT_K,
-				tid: t.id,
-			}
-		})
-	}
+	t.Terminate()
+	// if m.IsReliable() {
+	// 	//不设置timerK
+	// } else {
+	// 	t.RunAfter(T4*64, TIMEOUT_K)
+	// }
 
 	return nil
 }
 
-func osip_nict_timeout_k_event(t *Transaction, e *EventObj) error {
+func osip_nict_timeout_k_event(t *Transaction, evt Event, m *sip.Message) error {
 	t.Terminate()
 	return nil
 }

transaction/fsm_nist.go

@@ -2,7 +2,8 @@ package transaction
 
 import (
 	"fmt"
-	"time"
+
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
 )
 
 /*
@@ -51,8 +52,8 @@ import (
 
 */
 
-func nist_rcv_request(t *Transaction, e *EventObj) error {
-	fmt.Println("rcv request: ", e.msg.GetMethod())
+func nist_rcv_request(t *Transaction, evt Event, m *sip.Message) error {
+	fmt.Println("rcv request: ", m.GetMethod())
 	fmt.Println("transaction state: ", t.state.String())
 	if t.state != NIST_PRE_TRYING {
 		fmt.Println("rcv request retransmission,do response")
@@ -65,16 +66,16 @@ func nist_rcv_request(t *Transaction, e *EventObj) error {
 		}
 		return nil
 	} else {
-		t.origRequest = e.msg
+		t.origRequest = m
 		t.state = NIST_TRYING
-		t.isReliable = e.msg.IsReliable()
+		t.isReliable = m.IsReliable()
 	}
 
 	return nil
 }
 
-func nist_snd_1xx(t *Transaction, e *EventObj) error {
-	t.lastResponse = e.msg
+func nist_snd_1xx(t *Transaction, evt Event, m *sip.Message) error {
+	t.lastResponse = m
 	err := t.SipSend(t.lastResponse)
 	if err != nil {
 		return err
@@ -84,27 +85,21 @@ func nist_snd_1xx(t *Transaction, e *EventObj) error {
 	return nil
 }
 
-func nist_snd_23456xx(t *Transaction, e *EventObj) error {
-	t.lastResponse = e.msg
-	err := t.SipSend(t.lastResponse)
-	if err != nil {
+func nist_snd_23456xx(t *Transaction, evt Event, m *sip.Message) error {
+	t.lastResponse = m
+	if err := t.SipSend(t.lastResponse); err != nil {
 		return err
 	}
 	if t.state != NIST_COMPLETED {
 		if !t.isReliable {
-			t.timerJ = time.AfterFunc(T1*64, func() {
-				t.event <- &EventObj{
-					evt: TIMEOUT_J,
-					tid: t.id,
-				}
-			})
+			t.RunAfter(T1*64, TIMEOUT_J)
 		}
 	}
 
 	t.state = NIST_COMPLETED
 	return nil
 }
-func osip_nist_timeout_j_event(t *Transaction, e *EventObj) error {
+func osip_nist_timeout_j_event(t *Transaction, evt Event, m *sip.Message) error {
 	t.Terminate()
 	return nil
 }

transaction/transaction.go

@@ -2,11 +2,13 @@ package transaction
 
 import (
 	"context"
-	"github.com/Monibuca/plugin-gb28181/sip"
-	"github.com/Monibuca/plugin-gb28181/transport"
 	"fmt"
 	"net"
+	"sync"
 	"time"
+
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
+	"github.com/Monibuca/plugin-gb28181/v3/transport"
 )
 
 //状态机之状态
@@ -228,13 +230,13 @@ type Response struct {
 	Data    *sip.Message
 }
 
-type Handler func(t *Transaction, e *EventObj) error //操作
+type Handler func(*Transaction, Event, *sip.Message) error //操作
 
 type Header map[string]string
 
 // timer相关基础常量、方法等定义
 const (
-	T1      = 100 * time.Millisecond
+	T1      = 250 * time.Millisecond
 	T2      = 4 * time.Second
 	T4      = 5 * time.Second
 	TimeA   = T1
@@ -256,15 +258,15 @@ const (
 
 //是否需要tp layer？
 type Transaction struct {
-	ctx        context.Context //线程管理、其他参数
-	id         string          //transaction ID
-	isReliable bool            //是否可靠传输
-	core       *Core           //全局参数
-	typo       FSMType         //状态机类型
-	done       chan struct{}   //主动退出
+	cancel          context.CancelFunc
+	context.Context //线程管理、其他参数
+	sync.Mutex
+	id         string  //transaction ID
+	isReliable bool    //是否可靠传输
+	core       *Core   //全局参数
+	typo       FSMType //状态机类型
 
 	state    State          //当前状态
-	event    chan *EventObj //输入的事件，带缓冲
 	response chan *Response //输出的响应
 	startAt  time.Time      //开始时间
 	endAt    time.Time      //结束时间
@@ -279,24 +281,10 @@ type Transaction struct {
 	origRequest  *sip.Message //Initial request
 	lastResponse *sip.Message //Last response，可能是临时的，也可能是最终的
 	ack          *sip.Message //ack request sent
-
 	//timer for ict
 	timerA *SipTimer
-	timerB *time.Timer
-	timerD *time.Timer
-
 	//timer for nict
 	timerE *SipTimer
-	timerF *time.Timer
-	timerK *time.Timer
-
-	//timer for ist
-	timerG *time.Timer
-	timerH *time.Timer
-	timerI *time.Timer
-
-	//timer for nist
-	timerJ *time.Timer
 }
 
 type SipTimer struct {
@@ -329,41 +317,37 @@ func (ta *Transaction) GetTid() string {
 	return ta.id
 }
 
+func (ta *Transaction) RunAfter(t time.Duration, evt Event) {
+	time.AfterFunc(t, func() {
+		if ta.Err() == nil {
+			ta.Run(evt, nil)
+		}
+	})
+}
+
 //每一个transaction至少有一个状态机线程运行
 //TODO:如果是一个uac的transaction，则把最后响应的消息返回（通过response chan）
 //transaction有很多消息需要传递到TU，也接收来自TU的消息。
-func (ta *Transaction) Run() {
-	for {
-		select {
-		case e := <-ta.event:
-			//根据event调用对应的handler
-			fmt.Println("fsm run event:", e.evt.String())
-			core := ta.core
-			state := ta.state
-			evtHandlers, ok1 := core.handlers[state]
-			if !ok1 {
-				fmt.Println("invalid state:", ta.state.String())
-				break
-			}
-			f, ok2 := evtHandlers[e.evt]
-			if !ok2 {
-				fmt.Println("invalid handler for this event:", e.evt.String())
-				break
-			}
-			fmt.Printf("state:%s, event:%s\n", state.String(), e.evt.String())
-			err := f(ta, e)
-			if err != nil {
-				fmt.Printf("transaction run failed, state:%s, event:%s\n", state.String(), e.evt.String())
-			}
-
-		case <-ta.done:
-			fmt.Println("fsm exit")
-			return
-
-		case <-ta.ctx.Done():
-			fmt.Println("fsm killed")
-			return
-		}
+func (ta *Transaction) Run(evt Event, m *sip.Message) {
+	//根据event调用对应的handler
+	//fmt.Println("fsm run event:", e.evt.String())
+	core := ta.core
+	ta.Lock()
+	defer ta.Unlock()
+	evtHandlers, ok1 := core.handlers[ta.state]
+	if !ok1 {
+		//fmt.Println("invalid state:", ta.state.String())
+		return
+	}
+	f, ok2 := evtHandlers[evt]
+	if !ok2 {
+		//fmt.Println("invalid handler for this event:", e.evt.String())
+		return
+	}
+	//fmt.Printf("state:%s, event:%s\n", state.String(), e.evt.String())
+	err := f(ta, evt, m)
+	if err != nil {
+		//fmt.Printf("transaction run failed, state:%s, event:%s\n", state.String(), e.evt.String())
 	}
 }
 
@@ -384,13 +368,10 @@ func (ta *Transaction) Terminate() {
 		ta.state = NIST_TERMINATED
 	}
 
-	//关掉事物的线程
-	close(ta.done)
-
+	//关掉事物
+	ta.cancel()
 	//TODO：某些timer需要检查并关掉，并且设置为nil
-
-	//remove ta from core
-	ta.core.removeTa <- ta.id
+	ta.core.DelTransaction(ta.id)
 }
 
 //根据sip消息，解析出目标服务器地址，发送消息
@@ -399,8 +380,8 @@ func (ta *Transaction) SipSend(msg *sip.Message) error {
 	if err != nil {
 		return err
 	}
-    addr := msg.Addr
-    if addr==""{
+	addr := msg.Addr
+	if addr == "" {
 		viaParams := msg.Via.Params
 		//host
 		var host, port string
@@ -424,7 +405,7 @@ func (ta *Transaction) SipSend(msg *sip.Message) error {
 		addr = fmt.Sprintf("%s:%s", host, port)
 	}
 
-	fmt.Println("dest addr:", addr)
+	//fmt.Println("dest addr:", addr)
 
 	var err1, err2 error
 	pkt := &transport.Packet{}

transaction/utils.go

@@ -1,8 +1,8 @@
 package transaction
 
 import (
-	"github.com/Monibuca/plugin-gb28181/sip"
 	"fmt"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
 	"net"
 	"strings"
 )

transport/example.go

@@ -2,7 +2,7 @@ package transport
 
 import (
 	"fmt"
-	"github.com/Monibuca/plugin-gb28181/utils"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
 	"os"
 	"time"
 )

transport/tcp_client.go

@@ -48,7 +48,7 @@ func (c *TCPClient) Start() error {
 	if err != nil {
 		fmt.Println("dial tcp server failed :", err.Error())
 		return err
-	}else{
+	} else {
 		fmt.Println("start tcp client")
 	}
 

tu/client.go

@@ -2,7 +2,7 @@ package tu
 
 import (
 	"fmt"
-	"github.com/Monibuca/plugin-gb28181/transaction"
+	"github.com/Monibuca/plugin-gb28181/v3/transaction"
 )
 
 //sip server和client的配置，可以得到sip URI：sip
@@ -45,7 +45,6 @@ func NewClient(config *transaction.Config, static *ClientStatic) *Client {
 	}
 }
 
-
 //TODO：对于一个TU，开启之后
 //运行一个sip client
 func RunClient() {
@@ -82,7 +81,7 @@ func RunClient() {
 	//TODO：先发起注册
 	//TODO:build sip message
 	msg := BuildMessageRequest("", "", "", "", "", "",
-		0, 0, 0,"")
+		0, 0, 0, "")
 	resp := c.SendMessage(msg)
 	if resp.Code != 0 {
 		fmt.Println("request failed")

tu/common.go

@@ -2,8 +2,8 @@ package tu
 
 import (
 	"fmt"
-	"github.com/Monibuca/plugin-gb28181/sip"
-	"github.com/Monibuca/plugin-gb28181/utils"
+	"github.com/Monibuca/plugin-gb28181/v3/sip"
+	"github.com/Monibuca/plugin-gb28181/v3/utils"
 )
 
 //根据参数构建各种消息
@@ -20,7 +20,7 @@ expires: 过期时间
 cseq：消息序列号，当前对话递增
 */
 //构建消息：以客户端（可能是IPC，也可能是SIP Server）的角度
-func BuildMessageRequest(method sip.Method, transport, sipSerial, sipRealm, username , srcIP string, srcPort uint16, expires, cseq int,body string) *sip.Message {
+func BuildMessageRequest(method sip.Method, transport, sipSerial, sipRealm, username, srcIP string, srcPort uint16, expires, cseq int, body string) *sip.Message {
 	server := fmt.Sprintf("%s@%s", sipSerial, sipRealm)
 	client := fmt.Sprintf("%s@%s", username, sipRealm)
 
@@ -62,7 +62,7 @@ func BuildMessageRequest(method sip.Method, transport, sipSerial, sipRealm, user
 	msg.Contact = &sip.Contact{
 		Uri: sip.NewURI(fmt.Sprintf("%s@%s:%d", username, srcIP, srcPort)),
 	}
-	if len(body)>0{
+	if len(body) > 0 {
 		msg.ContentLength = len(body)
 		msg.Body = body
 	}

tu/server.go

@@ -1,8 +1,9 @@
 package tu
 
 import (
-	"github.com/Monibuca/plugin-gb28181/transaction"
 	"sync"
+
+	"github.com/Monibuca/plugin-gb28181/v3/transaction"
 )
 
 //TODO:参考http服务，使用者仅需要根据需要实现某些handler，替换某些header fileds or body信息。其他的处理都由库来实现。
@@ -15,7 +16,7 @@ type Server struct {
 //提供config参数
 func NewServer(config *transaction.Config) *Server {
 	return &Server{
-		Core:      transaction.NewCore(config),
+		Core: transaction.NewCore(config),
 	}
 }
 

ui/dist/demo.html

@@ -1,19 +0,0 @@
-<meta charset="utf-8">
-<title>plugin-gb28181 demo</title>
-<script src="https://unpkg.com/vue"></script>
-<script src="./plugin-gb28181.umd.js"></script>
-
-<link rel="stylesheet" href="./plugin-gb28181.css">
-
-
-<div id="app">
-  <demo></demo>
-</div>
-
-<script>
-new Vue({
-  components: {
-    demo: plugin-gb28181
-  }
-}).$mount('#app')
-</script>

ui/dist/plugin-gb28181.common.js

@@ -1,612 +0,0 @@
-module.exports =
-/******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__webpack_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __webpack_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "deee");
-/******/ })
-/************************************************************************/
-/******/ ({
-
-/***/ "789d":
-/***/ (function(module, exports, __webpack_require__) {
-
-// extracted by mini-css-extract-plugin
-
-/***/ }),
-
-/***/ "b284":
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var _plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("789d");
-/* harmony import */ var _plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__);
-/* unused harmony reexport * */
- /* unused harmony default export */ var _unused_webpack_default_export = (_plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0___default.a); 
-
-/***/ }),
-
-/***/ "deee":
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
-// This file is imported into lib/wc client bundles.
-
-if (typeof window !== 'undefined') {
-  var currentScript = window.document.currentScript
-  if (true) {
-    var getCurrentScript = __webpack_require__("f3a8")
-    currentScript = getCurrentScript()
-
-    // for backward compatibility, because previously we directly included the polyfill
-    if (!('currentScript' in document)) {
-      Object.defineProperty(document, 'currentScript', { get: getCurrentScript })
-    }
-  }
-
-  var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
-  if (src) {
-    __webpack_require__.p = src[1] // eslint-disable-line
-  }
-}
-
-// Indicate to webpack that this file can be concatenated
-/* harmony default export */ var setPublicPath = (null);
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"2507526a-vue-loader-template"}!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/App.vue?vue&type=template&id=764a9e60&
-var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_c('mu-data-table',{attrs:{"data":_vm.Devices,"columns":_vm.columns},scopedSlots:_vm._u([{key:"expand",fn:function(prop){return [_c('mu-data-table',{attrs:{"data":prop.row.Channels,"columns":_vm.columns2},scopedSlots:_vm._u([{key:"default",fn:function(ref){
-var item = ref.row;
-var $index = ref.$index;
-return [_c('td',[_vm._v(_vm._s(item.DeviceID))]),_c('td',[_vm._v(_vm._s(item.Name))]),_c('td',[_vm._v(_vm._s(item.Manufacturer))]),_c('td',[_vm._v(_vm._s(item.Address))]),_c('td',[_vm._v(_vm._s(item.Status))]),_c('td',[(item.Connected)?_c('mu-button',{attrs:{"flat":""},on:{"click":function($event){return _vm.ptz(prop.row.ID, $index,item)}}},[_vm._v("云台")]):_vm._e(),(item.Connected)?_c('mu-button',{attrs:{"flat":""},on:{"click":function($event){return _vm.bye(prop.row.ID, $index)}}},[_vm._v("断开")]):_c('mu-button',{attrs:{"flat":""},on:{"click":function($event){return _vm.invite(prop.row.ID, $index,item)}}},[_vm._v("连接 ")])],1)]}}],null,true)})]}},{key:"default",fn:function(ref){
-var item = ref.row;
-return [_c('td',[_vm._v(_vm._s(item.ID))]),_c('td',[_vm._v(_vm._s(item.Channels ? item.Channels.length : 0))]),_c('td',[_c('StartTime',{attrs:{"value":item.RegisterTime}})],1),_c('td',[_c('StartTime',{attrs:{"value":item.UpdateTime}})],1),_c('td',[_vm._v(_vm._s(item.Status))])]}}])}),_c('webrtc-player',{ref:"player",attrs:{"PublicIP":_vm.PublicIP},on:{"ptz":_vm.sendPtz},model:{value:(_vm.previewStreamPath),callback:function ($$v) {_vm.previewStreamPath=$$v},expression:"previewStreamPath"}})],1)}
-var staticRenderFns = []
-
-
-// CONCATENATED MODULE: ./src/App.vue?vue&type=template&id=764a9e60&
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"2507526a-vue-loader-template"}!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/components/Player.vue?vue&type=template&id=70987c50&scoped=true&
-var Playervue_type_template_id_70987c50_scoped_true_render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('Modal',_vm._g(_vm._b({attrs:{"draggable":"","title":_vm.streamPath},on:{"on-ok":_vm.onClosePreview,"on-cancel":_vm.onClosePreview}},'Modal',_vm.$attrs,false),_vm.$listeners),[_c('div',{staticClass:"container"},[_c('video',{ref:"webrtc",attrs:{"width":"488","height":"275","autoplay":"","muted":"","controls":""},domProps:{"srcObject":_vm.stream,"muted":true}}),_c('div',{staticClass:"control"},_vm._l((4),function(n){return _c('svg',{class:'arrow'+n,attrs:{"viewBox":"0 0 1024 1024","version":"1.1","xmlns":"http://www.w3.org/2000/svg","xmlns:xlink":"http://www.w3.org/1999/xlink","width":"64","height":"64"},on:{"click":function($event){return _vm.$emit('ptz',n)}}},[_c('defs'),_c('path',{attrs:{"d":"M682.666667 955.733333H341.333333a17.066667 17.066667 0 0 1-17.066666-17.066666V529.066667H85.333333a17.066667 17.066667 0 0 1-12.066133-29.1328l426.666667-426.666667a17.0496 17.0496 0 0 1 24.132266 0l426.666667 426.666667A17.066667 17.066667 0 0 1 938.666667 529.066667H699.733333v409.6a17.066667 17.066667 0 0 1-17.066666 17.066666z m-324.266667-34.133333h307.2V512a17.066667 17.066667 0 0 1 17.066667-17.066667h214.801066L512 109.4656 126.532267 494.933333H341.333333a17.066667 17.066667 0 0 1 17.066667 17.066667v409.6z","p-id":"6849"}})])}),0)]),_c('div',{attrs:{"slot":"footer"},slot:"footer"},[(_vm.remoteSDP)?_c('mu-badge',[_c('a',{attrs:{"slot":"content","href":_vm.remoteSDPURL,"download":"remoteSDP.txt"},slot:"content"},[_vm._v("remoteSDP")])]):_vm._e(),(_vm.localSDP)?_c('mu-badge',[_c('a',{attrs:{"slot":"content","href":_vm.localSDPURL,"download":"localSDP.txt"},slot:"content"},[_vm._v("localSDP")])]):_vm._e()],1)])}
-var Playervue_type_template_id_70987c50_scoped_true_staticRenderFns = []
-
-
-// CONCATENATED MODULE: ./src/components/Player.vue?vue&type=template&id=70987c50&scoped=true&
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/components/Player.vue?vue&type=script&lang=js&
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-
-let pc = null;
-/* harmony default export */ var Playervue_type_script_lang_js_ = ({
-  data() {
-    return {
-      iceConnectionState: pc && pc.iceConnectionState,
-      stream: null,
-      localSDP: "",
-      remoteSDP: "",
-      remoteSDPURL: "",
-      localSDPURL: "",
-      streamPath: ""
-    };
-  },
-props:{
-  PublicIP:String
-},
-    methods: {
-        async play(streamPath) {
-            pc = new RTCPeerConnection();
-            pc.addTransceiver('video',{
-              direction:'recvonly'
-            })
-            this.streamPath = streamPath;
-            pc.onsignalingstatechange = e => {
-                //console.log(e);
-            };
-            pc.oniceconnectionstatechange = e => {
-                this.$toast.info(pc.iceConnectionState);
-                this.iceConnectionState = pc.iceConnectionState;
-            };
-            pc.onicecandidate = event => {
-                console.log(event)
-            };
-            pc.ontrack = event => {
-               // console.log(event);
-                if (event.track.kind == "video")
-                    this.stream = event.streams[0];
-            };
-            await pc.setLocalDescription(await pc.createOffer());
-            this.localSDP = pc.localDescription.sdp;
-            this.localSDPURL = URL.createObjectURL(
-                new Blob([this.localSDP], { type: "text/plain" })
-            );
-            const result = await this.ajax({
-                type: "POST",
-                processData: false,
-                data: JSON.stringify(pc.localDescription.toJSON()),
-                url: "/webrtc/play?streamPath=" + this.streamPath,
-                dataType: "json"
-            });
-            if (result.errmsg) {
-                this.$toast.error(result.errmsg);
-                return;
-            } else {
-                this.remoteSDP = result.sdp;
-                this.remoteSDPURL = URL.createObjectURL(new Blob([this.remoteSDP], { type: "text/plain" }));
-            }
-            await pc.setRemoteDescription(new RTCSessionDescription(result));
-        },
-        onClosePreview() {
-            pc.close();
-        }
-    }
-});
-
-// CONCATENATED MODULE: ./src/components/Player.vue?vue&type=script&lang=js&
- /* harmony default export */ var components_Playervue_type_script_lang_js_ = (Playervue_type_script_lang_js_); 
-// EXTERNAL MODULE: ./src/components/Player.vue?vue&type=style&index=0&id=70987c50&scoped=true&lang=css&
-var Playervue_type_style_index_0_id_70987c50_scoped_true_lang_css_ = __webpack_require__("b284");
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib/runtime/componentNormalizer.js
-/* globals __VUE_SSR_CONTEXT__ */
-
-// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
-// This module is a runtime utility for cleaner component module output and will
-// be included in the final webpack user bundle.
-
-function normalizeComponent (
-  scriptExports,
-  render,
-  staticRenderFns,
-  functionalTemplate,
-  injectStyles,
-  scopeId,
-  moduleIdentifier, /* server only */
-  shadowMode /* vue-cli only */
-) {
-  // Vue.extend constructor export interop
-  var options = typeof scriptExports === 'function'
-    ? scriptExports.options
-    : scriptExports
-
-  // render functions
-  if (render) {
-    options.render = render
-    options.staticRenderFns = staticRenderFns
-    options._compiled = true
-  }
-
-  // functional template
-  if (functionalTemplate) {
-    options.functional = true
-  }
-
-  // scopedId
-  if (scopeId) {
-    options._scopeId = 'data-v-' + scopeId
-  }
-
-  var hook
-  if (moduleIdentifier) { // server build
-    hook = function (context) {
-      // 2.3 injection
-      context =
-        context || // cached call
-        (this.$vnode && this.$vnode.ssrContext) || // stateful
-        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
-      // 2.2 with runInNewContext: true
-      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
-        context = __VUE_SSR_CONTEXT__
-      }
-      // inject component styles
-      if (injectStyles) {
-        injectStyles.call(this, context)
-      }
-      // register component module identifier for async chunk inferrence
-      if (context && context._registeredComponents) {
-        context._registeredComponents.add(moduleIdentifier)
-      }
-    }
-    // used by ssr in case component is cached and beforeCreate
-    // never gets called
-    options._ssrRegister = hook
-  } else if (injectStyles) {
-    hook = shadowMode
-      ? function () {
-        injectStyles.call(
-          this,
-          (options.functional ? this.parent : this).$root.$options.shadowRoot
-        )
-      }
-      : injectStyles
-  }
-
-  if (hook) {
-    if (options.functional) {
-      // for template-only hot-reload because in that case the render fn doesn't
-      // go through the normalizer
-      options._injectStyles = hook
-      // register for functional component in vue file
-      var originalRender = options.render
-      options.render = function renderWithStyleInjection (h, context) {
-        hook.call(context)
-        return originalRender(h, context)
-      }
-    } else {
-      // inject component registration as beforeCreate hook
-      var existing = options.beforeCreate
-      options.beforeCreate = existing
-        ? [].concat(existing, hook)
-        : [hook]
-    }
-  }
-
-  return {
-    exports: scriptExports,
-    options: options
-  }
-}
-
-// CONCATENATED MODULE: ./src/components/Player.vue
-
-
-
-
-
-
-/* normalize component */
-
-var component = normalizeComponent(
-  components_Playervue_type_script_lang_js_,
-  Playervue_type_template_id_70987c50_scoped_true_render,
-  Playervue_type_template_id_70987c50_scoped_true_staticRenderFns,
-  false,
-  null,
-  "70987c50",
-  null
-  
-)
-
-/* harmony default export */ var Player = (component.exports);
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/App.vue?vue&type=script&lang=js&
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-
-
-/* harmony default export */ var Appvue_type_script_lang_js_ = ({
-  components:{
-    WebrtcPlayer: Player
-  },
-  props:{
-    ListenAddr:String
-  },
-  computed:{
-    PublicIP(){
-      return this.ListenAddr.split(":")[0]
-    }
-  },
-  data() {
-    return {
-      Devices: [], previewStreamPath:false,
-      context:{
-        id:null,
-        channel:0,
-        item:null
-      },
-      columns: Object.freeze(
-          ["设备号", "通道数", "注册时间", "更新时间", "状态"].map(
-              (title) => ({
-                title,
-              })
-          )
-      ),
-      columns2: Object.freeze([
-        "通道编号",
-        "名称",
-        "厂商",
-        "地址",
-        "状态",
-        "操作",
-      ]).map((title) => ({title})),
-      ptzCmds:["A50F010800880045","A50F01018800003E", "A50F010400880041","A50F01028800003F"]
-    };
-  },
-  created() {
-    this.fetchlist();
-  },
-  methods: {
-    fetchlist() {
-      const listES = new EventSource(this.apiHost + "/gb28181/list");
-      listES.onmessage = (evt) => {
-        if (!evt.data) return;
-        this.Devices = JSON.parse(evt.data) || [];
-        this.Devices.sort((a, b) => (a.ID > b.ID ? 1 : -1));
-      };
-      this.$once("hook:destroyed", () => listES.close());
-    },
-    ptz(id, channel,item) {
-      this.context = {
-        id,channel,item
-      }
-      this.previewStreamPath = true
-      this.$nextTick(() =>this.$refs.player.play("gb28181/"+item.DeviceID));
-    },
-    sendPtz(n){
-      this.ajax.get("/gb28181/control", {
-        id:this.context.id,
-        channel:this.context.channel,
-        ptzcmd: this.ptzCmds[n-1],
-      }).then(x=>{
-        setTimeout(()=>{
-          this.ajax.get("/gb28181/control", {
-            id:this.context.id,
-            channel:this.context.channel,
-            ptzcmd: "A50F0100000000B5",
-          });
-        },500)
-      });
-    },
-    invite(id, channel,item) {
-      this.ajax.get("/gb28181/invite", {id, channel}).then(x=>{
-        item.Connected = true
-      });
-    },
-    bye(id, channel,item) {
-      this.ajax.get("/gb28181/bye", {id, channel}).then(x=>{
-        item.Connected = false
-      });;
-    }
-  },
-});
-
-// CONCATENATED MODULE: ./src/App.vue?vue&type=script&lang=js&
- /* harmony default export */ var src_Appvue_type_script_lang_js_ = (Appvue_type_script_lang_js_); 
-// CONCATENATED MODULE: ./src/App.vue
-
-
-
-
-
-/* normalize component */
-
-var App_component = normalizeComponent(
-  src_Appvue_type_script_lang_js_,
-  render,
-  staticRenderFns,
-  false,
-  null,
-  null,
-  null
-  
-)
-
-/* harmony default export */ var App = (App_component.exports);
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/@vue/cli-service/lib/commands/build/entry-lib.js
-
-
-/* harmony default export */ var entry_lib = __webpack_exports__["default"] = (App);
-
-
-
-/***/ }),
-
-/***/ "f3a8":
-/***/ (function(module, exports, __webpack_require__) {
-
-var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// addapted from the document.currentScript polyfill by Adam Miller
-// MIT license
-// source: https://github.com/amiller-gh/currentScript-polyfill
-
-// added support for Firefox https://bugzilla.mozilla.org/show_bug.cgi?id=1620505
-
-(function (root, factory) {
-  if (true) {
-    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
-				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
-				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-  } else {}
-}(typeof self !== 'undefined' ? self : this, function () {
-  function getCurrentScript () {
-    if (document.currentScript) {
-      return document.currentScript
-    }
-  
-    // IE 8-10 support script readyState
-    // IE 11+ & Firefox support stack trace
-    try {
-      throw new Error();
-    }
-    catch (err) {
-      // Find the second match for the "at" string to get file src url from stack.
-      var ieStackRegExp = /.*at [^(]*\((.*):(.+):(.+)\)$/ig,
-        ffStackRegExp = /@([^@]*):(\d+):(\d+)\s*$/ig,
-        stackDetails = ieStackRegExp.exec(err.stack) || ffStackRegExp.exec(err.stack),
-        scriptLocation = (stackDetails && stackDetails[1]) || false,
-        line = (stackDetails && stackDetails[2]) || false,
-        currentLocation = document.location.href.replace(document.location.hash, ''),
-        pageSource,
-        inlineScriptSourceRegExp,
-        inlineScriptSource,
-        scripts = document.getElementsByTagName('script'); // Live NodeList collection
-  
-      if (scriptLocation === currentLocation) {
-        pageSource = document.documentElement.outerHTML;
-        inlineScriptSourceRegExp = new RegExp('(?:[^\\n]+?\\n){0,' + (line - 2) + '}[^<]*<script>([\\d\\D]*?)<\\/script>[\\d\\D]*', 'i');
-        inlineScriptSource = pageSource.replace(inlineScriptSourceRegExp, '$1').trim();
-      }
-  
-      for (var i = 0; i < scripts.length; i++) {
-        // If ready state is interactive, return the script tag
-        if (scripts[i].readyState === 'interactive') {
-          return scripts[i];
-        }
-  
-        // If src matches, return the script tag
-        if (scripts[i].src === scriptLocation) {
-          return scripts[i];
-        }
-  
-        // If inline source matches, return the script tag
-        if (
-          scriptLocation === currentLocation &&
-          scripts[i].innerHTML &&
-          scripts[i].innerHTML.trim() === inlineScriptSource
-        ) {
-          return scripts[i];
-        }
-      }
-  
-      // If no match, return null
-      return null;
-    }
-  };
-
-  return getCurrentScript
-}));
-
-
-/***/ })
-
-/******/ })["default"];
-//# sourceMappingURL=plugin-gb28181.common.js.map

ui/dist/plugin-gb28181.css

@@ -1 +0,0 @@
-.arrow1[data-v-70987c50]{grid-column:2;grid-row:1}.arrow2[data-v-70987c50]{transform:rotate(90deg);grid-column:3;grid-row:2}.arrow3[data-v-70987c50]{transform:rotate(180deg);grid-column:2;grid-row:3}.arrow4[data-v-70987c50]{transform:rotate(270deg);grid-column:1;grid-row:2}.container[data-v-70987c50]{position:relative}.control[data-v-70987c50]{position:absolute;bottom:0;right:0;display:grid;grid-template-columns:repeat(3,33.33%);grid-template-rows:repeat(3,33.33%);width:192px;height:192px}.control>[data-v-70987c50]{cursor:pointer;fill:grey}.control>[data-v-70987c50]:hover{fill:#0ff}

ui/dist/plugin-gb28181.umd.js

@@ -1,622 +0,0 @@
-(function webpackUniversalModuleDefinition(root, factory) {
-	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory();
-	else if(typeof define === 'function' && define.amd)
-		define([], factory);
-	else if(typeof exports === 'object')
-		exports["plugin-gb28181"] = factory();
-	else
-		root["plugin-gb28181"] = factory();
-})((typeof self !== 'undefined' ? self : this), function() {
-return /******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __webpack_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__webpack_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__webpack_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__webpack_require__.d = function(exports, name, getter) {
-/******/ 		if(!__webpack_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__webpack_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __webpack_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__webpack_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__webpack_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "deee");
-/******/ })
-/************************************************************************/
-/******/ ({
-
-/***/ "789d":
-/***/ (function(module, exports, __webpack_require__) {
-
-// extracted by mini-css-extract-plugin
-
-/***/ }),
-
-/***/ "b284":
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-/* harmony import */ var _plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("789d");
-/* harmony import */ var _plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0__);
-/* unused harmony reexport * */
- /* unused harmony default export */ var _unused_webpack_default_export = (_plugin_webrtc_ui_node_modules_mini_css_extract_plugin_dist_loader_js_ref_6_oneOf_1_0_plugin_webrtc_ui_node_modules_css_loader_dist_cjs_js_ref_6_oneOf_1_1_plugin_webrtc_ui_node_modules_vue_loader_lib_loaders_stylePostLoader_js_plugin_webrtc_ui_node_modules_postcss_loader_src_index_js_ref_6_oneOf_1_2_plugin_webrtc_ui_node_modules_cache_loader_dist_cjs_js_ref_0_0_plugin_webrtc_ui_node_modules_vue_loader_lib_index_js_vue_loader_options_Player_vue_vue_type_style_index_0_id_70987c50_scoped_true_lang_css___WEBPACK_IMPORTED_MODULE_0___default.a); 
-
-/***/ }),
-
-/***/ "deee":
-/***/ (function(module, __webpack_exports__, __webpack_require__) {
-
-"use strict";
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
-// This file is imported into lib/wc client bundles.
-
-if (typeof window !== 'undefined') {
-  var currentScript = window.document.currentScript
-  if (true) {
-    var getCurrentScript = __webpack_require__("f3a8")
-    currentScript = getCurrentScript()
-
-    // for backward compatibility, because previously we directly included the polyfill
-    if (!('currentScript' in document)) {
-      Object.defineProperty(document, 'currentScript', { get: getCurrentScript })
-    }
-  }
-
-  var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
-  if (src) {
-    __webpack_require__.p = src[1] // eslint-disable-line
-  }
-}
-
-// Indicate to webpack that this file can be concatenated
-/* harmony default export */ var setPublicPath = (null);
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"2507526a-vue-loader-template"}!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/App.vue?vue&type=template&id=764a9e60&
-var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',[_c('mu-data-table',{attrs:{"data":_vm.Devices,"columns":_vm.columns},scopedSlots:_vm._u([{key:"expand",fn:function(prop){return [_c('mu-data-table',{attrs:{"data":prop.row.Channels,"columns":_vm.columns2},scopedSlots:_vm._u([{key:"default",fn:function(ref){
-var item = ref.row;
-var $index = ref.$index;
-return [_c('td',[_vm._v(_vm._s(item.DeviceID))]),_c('td',[_vm._v(_vm._s(item.Name))]),_c('td',[_vm._v(_vm._s(item.Manufacturer))]),_c('td',[_vm._v(_vm._s(item.Address))]),_c('td',[_vm._v(_vm._s(item.Status))]),_c('td',[(item.Connected)?_c('mu-button',{attrs:{"flat":""},on:{"click":function($event){return _vm.ptz(prop.row.ID, $index,item)}}},[_vm._v("云台")]):_vm._e(),(item.Connected)?_c('mu-button',{attrs:{"flat":""},on:{"click":function($event){return _vm.bye(prop.row.ID, $index)}}},[_vm._v("断开")]):_c('mu-button',{attrs:{"flat":""},on:{"click":function($event){return _vm.invite(prop.row.ID, $index,item)}}},[_vm._v("连接 ")])],1)]}}],null,true)})]}},{key:"default",fn:function(ref){
-var item = ref.row;
-return [_c('td',[_vm._v(_vm._s(item.ID))]),_c('td',[_vm._v(_vm._s(item.Channels ? item.Channels.length : 0))]),_c('td',[_c('StartTime',{attrs:{"value":item.RegisterTime}})],1),_c('td',[_c('StartTime',{attrs:{"value":item.UpdateTime}})],1),_c('td',[_vm._v(_vm._s(item.Status))])]}}])}),_c('webrtc-player',{ref:"player",attrs:{"PublicIP":_vm.PublicIP},on:{"ptz":_vm.sendPtz},model:{value:(_vm.previewStreamPath),callback:function ($$v) {_vm.previewStreamPath=$$v},expression:"previewStreamPath"}})],1)}
-var staticRenderFns = []
-
-
-// CONCATENATED MODULE: ./src/App.vue?vue&type=template&id=764a9e60&
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"2507526a-vue-loader-template"}!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/components/Player.vue?vue&type=template&id=70987c50&scoped=true&
-var Playervue_type_template_id_70987c50_scoped_true_render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('Modal',_vm._g(_vm._b({attrs:{"draggable":"","title":_vm.streamPath},on:{"on-ok":_vm.onClosePreview,"on-cancel":_vm.onClosePreview}},'Modal',_vm.$attrs,false),_vm.$listeners),[_c('div',{staticClass:"container"},[_c('video',{ref:"webrtc",attrs:{"width":"488","height":"275","autoplay":"","muted":"","controls":""},domProps:{"srcObject":_vm.stream,"muted":true}}),_c('div',{staticClass:"control"},_vm._l((4),function(n){return _c('svg',{class:'arrow'+n,attrs:{"viewBox":"0 0 1024 1024","version":"1.1","xmlns":"http://www.w3.org/2000/svg","xmlns:xlink":"http://www.w3.org/1999/xlink","width":"64","height":"64"},on:{"click":function($event){return _vm.$emit('ptz',n)}}},[_c('defs'),_c('path',{attrs:{"d":"M682.666667 955.733333H341.333333a17.066667 17.066667 0 0 1-17.066666-17.066666V529.066667H85.333333a17.066667 17.066667 0 0 1-12.066133-29.1328l426.666667-426.666667a17.0496 17.0496 0 0 1 24.132266 0l426.666667 426.666667A17.066667 17.066667 0 0 1 938.666667 529.066667H699.733333v409.6a17.066667 17.066667 0 0 1-17.066666 17.066666z m-324.266667-34.133333h307.2V512a17.066667 17.066667 0 0 1 17.066667-17.066667h214.801066L512 109.4656 126.532267 494.933333H341.333333a17.066667 17.066667 0 0 1 17.066667 17.066667v409.6z","p-id":"6849"}})])}),0)]),_c('div',{attrs:{"slot":"footer"},slot:"footer"},[(_vm.remoteSDP)?_c('mu-badge',[_c('a',{attrs:{"slot":"content","href":_vm.remoteSDPURL,"download":"remoteSDP.txt"},slot:"content"},[_vm._v("remoteSDP")])]):_vm._e(),(_vm.localSDP)?_c('mu-badge',[_c('a',{attrs:{"slot":"content","href":_vm.localSDPURL,"download":"localSDP.txt"},slot:"content"},[_vm._v("localSDP")])]):_vm._e()],1)])}
-var Playervue_type_template_id_70987c50_scoped_true_staticRenderFns = []
-
-
-// CONCATENATED MODULE: ./src/components/Player.vue?vue&type=template&id=70987c50&scoped=true&
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/components/Player.vue?vue&type=script&lang=js&
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-
-let pc = null;
-/* harmony default export */ var Playervue_type_script_lang_js_ = ({
-  data() {
-    return {
-      iceConnectionState: pc && pc.iceConnectionState,
-      stream: null,
-      localSDP: "",
-      remoteSDP: "",
-      remoteSDPURL: "",
-      localSDPURL: "",
-      streamPath: ""
-    };
-  },
-props:{
-  PublicIP:String
-},
-    methods: {
-        async play(streamPath) {
-            pc = new RTCPeerConnection();
-            pc.addTransceiver('video',{
-              direction:'recvonly'
-            })
-            this.streamPath = streamPath;
-            pc.onsignalingstatechange = e => {
-                //console.log(e);
-            };
-            pc.oniceconnectionstatechange = e => {
-                this.$toast.info(pc.iceConnectionState);
-                this.iceConnectionState = pc.iceConnectionState;
-            };
-            pc.onicecandidate = event => {
-                console.log(event)
-            };
-            pc.ontrack = event => {
-               // console.log(event);
-                if (event.track.kind == "video")
-                    this.stream = event.streams[0];
-            };
-            await pc.setLocalDescription(await pc.createOffer());
-            this.localSDP = pc.localDescription.sdp;
-            this.localSDPURL = URL.createObjectURL(
-                new Blob([this.localSDP], { type: "text/plain" })
-            );
-            const result = await this.ajax({
-                type: "POST",
-                processData: false,
-                data: JSON.stringify(pc.localDescription.toJSON()),
-                url: "/webrtc/play?streamPath=" + this.streamPath,
-                dataType: "json"
-            });
-            if (result.errmsg) {
-                this.$toast.error(result.errmsg);
-                return;
-            } else {
-                this.remoteSDP = result.sdp;
-                this.remoteSDPURL = URL.createObjectURL(new Blob([this.remoteSDP], { type: "text/plain" }));
-            }
-            await pc.setRemoteDescription(new RTCSessionDescription(result));
-        },
-        onClosePreview() {
-            pc.close();
-        }
-    }
-});
-
-// CONCATENATED MODULE: ./src/components/Player.vue?vue&type=script&lang=js&
- /* harmony default export */ var components_Playervue_type_script_lang_js_ = (Playervue_type_script_lang_js_); 
-// EXTERNAL MODULE: ./src/components/Player.vue?vue&type=style&index=0&id=70987c50&scoped=true&lang=css&
-var Playervue_type_style_index_0_id_70987c50_scoped_true_lang_css_ = __webpack_require__("b284");
-
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib/runtime/componentNormalizer.js
-/* globals __VUE_SSR_CONTEXT__ */
-
-// IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
-// This module is a runtime utility for cleaner component module output and will
-// be included in the final webpack user bundle.
-
-function normalizeComponent (
-  scriptExports,
-  render,
-  staticRenderFns,
-  functionalTemplate,
-  injectStyles,
-  scopeId,
-  moduleIdentifier, /* server only */
-  shadowMode /* vue-cli only */
-) {
-  // Vue.extend constructor export interop
-  var options = typeof scriptExports === 'function'
-    ? scriptExports.options
-    : scriptExports
-
-  // render functions
-  if (render) {
-    options.render = render
-    options.staticRenderFns = staticRenderFns
-    options._compiled = true
-  }
-
-  // functional template
-  if (functionalTemplate) {
-    options.functional = true
-  }
-
-  // scopedId
-  if (scopeId) {
-    options._scopeId = 'data-v-' + scopeId
-  }
-
-  var hook
-  if (moduleIdentifier) { // server build
-    hook = function (context) {
-      // 2.3 injection
-      context =
-        context || // cached call
-        (this.$vnode && this.$vnode.ssrContext) || // stateful
-        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
-      // 2.2 with runInNewContext: true
-      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
-        context = __VUE_SSR_CONTEXT__
-      }
-      // inject component styles
-      if (injectStyles) {
-        injectStyles.call(this, context)
-      }
-      // register component module identifier for async chunk inferrence
-      if (context && context._registeredComponents) {
-        context._registeredComponents.add(moduleIdentifier)
-      }
-    }
-    // used by ssr in case component is cached and beforeCreate
-    // never gets called
-    options._ssrRegister = hook
-  } else if (injectStyles) {
-    hook = shadowMode
-      ? function () {
-        injectStyles.call(
-          this,
-          (options.functional ? this.parent : this).$root.$options.shadowRoot
-        )
-      }
-      : injectStyles
-  }
-
-  if (hook) {
-    if (options.functional) {
-      // for template-only hot-reload because in that case the render fn doesn't
-      // go through the normalizer
-      options._injectStyles = hook
-      // register for functional component in vue file
-      var originalRender = options.render
-      options.render = function renderWithStyleInjection (h, context) {
-        hook.call(context)
-        return originalRender(h, context)
-      }
-    } else {
-      // inject component registration as beforeCreate hook
-      var existing = options.beforeCreate
-      options.beforeCreate = existing
-        ? [].concat(existing, hook)
-        : [hook]
-    }
-  }
-
-  return {
-    exports: scriptExports,
-    options: options
-  }
-}
-
-// CONCATENATED MODULE: ./src/components/Player.vue
-
-
-
-
-
-
-/* normalize component */
-
-var component = normalizeComponent(
-  components_Playervue_type_script_lang_js_,
-  Playervue_type_template_id_70987c50_scoped_true_render,
-  Playervue_type_template_id_70987c50_scoped_true_staticRenderFns,
-  false,
-  null,
-  "70987c50",
-  null
-  
-)
-
-/* harmony default export */ var Player = (component.exports);
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/cache-loader/dist/cjs.js??ref--0-0!C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/vue-loader/lib??vue-loader-options!./src/App.vue?vue&type=script&lang=js&
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-
-
-/* harmony default export */ var Appvue_type_script_lang_js_ = ({
-  components:{
-    WebrtcPlayer: Player
-  },
-  props:{
-    ListenAddr:String
-  },
-  computed:{
-    PublicIP(){
-      return this.ListenAddr.split(":")[0]
-    }
-  },
-  data() {
-    return {
-      Devices: [], previewStreamPath:false,
-      context:{
-        id:null,
-        channel:0,
-        item:null
-      },
-      columns: Object.freeze(
-          ["设备号", "通道数", "注册时间", "更新时间", "状态"].map(
-              (title) => ({
-                title,
-              })
-          )
-      ),
-      columns2: Object.freeze([
-        "通道编号",
-        "名称",
-        "厂商",
-        "地址",
-        "状态",
-        "操作",
-      ]).map((title) => ({title})),
-      ptzCmds:["A50F010800880045","A50F01018800003E", "A50F010400880041","A50F01028800003F"]
-    };
-  },
-  created() {
-    this.fetchlist();
-  },
-  methods: {
-    fetchlist() {
-      const listES = new EventSource(this.apiHost + "/gb28181/list");
-      listES.onmessage = (evt) => {
-        if (!evt.data) return;
-        this.Devices = JSON.parse(evt.data) || [];
-        this.Devices.sort((a, b) => (a.ID > b.ID ? 1 : -1));
-      };
-      this.$once("hook:destroyed", () => listES.close());
-    },
-    ptz(id, channel,item) {
-      this.context = {
-        id,channel,item
-      }
-      this.previewStreamPath = true
-      this.$nextTick(() =>this.$refs.player.play("gb28181/"+item.DeviceID));
-    },
-    sendPtz(n){
-      this.ajax.get("/gb28181/control", {
-        id:this.context.id,
-        channel:this.context.channel,
-        ptzcmd: this.ptzCmds[n-1],
-      }).then(x=>{
-        setTimeout(()=>{
-          this.ajax.get("/gb28181/control", {
-            id:this.context.id,
-            channel:this.context.channel,
-            ptzcmd: "A50F0100000000B5",
-          });
-        },500)
-      });
-    },
-    invite(id, channel,item) {
-      this.ajax.get("/gb28181/invite", {id, channel}).then(x=>{
-        item.Connected = true
-      });
-    },
-    bye(id, channel,item) {
-      this.ajax.get("/gb28181/bye", {id, channel}).then(x=>{
-        item.Connected = false
-      });;
-    }
-  },
-});
-
-// CONCATENATED MODULE: ./src/App.vue?vue&type=script&lang=js&
- /* harmony default export */ var src_Appvue_type_script_lang_js_ = (Appvue_type_script_lang_js_); 
-// CONCATENATED MODULE: ./src/App.vue
-
-
-
-
-
-/* normalize component */
-
-var App_component = normalizeComponent(
-  src_Appvue_type_script_lang_js_,
-  render,
-  staticRenderFns,
-  false,
-  null,
-  null,
-  null
-  
-)
-
-/* harmony default export */ var App = (App_component.exports);
-// CONCATENATED MODULE: C:/Users/dexte/go/src/github.com/Monibuca/plugin-webrtc/ui/node_modules/@vue/cli-service/lib/commands/build/entry-lib.js
-
-
-/* harmony default export */ var entry_lib = __webpack_exports__["default"] = (App);
-
-
-
-/***/ }),
-
-/***/ "f3a8":
-/***/ (function(module, exports, __webpack_require__) {
-
-var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;// addapted from the document.currentScript polyfill by Adam Miller
-// MIT license
-// source: https://github.com/amiller-gh/currentScript-polyfill
-
-// added support for Firefox https://bugzilla.mozilla.org/show_bug.cgi?id=1620505
-
-(function (root, factory) {
-  if (true) {
-    !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory),
-				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
-				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
-				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-  } else {}
-}(typeof self !== 'undefined' ? self : this, function () {
-  function getCurrentScript () {
-    if (document.currentScript) {
-      return document.currentScript
-    }
-  
-    // IE 8-10 support script readyState
-    // IE 11+ & Firefox support stack trace
-    try {
-      throw new Error();
-    }
-    catch (err) {
-      // Find the second match for the "at" string to get file src url from stack.
-      var ieStackRegExp = /.*at [^(]*\((.*):(.+):(.+)\)$/ig,
-        ffStackRegExp = /@([^@]*):(\d+):(\d+)\s*$/ig,
-        stackDetails = ieStackRegExp.exec(err.stack) || ffStackRegExp.exec(err.stack),
-        scriptLocation = (stackDetails && stackDetails[1]) || false,
-        line = (stackDetails && stackDetails[2]) || false,
-        currentLocation = document.location.href.replace(document.location.hash, ''),
-        pageSource,
-        inlineScriptSourceRegExp,
-        inlineScriptSource,
-        scripts = document.getElementsByTagName('script'); // Live NodeList collection
-  
-      if (scriptLocation === currentLocation) {
-        pageSource = document.documentElement.outerHTML;
-        inlineScriptSourceRegExp = new RegExp('(?:[^\\n]+?\\n){0,' + (line - 2) + '}[^<]*<script>([\\d\\D]*?)<\\/script>[\\d\\D]*', 'i');
-        inlineScriptSource = pageSource.replace(inlineScriptSourceRegExp, '$1').trim();
-      }
-  
-      for (var i = 0; i < scripts.length; i++) {
-        // If ready state is interactive, return the script tag
-        if (scripts[i].readyState === 'interactive') {
-          return scripts[i];
-        }
-  
-        // If src matches, return the script tag
-        if (scripts[i].src === scriptLocation) {
-          return scripts[i];
-        }
-  
-        // If inline source matches, return the script tag
-        if (
-          scriptLocation === currentLocation &&
-          scripts[i].innerHTML &&
-          scripts[i].innerHTML.trim() === inlineScriptSource
-        ) {
-          return scripts[i];
-        }
-      }
-  
-      // If no match, return null
-      return null;
-    }
-  };
-
-  return getCurrentScript
-}));
-
-
-/***/ })
-
-/******/ })["default"];
-});
-//# sourceMappingURL=plugin-gb28181.umd.js.map

ui/package.json

@@ -1,15 +0,0 @@
-{
-  "name": "dashboard",
-  "version": "1.0.0",
-  "description": "dashboard of gb28181 plugin for monibuca",
-  "main": "index.js",
-  "scripts": {
-    "build": "vue-cli-service build --target lib --name plugin-gb28181"
-  },
-  "author": "dexter",
-  "license": "ISC",
-  "devDependencies": {
-    "@vue/cli-service": "^4.5.4",
-    "vue-template-compiler": "^2.6.12"
-  }
-}

ui/src/App.vue

@@ -1,125 +0,0 @@
-<template>
-  <div>
-    <mu-data-table :data="Devices" :columns="columns">
-      <template #expand="prop">
-        <mu-data-table :data="prop.row.Channels" :columns="columns2">
-          <template #default="{ row: item, $index }">
-            <td>{{ item.DeviceID }}</td>
-            <td>{{ item.Name }}</td>
-            <td>{{ item.Manufacturer }}</td>
-            <td>{{ item.Address }}</td>
-            <td>{{ item.Status }}</td>
-            <td>
-              <mu-button flat v-if="item.Connected" @click="ptz(prop.row.ID, $index,item)">云台</mu-button>
-              <mu-button flat v-if="item.Connected" @click="bye(prop.row.ID, $index)">断开</mu-button>
-              <mu-button v-else flat @click="invite(prop.row.ID, $index,item)"
-              >连接
-              </mu-button
-              >
-            </td>
-          </template>
-        </mu-data-table>
-      </template>
-      <template #default="{ row: item }">
-        <td>{{ item.ID }}</td>
-        <td>{{ item.Channels ? item.Channels.length : 0 }}</td>
-        <td>
-          <StartTime :value="item.RegisterTime"></StartTime>
-        </td>
-        <td>
-          <StartTime :value="item.UpdateTime"></StartTime>
-        </td>
-        <td>{{ item.Status }}</td>
-      </template>
-    </mu-data-table>
-    <webrtc-player ref="player" @ptz="sendPtz" v-model="previewStreamPath" :PublicIP="PublicIP"></webrtc-player>
-  </div>
-</template>
-<script>
-import WebrtcPlayer from "./components/Player"
-export default {
-  components:{
-    WebrtcPlayer
-  },
-  props:{
-    ListenAddr:String
-  },
-  computed:{
-    PublicIP(){
-      return this.ListenAddr.split(":")[0]
-    }
-  },
-  data() {
-    return {
-      Devices: [], previewStreamPath:false,
-      context:{
-        id:null,
-        channel:0,
-        item:null
-      },
-      columns: Object.freeze(
-          ["设备号", "通道数", "注册时间", "更新时间", "状态"].map(
-              (title) => ({
-                title,
-              })
-          )
-      ),
-      columns2: Object.freeze([
-        "通道编号",
-        "名称",
-        "厂商",
-        "地址",
-        "状态",
-        "操作",
-      ]).map((title) => ({title})),
-      ptzCmds:["A50F010800880045","A50F01018800003E", "A50F010400880041","A50F01028800003F"]
-    };
-  },
-  created() {
-    this.fetchlist();
-  },
-  methods: {
-    fetchlist() {
-      const listES = new EventSource(this.apiHost + "/gb28181/list");
-      listES.onmessage = (evt) => {
-        if (!evt.data) return;
-        this.Devices = JSON.parse(evt.data) || [];
-        this.Devices.sort((a, b) => (a.ID > b.ID ? 1 : -1));
-      };
-      this.$once("hook:destroyed", () => listES.close());
-    },
-    ptz(id, channel,item) {
-      this.context = {
-        id,channel,item
-      }
-      this.previewStreamPath = true
-      this.$nextTick(() =>this.$refs.player.play("gb28181/"+item.DeviceID));
-    },
-    sendPtz(n){
-      this.ajax.get("/gb28181/control", {
-        id:this.context.id,
-        channel:this.context.channel,
-        ptzcmd: this.ptzCmds[n-1],
-      }).then(x=>{
-        setTimeout(()=>{
-          this.ajax.get("/gb28181/control", {
-            id:this.context.id,
-            channel:this.context.channel,
-            ptzcmd: "A50F0100000000B5",
-          });
-        },500)
-      });
-    },
-    invite(id, channel,item) {
-      this.ajax.get("/gb28181/invite", {id, channel}).then(x=>{
-        item.Connected = true
-      });
-    },
-    bye(id, channel,item) {
-      this.ajax.get("/gb28181/bye", {id, channel}).then(x=>{
-        item.Connected = false
-      });;
-    }
-  },
-};
-</script>

ui/src/components/Player.vue

@@ -1,132 +0,0 @@
-<template>
-  <Modal
-    v-bind="$attrs"
-    draggable
-    v-on="$listeners"
-    :title="streamPath"
-    @on-ok="onClosePreview"
-    @on-cancel="onClosePreview"
-  >
-    <div class="container">
-      <video ref="webrtc" :srcObject.prop="stream" width="488" height="275" autoplay muted controls></video>
-      <div class="control">
-        <svg @click="$emit('ptz',n)" v-for="n in 4" :class="'arrow'+n" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="64" height="64"><defs><style type="text/css"></style></defs><path d="M682.666667 955.733333H341.333333a17.066667 17.066667 0 0 1-17.066666-17.066666V529.066667H85.333333a17.066667 17.066667 0 0 1-12.066133-29.1328l426.666667-426.666667a17.0496 17.0496 0 0 1 24.132266 0l426.666667 426.666667A17.066667 17.066667 0 0 1 938.666667 529.066667H699.733333v409.6a17.066667 17.066667 0 0 1-17.066666 17.066666z m-324.266667-34.133333h307.2V512a17.066667 17.066667 0 0 1 17.066667-17.066667h214.801066L512 109.4656 126.532267 494.933333H341.333333a17.066667 17.066667 0 0 1 17.066667 17.066667v409.6z" p-id="6849"></path></svg>
-      </div>
-    </div>
-    <div slot="footer">
-      <mu-badge v-if="remoteSDP">
-        <a slot="content" :href="remoteSDPURL" download="remoteSDP.txt">remoteSDP</a>
-      </mu-badge>
-      <mu-badge v-if="localSDP">
-        <a slot="content" :href="localSDPURL" download="localSDP.txt">localSDP</a>
-      </mu-badge>
-    </div>
-  </Modal>
-</template>
-<script>
-let pc = null;
-export default {
-  data() {
-    return {
-      iceConnectionState: pc && pc.iceConnectionState,
-      stream: null,
-      localSDP: "",
-      remoteSDP: "",
-      remoteSDPURL: "",
-      localSDPURL: "",
-      streamPath: ""
-    };
-  },
-props:{
-  PublicIP:String
-},
-    methods: {
-        async play(streamPath) {
-            pc = new RTCPeerConnection();
-            pc.addTransceiver('video',{
-              direction:'recvonly'
-            })
-            this.streamPath = streamPath;
-            pc.onsignalingstatechange = e => {
-                //console.log(e);
-            };
-            pc.oniceconnectionstatechange = e => {
-                this.$toast.info(pc.iceConnectionState);
-                this.iceConnectionState = pc.iceConnectionState;
-            };
-            pc.onicecandidate = event => {
-                console.log(event)
-            };
-            pc.ontrack = event => {
-               // console.log(event);
-                if (event.track.kind == "video")
-                    this.stream = event.streams[0];
-            };
-            await pc.setLocalDescription(await pc.createOffer());
-            this.localSDP = pc.localDescription.sdp;
-            this.localSDPURL = URL.createObjectURL(
-                new Blob([this.localSDP], { type: "text/plain" })
-            );
-            const result = await this.ajax({
-                type: "POST",
-                processData: false,
-                data: JSON.stringify(pc.localDescription.toJSON()),
-                url: "/webrtc/play?streamPath=" + this.streamPath,
-                dataType: "json"
-            });
-            if (result.errmsg) {
-                this.$toast.error(result.errmsg);
-                return;
-            } else {
-                this.remoteSDP = result.sdp;
-                this.remoteSDPURL = URL.createObjectURL(new Blob([this.remoteSDP], { type: "text/plain" }));
-            }
-            await pc.setRemoteDescription(new RTCSessionDescription(result));
-        },
-        onClosePreview() {
-            pc.close();
-        }
-    }
-};
-</script>
-<style scoped>
-.arrow1{
-  grid-column: 2;
-  grid-row: 1;
-}
-.arrow2{
-  transform: rotate(90deg);
-  grid-column: 3;
-  grid-row: 2;
-}
-.arrow3{
-  transform: rotate(180deg);
-  grid-column: 2;
-  grid-row: 3;
-}
-.arrow4{
-  transform: rotate(270deg);
-  grid-column: 1;
-  grid-row: 2;
-}
-.container {
-  position: relative;
-}
-.control {
-  position: absolute;
-  bottom: 0;
-  right: 0;
-  display: grid;
-  grid-template-columns: repeat(3, 33.33%);
-  grid-template-rows: repeat(3, 33.33%);
-  width: 192px;
-  height: 192px;
-}
-.control >* {
-  cursor: pointer;
-  fill: gray;
-}
-.control >*:hover{
-  fill: cyan
-}
-</style>

utils/buffer.go

@@ -0,0 +1,100 @@
+package utils
+
+import (
+	"encoding/binary"
+	"errors"
+	"io"
+)
+
+type IOBuffer struct {
+	buf []byte // contents are the bytes buf[off : len(buf)]
+	off int    // read at &buf[off], write at &buf[len(buf)]
+}
+
+func (b *IOBuffer) Next(n int) []byte {
+	m := b.Len()
+	if n > m {
+		n = m
+	}
+	data := b.buf[b.off : b.off+n]
+	b.off += n
+	return data
+}
+func (b *IOBuffer) Uint16() (uint16, error) {
+	if b.Len() > 1 {
+
+		return binary.BigEndian.Uint16(b.Next(2)), nil
+	}
+	return 0, io.EOF
+}
+
+func (b *IOBuffer) Skip(n int) (err error) {
+	_, err = b.ReadN(n)
+	return
+}
+
+func (b *IOBuffer) Uint32() (uint32, error) {
+	if b.Len() > 3 {
+		return binary.BigEndian.Uint32(b.Next(4)), nil
+	}
+	return 0, io.EOF
+}
+
+func (b *IOBuffer) ReadN(length int) ([]byte, error) {
+	if b.Len() >= length {
+		return b.Next(length), nil
+	}
+	return nil, io.EOF
+}
+
+// empty reports whether the unread portion of the buffer is empty.
+func (b *IOBuffer) empty() bool { return b.Len() <= b.off }
+
+func (b *IOBuffer) ReadByte() (byte, error) {
+	if b.empty() {
+		// Buffer is empty, reset to recover space.
+		b.Reset()
+		return 0, io.EOF
+	}
+	c := b.buf[b.off]
+	b.off++
+	return c, nil
+}
+func (b *IOBuffer) Reset() {
+	b.buf = b.buf[:0]
+	b.off = 0
+}
+
+func (b *IOBuffer) Len() int { return len(b.buf) - b.off }
+
+// tryGrowByReslice is a inlineable version of grow for the fast-case where the
+// internal buffer only needs to be resliced.
+// It returns the index where bytes should be written and whether it succeeded.
+func (b *IOBuffer) tryGrowByReslice(n int) (int, bool) {
+	if l := len(b.buf); n <= cap(b.buf)-l {
+		b.buf = b.buf[:l+n]
+		return l, true
+	}
+	return 0, false
+}
+
+var ErrTooLarge = errors.New("bytes.Buffer: too large")
+
+func (b *IOBuffer) Write(p []byte) (n int, err error) {
+	defer func() {
+		if recover() != nil {
+			panic(ErrTooLarge)
+		}
+	}()
+	l := len(p)
+	oldLen := len(b.buf)
+	m, ok := b.tryGrowByReslice(l)
+	if !ok {
+		buf := make([]byte, oldLen+l)
+		copy(buf, b.buf[b.off:])
+		m = oldLen - b.off
+		b.off = 0
+		b.buf = buf
+	}
+	return copy(b.buf[m:], p), nil
+}

utils/ps.go

@@ -0,0 +1,320 @@
+package utils
+
+import (
+	"errors"
+
+	"github.com/Monibuca/utils/v3"
+)
+
+//
+const (
+	UDPTransfer        int = 0
+	TCPTransferActive  int = 1
+	TCPTransferPassive int = 2
+	LocalCache         int = 3
+
+	StreamTypeH264 = 0x1b
+	StreamTypeH265 = 0x24
+	G711A          = 0x90 //PCMA
+	G7221AUDIOTYPE = 0x92
+	G7231AUDIOTYPE = 0x93
+	G729AUDIOTYPE  = 0x99
+
+	StreamIDVideo = 0xe0
+	StreamIDAudio = 0xc0
+
+	StartCodePS        = 0x000001ba
+	StartCodeSYS       = 0x000001bb
+	StartCodeMAP       = 0x000001bc
+	StartCodeVideo     = 0x000001e0
+	StartCodeAudio     = 0x000001c0
+	HaiKangCode        = 0x000001bd
+	MEPGProgramEndCode = 0x000001b9
+
+	RTPHeaderLength    int = 12
+	PSHeaderLength     int = 14
+	SystemHeaderLength int = 18
+	MAPHeaderLength    int = 24
+	PESHeaderLength    int = 19
+	RtpLoadLength      int = 1460
+	PESLoadLength      int = 0xFFFF
+	MAXFrameLen        int = 1024 * 1024 * 2
+)
+
+var (
+	ErrNotFoundStartCode = errors.New("not found the need start code flag")
+	ErrMarkerBit         = errors.New("marker bit value error")
+	ErrFormatPack        = errors.New("not package standard")
+	ErrParsePakcet       = errors.New("parse ps packet error")
+)
+
+type Pusher interface {
+	PushVideo(uint32, uint32, []byte)
+	PushAudio(uint32, []byte)
+}
+
+/*
+ This implement from VLC source code
+ notes: https://github.com/videolan/vlc/blob/master/modules/mux/mpeg/bits.h
+*/
+
+//bitsBuffer bits buffer
+// type bitsBuffer struct {
+// 	iSize int
+// 	iData int
+// 	iMask uint8
+// 	pData []byte
+// }
+
+// func bitsInit(isize int, buffer []byte) *bitsBuffer {
+
+// 	bits := &bitsBuffer{
+// 		iSize: isize,
+// 		iData: 0,
+// 		iMask: 0x80,
+// 		pData: buffer,
+// 	}
+// 	if bits.pData == nil {
+// 		bits.pData = make([]byte, isize)
+// 	}
+// 	return bits
+// }
+
+// func bitsAlign(bits *bitsBuffer) {
+
+// 	if bits.iMask != 0x80 && bits.iData < bits.iSize {
+// 		bits.iMask = 0x80
+// 		bits.iData++
+// 		bits.pData[bits.iData] = 0x00
+// 	}
+// }
+// func bitsWrite(bits *bitsBuffer, count int, src uint64) *bitsBuffer {
+
+// 	for count > 0 {
+// 		count--
+// 		if ((src >> uint(count)) & 0x01) != 0 {
+// 			bits.pData[bits.iData] |= bits.iMask
+// 		} else {
+// 			bits.pData[bits.iData] &= ^bits.iMask
+// 		}
+// 		bits.iMask >>= 1
+// 		if bits.iMask == 0 {
+// 			bits.iData++
+// 			bits.iMask = 0x80
+// 		}
+// 	}
+
+// 	return bits
+// }
+
+/*
+https://github.com/videolan/vlc/blob/master/modules/demux/mpeg
+*/
+type DecPSPackage struct {
+	systemClockReferenceBase      uint64
+	systemClockReferenceExtension uint64
+	programMuxRate                uint32
+
+	VideoStreamType uint32
+	AudioStreamType uint32
+	IOBuffer
+	Payload []byte
+	PTS     uint32
+	DTS     uint32
+}
+
+func (dec *DecPSPackage) clean() {
+	dec.systemClockReferenceBase = 0
+	dec.systemClockReferenceExtension = 0
+	dec.programMuxRate = 0
+	dec.Payload = nil
+	dec.PTS = 0
+	dec.DTS = 0
+}
+
+func (dec *DecPSPackage) ReadPayload() (payload []byte, err error) {
+	payloadlen, err := dec.Uint16()
+	if err != nil {
+		return
+	}
+	return dec.ReadN(int(payloadlen))
+}
+
+func (dec *DecPSPackage) Read(ts uint32, pusher Pusher) error {
+	var nextStartCode uint32
+	dec.clean()
+
+	if err := dec.Skip(9); err != nil {
+		return err
+	}
+
+	psl, err := dec.ReadByte()
+	if err != nil {
+		return err
+	}
+	psl &= 0x07
+	if err = dec.Skip(int(psl)); err != nil {
+		return err
+	}
+	var video []byte
+	var videoTs, videoCts uint32
+	defer func() {
+		if video != nil {
+			pusher.PushVideo(videoTs, videoCts, video)
+			video = nil
+		}
+		if nextStartCode == StartCodePS {
+			err = dec.Read(ts, pusher)
+		}
+	}()
+	for err == nil {
+		nextStartCode, err = dec.Uint32()
+		if err != nil {
+			return err
+		}
+		switch nextStartCode {
+		case StartCodeSYS:
+			dec.ReadPayload()
+			//err = dec.decSystemHeader()
+		case StartCodeMAP:
+			err = dec.decProgramStreamMap()
+		case StartCodeVideo:
+			var cts uint32
+			if err = dec.decPESPacket(); err == nil {
+				if video == nil {
+					if dec.PTS == 0 {
+						dec.PTS = ts
+					}
+					if dec.DTS != 0 {
+						cts = dec.PTS - dec.DTS
+					} else {
+						dec.DTS = dec.PTS
+					}
+					videoTs = dec.DTS / 90
+					videoCts = cts / 90
+				}
+				video = append(video, dec.Payload...)
+			} else {
+				utils.Println("video", err)
+			}
+		case StartCodeAudio:
+			if err = dec.decPESPacket(); err == nil {
+				var payload []byte
+				ts := ts  / 90
+				if dec.PTS != 0 {
+					ts = dec.PTS / 90
+				}
+				pusher.PushAudio(ts, append(payload, dec.Payload...))
+			} else {
+				utils.Println("audio", err)
+			}
+		case StartCodePS:
+			return nil
+		default:
+			dec.ReadPayload()
+		}
+	}
+	return err
+}
+
+/*
+func (dec *DecPSPackage) decSystemHeader() error {
+	syslens, err := dec.Uint16()
+	if err != nil {
+		return err
+	}
+	// drop rate video audio bound and lock flag
+	syslens -= 6
+	if err = dec.Skip(6); err != nil {
+		return err
+	}
+
+	// ONE WAY: do not to parse the stream  and skip the buffer
+	//br.Skip(syslen * 8)
+
+	// TWO WAY: parse every stream info
+	for syslens > 0 {
+		if nextbits, err := dec.Uint8(); err != nil {
+			return err
+		} else if (nextbits&0x80)>>7 != 1 {
+			break
+		}
+		if err = dec.Skip(2); err != nil {
+			return err
+		}
+		syslens -= 3
+	}
+	return nil
+}
+*/
+func (dec *DecPSPackage) decProgramStreamMap() error {
+	psm, err := dec.ReadPayload()
+	if err != nil {
+		return err
+	}
+	l := len(psm)
+	index := 2
+	programStreamInfoLen := utils.BigEndian.Uint16(psm[index:])
+	index += 2
+	index += int(programStreamInfoLen)
+	programStreamMapLen := utils.BigEndian.Uint16(psm[index:])
+	index += 2
+	for programStreamMapLen > 0 {
+		if l <= index+1 {
+			break
+		}
+		streamType := psm[index]
+		index++
+		elementaryStreamID := psm[index]
+		index++
+		if elementaryStreamID >= 0xe0 && elementaryStreamID <= 0xef {
+			dec.VideoStreamType = uint32(streamType)
+		} else if elementaryStreamID >= 0xc0 && elementaryStreamID <= 0xdf {
+			dec.AudioStreamType = uint32(streamType)
+		}
+		if l <= index+1 {
+			break
+		}
+		elementaryStreamInfoLength := utils.BigEndian.Uint16(psm[index:])
+		index += 2
+		index += int(elementaryStreamInfoLength)
+		programStreamMapLen -= 4 + elementaryStreamInfoLength
+	}
+	return nil
+}
+
+func (dec *DecPSPackage) decPESPacket() error {
+	payload, err := dec.ReadPayload()
+	if err != nil {
+		return err
+	}
+	if len(payload) < 4 {
+		return errors.New("not enough data")
+	}
+	//data_alignment_indicator := (payload[0]&0b0001_0000)>>4 == 1
+	flag := payload[1]
+	ptsFlag := flag>>7 == 1
+	dtsFlag := (flag&0b0100_0000)>>6 == 1
+	var pts, dts uint32
+	pesHeaderDataLen := payload[2]
+	payload = payload[3:]
+	extraData := payload[:pesHeaderDataLen]
+	if ptsFlag && len(extraData) > 4 {
+		pts = uint32(extraData[0]&0b0000_1110) << 29
+		pts += uint32(extraData[1]) << 22
+		pts += uint32(extraData[2]&0b1111_1110) << 14
+		pts += uint32(extraData[3]) << 7
+		pts += uint32(extraData[4]) >> 1
+		if dtsFlag && len(extraData) > 9 {
+			dts = uint32(extraData[5]&0b0000_1110) << 29
+			dts += uint32(extraData[6]) << 22
+			dts += uint32(extraData[7]&0b1111_1110) << 14
+			dts += uint32(extraData[8]) << 7
+			dts += uint32(extraData[9]) >> 1
+		}
+	}
+	dec.PTS = pts
+	dec.DTS = dts
+	dec.Payload = payload[pesHeaderDataLen:]
+	return err
+}

utils/rtp_sort.go

@@ -0,0 +1,97 @@
+package utils
+
+import (
+	"container/heap"
+	"errors"
+	"github.com/pion/rtp"
+)
+
+const MaxRtpDiff = 65000 //相邻两个包之间的最大差值
+
+type PriorityQueueRtp struct {
+	itemHeap    *packets
+	current     *rtp.Packet
+	priorityMap map[uint16]bool
+	lastPacket  *rtp.Packet
+}
+
+func NewPqRtp() *PriorityQueueRtp {
+	return &PriorityQueueRtp{
+		itemHeap:    &packets{},
+		priorityMap: make(map[uint16]bool),
+	}
+}
+
+func (p *PriorityQueueRtp) Len() int {
+	return p.itemHeap.Len()
+}
+
+func (p *PriorityQueueRtp) Push(v rtp.Packet) {
+	if p.priorityMap[v.SequenceNumber] {
+		return
+	}
+	newItem := &packet{
+		value:    v,
+		priority: v.SequenceNumber,
+	}
+	heap.Push(p.itemHeap, newItem)
+}
+
+func (p *PriorityQueueRtp) Pop() (rtp.Packet, error) {
+	if len(*p.itemHeap) == 0 {
+		return rtp.Packet{}, errors.New("empty queue")
+	}
+
+	item := heap.Pop(p.itemHeap).(*packet)
+	return item.value, nil
+}
+
+func (p *PriorityQueueRtp) Empty() {
+	old := *p.itemHeap
+	*p.itemHeap = old[:0]
+}
+
+type packets []*packet
+
+type packet struct {
+	value    rtp.Packet
+	priority uint16
+	index    int
+}
+
+func (p *packets) Len() int {
+	return len(*p)
+}
+
+func (p *packets) Less(i, j int) bool {
+	a, b := (*p)[i].priority, (*p)[j].priority
+	if int(a)-int(b) > MaxRtpDiff || int(b)-int(a) > MaxRtpDiff {
+		if a < b {
+			return false
+		}
+		return true
+	}
+	return a < b
+}
+
+func (p *packets) Swap(i, j int) {
+	(*p)[i], (*p)[j] = (*p)[j], (*p)[i]
+	(*p)[i].index = i
+	(*p)[j].index = j
+}
+
+func (p *packets) Push(x interface{}) {
+	it := x.(*packet)
+	it.index = len(*p)
+	*p = append(*p, it)
+}
+
+func (p *packets) Pop() interface{} {
+	old := *p
+	n := len(old)
+	item := old[n-1]
+	old[n-1] = nil  // avoid memory leak
+	item.index = -1 // for safety
+	*p = old[0 : n-1]
+	return item
+}

utils/string.go

@@ -1,6 +1,14 @@
 package utils
 
-import "encoding/json"
+import (
+    "bytes"
+    "encoding/json"
+    "encoding/xml"
+    "golang.org/x/net/html/charset"
+    "golang.org/x/text/encoding/simplifiedchinese"
+    "golang.org/x/text/transform"
+    "io/ioutil"
+)
 
 func ToJSONString(v interface{}) string {
 	b, _ := json.Marshal(v)
@@ -11,3 +19,23 @@ func ToPrettyString(v interface{}) string {
 	b, _ := json.MarshalIndent(v, "", "    ")
 	return string(b)
 }
+
+func GbkToUtf8(s []byte) ([]byte, error) {
+    reader := transform.NewReader(bytes.NewReader(s), simplifiedchinese.GBK.NewDecoder())
+    d, e := ioutil.ReadAll(reader)
+    if e != nil {
+        return s, e
+    }
+    return d, nil
+}
+
+func DecodeGbk(v interface{}, body []byte) error {
+    bodyBytes, err := GbkToUtf8(body)
+    if err != nil {
+        return err
+    }
+    decoder := xml.NewDecoder(bytes.NewReader(bodyBytes))
+    decoder.CharsetReader = charset.NewReaderLabel
+    err = decoder.Decode(v)
+    return err
+}

yarn.lock

@@ -0,0 +1,4 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+