From 36246afe8caf04fdfacea0a320fe69b70417040d Mon Sep 17 00:00:00 2001 From: Mark Qvist Date: Tue, 11 Mar 2025 16:41:15 +0100 Subject: [PATCH] Public repo init --- .gitignore | 10 + LICENSE | 403 ++++ LXST/Call.py | 55 + LXST/Codecs/Codec.py | 62 + LXST/Codecs/Codec2.py | 120 + LXST/Codecs/Opus.py | 179 ++ LXST/Codecs/Raw.py | 58 + LXST/Codecs/__init__.py | 29 + LXST/Codecs/libs/pydub/__init__.py | 1 + LXST/Codecs/libs/pydub/audio_segment.py | 1399 +++++++++++ LXST/Codecs/libs/pydub/effects.py | 341 +++ LXST/Codecs/libs/pydub/exceptions.py | 32 + LXST/Codecs/libs/pydub/generators.py | 142 ++ LXST/Codecs/libs/pydub/logging_utils.py | 14 + LXST/Codecs/libs/pydub/playback.py | 71 + LXST/Codecs/libs/pydub/pyaudioop.py | 591 +++++ LXST/Codecs/libs/pydub/scipy_effects.py | 175 ++ LXST/Codecs/libs/pydub/silence.py | 182 ++ LXST/Codecs/libs/pydub/utils.py | 434 ++++ LXST/Codecs/libs/pyogg/__init__.py | 108 + LXST/Codecs/libs/pyogg/audio_file.py | 59 + LXST/Codecs/libs/pyogg/flac.py | 2061 +++++++++++++++++ LXST/Codecs/libs/pyogg/flac_file.py | 114 + LXST/Codecs/libs/pyogg/flac_file_stream.py | 141 ++ LXST/Codecs/libs/pyogg/library_loader.py | 147 ++ LXST/Codecs/libs/pyogg/ogg.py | 672 ++++++ LXST/Codecs/libs/pyogg/ogg_opus_writer.py | 421 ++++ LXST/Codecs/libs/pyogg/opus.py | 1377 +++++++++++ .../libs/pyogg/opus_buffered_encoder.py | 407 ++++ LXST/Codecs/libs/pyogg/opus_decoder.py | 273 +++ LXST/Codecs/libs/pyogg/opus_encoder.py | 358 +++ LXST/Codecs/libs/pyogg/opus_file.py | 106 + LXST/Codecs/libs/pyogg/opus_file_stream.py | 127 + LXST/Codecs/libs/pyogg/py.typed | 1 + LXST/Codecs/libs/pyogg/pyogg_error.py | 2 + LXST/Codecs/libs/pyogg/vorbis.py | 855 +++++++ LXST/Codecs/libs/pyogg/vorbis_file.py | 161 ++ LXST/Codecs/libs/pyogg/vorbis_file_stream.py | 110 + LXST/Common.py | 2 + LXST/Generators.py | 135 ++ LXST/Mixer.py | 149 ++ LXST/Network.py | 149 ++ LXST/Pipeline.py | 60 + LXST/Primitives/Telephony.py | 501 ++++ LXST/Primitives/__init__.py | 1 + .../hardware/display_i2c_lcd1602.py | 100 + LXST/Primitives/hardware/keypad_gpio_4x4.py | 130 ++ LXST/Processing.py | 0 LXST/Sinks.py | 136 ++ LXST/Sources.py | 270 +++ LXST/Utilities/rnphone.py | 787 +++++++ LXST/__init__.py | 7 + LXST/_version.py | 1 + Makefile | 30 + README.md | 49 + docs/425.opus | Bin 0 -> 967538 bytes docs/rns_audio_call_calc.py | 140 ++ docs/speech.opus | Bin 0 -> 348609 bytes docs/speech_stereo.opus | Bin 0 -> 348577 bytes examples/mixer.py | 51 + examples/pipelines.py | 48 + examples/tone_generator.py | 15 + requirements.txt | 3 + setup.py | 42 + 64 files changed, 14604 insertions(+) create mode 100755 .gitignore create mode 100644 LICENSE create mode 100644 LXST/Call.py create mode 100644 LXST/Codecs/Codec.py create mode 100644 LXST/Codecs/Codec2.py create mode 100644 LXST/Codecs/Opus.py create mode 100644 LXST/Codecs/Raw.py create mode 100644 LXST/Codecs/__init__.py create mode 100644 LXST/Codecs/libs/pydub/__init__.py create mode 100644 LXST/Codecs/libs/pydub/audio_segment.py create mode 100644 LXST/Codecs/libs/pydub/effects.py create mode 100644 LXST/Codecs/libs/pydub/exceptions.py create mode 100644 LXST/Codecs/libs/pydub/generators.py create mode 100644 LXST/Codecs/libs/pydub/logging_utils.py create mode 100644 LXST/Codecs/libs/pydub/playback.py create mode 100644 LXST/Codecs/libs/pydub/pyaudioop.py create mode 100644 LXST/Codecs/libs/pydub/scipy_effects.py create mode 100644 LXST/Codecs/libs/pydub/silence.py create mode 100644 LXST/Codecs/libs/pydub/utils.py create mode 100644 LXST/Codecs/libs/pyogg/__init__.py create mode 100644 LXST/Codecs/libs/pyogg/audio_file.py create mode 100644 LXST/Codecs/libs/pyogg/flac.py create mode 100644 LXST/Codecs/libs/pyogg/flac_file.py create mode 100644 LXST/Codecs/libs/pyogg/flac_file_stream.py create mode 100644 LXST/Codecs/libs/pyogg/library_loader.py create mode 100644 LXST/Codecs/libs/pyogg/ogg.py create mode 100644 LXST/Codecs/libs/pyogg/ogg_opus_writer.py create mode 100644 LXST/Codecs/libs/pyogg/opus.py create mode 100644 LXST/Codecs/libs/pyogg/opus_buffered_encoder.py create mode 100644 LXST/Codecs/libs/pyogg/opus_decoder.py create mode 100644 LXST/Codecs/libs/pyogg/opus_encoder.py create mode 100644 LXST/Codecs/libs/pyogg/opus_file.py create mode 100644 LXST/Codecs/libs/pyogg/opus_file_stream.py create mode 100644 LXST/Codecs/libs/pyogg/py.typed create mode 100644 LXST/Codecs/libs/pyogg/pyogg_error.py create mode 100644 LXST/Codecs/libs/pyogg/vorbis.py create mode 100644 LXST/Codecs/libs/pyogg/vorbis_file.py create mode 100644 LXST/Codecs/libs/pyogg/vorbis_file_stream.py create mode 100644 LXST/Common.py create mode 100644 LXST/Generators.py create mode 100644 LXST/Mixer.py create mode 100644 LXST/Network.py create mode 100644 LXST/Pipeline.py create mode 100644 LXST/Primitives/Telephony.py create mode 100644 LXST/Primitives/__init__.py create mode 100644 LXST/Primitives/hardware/display_i2c_lcd1602.py create mode 100644 LXST/Primitives/hardware/keypad_gpio_4x4.py create mode 100644 LXST/Processing.py create mode 100644 LXST/Sinks.py create mode 100644 LXST/Sources.py create mode 100644 LXST/Utilities/rnphone.py create mode 100644 LXST/__init__.py create mode 100644 LXST/_version.py create mode 100644 Makefile create mode 100644 README.md create mode 100644 docs/425.opus create mode 100644 docs/rns_audio_call_calc.py create mode 100644 docs/speech.opus create mode 100644 docs/speech_stereo.opus create mode 100644 examples/mixer.py create mode 100644 examples/pipelines.py create mode 100644 examples/tone_generator.py create mode 100644 requirements.txt create mode 100644 setup.py diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..5b80e79 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +*.DS_Store +*.pyc +testutils +build +dist +docs/build +lxst*.egg-info +examples/LXST +LXST/Utilities/LXST +RNS diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..cfe676c --- /dev/null +++ b/LICENSE @@ -0,0 +1,403 @@ +Attribution-NonCommercial-NoDerivatives 4.0 International + +======================================================================= + +Creative Commons Corporation ("Creative Commons") is not a law firm and +does not provide legal services or legal advice. Distribution of +Creative Commons public licenses does not create a lawyer-client or +other relationship. Creative Commons makes its licenses and related +information available on an "as-is" basis. Creative Commons gives no +warranties regarding its licenses, any material licensed under their +terms and conditions, or any related information. Creative Commons +disclaims all liability for damages resulting from their use to the +fullest extent possible. + +Using Creative Commons Public Licenses + +Creative Commons public licenses provide a standard set of terms and +conditions that creators and other rights holders may use to share +original works of authorship and other material subject to copyright +and certain other rights specified in the public license below. The +following considerations are for informational purposes only, are not +exhaustive, and do not form part of our licenses. + + Considerations for licensors: Our public licenses are + intended for use by those authorized to give the public + permission to use material in ways otherwise restricted by + copyright and certain other rights. Our licenses are + irrevocable. Licensors should read and understand the terms + and conditions of the license they choose before applying it. + Licensors should also secure all rights necessary before + applying our licenses so that the public can reuse the + material as expected. Licensors should clearly mark any + material not subject to the license. This includes other CC- + licensed material, or material used under an exception or + limitation to copyright. More considerations for licensors: + wiki.creativecommons.org/Considerations_for_licensors + + Considerations for the public: By using one of our public + licenses, a licensor grants the public permission to use the + licensed material under specified terms and conditions. If + the licensor's permission is not necessary for any reason--for + example, because of any applicable exception or limitation to + copyright--then that use is not regulated by the license. Our + licenses grant only permissions under copyright and certain + other rights that a licensor has authority to grant. Use of + the licensed material may still be restricted for other + reasons, including because others have copyright or other + rights in the material. A licensor may make special requests, + such as asking that all changes be marked or described. + Although not required by our licenses, you are encouraged to + respect those requests where reasonable. More considerations + for the public: + wiki.creativecommons.org/Considerations_for_licensees + +======================================================================= + +Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 +International Public License + +By exercising the Licensed Rights (defined below), You accept and agree +to be bound by the terms and conditions of this Creative Commons +Attribution-NonCommercial-NoDerivatives 4.0 International Public +License ("Public License"). To the extent this Public License may be +interpreted as a contract, You are granted the Licensed Rights in +consideration of Your acceptance of these terms and conditions, and the +Licensor grants You such rights in consideration of benefits the +Licensor receives from making the Licensed Material available under +these terms and conditions. + + +Section 1 -- Definitions. + + a. Adapted Material means material subject to Copyright and Similar + Rights that is derived from or based upon the Licensed Material + and in which the Licensed Material is translated, altered, + arranged, transformed, or otherwise modified in a manner requiring + permission under the Copyright and Similar Rights held by the + Licensor. For purposes of this Public License, where the Licensed + Material is a musical work, performance, or sound recording, + Adapted Material is always produced where the Licensed Material is + synched in timed relation with a moving image. + + b. Copyright and Similar Rights means copyright and/or similar rights + closely related to copyright including, without limitation, + performance, broadcast, sound recording, and Sui Generis Database + Rights, without regard to how the rights are labeled or + categorized. For purposes of this Public License, the rights + specified in Section 2(b)(1)-(2) are not Copyright and Similar + Rights. + + c. Effective Technological Measures means those measures that, in the + absence of proper authority, may not be circumvented under laws + fulfilling obligations under Article 11 of the WIPO Copyright + Treaty adopted on December 20, 1996, and/or similar international + agreements. + + d. Exceptions and Limitations means fair use, fair dealing, and/or + any other exception or limitation to Copyright and Similar Rights + that applies to Your use of the Licensed Material. + + e. Licensed Material means the artistic or literary work, database, + or other material to which the Licensor applied this Public + License. + + f. Licensed Rights means the rights granted to You subject to the + terms and conditions of this Public License, which are limited to + all Copyright and Similar Rights that apply to Your use of the + Licensed Material and that the Licensor has authority to license. + + g. Licensor means the individual(s) or entity(ies) granting rights + under this Public License. + + h. NonCommercial means not primarily intended for or directed towards + commercial advantage or monetary compensation. For purposes of + this Public License, the exchange of the Licensed Material for + other material subject to Copyright and Similar Rights by digital + file-sharing or similar means is NonCommercial provided there is + no payment of monetary compensation in connection with the + exchange. + + i. Share means to provide material to the public by any means or + process that requires permission under the Licensed Rights, such + as reproduction, public display, public performance, distribution, + dissemination, communication, or importation, and to make material + available to the public including in ways that members of the + public may access the material from a place and at a time + individually chosen by them. + + j. Sui Generis Database Rights means rights other than copyright + resulting from Directive 96/9/EC of the European Parliament and of + the Council of 11 March 1996 on the legal protection of databases, + as amended and/or succeeded, as well as other essentially + equivalent rights anywhere in the world. + + k. You means the individual or entity exercising the Licensed Rights + under this Public License. Your has a corresponding meaning. + + +Section 2 -- Scope. + + a. License grant. + + 1. Subject to the terms and conditions of this Public License, + the Licensor hereby grants You a worldwide, royalty-free, + non-sublicensable, non-exclusive, irrevocable license to + exercise the Licensed Rights in the Licensed Material to: + + a. reproduce and Share the Licensed Material, in whole or + in part, for NonCommercial purposes only; and + + b. produce and reproduce, but not Share, Adapted Material + for NonCommercial purposes only. + + 2. Exceptions and Limitations. For the avoidance of doubt, where + Exceptions and Limitations apply to Your use, this Public + License does not apply, and You do not need to comply with + its terms and conditions. + + 3. Term. The term of this Public License is specified in Section + 6(a). + + 4. Media and formats; technical modifications allowed. The + Licensor authorizes You to exercise the Licensed Rights in + all media and formats whether now known or hereafter created, + and to make technical modifications necessary to do so. The + Licensor waives and/or agrees not to assert any right or + authority to forbid You from making technical modifications + necessary to exercise the Licensed Rights, including + technical modifications necessary to circumvent Effective + Technological Measures. For purposes of this Public License, + simply making modifications authorized by this Section 2(a) + (4) never produces Adapted Material. + + 5. Downstream recipients. + + a. Offer from the Licensor -- Licensed Material. Every + recipient of the Licensed Material automatically + receives an offer from the Licensor to exercise the + Licensed Rights under the terms and conditions of this + Public License. + + b. No downstream restrictions. You may not offer or impose + any additional or different terms or conditions on, or + apply any Effective Technological Measures to, the + Licensed Material if doing so restricts exercise of the + Licensed Rights by any recipient of the Licensed + Material. + + 6. No endorsement. Nothing in this Public License constitutes or + may be construed as permission to assert or imply that You + are, or that Your use of the Licensed Material is, connected + with, or sponsored, endorsed, or granted official status by, + the Licensor or others designated to receive attribution as + provided in Section 3(a)(1)(A)(i). + + b. Other rights. + + 1. Moral rights, such as the right of integrity, are not + licensed under this Public License, nor are publicity, + privacy, and/or other similar personality rights; however, to + the extent possible, the Licensor waives and/or agrees not to + assert any such rights held by the Licensor to the limited + extent necessary to allow You to exercise the Licensed + Rights, but not otherwise. + + 2. Patent and trademark rights are not licensed under this + Public License. + + 3. To the extent possible, the Licensor waives any right to + collect royalties from You for the exercise of the Licensed + Rights, whether directly or through a collecting society + under any voluntary or waivable statutory or compulsory + licensing scheme. In all other cases the Licensor expressly + reserves any right to collect such royalties, including when + the Licensed Material is used other than for NonCommercial + purposes. + + +Section 3 -- License Conditions. + +Your exercise of the Licensed Rights is expressly made subject to the +following conditions. + + a. Attribution. + + 1. If You Share the Licensed Material, You must: + + a. retain the following if it is supplied by the Licensor + with the Licensed Material: + + i. identification of the creator(s) of the Licensed + Material and any others designated to receive + attribution, in any reasonable manner requested by + the Licensor (including by pseudonym if + designated); + + ii. a copyright notice; + + iii. a notice that refers to this Public License; + + iv. a notice that refers to the disclaimer of + warranties; + + v. a URI or hyperlink to the Licensed Material to the + extent reasonably practicable; + + b. indicate if You modified the Licensed Material and + retain an indication of any previous modifications; and + + c. indicate the Licensed Material is licensed under this + Public License, and include the text of, or the URI or + hyperlink to, this Public License. + + For the avoidance of doubt, You do not have permission under + this Public License to Share Adapted Material. + + 2. You may satisfy the conditions in Section 3(a)(1) in any + reasonable manner based on the medium, means, and context in + which You Share the Licensed Material. For example, it may be + reasonable to satisfy the conditions by providing a URI or + hyperlink to a resource that includes the required + information. + + 3. If requested by the Licensor, You must remove any of the + information required by Section 3(a)(1)(A) to the extent + reasonably practicable. + + +Section 4 -- Sui Generis Database Rights. + +Where the Licensed Rights include Sui Generis Database Rights that +apply to Your use of the Licensed Material: + + a. for the avoidance of doubt, Section 2(a)(1) grants You the right + to extract, reuse, reproduce, and Share all or a substantial + portion of the contents of the database for NonCommercial purposes + only and provided You do not Share Adapted Material; + + b. if You include all or a substantial portion of the database + contents in a database in which You have Sui Generis Database + Rights, then the database in which You have Sui Generis Database + Rights (but not its individual contents) is Adapted Material; and + + c. You must comply with the conditions in Section 3(a) if You Share + all or a substantial portion of the contents of the database. + +For the avoidance of doubt, this Section 4 supplements and does not +replace Your obligations under this Public License where the Licensed +Rights include other Copyright and Similar Rights. + + +Section 5 -- Disclaimer of Warranties and Limitation of Liability. + + a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE + EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS + AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF + ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, + IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, + WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, + ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT + KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT + ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU. + + b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE + TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, + NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, + INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, + COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR + USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR + DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR + IN PART, THIS LIMITATION MAY NOT APPLY TO YOU. + + c. The disclaimer of warranties and limitation of liability provided + above shall be interpreted in a manner that, to the extent + possible, most closely approximates an absolute disclaimer and + waiver of all liability. + + +Section 6 -- Term and Termination. + + a. This Public License applies for the term of the Copyright and + Similar Rights licensed here. However, if You fail to comply with + this Public License, then Your rights under this Public License + terminate automatically. + + b. Where Your right to use the Licensed Material has terminated under + Section 6(a), it reinstates: + + 1. automatically as of the date the violation is cured, provided + it is cured within 30 days of Your discovery of the + violation; or + + 2. upon express reinstatement by the Licensor. + + For the avoidance of doubt, this Section 6(b) does not affect any + right the Licensor may have to seek remedies for Your violations + of this Public License. + + c. For the avoidance of doubt, the Licensor may also offer the + Licensed Material under separate terms or conditions or stop + distributing the Licensed Material at any time; however, doing so + will not terminate this Public License. + + d. Sections 1, 5, 6, 7, and 8 survive termination of this Public + License. + + +Section 7 -- Other Terms and Conditions. + + a. The Licensor shall not be bound by any additional or different + terms or conditions communicated by You unless expressly agreed. + + b. Any arrangements, understandings, or agreements regarding the + Licensed Material not stated herein are separate from and + independent of the terms and conditions of this Public License. + + +Section 8 -- Interpretation. + + a. For the avoidance of doubt, this Public License does not, and + shall not be interpreted to, reduce, limit, restrict, or impose + conditions on any use of the Licensed Material that could lawfully + be made without permission under this Public License. + + b. To the extent possible, if any provision of this Public License is + deemed unenforceable, it shall be automatically reformed to the + minimum extent necessary to make it enforceable. If the provision + cannot be reformed, it shall be severed from this Public License + without affecting the enforceability of the remaining terms and + conditions. + + c. No term or condition of this Public License will be waived and no + failure to comply consented to unless expressly agreed to by the + Licensor. + + d. Nothing in this Public License constitutes or may be interpreted + as a limitation upon, or waiver of, any privileges and immunities + that apply to the Licensor or You, including from the legal + processes of any jurisdiction or authority. + +======================================================================= + +Creative Commons is not a party to its public +licenses. Notwithstanding, Creative Commons may elect to apply one of +its public licenses to material it publishes and in those instances +will be considered the “Licensor.” The text of the Creative Commons +public licenses is dedicated to the public domain under the CC0 Public +Domain Dedication. Except for the limited purpose of indicating that +material is shared under a Creative Commons public license or as +otherwise permitted by the Creative Commons policies published at +creativecommons.org/policies, Creative Commons does not authorize the +use of the trademark "Creative Commons" or any other trademark or logo +of Creative Commons without its prior written consent including, +without limitation, in connection with any unauthorized modifications +to any of its public licenses or any other arrangements, +understandings, or agreements concerning use of licensed material. For +the avoidance of doubt, this paragraph does not form part of the +public licenses. + +Creative Commons may be contacted at creativecommons.org. + diff --git a/LXST/Call.py b/LXST/Call.py new file mode 100644 index 0000000..c67b237 --- /dev/null +++ b/LXST/Call.py @@ -0,0 +1,55 @@ +import RNS +from .Pipeline import Pipeline +from .Codecs import * +from .Sources import * +from .Sinks import * +from . import APP_NAME + +class CallEndpoint(): + def __init__(self, identity): + self.identity = identity + self.destination = RNS.Destination(self.identity, RNS.Destination.IN, RNS.Destination.SINGLE, APP_NAME, "call", "endpoint") + self.destination.set_link_established_callback(self._incoming_call) + self.active_call = None + self.auto_answer = True + self.receive_pipeline = None + self.transmit_pipeline = None + self._incoming_call_callback = None + + def announce(self): + if self.destination: + self.destination.announce() + + @property + def incoming_call_callback(self): + return self._incoming_call_callback + + @incoming_call_callback.setter + def incoming_call_callback(self, callback): + if callable(callback): + self._incoming_call_callback = callback + else: + raise TypeError(f"Invalid callback for {self}: Not callable") + + def _incoming_call(self, link): + RNS.log(f"Incoming call on {self}", RNS.LOG_DEBUG) + if callable(self._incoming_call_callback): + self._incoming_call_callback(link) + + def answer(self, call_link): + RNS.log(f"Answering call on {call_link}", RNS.LOG_DEBUG) + self.active_call = call_link + + self.receive_pipeline = Pipeline(source=PacketSource(self), + codec=Opus(), + sink=LineSink()) + + self.transmit_pipeline = Pipeline(source=LineSource(target_frame_ms=target_frame_ms), + codec=Opus(), + sink=PacketSink(self)) + + def terminate(self): + self.receive_pipeline.stop() + self.transmit_pipeline.stop() + if self.active_call: + self.active_call.teardown() \ No newline at end of file diff --git a/LXST/Codecs/Codec.py b/LXST/Codecs/Codec.py new file mode 100644 index 0000000..911d7f5 --- /dev/null +++ b/LXST/Codecs/Codec.py @@ -0,0 +1,62 @@ +import numpy as np +from .libs.pydub import AudioSegment + +TYPE_MAP_FACTOR = np.iinfo("int16").max + +class Codec(): + preferred_samplerate = None + frame_quanta_ms = None + frame_max_ms = None + valid_frame_ms = None + source = None + sink = None + +class CodecError(Exception): + pass + +class Null(Codec): + def __init__(self): + pass + + def encode(self, frame): + return frame + + def decode(self, frame): + return frame + +def resample_bytes(sample_bytes, bitdepth, channels, input_rate, output_rate, normalize=False): + sample_width = bitdepth//8 + audio = AudioSegment( + sample_bytes, + frame_rate=input_rate, + sample_width=sample_width, + channels=channels) + + if normalize: + audio = audio.apply_gain(-audio.max_dBFS) + + resampled_audio = audio.set_frame_rate(output_rate) + resampled_bytes = resampled_audio.get_array_of_samples().tobytes() + + # rate_factor = input_rate/output_rate + # input_samples = int(len(sample_bytes)/channels/sample_width) + # output_samples = int(len(resampled_bytes)/channels/sample_width) + # target_samples = int(input_samples/rate_factor) + # if output_samples < target_samples: + # print("Mismatch") + # add_samples = int(target_samples-output_samples) + # fill = resampled_bytes[-sample_width:]*add_samples + # resampled_bytes += fill + + return resampled_bytes + +def resample(input_samples, bitdepth, channels, input_rate, output_rate, normalize=False): + sample_width = bitdepth//8 + input_samples = input_samples*TYPE_MAP_FACTOR + input_samples = input_samples.astype(np.int16) + resampled_bytes = resample_bytes(input_samples.tobytes(), bitdepth, channels, input_rate, output_rate, normalize) + output_samples = np.frombuffer(resampled_bytes, dtype=np.int16)/TYPE_MAP_FACTOR + output_samples = output_samples.reshape(output_samples.shape[0]//channels, channels) + output_samples = output_samples.astype(np.float32) + + return output_samples \ No newline at end of file diff --git a/LXST/Codecs/Codec2.py b/LXST/Codecs/Codec2.py new file mode 100644 index 0000000..b371343 --- /dev/null +++ b/LXST/Codecs/Codec2.py @@ -0,0 +1,120 @@ +import time +import math +import struct +import pycodec2 +import numpy as np +from .Codec import Codec, CodecError, resample_bytes + +# TODO: Remove debug +import RNS + +class Codec2(Codec): + CODEC2_700C = 700 + CODEC2_1200 = 1200 + CODEC2_1300 = 1300 + CODEC2_1400 = 1400 + CODEC2_1600 = 1600 + CODEC2_2400 = 2400 + CODEC2_3200 = 3200 + + INPUT_RATE = 8000 + OUTPUT_RATE = 8000 + FRAME_QUANTA_MS = 40 + TYPE_MAP_FACTOR = np.iinfo("int16").max + + MODE_HEADERS = {CODEC2_700C: 0x00, + CODEC2_1200: 0x01, + CODEC2_1300: 0x02, + CODEC2_1400: 0x03, + CODEC2_1600: 0x04, + CODEC2_2400: 0x05, + CODEC2_3200: 0x06} + + HEADER_MODES = {0x00: CODEC2_700C, + 0x01: CODEC2_1200, + 0x02: CODEC2_1300, + 0x03: CODEC2_1400, + 0x04: CODEC2_1600, + 0x05: CODEC2_2400, + 0x06: CODEC2_3200} + + def __init__(self, mode=CODEC2_2400): + self.frame_quanta_ms = self.FRAME_QUANTA_MS + self.channels = 1 + self.bitdepth = 16 + self.c2 = None + self.output_samplerate = self.OUTPUT_RATE + self.set_mode(mode) + + def set_mode(self, mode): + self.mode = mode + self.mode_header = self.MODE_HEADERS[self.mode].to_bytes() + self.c2 = pycodec2.Codec2(self.mode) + + def encode(self, frame): + if frame.shape[1] == 0: + raise CodecError("Cannot encode frame with 0 channels") + elif frame.shape[1] > self.channels: + frame = frame[:, 1] + + + input_samples = frame*self.TYPE_MAP_FACTOR + input_samples = input_samples.astype(np.int16) + + if self.source: + if self.source.samplerate != self.INPUT_RATE: + frame_bytes = input_samples.tobytes() + resampled_bytes = resample_bytes(frame_bytes, self.bitdepth, self.channels, self.source.samplerate, self.INPUT_RATE) + input_samples = np.frombuffer(resampled_bytes, dtype=np.int16) + + SPF = self.c2.samples_per_frame() + N_FRAMES = math.floor(len(input_samples)/SPF) + input_frames = np.array(input_samples[0:N_FRAMES*SPF], dtype=np.int16) + + encoded = b"" + for pi in range(0, N_FRAMES): + pstart = pi*SPF + pend = (pi+1)*SPF + input_frame = input_frames[pstart:pend] + encoded_frame = self.c2.encode(input_frame) + encoded += encoded_frame + + # TODO: Remove debug + # print(f"SPF : {SPF}") + # print(f"N_FRAMES : {N_FRAMES}") + + return self.mode_header+encoded + + def decode(self, frame_bytes): + frame_header = frame_bytes[0] + frame_bytes = frame_bytes[1:] + frame_mode = self.HEADER_MODES[frame_header] + if self.mode != frame_mode: + self.set_mode(frame_mode) + + SPF = self.c2.samples_per_frame() + BPF = self.c2.bytes_per_frame() + STRUCT_FORMAT = f"{SPF}h" + N_FRAMES = math.floor(len(frame_bytes)/BPF) + + # TODO: Remove debug + # print(f"BPF : {BPF}") + # print(f"N_FRAMES : {N_FRAMES}") + + decoded = b"" + for pi in range(0, N_FRAMES): + pstart = pi*BPF + pend = (pi+1)*BPF + encoded_frame = frame_bytes[pstart:pend] + decoded_frame = self.c2.decode(encoded_frame) + decoded += struct.pack(STRUCT_FORMAT, *decoded_frame) + + if self.sink: + if self.sink.samplerate != self.OUTPUT_RATE: + decoded = resample_bytes(decoded, self.bitdepth, self.channels, self.OUTPUT_RATE, self.sink.samplerate) + + decoded_samples = np.frombuffer(decoded, dtype="int16")/self.TYPE_MAP_FACTOR + frame_samples = np.zeros((len(decoded_samples), 1), dtype="float32") + frame_samples[:, 0] = decoded_samples + + return frame_samples \ No newline at end of file diff --git a/LXST/Codecs/Opus.py b/LXST/Codecs/Opus.py new file mode 100644 index 0000000..f85defc --- /dev/null +++ b/LXST/Codecs/Opus.py @@ -0,0 +1,179 @@ +import io +import RNS +import time +import math +import numpy as np +from .Codec import Codec, CodecError, resample_bytes +from .libs.pyogg import OpusEncoder, OpusDecoder + +class Opus(Codec): + FRAME_QUANTA_MS = 2.5 + FRAME_MAX_MS = 60 + VALID_FRAME_MS = [2.5, 5, 10, 20, 40, 60] + TYPE_MAP_FACTOR = np.iinfo("int16").max + + PROFILE_VOICE_LOW = 0x00 + PROFILE_VOICE_MEDIUM = 0x01 + PROFILE_VOICE_HIGH = 0x02 + PROFILE_VOICE_MAX = 0x03 + PROFILE_AUDIO_MIN = 0x04 + PROFILE_AUDIO_LOW = 0x05 + PROFILE_AUDIO_MEDIUM = 0x06 + PROFILE_AUDIO_HIGH = 0x07 + PROFILE_AUDIO_MAX = 0x08 + + def __init__(self, profile=PROFILE_VOICE_LOW): + self.frame_quanta_ms = self.FRAME_QUANTA_MS + self.frame_max_ms = self.FRAME_MAX_MS + self.valid_frame_ms = self.VALID_FRAME_MS + self.channels = 1 + self.input_channels = 1 + self.output_channels = 2 + self.bitdepth = 16 + self.opus_encoder = OpusEncoder() + self.opus_decoder = OpusDecoder() + self.encoder_configured = False + self.decoder_configured = False + self.bitrate_ceiling = 6000 + self.output_bytes = 0 + self.output_ms = 0 + self.output_bitrate = 0 + self.set_profile(profile) + + def set_profile(self, profile): + if profile == self.PROFILE_VOICE_LOW: + self.profile = profile + self.channels = 1 + self.input_channels = self.channels + self.output_samplerate = 8000 + self.opus_encoder.set_application("voip") + elif profile == self.PROFILE_VOICE_MEDIUM: + self.profile = profile + self.channels = 1 + self.input_channels = self.channels + self.output_samplerate = 24000 + self.opus_encoder.set_application("voip") + elif profile == self.PROFILE_VOICE_HIGH: + self.profile = profile + self.channels = 1 + self.input_channels = self.channels + self.output_samplerate = 48000 + self.opus_encoder.set_application("voip") + elif profile == self.PROFILE_VOICE_MAX: + self.profile = profile + self.channels = 2 + self.input_channels = self.channels + self.output_samplerate = 48000 + self.opus_encoder.set_application("voip") + elif profile == self.PROFILE_AUDIO_MIN: + self.profile = profile + self.channels = 1 + self.input_channels = self.channels + self.output_samplerate = 8000 + self.opus_encoder.set_application("audio") + elif profile == self.PROFILE_AUDIO_LOW: + self.profile = profile + self.channels = 1 + self.input_channels = self.channels + self.output_samplerate = 12000 + self.opus_encoder.set_application("audio") + elif profile == self.PROFILE_AUDIO_MEDIUM: + self.profile = profile + self.channels = 2 + self.input_channels = self.channels + self.output_samplerate = 24000 + self.opus_encoder.set_application("audio") + elif profile == self.PROFILE_AUDIO_HIGH: + self.profile = profile + self.channels = 2 + self.input_channels = self.channels + self.output_samplerate = 48000 + self.opus_encoder.set_application("audio") + elif profile == self.PROFILE_AUDIO_MAX: + self.profile = profile + self.channels = 2 + self.input_channels = self.channels + self.output_samplerate = 48000 + self.opus_encoder.set_application("audio") + else: + raise CodecError(f"Unsupported profile configured for {self}") + + def update_bitrate(self, frame_duration_ms): + if self.profile == self.PROFILE_VOICE_LOW: + self.bitrate_ceiling = 6000 + elif self.profile == self.PROFILE_VOICE_MEDIUM: + self.bitrate_ceiling = 8000 + elif self.profile == self.PROFILE_VOICE_HIGH: + self.bitrate_ceiling = 16000 + elif self.profile == self.PROFILE_VOICE_MAX: + self.bitrate_ceiling = 32000 + elif self.profile == self.PROFILE_AUDIO_MIN: + self.bitrate_ceiling = 8000 + elif self.profile == self.PROFILE_AUDIO_LOW: + self.bitrate_ceiling = 14000 + elif self.profile == self.PROFILE_AUDIO_MEDIUM: + self.bitrate_ceiling = 28000 + elif self.profile == self.PROFILE_AUDIO_HIGH: + self.bitrate_ceiling = 56000 + elif self.profile == self.PROFILE_AUDIO_MAX: + self.bitrate_ceiling = 128000 + + max_bytes_per_frame = math.ceil((self.bitrate_ceiling/8)*(frame_duration_ms/1000)) + configured_bitrate = (max_bytes_per_frame*8)/(frame_duration_ms/1000) + self.opus_encoder.set_max_bytes_per_frame(max_bytes_per_frame) + + def encode(self, frame): + if frame.shape[1] == 0: + raise CodecError("Cannot encode frame with 0 channels") + elif frame.shape[1] > self.input_channels: + frame = frame[:, 0:self.input_channels] + elif frame.shape[1] < self.input_channels: + new_frame = np.zeros(shape=(frame.shape[0], self.input_channels)) + for n in range(0, frame.shape[1]): new_frame[:, n] = frame[:, n] + for n in range(frame.shape[1], new_frame.shape[1]): new_frame[:, n] = frame[:, frame.shape[1]-1] + frame = new_frame + + input_samples = frame*self.TYPE_MAP_FACTOR + input_samples = input_samples.astype(np.int16) + + if self.source.samplerate != self.output_samplerate: + frame_bytes = input_samples.tobytes() + resampled_bytes = resample_bytes(frame_bytes, self.bitdepth, self.input_channels, self.source.samplerate, self.output_samplerate) + input_samples = np.frombuffer(resampled_bytes, dtype=np.int16) + input_samples = input_samples.reshape(len(input_samples)//self.input_channels, self.input_channels) + + frame_duration_ms = (input_samples.shape[0]/self.output_samplerate)*1000 + self.update_bitrate(frame_duration_ms) + + if not self.encoder_configured: + self.input_channels = self.channels + self.opus_encoder.set_sampling_frequency(self.output_samplerate) + self.opus_encoder.set_channels(self.input_channels) + RNS.log(f"{self} encoder set to {self.input_channels} channels, {RNS.prettyfrequency(self.output_samplerate)}", RNS.LOG_DEBUG) + self.encoder_configured = True + + input_bytes = input_samples.tobytes() + # TODO: Pad input bytes on partial frame + encoded_frame = self.opus_encoder.encode(input_bytes).tobytes() + + self.output_bytes += len(encoded_frame) + self.output_ms += frame_duration_ms + self.output_bitrate = (self.output_bytes*8)/(self.output_ms/1000) + + return encoded_frame + + def decode(self, frame_bytes): + if not self.decoder_configured: + if self.sink and self.sink.channels: output_channels = self.sink.channels + else: output_channels = self.output_channels if self.output_channels > self.channels else self.channels + self.channels = output_channels + self.opus_decoder.set_channels(output_channels) + self.opus_decoder.set_sampling_frequency(self.sink.samplerate) + self.decoder_configured = True + RNS.log(f"{self} decoder set to {self.channels} channels, {RNS.prettyfrequency(self.sink.samplerate)}", RNS.LOG_DEBUG) + + decoded_frame_bytes = self.opus_decoder.decode(memoryview(bytearray(frame_bytes))) + decoded_samples = np.frombuffer(decoded_frame_bytes, dtype="int16")/self.TYPE_MAP_FACTOR + frame_samples = decoded_samples.reshape(len(decoded_samples)//self.channels, self.channels) + + return frame_samples \ No newline at end of file diff --git a/LXST/Codecs/Raw.py b/LXST/Codecs/Raw.py new file mode 100644 index 0000000..70652d8 --- /dev/null +++ b/LXST/Codecs/Raw.py @@ -0,0 +1,58 @@ +import RNS +import numpy as np +from .Codec import Codec + +class Raw(Codec): + BITDEPTH_16 = 0x00 + BITDEPTH_32 = 0x01 + BITDEPTH_64 = 0x02 + BITDEPTH_128 = 0x03 + BITDEPTHS = ["float16", "float32", "float64", "float128"] + + def __init__(self, channels=None, bitdepth=16): + if channels: + channels = min(max(channels, 1), 32) + + self.bitdepth = bitdepth + self.channels = channels + + if self.bitdepth >= 128: + self.dtype = self.BITDEPTHS[self.BITDEPTH_128] + self.header_bitdpeth = self.BITDEPTH_128 + elif self.bitdepth >= 64: + self.dtype = self.BITDEPTHS[self.BITDEPTH_64] + self.header_bitdpeth = self.BITDEPTH_64 + elif self.bitdepth >= 32: + self.dtype = self.BITDEPTHS[self.BITDEPTH_32] + self.header_bitdpeth = self.BITDEPTH_32 + else: + self.dtype = self.BITDEPTHS[self.BITDEPTH_16] + self.header_bitdpeth = self.BITDEPTH_16 + + def encode(self, frame): + if self.channels == None: + self.channels = frame.shape[1] + RNS.log(f"{self} encoder set to {self.channels} channels", RNS.LOG_DEBUG) + + if frame.shape[1] > self.channels: + frame = frame[:, range(0, self.channels)] + elif frame.shape[1] < self.channels: + new_frame = np.zeros(shape=(frame.shape[0], self.channels)) + for n in range(0, frame.shape[1]): new_frame[:, n] = frame[:, n] + for n in range(frame.shape[1], new_frame.shape[1]): new_frame[:, n] = frame[:, frame.shape[1]-1] + frame = new_frame + + frame_header = (self.header_bitdpeth << 6) | self.channels-1 + frame_bytes = frame_header.to_bytes()+frame.astype(self.dtype).tobytes() + return frame_bytes + + def decode(self, frame_bytes): + frame_header = frame_bytes[0] + frame_channels = (frame_header & 0b00111111)+1 + frame_bitdepth = frame_header >> 6 + frame_dtype = self.BITDEPTHS[frame_bitdepth] + frame_samples = np.frombuffer(frame_bytes[1:], dtype=frame_dtype) + frame_samples = frame_samples.reshape(len(frame_samples)//frame_channels, frame_channels) + if not self.channels: self.channels = frame_channels + + return frame_samples \ No newline at end of file diff --git a/LXST/Codecs/__init__.py b/LXST/Codecs/__init__.py new file mode 100644 index 0000000..b081b02 --- /dev/null +++ b/LXST/Codecs/__init__.py @@ -0,0 +1,29 @@ +from .Codec import CodecError as CodecError +from .Codec import Codec as Codec +from .Codec import Null as Null +from .Raw import Raw as Raw +from .Codec2 import Codec2 as Codec2 +from .Opus import Opus as Opus + +NULL = 0xFF +RAW = 0x00 +OPUS = 0x01 +CODEC2 = 0x02 + +def codec_header_byte(codec): + if codec == Raw: + return RAW.to_bytes() + elif codec == Opus: + return OPUS.to_bytes() + elif codec == Codec2: + return CODEC2.to_bytes() + + raise TypeError(f"No header mapping for codec type {codec}") + +def codec_type(header_byte): + if header_byte == RAW: + return Raw + elif header_byte == OPUS: + return Opus + elif header_byte == CODEC2: + return Codec2 \ No newline at end of file diff --git a/LXST/Codecs/libs/pydub/__init__.py b/LXST/Codecs/libs/pydub/__init__.py new file mode 100644 index 0000000..65e30b4 --- /dev/null +++ b/LXST/Codecs/libs/pydub/__init__.py @@ -0,0 +1 @@ +from .audio_segment import AudioSegment \ No newline at end of file diff --git a/LXST/Codecs/libs/pydub/audio_segment.py b/LXST/Codecs/libs/pydub/audio_segment.py new file mode 100644 index 0000000..14ea46e --- /dev/null +++ b/LXST/Codecs/libs/pydub/audio_segment.py @@ -0,0 +1,1399 @@ +from __future__ import division + +import array +import os +import subprocess +from tempfile import TemporaryFile, NamedTemporaryFile +import wave +import sys +import struct +from .logging_utils import log_conversion, log_subprocess_output +from .utils import mediainfo_json, fsdecode +import base64 +from collections import namedtuple + +try: + from StringIO import StringIO +except: + from io import StringIO + +from io import BytesIO + +try: + from itertools import izip +except: + izip = zip + +from .utils import ( + _fd_or_path_or_tempfile, + db_to_float, + ratio_to_db, + get_encoder_name, + get_array_type, + audioop, +) +from .exceptions import ( + TooManyMissingFrames, + InvalidDuration, + InvalidID3TagVersion, + InvalidTag, + CouldntDecodeError, + CouldntEncodeError, + MissingAudioParameter, +) + +if sys.version_info >= (3, 0): + basestring = str + xrange = range + StringIO = BytesIO + + +class ClassPropertyDescriptor(object): + + def __init__(self, fget, fset=None): + self.fget = fget + self.fset = fset + + def __get__(self, obj, klass=None): + if klass is None: + klass = type(obj) + return self.fget.__get__(obj, klass)() + + def __set__(self, obj, value): + if not self.fset: + raise AttributeError("can't set attribute") + type_ = type(obj) + return self.fset.__get__(obj, type_)(value) + + def setter(self, func): + if not isinstance(func, (classmethod, staticmethod)): + func = classmethod(func) + self.fset = func + return self + + +def classproperty(func): + if not isinstance(func, (classmethod, staticmethod)): + func = classmethod(func) + + return ClassPropertyDescriptor(func) + + +AUDIO_FILE_EXT_ALIASES = { + "m4a": "mp4", + "wave": "wav", +} + +WavSubChunk = namedtuple('WavSubChunk', ['id', 'position', 'size']) +WavData = namedtuple('WavData', ['audio_format', 'channels', 'sample_rate', + 'bits_per_sample', 'raw_data']) + + +def extract_wav_headers(data): + # def search_subchunk(data, subchunk_id): + pos = 12 # The size of the RIFF chunk descriptor + subchunks = [] + while pos + 8 <= len(data) and len(subchunks) < 10: + subchunk_id = data[pos:pos + 4] + subchunk_size = struct.unpack_from(' 2**32: + raise CouldntDecodeError("Unable to process >4GB files") + + # Set the file size in the RIFF chunk descriptor + data[4:8] = struct.pack(' b'\x7f'[0]]) + old_bytes = struct.pack(pack_fmt, b0, b1, b2) + byte_buffer.write(old_bytes) + + self._data = byte_buffer.getvalue() + self.sample_width = 4 + self.frame_width = self.channels * self.sample_width + + super(AudioSegment, self).__init__(*args, **kwargs) + + @property + def raw_data(self): + """ + public access to the raw audio data as a bytestring + """ + return self._data + + def get_array_of_samples(self, array_type_override=None): + """ + returns the raw_data as an array of samples + """ + if array_type_override is None: + array_type_override = self.array_type + return array.array(array_type_override, self._data) + + @property + def array_type(self): + return get_array_type(self.sample_width * 8) + + def __len__(self): + """ + returns the length of this audio segment in milliseconds + """ + return round(1000 * (self.frame_count() / self.frame_rate)) + + def __eq__(self, other): + try: + return self._data == other._data + except: + return False + + def __hash__(self): + return hash(AudioSegment) ^ hash((self.channels, self.frame_rate, self.sample_width, self._data)) + + def __ne__(self, other): + return not (self == other) + + def __iter__(self): + return (self[i] for i in xrange(len(self))) + + def __getitem__(self, millisecond): + if isinstance(millisecond, slice): + if millisecond.step: + return ( + self[i:i + millisecond.step] + for i in xrange(*millisecond.indices(len(self))) + ) + + start = millisecond.start if millisecond.start is not None else 0 + end = millisecond.stop if millisecond.stop is not None \ + else len(self) + + start = min(start, len(self)) + end = min(end, len(self)) + else: + start = millisecond + end = millisecond + 1 + + start = self._parse_position(start) * self.frame_width + end = self._parse_position(end) * self.frame_width + data = self._data[start:end] + + # ensure the output is as long as the requester is expecting + expected_length = end - start + missing_frames = (expected_length - len(data)) // self.frame_width + if missing_frames: + if missing_frames > self.frame_count(ms=2): + raise TooManyMissingFrames( + "You should never be filling in " + " more than 2 ms with silence here, " + "missing frames: %s" % missing_frames) + silence = audioop.mul(data[:self.frame_width], + self.sample_width, 0) + data += (silence * missing_frames) + + return self._spawn(data) + + def get_sample_slice(self, start_sample=None, end_sample=None): + """ + Get a section of the audio segment by sample index. + + NOTE: Negative indices do *not* address samples backword + from the end of the audio segment like a python list. + This is intentional. + """ + max_val = int(self.frame_count()) + + def bounded(val, default): + if val is None: + return default + if val < 0: + return 0 + if val > max_val: + return max_val + return val + + start_i = bounded(start_sample, 0) * self.frame_width + end_i = bounded(end_sample, max_val) * self.frame_width + + data = self._data[start_i:end_i] + return self._spawn(data) + + def __add__(self, arg): + if isinstance(arg, AudioSegment): + return self.append(arg, crossfade=0) + else: + return self.apply_gain(arg) + + def __radd__(self, rarg): + """ + Permit use of sum() builtin with an iterable of AudioSegments + """ + if rarg == 0: + return self + raise TypeError("Gains must be the second addend after the " + "AudioSegment") + + def __sub__(self, arg): + if isinstance(arg, AudioSegment): + raise TypeError("AudioSegment objects can't be subtracted from " + "each other") + else: + return self.apply_gain(-arg) + + def __mul__(self, arg): + """ + If the argument is an AudioSegment, overlay the multiplied audio + segment. + + If it's a number, just use the string multiply operation to repeat the + audio. + + The following would return an AudioSegment that contains the + audio of audio_seg eight times + + `audio_seg * 8` + """ + if isinstance(arg, AudioSegment): + return self.overlay(arg, position=0, loop=True) + else: + return self._spawn(data=self._data * arg) + + def _spawn(self, data, overrides={}): + """ + Creates a new audio segment using the metadata from the current one + and the data passed in. Should be used whenever an AudioSegment is + being returned by an operation that would alters the current one, + since AudioSegment objects are immutable. + """ + # accept lists of data chunks + if isinstance(data, list): + data = b''.join(data) + + if isinstance(data, array.array): + try: + data = data.tobytes() + except: + data = data.tostring() + + # accept file-like objects + if hasattr(data, 'read'): + if hasattr(data, 'seek'): + data.seek(0) + data = data.read() + + metadata = { + 'sample_width': self.sample_width, + 'frame_rate': self.frame_rate, + 'frame_width': self.frame_width, + 'channels': self.channels + } + metadata.update(overrides) + return self.__class__(data=data, metadata=metadata) + + @classmethod + def _sync(cls, *segs): + channels = max(seg.channels for seg in segs) + frame_rate = max(seg.frame_rate for seg in segs) + sample_width = max(seg.sample_width for seg in segs) + + return tuple( + seg.set_channels(channels).set_frame_rate(frame_rate).set_sample_width(sample_width) + for seg in segs + ) + + def _parse_position(self, val): + if val < 0: + val = len(self) - abs(val) + val = self.frame_count(ms=len(self)) if val == float("inf") else \ + self.frame_count(ms=val) + return int(val) + + @classmethod + def empty(cls): + return cls(b'', metadata={ + "channels": 1, + "sample_width": 1, + "frame_rate": 1, + "frame_width": 1 + }) + + @classmethod + def silent(cls, duration=1000, frame_rate=11025): + """ + Generate a silent audio segment. + duration specified in milliseconds (default duration: 1000ms, default frame_rate: 11025). + """ + frames = int(frame_rate * (duration / 1000.0)) + data = b"\0\0" * frames + return cls(data, metadata={"channels": 1, + "sample_width": 2, + "frame_rate": frame_rate, + "frame_width": 2}) + + @classmethod + def from_mono_audiosegments(cls, *mono_segments): + if not len(mono_segments): + raise ValueError("At least one AudioSegment instance is required") + + segs = cls._sync(*mono_segments) + + if segs[0].channels != 1: + raise ValueError( + "AudioSegment.from_mono_audiosegments requires all arguments are mono AudioSegment instances") + + channels = len(segs) + sample_width = segs[0].sample_width + frame_rate = segs[0].frame_rate + + frame_count = max(int(seg.frame_count()) for seg in segs) + data = array.array( + segs[0].array_type, + b'\0' * (frame_count * sample_width * channels) + ) + + for i, seg in enumerate(segs): + data[i::channels] = seg.get_array_of_samples() + + return cls( + data, + channels=channels, + sample_width=sample_width, + frame_rate=frame_rate, + ) + + @classmethod + def from_file_using_temporary_files(cls, file, format=None, codec=None, parameters=None, start_second=None, duration=None, **kwargs): + orig_file = file + file, close_file = _fd_or_path_or_tempfile(file, 'rb', tempfile=False) + + if format: + format = format.lower() + format = AUDIO_FILE_EXT_ALIASES.get(format, format) + + def is_format(f): + f = f.lower() + if format == f: + return True + if isinstance(orig_file, basestring): + return orig_file.lower().endswith(".{0}".format(f)) + if isinstance(orig_file, bytes): + return orig_file.lower().endswith((".{0}".format(f)).encode('utf8')) + return False + + if is_format("wav"): + try: + obj = cls._from_safe_wav(file) + if close_file: + file.close() + if start_second is None and duration is None: + return obj + elif start_second is not None and duration is None: + return obj[start_second*1000:] + elif start_second is None and duration is not None: + return obj[:duration*1000] + else: + return obj[start_second*1000:(start_second+duration)*1000] + except: + file.seek(0) + elif is_format("raw") or is_format("pcm"): + sample_width = kwargs['sample_width'] + frame_rate = kwargs['frame_rate'] + channels = kwargs['channels'] + metadata = { + 'sample_width': sample_width, + 'frame_rate': frame_rate, + 'channels': channels, + 'frame_width': channels * sample_width + } + obj = cls(data=file.read(), metadata=metadata) + if close_file: + file.close() + if start_second is None and duration is None: + return obj + elif start_second is not None and duration is None: + return obj[start_second * 1000:] + elif start_second is None and duration is not None: + return obj[:duration * 1000] + else: + return obj[start_second * 1000:(start_second + duration) * 1000] + + input_file = NamedTemporaryFile(mode='wb', delete=False) + try: + input_file.write(file.read()) + except(OSError): + input_file.flush() + input_file.close() + input_file = NamedTemporaryFile(mode='wb', delete=False, buffering=2 ** 31 - 1) + if close_file: + file.close() + close_file = True + file = open(orig_file, buffering=2 ** 13 - 1, mode='rb') + reader = file.read(2 ** 31 - 1) + while reader: + input_file.write(reader) + reader = file.read(2 ** 31 - 1) + input_file.flush() + if close_file: + file.close() + + output = NamedTemporaryFile(mode="rb", delete=False) + + conversion_command = [cls.converter, + '-y', # always overwrite existing files + ] + + # If format is not defined + # ffmpeg/avconv will detect it automatically + if format: + conversion_command += ["-f", format] + + if codec: + # force audio decoder + conversion_command += ["-acodec", codec] + + conversion_command += [ + "-i", input_file.name, # input_file options (filename last) + "-vn", # Drop any video streams if there are any + "-f", "wav" # output options (filename last) + ] + + if start_second is not None: + conversion_command += ["-ss", str(start_second)] + + if duration is not None: + conversion_command += ["-t", str(duration)] + + conversion_command += [output.name] + + if parameters is not None: + # extend arguments with arbitrary set + conversion_command.extend(parameters) + + log_conversion(conversion_command) + + with open(os.devnull, 'rb') as devnull: + p = subprocess.Popen(conversion_command, stdin=devnull, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p_out, p_err = p.communicate() + + log_subprocess_output(p_out) + log_subprocess_output(p_err) + + try: + if p.returncode != 0: + raise CouldntDecodeError( + "Decoding failed. ffmpeg returned error code: {0}\n\nOutput from ffmpeg/avlib:\n\n{1}".format( + p.returncode, p_err.decode(errors='ignore') )) + obj = cls._from_safe_wav(output) + finally: + input_file.close() + output.close() + os.unlink(input_file.name) + os.unlink(output.name) + + if start_second is None and duration is None: + return obj + elif start_second is not None and duration is None: + return obj[0:] + elif start_second is None and duration is not None: + return obj[:duration * 1000] + else: + return obj[0:duration * 1000] + + + @classmethod + def from_file(cls, file, format=None, codec=None, parameters=None, start_second=None, duration=None, **kwargs): + orig_file = file + try: + filename = fsdecode(file) + except TypeError: + filename = None + file, close_file = _fd_or_path_or_tempfile(file, 'rb', tempfile=False) + + if format: + format = format.lower() + format = AUDIO_FILE_EXT_ALIASES.get(format, format) + + def is_format(f): + f = f.lower() + if format == f: + return True + + if filename: + return filename.lower().endswith(".{0}".format(f)) + + return False + + if is_format("wav"): + try: + if start_second is None and duration is None: + return cls._from_safe_wav(file) + elif start_second is not None and duration is None: + return cls._from_safe_wav(file)[start_second*1000:] + elif start_second is None and duration is not None: + return cls._from_safe_wav(file)[:duration*1000] + else: + return cls._from_safe_wav(file)[start_second*1000:(start_second+duration)*1000] + except: + file.seek(0) + elif is_format("raw") or is_format("pcm"): + sample_width = kwargs['sample_width'] + frame_rate = kwargs['frame_rate'] + channels = kwargs['channels'] + metadata = { + 'sample_width': sample_width, + 'frame_rate': frame_rate, + 'channels': channels, + 'frame_width': channels * sample_width + } + if start_second is None and duration is None: + return cls(data=file.read(), metadata=metadata) + elif start_second is not None and duration is None: + return cls(data=file.read(), metadata=metadata)[start_second*1000:] + elif start_second is None and duration is not None: + return cls(data=file.read(), metadata=metadata)[:duration*1000] + else: + return cls(data=file.read(), metadata=metadata)[start_second*1000:(start_second+duration)*1000] + + conversion_command = [cls.converter, + '-y', # always overwrite existing files + ] + + # If format is not defined + # ffmpeg/avconv will detect it automatically + if format: + conversion_command += ["-f", format] + + if codec: + # force audio decoder + conversion_command += ["-acodec", codec] + + read_ahead_limit = kwargs.get('read_ahead_limit', -1) + if filename: + conversion_command += ["-i", filename] + stdin_parameter = None + stdin_data = None + else: + if cls.converter == 'ffmpeg': + conversion_command += ["-read_ahead_limit", str(read_ahead_limit), + "-i", "cache:pipe:0"] + else: + conversion_command += ["-i", "-"] + stdin_parameter = subprocess.PIPE + stdin_data = file.read() + + if codec: + info = None + else: + info = mediainfo_json(orig_file, read_ahead_limit=read_ahead_limit) + if info: + audio_streams = [x for x in info['streams'] + if x['codec_type'] == 'audio'] + # This is a workaround for some ffprobe versions that always say + # that mp3/mp4/aac/webm/ogg files contain fltp samples + audio_codec = audio_streams[0].get('codec_name') + if (audio_streams[0].get('sample_fmt') == 'fltp' and + audio_codec in ['mp3', 'mp4', 'aac', 'webm', 'ogg']): + bits_per_sample = 16 + else: + bits_per_sample = audio_streams[0]['bits_per_sample'] + if bits_per_sample == 8: + acodec = 'pcm_u8' + else: + acodec = 'pcm_s%dle' % bits_per_sample + + conversion_command += ["-acodec", acodec] + + conversion_command += [ + "-vn", # Drop any video streams if there are any + "-f", "wav" # output options (filename last) + ] + + if start_second is not None: + conversion_command += ["-ss", str(start_second)] + + if duration is not None: + conversion_command += ["-t", str(duration)] + + conversion_command += ["-"] + + if parameters is not None: + # extend arguments with arbitrary set + conversion_command.extend(parameters) + + log_conversion(conversion_command) + + p = subprocess.Popen(conversion_command, stdin=stdin_parameter, + stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p_out, p_err = p.communicate(input=stdin_data) + + if p.returncode != 0 or len(p_out) == 0: + if close_file: + file.close() + raise CouldntDecodeError( + "Decoding failed. ffmpeg returned error code: {0}\n\nOutput from ffmpeg/avlib:\n\n{1}".format( + p.returncode, p_err.decode(errors='ignore') )) + + p_out = bytearray(p_out) + fix_wav_headers(p_out) + p_out = bytes(p_out) + obj = cls(p_out) + + if close_file: + file.close() + + if start_second is None and duration is None: + return obj + elif start_second is not None and duration is None: + return obj[0:] + elif start_second is None and duration is not None: + return obj[:duration * 1000] + else: + return obj[0:duration * 1000] + + @classmethod + def from_mp3(cls, file, parameters=None): + return cls.from_file(file, 'mp3', parameters=parameters) + + @classmethod + def from_flv(cls, file, parameters=None): + return cls.from_file(file, 'flv', parameters=parameters) + + @classmethod + def from_ogg(cls, file, parameters=None): + return cls.from_file(file, 'ogg', parameters=parameters) + + @classmethod + def from_wav(cls, file, parameters=None): + return cls.from_file(file, 'wav', parameters=parameters) + + @classmethod + def from_raw(cls, file, **kwargs): + return cls.from_file(file, 'raw', sample_width=kwargs['sample_width'], frame_rate=kwargs['frame_rate'], + channels=kwargs['channels']) + + @classmethod + def _from_safe_wav(cls, file): + file, close_file = _fd_or_path_or_tempfile(file, 'rb', tempfile=False) + file.seek(0) + obj = cls(data=file) + if close_file: + file.close() + return obj + + def export(self, out_f=None, format='mp3', codec=None, bitrate=None, parameters=None, tags=None, id3v2_version='4', + cover=None): + """ + Export an AudioSegment to a file with given options + + out_f (string): + Path to destination audio file. Also accepts os.PathLike objects on + python >= 3.6 + + format (string) + Format for destination audio file. + ('mp3', 'wav', 'raw', 'ogg' or other ffmpeg/avconv supported files) + + codec (string) + Codec used to encode the destination file. + + bitrate (string) + Bitrate used when encoding destination file. (64, 92, 128, 256, 312k...) + Each codec accepts different bitrate arguments so take a look at the + ffmpeg documentation for details (bitrate usually shown as -b, -ba or + -a:b). + + parameters (list of strings) + Aditional ffmpeg/avconv parameters + + tags (dict) + Set metadata information to destination files + usually used as tags. ({title='Song Title', artist='Song Artist'}) + + id3v2_version (string) + Set ID3v2 version for tags. (default: '4') + + cover (file) + Set cover for audio file from image file. (png or jpg) + """ + id3v2_allowed_versions = ['3', '4'] + + if format == "raw" and (codec is not None or parameters is not None): + raise AttributeError( + 'Can not invoke ffmpeg when export format is "raw"; ' + 'specify an ffmpeg raw format like format="s16le" instead ' + 'or call export(format="raw") with no codec or parameters') + + out_f, _ = _fd_or_path_or_tempfile(out_f, 'wb+') + out_f.seek(0) + + if format == "raw": + out_f.write(self._data) + out_f.seek(0) + return out_f + + # wav with no ffmpeg parameters can just be written directly to out_f + easy_wav = format == "wav" and codec is None and parameters is None + + if easy_wav: + data = out_f + else: + data = NamedTemporaryFile(mode="wb", delete=False) + + pcm_for_wav = self._data + if self.sample_width == 1: + # convert to unsigned integers for wav + pcm_for_wav = audioop.bias(self._data, 1, 128) + + wave_data = wave.open(data, 'wb') + wave_data.setnchannels(self.channels) + wave_data.setsampwidth(self.sample_width) + wave_data.setframerate(self.frame_rate) + # For some reason packing the wave header struct with + # a float in python 2 doesn't throw an exception + wave_data.setnframes(int(self.frame_count())) + wave_data.writeframesraw(pcm_for_wav) + wave_data.close() + + # for easy wav files, we're done (wav data is written directly to out_f) + if easy_wav: + out_f.seek(0) + return out_f + + output = NamedTemporaryFile(mode="w+b", delete=False) + + # build converter command to export + conversion_command = [ + self.converter, + '-y', # always overwrite existing files + "-f", "wav", "-i", data.name, # input options (filename last) + ] + + if codec is None: + codec = self.DEFAULT_CODECS.get(format, None) + + if cover is not None: + if cover.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tif', '.tiff')) and format == "mp3": + conversion_command.extend(["-i", cover, "-map", "0", "-map", "1", "-c:v", "mjpeg"]) + else: + raise AttributeError( + "Currently cover images are only supported by MP3 files. The allowed image formats are: .tif, .jpg, .bmp, .jpeg and .png.") + + if codec is not None: + # force audio encoder + conversion_command.extend(["-acodec", codec]) + + if bitrate is not None: + conversion_command.extend(["-b:a", bitrate]) + + if parameters is not None: + # extend arguments with arbitrary set + conversion_command.extend(parameters) + + if tags is not None: + if not isinstance(tags, dict): + raise InvalidTag("Tags must be a dictionary.") + else: + # Extend converter command with tags + # print(tags) + for key, value in tags.items(): + conversion_command.extend( + ['-metadata', '{0}={1}'.format(key, value)]) + + if format == 'mp3': + # set id3v2 tag version + if id3v2_version not in id3v2_allowed_versions: + raise InvalidID3TagVersion( + "id3v2_version not allowed, allowed versions: %s" % id3v2_allowed_versions) + conversion_command.extend([ + "-id3v2_version", id3v2_version + ]) + + if sys.platform == 'darwin' and codec == 'mp3': + conversion_command.extend(["-write_xing", "0"]) + + conversion_command.extend([ + "-f", format, output.name, # output options (filename last) + ]) + + log_conversion(conversion_command) + + # read stdin / write stdout + with open(os.devnull, 'rb') as devnull: + p = subprocess.Popen(conversion_command, stdin=devnull, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + p_out, p_err = p.communicate() + + log_subprocess_output(p_out) + log_subprocess_output(p_err) + + if p.returncode != 0: + raise CouldntEncodeError( + "Encoding failed. ffmpeg/avlib returned error code: {0}\n\nCommand:{1}\n\nOutput from ffmpeg/avlib:\n\n{2}".format( + p.returncode, conversion_command, p_err.decode(errors='ignore') )) + + output.seek(0) + out_f.write(output.read()) + + data.close() + output.close() + + os.unlink(data.name) + os.unlink(output.name) + + out_f.seek(0) + return out_f + + def get_frame(self, index): + frame_start = index * self.frame_width + frame_end = frame_start + self.frame_width + return self._data[frame_start:frame_end] + + def frame_count(self, ms=None): + """ + returns the number of frames for the given number of milliseconds, or + if not specified, the number of frames in the whole AudioSegment + """ + if ms is not None: + return ms * (self.frame_rate / 1000.0) + else: + return float(len(self._data) // self.frame_width) + + def set_sample_width(self, sample_width): + if sample_width == self.sample_width: + return self + + frame_width = self.channels * sample_width + + return self._spawn( + audioop.lin2lin(self._data, self.sample_width, sample_width), + overrides={'sample_width': sample_width, 'frame_width': frame_width} + ) + + def set_frame_rate(self, frame_rate): + if frame_rate == self.frame_rate: + return self + + if self._data: + converted, _ = audioop.ratecv(self._data, self.sample_width, + self.channels, self.frame_rate, + frame_rate, None) + else: + converted = self._data + + return self._spawn(data=converted, + overrides={'frame_rate': frame_rate}) + + def set_channels(self, channels): + if channels == self.channels: + return self + + if channels == 2 and self.channels == 1: + fn = audioop.tostereo + frame_width = self.frame_width * 2 + fac = 1 + converted = fn(self._data, self.sample_width, fac, fac) + elif channels == 1 and self.channels == 2: + fn = audioop.tomono + frame_width = self.frame_width // 2 + fac = 0.5 + converted = fn(self._data, self.sample_width, fac, fac) + elif channels == 1: + channels_data = [seg.get_array_of_samples() for seg in self.split_to_mono()] + frame_count = int(self.frame_count()) + converted = array.array( + channels_data[0].typecode, + b'\0' * (frame_count * self.sample_width) + ) + for raw_channel_data in channels_data: + for i in range(frame_count): + converted[i] += raw_channel_data[i] // self.channels + frame_width = self.frame_width // self.channels + elif self.channels == 1: + dup_channels = [self for iChannel in range(channels)] + return AudioSegment.from_mono_audiosegments(*dup_channels) + else: + raise ValueError( + "AudioSegment.set_channels only supports mono-to-multi channel and multi-to-mono channel conversion") + + return self._spawn(data=converted, + overrides={ + 'channels': channels, + 'frame_width': frame_width}) + + def split_to_mono(self): + if self.channels == 1: + return [self] + + samples = self.get_array_of_samples() + + mono_channels = [] + for i in range(self.channels): + samples_for_current_channel = samples[i::self.channels] + + try: + mono_data = samples_for_current_channel.tobytes() + except AttributeError: + mono_data = samples_for_current_channel.tostring() + + mono_channels.append( + self._spawn(mono_data, overrides={"channels": 1, "frame_width": self.sample_width}) + ) + + return mono_channels + + @property + def rms(self): + return audioop.rms(self._data, self.sample_width) + + @property + def dBFS(self): + rms = self.rms + if not rms: + return -float("infinity") + return ratio_to_db(self.rms / self.max_possible_amplitude) + + @property + def max(self): + return audioop.max(self._data, self.sample_width) + + @property + def max_possible_amplitude(self): + bits = self.sample_width * 8 + max_possible_val = (2 ** bits) + + # since half is above 0 and half is below the max amplitude is divided + return max_possible_val / 2 + + @property + def max_dBFS(self): + return ratio_to_db(self.max, self.max_possible_amplitude) + + @property + def duration_seconds(self): + return self.frame_rate and self.frame_count() / self.frame_rate or 0.0 + + def get_dc_offset(self, channel=1): + """ + Returns a value between -1.0 and 1.0 representing the DC offset of a + channel (1 for left, 2 for right). + """ + if not 1 <= channel <= 2: + raise ValueError("channel value must be 1 (left) or 2 (right)") + + if self.channels == 1: + data = self._data + elif channel == 1: + data = audioop.tomono(self._data, self.sample_width, 1, 0) + else: + data = audioop.tomono(self._data, self.sample_width, 0, 1) + + return float(audioop.avg(data, self.sample_width)) / self.max_possible_amplitude + + def remove_dc_offset(self, channel=None, offset=None): + """ + Removes DC offset of given channel. Calculates offset if it's not given. + Offset values must be in range -1.0 to 1.0. If channel is None, removes + DC offset from all available channels. + """ + if channel and not 1 <= channel <= 2: + raise ValueError("channel value must be None, 1 (left) or 2 (right)") + + if offset and not -1.0 <= offset <= 1.0: + raise ValueError("offset value must be in range -1.0 to 1.0") + + if offset: + offset = int(round(offset * self.max_possible_amplitude)) + + def remove_data_dc(data, off): + if not off: + off = audioop.avg(data, self.sample_width) + return audioop.bias(data, self.sample_width, -off) + + if self.channels == 1: + return self._spawn(data=remove_data_dc(self._data, offset)) + + left_channel = audioop.tomono(self._data, self.sample_width, 1, 0) + right_channel = audioop.tomono(self._data, self.sample_width, 0, 1) + + if not channel or channel == 1: + left_channel = remove_data_dc(left_channel, offset) + + if not channel or channel == 2: + right_channel = remove_data_dc(right_channel, offset) + + left_channel = audioop.tostereo(left_channel, self.sample_width, 1, 0) + right_channel = audioop.tostereo(right_channel, self.sample_width, 0, 1) + + return self._spawn(data=audioop.add(left_channel, right_channel, + self.sample_width)) + + def apply_gain(self, volume_change): + return self._spawn(data=audioop.mul(self._data, self.sample_width, + db_to_float(float(volume_change)))) + + def overlay(self, seg, position=0, loop=False, times=None, gain_during_overlay=None): + """ + Overlay the provided segment on to this segment starting at the + specificed position and using the specfied looping beahvior. + + seg (AudioSegment): + The audio segment to overlay on to this one. + + position (optional int): + The position to start overlaying the provided segment in to this + one. + + loop (optional bool): + Loop seg as many times as necessary to match this segment's length. + Overrides loops param. + + times (optional int): + Loop seg the specified number of times or until it matches this + segment's length. 1 means once, 2 means twice, ... 0 would make the + call a no-op + gain_during_overlay (optional int): + Changes this segment's volume by the specified amount during the + duration of time that seg is overlaid on top of it. When negative, + this has the effect of 'ducking' the audio under the overlay. + """ + + if loop: + # match loop=True's behavior with new times (count) mechinism. + times = -1 + elif times is None: + # no times specified, just once through + times = 1 + elif times == 0: + # it's a no-op, make a copy since we never mutate + return self._spawn(self._data) + + output = StringIO() + + seg1, seg2 = AudioSegment._sync(self, seg) + sample_width = seg1.sample_width + spawn = seg1._spawn + + output.write(seg1[:position]._data) + + # drop down to the raw data + seg1 = seg1[position:]._data + seg2 = seg2._data + pos = 0 + seg1_len = len(seg1) + seg2_len = len(seg2) + while times: + remaining = max(0, seg1_len - pos) + if seg2_len >= remaining: + seg2 = seg2[:remaining] + seg2_len = remaining + # we've hit the end, we're done looping (if we were) and this + # is our last go-around + times = 1 + + if gain_during_overlay: + seg1_overlaid = seg1[pos:pos + seg2_len] + seg1_adjusted_gain = audioop.mul(seg1_overlaid, self.sample_width, + db_to_float(float(gain_during_overlay))) + output.write(audioop.add(seg1_adjusted_gain, seg2, sample_width)) + else: + output.write(audioop.add(seg1[pos:pos + seg2_len], seg2, + sample_width)) + pos += seg2_len + + # dec times to break our while loop (eventually) + times -= 1 + + output.write(seg1[pos:]) + + return spawn(data=output) + + def append(self, seg, crossfade=100): + seg1, seg2 = AudioSegment._sync(self, seg) + + if not crossfade: + return seg1._spawn(seg1._data + seg2._data) + elif crossfade > len(self): + raise ValueError("Crossfade is longer than the original AudioSegment ({}ms > {}ms)".format( + crossfade, len(self) + )) + elif crossfade > len(seg): + raise ValueError("Crossfade is longer than the appended AudioSegment ({}ms > {}ms)".format( + crossfade, len(seg) + )) + + xf = seg1[-crossfade:].fade(to_gain=-120, start=0, end=float('inf')) + xf *= seg2[:crossfade].fade(from_gain=-120, start=0, end=float('inf')) + + output = TemporaryFile() + + output.write(seg1[:-crossfade]._data) + output.write(xf._data) + output.write(seg2[crossfade:]._data) + + output.seek(0) + obj = seg1._spawn(data=output) + output.close() + return obj + + def fade(self, to_gain=0, from_gain=0, start=None, end=None, + duration=None): + """ + Fade the volume of this audio segment. + + to_gain (float): + resulting volume_change in db + + start (int): + default = beginning of the segment + when in this segment to start fading in milliseconds + + end (int): + default = end of the segment + when in this segment to start fading in milliseconds + + duration (int): + default = until the end of the audio segment + the duration of the fade + """ + if None not in [duration, end, start]: + raise TypeError('Only two of the three arguments, "start", ' + '"end", and "duration" may be specified') + + # no fade == the same audio + if to_gain == 0 and from_gain == 0: + return self + + start = min(len(self), start) if start is not None else None + end = min(len(self), end) if end is not None else None + + if start is not None and start < 0: + start += len(self) + if end is not None and end < 0: + end += len(self) + + if duration is not None and duration < 0: + raise InvalidDuration("duration must be a positive integer") + + if duration: + if start is not None: + end = start + duration + elif end is not None: + start = end - duration + else: + duration = end - start + + from_power = db_to_float(from_gain) + + output = [] + + # original data - up until the crossfade portion, as is + before_fade = self[:start]._data + if from_gain != 0: + before_fade = audioop.mul(before_fade, + self.sample_width, + from_power) + output.append(before_fade) + + gain_delta = db_to_float(to_gain) - from_power + + # fades longer than 100ms can use coarse fading (one gain step per ms), + # shorter fades will have audible clicks so they use precise fading + # (one gain step per sample) + if duration > 100: + scale_step = gain_delta / duration + + for i in range(duration): + volume_change = from_power + (scale_step * i) + chunk = self[start + i] + chunk = audioop.mul(chunk._data, + self.sample_width, + volume_change) + + output.append(chunk) + else: + start_frame = self.frame_count(ms=start) + end_frame = self.frame_count(ms=end) + fade_frames = end_frame - start_frame + scale_step = gain_delta / fade_frames + + for i in range(int(fade_frames)): + volume_change = from_power + (scale_step * i) + sample = self.get_frame(int(start_frame + i)) + sample = audioop.mul(sample, self.sample_width, volume_change) + + output.append(sample) + + # original data after the crossfade portion, at the new volume + after_fade = self[end:]._data + if to_gain != 0: + after_fade = audioop.mul(after_fade, + self.sample_width, + db_to_float(to_gain)) + output.append(after_fade) + + return self._spawn(data=output) + + def fade_out(self, duration): + return self.fade(to_gain=-120, duration=duration, end=float('inf')) + + def fade_in(self, duration): + return self.fade(from_gain=-120, duration=duration, start=0) + + def reverse(self): + return self._spawn( + data=audioop.reverse(self._data, self.sample_width) + ) + + def _repr_html_(self): + src = """ + + """ + fh = self.export() + data = base64.b64encode(fh.read()).decode('ascii') + return src.format(base64=data) + + +from . import effects diff --git a/LXST/Codecs/libs/pydub/effects.py b/LXST/Codecs/libs/pydub/effects.py new file mode 100644 index 0000000..0210521 --- /dev/null +++ b/LXST/Codecs/libs/pydub/effects.py @@ -0,0 +1,341 @@ +import sys +import math +import array +from .utils import ( + db_to_float, + ratio_to_db, + register_pydub_effect, + make_chunks, + audioop, + get_min_max_value +) +from .silence import split_on_silence +from .exceptions import TooManyMissingFrames, InvalidDuration + +if sys.version_info >= (3, 0): + xrange = range + + +@register_pydub_effect +def apply_mono_filter_to_each_channel(seg, filter_fn): + n_channels = seg.channels + + channel_segs = seg.split_to_mono() + channel_segs = [filter_fn(channel_seg) for channel_seg in channel_segs] + + out_data = seg.get_array_of_samples() + for channel_i, channel_seg in enumerate(channel_segs): + for sample_i, sample in enumerate(channel_seg.get_array_of_samples()): + index = (sample_i * n_channels) + channel_i + out_data[index] = sample + + return seg._spawn(out_data) + + +@register_pydub_effect +def normalize(seg, headroom=0.1): + """ + headroom is how close to the maximum volume to boost the signal up to (specified in dB) + """ + peak_sample_val = seg.max + + # if the max is 0, this audio segment is silent, and can't be normalized + if peak_sample_val == 0: + return seg + + target_peak = seg.max_possible_amplitude * db_to_float(-headroom) + + needed_boost = ratio_to_db(target_peak / peak_sample_val) + return seg.apply_gain(needed_boost) + + +@register_pydub_effect +def speedup(seg, playback_speed=1.5, chunk_size=150, crossfade=25): + # we will keep audio in 150ms chunks since one waveform at 20Hz is 50ms long + # (20 Hz is the lowest frequency audible to humans) + + # portion of AUDIO TO KEEP. if playback speed is 1.25 we keep 80% (0.8) and + # discard 20% (0.2) + atk = 1.0 / playback_speed + + if playback_speed < 2.0: + # throwing out more than half the audio - keep 50ms chunks + ms_to_remove_per_chunk = int(chunk_size * (1 - atk) / atk) + else: + # throwing out less than half the audio - throw out 50ms chunks + ms_to_remove_per_chunk = int(chunk_size) + chunk_size = int(atk * chunk_size / (1 - atk)) + + # the crossfade cannot be longer than the amount of audio we're removing + crossfade = min(crossfade, ms_to_remove_per_chunk - 1) + + # DEBUG + #print("chunk: {0}, rm: {1}".format(chunk_size, ms_to_remove_per_chunk)) + + chunks = make_chunks(seg, chunk_size + ms_to_remove_per_chunk) + if len(chunks) < 2: + raise Exception("Could not speed up AudioSegment, it was too short {2:0.2f}s for the current settings:\n{0}ms chunks at {1:0.1f}x speedup".format( + chunk_size, playback_speed, seg.duration_seconds)) + + # we'll actually truncate a bit less than we calculated to make up for the + # crossfade between chunks + ms_to_remove_per_chunk -= crossfade + + # we don't want to truncate the last chunk since it is not guaranteed to be + # the full chunk length + last_chunk = chunks[-1] + chunks = [chunk[:-ms_to_remove_per_chunk] for chunk in chunks[:-1]] + + out = chunks[0] + for chunk in chunks[1:]: + out = out.append(chunk, crossfade=crossfade) + + out += last_chunk + return out + + +@register_pydub_effect +def strip_silence(seg, silence_len=1000, silence_thresh=-16, padding=100): + if padding > silence_len: + raise InvalidDuration("padding cannot be longer than silence_len") + + chunks = split_on_silence(seg, silence_len, silence_thresh, padding) + crossfade = padding / 2 + + if not len(chunks): + return seg[0:0] + + seg = chunks[0] + for chunk in chunks[1:]: + seg = seg.append(chunk, crossfade=crossfade) + + return seg + + +@register_pydub_effect +def compress_dynamic_range(seg, threshold=-20.0, ratio=4.0, attack=5.0, release=50.0): + """ + Keyword Arguments: + + threshold - default: -20.0 + Threshold in dBFS. default of -20.0 means -20dB relative to the + maximum possible volume. 0dBFS is the maximum possible value so + all values for this argument sould be negative. + + ratio - default: 4.0 + Compression ratio. Audio louder than the threshold will be + reduced to 1/ratio the volume. A ratio of 4.0 is equivalent to + a setting of 4:1 in a pro-audio compressor like the Waves C1. + + attack - default: 5.0 + Attack in milliseconds. How long it should take for the compressor + to kick in once the audio has exceeded the threshold. + + release - default: 50.0 + Release in milliseconds. How long it should take for the compressor + to stop compressing after the audio has falled below the threshold. + + + For an overview of Dynamic Range Compression, and more detailed explanation + of the related terminology, see: + + http://en.wikipedia.org/wiki/Dynamic_range_compression + """ + + thresh_rms = seg.max_possible_amplitude * db_to_float(threshold) + + look_frames = int(seg.frame_count(ms=attack)) + def rms_at(frame_i): + return seg.get_sample_slice(frame_i - look_frames, frame_i).rms + def db_over_threshold(rms): + if rms == 0: return 0.0 + db = ratio_to_db(rms / thresh_rms) + return max(db, 0) + + output = [] + + # amount to reduce the volume of the audio by (in dB) + attenuation = 0.0 + + attack_frames = seg.frame_count(ms=attack) + release_frames = seg.frame_count(ms=release) + for i in xrange(int(seg.frame_count())): + rms_now = rms_at(i) + + # with a ratio of 4.0 this means the volume will exceed the threshold by + # 1/4 the amount (of dB) that it would otherwise + max_attenuation = (1 - (1.0 / ratio)) * db_over_threshold(rms_now) + + attenuation_inc = max_attenuation / attack_frames + attenuation_dec = max_attenuation / release_frames + + if rms_now > thresh_rms and attenuation <= max_attenuation: + attenuation += attenuation_inc + attenuation = min(attenuation, max_attenuation) + else: + attenuation -= attenuation_dec + attenuation = max(attenuation, 0) + + frame = seg.get_frame(i) + if attenuation != 0.0: + frame = audioop.mul(frame, + seg.sample_width, + db_to_float(-attenuation)) + + output.append(frame) + + return seg._spawn(data=b''.join(output)) + + +# Invert the phase of the signal. + +@register_pydub_effect + +def invert_phase(seg, channels=(1, 1)): + """ + channels- specifies which channel (left or right) to reverse the phase of. + Note that mono AudioSegments will become stereo. + """ + if channels == (1, 1): + inverted = audioop.mul(seg._data, seg.sample_width, -1.0) + return seg._spawn(data=inverted) + + else: + if seg.channels == 2: + left, right = seg.split_to_mono() + else: + raise Exception("Can't implicitly convert an AudioSegment with " + str(seg.channels) + " channels to stereo.") + + if channels == (1, 0): + left = left.invert_phase() + else: + right = right.invert_phase() + + return seg.from_mono_audiosegments(left, right) + + + +# High and low pass filters based on implementation found on Stack Overflow: +# http://stackoverflow.com/questions/13882038/implementing-simple-high-and-low-pass-filters-in-c + +@register_pydub_effect +def low_pass_filter(seg, cutoff): + """ + cutoff - Frequency (in Hz) where higher frequency signal will begin to + be reduced by 6dB per octave (doubling in frequency) above this point + """ + RC = 1.0 / (cutoff * 2 * math.pi) + dt = 1.0 / seg.frame_rate + + alpha = dt / (RC + dt) + + original = seg.get_array_of_samples() + filteredArray = array.array(seg.array_type, original) + + frame_count = int(seg.frame_count()) + + last_val = [0] * seg.channels + for i in range(seg.channels): + last_val[i] = filteredArray[i] = original[i] + + for i in range(1, frame_count): + for j in range(seg.channels): + offset = (i * seg.channels) + j + last_val[j] = last_val[j] + (alpha * (original[offset] - last_val[j])) + filteredArray[offset] = int(last_val[j]) + + return seg._spawn(data=filteredArray) + + +@register_pydub_effect +def high_pass_filter(seg, cutoff): + """ + cutoff - Frequency (in Hz) where lower frequency signal will begin to + be reduced by 6dB per octave (doubling in frequency) below this point + """ + RC = 1.0 / (cutoff * 2 * math.pi) + dt = 1.0 / seg.frame_rate + + alpha = RC / (RC + dt) + + minval, maxval = get_min_max_value(seg.sample_width * 8) + + original = seg.get_array_of_samples() + filteredArray = array.array(seg.array_type, original) + + frame_count = int(seg.frame_count()) + + last_val = [0] * seg.channels + for i in range(seg.channels): + last_val[i] = filteredArray[i] = original[i] + + for i in range(1, frame_count): + for j in range(seg.channels): + offset = (i * seg.channels) + j + offset_minus_1 = ((i-1) * seg.channels) + j + + last_val[j] = alpha * (last_val[j] + original[offset] - original[offset_minus_1]) + filteredArray[offset] = int(min(max(last_val[j], minval), maxval)) + + return seg._spawn(data=filteredArray) + + +@register_pydub_effect +def pan(seg, pan_amount): + """ + pan_amount should be between -1.0 (100% left) and +1.0 (100% right) + + When pan_amount == 0.0 the left/right balance is not changed. + + Panning does not alter the *perceived* loundness, but since loudness + is decreasing on one side, the other side needs to get louder to + compensate. When panned hard left, the left channel will be 3dB louder. + """ + if not -1.0 <= pan_amount <= 1.0: + raise ValueError("pan_amount should be between -1.0 (100% left) and +1.0 (100% right)") + + max_boost_db = ratio_to_db(2.0) + boost_db = abs(pan_amount) * max_boost_db + + boost_factor = db_to_float(boost_db) + reduce_factor = db_to_float(max_boost_db) - boost_factor + + reduce_db = ratio_to_db(reduce_factor) + + # Cut boost in half (max boost== 3dB) - in reality 2 speakers + # do not sum to a full 6 dB. + boost_db = boost_db / 2.0 + + if pan_amount < 0: + return seg.apply_gain_stereo(boost_db, reduce_db) + else: + return seg.apply_gain_stereo(reduce_db, boost_db) + + +@register_pydub_effect +def apply_gain_stereo(seg, left_gain=0.0, right_gain=0.0): + """ + left_gain - amount of gain to apply to the left channel (in dB) + right_gain - amount of gain to apply to the right channel (in dB) + + note: mono audio segments will be converted to stereo + """ + if seg.channels == 1: + left = right = seg + elif seg.channels == 2: + left, right = seg.split_to_mono() + + l_mult_factor = db_to_float(left_gain) + r_mult_factor = db_to_float(right_gain) + + left_data = audioop.mul(left._data, left.sample_width, l_mult_factor) + left_data = audioop.tostereo(left_data, left.sample_width, 1, 0) + + right_data = audioop.mul(right._data, right.sample_width, r_mult_factor) + right_data = audioop.tostereo(right_data, right.sample_width, 0, 1) + + output = audioop.add(left_data, right_data, seg.sample_width) + + return seg._spawn(data=output, + overrides={'channels': 2, + 'frame_width': 2 * seg.sample_width}) diff --git a/LXST/Codecs/libs/pydub/exceptions.py b/LXST/Codecs/libs/pydub/exceptions.py new file mode 100644 index 0000000..79d0743 --- /dev/null +++ b/LXST/Codecs/libs/pydub/exceptions.py @@ -0,0 +1,32 @@ +class PydubException(Exception): + """ + Base class for any Pydub exception + """ + + +class TooManyMissingFrames(PydubException): + pass + + +class InvalidDuration(PydubException): + pass + + +class InvalidTag(PydubException): + pass + + +class InvalidID3TagVersion(PydubException): + pass + + +class CouldntDecodeError(PydubException): + pass + + +class CouldntEncodeError(PydubException): + pass + + +class MissingAudioParameter(PydubException): + pass diff --git a/LXST/Codecs/libs/pydub/generators.py b/LXST/Codecs/libs/pydub/generators.py new file mode 100644 index 0000000..b04cb4c --- /dev/null +++ b/LXST/Codecs/libs/pydub/generators.py @@ -0,0 +1,142 @@ +""" +Each generator will return float samples from -1.0 to 1.0, which can be +converted to actual audio with 8, 16, 24, or 32 bit depth using the +SiganlGenerator.to_audio_segment() method (on any of it's subclasses). + +See Wikipedia's "waveform" page for info on some of the generators included +here: http://en.wikipedia.org/wiki/Waveform +""" + +import math +import array +import itertools +import random +from .audio_segment import AudioSegment +from .utils import ( + db_to_float, + get_frame_width, + get_array_type, + get_min_max_value +) + + + +class SignalGenerator(object): + def __init__(self, sample_rate=44100, bit_depth=16): + self.sample_rate = sample_rate + self.bit_depth = bit_depth + + def to_audio_segment(self, duration=1000.0, volume=0.0): + """ + Duration in milliseconds + (default: 1 second) + Volume in DB relative to maximum amplitude + (default 0.0 dBFS, which is the maximum value) + """ + minval, maxval = get_min_max_value(self.bit_depth) + sample_width = get_frame_width(self.bit_depth) + array_type = get_array_type(self.bit_depth) + + gain = db_to_float(volume) + sample_count = int(self.sample_rate * (duration / 1000.0)) + + sample_data = (int(val * maxval * gain) for val in self.generate()) + sample_data = itertools.islice(sample_data, 0, sample_count) + + data = array.array(array_type, sample_data) + + try: + data = data.tobytes() + except: + data = data.tostring() + + return AudioSegment(data=data, metadata={ + "channels": 1, + "sample_width": sample_width, + "frame_rate": self.sample_rate, + "frame_width": sample_width, + }) + + def generate(self): + raise NotImplementedError("SignalGenerator subclasses must implement the generate() method, and *should not* call the superclass implementation.") + + + +class Sine(SignalGenerator): + def __init__(self, freq, **kwargs): + super(Sine, self).__init__(**kwargs) + self.freq = freq + + def generate(self): + sine_of = (self.freq * 2 * math.pi) / self.sample_rate + sample_n = 0 + while True: + yield math.sin(sine_of * sample_n) + sample_n += 1 + + + +class Pulse(SignalGenerator): + def __init__(self, freq, duty_cycle=0.5, **kwargs): + super(Pulse, self).__init__(**kwargs) + self.freq = freq + self.duty_cycle = duty_cycle + + def generate(self): + sample_n = 0 + + # in samples + cycle_length = self.sample_rate / float(self.freq) + pulse_length = cycle_length * self.duty_cycle + + while True: + if (sample_n % cycle_length) < pulse_length: + yield 1.0 + else: + yield -1.0 + sample_n += 1 + + + +class Square(Pulse): + def __init__(self, freq, **kwargs): + kwargs['duty_cycle'] = 0.5 + super(Square, self).__init__(freq, **kwargs) + + + +class Sawtooth(SignalGenerator): + def __init__(self, freq, duty_cycle=1.0, **kwargs): + super(Sawtooth, self).__init__(**kwargs) + self.freq = freq + self.duty_cycle = duty_cycle + + def generate(self): + sample_n = 0 + + # in samples + cycle_length = self.sample_rate / float(self.freq) + midpoint = cycle_length * self.duty_cycle + ascend_length = midpoint + descend_length = cycle_length - ascend_length + + while True: + cycle_position = sample_n % cycle_length + if cycle_position < midpoint: + yield (2 * cycle_position / ascend_length) - 1.0 + else: + yield 1.0 - (2 * (cycle_position - midpoint) / descend_length) + sample_n += 1 + + + +class Triangle(Sawtooth): + def __init__(self, freq, **kwargs): + kwargs['duty_cycle'] = 0.5 + super(Triangle, self).__init__(freq, **kwargs) + + +class WhiteNoise(SignalGenerator): + def generate(self): + while True: + yield (random.random() * 2) - 1.0 diff --git a/LXST/Codecs/libs/pydub/logging_utils.py b/LXST/Codecs/libs/pydub/logging_utils.py new file mode 100644 index 0000000..a312bd2 --- /dev/null +++ b/LXST/Codecs/libs/pydub/logging_utils.py @@ -0,0 +1,14 @@ +""" + +""" +import logging + +converter_logger = logging.getLogger("pydub.converter") + +def log_conversion(conversion_command): + converter_logger.debug("subprocess.call(%s)", repr(conversion_command)) + +def log_subprocess_output(output): + if output: + for line in output.rstrip().splitlines(): + converter_logger.debug('subprocess output: %s', line.rstrip()) diff --git a/LXST/Codecs/libs/pydub/playback.py b/LXST/Codecs/libs/pydub/playback.py new file mode 100644 index 0000000..72ce4a5 --- /dev/null +++ b/LXST/Codecs/libs/pydub/playback.py @@ -0,0 +1,71 @@ +""" +Support for playing AudioSegments. Pyaudio will be used if it's installed, +otherwise will fallback to ffplay. Pyaudio is a *much* nicer solution, but +is tricky to install. See my notes on installing pyaudio in a virtualenv (on +OSX 10.10): https://gist.github.com/jiaaro/9767512210a1d80a8a0d +""" + +import subprocess +from tempfile import NamedTemporaryFile +from .utils import get_player_name, make_chunks + +def _play_with_ffplay(seg): + PLAYER = get_player_name() + with NamedTemporaryFile("w+b", suffix=".wav") as f: + seg.export(f.name, "wav") + subprocess.call([PLAYER, "-nodisp", "-autoexit", "-hide_banner", f.name]) + + +def _play_with_pyaudio(seg): + import pyaudio + + p = pyaudio.PyAudio() + stream = p.open(format=p.get_format_from_width(seg.sample_width), + channels=seg.channels, + rate=seg.frame_rate, + output=True) + + # Just in case there were any exceptions/interrupts, we release the resource + # So as not to raise OSError: Device Unavailable should play() be used again + try: + # break audio into half-second chunks (to allows keyboard interrupts) + for chunk in make_chunks(seg, 500): + stream.write(chunk._data) + finally: + stream.stop_stream() + stream.close() + + p.terminate() + + +def _play_with_simpleaudio(seg): + import simpleaudio + return simpleaudio.play_buffer( + seg.raw_data, + num_channels=seg.channels, + bytes_per_sample=seg.sample_width, + sample_rate=seg.frame_rate + ) + + +def play(audio_segment): + try: + playback = _play_with_simpleaudio(audio_segment) + try: + playback.wait_done() + except KeyboardInterrupt: + playback.stop() + except ImportError: + pass + else: + return + + try: + _play_with_pyaudio(audio_segment) + return + except ImportError: + pass + else: + return + + _play_with_ffplay(audio_segment) diff --git a/LXST/Codecs/libs/pydub/pyaudioop.py b/LXST/Codecs/libs/pydub/pyaudioop.py new file mode 100644 index 0000000..c636a4a --- /dev/null +++ b/LXST/Codecs/libs/pydub/pyaudioop.py @@ -0,0 +1,591 @@ +try: + from __builtin__ import max as builtin_max + from __builtin__ import min as builtin_min +except ImportError: + from builtins import max as builtin_max + from builtins import min as builtin_min +import math +import struct +try: + from fractions import gcd +except ImportError: # Python 3.9+ + from math import gcd +from ctypes import create_string_buffer + + +class error(Exception): + pass + + +def _check_size(size): + if size != 1 and size != 2 and size != 4: + raise error("Size should be 1, 2 or 4") + + +def _check_params(length, size): + _check_size(size) + if length % size != 0: + raise error("not a whole number of frames") + + +def _sample_count(cp, size): + return len(cp) / size + + +def _get_samples(cp, size, signed=True): + for i in range(_sample_count(cp, size)): + yield _get_sample(cp, size, i, signed) + + +def _struct_format(size, signed): + if size == 1: + return "b" if signed else "B" + elif size == 2: + return "h" if signed else "H" + elif size == 4: + return "i" if signed else "I" + + +def _get_sample(cp, size, i, signed=True): + fmt = _struct_format(size, signed) + start = i * size + end = start + size + return struct.unpack_from(fmt, buffer(cp)[start:end])[0] + + +def _put_sample(cp, size, i, val, signed=True): + fmt = _struct_format(size, signed) + struct.pack_into(fmt, cp, i * size, val) + + +def _get_maxval(size, signed=True): + if signed and size == 1: + return 0x7f + elif size == 1: + return 0xff + elif signed and size == 2: + return 0x7fff + elif size == 2: + return 0xffff + elif signed and size == 4: + return 0x7fffffff + elif size == 4: + return 0xffffffff + + +def _get_minval(size, signed=True): + if not signed: + return 0 + elif size == 1: + return -0x80 + elif size == 2: + return -0x8000 + elif size == 4: + return -0x80000000 + + +def _get_clipfn(size, signed=True): + maxval = _get_maxval(size, signed) + minval = _get_minval(size, signed) + return lambda val: builtin_max(min(val, maxval), minval) + + +def _overflow(val, size, signed=True): + minval = _get_minval(size, signed) + maxval = _get_maxval(size, signed) + if minval <= val <= maxval: + return val + + bits = size * 8 + if signed: + offset = 2**(bits-1) + return ((val + offset) % (2**bits)) - offset + else: + return val % (2**bits) + + +def getsample(cp, size, i): + _check_params(len(cp), size) + if not (0 <= i < len(cp) / size): + raise error("Index out of range") + return _get_sample(cp, size, i) + + +def max(cp, size): + _check_params(len(cp), size) + + if len(cp) == 0: + return 0 + + return builtin_max(abs(sample) for sample in _get_samples(cp, size)) + + +def minmax(cp, size): + _check_params(len(cp), size) + + max_sample, min_sample = 0, 0 + for sample in _get_samples(cp, size): + max_sample = builtin_max(sample, max_sample) + min_sample = builtin_min(sample, min_sample) + + return min_sample, max_sample + + +def avg(cp, size): + _check_params(len(cp), size) + sample_count = _sample_count(cp, size) + if sample_count == 0: + return 0 + return sum(_get_samples(cp, size)) / sample_count + + +def rms(cp, size): + _check_params(len(cp), size) + + sample_count = _sample_count(cp, size) + if sample_count == 0: + return 0 + + sum_squares = sum(sample**2 for sample in _get_samples(cp, size)) + return int(math.sqrt(sum_squares / sample_count)) + + +def _sum2(cp1, cp2, length): + size = 2 + total = 0 + for i in range(length): + total += getsample(cp1, size, i) * getsample(cp2, size, i) + return total + + +def findfit(cp1, cp2): + size = 2 + + if len(cp1) % 2 != 0 or len(cp2) % 2 != 0: + raise error("Strings should be even-sized") + + if len(cp1) < len(cp2): + raise error("First sample should be longer") + + len1 = _sample_count(cp1, size) + len2 = _sample_count(cp2, size) + + sum_ri_2 = _sum2(cp2, cp2, len2) + sum_aij_2 = _sum2(cp1, cp1, len2) + sum_aij_ri = _sum2(cp1, cp2, len2) + + result = (sum_ri_2 * sum_aij_2 - sum_aij_ri * sum_aij_ri) / sum_aij_2 + + best_result = result + best_i = 0 + + for i in range(1, len1 - len2 + 1): + aj_m1 = _get_sample(cp1, size, i - 1) + aj_lm1 = _get_sample(cp1, size, i + len2 - 1) + + sum_aij_2 += aj_lm1**2 - aj_m1**2 + sum_aij_ri = _sum2(buffer(cp1)[i*size:], cp2, len2) + + result = (sum_ri_2 * sum_aij_2 - sum_aij_ri * sum_aij_ri) / sum_aij_2 + + if result < best_result: + best_result = result + best_i = i + + factor = _sum2(buffer(cp1)[best_i*size:], cp2, len2) / sum_ri_2 + + return best_i, factor + + +def findfactor(cp1, cp2): + size = 2 + + if len(cp1) % 2 != 0: + raise error("Strings should be even-sized") + + if len(cp1) != len(cp2): + raise error("Samples should be same size") + + sample_count = _sample_count(cp1, size) + + sum_ri_2 = _sum2(cp2, cp2, sample_count) + sum_aij_ri = _sum2(cp1, cp2, sample_count) + + return sum_aij_ri / sum_ri_2 + + +def findmax(cp, len2): + size = 2 + sample_count = _sample_count(cp, size) + + if len(cp) % 2 != 0: + raise error("Strings should be even-sized") + + if len2 < 0 or sample_count < len2: + raise error("Input sample should be longer") + + if sample_count == 0: + return 0 + + result = _sum2(cp, cp, len2) + best_result = result + best_i = 0 + + for i in range(1, sample_count - len2 + 1): + sample_leaving_window = getsample(cp, size, i - 1) + sample_entering_window = getsample(cp, size, i + len2 - 1) + + result -= sample_leaving_window**2 + result += sample_entering_window**2 + + if result > best_result: + best_result = result + best_i = i + + return best_i + + +def avgpp(cp, size): + _check_params(len(cp), size) + sample_count = _sample_count(cp, size) + + prevextremevalid = False + prevextreme = None + avg = 0 + nextreme = 0 + + prevval = getsample(cp, size, 0) + val = getsample(cp, size, 1) + + prevdiff = val - prevval + + for i in range(1, sample_count): + val = getsample(cp, size, i) + diff = val - prevval + + if diff * prevdiff < 0: + if prevextremevalid: + avg += abs(prevval - prevextreme) + nextreme += 1 + + prevextremevalid = True + prevextreme = prevval + + prevval = val + if diff != 0: + prevdiff = diff + + if nextreme == 0: + return 0 + + return avg / nextreme + + +def maxpp(cp, size): + _check_params(len(cp), size) + sample_count = _sample_count(cp, size) + + prevextremevalid = False + prevextreme = None + max = 0 + + prevval = getsample(cp, size, 0) + val = getsample(cp, size, 1) + + prevdiff = val - prevval + + for i in range(1, sample_count): + val = getsample(cp, size, i) + diff = val - prevval + + if diff * prevdiff < 0: + if prevextremevalid: + extremediff = abs(prevval - prevextreme) + if extremediff > max: + max = extremediff + prevextremevalid = True + prevextreme = prevval + + prevval = val + if diff != 0: + prevdiff = diff + + return max + + +def cross(cp, size): + _check_params(len(cp), size) + + crossings = 0 + last_sample = 0 + for sample in _get_samples(cp, size): + if sample <= 0 < last_sample or sample >= 0 > last_sample: + crossings += 1 + last_sample = sample + + return crossings + + +def mul(cp, size, factor): + _check_params(len(cp), size) + clip = _get_clipfn(size) + + result = create_string_buffer(len(cp)) + + for i, sample in enumerate(_get_samples(cp, size)): + sample = clip(int(sample * factor)) + _put_sample(result, size, i, sample) + + return result.raw + + +def tomono(cp, size, fac1, fac2): + _check_params(len(cp), size) + clip = _get_clipfn(size) + + sample_count = _sample_count(cp, size) + + result = create_string_buffer(len(cp) / 2) + + for i in range(0, sample_count, 2): + l_sample = getsample(cp, size, i) + r_sample = getsample(cp, size, i + 1) + + sample = (l_sample * fac1) + (r_sample * fac2) + sample = clip(sample) + + _put_sample(result, size, i / 2, sample) + + return result.raw + + +def tostereo(cp, size, fac1, fac2): + _check_params(len(cp), size) + + sample_count = _sample_count(cp, size) + + result = create_string_buffer(len(cp) * 2) + clip = _get_clipfn(size) + + for i in range(sample_count): + sample = _get_sample(cp, size, i) + + l_sample = clip(sample * fac1) + r_sample = clip(sample * fac2) + + _put_sample(result, size, i * 2, l_sample) + _put_sample(result, size, i * 2 + 1, r_sample) + + return result.raw + + +def add(cp1, cp2, size): + _check_params(len(cp1), size) + + if len(cp1) != len(cp2): + raise error("Lengths should be the same") + + clip = _get_clipfn(size) + sample_count = _sample_count(cp1, size) + result = create_string_buffer(len(cp1)) + + for i in range(sample_count): + sample1 = getsample(cp1, size, i) + sample2 = getsample(cp2, size, i) + + sample = clip(sample1 + sample2) + + _put_sample(result, size, i, sample) + + return result.raw + + +def bias(cp, size, bias): + _check_params(len(cp), size) + + result = create_string_buffer(len(cp)) + + for i, sample in enumerate(_get_samples(cp, size)): + sample = _overflow(sample + bias, size) + _put_sample(result, size, i, sample) + + return result.raw + + +def reverse(cp, size): + _check_params(len(cp), size) + sample_count = _sample_count(cp, size) + + result = create_string_buffer(len(cp)) + for i, sample in enumerate(_get_samples(cp, size)): + _put_sample(result, size, sample_count - i - 1, sample) + + return result.raw + + +def lin2lin(cp, size, size2): + _check_params(len(cp), size) + _check_size(size2) + + if size == size2: + return cp + + new_len = (len(cp) / size) * size2 + + result = create_string_buffer(new_len) + + for i in range(_sample_count(cp, size)): + sample = _get_sample(cp, size, i) + if size < size2: + sample = sample << (4 * size2 / size) + elif size > size2: + sample = sample >> (4 * size / size2) + + sample = _overflow(sample, size2) + + _put_sample(result, size2, i, sample) + + return result.raw + + +def ratecv(cp, size, nchannels, inrate, outrate, state, weightA=1, weightB=0): + _check_params(len(cp), size) + if nchannels < 1: + raise error("# of channels should be >= 1") + + bytes_per_frame = size * nchannels + frame_count = len(cp) / bytes_per_frame + + if bytes_per_frame / nchannels != size: + raise OverflowError("width * nchannels too big for a C int") + + if weightA < 1 or weightB < 0: + raise error("weightA should be >= 1, weightB should be >= 0") + + if len(cp) % bytes_per_frame != 0: + raise error("not a whole number of frames") + + if inrate <= 0 or outrate <= 0: + raise error("sampling rate not > 0") + + d = gcd(inrate, outrate) + inrate /= d + outrate /= d + + prev_i = [0] * nchannels + cur_i = [0] * nchannels + + if state is None: + d = -outrate + else: + d, samps = state + + if len(samps) != nchannels: + raise error("illegal state argument") + + prev_i, cur_i = zip(*samps) + prev_i, cur_i = list(prev_i), list(cur_i) + + q = frame_count / inrate + ceiling = (q + 1) * outrate + nbytes = ceiling * bytes_per_frame + + result = create_string_buffer(nbytes) + + samples = _get_samples(cp, size) + out_i = 0 + while True: + while d < 0: + if frame_count == 0: + samps = zip(prev_i, cur_i) + retval = result.raw + + # slice off extra bytes + trim_index = (out_i * bytes_per_frame) - len(retval) + retval = buffer(retval)[:trim_index] + + return (retval, (d, tuple(samps))) + + for chan in range(nchannels): + prev_i[chan] = cur_i[chan] + cur_i[chan] = samples.next() + + cur_i[chan] = ( + (weightA * cur_i[chan] + weightB * prev_i[chan]) + / (weightA + weightB) + ) + + frame_count -= 1 + d += outrate + + while d >= 0: + for chan in range(nchannels): + cur_o = ( + (prev_i[chan] * d + cur_i[chan] * (outrate - d)) + / outrate + ) + _put_sample(result, size, out_i, _overflow(cur_o, size)) + out_i += 1 + d -= inrate + +def _sign(num): + return -1 if num < 0 else 0 if num == 0 else 1 + +def lin2ulaw(cp, size): + maxval = _get_maxval(size) + result = create_string_buffer(len(cp)) + + for i in range(_sample_count(cp, size)): + sample = _get_sample(cp, size, i) + val = _sign(sample/maxval)*math.log(1+255*math.abs(sample/maxval))/math.log(1+255) + _put_sample(result, size, i, val) + + return result + +def ulaw2lin(cp, size): + maxval = _get_maxval(size) + result = create_string_buffer(len(cp)) + + for i in range(_sample_count(cp, size)): + sample = _get_sample(cp, size, i) + val = (_sign(sample)*((1+255)**math.abs(sample)-1)/255) * maxval + _put_sample(result, size, i, val) + + return result + +def lin2alaw(cp, size): + maxval = _get_maxval(size) + result = create_string_buffer(len(cp)) + + for i in range(_sample_count(cp, size)): + sample = _get_sample(cp, size, i) + val = None + if math.abs(sample/maxval) < 1/87.6: + val = _sign(sample/maxval)*87.6*math.abs(sample/maxval)/(1+math.log(87.6)) + else: + val = _sign(sample/maxval)*(1+math.log(87.6*math.abs(sample/maxval)))/(1+math.log(87.6)) + _put_sample(result, size, i, val) + + return result + +def alaw2lin(cp, size): + maxval = _get_maxval(size) + result = create_string_buffer(len(cp)) + + for i in range(_sample_count(cp, size)): + sample = _get_sample(cp, size, i) + val = None + if math.abs(sample) < 1/(1+math.log(87.6)): + val = _sign(sample) * math.abs(sample)*(1+math.log(87.6))/87.6 * maxval + else: + val = _sign(sample) * (math.e**(-1+math.abs(sample)*(1+math.log(87.6)))) / 87.6 * maxval + _put_sample(result, size, i, val) + + return result + +def lin2adpcm(cp, size, state): + raise NotImplementedError() + + +def adpcm2lin(cp, size, state): + raise NotImplementedError() diff --git a/LXST/Codecs/libs/pydub/scipy_effects.py b/LXST/Codecs/libs/pydub/scipy_effects.py new file mode 100644 index 0000000..abab2b4 --- /dev/null +++ b/LXST/Codecs/libs/pydub/scipy_effects.py @@ -0,0 +1,175 @@ +""" +This module provides scipy versions of high_pass_filter, and low_pass_filter +as well as an additional band_pass_filter. + +Of course, you will need to install scipy for these to work. + +When this module is imported the high and low pass filters from this module +will be used when calling audio_segment.high_pass_filter() and +audio_segment.high_pass_filter() instead of the slower, less powerful versions +provided by pydub.effects. +""" +from scipy.signal import butter, sosfilt +from .utils import (register_pydub_effect,stereo_to_ms,ms_to_stereo) + + +def _mk_butter_filter(freq, type, order): + """ + Args: + freq: The cutoff frequency for highpass and lowpass filters. For + band filters, a list of [low_cutoff, high_cutoff] + type: "lowpass", "highpass", or "band" + order: nth order butterworth filter (default: 5th order). The + attenuation is -6dB/octave beyond the cutoff frequency (for 1st + order). A Higher order filter will have more attenuation, each level + adding an additional -6dB (so a 3rd order butterworth filter would + be -18dB/octave). + + Returns: + function which can filter a mono audio segment + + """ + def filter_fn(seg): + assert seg.channels == 1 + + nyq = 0.5 * seg.frame_rate + try: + freqs = [f / nyq for f in freq] + except TypeError: + freqs = freq / nyq + + sos = butter(order, freqs, btype=type, output='sos') + y = sosfilt(sos, seg.get_array_of_samples()) + + return seg._spawn(y.astype(seg.array_type)) + + return filter_fn + + +@register_pydub_effect +def band_pass_filter(seg, low_cutoff_freq, high_cutoff_freq, order=5): + filter_fn = _mk_butter_filter([low_cutoff_freq, high_cutoff_freq], 'band', order=order) + return seg.apply_mono_filter_to_each_channel(filter_fn) + + +@register_pydub_effect +def high_pass_filter(seg, cutoff_freq, order=5): + filter_fn = _mk_butter_filter(cutoff_freq, 'highpass', order=order) + return seg.apply_mono_filter_to_each_channel(filter_fn) + + +@register_pydub_effect +def low_pass_filter(seg, cutoff_freq, order=5): + filter_fn = _mk_butter_filter(cutoff_freq, 'lowpass', order=order) + return seg.apply_mono_filter_to_each_channel(filter_fn) + + +@register_pydub_effect +def _eq(seg, focus_freq, bandwidth=100, mode="peak", gain_dB=0, order=2): + """ + Args: + focus_freq - middle frequency or known frequency of band (in Hz) + bandwidth - range of the equalizer band + mode - Mode of Equalization(Peak/Notch(Bell Curve),High Shelf, Low Shelf) + order - Rolloff factor(1 - 6dB/Octave 2 - 12dB/Octave) + + Returns: + Equalized/Filtered AudioSegment + """ + filt_mode = ["peak", "low_shelf", "high_shelf"] + if mode not in filt_mode: + raise ValueError("Incorrect Mode Selection") + + if gain_dB >= 0: + if mode == "peak": + sec = band_pass_filter(seg, focus_freq - bandwidth/2, focus_freq + bandwidth/2, order = order) + seg = seg.overlay(sec - (3 - gain_dB)) + return seg + + if mode == "low_shelf": + sec = low_pass_filter(seg, focus_freq, order=order) + seg = seg.overlay(sec - (3 - gain_dB)) + return seg + + if mode == "high_shelf": + sec = high_pass_filter(seg, focus_freq, order=order) + seg = seg.overlay(sec - (3 - gain_dB)) + return seg + + if gain_dB < 0: + if mode == "peak": + sec = high_pass_filter(seg, focus_freq - bandwidth/2, order=order) + seg = seg.overlay(sec - (3 + gain_dB)) + gain_dB + sec = low_pass_filter(seg, focus_freq + bandwidth/2, order=order) + seg = seg.overlay(sec - (3 + gain_dB)) + gain_dB + return seg + + if mode == "low_shelf": + sec = high_pass_filter(seg, focus_freq, order=order) + seg = seg.overlay(sec - (3 + gain_dB)) + gain_dB + return seg + + if mode=="high_shelf": + sec=low_pass_filter(seg, focus_freq, order=order) + seg=seg.overlay(sec - (3 + gain_dB)) +gain_dB + return seg + + +@register_pydub_effect +def eq(seg, focus_freq, bandwidth=100, channel_mode="L+R", filter_mode="peak", gain_dB=0, order=2): + """ + Args: + focus_freq - middle frequency or known frequency of band (in Hz) + bandwidth - range of the equalizer band + channel_mode - Select Channels to be affected by the filter. + L+R - Standard Stereo Filter + L - Only Left Channel is Filtered + R - Only Right Channel is Filtered + M+S - Blumlien Stereo Filter(Mid-Side) + M - Only Mid Channel is Filtered + S - Only Side Channel is Filtered + Mono Audio Segments are completely filtered. + filter_mode - Mode of Equalization(Peak/Notch(Bell Curve),High Shelf, Low Shelf) + order - Rolloff factor(1 - 6dB/Octave 2 - 12dB/Octave) + + Returns: + Equalized/Filtered AudioSegment + """ + channel_modes = ["L+R", "M+S", "L", "R", "M", "S"] + if channel_mode not in channel_modes: + raise ValueError("Incorrect Channel Mode Selection") + + if seg.channels == 1: + return _eq(seg, focus_freq, bandwidth, filter_mode, gain_dB, order) + + if channel_mode == "L+R": + return _eq(seg, focus_freq, bandwidth, filter_mode, gain_dB, order) + + if channel_mode == "L": + seg = seg.split_to_mono() + seg = [_eq(seg[0], focus_freq, bandwidth, filter_mode, gain_dB, order), seg[1]] + return AudioSegment.from_mono_audio_segements(seg[0], seg[1]) + + if channel_mode == "R": + seg = seg.split_to_mono() + seg = [seg[0], _eq(seg[1], focus_freq, bandwidth, filter_mode, gain_dB, order)] + return AudioSegment.from_mono_audio_segements(seg[0], seg[1]) + + if channel_mode == "M+S": + seg = stereo_to_ms(seg) + seg = _eq(seg, focus_freq, bandwidth, filter_mode, gain_dB, order) + return ms_to_stereo(seg) + + if channel_mode == "M": + seg = stereo_to_ms(seg).split_to_mono() + seg = [_eq(seg[0], focus_freq, bandwidth, filter_mode, gain_dB, order), seg[1]] + seg = AudioSegment.from_mono_audio_segements(seg[0], seg[1]) + return ms_to_stereo(seg) + + if channel_mode == "S": + seg = stereo_to_ms(seg).split_to_mono() + seg = [seg[0], _eq(seg[1], focus_freq, bandwidth, filter_mode, gain_dB, order)] + seg = AudioSegment.from_mono_audio_segements(seg[0], seg[1]) + return ms_to_stereo(seg) + + diff --git a/LXST/Codecs/libs/pydub/silence.py b/LXST/Codecs/libs/pydub/silence.py new file mode 100644 index 0000000..0ad1499 --- /dev/null +++ b/LXST/Codecs/libs/pydub/silence.py @@ -0,0 +1,182 @@ +""" +Various functions for finding/manipulating silence in AudioSegments +""" +import itertools + +from .utils import db_to_float + + +def detect_silence(audio_segment, min_silence_len=1000, silence_thresh=-16, seek_step=1): + """ + Returns a list of all silent sections [start, end] in milliseconds of audio_segment. + Inverse of detect_nonsilent() + + audio_segment - the segment to find silence in + min_silence_len - the minimum length for any silent section + silence_thresh - the upper bound for how quiet is silent in dFBS + seek_step - step size for interating over the segment in ms + """ + seg_len = len(audio_segment) + + # you can't have a silent portion of a sound that is longer than the sound + if seg_len < min_silence_len: + return [] + + # convert silence threshold to a float value (so we can compare it to rms) + silence_thresh = db_to_float(silence_thresh) * audio_segment.max_possible_amplitude + + # find silence and add start and end indicies to the to_cut list + silence_starts = [] + + # check successive (1 sec by default) chunk of sound for silence + # try a chunk at every "seek step" (or every chunk for a seek step == 1) + last_slice_start = seg_len - min_silence_len + slice_starts = range(0, last_slice_start + 1, seek_step) + + # guarantee last_slice_start is included in the range + # to make sure the last portion of the audio is searched + if last_slice_start % seek_step: + slice_starts = itertools.chain(slice_starts, [last_slice_start]) + + for i in slice_starts: + audio_slice = audio_segment[i:i + min_silence_len] + if audio_slice.rms <= silence_thresh: + silence_starts.append(i) + + # short circuit when there is no silence + if not silence_starts: + return [] + + # combine the silence we detected into ranges (start ms - end ms) + silent_ranges = [] + + prev_i = silence_starts.pop(0) + current_range_start = prev_i + + for silence_start_i in silence_starts: + continuous = (silence_start_i == prev_i + seek_step) + + # sometimes two small blips are enough for one particular slice to be + # non-silent, despite the silence all running together. Just combine + # the two overlapping silent ranges. + silence_has_gap = silence_start_i > (prev_i + min_silence_len) + + if not continuous and silence_has_gap: + silent_ranges.append([current_range_start, + prev_i + min_silence_len]) + current_range_start = silence_start_i + prev_i = silence_start_i + + silent_ranges.append([current_range_start, + prev_i + min_silence_len]) + + return silent_ranges + + +def detect_nonsilent(audio_segment, min_silence_len=1000, silence_thresh=-16, seek_step=1): + """ + Returns a list of all nonsilent sections [start, end] in milliseconds of audio_segment. + Inverse of detect_silent() + + audio_segment - the segment to find silence in + min_silence_len - the minimum length for any silent section + silence_thresh - the upper bound for how quiet is silent in dFBS + seek_step - step size for interating over the segment in ms + """ + silent_ranges = detect_silence(audio_segment, min_silence_len, silence_thresh, seek_step) + len_seg = len(audio_segment) + + # if there is no silence, the whole thing is nonsilent + if not silent_ranges: + return [[0, len_seg]] + + # short circuit when the whole audio segment is silent + if silent_ranges[0][0] == 0 and silent_ranges[0][1] == len_seg: + return [] + + prev_end_i = 0 + nonsilent_ranges = [] + for start_i, end_i in silent_ranges: + nonsilent_ranges.append([prev_end_i, start_i]) + prev_end_i = end_i + + if end_i != len_seg: + nonsilent_ranges.append([prev_end_i, len_seg]) + + if nonsilent_ranges[0] == [0, 0]: + nonsilent_ranges.pop(0) + + return nonsilent_ranges + + +def split_on_silence(audio_segment, min_silence_len=1000, silence_thresh=-16, keep_silence=100, + seek_step=1): + """ + Returns list of audio segments from splitting audio_segment on silent sections + + audio_segment - original pydub.AudioSegment() object + + min_silence_len - (in ms) minimum length of a silence to be used for + a split. default: 1000ms + + silence_thresh - (in dBFS) anything quieter than this will be + considered silence. default: -16dBFS + + keep_silence - (in ms or True/False) leave some silence at the beginning + and end of the chunks. Keeps the sound from sounding like it + is abruptly cut off. + When the length of the silence is less than the keep_silence duration + it is split evenly between the preceding and following non-silent + segments. + If True is specified, all the silence is kept, if False none is kept. + default: 100ms + + seek_step - step size for interating over the segment in ms + """ + + # from the itertools documentation + def pairwise(iterable): + "s -> (s0,s1), (s1,s2), (s2, s3), ..." + a, b = itertools.tee(iterable) + next(b, None) + return zip(a, b) + + if isinstance(keep_silence, bool): + keep_silence = len(audio_segment) if keep_silence else 0 + + output_ranges = [ + [ start - keep_silence, end + keep_silence ] + for (start,end) + in detect_nonsilent(audio_segment, min_silence_len, silence_thresh, seek_step) + ] + + for range_i, range_ii in pairwise(output_ranges): + last_end = range_i[1] + next_start = range_ii[0] + if next_start < last_end: + range_i[1] = (last_end+next_start)//2 + range_ii[0] = range_i[1] + + return [ + audio_segment[ max(start,0) : min(end,len(audio_segment)) ] + for start,end in output_ranges + ] + + +def detect_leading_silence(sound, silence_threshold=-50.0, chunk_size=10): + """ + Returns the millisecond/index that the leading silence ends. + + audio_segment - the segment to find silence in + silence_threshold - the upper bound for how quiet is silent in dFBS + chunk_size - chunk size for interating over the segment in ms + """ + trim_ms = 0 # ms + assert chunk_size > 0 # to avoid infinite loop + while sound[trim_ms:trim_ms+chunk_size].dBFS < silence_threshold and trim_ms < len(sound): + trim_ms += chunk_size + + # if there is no end it should return the length of the segment + return min(trim_ms, len(sound)) + + diff --git a/LXST/Codecs/libs/pydub/utils.py b/LXST/Codecs/libs/pydub/utils.py new file mode 100644 index 0000000..cb60ec9 --- /dev/null +++ b/LXST/Codecs/libs/pydub/utils.py @@ -0,0 +1,434 @@ +from __future__ import division + +import json +import os +import re +import sys +from subprocess import Popen, PIPE +from math import log, ceil +from tempfile import TemporaryFile +from warnings import warn +from functools import wraps + +try: + import audioop +except ImportError: + import pyaudioop as audioop + +if sys.version_info >= (3, 0): + basestring = str + +FRAME_WIDTHS = { + 8: 1, + 16: 2, + 32: 4, +} +ARRAY_TYPES = { + 8: "b", + 16: "h", + 32: "i", +} +ARRAY_RANGES = { + 8: (-0x80, 0x7f), + 16: (-0x8000, 0x7fff), + 32: (-0x80000000, 0x7fffffff), +} + + +def get_frame_width(bit_depth): + return FRAME_WIDTHS[bit_depth] + + +def get_array_type(bit_depth, signed=True): + t = ARRAY_TYPES[bit_depth] + if not signed: + t = t.upper() + return t + + +def get_min_max_value(bit_depth): + return ARRAY_RANGES[bit_depth] + + +def _fd_or_path_or_tempfile(fd, mode='w+b', tempfile=True): + close_fd = False + if fd is None and tempfile: + fd = TemporaryFile(mode=mode) + close_fd = True + + if isinstance(fd, basestring): + fd = open(fd, mode=mode) + close_fd = True + + try: + if isinstance(fd, os.PathLike): + fd = open(fd, mode=mode) + close_fd = True + except AttributeError: + # module os has no attribute PathLike, so we're on python < 3.6. + # The protocol we're trying to support doesn't exist, so just pass. + pass + + return fd, close_fd + + +def db_to_float(db, using_amplitude=True): + """ + Converts the input db to a float, which represents the equivalent + ratio in power. + """ + db = float(db) + if using_amplitude: + return 10 ** (db / 20) + else: # using power + return 10 ** (db / 10) + + +def ratio_to_db(ratio, val2=None, using_amplitude=True): + """ + Converts the input float to db, which represents the equivalent + to the ratio in power represented by the multiplier passed in. + """ + ratio = float(ratio) + + # accept 2 values and use the ratio of val1 to val2 + if val2 is not None: + ratio = ratio / val2 + + # special case for multiply-by-zero (convert to silence) + if ratio == 0: + return -float('inf') + + if using_amplitude: + return 20 * log(ratio, 10) + else: # using power + return 10 * log(ratio, 10) + + +def register_pydub_effect(fn, name=None): + """ + decorator for adding pydub effects to the AudioSegment objects. + example use: + @register_pydub_effect + def normalize(audio_segment): + ... + or you can specify a name: + @register_pydub_effect("normalize") + def normalize_audio_segment(audio_segment): + ... + """ + if isinstance(fn, basestring): + name = fn + return lambda fn: register_pydub_effect(fn, name) + + if name is None: + name = fn.__name__ + + from .audio_segment import AudioSegment + setattr(AudioSegment, name, fn) + return fn + + +def make_chunks(audio_segment, chunk_length): + """ + Breaks an AudioSegment into chunks that are milliseconds + long. + if chunk_length is 50 then you'll get a list of 50 millisecond long audio + segments back (except the last one, which can be shorter) + """ + number_of_chunks = ceil(len(audio_segment) / float(chunk_length)) + return [audio_segment[i * chunk_length:(i + 1) * chunk_length] + for i in range(int(number_of_chunks))] + + +def which(program): + """ + Mimics behavior of UNIX which command. + """ + # Add .exe program extension for windows support + if os.name == "nt" and not program.endswith(".exe"): + program += ".exe" + + envdir_list = [os.curdir] + os.environ["PATH"].split(os.pathsep) + + for envdir in envdir_list: + program_path = os.path.join(envdir, program) + if os.path.isfile(program_path) and os.access(program_path, os.X_OK): + return program_path + + +def get_encoder_name(): + """ + Return enconder default application for system, either avconv or ffmpeg + """ + if which("avconv"): + return "avconv" + elif which("ffmpeg"): + return "ffmpeg" + else: + # should raise exception + warn("Couldn't find ffmpeg or avconv - defaulting to ffmpeg, but may not work", RuntimeWarning) + return "ffmpeg" + + +def get_player_name(): + """ + Return enconder default application for system, either avconv or ffmpeg + """ + if which("avplay"): + return "avplay" + elif which("ffplay"): + return "ffplay" + else: + # should raise exception + warn("Couldn't find ffplay or avplay - defaulting to ffplay, but may not work", RuntimeWarning) + return "ffplay" + + +def get_prober_name(): + """ + Return probe application, either avconv or ffmpeg + """ + if which("avprobe"): + return "avprobe" + elif which("ffprobe"): + return "ffprobe" + else: + # should raise exception + warn("Couldn't find ffprobe or avprobe - defaulting to ffprobe, but may not work", RuntimeWarning) + return "ffprobe" + + +def fsdecode(filename): + """Wrapper for os.fsdecode which was introduced in python 3.2 .""" + + if sys.version_info >= (3, 2): + PathLikeTypes = (basestring, bytes) + if sys.version_info >= (3, 6): + PathLikeTypes += (os.PathLike,) + if isinstance(filename, PathLikeTypes): + return os.fsdecode(filename) + else: + if isinstance(filename, bytes): + return filename.decode(sys.getfilesystemencoding()) + if isinstance(filename, basestring): + return filename + + raise TypeError("type {0} not accepted by fsdecode".format(type(filename))) + + +def get_extra_info(stderr): + """ + avprobe sometimes gives more information on stderr than + on the json output. The information has to be extracted + from stderr of the format of: + ' Stream #0:0: Audio: flac, 88200 Hz, stereo, s32 (24 bit)' + or (macOS version): + ' Stream #0:0: Audio: vorbis' + ' 44100 Hz, stereo, fltp, 320 kb/s' + + :type stderr: str + :rtype: list of dict + """ + extra_info = {} + + re_stream = r'(?P +)Stream #0[:\.](?P([0-9]+))(?P.+)\n?(?! *Stream)((?P +)(?P.+))?' + for i in re.finditer(re_stream, stderr): + if i.group('space_end') is not None and len(i.group('space_start')) <= len( + i.group('space_end')): + content_line = ','.join([i.group('content_0'), i.group('content_1')]) + else: + content_line = i.group('content_0') + tokens = [x.strip() for x in re.split('[:,]', content_line) if x] + extra_info[int(i.group('stream_id'))] = tokens + return extra_info + + +def mediainfo_json(filepath, read_ahead_limit=-1): + """Return json dictionary with media info(codec, duration, size, bitrate...) from filepath + """ + prober = get_prober_name() + command_args = [ + "-v", "info", + "-show_format", + "-show_streams", + ] + try: + command_args += [fsdecode(filepath)] + stdin_parameter = None + stdin_data = None + except TypeError: + if prober == 'ffprobe': + command_args += ["-read_ahead_limit", str(read_ahead_limit), + "cache:pipe:0"] + else: + command_args += ["-"] + stdin_parameter = PIPE + file, close_file = _fd_or_path_or_tempfile(filepath, 'rb', tempfile=False) + file.seek(0) + stdin_data = file.read() + if close_file: + file.close() + + command = [prober, '-of', 'json'] + command_args + res = Popen(command, stdin=stdin_parameter, stdout=PIPE, stderr=PIPE) + output, stderr = res.communicate(input=stdin_data) + output = output.decode("utf-8", 'ignore') + stderr = stderr.decode("utf-8", 'ignore') + + info = json.loads(output) + + if not info: + # If ffprobe didn't give any information, just return it + # (for example, because the file doesn't exist) + return info + + extra_info = get_extra_info(stderr) + + audio_streams = [x for x in info['streams'] if x['codec_type'] == 'audio'] + if len(audio_streams) == 0: + return info + + # We just operate on the first audio stream in case there are more + stream = audio_streams[0] + + def set_property(stream, prop, value): + if prop not in stream or stream[prop] == 0: + stream[prop] = value + + for token in extra_info[stream['index']]: + m = re.match(r'([su]([0-9]{1,2})p?) \(([0-9]{1,2}) bit\)$', token) + m2 = re.match(r'([su]([0-9]{1,2})p?)( \(default\))?$', token) + if m: + set_property(stream, 'sample_fmt', m.group(1)) + set_property(stream, 'bits_per_sample', int(m.group(2))) + set_property(stream, 'bits_per_raw_sample', int(m.group(3))) + elif m2: + set_property(stream, 'sample_fmt', m2.group(1)) + set_property(stream, 'bits_per_sample', int(m2.group(2))) + set_property(stream, 'bits_per_raw_sample', int(m2.group(2))) + elif re.match(r'(flt)p?( \(default\))?$', token): + set_property(stream, 'sample_fmt', token) + set_property(stream, 'bits_per_sample', 32) + set_property(stream, 'bits_per_raw_sample', 32) + elif re.match(r'(dbl)p?( \(default\))?$', token): + set_property(stream, 'sample_fmt', token) + set_property(stream, 'bits_per_sample', 64) + set_property(stream, 'bits_per_raw_sample', 64) + return info + + +def mediainfo(filepath): + """Return dictionary with media info(codec, duration, size, bitrate...) from filepath + """ + + prober = get_prober_name() + command_args = [ + "-v", "quiet", + "-show_format", + "-show_streams", + filepath + ] + + command = [prober, '-of', 'old'] + command_args + res = Popen(command, stdout=PIPE) + output = res.communicate()[0].decode("utf-8") + + if res.returncode != 0: + command = [prober] + command_args + output = Popen(command, stdout=PIPE).communicate()[0].decode("utf-8") + + rgx = re.compile(r"(?:(?P.*?):)?(?P.*?)\=(?P.*?)$") + info = {} + + if sys.platform == 'win32': + output = output.replace("\r", "") + + for line in output.split("\n"): + # print(line) + mobj = rgx.match(line) + + if mobj: + # print(mobj.groups()) + inner_dict, key, value = mobj.groups() + + if inner_dict: + try: + info[inner_dict] + except KeyError: + info[inner_dict] = {} + info[inner_dict][key] = value + else: + info[key] = value + + return info + + +def cache_codecs(function): + cache = {} + + @wraps(function) + def wrapper(): + try: + return cache[0] + except: + cache[0] = function() + return cache[0] + + return wrapper + + +@cache_codecs +def get_supported_codecs(): + encoder = get_encoder_name() + command = [encoder, "-codecs"] + res = Popen(command, stdout=PIPE, stderr=PIPE) + output = res.communicate()[0].decode("utf-8") + if res.returncode != 0: + return [] + + if sys.platform == 'win32': + output = output.replace("\r", "") + + + rgx = re.compile(r"^([D.][E.][AVS.][I.][L.][S.]) (\w*) +(.*)") + decoders = set() + encoders = set() + for line in output.split('\n'): + match = rgx.match(line.strip()) + if not match: + continue + flags, codec, name = match.groups() + + if flags[0] == 'D': + decoders.add(codec) + + if flags[1] == 'E': + encoders.add(codec) + + return (decoders, encoders) + + +def get_supported_decoders(): + return get_supported_codecs()[0] + + +def get_supported_encoders(): + return get_supported_codecs()[1] + +def stereo_to_ms(audio_segment): + ''' + Left-Right -> Mid-Side + ''' + channel = audio_segment.split_to_mono() + channel = [channel[0].overlay(channel[1]), channel[0].overlay(channel[1].invert_phase())] + return AudioSegment.from_mono_audiosegments(channel[0], channel[1]) + +def ms_to_stereo(audio_segment): + ''' + Mid-Side -> Left-Right + ''' + channel = audio_segment.split_to_mono() + channel = [channel[0].overlay(channel[1]) - 3, channel[0].overlay(channel[1].invert_phase()) - 3] + return AudioSegment.from_mono_audiosegments(channel[0], channel[1]) + diff --git a/LXST/Codecs/libs/pyogg/__init__.py b/LXST/Codecs/libs/pyogg/__init__.py new file mode 100644 index 0000000..a97b0d2 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/__init__.py @@ -0,0 +1,108 @@ +import ctypes + +from .pyogg_error import PyOggError +from .ogg import PYOGG_OGG_AVAIL +from .vorbis import PYOGG_VORBIS_AVAIL, PYOGG_VORBIS_FILE_AVAIL, PYOGG_VORBIS_ENC_AVAIL +from .opus import PYOGG_OPUS_AVAIL, PYOGG_OPUS_FILE_AVAIL, PYOGG_OPUS_ENC_AVAIL +from .flac import PYOGG_FLAC_AVAIL + + +#: PyOgg version number. Versions should comply with PEP440. +__version__ = '0.7' + + +if (PYOGG_OGG_AVAIL and PYOGG_VORBIS_AVAIL and PYOGG_VORBIS_FILE_AVAIL): + # VorbisFile + from .vorbis_file import VorbisFile + # VorbisFileStream + from .vorbis_file_stream import VorbisFileStream + +else: + class VorbisFile: # type: ignore + def __init__(*args, **kw): + if not PYOGG_OGG_AVAIL: + raise PyOggError("The Ogg library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + raise PyOggError("The Vorbis libraries weren't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + + class VorbisFileStream: # type: ignore + def __init__(*args, **kw): + if not PYOGG_OGG_AVAIL: + raise PyOggError("The Ogg library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + raise PyOggError("The Vorbis libraries weren't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + + + +if (PYOGG_OGG_AVAIL and PYOGG_OPUS_AVAIL and PYOGG_OPUS_FILE_AVAIL): + # OpusFile + from .opus_file import OpusFile + # OpusFileStream + from .opus_file_stream import OpusFileStream + +else: + class OpusFile: # type: ignore + def __init__(*args, **kw): + if not PYOGG_OGG_AVAIL: + raise PyOggError("The Ogg library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + if not PYOGG_OPUS_AVAIL: + raise PyOggError("The Opus library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + if not PYOGG_OPUS_FILE_AVAIL: + raise PyOggError("The OpusFile library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + raise PyOggError("Unknown initialisation error") + + class OpusFileStream: # type: ignore + def __init__(*args, **kw): + if not PYOGG_OGG_AVAIL: + raise PyOggError("The Ogg library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + if not PYOGG_OPUS_AVAIL: + raise PyOggError("The Opus library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + if not PYOGG_OPUS_FILE_AVAIL: + raise PyOggError("The OpusFile library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + raise PyOggError("Unknown initialisation error") + + +if PYOGG_OPUS_AVAIL: + # OpusEncoder + from .opus_encoder import OpusEncoder + # OpusBufferedEncoder + from .opus_buffered_encoder import OpusBufferedEncoder + # OpusDecoder + from .opus_decoder import OpusDecoder + +else: + class OpusEncoder: # type: ignore + def __init__(*args, **kw): + raise PyOggError("The Opus library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + + class OpusBufferedEncoder: # type: ignore + def __init__(*args, **kw): + raise PyOggError("The Opus library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + + class OpusDecoder: # type: ignore + def __init__(*args, **kw): + raise PyOggError("The Opus library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + +if (PYOGG_OGG_AVAIL and PYOGG_OPUS_AVAIL): + # OggOpusWriter + from .ogg_opus_writer import OggOpusWriter + +else: + class OggOpusWriter: # type: ignore + def __init__(*args, **kw): + if not PYOGG_OGG_AVAIL: + raise PyOggError("The Ogg library wasn't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + raise PyOggError("The Opus library was't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + + +if PYOGG_FLAC_AVAIL: + # FlacFile + from .flac_file import FlacFile + # FlacFileStream + from .flac_file_stream import FlacFileStream +else: + class FlacFile: # type: ignore + def __init__(*args, **kw): + raise PyOggError("The FLAC libraries weren't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") + + class FlacFileStream: # type: ignore + def __init__(*args, **kw): + raise PyOggError("The FLAC libraries weren't found or couldn't be loaded (maybe you're trying to use 64bit libraries with 32bit Python?)") diff --git a/LXST/Codecs/libs/pyogg/audio_file.py b/LXST/Codecs/libs/pyogg/audio_file.py new file mode 100644 index 0000000..4fb77a2 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/audio_file.py @@ -0,0 +1,59 @@ +from .pyogg_error import PyOggError + +class AudioFile: + """Abstract base class for audio files. + + This class is a base class for audio files (such as Vorbis, Opus, + and FLAC). It should not be instatiated directly. + """ + + def __init__(self): + raise PyOggError("AudioFile is an Abstract Base Class "+ + "and should not be instantiated") + + def as_array(self): + """Returns the buffer as a NumPy array. + + The shape of the returned array is in units of (number of + samples per channel, number of channels). + + The data type is either 8-bit or 16-bit signed integers, + depending on bytes_per_sample. + + The buffer is not copied, but rather the NumPy array + shares the memory with the buffer. + + """ + # Assumes that self.buffer is a one-dimensional array of + # bytes and that channels are interleaved. + + import numpy # type: ignore + + assert self.buffer is not None + assert self.channels is not None + + # The following code assumes that the bytes in the buffer + # represent 8-bit or 16-bit signed ints. Ensure the number of + # bytes per sample matches that assumption. + assert self.bytes_per_sample == 1 or self.bytes_per_sample == 2 + + # Create a dictionary mapping bytes per sample to numpy data + # types + dtype = { + 1: numpy.int8, + 2: numpy.int16 + } + + # Convert the ctypes buffer to a NumPy array + array = numpy.frombuffer( + self.buffer, + dtype=dtype[self.bytes_per_sample] + ) + + # Reshape the array + return array.reshape( + (len(self.buffer) + // self.bytes_per_sample + // self.channels, + self.channels) + ) diff --git a/LXST/Codecs/libs/pyogg/flac.py b/LXST/Codecs/libs/pyogg/flac.py new file mode 100644 index 0000000..d44509e --- /dev/null +++ b/LXST/Codecs/libs/pyogg/flac.py @@ -0,0 +1,2061 @@ +############################################################ +# Flac license: # +############################################################ +""" +Copyright (C) 2000-2009 Josh Coalson +Copyright (C) 2011-2016 Xiph.Org Foundation + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +- Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +- Neither the name of the Xiph.org Foundation nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" + +import ctypes +from ctypes import c_int, c_int8, c_int16, c_int32, c_int64, c_uint, c_uint8, c_uint16, c_uint32, c_uint64, c_float, c_long, c_ulong, c_char, c_bool, c_char_p, c_ubyte, c_longlong, c_ulonglong, c_size_t, c_void_p, c_double, POINTER, pointer, cast, CFUNCTYPE, Structure, Union +import ctypes.util +import sys +from traceback import print_exc as _print_exc +import os + +from .ogg import * + +from .library_loader import ExternalLibrary, ExternalLibraryError + +__here = os.getcwd() + +libflac = None + +try: + names = { + "Windows": "libFLAC.dll", + "Darwin": "libFLAC.8.dylib", + "external": "FLAC" + } + libflac = Library.load(names, tests = [lambda lib: hasattr(lib, "FLAC__EntropyCodingMethodTypeString")]) +except ExternalLibraryError: + pass +except: + _print_exc() + +if libflac: + PYOGG_FLAC_AVAIL = True +else: + PYOGG_FLAC_AVAIL = False + +# ctypes +c_ubyte_p = POINTER(c_ubyte) +c_uchar_p = c_ubyte_p +c_uint_p = POINTER(c_uint) +c_size_t_p = POINTER(c_size_t) +c_off_t = c_int32 +# /ctypes + +if PYOGG_FLAC_AVAIL: + # Sanity check also satisfies mypy type checking + assert libflac is not None + + # ordinals + + FLAC__int8 = c_int8 + FLAC__uint8 = c_uint8 + + FLAC__int16 = c_int16 + + FLAC__int32 = c_int32 + FLAC__int32_p = POINTER(FLAC__int32) + + FLAC__int64 = c_int64 + FLAC__uint16 = c_uint16 + FLAC__uint32 = c_uint32 + FLAC__uint64 = c_uint64 + + FLAC__uint64_p = POINTER(FLAC__uint64) + + FLAC__bool = c_bool + + FLAC__byte = c_uint8 + + FLAC__byte_p = POINTER(FLAC__byte) + + c_char_p_p = POINTER(c_char_p) + + # /ordinals + + # callback + + FLAC__IOHandle = CFUNCTYPE(c_void_p) + + FLAC__IOCallback_Read = CFUNCTYPE(c_size_t, + c_void_p, + c_size_t, + c_size_t, + FLAC__IOHandle) + + FLAC__IOCallback_Write = CFUNCTYPE(c_size_t, c_void_p, c_size_t, c_size_t, FLAC__IOHandle) + + FLAC__IOCallback_Seek = CFUNCTYPE(c_int, FLAC__IOHandle, FLAC__int64, c_int) + + FLAC__IOCallback_Tell = CFUNCTYPE(FLAC__int64, FLAC__IOHandle) + + FLAC__IOCallback_Eof = CFUNCTYPE(c_int, FLAC__IOHandle) + + FLAC__IOCallback_Close = CFUNCTYPE(c_int, FLAC__IOHandle) + + class FLAC__IOCallbacks(Structure): + _fields_ = [("read", FLAC__IOCallback_Read), + ("write", FLAC__IOCallback_Write), + ("seek", FLAC__IOCallback_Seek), + ("tell", FLAC__IOCallback_Tell), + ("eof", FLAC__IOCallback_Eof), + ("close", FLAC__IOCallback_Close)] + + # /callback + + # format + + FLAC__MAX_METADATA_TYPE_CODE =(126) + FLAC__MIN_BLOCK_SIZE =(16) + FLAC__MAX_BLOCK_SIZE =(65535) + FLAC__SUBSET_MAX_BLOCK_SIZE_48000HZ =(4608) + FLAC__MAX_CHANNELS =(8) + FLAC__MIN_BITS_PER_SAMPLE =(4) + FLAC__MAX_BITS_PER_SAMPLE =(32) + FLAC__REFERENCE_CODEC_MAX_BITS_PER_SAMPLE =(24) + FLAC__MAX_SAMPLE_RATE =(655350) + FLAC__MAX_LPC_ORDER =(32) + FLAC__SUBSET_MAX_LPC_ORDER_48000HZ =(12) + FLAC__MIN_QLP_COEFF_PRECISION =(5) + FLAC__MAX_QLP_COEFF_PRECISION =(15) + FLAC__MAX_FIXED_ORDER =(4) + FLAC__MAX_RICE_PARTITION_ORDER =(15) + FLAC__SUBSET_MAX_RICE_PARTITION_ORDER =(8) + + FLAC__VERSION_STRING = c_char_p.in_dll(libflac, "FLAC__VERSION_STRING") + + FLAC__VENDOR_STRING = c_char_p.in_dll(libflac, "FLAC__VENDOR_STRING") + + FLAC__STREAM_SYNC_STRING = (FLAC__byte * 4).in_dll(libflac, "FLAC__STREAM_SYNC_STRING") + + FLAC__STREAM_SYNC = c_uint.in_dll(libflac, "FLAC__STREAM_SYNC") + + FLAC__STREAM_SYNC_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_SYNC_LEN") + + FLAC__STREAM_SYNC_LENGTH =(4) + + + + FLAC__EntropyCodingMethodType = c_int + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE = 0 + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2 = 1 + + + + libflac.FLAC__EntropyCodingMethodTypeString.restype = c_char_p + libflac.FLAC__EntropyCodingMethodTypeString.argtypes = [] + + def FLAC__EntropyCodingMethodTypeString(): + return libflac.FLAC__EntropyCodingMethodTypeString() + + + + class FLAC__EntropyCodingMethod_PartitionedRiceContents(Structure): + _fields_ = [("parameters", c_uint_p), + ("raw_bits", c_uint_p), + ("capacity_by_order", c_uint)] + + class FLAC__EntropyCodingMethod_PartitionedRice(Structure): + _fields_ = [("order", c_uint), + ("contents", POINTER(FLAC__EntropyCodingMethod_PartitionedRiceContents))] + + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ORDER_LEN") + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_PARAMETER_LEN") + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2_PARAMETER_LEN") + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_RAW_LEN") + + FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE_ESCAPE_PARAMETER") + + + class FLAC__EntropyCodingMethod_data(Union): + _fields_ = [("partitioned_rice", FLAC__EntropyCodingMethod_PartitionedRice)] + + class FLAC__EntropyCodingMethod(Structure): + _fields_ = [("type", POINTER(FLAC__EntropyCodingMethodType)), + ("data", FLAC__EntropyCodingMethod_data)] + + FLAC__ENTROPY_CODING_METHOD_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__ENTROPY_CODING_METHOD_TYPE_LEN") + + + + FLAC__SubframeType = c_int + FLAC__SUBFRAME_TYPE_CONSTANT = 0 + FLAC__SUBFRAME_TYPE_VERBATIM = 1 + FLAC__SUBFRAME_TYPE_FIXED = 2 + FLAC__SUBFRAME_TYPE_LPC = 3 + + + + libflac.FLAC__SubframeTypeString.restype = c_char_p + libflac.FLAC__SubframeTypeString.argtypes = [] + + def FLAC__SubframeTypeString(): + return libflac.FLAC__SubframeTypeString() + + + + class FLAC__Subframe_Constant(Structure): + _fields_ = [("value", FLAC__int32)] + + + class FLAC__Subframe_Verbatim(Structure): + _fields_ = [("data", FLAC__int32_p)] + + + class FLAC__Subframe_Fixed(Structure): + _fields_ = [("entropy_coding_method", FLAC__EntropyCodingMethod), + ("order", c_uint), + ("warmup", FLAC__int32 * FLAC__MAX_FIXED_ORDER), + ("residual", FLAC__int32_p)] + + + class FLAC__Subframe_LPC(Structure): + _fields_ = [("entropy_coding_method", FLAC__EntropyCodingMethod), + ("order", c_uint), + ("qlp_coeff_precision", c_uint), + ("quantization_level", c_int), + ("qlp_coeff", FLAC__int32 * FLAC__MAX_LPC_ORDER), + ("warmup", FLAC__int32 * FLAC__MAX_LPC_ORDER), + ("residual", FLAC__int32_p)] + + + FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN") + + FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_LPC_QLP_SHIFT_LEN") + + + + class FLAC__Subframe_data(Union): + _fields_ = [("constant", FLAC__Subframe_Constant), + ("fixed", FLAC__Subframe_Fixed), + ("lpc", FLAC__Subframe_LPC), + ("verbatim", FLAC__Subframe_Verbatim)] + + class FLAC__Subframe(Structure): + _fields_ = [("type", FLAC__SubframeType), + ("data", FLAC__Subframe_data), + ("wasted_bits", c_uint)] + + + FLAC__SUBFRAME_ZERO_PAD_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_ZERO_PAD_LEN") + + FLAC__SUBFRAME_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_LEN") + + FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN = c_uint.in_dll(libflac, "FLAC__SUBFRAME_WASTED_BITS_FLAG_LEN") + + FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_CONSTANT_BYTE_ALIGNED_MASK") + + FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_VERBATIM_BYTE_ALIGNED_MASK") + + FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_FIXED_BYTE_ALIGNED_MASK") + + FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK = c_uint.in_dll(libflac, "FLAC__SUBFRAME_TYPE_LPC_BYTE_ALIGNED_MASK") + + + FLAC__ChannelAssignment = c_int + + FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT = 0 + FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE = 1 + FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE = 2 + FLAC__CHANNEL_ASSIGNMENT_MID_SIDE = 3 + + + + libflac.FLAC__ChannelAssignmentString.restype = c_char_p + libflac.FLAC__ChannelAssignmentString.argtypes = [] + + def FLAC__ChannelAssignmentString(): + return libflac.FLAC__ChannelAssignmentString() + + FLAC__FrameNumberType = c_int + + + libflac.FLAC__FrameNumberTypeString.restype = c_char_p + libflac.FLAC__FrameNumberTypeString.argtypes = [] + + def FLAC__FrameNumberTypeString(): + return libflac.FLAC__FrameNumberTypeString() + + + class FLAC__FrameHeader_number(Union): + _fields_ =[("frame_number", FLAC__uint32), + ("sample_number", FLAC__uint64)] + + class FLAC__FrameHeader(Structure): + _fields_ = [("blocksize", c_uint), + ("sample_rate", c_uint), + ("channels", c_uint), + ("channel_assignment", FLAC__ChannelAssignment), + ("bits_per_sample", c_uint), + ("number_type", FLAC__FrameNumberType), + ("number", FLAC__FrameHeader_number), + ("crc", FLAC__uint8)] + + + FLAC__FRAME_HEADER_SYNC = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_SYNC") + + FLAC__FRAME_HEADER_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_RESERVED_LEN") + + FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_BLOCKING_STRATEGY_LEN") + + FLAC__FRAME_HEADER_BLOCK_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_BLOCK_SIZE_LEN") + + FLAC__FRAME_HEADER_SAMPLE_RATE_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_SAMPLE_RATE_LEN") + + FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_CHANNEL_ASSIGNMENT_LEN") + + FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_BITS_PER_SAMPLE_LEN") + + FLAC__FRAME_HEADER_ZERO_PAD_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_ZERO_PAD_LEN") + + FLAC__FRAME_HEADER_CRC_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_HEADER_CRC_LEN") + + + + class FLAC__FrameFooter(Structure): + _fields_ = [("crc", FLAC__uint16)] + + FLAC__FRAME_FOOTER_CRC_LEN = c_uint.in_dll(libflac, "FLAC__FRAME_FOOTER_CRC_LEN") + + + + class FLAC__Frame(Structure): + _fields_ = [("header", FLAC__FrameHeader), + ("subframes", FLAC__Subframe * FLAC__MAX_CHANNELS), + ("footer", FLAC__FrameFooter)] + + + FLAC__MetadataType = c_int + + FLAC__METADATA_TYPE_STREAMINFO = 0 + + FLAC__METADATA_TYPE_PADDING = 1 + + FLAC__METADATA_TYPE_APPLICATION = 2 + + FLAC__METADATA_TYPE_SEEKTABLE = 3 + + FLAC__METADATA_TYPE_VORBIS_COMMENT = 4 + + FLAC__METADATA_TYPE_CUESHEET = 5 + + FLAC__METADATA_TYPE_PICTURE = 6 + + FLAC__METADATA_TYPE_UNDEFINED = 7 + + FLAC__MAX_METADATA_TYPE = FLAC__MAX_METADATA_TYPE_CODE + + + + libflac.FLAC__MetadataTypeString.restype = c_char_p + libflac.FLAC__MetadataTypeString.argtypes = [] + + def FLAC__MetadataTypeString(): + return libflac.FLAC__MetadataTypeString() + + + + class FLAC__StreamMetadata_StreamInfo(Structure): + _fields_ = [("min_blocksize", c_uint), + ("max_framesize", c_uint), + ("min_framesize", c_uint), + ("max_framesize", c_uint), + ("sample_rate", c_uint), + ("channels", c_uint), + ("bits_per_sample", c_uint), + ("total_samples", FLAC__uint64), + ("md5sum", FLAC__byte*16)] + + FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MIN_BLOCK_SIZE_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MAX_BLOCK_SIZE_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_SAMPLE_RATE_LEN") + + + FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_CHANNELS_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_BITS_PER_SAMPLE_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_STREAMINFO_MD5SUM_LEN") + + FLAC__STREAM_METADATA_STREAMINFO_LENGTH =(34) + + + class FLAC__StreamMetadata_Padding(Structure): + _fields_ = [("dummy", c_int)] + + + + class FLAC__StreamMetadata_Application(Structure): + _fields_ = [("id", FLAC__byte*4), + ("data", FLAC__byte_p)] + + FLAC__STREAM_METADATA_APPLICATION_ID_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_APPLICATION_ID_LEN") + + + class FLAC__StreamMetadata_SeekPoint(Structure): + _fields_ = [("sample_number", FLAC__uint64), + ("stream_offset", FLAC__uint64), + ("frame_samples", c_uint)] + + FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_SAMPLE_NUMBER_LEN") + + FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_STREAM_OFFSET_LEN") + + FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_FRAME_SAMPLES_LEN") + + FLAC__STREAM_METADATA_SEEKPOINT_LENGTH =(18) + + + FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER = FLAC__uint64.in_dll(libflac, "FLAC__STREAM_METADATA_SEEKPOINT_PLACEHOLDER") + + class FLAC__StreamMetadata_SeekTable(Structure): + _fields_ = [("num_points", c_uint), + ("points", POINTER(FLAC__StreamMetadata_SeekPoint))] + + class FLAC__StreamMetadata_VorbisComment_Entry(Structure): + _fields_ = [("length", FLAC__uint32), + ("entry", FLAC__byte_p)] + + FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_VORBIS_COMMENT_ENTRY_LENGTH_LEN") + + + class FLAC__StreamMetadata_VorbisComment(Structure): + _fields_ = [("vendor_string", FLAC__StreamMetadata_VorbisComment_Entry), + ("num_comments", FLAC__uint32), + ("comments", POINTER(FLAC__StreamMetadata_VorbisComment_Entry))] + + FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_VORBIS_COMMENT_NUM_COMMENTS_LEN") + + + class FLAC__StreamMetadata_CueSheet_Index(Structure): + _fields_ = [("offset", FLAC__uint64), + ("number", FLAC__byte)] + + + FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_INDEX_OFFSET_LEN") + + FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_INDEX_NUMBER_LEN") + + FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_INDEX_RESERVED_LEN") + + + class FLAC__StreamMetadata_CueSheet_Track(Structure): + _fields_ = [("offset", FLAC__uint64), + ("number", FLAC__byte), + ("isrc", c_char*13), + ("type", c_uint), + ("pre_emphasis", c_uint), + ("num_indices", FLAC__byte), + ("indices", POINTER(FLAC__StreamMetadata_CueSheet_Index))] + + FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_OFFSET_LEN") + + FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_NUMBER_LEN") + + FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_ISRC_LEN") + + FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_TYPE_LEN") + + FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_PRE_EMPHASIS_LEN") + + FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_RESERVED_LEN") + + FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_TRACK_NUM_INDICES_LEN") + + + class FLAC__StreamMetadata_CueSheet(Structure): + _fields_ = [("media_catalog_number", c_char*129), + ("lead_in", FLAC__uint64), + ("is_cd", FLAC__bool), + ("num_tracks", c_uint), + ("tracks", POINTER(FLAC__StreamMetadata_CueSheet_Track))] + + FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_MEDIA_CATALOG_NUMBER_LEN") + + + FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_LEAD_IN_LEN") + + FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_IS_CD_LEN") + + FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_RESERVED_LEN") + + FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_CUESHEET_NUM_TRACKS_LEN") + + + FLAC__StreamMetadata_Picture_Type = c_int + FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER = 0 + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD = 1 + FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON = 2 + FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER = 3 + FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER = 4 + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE = 5 + FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA = 6 + FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST = 7 + FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST = 8 + FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR = 9 + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND = 10 + FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER = 11 + FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST = 12 + FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION = 13 + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING = 14 + FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE = 15 + FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE = 16 + FLAC__STREAM_METADATA_PICTURE_TYPE_FISH = 17 + FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION = 18 + FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE = 19 + FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE = 20 + + + libflac.FLAC__StreamMetadata_Picture_TypeString.restype = c_char_p + libflac.FLAC__StreamMetadata_Picture_TypeString.argtypes = [] + + def FLAC__StreamMetadata_Picture_TypeString(): + return libflac.FLAC__StreamMetadata_Picture_TypeString() + + + class FLAC__StreamMetadata_Picture(Structure): + _fields_ = [("type", FLAC__StreamMetadata_Picture_Type), + ("mime_type", c_char_p), + ("description", FLAC__byte_p), + ("width", FLAC__uint32), + ("height", FLAC__uint32), + ("depth", FLAC__uint32), + ("colors", FLAC__uint32), + ("data_length", FLAC__uint32), + ("data", FLAC__byte)] + + FLAC__STREAM_METADATA_PICTURE_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_TYPE_LEN") + + FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_MIME_TYPE_LENGTH_LEN") + + FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_DESCRIPTION_LENGTH_LEN") + + FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_WIDTH_LEN") + + FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_HEIGHT_LEN") + + + FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_DEPTH_LEN") + + FLAC__STREAM_METADATA_PICTURE_COLORS_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_COLORS_LEN") + + FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_PICTURE_DATA_LENGTH_LEN") + + + class FLAC__StreamMetadata_Unknown(Structure): + _fields_ = [("data", FLAC__byte_p)] + + + class FLAC__StreamMetadata_data(Union): + _fields_ = [("stream_info", FLAC__StreamMetadata_StreamInfo), + ("padding", FLAC__StreamMetadata_Padding), + ("application", FLAC__StreamMetadata_Application), + ("seek_table", FLAC__StreamMetadata_SeekTable), + ("vorbis_comment", FLAC__StreamMetadata_VorbisComment), + ("cue_sheet", FLAC__StreamMetadata_CueSheet), + ("picture", FLAC__StreamMetadata_Picture), + ("unknown", FLAC__StreamMetadata_Unknown)] + + class FLAC__StreamMetadata(Structure): + _fields_ = [("type", FLAC__MetadataType), + ("is_last", FLAC__bool), + ("length", c_uint), + ("data", FLAC__StreamMetadata_data)] + + FLAC__STREAM_METADATA_IS_LAST_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_IS_LAST_LEN") + + FLAC__STREAM_METADATA_TYPE_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_TYPE_LEN") + + FLAC__STREAM_METADATA_LENGTH_LEN = c_uint.in_dll(libflac, "FLAC__STREAM_METADATA_LENGTH_LEN") + + FLAC__STREAM_METADATA_HEADER_LENGTH =(4) + + + + libflac.FLAC__format_sample_rate_is_valid.restype = FLAC__bool + libflac.FLAC__format_sample_rate_is_valid.argtypes = [c_uint] + + def FLAC__format_sample_rate_is_valid(sample_rate): + return libflac.FLAC__format_sample_rate_is_valid(sample_rate) + + + libflac.FLAC__format_blocksize_is_subset.restype = FLAC__bool + libflac.FLAC__format_blocksize_is_subset.argtypes = [c_uint, c_uint] + + def FLAC__format_blocksize_is_subset(blocksize, sample_rate): + return libflac.FLAC__format_blocksize_is_subset(blocksize, sample_rate) + + + libflac.FLAC__format_sample_rate_is_subset.restype = FLAC__bool + libflac.FLAC__format_sample_rate_is_subset.argtypes = [c_uint] + + def FLAC__format_sample_rate_is_subset(sample_rate): + return libflac.FLAC__format_sample_rate_is_subset(sample_rate) + + + libflac.FLAC__format_vorbiscomment_entry_name_is_legal.restype = FLAC__bool + libflac.FLAC__format_vorbiscomment_entry_name_is_legal.argtypes = [c_char_p] + + def FLAC__format_vorbiscomment_entry_name_is_legal(name): + return libflac.FLAC__format_vorbiscomment_entry_name_is_legal(name) + + libflac.FLAC__format_vorbiscomment_entry_value_is_legal.restype = FLAC__bool + libflac.FLAC__format_vorbiscomment_entry_value_is_legal.argtypes = [FLAC__byte_p, c_uint] + + def FLAC__format_vorbiscomment_entry_value_is_legal(value, length): + return libflac.FLAC__format_vorbiscomment_entry_value_is_legal(value, length) + + libflac.FLAC__format_vorbiscomment_entry_is_legal.restype = FLAC__bool + libflac.FLAC__format_vorbiscomment_entry_is_legal.argtypes = [FLAC__byte_p, c_uint] + + def FLAC__format_vorbiscomment_entry_is_legal(entry, length): + return libflac.FLAC__format_vorbiscomment_entry_is_legal(entry, length) + + libflac.FLAC__format_seektable_is_legal.restype = FLAC__bool + libflac.FLAC__format_seektable_is_legal.argtypes = [POINTER(FLAC__StreamMetadata_SeekTable)] + + def FLAC__format_seektable_is_legal(seek_table): + return libflac.FLAC__format_seektable_is_legal(seek_table) + + + libflac.FLAC__format_seektable_sort.restype = FLAC__bool + libflac.FLAC__format_seektable_sort.argtypes = [POINTER(FLAC__StreamMetadata_SeekTable)] + + def FLAC__format_seektable_sort(seek_table): + return libflac.FLAC__format_seektable_sort(seek_table) + + libflac.FLAC__format_cuesheet_is_legal.restype = FLAC__bool + libflac.FLAC__format_cuesheet_is_legal.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet), FLAC__bool, c_char_p_p] + + def FLAC__format_cuesheet_is_legal(cue_sheet, check_cd_da_subset, violation): + return libflac.FLAC__format_cuesheet_is_legal(cue_sheet, check_cd_da_subset, violation) + + # /format + + # metadata + + libflac.FLAC__metadata_get_streaminfo.restype = FLAC__bool + libflac.FLAC__metadata_get_streaminfo.argtypes = [c_char_p, POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_get_streaminfo(filename, streaminfo): + return libflac.FLAC__metadata_get_streaminfo(filename, streaminfo) + + libflac.FLAC__metadata_get_tags.restype = FLAC__bool + libflac.FLAC__metadata_get_tags.argtypes = [c_char_p, POINTER(POINTER(FLAC__StreamMetadata))] + + def FLAC__metadata_get_tags(filename, tags): + return libflac.FLAC__metadata_get_tags(filename, tags) + + libflac.FLAC__metadata_get_cuesheet.restype = FLAC__bool + libflac.FLAC__metadata_get_cuesheet.argtypes = [c_char_p, POINTER(POINTER(FLAC__StreamMetadata))] + + def FLAC__metadata_get_cuesheet(filename, cuesheet): + return libflac.FLAC__metadata_get_cuesheet(filename, cuesheet) + + libflac.FLAC__metadata_get_picture.restype = FLAC__bool + libflac.FLAC__metadata_get_picture.argtypes = [c_char_p, POINTER(POINTER(FLAC__StreamMetadata)), FLAC__StreamMetadata_Picture_Type, c_char_p, FLAC__byte_p, c_uint, c_uint, c_uint, c_uint] + + def FLAC__metadata_get_picture(filename, picture, type, mime_type, description, max_width, max_height, max_depth, max_colors): + return libflac.FLAC__metadata_get_picture(filename, picture, type, mime_type, description, max_width, max_height, max_depth, max_colors) + + + class FLAC__Metadata_SimpleIterator(Structure): + _fields_ = [("dummy", c_int)] + + FLAC__Metadata_SimpleIteratorStatus = c_int + + FLAC__METADATA_SIMPLE_ITERATOR_STATUS_OK = 0 + + + libflac.FLAC__Metadata_SimpleIteratorStatusString.restype = c_char_p + libflac.FLAC__Metadata_SimpleIteratorStatusString.argtypes = [] + + def FLAC__Metadata_SimpleIteratorStatusString(): + return libflac.FLAC__Metadata_SimpleIteratorStatusString() + + + libflac.FLAC__metadata_simple_iterator_new.restype = POINTER(FLAC__Metadata_SimpleIterator) + libflac.FLAC__metadata_simple_iterator_new.argtypes = [] + + def FLAC__metadata_simple_iterator_new(): + return libflac.FLAC__metadata_simple_iterator_new() + + + libflac.FLAC__metadata_simple_iterator_delete.restype = None + libflac.FLAC__metadata_simple_iterator_delete.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_delete(iterator): + return libflac.FLAC__metadata_simple_iterator_delete(iterator) + + + libflac.FLAC__metadata_simple_iterator_status.restype = FLAC__Metadata_SimpleIteratorStatus + libflac.FLAC__metadata_simple_iterator_status.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_status(iterator): + return libflac.FLAC__metadata_simple_iterator_status(iterator) + + libflac.FLAC__metadata_simple_iterator_init.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_init.argtypes = [POINTER(FLAC__Metadata_SimpleIterator), c_char_p, FLAC__bool, FLAC__bool] + + def FLAC__metadata_simple_iterator_init(iterator, filename, read_only, preserve_file_stats): + return libflac.FLAC__metadata_simple_iterator_init(iterator, filename, read_only, preserve_file_stats) + + libflac.FLAC__metadata_simple_iterator_is_writable.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_is_writable.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_is_writable(iterator): + return libflac.FLAC__metadata_simple_iterator_is_writable(iterator) + + libflac.FLAC__metadata_simple_iterator_next.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_next.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_next(iterator): + return libflac.FLAC__metadata_simple_iterator_next(iterator) + + libflac.FLAC__metadata_simple_iterator_prev.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_prev.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_prev(iterator): + return libflac.FLAC__metadata_simple_iterator_prev(iterator) + + libflac.FLAC__metadata_simple_iterator_is_last.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_is_last.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_is_last(iterator): + return libflac.FLAC__metadata_simple_iterator_is_last(iterator) + + libflac.FLAC__metadata_simple_iterator_get_block_offset.restype = c_off_t + libflac.FLAC__metadata_simple_iterator_get_block_offset.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_get_block_offset(iterator): + return libflac.FLAC__metadata_simple_iterator_get_block_offset(iterator) + + libflac.FLAC__metadata_simple_iterator_get_block_type.restype = FLAC__MetadataType + libflac.FLAC__metadata_simple_iterator_get_block_type.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_get_block_type(iterator): + return libflac.FLAC__metadata_simple_iterator_get_block_type(iterator) + + libflac.FLAC__metadata_simple_iterator_get_block_length.restype = c_uint + libflac.FLAC__metadata_simple_iterator_get_block_length.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_get_block_length(iterator): + return libflac.FLAC__metadata_simple_iterator_get_block_length(iterator) + + libflac.FLAC__metadata_simple_iterator_get_application_id.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_get_application_id.argtypes = [POINTER(FLAC__Metadata_SimpleIterator), FLAC__byte_p] + + def FLAC__metadata_simple_iterator_get_application_id(iterator, id): + return libflac.FLAC__metadata_simple_iterator_get_application_id(iterator, id) + + libflac.FLAC__metadata_simple_iterator_get_block.restype = POINTER(FLAC__StreamMetadata) + libflac.FLAC__metadata_simple_iterator_get_block.argtypes = [POINTER(FLAC__Metadata_SimpleIterator)] + + def FLAC__metadata_simple_iterator_get_block(iterator): + return libflac.FLAC__metadata_simple_iterator_get_block(iterator) + + libflac.FLAC__metadata_simple_iterator_set_block.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_set_block.argtypes = [POINTER(FLAC__Metadata_SimpleIterator), POINTER(FLAC__StreamMetadata), FLAC__bool] + + def FLAC__metadata_simple_iterator_set_block(iterator, block, use_padding): + return libflac.FLAC__metadata_simple_iterator_set_block(iterator, block, use_padding) + + libflac.FLAC__metadata_simple_iterator_insert_block_after.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_insert_block_after.argtypes = [POINTER(FLAC__Metadata_SimpleIterator), POINTER(FLAC__StreamMetadata), FLAC__bool] + + def FLAC__metadata_simple_iterator_insert_block_after(iterator, block, use_padding): + return libflac.FLAC__metadata_simple_iterator_insert_block_after(iterator, block, use_padding) + + libflac.FLAC__metadata_simple_iterator_delete_block.restype = FLAC__bool + libflac.FLAC__metadata_simple_iterator_delete_block.argtypes = [POINTER(FLAC__Metadata_SimpleIterator), FLAC__bool] + + def FLAC__metadata_simple_iterator_delete_block(iterator, use_padding): + return libflac.FLAC__metadata_simple_iterator_delete_block(iterator, use_padding) + + class FLAC__Metadata_Chain(Structure): + _fields_ = [("dummy", c_int)] + + class FLAC__Metadata_Iterator(Structure): + _fields_ = [("dummy", c_int)] + + FLAC__Metadata_ChainStatus = c_int + + FLAC__METADATA_CHAIN_STATUS_OK = 0 + + libflac.FLAC__Metadata_ChainStatusString.restype = c_char_p + libflac.FLAC__Metadata_ChainStatusString.argtypes = [] + + def FLAC__Metadata_ChainStatusString(): + return libflac.FLAC__Metadata_ChainStatusString() + + libflac.FLAC__metadata_chain_new.restype = POINTER(FLAC__Metadata_Chain) + libflac.FLAC__metadata_chain_new.argtypes = [] + + def FLAC__metadata_chain_new(): + return libflac.FLAC__metadata_chain_new() + + libflac.FLAC__metadata_chain_delete.restype = None + libflac.FLAC__metadata_chain_delete.argtypes = [POINTER(FLAC__Metadata_Chain)] + + def FLAC__metadata_chain_delete(chain): + return libflac.FLAC__metadata_chain_delete(chain) + + libflac.FLAC__metadata_chain_status.restype = FLAC__Metadata_ChainStatus + libflac.FLAC__metadata_chain_status.argtypes = [POINTER(FLAC__Metadata_Chain)] + + def FLAC__metadata_chain_status(chain): + return libflac.FLAC__metadata_chain_status(chain) + + libflac.FLAC__metadata_chain_read.restype = FLAC__bool + libflac.FLAC__metadata_chain_read.argtypes = [POINTER(FLAC__Metadata_Chain), c_char_p] + + def FLAC__metadata_chain_read(chain, filename): + return libflac.FLAC__metadata_chain_read(chain, filename) + + libflac.FLAC__metadata_chain_read_ogg.restype = FLAC__bool + libflac.FLAC__metadata_chain_read_ogg.argtypes = [POINTER(FLAC__Metadata_Chain), c_char_p] + + def FLAC__metadata_chain_read_ogg(chain, filename): + return libflac.FLAC__metadata_chain_read_ogg(chain, filename) + + libflac.FLAC__metadata_chain_read_with_callbacks.restype = FLAC__bool + libflac.FLAC__metadata_chain_read_with_callbacks.argtypes = [POINTER(FLAC__Metadata_Chain), FLAC__IOHandle, FLAC__IOCallbacks] + + def FLAC__metadata_chain_read_with_callbacks(chain, handle, callbacks): + return libflac.FLAC__metadata_chain_read_with_callbacks(chain, handle, callbacks) + + libflac.FLAC__metadata_chain_read_ogg_with_callbacks.restype = FLAC__bool + libflac.FLAC__metadata_chain_read_ogg_with_callbacks.argtypes = [POINTER(FLAC__Metadata_Chain), FLAC__IOHandle, FLAC__IOCallbacks] + + def FLAC__metadata_chain_read_ogg_with_callbacks(chain, handle, callbacks): + return libflac.FLAC__metadata_chain_read_ogg_with_callbacks(chain, handle, callbacks) + + libflac.FLAC__metadata_chain_check_if_tempfile_needed.restype = FLAC__bool + libflac.FLAC__metadata_chain_check_if_tempfile_needed.argtypes = [POINTER(FLAC__Metadata_Chain), FLAC__bool] + + def FLAC__metadata_chain_check_if_tempfile_needed(chain, use_padding): + return libflac.FLAC__metadata_chain_check_if_tempfile_needed(chain, use_padding) + + libflac.FLAC__metadata_chain_write.restype = FLAC__bool + libflac.FLAC__metadata_chain_write.argtypes = [POINTER(FLAC__Metadata_Chain), FLAC__bool, FLAC__bool] + + def FLAC__metadata_chain_write(chain, use_padding, preserve_file_stats): + return libflac.FLAC__metadata_chain_write(chain, use_padding, preserve_file_stats) + + libflac.FLAC__metadata_chain_write_with_callbacks.restype = FLAC__bool + libflac.FLAC__metadata_chain_write_with_callbacks.argtypes = [POINTER(FLAC__Metadata_Chain), FLAC__bool, FLAC__IOHandle, FLAC__IOCallbacks] + + def FLAC__metadata_chain_write_with_callbacks(chain, use_padding, handle, callbacks): + return libflac.FLAC__metadata_chain_write_with_callbacks(chain, use_padding, handle, callbacks) + + libflac.FLAC__metadata_chain_write_with_callbacks_and_tempfile.restype = FLAC__bool + libflac.FLAC__metadata_chain_write_with_callbacks_and_tempfile.argtypes = [POINTER(FLAC__Metadata_Chain), FLAC__bool, FLAC__IOHandle, FLAC__IOCallbacks, FLAC__IOHandle, FLAC__IOCallbacks] + + def FLAC__metadata_chain_write_with_callbacks_and_tempfile(chain, use_padding, handle, callbacks, temp_handle, temp_callbacks): + return libflac.FLAC__metadata_chain_write_with_callbacks_and_tempfile(chain, use_padding, handle, callbacks, temp_handle, temp_callbacks) + + libflac.FLAC__metadata_chain_merge_padding.restype = None + libflac.FLAC__metadata_chain_merge_padding.argtypes = [POINTER(FLAC__Metadata_Chain)] + + def FLAC__metadata_chain_merge_padding(chain): + return libflac.FLAC__metadata_chain_merge_padding(chain) + + libflac.FLAC__metadata_chain_sort_padding.restype = None + libflac.FLAC__metadata_chain_sort_padding.argtypes = [POINTER(FLAC__Metadata_Chain)] + + def FLAC__metadata_chain_sort_padding(chain): + return libflac.FLAC__metadata_chain_sort_padding(chain) + + libflac.FLAC__metadata_iterator_new.restype = POINTER(FLAC__Metadata_Iterator) + libflac.FLAC__metadata_iterator_new.argtypes = [] + + def FLAC__metadata_iterator_new(): + return libflac.FLAC__metadata_iterator_new() + + libflac.FLAC__metadata_iterator_delete.restype = None + libflac.FLAC__metadata_iterator_delete.argtypes = [POINTER(FLAC__Metadata_Iterator)] + + def FLAC__metadata_iterator_delete(iterator): + return libflac.FLAC__metadata_iterator_delete(iterator) + + libflac.FLAC__metadata_iterator_init.restype = None + libflac.FLAC__metadata_iterator_init.argtypes = [POINTER(FLAC__Metadata_Iterator), POINTER(FLAC__Metadata_Chain)] + + def FLAC__metadata_iterator_init(iterator, chain): + return libflac.FLAC__metadata_iterator_init(iterator, chain) + + libflac.FLAC__metadata_iterator_next.restype = FLAC__bool + libflac.FLAC__metadata_iterator_next.argtypes = [POINTER(FLAC__Metadata_Iterator)] + + def FLAC__metadata_iterator_next(iterator): + return libflac.FLAC__metadata_iterator_next(iterator) + + libflac.FLAC__metadata_iterator_prev.restype = FLAC__bool + libflac.FLAC__metadata_iterator_prev.argtypes = [POINTER(FLAC__Metadata_Iterator)] + + def FLAC__metadata_iterator_prev(iterator): + return libflac.FLAC__metadata_iterator_prev(iterator) + + libflac.FLAC__metadata_iterator_get_block_type.restype = FLAC__MetadataType + libflac.FLAC__metadata_iterator_get_block_type.argtypes = [POINTER(FLAC__Metadata_Iterator)] + + def FLAC__metadata_iterator_get_block_type(iterator): + return libflac.FLAC__metadata_iterator_get_block_type(iterator) + + libflac.FLAC__metadata_iterator_get_block_type.restype = POINTER(FLAC__StreamMetadata) + libflac.FLAC__metadata_iterator_get_block_type.argtypes = [POINTER(FLAC__Metadata_Iterator)] + + def FLAC__metadata_iterator_get_block_type(iterator): + return libflac.FLAC__metadata_iterator_get_block_type(iterator) + + libflac.FLAC__metadata_iterator_set_block.restype = FLAC__bool + libflac.FLAC__metadata_iterator_set_block.argtypes = [POINTER(FLAC__Metadata_Iterator), POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_iterator_set_block(iterator, block): + return libflac.FLAC__metadata_iterator_set_block(iterator, block) + + libflac.FLAC__metadata_iterator_delete_block.restype = FLAC__bool + libflac.FLAC__metadata_iterator_delete_block.argtypes = [POINTER(FLAC__Metadata_Iterator), FLAC__bool] + + def FLAC__metadata_iterator_delete_block(iterator, replace_with_padding): + return libflac.FLAC__metadata_iterator_delete_block(iterator, replace_with_padding) + + libflac.FLAC__metadata_iterator_insert_block_before.restype = FLAC__bool + libflac.FLAC__metadata_iterator_insert_block_before.argtypes = [POINTER(FLAC__Metadata_Iterator), POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_iterator_insert_block_before(iterator, block): + return libflac.FLAC__metadata_iterator_insert_block_before(iterator, block) + + libflac.FLAC__metadata_iterator_insert_block_after.restype = FLAC__bool + libflac.FLAC__metadata_iterator_insert_block_after.argtypes = [POINTER(FLAC__Metadata_Iterator), POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_iterator_insert_block_after(iterator, block): + return libflac.FLAC__metadata_iterator_insert_block_after(iterator, block) + + libflac.FLAC__metadata_object_new.restype = POINTER(FLAC__StreamMetadata) + libflac.FLAC__metadata_object_new.argtypes = [POINTER(FLAC__MetadataType)] + + def FLAC__metadata_object_new(type): + return libflac.FLAC__metadata_object_new(type) + + libflac.FLAC__metadata_object_clone.restype = POINTER(FLAC__StreamMetadata) + libflac.FLAC__metadata_object_clone.argtypes = [POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_object_clone(object): + return libflac.FLAC__metadata_object_clone(object) + + libflac.FLAC__metadata_object_delete.restype = None + libflac.FLAC__metadata_object_delete.argtypes = [POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_object_delete(object): + return libflac.FLAC__metadata_object_delete(object) + + libflac.FLAC__metadata_object_is_equal.restype = FLAC__bool + libflac.FLAC__metadata_object_is_equal.argtypes = [POINTER(FLAC__StreamMetadata), POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_object_is_equal(block1, block2): + return libflac.FLAC__metadata_object_is_equal(block1, block2) + + libflac.FLAC__metadata_object_application_set_data.restype = FLAC__bool + libflac.FLAC__metadata_object_application_set_data.argtypes = [POINTER(FLAC__StreamMetadata), FLAC__byte_p, c_uint, FLAC__bool] + + def FLAC__metadata_object_application_set_data(object, data, length, copy): + return libflac.FLAC__metadata_object_application_set_data(object, data, length, copy) + + libflac.FLAC__metadata_object_seektable_resize_points.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_resize_points.argtypes = [POINTER(FLAC__StreamMetadata),c_uint] + + def FLAC__metadata_object_seektable_resize_points(object, new_num_points): + return libflac.FLAC__metadata_object_seektable_resize_points(object, new_num_points) + + libflac.FLAC__metadata_object_seektable_set_point.restype = None + libflac.FLAC__metadata_object_seektable_set_point.argtypes = [POINTER(FLAC__StreamMetadata),c_uint, FLAC__StreamMetadata_SeekPoint] + + def FLAC__metadata_object_seektable_set_point(object, point_num, point): + return libflac.FLAC__metadata_object_seektable_set_point(object, point_num, point) + + libflac.FLAC__metadata_object_seektable_insert_point.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_insert_point.argtypes = [POINTER(FLAC__StreamMetadata),c_uint, FLAC__StreamMetadata_SeekPoint] + + def FLAC__metadata_object_seektable_insert_point(object, point_num, point): + return libflac.FLAC__metadata_object_seektable_insert_point(object, point_num, point) + + libflac.FLAC__metadata_object_seektable_delete_point.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_delete_point.argtypes = [POINTER(FLAC__StreamMetadata),c_uint] + + def FLAC__metadata_object_seektable_delete_point(object, point_num): + return libflac.FLAC__metadata_object_seektable_delete_point(object, point_num) + + libflac.FLAC__metadata_object_seektable_is_legal.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_is_legal.argtypes = [POINTER(FLAC__StreamMetadata)] + + def FLAC__metadata_object_seektable_is_legal(object): + return libflac.FLAC__metadata_object_seektable_is_legal(object) + + libflac.FLAC__metadata_object_seektable_template_append_placeholders.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_template_append_placeholders.argtypes = [POINTER(FLAC__StreamMetadata), c_uint] + + def FLAC__metadata_object_seektable_template_append_placeholders(object, num): + return libflac.FLAC__metadata_object_seektable_template_append_placeholders(object, num) + + libflac.FLAC__metadata_object_seektable_template_append_point.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_template_append_point.argtypes = [POINTER(FLAC__StreamMetadata), FLAC__uint64] + + def FLAC__metadata_object_seektable_template_append_point(object, sample_number): + return libflac.FLAC__metadata_object_seektable_template_append_point(object, sample_number) + + libflac.FLAC__metadata_object_seektable_template_append_points.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_template_append_points.argtypes = [POINTER(FLAC__StreamMetadata), POINTER(FLAC__uint64*0), c_uint] + + def FLAC__metadata_object_seektable_template_append_points(object, sample_numbers, num): + return libflac.FLAC__metadata_object_seektable_template_append_points(object, sample_numbers, num) + + libflac.FLAC__metadata_object_seektable_template_append_spaced_points.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_template_append_spaced_points.argtypes = [POINTER(FLAC__StreamMetadata), c_uint, FLAC__uint64] + + def FLAC__metadata_object_seektable_template_append_spaced_points(object, num, total_samples): + return libflac.FLAC__metadata_object_seektable_template_append_spaced_points(object, num, total_samples) + + libflac.FLAC__metadata_object_seektable_template_append_spaced_points_by_samples.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_template_append_spaced_points_by_samples.argtypes = [POINTER(FLAC__StreamMetadata), c_uint, FLAC__uint64] + + def FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(object, samples, total_samples): + return libflac.FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(object, samples, total_samples) + + libflac.FLAC__metadata_object_seektable_template_sort.restype = FLAC__bool + libflac.FLAC__metadata_object_seektable_template_sort.argtypes = [POINTER(FLAC__StreamMetadata), FLAC__bool] + + def FLAC__metadata_object_seektable_template_sort(object, compact): + return libflac.FLAC__metadata_object_seektable_template_sort(object, compact) + + libflac.FLAC__metadata_object_vorbiscomment_set_vendor_string.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_set_vendor_string.argtypes = [POINTER(FLAC__StreamMetadata), FLAC__StreamMetadata_VorbisComment_Entry, FLAC__bool] + + def FLAC__metadata_object_vorbiscomment_set_vendor_string(object, entry, copy): + return libflac.FLAC__metadata_object_vorbiscomment_set_vendor_string(object, entry, copy) + + libflac.FLAC__metadata_object_vorbiscomment_resize_comments.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_resize_comments.argtypes = [POINTER(FLAC__StreamMetadata), c_uint] + + def FLAC__metadata_object_vorbiscomment_resize_comments(object, new_num_comments): + return libflac.FLAC__metadata_object_vorbiscomment_resize_comments(object, new_num_comments) + + libflac.FLAC__metadata_object_vorbiscomment_set_comment.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_set_comment.argtypes = [POINTER(FLAC__StreamMetadata), c_uint, FLAC__StreamMetadata_VorbisComment_Entry, FLAC__bool] + + def FLAC__metadata_object_vorbiscomment_set_comment(object, comment_num, entry, copy): + return libflac.FLAC__metadata_object_vorbiscomment_set_comment(object, comment_num, entry, copy) + + libflac.FLAC__metadata_object_vorbiscomment_insert_comment.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_insert_comment.argtypes = [POINTER(FLAC__StreamMetadata), c_uint, FLAC__StreamMetadata_VorbisComment_Entry, FLAC__bool] + + def FLAC__metadata_object_vorbiscomment_insert_comment(object, comment_num, entry, copy): + return libflac.FLAC__metadata_object_vorbiscomment_insert_comment(object, comment_num, entry, copy) + + libflac.FLAC__metadata_object_vorbiscomment_append_comment.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_append_comment.argtypes = [POINTER(FLAC__StreamMetadata), c_uint, FLAC__StreamMetadata_VorbisComment_Entry, FLAC__bool] + + def FLAC__metadata_object_vorbiscomment_append_comment(object, entry, copy): + return libflac.FLAC__metadata_object_vorbiscomment_append_comment(object,entry, copy) + + libflac.FLAC__metadata_object_vorbiscomment_replace_comment.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_replace_comment.argtypes = [POINTER(FLAC__StreamMetadata), c_uint, FLAC__StreamMetadata_VorbisComment_Entry, FLAC__bool, FLAC__bool] + + def FLAC__metadata_object_vorbiscomment_replace_comment(object, entry, all, copy): + return libflac.FLAC__metadata_object_vorbiscomment_replace_comment(object,entry, all, copy) + + libflac.FLAC__metadata_object_vorbiscomment_delete_comment.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_delete_comment.argtypes = [POINTER(FLAC__StreamMetadata), c_uint] + + def FLAC__metadata_object_vorbiscomment_delete_comment(object, comment_num): + return libflac.FLAC__metadata_object_vorbiscomment_delete_comment(object,comment_num) + + libflac.FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair.argtypes = [POINTER(FLAC__StreamMetadata_VorbisComment_Entry), c_char_p, c_char_p] + + def FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(entry, field_name, field_value): + return libflac.FLAC__metadata_object_vorbiscomment_entry_from_name_value_pair(entry, field_name, field_value) + + libflac.FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair.argtypes = [POINTER(FLAC__StreamMetadata_VorbisComment_Entry), c_char_p_p, c_char_p_p] + + def FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(entry, field_name, field_value): + return libflac.FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(entry, field_name, field_value) + + libflac.FLAC__metadata_object_vorbiscomment_entry_matches.restype = FLAC__bool + libflac.FLAC__metadata_object_vorbiscomment_entry_matches.argtypes = [POINTER(FLAC__StreamMetadata_VorbisComment_Entry), c_char_p, c_uint] + + def FLAC__metadata_object_vorbiscomment_entry_matches(entry, field_name, field_value): + return libflac.FLAC__metadata_object_vorbiscomment_entry_matches(entry, field_name, field_value) + + libflac.FLAC__metadata_object_vorbiscomment_find_entry_from.restype = c_int + libflac.FLAC__metadata_object_vorbiscomment_find_entry_from.argtypes = [POINTER(FLAC__StreamMetadata), c_uint, c_char_p] + + def FLAC__metadata_object_vorbiscomment_find_entry_from(object, offset, field_name): + return libflac.FLAC__metadata_object_vorbiscomment_find_entry_from(object, offset, field_name) + + libflac.FLAC__metadata_object_vorbiscomment_remove_entry_matching.restype = c_int + libflac.FLAC__metadata_object_vorbiscomment_remove_entry_matching.argtypes = [POINTER(FLAC__StreamMetadata), c_char_p] + + def FLAC__metadata_object_vorbiscomment_remove_entry_matching(object, field_name): + return libflac.FLAC__metadata_object_vorbiscomment_remove_entry_matching(object, field_name) + + libflac.FLAC__metadata_object_vorbiscomment_remove_entries_matching.restype = c_int + libflac.FLAC__metadata_object_vorbiscomment_remove_entries_matching.argtypes = [POINTER(FLAC__StreamMetadata), c_char_p] + + def FLAC__metadata_object_vorbiscomment_remove_entries_matching(object, field_name): + return libflac.FLAC__metadata_object_vorbiscomment_remove_entries_matching(object, field_name) + + libflac.FLAC__metadata_object_cuesheet_track_new.restype = POINTER(FLAC__StreamMetadata_CueSheet_Track) + libflac.FLAC__metadata_object_cuesheet_track_new.argtypes = [] + + def FLAC__metadata_object_cuesheet_track_new(): + return libflac.FLAC__metadata_object_cuesheet_track_new() + + libflac.FLAC__metadata_object_cuesheet_track_delete.restype = None + libflac.FLAC__metadata_object_cuesheet_track_delete.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track)] + + def FLAC__metadata_object_cuesheet_track_delete(object): + return libflac.FLAC__metadata_object_cuesheet_track_delete(object) + + libflac.FLAC__metadata_object_cuesheet_track_resize_indices.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_track_resize_indices.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint, c_uint] + + def FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, new_num_indices): + return libflac.FLAC__metadata_object_cuesheet_track_resize_indices(object, track_num, new_num_indices) + + libflac.FLAC__metadata_object_cuesheet_track_insert_index.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_track_insert_index.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint, c_uint, FLAC__StreamMetadata_CueSheet_Index] + + def FLAC__metadata_object_cuesheet_track_insert_index(object, track_num, index_num, index): + return libflac.FLAC__metadata_object_cuesheet_track_insert_index(object, track_num, index_num, index) + + libflac.FLAC__metadata_object_cuesheet_track_insert_blank_index.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_track_insert_blank_index.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint, c_uint] + + def FLAC__metadata_object_cuesheet_track_insert_blank_index(object, track_num, index_num): + return libflac.FLAC__metadata_object_cuesheet_track_insert_blank_index(object, track_num, index_num) + + libflac.FLAC__metadata_object_cuesheet_track_delete_index.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_track_delete_index.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint, c_uint] + + def FLAC__metadata_object_cuesheet_track_delete_index(object, track_num, index_num): + return libflac.FLAC__metadata_object_cuesheet_track_delete_index(object, track_num, index_num) + + libflac.FLAC__metadata_object_cuesheet_resize_tracks.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_resize_tracks.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint] + + def FLAC__metadata_object_cuesheet_resize_tracks(object, new_num_tracks): + return libflac.FLAC__metadata_object_cuesheet_resize_tracks(object, new_num_tracks) + + libflac.FLAC__metadata_object_cuesheet_set_track.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_set_track.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint, POINTER(FLAC__StreamMetadata_CueSheet_Track), FLAC__bool] + + def FLAC__metadata_object_cuesheet_set_track(object, new_num_tracks, track, copy): + return libflac.FLAC__metadata_object_cuesheet_set_track(object, new_num_tracks, track, copy) + + libflac.FLAC__metadata_object_cuesheet_insert_track.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_insert_track.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint, POINTER(FLAC__StreamMetadata_CueSheet_Track), FLAC__bool] + + def FLAC__metadata_object_cuesheet_insert_track(object, track_num, track, copy): + return libflac.FLAC__metadata_object_cuesheet_insert_track(object, track_num, track, copy) + + libflac.FLAC__metadata_object_cuesheet_insert_blank_track.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_insert_blank_track.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint] + + def FLAC__metadata_object_cuesheet_insert_blank_track(object, track_num): + return libflac.FLAC__metadata_object_cuesheet_insert_blank_track(object, track_num) + + libflac.FLAC__metadata_object_cuesheet_delete_track.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_delete_track.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_uint] + + def FLAC__metadata_object_cuesheet_delete_track(object, track_num): + return libflac.FLAC__metadata_object_cuesheet_delete_track(object, track_num) + + libflac.FLAC__metadata_object_cuesheet_is_legal.restype = FLAC__bool + libflac.FLAC__metadata_object_cuesheet_is_legal.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), FLAC__bool, c_char_p_p] + + def FLAC__metadata_object_cuesheet_is_legal(object, check_cd_da_subset, violation): + return libflac.FLAC__metadata_object_cuesheet_is_legal(object, check_cd_da_subset, violation) + + libflac.FLAC__metadata_object_cuesheet_calculate_cddb_id.restype = FLAC__uint32 + libflac.FLAC__metadata_object_cuesheet_calculate_cddb_id.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track)] + + def FLAC__metadata_object_cuesheet_calculate_cddb_id(object): + return libflac.FLAC__metadata_object_cuesheet_calculate_cddb_id(object) + + libflac.FLAC__metadata_object_picture_set_mime_type.restype = FLAC__bool + libflac.FLAC__metadata_object_picture_set_mime_type.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_char_p, FLAC__bool] + + def FLAC__metadata_object_picture_set_mime_type(object, mime_type, copy): + return libflac.FLAC__metadata_object_picture_set_mime_type(object, mime_type, copy) + + libflac.FLAC__metadata_object_picture_set_description.restype = FLAC__bool + libflac.FLAC__metadata_object_picture_set_description.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), FLAC__byte_p, FLAC__bool] + + def FLAC__metadata_object_picture_set_description(object, description, copy): + return libflac.FLAC__metadata_object_picture_set_description(object, mime_type, copy) + + libflac.FLAC__metadata_object_picture_set_data.restype = FLAC__bool + libflac.FLAC__metadata_object_picture_set_data.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), FLAC__byte_p,FLAC__uint32, FLAC__bool] + + def FLAC__metadata_object_picture_set_data(object, data, length, copy): + return libflac.FLAC__metadata_object_picture_set_data(object, mime_type, copy) + + libflac.FLAC__metadata_object_picture_is_legal.restype = FLAC__bool + libflac.FLAC__metadata_object_picture_is_legal.argtypes = [POINTER(FLAC__StreamMetadata_CueSheet_Track), c_char_p] + + def FLAC__metadata_object_picture_is_legal(object, violation): + return libflac.FLAC__metadata_object_picture_is_legal(object, violation) + + # /metadata + + # stream_decoder + + FLAC__StreamDecoderState = c_int + FLAC__StreamDecoderStateEnum = ["FLAC__STREAM_DECODER_SEARCH_FOR_METADATA", + "FLAC__STREAM_DECODER_READ_METADATA", + "FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC", + "FLAC__STREAM_DECODER_READ_FRAME", + "FLAC__STREAM_DECODER_END_OF_STREAM", + "FLAC__STREAM_DECODER_OGG_ERROR", + "FLAC__STREAM_DECODER_SEEK_ERROR", + "FLAC__STREAM_DECODER_ABORTED", + "FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR", + "FLAC__STREAM_DECODER_UNINITIALIZED"] + + libflac.FLAC__StreamDecoderStateString.restype = c_char_p + libflac.FLAC__StreamDecoderStateString.argtypes = [] + + def FLAC__StreamDecoderStateString(): + return libflac.FLAC__StreamDecoderStateString() + + + FLAC__StreamDecoderInitStatus = c_int + FLAC__StreamDecoderInitStatusEnum = ["FLAC__STREAM_DECODER_INIT_STATUS_OK", + "FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER", + "FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS", + "FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR", + "FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE", + "FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED"] + + libflac.FLAC__StreamDecoderInitStatusString.restype = c_char_p + libflac.FLAC__StreamDecoderInitStatusString.argtypes = [] + + def FLAC__StreamDecoderInitStatusString(): + return libflac.FLAC__StreamDecoderInitStatusString() + + + FLAC__StreamDecoderReadStatus = c_int + FLAC__StreamDecoderReadStatusEnum = ["FLAC__STREAM_DECODER_READ_STATUS_CONTINUE", + "FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM", + "FLAC__STREAM_DECODER_READ_STATUS_ABORT"] + + libflac.FLAC__StreamDecoderReadStatusString.restype = c_char_p + libflac.FLAC__StreamDecoderReadStatusString.argtypes = [] + + def FLAC__StreamDecoderReadStatusString(): + return libflac.FLAC__StreamDecoderReadStatusString() + + + FLAC__StreamDecoderSeekStatus = c_int + FLAC__StreamDecoderSeekStatusEnum = ["FLAC__STREAM_DECODER_SEEK_STATUS_OK", + "FLAC__STREAM_DECODER_SEEK_STATUS_ERROR", + "FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED"] + + libflac.FLAC__StreamDecoderSeekStatusString.restype = c_char_p + libflac.FLAC__StreamDecoderSeekStatusString.argtypes = [] + + def FLAC__StreamDecoderSeekStatusString(): + return libflac.FLAC__StreamDecoderSeekStatusString() + + + FLAC__StreamDecoderTellStatus = c_int + FLAC__StreamDecoderTellStatusEnum = ["FLAC__STREAM_DECODER_TELL_STATUS_OK", + "FLAC__STREAM_DECODER_TELL_STATUS_ERROR", + "FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED"] + + libflac.FLAC__StreamDecoderTellStatusString.restype = c_char_p + libflac.FLAC__StreamDecoderTellStatusString.argtypes = [] + + def FLAC__StreamDecoderTellStatusString(): + return libflac.FLAC__StreamDecoderTellStatusString() + + + FLAC__StreamDecoderLengthStatus = c_int + FLAC__StreamDecoderLengthStatusEnum = ["FLAC__STREAM_DECODER_LENGTH_STATUS_OK", + "FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR", + "FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED"] + + libflac.FLAC__StreamDecoderLengthStatusString.restype = c_char_p + libflac.FLAC__StreamDecoderLengthStatusString.argtypes = [] + + def FLAC__StreamDecoderLengthStatusString(): + return libflac.FLAC__StreamDecoderLengthStatusString() + + + FLAC__StreamDecoderWriteStatus = c_int + FLAC__StreamDecoderWriteStatusEnum = ["FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE", "FLAC__STREAM_DECODER_WRITE_STATUS_ABORT"] + + libflac.FLAC__StreamDecoderWriteStatusString.restype = c_char_p + libflac.FLAC__StreamDecoderWriteStatusString.argtypes = [] + + def FLAC__StreamDecoderWriteStatusString(): + return libflac.FLAC__StreamDecoderWriteStatusString() + + FLAC__StreamDecoderErrorStatus = c_int + FLAC__StreamDecoderErrorStatusEnum = ["FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC", + "FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER", + "FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH", + "FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM"] + + libflac.FLAC__StreamDecoderErrorStatusString.restype = c_char_p + libflac.FLAC__StreamDecoderErrorStatusString.argtypes = [] + + def FLAC__StreamDecoderErrorStatusString(): + return libflac.FLAC__StreamDecoderErrorStatusString() + + + + class FLAC__StreamDecoderProtected(Structure): + _fields_ = [("dummy", c_int)] + + class FLAC__StreamDecoderPrivate(Structure): + _fields_ = [("dummy", c_int)] + + class FLAC__StreamDecoder(Structure): + _fields_ = [("protected_", POINTER(FLAC__StreamDecoderProtected)), + ("private_", POINTER(FLAC__StreamDecoderPrivate))] + + FLAC__StreamDecoderReadCallback = CFUNCTYPE( + FLAC__StreamDecoderReadStatus, + POINTER(FLAC__StreamDecoder), + POINTER(FLAC__byte*0), + c_size_t_p, + c_void_p + ) + + FLAC__StreamDecoderSeekCallback = CFUNCTYPE( + FLAC__StreamDecoderSeekStatus, + POINTER(FLAC__StreamDecoder), + FLAC__uint64, + c_void_p + ) + + FLAC__StreamDecoderTellCallback = CFUNCTYPE( + FLAC__StreamDecoderTellStatus, + POINTER(FLAC__StreamDecoder), + FLAC__uint64_p, + c_void_p + ) + + FLAC__StreamDecoderLengthCallback = CFUNCTYPE( + FLAC__StreamDecoderLengthStatus, + POINTER(FLAC__StreamDecoder), + FLAC__uint64_p, + c_void_p + ) + + FLAC__StreamDecoderEofCallback = CFUNCTYPE( + FLAC__bool, + POINTER(FLAC__StreamDecoder), + c_void_p + ) + + FLAC__StreamDecoderWriteCallback = CFUNCTYPE( + FLAC__StreamDecoderWriteStatus, + POINTER(FLAC__StreamDecoder), + POINTER(FLAC__Frame), + POINTER(FLAC__int32_p*0), + c_void_p + ) + + FLAC__StreamDecoderMetadataCallback = CFUNCTYPE( + None, + POINTER(FLAC__StreamDecoder), + POINTER(FLAC__StreamMetadata), + c_void_p + ) + + FLAC__StreamDecoderErrorCallback = CFUNCTYPE( + None, + POINTER(FLAC__StreamDecoder), + FLAC__StreamDecoderErrorStatus, + c_void_p + ) + + + libflac.FLAC__stream_decoder_new.restype = POINTER(FLAC__StreamDecoder) + libflac.FLAC__stream_decoder_new.argtypes = [] + + def FLAC__stream_decoder_new(): + return libflac.FLAC__stream_decoder_new() + + libflac.FLAC__stream_decoder_delete.restype = None + libflac.FLAC__stream_decoder_delete.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_delete(decoder): + return libflac.FLAC__stream_decoder_delete(decoder) + + + libflac.FLAC__stream_decoder_set_ogg_serial_number.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_ogg_serial_number.argtypes = [POINTER(FLAC__StreamDecoder), c_long] + + def FLAC__stream_decoder_set_ogg_serial_number(decoder, serial_number): + return libflac.FLAC__stream_decoder_set_ogg_serial_number(decoder, serial_number) + + libflac.FLAC__stream_decoder_set_md5_checking.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_md5_checking.argtypes = [POINTER(FLAC__StreamDecoder), FLAC__bool] + + def FLAC__stream_decoder_set_md5_checking(decoder, value): + return libflac.FLAC__stream_decoder_set_md5_checking(decoder, value) + + libflac.FLAC__stream_decoder_set_metadata_respond.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_metadata_respond.argtypes = [POINTER(FLAC__StreamDecoder), FLAC__MetadataType] + + def FLAC__stream_decoder_set_metadata_respond(decoder, type): + return libflac.FLAC__stream_decoder_set_metadata_respond(decoder, type) + + libflac.FLAC__stream_decoder_set_metadata_respond_application.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_metadata_respond_application.argtypes = [POINTER(FLAC__StreamDecoder), FLAC__byte*4] + + def FLAC__stream_decoder_set_metadata_respond_application(decoder, id): + return libflac.FLAC__stream_decoder_set_metadata_respond_application(decoder, id) + + libflac.FLAC__stream_decoder_set_metadata_respond_all.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_metadata_respond_all.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_set_metadata_respond_all(decoder): + return libflac.FLAC__stream_decoder_set_metadata_respond_all(decoder) + + libflac.FLAC__stream_decoder_set_metadata_ignore.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_metadata_ignore.argtypes = [POINTER(FLAC__StreamDecoder), FLAC__MetadataType] + + def FLAC__stream_decoder_set_metadata_ignore(decoder, type): + return libflac.FLAC__stream_decoder_set_metadata_ignore(decoder, type) + + libflac.FLAC__stream_decoder_set_metadata_ignore_application.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_metadata_ignore_application.argtypes = [POINTER(FLAC__StreamDecoder), FLAC__byte*4] + + def FLAC__stream_decoder_set_metadata_ignore_application(decoder, id): + return libflac.FLAC__stream_decoder_set_metadata_ignore_application(decoder, id) + + libflac.FLAC__stream_decoder_set_metadata_ignore_all.restype = FLAC__bool + libflac.FLAC__stream_decoder_set_metadata_ignore_all.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_set_metadata_ignore_all(decoder): + return libflac.FLAC__stream_decoder_set_metadata_ignore_all(decoder) + + libflac.FLAC__stream_decoder_get_state.restype = FLAC__StreamDecoderState + libflac.FLAC__stream_decoder_get_state.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_state(decoder): + return libflac.FLAC__stream_decoder_get_state(decoder) + + libflac.FLAC__stream_decoder_get_resolved_state_string.restype = c_char_p + libflac.FLAC__stream_decoder_get_resolved_state_string.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_resolved_state_string(decoder): + return libflac.FLAC__stream_decoder_get_resolved_state_string(decoder) + + libflac.FLAC__stream_decoder_get_md5_checking.restype = FLAC__bool + libflac.FLAC__stream_decoder_get_md5_checking.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_md5_checking(decoder): + return libflac.FLAC__stream_decoder_get_md5_checking(decoder) + + libflac.FLAC__stream_decoder_get_total_samples.restype = FLAC__uint64 + libflac.FLAC__stream_decoder_get_total_samples.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_total_samples(decoder): + return libflac.FLAC__stream_decoder_get_total_samples(decoder) + + libflac.FLAC__stream_decoder_get_channels.restype = c_uint + libflac.FLAC__stream_decoder_get_channels.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_channels(decoder): + return libflac.FLAC__stream_decoder_get_channels(decoder) + + libflac.FLAC__stream_decoder_get_channel_assignment.restype = FLAC__ChannelAssignment + libflac.FLAC__stream_decoder_get_channel_assignment.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_channel_assignment(decoder): + return libflac.FLAC__stream_decoder_get_channel_assignment(decoder) + + libflac.FLAC__stream_decoder_get_bits_per_sample.restype = c_uint + libflac.FLAC__stream_decoder_get_bits_per_sample.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_bits_per_sample(decoder): + return libflac.FLAC__stream_decoder_get_bits_per_sample(decoder) + + libflac.FLAC__stream_decoder_get_sample_rate.restype = c_uint + libflac.FLAC__stream_decoder_get_sample_rate.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_sample_rate(decoder): + return libflac.FLAC__stream_decoder_get_sample_rate(decoder) + + libflac.FLAC__stream_decoder_get_blocksize.restype = c_uint + libflac.FLAC__stream_decoder_get_blocksize.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_get_blocksize(decoder): + return libflac.FLAC__stream_decoder_get_blocksize(decoder) + + libflac.FLAC__stream_decoder_get_decode_position.restype = FLAC__bool + libflac.FLAC__stream_decoder_get_decode_position.argtypes = [POINTER(FLAC__StreamDecoder), FLAC__uint64_p] + + def FLAC__stream_decoder_get_decode_position(decoder, position): + return libflac.FLAC__stream_decoder_get_decode_position(decoder, position) + + libflac.FLAC__stream_decoder_init_stream.restype = FLAC__StreamDecoderInitStatus + libflac.FLAC__stream_decoder_init_stream.argtypes = [POINTER(FLAC__StreamDecoder), + FLAC__StreamDecoderReadCallback, + FLAC__StreamDecoderSeekCallback, + FLAC__StreamDecoderTellCallback, + FLAC__StreamDecoderLengthCallback, + FLAC__StreamDecoderEofCallback, + FLAC__StreamDecoderWriteCallback, + FLAC__StreamDecoderMetadataCallback, + FLAC__StreamDecoderErrorCallback, + c_void_p] + + def FLAC__stream_decoder_init_stream(decoder, read_callback, seek_callback, tell_callback, length_callback, eof_callback, write_callback, metadata_callback, error_callback, client_data): + return libflac.FLAC__stream_decoder_init_stream(decoder, read_callback, seek_callback, tell_callback, length_callback, eof_callback, write_callback, metadata_callback, error_callback, client_data) + + + libflac.FLAC__stream_decoder_init_ogg_stream.restype = FLAC__StreamDecoderInitStatus + libflac.FLAC__stream_decoder_init_ogg_stream.argtypes = [POINTER(FLAC__StreamDecoder), + FLAC__StreamDecoderReadCallback, + FLAC__StreamDecoderSeekCallback, + FLAC__StreamDecoderTellCallback, + FLAC__StreamDecoderLengthCallback, + FLAC__StreamDecoderEofCallback, + FLAC__StreamDecoderWriteCallback, + FLAC__StreamDecoderMetadataCallback, + FLAC__StreamDecoderErrorCallback, + c_void_p] + + def FLAC__stream_decoder_init_ogg_stream(decoder, read_callback, seek_callback, tell_callback, length_callback, eof_callback, write_callback, metadata_callback, error_callback, client_data): + return libflac.FLAC__stream_decoder_init_ogg_stream(decoder, read_callback, seek_callback, tell_callback, length_callback, eof_callback, write_callback, metadata_callback, error_callback, client_data) + + libflac.FLAC__stream_decoder_init_file.restype = FLAC__StreamDecoderInitStatus + libflac.FLAC__stream_decoder_init_file.argtypes = [POINTER(FLAC__StreamDecoder), + c_char_p, + FLAC__StreamDecoderWriteCallback, + FLAC__StreamDecoderMetadataCallback, + FLAC__StreamDecoderErrorCallback, + c_void_p] + + def FLAC__stream_decoder_init_file(decoder, filename, write_callback, metadata_callback, error_callback, client_data): + return libflac.FLAC__stream_decoder_init_file(decoder, filename, write_callback, metadata_callback, error_callback, client_data) + + libflac.FLAC__stream_decoder_init_ogg_file.restype = FLAC__StreamDecoderInitStatus + libflac.FLAC__stream_decoder_init_ogg_file.argtypes = [POINTER(FLAC__StreamDecoder), + c_char_p, + FLAC__StreamDecoderWriteCallback, + FLAC__StreamDecoderMetadataCallback, + FLAC__StreamDecoderErrorCallback, + c_void_p] + + def FLAC__stream_decoder_init_ogg_file(decoder, filename, write_callback, metadata_callback, error_callback, client_data): + return libflac.FLAC__stream_decoder_init_ogg_file(decoder, filename, write_callback, metadata_callback, error_callback, client_data) + + libflac.FLAC__stream_decoder_finish.restype = FLAC__bool + libflac.FLAC__stream_decoder_finish.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_finish(decoder): + return libflac.FLAC__stream_decoder_finish(decoder) + + libflac.FLAC__stream_decoder_flush.restype = FLAC__bool + libflac.FLAC__stream_decoder_flush.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_flush(decoder): + return libflac.FLAC__stream_decoder_flush(decoder) + + libflac.FLAC__stream_decoder_reset.restype = FLAC__bool + libflac.FLAC__stream_decoder_reset.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_reset(decoder): + return libflac.FLAC__stream_decoder_reset(decoder) + + libflac.FLAC__stream_decoder_process_single.restype = FLAC__bool + libflac.FLAC__stream_decoder_process_single.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_process_single(decoder): + return libflac.FLAC__stream_decoder_process_single(decoder) + + libflac.FLAC__stream_decoder_process_until_end_of_metadata.restype = FLAC__bool + libflac.FLAC__stream_decoder_process_until_end_of_metadata.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_process_until_end_of_metadata(decoder): + return libflac.FLAC__stream_decoder_process_until_end_of_metadata(decoder) + + libflac.FLAC__stream_decoder_process_until_end_of_stream.restype = FLAC__bool + libflac.FLAC__stream_decoder_process_until_end_of_stream.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_process_until_end_of_stream(decoder): + return libflac.FLAC__stream_decoder_process_until_end_of_stream(decoder) + + libflac.FLAC__stream_decoder_skip_single_frame.restype = FLAC__bool + libflac.FLAC__stream_decoder_skip_single_frame.argtypes = [POINTER(FLAC__StreamDecoder)] + + def FLAC__stream_decoder_skip_single_frame(decoder): + return libflac.FLAC__stream_decoder_skip_single_frame(decoder) + + libflac.FLAC__stream_decoder_seek_absolute.restype = FLAC__bool + libflac.FLAC__stream_decoder_seek_absolute.argtypes = [POINTER(FLAC__StreamDecoder), FLAC__uint64] + + def FLAC__stream_decoder_seek_absolute(decoder, sample): + return libflac.FLAC__stream_decoder_seek_absolute(decoder, sample) + + # /stream_decoder + + # stream_encoder + + FLAC__StreamEncoderState = c_int + + libflac.FLAC__StreamEncoderStateString.restype = c_char_p + libflac.FLAC__StreamEncoderStateString.argtypes = [] + + def FLAC__StreamEncoderStateString(): + return libflac.FLAC__StreamEncoderStateString() + + + FLAC__StreamEncoderInitStatus = c_int + + libflac.FLAC__StreamEncoderInitStatusString.restype = c_char_p + libflac.FLAC__StreamEncoderInitStatusString.argtypes = [] + + def FLAC__StreamEncoderInitStatusString(): + return libflac.FLAC__StreamEncoderInitStatusString() + + + FLAC__StreamEncoderReadStatus = c_int + + libflac.FLAC__StreamEncoderReadStatusString.restype = c_char_p + libflac.FLAC__StreamEncoderReadStatusString.argtypes = [] + + def FLAC__StreamEncoderReadStatusString(): + return libflac.FLAC__StreamEncoderReadStatusString() + + + FLAC__StreamEncoderWriteStatus = c_int + + libflac.FLAC__StreamEncoderWriteStatusString.restype = c_char_p + libflac.FLAC__StreamEncoderWriteStatusString.argtypes = [] + + def FLAC__StreamEncoderWriteStatusString(): + return libflac.FLAC__StreamEncoderWriteStatusString() + + + FLAC__StreamEncoderSeekStatus = c_int + + libflac.FLAC__StreamEncoderSeekStatusString.restype = c_char_p + libflac.FLAC__StreamEncoderSeekStatusString.argtypes = [] + + def FLAC__StreamEncoderSeekStatusString(): + return libflac.FLAC__StreamEncoderSeekStatusString() + + + FLAC__StreamEncoderTellStatus = c_int + + libflac.FLAC__StreamEncoderTellStatusString.restype = c_char_p + libflac.FLAC__StreamEncoderTellStatusString.argtypes = [] + + def FLAC__StreamEncoderTellStatusString(): + return libflac.FLAC__StreamEncoderTellStatusString() + + + class FLAC__StreamEncoderProtected(Structure): + _fields_ = [("dummy", c_int)] + + class FLAC__StreamEncoderPrivate(Structure): + _fields_ = [("dummy", c_int)] + + class FLAC__StreamEncoder(Structure): + _fields_ = [("protected_", POINTER(FLAC__StreamEncoderProtected)), + ("private_", POINTER(FLAC__StreamEncoderPrivate))] + + FLAC__StreamEncoderReadCallback = CFUNCTYPE(FLAC__StreamEncoderReadStatus, POINTER(FLAC__StreamEncoder), POINTER(FLAC__byte*0), c_size_t_p, c_void_p) + + FLAC__StreamEncoderWriteCallback = CFUNCTYPE(FLAC__StreamEncoderWriteStatus, POINTER(FLAC__StreamEncoder), POINTER(FLAC__byte*0), c_size_t, c_uint, c_uint, c_void_p) + + FLAC__StreamEncoderSeekCallback = CFUNCTYPE(FLAC__StreamEncoderSeekStatus, POINTER(FLAC__StreamEncoder), FLAC__uint64, c_void_p) + + FLAC__StreamEncoderTellCallback = CFUNCTYPE(FLAC__StreamEncoderTellStatus, POINTER(FLAC__StreamEncoder), FLAC__uint64_p, c_void_p) + + FLAC__StreamEncoderMetadataCallback = CFUNCTYPE(None, POINTER(FLAC__StreamEncoder), POINTER(FLAC__StreamMetadata), c_void_p) + + FLAC__StreamEncoderProgressCallback = CFUNCTYPE(None, POINTER(FLAC__StreamEncoder), FLAC__uint64,FLAC__uint64, c_uint, c_uint, c_void_p) + + + libflac.FLAC__stream_encoder_new.restype = POINTER(FLAC__StreamEncoder) + libflac.FLAC__stream_encoder_new.argtypes = [] + + def FLAC__stream_encoder_new(): + return libflac.FLAC__stream_encoder_new() + + libflac.FLAC__stream_encoder_delete.restype = None + libflac.FLAC__stream_encoder_delete.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_delete(encoder): + return libflac.FLAC__stream_encoder_delete(encoder) + + + libflac.FLAC__stream_encoder_set_ogg_serial_number.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_ogg_serial_number.argtypes = [POINTER(FLAC__StreamEncoder), c_long] + + def FLAC__stream_encoder_set_ogg_serial_number(encoder, serial_number): + return libflac.FLAC__stream_encoder_set_ogg_serial_number(encoder, serial_number) + + libflac.FLAC__stream_encoder_set_verify.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_verify.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_verify(encoder, value): + return libflac.FLAC__stream_encoder_set_verify(encoder, value) + + libflac.FLAC__stream_encoder_set_streamable_subset.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_streamable_subset.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_streamable_subset(encoder, value): + return libflac.FLAC__stream_encoder_set_streamable_subset(encoder, value) + + libflac.FLAC__stream_encoder_set_channels.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_channels.argtypes = [POINTER(FLAC__StreamEncoder), c_uint] + + def FLAC__stream_encoder_set_channels(encoder, value): + return libflac.FLAC__stream_encoder_set_channels(encoder, value) + + libflac.FLAC__stream_encoder_set_bits_per_sample.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_bits_per_sample.argtypes = [POINTER(FLAC__StreamEncoder), c_uint] + + def FLAC__stream_encoder_set_bits_per_sample(encoder, value): + return libflac.FLAC__stream_encoder_set_bits_per_sample(encoder, value) + + libflac.FLAC__stream_encoder_set_sample_rate.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_sample_rate.argtypes = [POINTER(FLAC__StreamEncoder), c_uint] + + def FLAC__stream_encoder_set_sample_rate(encoder, value): + return libflac.FLAC__stream_encoder_set_sample_rate(encoder, value) + + libflac.FLAC__stream_encoder_set_compression_level.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_compression_level.argtypes = [POINTER(FLAC__StreamEncoder), c_uint] + + def FLAC__stream_encoder_set_compression_level(encoder, value): + return libflac.FLAC__stream_encoder_set_compression_level(encoder, value) + + libflac.FLAC__stream_encoder_set_blocksize.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_blocksize.argtypes = [POINTER(FLAC__StreamEncoder), c_uint] + + def FLAC__stream_encoder_set_blocksize(encoder, value): + return libflac.FLAC__stream_encoder_set_blocksize(encoder, value) + + libflac.FLAC__stream_encoder_set_do_mid_side_stereo.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_do_mid_side_stereo.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_do_mid_side_stereo(encoder, value): + return libflac.FLAC__stream_encoder_set_do_mid_side_stereo(encoder, value) + + libflac.FLAC__stream_encoder_set_loose_mid_side_stereo.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_loose_mid_side_stereo.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, value): + return libflac.FLAC__stream_encoder_set_loose_mid_side_stereo(encoder, value) + + libflac.FLAC__stream_encoder_set_apodization.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_apodization.argtypes = [POINTER(FLAC__StreamEncoder), c_char_p] + + def FLAC__stream_encoder_set_apodization(encoder, specification): + return libflac.FLAC__stream_encoder_set_apodization(encoder, specification) + + libflac.FLAC__stream_encoder_set_max_lpc_order.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_max_lpc_order.argtypes = [POINTER(FLAC__StreamEncoder), c_uint] + + def FLAC__stream_encoder_set_max_lpc_order(encoder, value): + return libflac.FLAC__stream_encoder_set_max_lpc_order(encoder, value) + + libflac.FLAC__stream_encoder_set_qlp_coeff_precision.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_qlp_coeff_precision.argtypes = [POINTER(FLAC__StreamEncoder), c_uint] + + def FLAC__stream_encoder_set_qlp_coeff_precision(encoder, value): + return libflac.FLAC__stream_encoder_set_qlp_coeff_precision(encoder, value) + + libflac.FLAC__stream_encoder_set_do_qlp_coeff_prec_search.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_do_qlp_coeff_prec_search.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, value): + return libflac.FLAC__stream_encoder_set_do_qlp_coeff_prec_search(encoder, value) + + libflac.FLAC__stream_encoder_set_do_escape_coding.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_do_escape_coding.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_do_escape_coding(encoder, value): + return libflac.FLAC__stream_encoder_set_do_escape_coding(encoder, value) + + libflac.FLAC__stream_encoder_set_do_exhaustive_model_search.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_do_exhaustive_model_search.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, value): + return libflac.FLAC__stream_encoder_set_do_exhaustive_model_search(encoder, value) + + libflac.FLAC__stream_encoder_set_min_residual_partition_order.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_min_residual_partition_order.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_min_residual_partition_order(encoder, value): + return libflac.FLAC__stream_encoder_set_min_residual_partition_order(encoder, value) + + libflac.FLAC__stream_encoder_set_max_residual_partition_order.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_max_residual_partition_order.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_max_residual_partition_order(encoder, value): + return libflac.FLAC__stream_encoder_set_max_residual_partition_order(encoder, value) + + libflac.FLAC__stream_encoder_set_rice_parameter_search_dist.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_rice_parameter_search_dist.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__bool] + + def FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, value): + return libflac.FLAC__stream_encoder_set_rice_parameter_search_dist(encoder, value) + + libflac.FLAC__stream_encoder_set_total_samples_estimate.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_total_samples_estimate.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__uint64] + + def FLAC__stream_encoder_set_total_samples_estimate(encoder, value): + return libflac.FLAC__stream_encoder_set_total_samples_estimate(encoder, value) + + libflac.FLAC__stream_encoder_set_metadata.restype = FLAC__bool + libflac.FLAC__stream_encoder_set_metadata.argtypes = [POINTER(FLAC__StreamEncoder), POINTER(POINTER(FLAC__StreamMetadata)), c_uint] + + def FLAC__stream_encoder_set_metadata(encoder, metadata, num_blocks): + return libflac.FLAC__stream_encoder_set_metadata(encoder, metadata, num_blocks) + + libflac.FLAC__stream_encoder_get_state.restype = FLAC__StreamEncoderState + libflac.FLAC__stream_encoder_get_state.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_state(encoder): + return libflac.FLAC__stream_encoder_get_state(encoder) + + libflac.FLAC__stream_encoder_get_verify_decoder_state.restype = FLAC__StreamEncoderState + libflac.FLAC__stream_encoder_get_verify_decoder_state.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_verify_decoder_state(encoder): + return libflac.FLAC__stream_encoder_get_verify_decoder_state(encoder) + + libflac.FLAC__stream_encoder_get_resolved_state_string.restype = c_char_p + libflac.FLAC__stream_encoder_get_resolved_state_string.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_resolved_state_string(encoder): + return libflac.FLAC__stream_encoder_get_resolved_state_string(encoder) + + libflac.FLAC__stream_encoder_get_verify_decoder_error_stats.restype = None + libflac.FLAC__stream_encoder_get_verify_decoder_error_stats.argtypes = [POINTER(FLAC__StreamEncoder), FLAC__uint64_p, c_uint_p, c_uint_p, c_uint_p, FLAC__int32_p, FLAC__int32_p] + + def FLAC__stream_encoder_get_verify_decoder_error_stats(encoder, absolute_sample, frame_number, channel, sample, expected, got): + return libflac.FLAC__stream_encoder_get_verify_decoder_error_stats(encoder, absolute_sample, frame_number, channel, sample, expected, got) + + libflac.FLAC__stream_encoder_get_verify.restype = FLAC__bool + libflac.FLAC__stream_encoder_get_verify.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_verify(encoder): + return libflac.FLAC__stream_encoder_get_verify(encoder) + + libflac.FLAC__stream_encoder_get_streamable_subset.restype = FLAC__bool + libflac.FLAC__stream_encoder_get_streamable_subset.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_streamable_subset(encoder): + return libflac.FLAC__stream_encoder_get_streamable_subset(encoder) + + libflac.FLAC__stream_encoder_get_channels.restype = c_uint + libflac.FLAC__stream_encoder_get_channels.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_channels(encoder): + return libflac.FLAC__stream_encoder_get_channels(encoder) + + libflac.FLAC__stream_encoder_get_bits_per_sample.restype = c_uint + libflac.FLAC__stream_encoder_get_bits_per_sample.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_bits_per_sample(encoder): + return libflac.FLAC__stream_encoder_get_bits_per_sample(encoder) + + libflac.FLAC__stream_encoder_get_sample_rate.restype = c_uint + libflac.FLAC__stream_encoder_get_sample_rate.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_sample_rate(encoder): + return libflac.FLAC__stream_encoder_get_sample_rate(encoder) + + libflac.FLAC__stream_encoder_get_blocksize.restype = c_uint + libflac.FLAC__stream_encoder_get_blocksize.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_blocksize(encoder): + return libflac.FLAC__stream_encoder_get_blocksize(encoder) + + libflac.FLAC__stream_encoder_get_do_mid_side_stereo.restype = FLAC__bool + libflac.FLAC__stream_encoder_get_do_mid_side_stereo.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_do_mid_side_stereo(encoder): + return libflac.FLAC__stream_encoder_get_do_mid_side_stereo(encoder) + + libflac.FLAC__stream_encoder_get_loose_mid_side_stereo.restype = FLAC__bool + libflac.FLAC__stream_encoder_get_loose_mid_side_stereo.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_loose_mid_side_stereo(encoder): + return libflac.FLAC__stream_encoder_get_loose_mid_side_stereo(encoder) + + libflac.FLAC__stream_encoder_get_max_lpc_order.restype = c_uint + libflac.FLAC__stream_encoder_get_max_lpc_order.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_max_lpc_order(encoder): + return libflac.FLAC__stream_encoder_get_max_lpc_order(encoder) + + libflac.FLAC__stream_encoder_get_qlp_coeff_precision.restype = c_uint + libflac.FLAC__stream_encoder_get_qlp_coeff_precision.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_qlp_coeff_precision(encoder): + return libflac.FLAC__stream_encoder_get_qlp_coeff_precision(encoder) + + libflac.FLAC__stream_encoder_get_do_qlp_coeff_prec_search.restype = FLAC__bool + libflac.FLAC__stream_encoder_get_do_qlp_coeff_prec_search.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder): + return libflac.FLAC__stream_encoder_get_do_qlp_coeff_prec_search(encoder) + + libflac.FLAC__stream_encoder_get_do_escape_coding.restype = FLAC__bool + libflac.FLAC__stream_encoder_get_do_escape_coding.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_do_escape_coding(encoder): + return libflac.FLAC__stream_encoder_get_do_escape_coding(encoder) + + libflac.FLAC__stream_encoder_get_do_exhaustive_model_search.restype = FLAC__bool + libflac.FLAC__stream_encoder_get_do_exhaustive_model_search.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_do_exhaustive_model_search(encoder): + return libflac.FLAC__stream_encoder_get_do_exhaustive_model_search(encoder) + + libflac.FLAC__stream_encoder_get_min_residual_partition_order.restype = c_uint + libflac.FLAC__stream_encoder_get_min_residual_partition_order.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_min_residual_partition_order(encoder): + return libflac.FLAC__stream_encoder_get_min_residual_partition_order(encoder) + + libflac.FLAC__stream_encoder_get_max_residual_partition_order.restype = c_uint + libflac.FLAC__stream_encoder_get_max_residual_partition_order.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_max_residual_partition_order(encoder): + return libflac.FLAC__stream_encoder_get_max_residual_partition_order(encoder) + + libflac.FLAC__stream_encoder_get_rice_parameter_search_dist.restype = c_uint + libflac.FLAC__stream_encoder_get_rice_parameter_search_dist.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_rice_parameter_search_dist(encoder): + return libflac.FLAC__stream_encoder_get_rice_parameter_search_dist(encoder) + + libflac.FLAC__stream_encoder_get_total_samples_estimate.restype = FLAC__uint64 + libflac.FLAC__stream_encoder_get_total_samples_estimate.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_get_total_samples_estimate(encoder): + return libflac.FLAC__stream_encoder_get_total_samples_estimate(encoder) + + libflac.FLAC__stream_encoder_init_stream.restype = FLAC__StreamEncoderInitStatus + libflac.FLAC__stream_encoder_init_stream.argtypes = [POINTER(FLAC__StreamEncoder), + FLAC__StreamEncoderWriteCallback, + FLAC__StreamEncoderSeekCallback, + FLAC__StreamEncoderTellCallback, + FLAC__StreamEncoderMetadataCallback, + c_void_p] + + def FLAC__stream_encoder_init_stream(encoder, write_callback, seek_callback, tell_callback, metadata_callback,client_data): + return libflac.FLAC__stream_encoder_init_stream(encoder, write_callback, seek_callback, tell_callback, metadata_callback,client_data) + + libflac.FLAC__stream_encoder_init_ogg_stream.restype = FLAC__StreamEncoderInitStatus + libflac.FLAC__stream_encoder_init_ogg_stream.argtypes = [POINTER(FLAC__StreamEncoder), + FLAC__StreamEncoderReadCallback, + FLAC__StreamEncoderWriteCallback, + FLAC__StreamEncoderSeekCallback, + FLAC__StreamEncoderTellCallback, + FLAC__StreamEncoderMetadataCallback, + c_void_p] + + def FLAC__stream_encoder_init_ogg_stream(encoder, read_callback, write_callback, seek_callback, tell_callback, metadata_callback,client_data): + return libflac.FLAC__stream_encoder_init_ogg_stream(encoder, read_callback, write_callback, seek_callback, tell_callback, metadata_callback,client_data) + + libflac.FLAC__stream_encoder_init_file.restype = FLAC__StreamEncoderInitStatus + libflac.FLAC__stream_encoder_init_file.argtypes = [POINTER(FLAC__StreamEncoder), + c_char_p, + FLAC__StreamEncoderProgressCallback, + c_void_p] + + def FLAC__stream_encoder_init_file(encoder, filename, progress_callback,client_data): + return libflac.FLAC__stream_encoder_init_file(encoder, filename, progress_callback,client_data) + + + libflac.FLAC__stream_encoder_init_ogg_file.restype = FLAC__StreamEncoderInitStatus + libflac.FLAC__stream_encoder_init_ogg_file.argtypes = [POINTER(FLAC__StreamEncoder), + c_char_p, + FLAC__StreamEncoderProgressCallback, + c_void_p] + + def FLAC__stream_encoder_init_ogg_file(encoder, filename, progress_callback,client_data): + return libflac.FLAC__stream_encoder_init_ogg_file(encoder, filename, progress_callback,client_data) + + libflac.FLAC__stream_encoder_finish.restype = FLAC__bool + libflac.FLAC__stream_encoder_finish.argtypes = [POINTER(FLAC__StreamEncoder)] + + def FLAC__stream_encoder_finish(encoder): + return libflac.FLAC__stream_encoder_finish(encoder) + + libflac.FLAC__stream_encoder_process.restype = FLAC__bool + libflac.FLAC__stream_encoder_process.argtypes = [POINTER(FLAC__StreamEncoder), POINTER(FLAC__int32_p*0), c_uint] + + def FLAC__stream_encoder_process(encoder, buffer, samples): + return libflac.FLAC__stream_encoder_process(encoder, buffer, samples) + + libflac.FLAC__stream_encoder_process_interleaved.restype = FLAC__bool + libflac.FLAC__stream_encoder_process_interleaved.argtypes = [POINTER(FLAC__StreamEncoder), POINTER(FLAC__int32*0), c_uint] + + def FLAC__stream_encoder_process_interleaved(encoder, buffer, samples): + return libflac.FLAC__stream_encoder_process_interleaved(encoder, buffer, samples) + + # /stream_encoder diff --git a/LXST/Codecs/libs/pyogg/flac_file.py b/LXST/Codecs/libs/pyogg/flac_file.py new file mode 100644 index 0000000..7e97ca7 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/flac_file.py @@ -0,0 +1,114 @@ +import ctypes +from itertools import chain + +from . import flac +from .audio_file import AudioFile +from .pyogg_error import PyOggError + +def _to_char_p(string): + try: + return ctypes.c_char_p(string.encode("utf-8")) + except: + return ctypes.c_char_p(string) + +def _resize_array(array, new_size): + return (array._type_*new_size).from_address(ctypes.addressof(array)) + + +class FlacFile(AudioFile): + def write_callback(self, decoder, frame, buffer, client_data): + multi_channel_buf = _resize_array(buffer.contents, self.channels) + arr_size = frame.contents.header.blocksize + if frame.contents.header.channels >= 2: + arrays = [] + for i in range(frame.contents.header.channels): + arr = ctypes.cast(multi_channel_buf[i], ctypes.POINTER(flac.FLAC__int32*arr_size)).contents + arrays.append(arr[:]) + + arr = list(chain.from_iterable(zip(*arrays))) + + self.buffer[self.buffer_pos : self.buffer_pos + len(arr)] = arr[:] + self.buffer_pos += len(arr) + + else: + arr = ctypes.cast(multi_channel_buf[0], ctypes.POINTER(flac.FLAC__int32*arr_size)).contents + self.buffer[self.buffer_pos : self.buffer_pos + arr_size] = arr[:] + self.buffer_pos += arr_size + return 0 + + def metadata_callback(self,decoder, metadata, client_data): + if not self.buffer: + self.total_samples = metadata.contents.data.stream_info.total_samples + self.channels = metadata.contents.data.stream_info.channels + Buffer = flac.FLAC__int16*(self.total_samples * self.channels) + self.buffer = Buffer() + self.frequency = metadata.contents.data.stream_info.sample_rate + + def error_callback(self,decoder, status, client_data): + raise PyOggError("An error occured during the process of decoding. Status enum: {}".format(flac.FLAC__StreamDecoderErrorStatusEnum[status])) + + def __init__(self, path): + self.decoder = flac.FLAC__stream_decoder_new() + + self.client_data = ctypes.c_void_p() + + #: Number of channels in audio file. + self.channels = None + + #: Number of samples per second (per channel). For + # example, 44100. + self.frequency = None + + self.total_samples = None + + #: Raw PCM data from audio file. + self.buffer = None + + self.buffer_pos = 0 + + write_callback_ = flac.FLAC__StreamDecoderWriteCallback(self.write_callback) + + metadata_callback_ = flac.FLAC__StreamDecoderMetadataCallback(self.metadata_callback) + + error_callback_ = flac.FLAC__StreamDecoderErrorCallback(self.error_callback) + + init_status = flac.FLAC__stream_decoder_init_file( + self.decoder, + _to_char_p(path), # This will have an issue with Unicode filenames + write_callback_, + metadata_callback_, + error_callback_, + self.client_data + ) + + if init_status: # error + error = flac.FLAC__StreamDecoderInitStatusEnum[init_status] + raise PyOggError( + "An error occured when trying to open '{}': {}".format(path, error) + ) + + metadata_status = (flac.FLAC__stream_decoder_process_until_end_of_metadata(self.decoder)) + if not metadata_status: # error + raise PyOggError("An error occured when trying to decode the metadata of {}".format(path)) + + stream_status = (flac.FLAC__stream_decoder_process_until_end_of_stream(self.decoder)) + if not stream_status: # error + raise PyOggError("An error occured when trying to decode the audio stream of {}".format(path)) + + flac.FLAC__stream_decoder_finish(self.decoder) + + #: Length of buffer + self.buffer_length = len(self.buffer) + + self.bytes_per_sample = ctypes.sizeof(flac.FLAC__int16) # See definition of Buffer in metadata_callback() + + # Cast buffer to one-dimensional array of chars + CharBuffer = ( + ctypes.c_byte * + (self.bytes_per_sample * len(self.buffer)) + ) + self.buffer = CharBuffer.from_buffer(self.buffer) + + # FLAC audio is always signed. See + # https://xiph.org/flac/api/group__flac__stream__decoder.html#gaf98a4f9e2cac5747da6018c3dfc8dde1 + self.signed = True diff --git a/LXST/Codecs/libs/pyogg/flac_file_stream.py b/LXST/Codecs/libs/pyogg/flac_file_stream.py new file mode 100644 index 0000000..f832c31 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/flac_file_stream.py @@ -0,0 +1,141 @@ +import ctypes +from itertools import chain + +from . import flac +from .pyogg_error import PyOggError + +def _to_char_p(string): + try: + return ctypes.c_char_p(string.encode("utf-8")) + except: + return ctypes.c_char_p(string) + +def _resize_array(array, new_size): + return (array._type_*new_size).from_address(ctypes.addressof(array)) + + +class FlacFileStream: + def write_callback(self,decoder, frame, buffer, client_data): + multi_channel_buf = _resize_array(buffer.contents, self.channels) + arr_size = frame.contents.header.blocksize + if frame.contents.header.channels >= 2: + arrays = [] + for i in range(frame.contents.header.channels): + arr = ctypes.cast(multi_channel_buf[i], ctypes.POINTER(flac.FLAC__int32*arr_size)).contents + arrays.append(arr[:]) + + arr = list(chain.from_iterable(zip(*arrays))) + + self.buffer = (flac.FLAC__int16*len(arr))(*arr) + self.bytes_written = len(arr) * 2 + + else: + arr = ctypes.cast(multi_channel_buf[0], ctypes.POINTER(flac.FLAC__int32*arr_size)).contents + self.buffer = (flac.FLAC__int16*len(arr))(*arr[:]) + self.bytes_written = arr_size * 2 + return 0 + + def metadata_callback(self,decoder, metadata, client_data): + self.total_samples = metadata.contents.data.stream_info.total_samples + self.channels = metadata.contents.data.stream_info.channels + self.frequency = metadata.contents.data.stream_info.sample_rate + + def error_callback(self,decoder, status, client_data): + raise PyOggError("An error occured during the process of decoding. Status enum: {}".format(flac.FLAC__StreamDecoderErrorStatusEnum[status])) + + def __init__(self, path): + self.decoder = flac.FLAC__stream_decoder_new() + + self.client_data = ctypes.c_void_p() + + #: Number of channels in audio file. + self.channels = None + + #: Number of samples per second (per channel). For + # example, 44100. + self.frequency = None + + self.total_samples = None + + self.buffer = None + + self.bytes_written = None + + self.write_callback_ = flac.FLAC__StreamDecoderWriteCallback(self.write_callback) + + self.metadata_callback_ = flac.FLAC__StreamDecoderMetadataCallback(self.metadata_callback) + + self.error_callback_ = flac.FLAC__StreamDecoderErrorCallback(self.error_callback) + + init_status = flac.FLAC__stream_decoder_init_file(self.decoder, + _to_char_p(path), + self.write_callback_, + self.metadata_callback_, + self.error_callback_, + self.client_data) + + if init_status: # error + raise PyOggError("An error occured when trying to open '{}': {}".format(path, flac.FLAC__StreamDecoderInitStatusEnum[init_status])) + + metadata_status = (flac.FLAC__stream_decoder_process_until_end_of_metadata(self.decoder)) + if not metadata_status: # error + raise PyOggError("An error occured when trying to decode the metadata of {}".format(path)) + + #: Bytes per sample + self.bytes_per_sample = 2 + + def get_buffer(self): + """Returns the buffer. + + Returns buffer (a bytes object) or None if all data has + been read from the file. + + """ + # Attempt to read a single frame of audio + stream_status = (flac.FLAC__stream_decoder_process_single(self.decoder)) + if not stream_status: # error + raise PyOggError("An error occured when trying to decode the audio stream of {}".format(path)) + + # Check if we encountered the end of the stream + if (flac.FLAC__stream_decoder_get_state(self.decoder) == 4): # end of stream + return None + + buffer_as_bytes = bytes(self.buffer) + return buffer_as_bytes + + def clean_up(self): + flac.FLAC__stream_decoder_finish(self.decoder) + + def get_buffer_as_array(self): + """Provides the buffer as a NumPy array. + + Note that the underlying data type is 16-bit signed + integers. + + Does not copy the underlying data, so the returned array + should either be processed or copied before the next call + to get_buffer() or get_buffer_as_array(). + + """ + import numpy # type: ignore + + # Read the next samples from the stream + buf = self.get_buffer() + + # Check if we've come to the end of the stream + if buf is None: + return None + + # Convert the bytes buffer to a NumPy array + array = numpy.frombuffer( + buf, + dtype=numpy.int16 + ) + + # Reshape the array + return array.reshape( + (len(buf) + // self.bytes_per_sample + // self.channels, + self.channels) + ) diff --git a/LXST/Codecs/libs/pyogg/library_loader.py b/LXST/Codecs/libs/pyogg/library_loader.py new file mode 100644 index 0000000..711b1ba --- /dev/null +++ b/LXST/Codecs/libs/pyogg/library_loader.py @@ -0,0 +1,147 @@ +import ctypes +import ctypes.util +import os +import sys +import platform +from typing import ( + Optional, + Dict, + List +) + +_here = os.path.dirname(__file__) + +class ExternalLibraryError(Exception): + pass + +architecture = platform.architecture()[0] + +_windows_styles = ["{}", "lib{}", "lib{}_dynamic", "{}_dynamic"] + +_other_styles = ["{}", "lib{}"] + +if architecture == "32bit": + for arch_style in ["32bit", "32" "86", "win32", "x86", "_x86", "_32", "_win32", "_32bit"]: + for style in ["{}", "lib{}"]: + _windows_styles.append(style.format("{}"+arch_style)) + +elif architecture == "64bit": + for arch_style in ["64bit", "64" "86_64", "amd64", "win_amd64", "x86_64", "_x86_64", "_64", "_amd64", "_64bit"]: + for style in ["{}", "lib{}"]: + _windows_styles.append(style.format("{}"+arch_style)) + + +run_tests = lambda lib, tests: [f(lib) for f in tests] + +# Get the appropriate directory for the shared libraries depending +# on the current platform and architecture +platform_ = platform.system() +lib_dir = None +if platform_ == "Darwin": + lib_dir = "libs/macos" +elif platform_ == "Windows": + if architecture == "32bit": + lib_dir = "libs/win32" + elif architecture == "64bit": + lib_dir = "libs/win_amd64" + + +class Library: + @staticmethod + def load(names: Dict[str, str], paths: Optional[List[str]] = None, tests = []) -> Optional[ctypes.CDLL]: + lib = InternalLibrary.load(names, tests) + if lib is None: + lib = ExternalLibrary.load(names["external"], paths, tests) + return lib + + +class InternalLibrary: + @staticmethod + def load(names: Dict[str, str], tests) -> Optional[ctypes.CDLL]: + # If we do not have a library directory, give up immediately + if lib_dir is None: + return None + + # Get the appropriate library filename given the platform + try: + name = names[platform_] + except KeyError: + return None + + # Attempt to load the library from here + path = _here + "/" + lib_dir + "/" + name + try: + lib = ctypes.CDLL(path) + except OSError as e: + return None + + # Check that the library passes the tests + if tests and all(run_tests(lib, tests)): + return lib + + # Library failed tests + return None + +# Cache of libraries that have already been loaded +_loaded_libraries: Dict[str, ctypes.CDLL] = {} + +class ExternalLibrary: + @staticmethod + def load(name, paths = None, tests = []): + if name in _loaded_libraries: + return _loaded_libraries[name] + if sys.platform == "win32": + lib = ExternalLibrary.load_windows(name, paths, tests) + _loaded_libraries[name] = lib + return lib + else: + lib = ExternalLibrary.load_other(name, paths, tests) + _loaded_libraries[name] = lib + return lib + + @staticmethod + def load_other(name, paths = None, tests = []): + os.environ["PATH"] += ";" + ";".join((os.getcwd(), _here)) + if paths: os.environ["PATH"] += ";" + ";".join(paths) + + for style in _other_styles: + candidate = style.format(name) + library = ctypes.util.find_library(candidate) + if library: + try: + lib = ctypes.CDLL(library) + if tests and all(run_tests(lib, tests)): + return lib + except: + pass + + @staticmethod + def load_windows(name, paths = None, tests = []): + os.environ["PATH"] += ";" + ";".join((os.getcwd(), _here)) + if paths: os.environ["PATH"] += ";" + ";".join(paths) + + not_supported = [] # libraries that were found, but are not supported + for style in _windows_styles: + candidate = style.format(name) + library = ctypes.util.find_library(candidate) + if library: + try: + lib = ctypes.CDLL(library) + if tests and all(run_tests(lib, tests)): + return lib + not_supported.append(library) + except WindowsError: + pass + except OSError: + not_supported.append(library) + + + if not_supported: + raise ExternalLibraryError("library '{}' couldn't be loaded, because the following candidates were not supported:".format(name) + + ("\n{}" * len(not_supported)).format(*not_supported)) + + raise ExternalLibraryError("library '{}' couldn't be loaded".format(name)) + + + + diff --git a/LXST/Codecs/libs/pyogg/ogg.py b/LXST/Codecs/libs/pyogg/ogg.py new file mode 100644 index 0000000..08a944b --- /dev/null +++ b/LXST/Codecs/libs/pyogg/ogg.py @@ -0,0 +1,672 @@ +############################################################ +# Ogg license: # +############################################################ +""" +Copyright (c) 2002, Xiph.org Foundation + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +- Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +- Neither the name of the Xiph.org Foundation nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" + +import ctypes +from ctypes import c_int, c_int8, c_int16, c_int32, c_int64, c_uint, c_uint8, c_uint16, c_uint32, c_uint64, c_float, c_long, c_ulong, c_char, c_char_p, c_ubyte, c_longlong, c_ulonglong, c_size_t, c_void_p, c_double, POINTER, pointer, cast +import ctypes.util +import sys +from traceback import print_exc as _print_exc +import os + +from .library_loader import Library, ExternalLibrary, ExternalLibraryError + + +def get_raw_libname(name): + name = os.path.splitext(name)[0].lower() + for x in "0123456789._- ":name=name.replace(x,"") + return name + +# Define a function to convert strings to char-pointers. In Python 3 +# all strings are Unicode, while in Python 2 they were ASCII-encoded. +# FIXME: Does PyOgg even support Python 2? +if sys.version_info.major > 2: + to_char_p = lambda s: s.encode('utf-8') +else: + to_char_p = lambda s: s + +__here = os.getcwd() + +libogg = None + +try: + names = { + "Windows": "ogg.dll", + "Darwin": "libogg.0.dylib", + "external": "ogg" + } + libogg = Library.load(names, tests = [lambda lib: hasattr(lib, "oggpack_writeinit")]) +except ExternalLibraryError: + pass +except: + _print_exc() + +if libogg is not None: + PYOGG_OGG_AVAIL = True +else: + PYOGG_OGG_AVAIL = False + +if PYOGG_OGG_AVAIL: + # Sanity check also satisfies mypy type checking + assert libogg is not None + + # ctypes + c_ubyte_p = POINTER(c_ubyte) + c_uchar = c_ubyte + c_uchar_p = c_ubyte_p + c_float_p = POINTER(c_float) + c_float_p_p = POINTER(c_float_p) + c_float_p_p_p = POINTER(c_float_p_p) + c_char_p_p = POINTER(c_char_p) + c_int_p = POINTER(c_int) + c_long_p = POINTER(c_long) + + # os_types + ogg_int16_t = c_int16 + ogg_uint16_t = c_uint16 + ogg_int32_t = c_int32 + ogg_uint32_t = c_uint32 + ogg_int64_t = c_int64 + ogg_uint64_t = c_uint64 + ogg_int64_t_p = POINTER(ogg_int64_t) + + # ogg + class ogg_iovec_t(ctypes.Structure): + """ + Wrapper for: + typedef struct ogg_iovec_t; + """ + _fields_ = [("iov_base", c_void_p), + ("iov_len", c_size_t)] + + class oggpack_buffer(ctypes.Structure): + """ + Wrapper for: + typedef struct oggpack_buffer; + """ + _fields_ = [("endbyte", c_long), + ("endbit", c_int), + ("buffer", c_uchar_p), + ("ptr", c_uchar_p), + ("storage", c_long)] + + class ogg_page(ctypes.Structure): + """ + Wrapper for: + typedef struct ogg_page; + """ + _fields_ = [("header", c_uchar_p), + ("header_len", c_long), + ("body", c_uchar_p), + ("body_len", c_long)] + + class ogg_stream_state(ctypes.Structure): + """ + Wrapper for: + typedef struct ogg_stream_state; + """ + _fields_ = [("body_data", c_uchar_p), + ("body_storage", c_long), + ("body_fill", c_long), + ("body_returned", c_long), + + ("lacing_vals", c_int), + ("granule_vals", ogg_int64_t), + + ("lacing_storage", c_long), + ("lacing_fill", c_long), + ("lacing_packet", c_long), + ("lacing_returned", c_long), + + ("header", c_uchar*282), + ("header_fill", c_int), + + ("e_o_s", c_int), + ("b_o_s", c_int), + + ("serialno", c_long), + ("pageno", c_long), + ("packetno", ogg_int64_t), + ("granulepos", ogg_int64_t)] + + class ogg_packet(ctypes.Structure): + """ + Wrapper for: + typedef struct ogg_packet; + """ + _fields_ = [("packet", c_uchar_p), + ("bytes", c_long), + ("b_o_s", c_long), + ("e_o_s", c_long), + + ("granulepos", ogg_int64_t), + + ("packetno", ogg_int64_t)] + + def __str__(self): + bos = "" + if self.b_o_s: + bos = "beginning of stream, " + eos = "" + if self.e_o_s: + eos = "end of stream, " + + # Converting the data will cause a seg-fault if the memory isn't valid + data = bytes(self.packet[0:self.bytes]) + value = ( + f"Ogg Packet <{hex(id(self))}>: " + + f"number {self.packetno}, " + + f"granule position {self.granulepos}, " + + bos + eos + + f"{self.bytes} bytes" + ) + return value + + class ogg_sync_state(ctypes.Structure): + """ + Wrapper for: + typedef struct ogg_sync_state; + """ + _fields_ = [("data", c_uchar_p), + ("storage", c_int), + ("fill", c_int), + ("returned", c_int), + + ("unsynched", c_int), + ("headerbytes", c_int), + ("bodybytes", c_int)] + + b_p = POINTER(oggpack_buffer) + oy_p = POINTER(ogg_sync_state) + op_p = POINTER(ogg_packet) + og_p = POINTER(ogg_page) + os_p = POINTER(ogg_stream_state) + iov_p = POINTER(ogg_iovec_t) + + libogg.oggpack_writeinit.restype = None + libogg.oggpack_writeinit.argtypes = [b_p] + + def oggpack_writeinit(b): + libogg.oggpack_writeinit(b) + + try: + libogg.oggpack_writecheck.restype = c_int + libogg.oggpack_writecheck.argtypes = [b_p] + def oggpack_writecheck(b): + libogg.oggpack_writecheck(b) + except: + pass + + libogg.oggpack_writetrunc.restype = None + libogg.oggpack_writetrunc.argtypes = [b_p, c_long] + + def oggpack_writetrunc(b, bits): + libogg.oggpack_writetrunc(b, bits) + + libogg.oggpack_writealign.restype = None + libogg.oggpack_writealign.argtypes = [b_p] + + def oggpack_writealign(b): + libogg.oggpack_writealign(b) + + libogg.oggpack_writecopy.restype = None + libogg.oggpack_writecopy.argtypes = [b_p, c_void_p, c_long] + + def oggpack_writecopy(b, source, bits): + libogg.oggpack_writecopy(b, source, bits) + + libogg.oggpack_reset.restype = None + libogg.oggpack_reset.argtypes = [b_p] + + def oggpack_reset(b): + libogg.oggpack_reset(b) + + libogg.oggpack_writeclear.restype = None + libogg.oggpack_writeclear.argtypes = [b_p] + + def oggpack_writeclear(b): + libogg.oggpack_writeclear(b) + + libogg.oggpack_readinit.restype = None + libogg.oggpack_readinit.argtypes = [b_p, c_uchar_p, c_int] + + def oggpack_readinit(b, buf, bytes): + libogg.oggpack_readinit(b, buf, bytes) + + libogg.oggpack_write.restype = None + libogg.oggpack_write.argtypes = [b_p, c_ulong, c_int] + + def oggpack_write(b, value, bits): + libogg.oggpack_write(b, value, bits) + + libogg.oggpack_look.restype = c_long + libogg.oggpack_look.argtypes = [b_p, c_int] + + def oggpack_look(b, bits): + return libogg.oggpack_look(b, bits) + + libogg.oggpack_look1.restype = c_long + libogg.oggpack_look1.argtypes = [b_p] + + def oggpack_look1(b): + return libogg.oggpack_look1(b) + + libogg.oggpack_adv.restype = None + libogg.oggpack_adv.argtypes = [b_p, c_int] + + def oggpack_adv(b, bits): + libogg.oggpack_adv(b, bits) + + libogg.oggpack_adv1.restype = None + libogg.oggpack_adv1.argtypes = [b_p] + + def oggpack_adv1(b): + libogg.oggpack_adv1(b) + + libogg.oggpack_read.restype = c_long + libogg.oggpack_read.argtypes = [b_p, c_int] + + def oggpack_read(b, bits): + return libogg.oggpack_read(b, bits) + + libogg.oggpack_read1.restype = c_long + libogg.oggpack_read1.argtypes = [b_p] + + def oggpack_read1(b): + return libogg.oggpack_read1(b) + + libogg.oggpack_bytes.restype = c_long + libogg.oggpack_bytes.argtypes = [b_p] + + def oggpack_bytes(b): + return libogg.oggpack_bytes(b) + + libogg.oggpack_bits.restype = c_long + libogg.oggpack_bits.argtypes = [b_p] + + def oggpack_bits(b): + return libogg.oggpack_bits(b) + + libogg.oggpack_get_buffer.restype = c_uchar_p + libogg.oggpack_get_buffer.argtypes = [b_p] + + def oggpack_get_buffer(b): + return libogg.oggpack_get_buffer(b) + + + + libogg.oggpackB_writeinit.restype = None + libogg.oggpackB_writeinit.argtypes = [b_p] + + def oggpackB_writeinit(b): + libogg.oggpackB_writeinit(b) + + try: + libogg.oggpackB_writecheck.restype = c_int + libogg.oggpackB_writecheck.argtypes = [b_p] + + def oggpackB_writecheck(b): + return libogg.oggpackB_writecheck(b) + except: + pass + + libogg.oggpackB_writetrunc.restype = None + libogg.oggpackB_writetrunc.argtypes = [b_p, c_long] + + def oggpackB_writetrunc(b, bits): + libogg.oggpackB_writetrunc(b, bits) + + libogg.oggpackB_writealign.restype = None + libogg.oggpackB_writealign.argtypes = [b_p] + + def oggpackB_writealign(b): + libogg.oggpackB_writealign(b) + + libogg.oggpackB_writecopy.restype = None + libogg.oggpackB_writecopy.argtypes = [b_p, c_void_p, c_long] + + def oggpackB_writecopy(b, source, bits): + libogg.oggpackB_writecopy(b, source, bits) + + libogg.oggpackB_reset.restype = None + libogg.oggpackB_reset.argtypes = [b_p] + + def oggpackB_reset(b): + libogg.oggpackB_reset(b) + + libogg.oggpackB_reset.restype = None + libogg.oggpackB_writeclear.argtypes = [b_p] + + def oggpackB_reset(b): + libogg.oggpackB_reset(b) + + libogg.oggpackB_readinit.restype = None + libogg.oggpackB_readinit.argtypes = [b_p, c_uchar_p, c_int] + + def oggpackB_readinit(b, buf, bytes): + libogg.oggpackB_readinit(b, buf, bytes) + + libogg.oggpackB_write.restype = None + libogg.oggpackB_write.argtypes = [b_p, c_ulong, c_int] + + def oggpackB_write(b, value, bits): + libogg.oggpackB_write(b, value, bits) + + libogg.oggpackB_look.restype = c_long + libogg.oggpackB_look.argtypes = [b_p, c_int] + + def oggpackB_look(b, bits): + return libogg.oggpackB_look(b, bits) + + libogg.oggpackB_look1.restype = c_long + libogg.oggpackB_look1.argtypes = [b_p] + + def oggpackB_look1(b): + return libogg.oggpackB_look1(b) + + libogg.oggpackB_adv.restype = None + libogg.oggpackB_adv.argtypes = [b_p, c_int] + + def oggpackB_adv(b, bits): + libogg.oggpackB_adv(b, bits) + + libogg.oggpackB_adv1.restype = None + libogg.oggpackB_adv1.argtypes = [b_p] + + def oggpackB_adv1(b): + libogg.oggpackB_adv1(b) + + libogg.oggpackB_read.restype = c_long + libogg.oggpackB_read.argtypes = [b_p, c_int] + + def oggpackB_read(b, bits): + return libogg.oggpackB_read(b, bits) + + libogg.oggpackB_read1.restype = c_long + libogg.oggpackB_read1.argtypes = [b_p] + + def oggpackB_read1(b): + return libogg.oggpackB_read1(b) + + libogg.oggpackB_bytes.restype = c_long + libogg.oggpackB_bytes.argtypes = [b_p] + + def oggpackB_bytes(b): + return libogg.oggpackB_bytes(b) + + libogg.oggpackB_bits.restype = c_long + libogg.oggpackB_bits.argtypes = [b_p] + + def oggpackB_bits(b): + return libogg.oggpackB_bits(b) + + libogg.oggpackB_get_buffer.restype = c_uchar_p + libogg.oggpackB_get_buffer.argtypes = [b_p] + + def oggpackB_get_buffer(b): + return libogg.oggpackB_get_buffer(b) + + + + libogg.ogg_stream_packetin.restype = c_int + libogg.ogg_stream_packetin.argtypes = [os_p, op_p] + + def ogg_stream_packetin(os, op): + return libogg.ogg_stream_packetin(os, op) + + try: + libogg.ogg_stream_iovecin.restype = c_int + libogg.ogg_stream_iovecin.argtypes = [os_p, iov_p, c_int, c_long, ogg_int64_t] + + def ogg_stream_iovecin(os, iov, count, e_o_s, granulepos): + return libogg.ogg_stream_iovecin(os, iov, count, e_o_s, granulepos) + except: + pass + + libogg.ogg_stream_pageout.restype = c_int + libogg.ogg_stream_pageout.argtypes = [os_p, og_p] + + def ogg_stream_pageout(os, og): + return libogg.ogg_stream_pageout(os, og) + + try: + libogg.ogg_stream_pageout_fill.restype = c_int + libogg.ogg_stream_pageout_fill.argtypes = [os_p, og_p, c_int] + def ogg_stream_pageout_fill(os, og, nfill): + return libogg.ogg_stream_pageout_fill(os, og, nfill) + except: + pass + + libogg.ogg_stream_flush.restype = c_int + libogg.ogg_stream_flush.argtypes = [os_p, og_p] + + def ogg_stream_flush(os, og): + return libogg.ogg_stream_flush(os, og) + + try: + libogg.ogg_stream_flush_fill.restype = c_int + libogg.ogg_stream_flush_fill.argtypes = [os_p, og_p, c_int] + def ogg_stream_flush_fill(os, og, nfill): + return libogg.ogg_stream_flush_fill(os, og, nfill) + except: + pass + + + + libogg.ogg_sync_init.restype = c_int + libogg.ogg_sync_init.argtypes = [oy_p] + + def ogg_sync_init(oy): + return libogg.ogg_sync_init(oy) + + libogg.ogg_sync_clear.restype = c_int + libogg.ogg_sync_clear.argtypes = [oy_p] + + def ogg_sync_clear(oy): + return libogg.ogg_sync_clear(oy) + + libogg.ogg_sync_reset.restype = c_int + libogg.ogg_sync_reset.argtypes = [oy_p] + + def ogg_sync_reset(oy): + return libogg.ogg_sync_reset(oy) + + libogg.ogg_sync_destroy.restype = c_int + libogg.ogg_sync_destroy.argtypes = [oy_p] + + def ogg_sync_destroy(oy): + return libogg.ogg_sync_destroy(oy) + + try: + libogg.ogg_sync_check.restype = c_int + libogg.ogg_sync_check.argtypes = [oy_p] + def ogg_sync_check(oy): + return libogg.ogg_sync_check(oy) + except: + pass + + + + libogg.ogg_sync_buffer.restype = c_char_p + libogg.ogg_sync_buffer.argtypes = [oy_p, c_long] + + def ogg_sync_buffer(oy, size): + return libogg.ogg_sync_buffer(oy, size) + + libogg.ogg_sync_wrote.restype = c_int + libogg.ogg_sync_wrote.argtypes = [oy_p, c_long] + + def ogg_sync_wrote(oy, bytes): + return libogg.ogg_sync_wrote(oy, bytes) + + libogg.ogg_sync_pageseek.restype = c_int + libogg.ogg_sync_pageseek.argtypes = [oy_p, og_p] + + def ogg_sync_pageseek(oy, og): + return libogg.ogg_sync_pageseek(oy, og) + + libogg.ogg_sync_pageout.restype = c_long + libogg.ogg_sync_pageout.argtypes = [oy_p, og_p] + + def ogg_sync_pageout(oy, og): + return libogg.ogg_sync_pageout(oy, og) + + libogg.ogg_stream_pagein.restype = c_int + libogg.ogg_stream_pagein.argtypes = [os_p, og_p] + + def ogg_stream_pagein(os, og): + return libogg.ogg_stream_pagein(oy, og) + + libogg.ogg_stream_packetout.restype = c_int + libogg.ogg_stream_packetout.argtypes = [os_p, op_p] + + def ogg_stream_packetout(os, op): + return libogg.ogg_stream_packetout(oy, op) + + libogg.ogg_stream_packetpeek.restype = c_int + libogg.ogg_stream_packetpeek.argtypes = [os_p, op_p] + + def ogg_stream_packetpeek(os, op): + return libogg.ogg_stream_packetpeek(os, op) + + + + libogg.ogg_stream_init.restype = c_int + libogg.ogg_stream_init.argtypes = [os_p, c_int] + + def ogg_stream_init(os, serialno): + return libogg.ogg_stream_init(os, serialno) + + libogg.ogg_stream_clear.restype = c_int + libogg.ogg_stream_clear.argtypes = [os_p] + + def ogg_stream_clear(os): + return libogg.ogg_stream_clear(os) + + libogg.ogg_stream_reset.restype = c_int + libogg.ogg_stream_reset.argtypes = [os_p] + + def ogg_stream_reset(os): + return libogg.ogg_stream_reset(os) + + libogg.ogg_stream_reset_serialno.restype = c_int + libogg.ogg_stream_reset_serialno.argtypes = [os_p, c_int] + + def ogg_stream_reset_serialno(os, serialno): + return libogg.ogg_stream_reset_serialno(os, serialno) + + libogg.ogg_stream_destroy.restype = c_int + libogg.ogg_stream_destroy.argtypes = [os_p] + + def ogg_stream_destroy(os): + return libogg.ogg_stream_destroy(os) + + try: + libogg.ogg_stream_check.restype = c_int + libogg.ogg_stream_check.argtypes = [os_p] + def ogg_stream_check(os): + return libogg.ogg_stream_check(os) + except: + pass + + libogg.ogg_stream_eos.restype = c_int + libogg.ogg_stream_eos.argtypes = [os_p] + + def ogg_stream_eos(os): + return libogg.ogg_stream_eos(os) + + + + libogg.ogg_page_checksum_set.restype = None + libogg.ogg_page_checksum_set.argtypes = [og_p] + + def ogg_page_checksum_set(og): + libogg.ogg_page_checksum_set(og) + + + + libogg.ogg_page_version.restype = c_int + libogg.ogg_page_version.argtypes = [og_p] + + def ogg_page_version(og): + return libogg.ogg_page_version(og) + + libogg.ogg_page_continued.restype = c_int + libogg.ogg_page_continued.argtypes = [og_p] + + def ogg_page_continued(og): + return libogg.ogg_page_continued(og) + + libogg.ogg_page_bos.restype = c_int + libogg.ogg_page_bos.argtypes = [og_p] + + def ogg_page_bos(og): + return libogg.ogg_page_bos(og) + + libogg.ogg_page_eos.restype = c_int + libogg.ogg_page_eos.argtypes = [og_p] + + def ogg_page_eos(og): + return libogg.ogg_page_eos(og) + + libogg.ogg_page_granulepos.restype = ogg_int64_t + libogg.ogg_page_granulepos.argtypes = [og_p] + + def ogg_page_granulepos(og): + return libogg.ogg_page_granulepos(og) + + libogg.ogg_page_serialno.restype = c_int + libogg.ogg_page_serialno.argtypes = [og_p] + + def ogg_page_serialno(og): + return libogg.ogg_page_serialno(og) + + libogg.ogg_page_pageno.restype = c_long + libogg.ogg_page_pageno.argtypes = [og_p] + + def ogg_page_pageno(og): + return libogg.ogg_page_pageno(og) + + libogg.ogg_page_packets.restype = c_int + libogg.ogg_page_packets.argtypes = [og_p] + + def ogg_page_packets(og): + return libogg.ogg_page_packets(og) + + + + libogg.ogg_packet_clear.restype = None + libogg.ogg_packet_clear.argtypes = [op_p] + + def ogg_packet_clear(op): + libogg.ogg_packet_clear(op) diff --git a/LXST/Codecs/libs/pyogg/ogg_opus_writer.py b/LXST/Codecs/libs/pyogg/ogg_opus_writer.py new file mode 100644 index 0000000..547d0f5 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/ogg_opus_writer.py @@ -0,0 +1,421 @@ +import builtins +import copy +import ctypes +import random +import struct +from typing import ( + Optional, + Union, + BinaryIO +) + +from . import ogg +from . import opus +from .opus_buffered_encoder import OpusBufferedEncoder +#from .opus_encoder import OpusEncoder +from .pyogg_error import PyOggError + +class OggOpusWriter(): + """Encodes PCM data into an OggOpus file.""" + + def __init__(self, + f: Union[BinaryIO, str], + encoder: OpusBufferedEncoder, + custom_pre_skip: Optional[int] = None) -> None: + """Construct an OggOpusWriter. + + f may be either a string giving the path to the file, or + an already-opened file handle. + + If f is an already-opened file handle, then it is the + user's responsibility to close the file when they are + finished with it. The file should be opened for writing + in binary (not text) mode. + + The encoder should be a + OpusBufferedEncoder and should be fully configured before the + first call to the `write()` method. + + The Opus encoder requires an amount of "warm up" and when + stored in an Ogg container that warm up can be skipped. When + `custom_pre_skip` is None, the required amount of warm up + silence is automatically calculated and inserted. If a custom + (non-silent) pre-skip is desired, then `custom_pre_skip` + should be specified as the number of samples (per channel). + It is then the user's responsibility to pass the non-silent + pre-skip samples to `encode()`. + + """ + # Store the Opus encoder + self._encoder = encoder + + # Store the custom pre skip + self._custom_pre_skip = custom_pre_skip + + # Create a new stream state with a random serial number + self._stream_state = self._create_stream_state() + + # Create a packet (reused for each pass) + self._ogg_packet = ogg.ogg_packet() + self._packet_valid = False + + # Create a page (reused for each pass) + self._ogg_page = ogg.ogg_page() + + # Counter for the number of packets written into Ogg stream + self._count_packets = 0 + + # Counter for the number of samples encoded into Opus + # packets + self._count_samples = 0 + + # Flag to indicate if the headers have been written + self._headers_written = False + + # Flag to indicate that the stream has been finished (the + # EOS bit was set in a final packet) + self._finished = False + + # Reference to the current encoded packet (written only + # when we know if it the last) + self._current_encoded_packet: Optional[bytes] = None + + # Open file if required. Given this may raise an exception, + # it should be the last step of initialisation. + self._i_opened_the_file = False + if isinstance(f, str): + self._file = builtins.open(f, 'wb') + self._i_opened_the_file = True + else: + # Assume it's already opened file + self._file = f + + def __del__(self) -> None: + if not self._finished: + self.close() + + # + # User visible methods + # + + def write(self, pcm: memoryview) -> None: + """Encode the PCM and write out the Ogg Opus stream. + + Encoders the PCM using the provided encoder. + + """ + # Check that the stream hasn't already been finished + if self._finished: + raise PyOggError( + "Stream has already ended. Perhaps close() was "+ + "called too early?") + + # If we haven't already written out the headers, do so + # now. Then, write a frame of silence to warm up the + # encoder. + if not self._headers_written: + pre_skip = self._write_headers(self._custom_pre_skip) + if self._custom_pre_skip is None: + self._write_silence(pre_skip) + + # Call the internal method to encode the bytes + self._write_to_oggopus(pcm) + + + def _write_to_oggopus(self, pcm: memoryview, flush: bool = False) -> None: + assert self._encoder is not None + + def handle_encoded_packet(encoded_packet: memoryview, + samples: int, + end_of_stream: bool) -> None: + # Cast memoryview to ctypes Array + Buffer = ctypes.c_ubyte * len(encoded_packet) + encoded_packet_ctypes = Buffer.from_buffer(encoded_packet) + + # Obtain a pointer to the encoded packet + encoded_packet_ptr = ctypes.cast( + encoded_packet_ctypes, + ctypes.POINTER(ctypes.c_ubyte) + ) + + # Increase the count of the number of samples written + self._count_samples += samples + + # Place data into the packet + self._ogg_packet.packet = encoded_packet_ptr + self._ogg_packet.bytes = len(encoded_packet) + self._ogg_packet.b_o_s = 0 + self._ogg_packet.e_o_s = end_of_stream + self._ogg_packet.granulepos = self._count_samples + self._ogg_packet.packetno = self._count_packets + + # Increase the counter of the number of packets + # in the stream + self._count_packets += 1 + + # Write the packet into the stream + self._write_packet() + + + # Encode the PCM data into an Opus packet + self._encoder.buffered_encode( + pcm, + flush=flush, + callback=handle_encoded_packet + ) + + def close(self) -> None: + # Check we haven't already closed this stream + if self._finished: + # We're attempting to close an already closed stream, + # do nothing more. + return + + # Flush the underlying buffered encoder + self._write_to_oggopus(memoryview(bytearray(b"")), flush=True) + + # The current packet must be the end of the stream, update + # the packet's details + self._ogg_packet.e_o_s = 1 + + # Write the packet to the stream + if self._packet_valid: + self._write_packet() + + # Flush the stream of any unwritten pages + self._flush() + + # Mark the stream as finished + self._finished = True + + # Close the file if we opened it + if self._i_opened_the_file: + self._file.close() + self._i_opened_the_file = False + + # Clean up the Ogg-related memory + ogg.ogg_stream_clear(self._stream_state) + + # Clean up the reference to the encoded packet (as it must + # now have been written) + del self._current_encoded_packet + + # + # Internal methods + # + + def _create_random_serial_no(self) -> ctypes.c_int: + sizeof_c_int = ctypes.sizeof(ctypes.c_int) + min_int = -2**(sizeof_c_int*8-1) + max_int = 2**(sizeof_c_int*8-1)-1 + serial_no = ctypes.c_int(random.randint(min_int, max_int)) + + return serial_no + + def _create_stream_state(self) -> ogg.ogg_stream_state: + # Create a random serial number + serial_no = self._create_random_serial_no() + + # Create an ogg_stream_state + ogg_stream_state = ogg.ogg_stream_state() + + # Initialise the stream state + ogg.ogg_stream_init( + ctypes.pointer(ogg_stream_state), + serial_no + ) + + return ogg_stream_state + + def _make_identification_header(self, pre_skip: int, input_sampling_rate: int = 0) -> bytes: + """Make the OggOpus identification header. + + An input_sampling rate may be set to zero to mean 'unspecified'. + + Only channel mapping family 0 is currently supported. + This allows mono and stereo signals. + + See https://tools.ietf.org/html/rfc7845#page-12 for more + details. + + """ + signature = b"OpusHead" + version = 1 + output_channels = self._encoder._channels + output_gain = 0 + channel_mapping_family = 0 + data = struct.pack( + " int: + """ Returns pre-skip. """ + if custom_pre_skip is not None: + # Use the user-specified amount of pre-skip + pre_skip = custom_pre_skip + else: + # Obtain the algorithmic delay of the Opus encoder. See + # https://tools.ietf.org/html/rfc7845#page-27 + delay_samples = self._encoder.get_algorithmic_delay() + + # Extra samples are recommended. See + # https://tools.ietf.org/html/rfc7845#page-27 + extra_samples = 120 + + # We will just fill a whole frame with silence. Calculate + # the minimum frame length, which we'll use as the + # pre-skip. + frame_durations = [2.5, 5, 10, 20, 40, 60] # milliseconds + frame_lengths = [ + x * self._encoder._samples_per_second // 1000 + for x in frame_durations + ] + for frame_length in frame_lengths: + if frame_length > delay_samples + extra_samples: + pre_skip = frame_length + break + + # Create the identification header + id_header = self._make_identification_header( + pre_skip = pre_skip + ) + + # Specify the packet containing the identification header + self._ogg_packet.packet = ctypes.cast(id_header, ogg.c_uchar_p) # type: ignore + self._ogg_packet.bytes = len(id_header) + self._ogg_packet.b_o_s = 1 + self._ogg_packet.e_o_s = 0 + self._ogg_packet.granulepos = 0 + self._ogg_packet.packetno = self._count_packets + self._count_packets += 1 + + # Write the identification header + result = ogg.ogg_stream_packetin( + self._stream_state, + self._ogg_packet + ) + + if result != 0: + raise PyOggError( + "Failed to write Opus identification header" + ) + + return pre_skip + + def _make_comment_header(self): + """Make the OggOpus comment header. + + See https://tools.ietf.org/html/rfc7845#page-22 for more + details. + + """ + signature = b"OpusTags" + vendor_string = b"ENCODER=PyOgg" + vendor_string_length = struct.pack(" None: + super().__init__() + + self._frame_size_ms: Optional[float] = None + self._frame_size_bytes: Optional[int] = None + + # Buffer contains the bytes required for the next + # frame. + self._buffer: Optional[ctypes.Array] = None + + # Location of the next free byte in the buffer + self._buffer_index = 0 + + + def set_frame_size(self, frame_size: float) -> None: + """ Set the desired frame duration (in milliseconds). + + Valid options are 2.5, 5, 10, 20, 40, or 60ms. + + """ + + # Ensure the frame size is valid. Compare frame size in + # units of 0.1ms to avoid floating point comparison + if int(frame_size*10) not in [25, 50, 100, 200, 400, 600]: + raise PyOggError( + "Frame size ({:f}) not one of ".format(frame_size)+ + "the acceptable values" + ) + + self._frame_size_ms = frame_size + + self._calc_frame_size() + + + def set_sampling_frequency(self, samples_per_second: int) -> None: + super().set_sampling_frequency(samples_per_second) + self._calc_frame_size() + + + def buffered_encode(self, + pcm_bytes: memoryview, + flush: bool = False, + callback: Callable[[memoryview,int,bool],None] = None + ) -> List[Tuple[memoryview, int, bool]]: + """Gets encoded packets and their number of samples. + + This method returns a list, where each item in the list is + a tuple. The first item in the tuple is an Opus-encoded + frame stored as a bytes-object. The second item in the + tuple is the number of samples encoded (excluding + silence). + + If `callback` is supplied then this method will instead + return an empty list but call the callback for every + Opus-encoded frame that would have been returned as a + list. This option has the desireable property of + eliminating the copying of the encoded packets, which is + required in order to form a list. The callback should + take two arguments, the encoded frame (a Python bytes + object) and the number of samples encoded per channel (an + int). The user must either process or copy the data as + the data may be overwritten once the callback terminates. + + """ + # If there's no work to do return immediately + if len(pcm_bytes) == 0 and flush == False: + return [] # no work to do + + # Sanity checks + if self._frame_size_ms is None: + raise PyOggError("Frame size must be set before encoding") + assert self._frame_size_bytes is not None + assert self._channels is not None + assert self._buffer is not None + assert self._buffer_index is not None + + # Local variable initialisation + results = [] + pcm_index = 0 + pcm_len = len(pcm_bytes) + + # 'Cast' memoryview of PCM to ctypes Array + Buffer = ctypes.c_ubyte * len(pcm_bytes) + try: + pcm_ctypes = Buffer.from_buffer(pcm_bytes) + except TypeError: + warnings.warn( + "Because PCM was read-only, an extra memory "+ + "copy was required; consider storing PCM in "+ + "writable memory (for example, bytearray "+ + "rather than bytes)." + ) + pcm_ctypes = Buffer.from_buffer(pcm_bytes) + + # Either store the encoded packet to return at the end of the + # method or immediately call the callback with the encoded + # packet. + def store_or_callback(encoded_packet: memoryview, + samples: int, + end_of_stream: bool = False) -> None: + if callback is None: + # Store the result + results.append(( + encoded_packet, + samples, + end_of_stream + )) + else: + # Call the callback + callback( + encoded_packet, + samples, + end_of_stream + ) + + # Fill the remainder of the buffer with silence and encode it. + # The associated number of samples are only that of actual + # data, not the added silence. + def flush_buffer() -> None: + # Sanity checks to satisfy mypy + assert self._buffer_index is not None + assert self._channels is not None + assert self._buffer is not None + + # If the buffer is already empty, we have no work to do + if self._buffer_index == 0: + return + + # Store the number of samples currently in the buffer + samples = ( + self._buffer_index + // self._channels + // ctypes.sizeof(opus.opus_int16) + ) + + # Fill the buffer with silence + ctypes.memset( + # destination + ctypes.byref(self._buffer, self._buffer_index), + # value + 0, + # count + len(self._buffer) - self._buffer_index + ) + + # Encode the PCM + # As at 2020-11-05, mypy is unaware that ctype Arrays + # support the buffer protocol. + encoded_packet = self.encode(memoryview(self._buffer)) # type: ignore + + # Either store the encoded packet or call the + # callback + store_or_callback(encoded_packet, samples, True) + + + # Copy the data remaining from the provided PCM into the + # buffer. Flush if required. + def copy_insufficient_data() -> None: + # Sanity checks to satisfy mypy + assert self._buffer is not None + + # Calculate remaining data + remaining_data = len(pcm_bytes) - pcm_index + + # Copy the data into the buffer. + ctypes.memmove( + # destination + ctypes.byref(self._buffer, self._buffer_index), + # source + ctypes.byref(pcm_ctypes, pcm_index), + # count + remaining_data + ) + + self._buffer_index += remaining_data + + # If we've been asked to flush the buffer then do so + if flush: + flush_buffer() + + # Loop through the provided PCM and the current buffer, + # encoding as we have full packets. + while True: + # There are two possibilities at this point: either we + # have previously unencoded data still in the buffer or we + # do not + if self._buffer_index == 0: + # We do not have unencoded data + + # We are free to progress through the PCM that has + # been provided encoding frames without copying any + # bytes. Once there is insufficient data remaining + # for a complete frame, that data should be copied + # into the buffer and we have finished. + if pcm_len - pcm_index > self._frame_size_bytes: + # We have enough data remaining in the provided + # PCM to encode more than an entire frame without + # copying any data. Unfortunately, splicing a + # ctypes array copies the array. To avoid the + # copy we use memoryview see + # https://mattgwwalker.wordpress.com/2020/12/12/python-ctypes-slicing/ + frame_data = memoryview(pcm_bytes)[ + pcm_index:pcm_index+self._frame_size_bytes + ] + + # Update the PCM index + pcm_index += self._frame_size_bytes + + # Store number of samples (per channel) of actual + # data + samples = ( + len(frame_data) + // self._channels + // ctypes.sizeof(opus.opus_int16) + ) + + # Encode the PCM + encoded_packet = super().encode(frame_data) + + # Either store the encoded packet or call the + # callback + store_or_callback(encoded_packet, samples) + + else: + # We do not have enough data to fill a frame while + # still having data left over. Copy the data into + # the buffer. + copy_insufficient_data() + return results + + else: + # We have unencoded data. + + # Copy the provided PCM into the buffer (up until the + # buffer is full). If we can fill it, then we can + # encode the filled buffer and continue. If we can't + # fill it then we've finished. + data_required = len(self._buffer) - self._buffer_index + if pcm_len > data_required: + # We have sufficient data to fill the buffer and + # have data left over. Copy data into the buffer. + assert pcm_index == 0 + remaining = len(self._buffer) - self._buffer_index + ctypes.memmove( + # destination + ctypes.byref(self._buffer, self._buffer_index), + # source + pcm_ctypes, + # count + remaining + ) + pcm_index += remaining + self._buffer_index += remaining + assert self._buffer_index == len(self._buffer) + + # Encode the PCM + encoded_packet = super().encode( + # Memoryviews of ctypes do work, even though + # mypy complains. + memoryview(self._buffer) # type: ignore + ) + + # Store number of samples (per channel) of actual + # data + samples = ( + self._buffer_index + // self._channels + // ctypes.sizeof(opus.opus_int16) + ) + + # We've now processed the buffer + self._buffer_index = 0 + + # Either store the encoded packet or call the + # callback + store_or_callback(encoded_packet, samples) + else: + # We have insufficient data to fill the buffer + # while still having data left over. Copy the + # data into the buffer. + copy_insufficient_data() + return results + + + def _calc_frame_size(self): + """Calculates the number of bytes in a frame. + + If the frame size (in milliseconds) and the number of + samples per seconds have already been specified, then the + frame size in bytes is set. Otherwise, this method does + nothing. + + The frame size is measured in bytes required to store the + sample. + + """ + if (self._frame_size_ms is None + or self._samples_per_second is None): + return + + self._frame_size_bytes = ( + self._frame_size_ms + * self._samples_per_second + // 1000 + * ctypes.sizeof(opus.opus_int16) + * self._channels + ) + + # Allocate space for the buffer + Buffer = ctypes.c_ubyte * self._frame_size_bytes + self._buffer = Buffer() + + + def _get_next_frame(self, add_silence=False): + """Gets the next Opus-encoded frame. + + Returns a tuple where the first item is the Opus-encoded + frame and the second item is the number of encoded samples + (per channel). + + Returns None if insufficient data is available. + + """ + next_frame = bytes() + samples = 0 + + # Ensure frame size has been specified + if self._frame_size_bytes is None: + raise PyOggError( + "Desired frame size hasn't been set. Perhaps "+ + "encode() was called before set_frame_size() "+ + "and set_sampling_frequency()?" + ) + + # Check if there's insufficient data in the buffer to fill + # a frame. + if self._frame_size_bytes > self._buffer_size: + if len(self._buffer) == 0: + # No data at all in buffer + return None + if add_silence: + # Get all remaining data + while len(self._buffer) != 0: + next_frame += self._buffer.popleft() + self._buffer_size = 0 + # Store number of samples (per channel) of actual + # data + samples = ( + len(next_frame) + // self._channels + // ctypes.sizeof(opus.opus_int16) + ) + # Fill remainder of frame with silence + bytes_remaining = self._frame_size_bytes - len(next_frame) + next_frame += b'\x00' * bytes_remaining + return (next_frame, samples) + else: + # Insufficient data to fill a frame and we're not + # adding silence + return None + + bytes_remaining = self._frame_size_bytes + while bytes_remaining > 0: + if len(self._buffer[0]) <= bytes_remaining: + # Take the whole first item + buffer_ = self._buffer.popleft() + next_frame += buffer_ + bytes_remaining -= len(buffer_) + self._buffer_size -= len(buffer_) + else: + # Take only part of the buffer + + # TODO: This could be more efficiently + # implemented. Rather than appending back the + # remaining data, we could just update an index + # saying where we were up to in regards to the + # first entry of the buffer. + buffer_ = self._buffer.popleft() + next_frame += buffer_[:bytes_remaining] + self._buffer_size -= bytes_remaining + # And put the unused part back into the buffer + self._buffer.appendleft(buffer_[bytes_remaining:]) + bytes_remaining = 0 + + # Calculate number of samples (per channel) + samples = ( + len(next_frame) + // self._channels + // ctypes.sizeof(opus.opus_int16) + ) + + return (next_frame, samples) diff --git a/LXST/Codecs/libs/pyogg/opus_decoder.py b/LXST/Codecs/libs/pyogg/opus_decoder.py new file mode 100644 index 0000000..8a1f4dd --- /dev/null +++ b/LXST/Codecs/libs/pyogg/opus_decoder.py @@ -0,0 +1,273 @@ +import ctypes + +from . import opus +from .pyogg_error import PyOggError + +class OpusDecoder: + def __init__(self): + self._decoder = None + self._channels = None + self._samples_per_second = None + self._pcm_buffer = None + self._pcm_buffer_ptr = None + self._pcm_buffer_size_int = None + + # TODO: Check if there is clean up that we need to do when + # closing a decoder. + + # + # User visible methods + # + + def set_channels(self, n): + + """Set the number of channels. + + n must be either 1 or 2. + + The decoder is capable of filling in either mono or + interleaved stereo pcm buffers. + + """ + if self._decoder is None: + if n < 0 or n > 2: + raise PyOggError( + "Invalid number of channels in call to "+ + "set_channels()" + ) + self._channels = n + else: + raise PyOggError( + "Cannot change the number of channels after "+ + "the decoder was created. Perhaps "+ + "set_channels() was called after decode()?" + ) + self._create_pcm_buffer() + + def set_sampling_frequency(self, samples_per_second): + """Set the number of samples (per channel) per second. + + samples_per_second must be one of 8000, 12000, 16000, + 24000, or 48000. + + Internally Opus stores data at 48000 Hz, so that should be + the default value for Fs. However, the decoder can + efficiently decode to buffers at 8, 12, 16, and 24 kHz so + if for some reason the caller cannot use data at the full + sample rate, or knows the compressed data doesn't use the + full frequency range, it can request decoding at a reduced + rate. + + """ + if self._decoder is None: + if samples_per_second in [8000, 12000, 16000, 24000, 48000]: + self._samples_per_second = samples_per_second + else: + raise PyOggError( + "Specified sampling frequency "+ + "({:d}) ".format(samples_per_second)+ + "was not one of the accepted values" + ) + else: + raise PyOggError( + "Cannot change the sampling frequency after "+ + "the decoder was created. Perhaps "+ + "set_sampling_frequency() was called after decode()?" + ) + self._create_pcm_buffer() + + def decode(self, encoded_bytes: memoryview): + """Decodes an Opus-encoded packet into PCM. + + """ + # If we haven't already created a decoder, do so now + if self._decoder is None: + self._decoder = self._create_decoder() + + # Create a ctypes array from the memoryview (without copying + # data) + Buffer = ctypes.c_char * len(encoded_bytes) + encoded_bytes_ctypes = Buffer.from_buffer(encoded_bytes) + + # Create pointer to encoded bytes + encoded_bytes_ptr = ctypes.cast( + encoded_bytes_ctypes, + ctypes.POINTER(ctypes.c_ubyte) + ) + + # Store length of encoded bytes into int32 + len_int32 = opus.opus_int32( + len(encoded_bytes) + ) + + # Check that we have a PCM buffer + if self._pcm_buffer is None: + raise PyOggError("PCM buffer was not configured.") + + # Decode the encoded frame + result = opus.opus_decode( + self._decoder, + encoded_bytes_ptr, + len_int32, + self._pcm_buffer_ptr, + self._pcm_buffer_size_int, + 0 # TODO: What's Forward Error Correction about? + ) + + # Check for any errors + if result < 0: + raise PyOggError( + "An error occurred while decoding an Opus-encoded "+ + "packet: "+ + opus.opus_strerror(result).decode("utf") + ) + + # Extract just the valid data as bytes + end_valid_data = ( + result + * ctypes.sizeof(opus.opus_int16) + * self._channels + ) + + # Create memoryview of PCM buffer to avoid copying data during slice. + mv = memoryview(self._pcm_buffer) + + # Cast memoryview to chars + mv = mv.cast('c') + + # Slice memoryview to extract only valid data + mv = mv[:end_valid_data] + + return mv + + + def decode_missing_packet(self, frame_duration): + """ Obtain PCM data despite missing a frame. + + frame_duration is in milliseconds. + + """ + + # Consider frame duration in units of 0.1ms in order to + # avoid floating-point comparisons. + if int(frame_duration*10) not in [25, 50, 100, 200, 400, 600]: + raise PyOggError( + "Frame duration ({:f}) is not one of the accepted values".format(frame_duration) + ) + + # Calculate frame size + frame_size = int( + frame_duration + * self._samples_per_second + // 1000 + ) + + # Store frame size as int + frame_size_int = ctypes.c_int(frame_size) + + # Decode missing packet + result = opus.opus_decode( + self._decoder, + None, + 0, + self._pcm_buffer_ptr, + frame_size_int, + 0 # TODO: What is this Forward Error Correction about? + ) + + # Check for any errors + if result < 0: + raise PyOggError( + "An error occurred while decoding an Opus-encoded "+ + "packet: "+ + opus.opus_strerror(result).decode("utf") + ) + + # Extract just the valid data as bytes + end_valid_data = ( + result + * ctypes.sizeof(opus.opus_int16) + * self._channels + ) + return bytes(self._pcm_buffer)[:end_valid_data] + + # + # Internal methods + # + + def _create_pcm_buffer(self): + if (self._samples_per_second is None + or self._channels is None): + # We cannot define the buffer yet + return + + # Create buffer to hold 120ms of samples. See "opus_decode()" at + # https://opus-codec.org/docs/opus_api-1.3.1/group__opus__decoder.html + max_duration = 120 # milliseconds + max_samples = max_duration * self._samples_per_second // 1000 + PCMBuffer = opus.opus_int16 * (max_samples * self._channels) + self._pcm_buffer = PCMBuffer() + self._pcm_buffer_ptr = ( + ctypes.cast(ctypes.pointer(self._pcm_buffer), + ctypes.POINTER(opus.opus_int16)) + ) + + # Store samples per channel in an int + self._pcm_buffer_size_int = ctypes.c_int(max_samples) + + def _create_decoder(self): + # To create a decoder, we must first allocate resources for it. + # We want Python to be responsible for the memory deallocation, + # and thus Python must be responsible for the initial memory + # allocation. + + # Check that the sampling frequency has been defined + if self._samples_per_second is None: + raise PyOggError( + "The sampling frequency was not specified before "+ + "attempting to create an Opus decoder. Perhaps "+ + "decode() was called before set_sampling_frequency()?" + ) + + # The sampling frequency must be passed in as a 32-bit int + samples_per_second = opus.opus_int32(self._samples_per_second) + + # Check that the number of channels has been defined + if self._channels is None: + raise PyOggError( + "The number of channels were not specified before "+ + "attempting to create an Opus decoder. Perhaps "+ + "decode() was called before set_channels()?" + ) + + # The number of channels must also be passed in as a 32-bit int + channels = opus.opus_int32(self._channels) + + # Obtain the number of bytes of memory required for the decoder + size = opus.opus_decoder_get_size(channels); + + # Allocate the required memory for the decoder + memory = ctypes.create_string_buffer(size) + + # Cast the newly-allocated memory as a pointer to a decoder. We + # could also have used opus.od_p as the pointer type, but writing + # it out in full may be clearer. + decoder = ctypes.cast(memory, ctypes.POINTER(opus.OpusDecoder)) + + # Initialise the decoder + error = opus.opus_decoder_init( + decoder, + samples_per_second, + channels + ); + + # Check that there hasn't been an error when initialising the + # decoder + if error != opus.OPUS_OK: + raise PyOggError( + "An error occurred while creating the decoder: "+ + opus.opus_strerror(error).decode("utf") + ) + + # Return our newly-created decoder + return decoder diff --git a/LXST/Codecs/libs/pyogg/opus_encoder.py b/LXST/Codecs/libs/pyogg/opus_encoder.py new file mode 100644 index 0000000..1da82da --- /dev/null +++ b/LXST/Codecs/libs/pyogg/opus_encoder.py @@ -0,0 +1,358 @@ +import ctypes +from typing import Optional, Union, ByteString + +from . import opus +from .pyogg_error import PyOggError + +class OpusEncoder: + """Encodes PCM data into Opus frames.""" + def __init__(self) -> None: + self._encoder: Optional[ctypes.pointer] = None + self._channels: Optional[int] = None + self._samples_per_second: Optional[int] = None + self._application: Optional[int] = None + self._max_bytes_per_frame: Optional[opus.opus_int32] = None + self._output_buffer: Optional[ctypes.Array] = None + self._output_buffer_ptr: Optional[ctypes.pointer] = None + + # An output buffer of 4,000 bytes is recommended in + # https://opus-codec.org/docs/opus_api-1.3.1/group__opus__encoder.html + self.set_max_bytes_per_frame(4000) + + # + # User visible methods + # + + def set_channels(self, n: int) -> None: + """Set the number of channels. + + n must be either 1 or 2. + + """ + if self._encoder is None: + if n < 0 or n > 2: + raise PyOggError( + "Invalid number of channels in call to "+ + "set_channels()" + ) + self._channels = n + else: + raise PyOggError( + "Cannot change the number of channels after "+ + "the encoder was created. Perhaps "+ + "set_channels() was called after encode()?" + ) + + def set_sampling_frequency(self, samples_per_second: int) -> None: + """Set the number of samples (per channel) per second. + + This must be one of 8000, 12000, 16000, 24000, or 48000. + + Regardless of the sampling rate and number of channels + selected, the Opus encoder can switch to a lower audio + bandwidth or number of channels if the bitrate selected is + too low. This also means that it is safe to always use 48 + kHz stereo input and let the encoder optimize the + encoding. + + """ + if self._encoder is None: + if samples_per_second in [8000, 12000, 16000, 24000, 48000]: + self._samples_per_second = samples_per_second + else: + raise PyOggError( + "Specified sampling frequency "+ + "({:d}) ".format(samples_per_second)+ + "was not one of the accepted values" + ) + else: + raise PyOggError( + "Cannot change the sampling frequency after "+ + "the encoder was created. Perhaps "+ + "set_sampling_frequency() was called after encode()?" + ) + + def set_application(self, application: str) -> None: + """Set the encoding mode. + + This must be one of 'voip', 'audio', or 'restricted_lowdelay'. + + 'voip': Gives best quality at a given bitrate for voice + signals. It enhances the input signal by high-pass + filtering and emphasizing formants and + harmonics. Optionally it includes in-band forward error + correction to protect against packet loss. Use this mode + for typical VoIP applications. Because of the enhancement, + even at high bitrates the output may sound different from + the input. + + 'audio': Gives best quality at a given bitrate for most + non-voice signals like music. Use this mode for music and + mixed (music/voice) content, broadcast, and applications + requiring less than 15 ms of coding delay. + + 'restricted_lowdelay': configures low-delay mode that + disables the speech-optimized mode in exchange for + slightly reduced delay. This mode can only be set on an + newly initialized encoder because it changes the codec + delay. + """ + if self._encoder is not None: + raise PyOggError( + "Cannot change the application after "+ + "the encoder was created. Perhaps "+ + "set_application() was called after encode()?" + ) + if application == "voip": + self._application = opus.OPUS_APPLICATION_VOIP + elif application == "audio": + self._application = opus.OPUS_APPLICATION_AUDIO + elif application == "restricted_lowdelay": + self._application = opus.OPUS_APPLICATION_RESTRICTED_LOWDELAY + else: + raise PyOggError( + "The application specification '{:s}' ".format(application)+ + "wasn't one of the accepted values." + ) + + def set_max_bytes_per_frame(self, max_bytes: int) -> None: + """Set the maximum number of bytes in an encoded frame. + + Size of the output payload. This may be used to impose an + upper limit on the instant bitrate, but should not be used + as the only bitrate control. + + TODO: Use OPUS_SET_BITRATE to control the bitrate. + + """ + self._max_bytes_per_frame = opus.opus_int32(max_bytes) + OutputBuffer = ctypes.c_ubyte * max_bytes + self._output_buffer = OutputBuffer() + self._output_buffer_ptr = ( + ctypes.cast(ctypes.pointer(self._output_buffer), + ctypes.POINTER(ctypes.c_ubyte)) + ) + + + def encode(self, pcm: Union[bytes, bytearray, memoryview]) -> memoryview: + """Encodes PCM data into an Opus frame. + + `pcm` must be formatted as bytes-like, with each sample taking + two bytes (signed 16-bit integers; interleaved left, then + right channels if in stereo). + + If `pcm` is not writeable, a copy of the array will be made. + + """ + # If we haven't already created an encoder, do so now + if self._encoder is None: + self._encoder = self._create_encoder() + + # Sanity checks also satisfy mypy type checking + assert self._channels is not None + assert self._samples_per_second is not None + assert self._output_buffer is not None + + # Calculate the effective frame duration of the given PCM + # data. Calculate it in units of 0.1ms in order to avoid + # floating point comparisons. + bytes_per_sample = 2 + frame_size = ( + len(pcm) # bytes + // bytes_per_sample + // self._channels + ) + frame_duration = ( + (10*frame_size) + // (self._samples_per_second//1000) + ) + + # Check that we have a valid frame size + if int(frame_duration) not in [25, 50, 100, 200, 400, 600]: + raise PyOggError( + "The effective frame duration ({:.1f} ms) " + .format(frame_duration/10)+ + "was not one of the acceptable values." + ) + + # Create a ctypes object sharing the memory of the PCM data + PcmCtypes = ctypes.c_ubyte * len(pcm) + try: + # Attempt to share the PCM memory + + # Unfortunately, as at 2020-09-27, the type hinting for + # read-only and writeable buffer protocols was a + # work-in-progress. The following only works for writable + # cases, but the method's parameters include a read-only + # possibility (bytes), thus we ignore mypy's error. + pcm_ctypes = PcmCtypes.from_buffer(pcm) # type: ignore[arg-type] + except TypeError: + # The data must be copied if it's not writeable + pcm_ctypes = PcmCtypes.from_buffer_copy(pcm) + + # Create a pointer to the PCM data + pcm_ptr = ctypes.cast( + pcm_ctypes, + ctypes.POINTER(opus.opus_int16) + ) + + # Create an int giving the frame size per channel + frame_size_int = ctypes.c_int(frame_size) + + # Encode PCM + result = opus.opus_encode( + self._encoder, + pcm_ptr, + frame_size_int, + self._output_buffer_ptr, + self._max_bytes_per_frame + ) + + # Check for any errors + if result < 0: + raise PyOggError( + "An error occurred while encoding to Opus format: "+ + opus.opus_strerror(result).decode("utf") + ) + + # Get memoryview of buffer so that the slice operation doesn't + # copy the data. + # + # Unfortunately, as at 2020-09-27, the type hints for + # memoryview do not include ctype arrays. This is because + # there is no currently accepted manner to label a class as + # supporting the buffer protocol. However, it's clearly a + # work in progress. For more information, see: + # * https://bugs.python.org/issue27501 + # * https://github.com/python/typing/issues/593 + # * https://github.com/python/typeshed/pull/4232 + mv = memoryview(self._output_buffer) # type: ignore + + # Cast the memoryview to char + mv = mv.cast('c') + + # Slice just the valid data from the memoryview + valid_data_as_bytes = mv[:result] + + # DEBUG + # Convert memoryview back to ctypes instance + Buffer = ctypes.c_ubyte * len(valid_data_as_bytes) + buf = Buffer.from_buffer( valid_data_as_bytes ) + + # Convert PCM back to pointer and dump 4,000-byte buffer + ptr = ctypes.cast( + buf, + ctypes.POINTER(ctypes.c_ubyte) + ) + + return valid_data_as_bytes + + + def get_algorithmic_delay(self): + """Gets the total samples of delay added by the entire codec. + + This can be queried by the encoder and then the provided + number of samples can be skipped on from the start of the + decoder's output to provide time aligned input and + output. From the perspective of a decoding application the + real data begins this many samples late. + + The decoder contribution to this delay is identical for all + decoders, but the encoder portion of the delay may vary from + implementation to implementation, version to version, or even + depend on the encoder's initial configuration. Applications + needing delay compensation should call this method rather than + hard-coding a value. + + """ + # If we haven't already created an encoder, do so now + if self._encoder is None: + self._encoder = self._create_encoder() + + # Obtain the algorithmic delay of the Opus encoder. See + # https://tools.ietf.org/html/rfc7845#page-27 + delay = opus.opus_int32() + + result = opus.opus_encoder_ctl( + self._encoder, + opus.OPUS_GET_LOOKAHEAD_REQUEST, + ctypes.pointer(delay) + ) + if result != opus.OPUS_OK: + raise PyOggError( + "Failed to obtain the algorithmic delay of "+ + "the Opus encoder: "+ + opus.opus_strerror(result).decode("utf") + ) + delay_samples = delay.value + return delay_samples + + + # + # Internal methods + # + + def _create_encoder(self) -> ctypes.pointer: + # To create an encoder, we must first allocate resources for it. + # We want Python to be responsible for the memory deallocation, + # and thus Python must be responsible for the initial memory + # allocation. + + # Check that the application has been defined + if self._application is None: + raise PyOggError( + "The application was not specified before "+ + "attempting to create an Opus encoder. Perhaps "+ + "encode() was called before set_application()?" + ) + application = self._application + + # Check that the sampling frequency has been defined + if self._samples_per_second is None: + raise PyOggError( + "The sampling frequency was not specified before "+ + "attempting to create an Opus encoder. Perhaps "+ + "encode() was called before set_sampling_frequency()?" + ) + + # The frequency must be passed in as a 32-bit int + samples_per_second = opus.opus_int32(self._samples_per_second) + + # Check that the number of channels has been defined + if self._channels is None: + raise PyOggError( + "The number of channels were not specified before "+ + "attempting to create an Opus encoder. Perhaps "+ + "encode() was called before set_channels()?" + ) + channels = self._channels + + # Obtain the number of bytes of memory required for the encoder + size = opus.opus_encoder_get_size(channels); + + # Allocate the required memory for the encoder + memory = ctypes.create_string_buffer(size) + + # Cast the newly-allocated memory as a pointer to an encoder. We + # could also have used opus.oe_p as the pointer type, but writing + # it out in full may be clearer. + encoder = ctypes.cast(memory, ctypes.POINTER(opus.OpusEncoder)) + + # Initialise the encoder + error = opus.opus_encoder_init( + encoder, + samples_per_second, + channels, + application + ) + + # Check that there hasn't been an error when initialising the + # encoder + if error != opus.OPUS_OK: + raise PyOggError( + "An error occurred while creating the encoder: "+ + opus.opus_strerror(error).decode("utf") + ) + + # Return our newly-created encoder + return encoder diff --git a/LXST/Codecs/libs/pyogg/opus_file.py b/LXST/Codecs/libs/pyogg/opus_file.py new file mode 100644 index 0000000..f8519f4 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/opus_file.py @@ -0,0 +1,106 @@ +import ctypes + +from . import ogg +from . import opus +from .pyogg_error import PyOggError +from .audio_file import AudioFile + +class OpusFile(AudioFile): + def __init__(self, path: str) -> None: + # Open the file + error = ctypes.c_int() + of = opus.op_open_file( + ogg.to_char_p(path), + ctypes.pointer(error) + ) + + # Check for errors + if error.value != 0: + raise PyOggError( + ("File '{}' couldn't be opened or doesn't exist. "+ + "Error code: {}").format(path, error.value) + ) + + # Extract the number of channels in the newly opened file + #: Number of channels in audio file. + self.channels = opus.op_channel_count(of, -1) + + # Allocate sufficient memory to store the entire PCM + pcm_size = opus.op_pcm_total(of, -1) + Buf = opus.opus_int16*(pcm_size*self.channels) + buf = Buf() + + # Create a pointer to the newly allocated memory. It + # seems we can only do pointer arithmetic on void + # pointers. See + # https://mattgwwalker.wordpress.com/2020/05/30/pointer-manipulation-in-python/ + buf_ptr = ctypes.cast( + ctypes.pointer(buf), + ctypes.c_void_p + ) + assert buf_ptr.value is not None # for mypy + buf_ptr_zero = buf_ptr.value + + #: Bytes per sample + self.bytes_per_sample = ctypes.sizeof(opus.opus_int16) + + # Read through the entire file, copying the PCM into the + # buffer + samples = 0 + while True: + # Calculate remaining buffer size + remaining_buffer = ( + len(buf) # int + - (buf_ptr.value + - buf_ptr_zero) // self.bytes_per_sample + ) + + # Convert buffer pointer to the desired type + ptr = ctypes.cast( + buf_ptr, + ctypes.POINTER(opus.opus_int16) + ) + + # Read the next section of PCM + ns = opus.op_read( + of, + ptr, + remaining_buffer, + ogg.c_int_p() + ) + + # Check for errors + if ns<0: + raise PyOggError( + "Error while reading OggOpus file. "+ + "Error code: {}".format(ns) + ) + + # Increment the pointer + buf_ptr.value += ( + ns + * self.bytes_per_sample + * self.channels + ) + assert buf_ptr.value is not None # for mypy + + samples += ns + + # Check if we've finished + if ns==0: + break + + # Close the open file + opus.op_free(of) + + # Opus files are always stored at 48k samples per second + #: Number of samples per second (per channel). Always 48,000. + self.frequency = 48000 + + # Cast buffer to a one-dimensional array of chars + #: Raw PCM data from audio file. + CharBuffer = ( + ctypes.c_byte + * (self.bytes_per_sample * self.channels * pcm_size) + ) + self.buffer = CharBuffer.from_buffer(buf) diff --git a/LXST/Codecs/libs/pyogg/opus_file_stream.py b/LXST/Codecs/libs/pyogg/opus_file_stream.py new file mode 100644 index 0000000..b3e1723 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/opus_file_stream.py @@ -0,0 +1,127 @@ +import ctypes + +from . import ogg +from . import opus +from .pyogg_error import PyOggError + +class OpusFileStream: + def __init__(self, path): + """Opens an OggOpus file as a stream. + + path should be a string giving the filename of the file to + open. Unicode file names may not work correctly. + + An exception will be raised if the file cannot be opened + correctly. + + """ + error = ctypes.c_int() + + self.of = opus.op_open_file(ogg.to_char_p(path), ctypes.pointer(error)) + + if error.value != 0: + self.of = None + raise PyOggError("file couldn't be opened or doesn't exist. Error code : {}".format(error.value)) + + #: Number of channels in audio file + self.channels = opus.op_channel_count(self.of, -1) + + #: Total PCM Length + self.pcm_size = opus.op_pcm_total(self.of, -1) + + #: Number of samples per second (per channel) + self.frequency = 48000 + + # The buffer size should be (per channel) large enough to + # hold 120ms (the largest possible Opus frame) at 48kHz. + # See https://opus-codec.org/docs/opusfile_api-0.7/group__stream__decoding.html#ga963c917749335e29bb2b698c1cb20a10 + self.buffer_size = self.frequency // 1000 * 120 * self.channels + self.Buf = opus.opus_int16 * self.buffer_size + self._buf = self.Buf() + self.buffer_ptr = ctypes.cast( + ctypes.pointer(self._buf), + opus.opus_int16_p + ) + + #: Bytes per sample + self.bytes_per_sample = ctypes.sizeof(opus.opus_int16) + + def __del__(self): + if self.of is not None: + opus.op_free(self.of) + + def get_buffer(self): + """Obtains the next frame of PCM samples. + + Returns an array of signed 16-bit integers. If the file + is in stereo, the left and right channels are interleaved. + + Returns None when all data has been read. + + The array that is returned should be either processed or + copied before the next call to :meth:`~get_buffer` or + :meth:`~get_buffer_as_array` as the array's memory is reused for + each call. + + """ + # Read the next frame + samples_read = opus.op_read( + self.of, + self.buffer_ptr, + self.buffer_size, + None + ) + + # Check for errors + if samples_read < 0: + raise PyOggError( + "Failed to read OpusFileStream. Error {:d}".format(samples_read) + ) + + # Check if we've reached the end of the stream + if samples_read == 0: + return None + + # Cast the pointer to opus_int16 to an array of the + # correct size + result_ptr = ctypes.cast( + self.buffer_ptr, + ctypes.POINTER(opus.opus_int16 * (samples_read*self.channels)) + ) + + # Convert the array to Python bytes + return bytes(result_ptr.contents) + + def get_buffer_as_array(self): + """Provides the buffer as a NumPy array. + + Note that the underlying data type is 16-bit signed + integers. + + Does not copy the underlying data, so the returned array + should either be processed or copied before the next call + to :meth:`~get_buffer` or :meth:`~get_buffer_as_array`. + + """ + import numpy # type: ignore + + # Read the next samples from the stream + buf = self.get_buffer() + + # Check if we've come to the end of the stream + if buf is None: + return None + + # Convert the bytes buffer to a NumPy array + array = numpy.frombuffer( + buf, + dtype=numpy.int16 + ) + + # Reshape the array + return array.reshape( + (len(buf) + // self.bytes_per_sample + // self.channels, + self.channels) + ) diff --git a/LXST/Codecs/libs/pyogg/py.typed b/LXST/Codecs/libs/pyogg/py.typed new file mode 100644 index 0000000..d4defd9 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/py.typed @@ -0,0 +1 @@ +# Marker file for PEP 561. This package uses inline types. \ No newline at end of file diff --git a/LXST/Codecs/libs/pyogg/pyogg_error.py b/LXST/Codecs/libs/pyogg/pyogg_error.py new file mode 100644 index 0000000..35f28bf --- /dev/null +++ b/LXST/Codecs/libs/pyogg/pyogg_error.py @@ -0,0 +1,2 @@ +class PyOggError(Exception): + pass diff --git a/LXST/Codecs/libs/pyogg/vorbis.py b/LXST/Codecs/libs/pyogg/vorbis.py new file mode 100644 index 0000000..a8432ba --- /dev/null +++ b/LXST/Codecs/libs/pyogg/vorbis.py @@ -0,0 +1,855 @@ +############################################################ +# Vorbis license: # +############################################################ +""" +Copyright (c) 2002-2015 Xiph.org Foundation + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + +- Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + +- Redistributions in binary form must reproduce the above copyright +notice, this list of conditions and the following disclaimer in the +documentation and/or other materials provided with the distribution. + +- Neither the name of the Xiph.org Foundation nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION +OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +""" + +import ctypes +import ctypes.util +from traceback import print_exc as _print_exc +import os + +OV_EXCLUDE_STATIC_CALLBACKS = False + +__MINGW32__ = False + +_WIN32 = False + +from .ogg import * + +from .library_loader import ExternalLibrary, ExternalLibraryError + +__here = os.getcwd() + +libvorbis = None + +try: + names = { + "Windows": "libvorbis.dll", + "Darwin": "libvorbis.0.dylib", + "external": "vorbis" + } + libvorbis = Library.load(names, tests = [lambda lib: hasattr(lib, "vorbis_info_init")]) +except ExternalLibraryError: + pass +except: + _print_exc() + +libvorbisfile = None + +try: + names = { + "Windows": "libvorbisfile.dll", + "Darwin": "libvorbisfile.3.dylib", + "external": "vorbisfile" + } + libvorbisfile = Library.load(names, tests = [lambda lib: hasattr(lib, "ov_clear")]) +except ExternalLibraryError: + pass +except: + _print_exc() + +libvorbisenc = None + +# In some cases, libvorbis may also have the libvorbisenc functionality. +libvorbis_is_also_libvorbisenc = True + +for f in ("vorbis_encode_ctl", + "vorbis_encode_init", + "vorbis_encode_init_vbr", + "vorbis_encode_setup_init", + "vorbis_encode_setup_managed", + "vorbis_encode_setup_vbr"): + if not hasattr(libvorbis, f): + libvorbis_is_also_libvorbisenc = False + break + +if libvorbis_is_also_libvorbisenc: + libvorbisenc = libvorbis +else: + try: + names = { + "Windows": "libvorbisenc.dll", + "Darwin": "libvorbisenc.2.dylib", + "external": "vorbisenc" + } + libvorbisenc = Library.load(names, tests = [lambda lib: hasattr(lib, "vorbis_encode_init")]) + except ExternalLibraryError: + pass + except: + _print_exc() + +if libvorbis is None: + PYOGG_VORBIS_AVAIL = False +else: + PYOGG_VORBIS_AVAIL = True + +if libvorbisfile is None: + PYOGG_VORBIS_FILE_AVAIL = False +else: + PYOGG_VORBIS_FILE_AVAIL = True + +if libvorbisenc is None: + PYOGG_VORBIS_ENC_AVAIL = False +else: + PYOGG_VORBIS_ENC_AVAIL = True + +# FIXME: What's the story with the lack of checking for PYOGG_VORBIS_ENC_AVAIL? +# We just seem to assume that it's available. + +if PYOGG_OGG_AVAIL and PYOGG_VORBIS_AVAIL and PYOGG_VORBIS_FILE_AVAIL: + # Sanity check also satisfies mypy type checking + assert libogg is not None + assert libvorbis is not None + assert libvorbisfile is not None + + + # codecs + class vorbis_info(ctypes.Structure): + """ + Wrapper for: + typedef struct vorbis_info vorbis_info; + """ + _fields_ = [("version", c_int), + ("channels", c_int), + ("rate", c_long), + + ("bitrate_upper", c_long), + ("bitrate_nominal", c_long), + ("bitrate_lower", c_long), + ("bitrate_window", c_long), + ("codec_setup", c_void_p)] + + + + class vorbis_dsp_state(ctypes.Structure): + """ + Wrapper for: + typedef struct vorbis_dsp_state vorbis_dsp_state; + """ + _fields_ = [("analysisp", c_int), + ("vi", POINTER(vorbis_info)), + ("pcm", c_float_p_p), + ("pcmret", c_float_p_p), + ("pcm_storage", c_int), + ("pcm_current", c_int), + ("pcm_returned", c_int), + + ("preextrapolate", c_int), + ("eofflag", c_int), + + ("lW", c_long), + ("W", c_long), + ("nW", c_long), + ("centerW", c_long), + + ("granulepos", ogg_int64_t), + ("sequence", ogg_int64_t), + + ("glue_bits", ogg_int64_t), + ("time_bits", ogg_int64_t), + ("floor_bits", ogg_int64_t), + ("res_bits", ogg_int64_t), + + ("backend_state", c_void_p)] + + class alloc_chain(ctypes.Structure): + """ + Wrapper for: + typedef struct alloc_chain; + """ + pass + + alloc_chain._fields_ = [("ptr", c_void_p), + ("next", POINTER(alloc_chain))] + + class vorbis_block(ctypes.Structure): + """ + Wrapper for: + typedef struct vorbis_block vorbis_block; + """ + _fields_ = [("pcm", c_float_p_p), + ("opb", oggpack_buffer), + ("lW", c_long), + ("W", c_long), + ("nW", c_long), + ("pcmend", c_int), + ("mode", c_int), + + ("eofflag", c_int), + ("granulepos", ogg_int64_t), + ("sequence", ogg_int64_t), + ("vd", POINTER(vorbis_dsp_state)), + + ("localstore", c_void_p), + ("localtop", c_long), + ("localalloc", c_long), + ("totaluse", c_long), + ("reap", POINTER(alloc_chain)), + + ("glue_bits", c_long), + ("time_bits", c_long), + ("floor_bits", c_long), + ("res_bits", c_long), + + ("internal", c_void_p)] + + class vorbis_comment(ctypes.Structure): + """ + Wrapper for: + typedef struct vorbis_comment vorbis_comment; + """ + _fields_ = [("user_comments", c_char_p_p), + ("comment_lengths", c_int_p), + ("comments", c_int), + ("vendor", c_char_p)] + + + + vi_p = POINTER(vorbis_info) + vc_p = POINTER(vorbis_comment) + vd_p = POINTER(vorbis_dsp_state) + vb_p = POINTER(vorbis_block) + + libvorbis.vorbis_info_init.restype = None + libvorbis.vorbis_info_init.argtypes = [vi_p] + def vorbis_info_init(vi): + libvorbis.vorbis_info_init(vi) + + libvorbis.vorbis_info_clear.restype = None + libvorbis.vorbis_info_clear.argtypes = [vi_p] + def vorbis_info_clear(vi): + libvorbis.vorbis_info_clear(vi) + + libvorbis.vorbis_info_blocksize.restype = c_int + libvorbis.vorbis_info_blocksize.argtypes = [vi_p, c_int] + def vorbis_info_blocksize(vi, zo): + return libvorbis.vorbis_info_blocksize(vi, zo) + + libvorbis.vorbis_comment_init.restype = None + libvorbis.vorbis_comment_init.argtypes = [vc_p] + def vorbis_comment_init(vc): + libvorbis.vorbis_comment_init(vc) + + libvorbis.vorbis_comment_add.restype = None + libvorbis.vorbis_comment_add.argtypes = [vc_p, c_char_p] + def vorbis_comment_add(vc, comment): + libvorbis.vorbis_comment_add(vc, comment) + + libvorbis.vorbis_comment_add_tag.restype = None + libvorbis.vorbis_comment_add_tag.argtypes = [vc_p, c_char_p, c_char_p] + def vorbis_comment_add_tag(vc, tag, comment): + libvorbis.vorbis_comment_add_tag(vc, tag, comment) + + libvorbis.vorbis_comment_query.restype = c_char_p + libvorbis.vorbis_comment_query.argtypes = [vc_p, c_char_p, c_int] + def vorbis_comment_query(vc, tag, count): + libvorbis.vorbis_comment_query(vc, tag, count) + + libvorbis.vorbis_comment_query_count.restype = c_int + libvorbis.vorbis_comment_query_count.argtypes = [vc_p, c_char_p] + def vorbis_comment_query_count(vc, tag): + libvorbis.vorbis_comment_query_count(vc, tag) + + libvorbis.vorbis_comment_clear.restype = None + libvorbis.vorbis_comment_clear.argtypes = [vc_p] + def vorbis_comment_clear(vc): + libvorbis.vorbis_comment_clear(vc) + + + + libvorbis.vorbis_block_init.restype = c_int + libvorbis.vorbis_block_init.argtypes = [vd_p, vb_p] + def vorbis_block_init(v,vb): + return libvorbis.vorbis_block_init(v,vb) + + libvorbis.vorbis_block_clear.restype = c_int + libvorbis.vorbis_block_clear.argtypes = [vb_p] + def vorbis_block_clear(vb): + return libvorbis.vorbis_block_clear(vb) + + libvorbis.vorbis_dsp_clear.restype = None + libvorbis.vorbis_dsp_clear.argtypes = [vd_p] + def vorbis_dsp_clear(v): + return libvorbis.vorbis_dsp_clear(v) + + libvorbis.vorbis_granule_time.restype = c_double + libvorbis.vorbis_granule_time.argtypes = [vd_p, ogg_int64_t] + def vorbis_granule_time(v, granulepos): + return libvorbis.vorbis_granule_time(v, granulepos) + + + + libvorbis.vorbis_version_string.restype = c_char_p + libvorbis.vorbis_version_string.argtypes = [] + def vorbis_version_string(): + return libvorbis.vorbis_version_string() + + + + + + libvorbis.vorbis_analysis_init.restype = c_int + libvorbis.vorbis_analysis_init.argtypes = [vd_p, vi_p] + def vorbis_analysis_init(v, vi): + return libvorbis.vorbis_analysis_init(v, vi) + + libvorbis.vorbis_commentheader_out.restype = c_int + libvorbis.vorbis_commentheader_out.argtypes = [vc_p, op_p] + def vorbis_commentheader_out(vc, op): + return libvorbis.vorbis_commentheader_out(vc, op) + + libvorbis.vorbis_analysis_headerout.restype = c_int + libvorbis.vorbis_analysis_headerout.argtypes = [vd_p, vc_p, op_p, op_p, op_p] + def vorbis_analysis_headerout(v,vc, op, op_comm, op_code): + return libvorbis.vorbis_analysis_headerout(v,vc, op, op_comm, op_code) + + libvorbis.vorbis_analysis_buffer.restype = c_float_p_p + libvorbis.vorbis_analysis_buffer.argtypes = [vd_p, c_int] + def vorbis_analysis_buffer(v, vals): + return libvorbis.vorbis_analysis_buffer(v, vals) + + libvorbis.vorbis_analysis_wrote.restype = c_int + libvorbis.vorbis_analysis_wrote.argtypes = [vd_p, c_int] + def vorbis_analysis_wrote(v, vals): + return libvorbis.vorbis_analysis_wrote(v, vals) + + libvorbis.vorbis_analysis_blockout.restype = c_int + libvorbis.vorbis_analysis_blockout.argtypes = [vd_p, vb_p] + def vorbis_analysis_blockout(v, vb): + return libvorbis.vorbis_analysis_blockout(v, vb) + + libvorbis.vorbis_analysis.restype = c_int + libvorbis.vorbis_analysis.argtypes = [vb_p, op_p] + def vorbis_analysis(vb, op): + return libvorbis.vorbis_analysis(vb, op) + + + + + libvorbis.vorbis_bitrate_addblock.restype = c_int + libvorbis.vorbis_bitrate_addblock.argtypes = [vb_p] + def vorbis_bitrate_addblock(vb): + return libvorbis.vorbis_bitrate_addblock(vb) + + libvorbis.vorbis_bitrate_flushpacket.restype = c_int + libvorbis.vorbis_bitrate_flushpacket.argtypes = [vd_p, op_p] + def vorbis_bitrate_flushpacket(vd, op): + return libvorbis.vorbis_bitrate_flushpacket(vd, op) + + + + + libvorbis.vorbis_synthesis_idheader.restype = c_int + libvorbis.vorbis_synthesis_idheader.argtypes = [op_p] + def vorbis_synthesis_idheader(op): + return libvorbis.vorbis_synthesis_idheader(op) + + libvorbis.vorbis_synthesis_headerin.restype = c_int + libvorbis.vorbis_synthesis_headerin.argtypes = [vi_p, vc_p, op_p] + def vorbis_synthesis_headerin(vi, vc, op): + return libvorbis.vorbis_synthesis_headerin(vi, vc, op) + + + + + libvorbis.vorbis_synthesis_init.restype = c_int + libvorbis.vorbis_synthesis_init.argtypes = [vd_p, vi_p] + def vorbis_synthesis_init(v,vi): + return libvorbis.vorbis_synthesis_init(v,vi) + + libvorbis.vorbis_synthesis_restart.restype = c_int + libvorbis.vorbis_synthesis_restart.argtypes = [vd_p] + def vorbis_synthesis_restart(v): + return libvorbis.vorbis_synthesis_restart(v) + + libvorbis.vorbis_synthesis.restype = c_int + libvorbis.vorbis_synthesis.argtypes = [vb_p, op_p] + def vorbis_synthesis(vb, op): + return libvorbis.vorbis_synthesis(vb, op) + + libvorbis.vorbis_synthesis_trackonly.restype = c_int + libvorbis.vorbis_synthesis_trackonly.argtypes = [vb_p, op_p] + def vorbis_synthesis_trackonly(vb, op): + return libvorbis.vorbis_synthesis_trackonly(vb, op) + + libvorbis.vorbis_synthesis_blockin.restype = c_int + libvorbis.vorbis_synthesis_blockin.argtypes = [vd_p, vb_p] + def vorbis_synthesis_blockin(v, vb): + return libvorbis.vorbis_synthesis_blockin(v, vb) + + libvorbis.vorbis_synthesis_pcmout.restype = c_int + libvorbis.vorbis_synthesis_pcmout.argtypes = [vd_p, c_float_p_p_p] + def vorbis_synthesis_pcmout(v, pcm): + return libvorbis.vorbis_synthesis_pcmout(v, pcm) + + libvorbis.vorbis_synthesis_lapout.restype = c_int + libvorbis.vorbis_synthesis_lapout.argtypes = [vd_p, c_float_p_p_p] + def vorbis_synthesis_lapout(v, pcm): + return libvorbis.vorbis_synthesis_lapout(v, pcm) + + libvorbis.vorbis_synthesis_read.restype = c_int + libvorbis.vorbis_synthesis_read.argtypes = [vd_p, c_int] + def vorbis_synthesis_read(v, samples): + return libvorbis.vorbis_synthesis_read(v, samples) + + libvorbis.vorbis_packet_blocksize.restype = c_long + libvorbis.vorbis_packet_blocksize.argtypes = [vi_p, op_p] + def vorbis_packet_blocksize(vi, op): + return libvorbis.vorbis_packet_blocksize(vi, op) + + + + libvorbis.vorbis_synthesis_halfrate.restype = c_int + libvorbis.vorbis_synthesis_halfrate.argtypes = [vi_p, c_int] + def vorbis_synthesis_halfrate(v, flag): + return libvorbis.vorbis_synthesis_halfrate(v, flag) + + libvorbis.vorbis_synthesis_halfrate_p.restype = c_int + libvorbis.vorbis_synthesis_halfrate_p.argtypes = [vi_p] + def vorbis_synthesis_halfrate_p(vi): + return libvorbis.vorbis_synthesis_halfrate_p(vi) + + OV_FALSE = -1 + OV_EOF = -2 + OV_HOLE = -3 + + OV_EREAD = -128 + OV_EFAULT = -129 + OV_EIMPL =-130 + OV_EINVAL =-131 + OV_ENOTVORBIS =-132 + OV_EBADHEADER =-133 + OV_EVERSION =-134 + OV_ENOTAUDIO =-135 + OV_EBADPACKET =-136 + OV_EBADLINK =-137 + OV_ENOSEEK =-138 + # end of codecs + + # vorbisfile + read_func = ctypes.CFUNCTYPE(c_size_t, + c_void_p, + c_size_t, + c_size_t, + c_void_p) + + seek_func = ctypes.CFUNCTYPE(c_int, + c_void_p, + ogg_int64_t, + c_int) + + close_func = ctypes.CFUNCTYPE(c_int, + c_void_p) + + tell_func = ctypes.CFUNCTYPE(c_long, + c_void_p) + + class ov_callbacks(ctypes.Structure): + """ + Wrapper for: + typedef struct ov_callbacks; + """ + + _fields_ = [("read_func", read_func), + ("seek_func", seek_func), + ("close_func", close_func), + ("tell_func", tell_func)] + + NOTOPEN = 0 + PARTOPEN = 1 + OPENED = 2 + STREAMSET = 3 + INITSET = 4 + + class OggVorbis_File(ctypes.Structure): + """ + Wrapper for: + typedef struct OggVorbis_File OggVorbis_File; + """ + + _fields_ = [("datasource", c_void_p), + ("seekable", c_int), + ("offset", ogg_int64_t), + ("end", ogg_int64_t), + ("oy", ogg_sync_state), + + ("links", c_int), + ("offsets", ogg_int64_t_p), + ("dataoffsets", ogg_int64_t_p), + ("serialnos", c_long_p), + ("pcmlengths", ogg_int64_t_p), + ("vi", vi_p), + ("vc", vc_p), + + ("pcm_offset", ogg_int64_t), + ("ready_state", c_int), + ("current_serialno", c_long), + ("current_link", c_int), + + ("bittrack", c_double), + ("samptrack", c_double), + + ("os", ogg_stream_state), + + ("vd", vorbis_dsp_state), + ("vb", vorbis_block), + + ("callbacks", ov_callbacks)] + vf_p = POINTER(OggVorbis_File) + + libvorbisfile.ov_clear.restype = c_int + libvorbisfile.ov_clear.argtypes = [vf_p] + + def ov_clear(vf): + return libvorbisfile.ov_clear(vf) + + libvorbisfile.ov_fopen.restype = c_int + libvorbisfile.ov_fopen.argtypes = [c_char_p, vf_p] + + def ov_fopen(path, vf): + return libvorbisfile.ov_fopen(to_char_p(path), vf) + + libvorbisfile.ov_open_callbacks.restype = c_int + libvorbisfile.ov_open_callbacks.argtypes = [c_void_p, vf_p, c_char_p, c_long, ov_callbacks] + + def ov_open_callbacks(datasource, vf, initial, ibytes, callbacks): + return libvorbisfile.ov_open_callbacks(datasource, vf, initial, ibytes, callbacks) + + def ov_open(*args, **kw): + raise PyOggError("ov_open is not supported, please use ov_fopen instead") + + def ov_test(*args, **kw): + raise PyOggError("ov_test is not supported") + + libvorbisfile.ov_test_callbacks.restype = c_int + libvorbisfile.ov_test_callbacks.argtypes = [c_void_p, vf_p, c_char_p, c_long, ov_callbacks] + + def ov_test_callbacks(datasource, vf, initial, ibytes, callbacks): + return libvorbisfile.ov_test_callbacks(datasource, vf, initial, ibytes, callbacks) + + libvorbisfile.ov_test_open.restype = c_int + libvorbisfile.ov_test_open.argtypes = [vf_p] + + def ov_test_open(vf): + return libvorbisfile.ov_test_open(vf) + + + + + libvorbisfile.ov_bitrate.restype = c_long + libvorbisfile.ov_bitrate.argtypes = [vf_p, c_int] + + def ov_bitrate(vf, i): + return libvorbisfile.ov_bitrate(vf, i) + + libvorbisfile.ov_bitrate_instant.restype = c_long + libvorbisfile.ov_bitrate_instant.argtypes = [vf_p] + + def ov_bitrate_instant(vf): + return libvorbisfile.ov_bitrate_instant(vf) + + libvorbisfile.ov_streams.restype = c_long + libvorbisfile.ov_streams.argtypes = [vf_p] + + def ov_streams(vf): + return libvorbisfile.ov_streams(vf) + + libvorbisfile.ov_seekable.restype = c_long + libvorbisfile.ov_seekable.argtypes = [vf_p] + + def ov_seekable(vf): + return libvorbisfile.ov_seekable(vf) + + libvorbisfile.ov_serialnumber.restype = c_long + libvorbisfile.ov_serialnumber.argtypes = [vf_p, c_int] + + def ov_serialnumber(vf, i): + return libvorbisfile.ov_serialnumber(vf, i) + + + + libvorbisfile.ov_raw_total.restype = ogg_int64_t + libvorbisfile.ov_raw_total.argtypes = [vf_p, c_int] + + def ov_raw_total(vf, i): + return libvorbisfile.ov_raw_total(vf, i) + + libvorbisfile.ov_pcm_total.restype = ogg_int64_t + libvorbisfile.ov_pcm_total.argtypes = [vf_p, c_int] + + def ov_pcm_total(vf, i): + return libvorbisfile.ov_pcm_total(vf, i) + + libvorbisfile.ov_time_total.restype = c_double + libvorbisfile.ov_time_total.argtypes = [vf_p, c_int] + + def ov_time_total(vf, i): + return libvorbisfile.ov_time_total(vf, i) + + + + + libvorbisfile.ov_raw_seek.restype = c_int + libvorbisfile.ov_raw_seek.argtypes = [vf_p, ogg_int64_t] + + def ov_raw_seek(vf, pos): + return libvorbisfile.ov_raw_seek(vf, pos) + + libvorbisfile.ov_pcm_seek.restype = c_int + libvorbisfile.ov_pcm_seek.argtypes = [vf_p, ogg_int64_t] + + def ov_pcm_seek(vf, pos): + return libvorbisfile.ov_pcm_seek(vf, pos) + + libvorbisfile.ov_pcm_seek_page.restype = c_int + libvorbisfile.ov_pcm_seek_page.argtypes = [vf_p, ogg_int64_t] + + def ov_pcm_seek_page(vf, pos): + return libvorbisfile.ov_pcm_seek_page(vf, pos) + + libvorbisfile.ov_time_seek.restype = c_int + libvorbisfile.ov_time_seek.argtypes = [vf_p, c_double] + + def ov_time_seek(vf, pos): + return libvorbisfile.ov_time_seek(vf, pos) + + libvorbisfile.ov_time_seek_page.restype = c_int + libvorbisfile.ov_time_seek_page.argtypes = [vf_p, c_double] + + def ov_time_seek_page(vf, pos): + return libvorbisfile.ov_time_seek_page(vf, pos) + + + + + libvorbisfile.ov_raw_seek_lap.restype = c_int + libvorbisfile.ov_raw_seek_lap.argtypes = [vf_p, ogg_int64_t] + + def ov_raw_seek_lap(vf, pos): + return libvorbisfile.ov_raw_seek_lap(vf, pos) + + libvorbisfile.ov_pcm_seek_lap.restype = c_int + libvorbisfile.ov_pcm_seek_lap.argtypes = [vf_p, ogg_int64_t] + + def ov_pcm_seek_lap(vf, pos): + return libvorbisfile.ov_pcm_seek_lap(vf, pos) + + libvorbisfile.ov_pcm_seek_page_lap.restype = c_int + libvorbisfile.ov_pcm_seek_page_lap.argtypes = [vf_p, ogg_int64_t] + + def ov_pcm_seek_page_lap(vf, pos): + return libvorbisfile.ov_pcm_seek_page_lap(vf, pos) + + libvorbisfile.ov_time_seek_lap.restype = c_int + libvorbisfile.ov_time_seek_lap.argtypes = [vf_p, c_double] + + def ov_time_seek_lap(vf, pos): + return libvorbisfile.ov_time_seek_lap(vf, pos) + + libvorbisfile.ov_time_seek_page_lap.restype = c_int + libvorbisfile.ov_time_seek_page_lap.argtypes = [vf_p, c_double] + + def ov_time_seek_page_lap(vf, pos): + return libvorbisfile.ov_time_seek_page_lap(vf, pos) + + + + libvorbisfile.ov_raw_tell.restype = ogg_int64_t + libvorbisfile.ov_raw_tell.argtypes = [vf_p] + + def ov_raw_tell(vf): + return libvorbisfile.ov_raw_tell(vf) + + libvorbisfile.ov_pcm_tell.restype = ogg_int64_t + libvorbisfile.ov_pcm_tell.argtypes = [vf_p] + + def ov_pcm_tell(vf): + return libvorbisfile.ov_pcm_tell(vf) + + libvorbisfile.ov_time_tell.restype = c_double + libvorbisfile.ov_time_tell.argtypes = [vf_p] + + def ov_time_tell(vf): + return libvorbisfile.ov_time_tell(vf) + + + + libvorbisfile.ov_info.restype = vi_p + libvorbisfile.ov_info.argtypes = [vf_p, c_int] + + def ov_info(vf, link): + return libvorbisfile.ov_info(vf, link) + + libvorbisfile.ov_comment.restype = vc_p + libvorbisfile.ov_comment.argtypes = [vf_p, c_int] + + def ov_comment(vf, link): + return libvorbisfile.ov_comment(vf, link) + + + + libvorbisfile.ov_read_float.restype = c_long + libvorbisfile.ov_read_float.argtypes = [vf_p, c_float_p_p_p, c_int, c_int_p] + + def ov_read_float(vf, pcm_channels, samples, bitstream): + return libvorbisfile.ov_read_float(vf, pcm_channels, samples, bitstream) + + filter_ = ctypes.CFUNCTYPE(None, + c_float_p_p, + c_long, + c_long, + c_void_p) + + try: + libvorbisfile.ov_read_filter.restype = c_long + libvorbisfile.ov_read_filter.argtypes = [vf_p, c_char_p, c_int, c_int, c_int, c_int, c_int_p, filter_, c_void_p] + + def ov_read_filter(vf, buffer, length, bigendianp, word, sgned, bitstream, filter_, filter_param): + return libvorbisfile.ov_read_filter(vf, buffer, length, bigendianp, word, sgned, bitstream, filter_, filter_param) + except: + pass + + libvorbisfile.ov_read.restype = c_long + libvorbisfile.ov_read.argtypes = [vf_p, c_char_p, c_int, c_int, c_int, c_int, c_int_p] + + def ov_read(vf, buffer, length, bigendianp, word, sgned, bitstream): + return libvorbisfile.ov_read(vf, buffer, length, bigendianp, word, sgned, bitstream) + + libvorbisfile.ov_crosslap.restype = c_int + libvorbisfile.ov_crosslap.argtypes = [vf_p, vf_p] + + def ov_crosslap(vf1, cf2): + return libvorbisfile.ov_crosslap(vf1, vf2) + + + + + libvorbisfile.ov_halfrate.restype = c_int + libvorbisfile.ov_halfrate.argtypes = [vf_p, c_int] + + def ov_halfrate(vf, flag): + return libvorbisfile.ov_halfrate(vf, flag) + + libvorbisfile.ov_halfrate_p.restype = c_int + libvorbisfile.ov_halfrate_p.argtypes = [vf_p] + + def ov_halfrate_p(vf): + return libvorbisfile.ov_halfrate_p(vf) + # end of vorbisfile + + try: + # vorbisenc + + # Sanity check also satisfies mypy type checking + assert libvorbisenc is not None + + libvorbisenc.vorbis_encode_init.restype = c_int + libvorbisenc.vorbis_encode_init.argtypes = [vi_p, c_long, c_long, c_long, c_long, c_long] + + def vorbis_encode_init(vi, channels, rate, max_bitrate, nominal_bitrate, min_bitrate): + return libvorbisenc.vorbis_encode_init(vi, channels, rate, max_bitrate, nominal_bitrate, min_bitrate) + + libvorbisenc.vorbis_encode_setup_managed.restype = c_int + libvorbisenc.vorbis_encode_setup_managed.argtypes = [vi_p, c_long, c_long, c_long, c_long, c_long] + + def vorbis_encode_setup_managed(vi, channels, rate, max_bitrate, nominal_bitrate, min_bitrate): + return libvorbisenc.vorbis_encode_setup_managed(vi, channels, rate, max_bitrate, nominal_bitrate, min_bitrate) + + libvorbisenc.vorbis_encode_setup_vbr.restype = c_int + libvorbisenc.vorbis_encode_setup_vbr.argtypes = [vi_p, c_long, c_long, c_float] + + def vorbis_encode_setup_vbr(vi, channels, rate, quality): + return libvorbisenc.vorbis_encode_setup_vbr(vi, channels, rate, quality) + + libvorbisenc.vorbis_encode_init_vbr.restype = c_int + libvorbisenc.vorbis_encode_init_vbr.argtypes = [vi_p, c_long, c_long, c_float] + + def vorbis_encode_init_vbr(vi, channels, rate, quality): + return libvorbisenc.vorbis_encode_init_vbr(vi, channels, rate, quality) + + libvorbisenc.vorbis_encode_setup_init.restype = c_int + libvorbisenc.vorbis_encode_setup_init.argtypes = [vi_p] + + def vorbis_encode_setup_init(vi): + return libvorbisenc.vorbis_encode_setup_init(vi) + + libvorbisenc.vorbis_encode_ctl.restype = c_int + libvorbisenc.vorbis_encode_ctl.argtypes = [vi_p, c_int, c_void_p] + + def vorbis_encode_ctl(vi, number, arg): + return libvorbisenc.vorbis_encode_ctl(vi, number, arg) + + class ovectl_ratemanage_arg(ctypes.Structure): + _fields_ = [("management_active", c_int), + ("bitrate_hard_min", c_long), + ("bitrate_hard_max", c_long), + ("bitrate_hard_window", c_double), + ("bitrate_av_lo", c_long), + ("bitrate_av_hi", c_long), + ("bitrate_av_window", c_double), + ("bitrate_av_window_center", c_double)] + + class ovectl_ratemanage2_arg(ctypes.Structure): + _fields_ = [("management_active", c_int), + ("bitrate_limit_min_kbps", c_long), + ("bitrate_limit_max_kbps", c_long), + ("bitrate_limit_reservoir_bits", c_long), + ("bitrate_limit_reservoir_bias", c_double), + ("bitrate_average_kbps", c_long), + ("bitrate_average_damping", c_double)] + + OV_ECTL_RATEMANAGE2_GET =0x14 + + OV_ECTL_RATEMANAGE2_SET =0x15 + + OV_ECTL_LOWPASS_GET =0x20 + + OV_ECTL_LOWPASS_SET =0x21 + + OV_ECTL_IBLOCK_GET =0x30 + + OV_ECTL_IBLOCK_SET =0x31 + + OV_ECTL_COUPLING_GET =0x40 + + OV_ECTL_COUPLING_SET =0x41 + + OV_ECTL_RATEMANAGE_GET =0x10 + + OV_ECTL_RATEMANAGE_SET =0x11 + + OV_ECTL_RATEMANAGE_AVG =0x12 + + OV_ECTL_RATEMANAGE_HARD =0x13 + # end of vorbisenc + except: + pass diff --git a/LXST/Codecs/libs/pyogg/vorbis_file.py b/LXST/Codecs/libs/pyogg/vorbis_file.py new file mode 100644 index 0000000..918f1e8 --- /dev/null +++ b/LXST/Codecs/libs/pyogg/vorbis_file.py @@ -0,0 +1,161 @@ +import ctypes + +from . import vorbis +from .audio_file import AudioFile +from .pyogg_error import PyOggError + +# TODO: Issue #70: Vorbis files with multiple logical bitstreams could +# be supported by chaining VorbisFile instances (with say a 'next' +# attribute that points to the next VorbisFile that would contain the +# PCM for the next logical bitstream). A considerable constraint to +# implementing this was that examples files that demonstrated multiple +# logical bitstreams couldn't be found or created. Note that even +# Audacity doesn't handle multiple logical bitstreams (see +# https://wiki.audacityteam.org/wiki/OGG#Importing_multiple_stream_files). + +# TODO: Issue #53: Unicode file names are not well supported. +# They may work in macOS and Linux, they don't work under Windows. + +class VorbisFile(AudioFile): + def __init__(self, + path: str, + bytes_per_sample: int = 2, + signed:bool = True) -> None: + """Load an OggVorbis File. + + path specifies the location of the Vorbis file. Unicode + filenames may not work correctly under Windows. + + bytes_per_sample specifies the word size of the PCM. It may + be either 1 or 2. Specifying one byte per sample will save + memory but will likely decrease the quality of the decoded + audio. + + Only Vorbis files with a single logical bitstream are + supported. + + """ + # Sanity check the number of bytes per sample + assert bytes_per_sample==1 or bytes_per_sample==2 + + # Sanity check that the vorbis library is available (for mypy) + assert vorbis.libvorbisfile is not None + + #: Bytes per sample + self.bytes_per_sample = bytes_per_sample + + #: Samples are signed (rather than unsigned) + self.signed = signed + + # Create a Vorbis File structure + vf = vorbis.OggVorbis_File() + + # Attempt to open the Vorbis file + error = vorbis.libvorbisfile.ov_fopen( + vorbis.to_char_p(path), + ctypes.byref(vf) + ) + + # Check for errors during opening + if error != 0: + raise PyOggError( + ("File '{}' couldn't be opened or doesn't exist. "+ + "Error code : {}").format(path, error) + ) + + # Extract info from the Vorbis file + info = vorbis.libvorbisfile.ov_info( + ctypes.byref(vf), + -1 # the current logical bitstream + ) + + #: Number of channels in audio file. + self.channels = info.contents.channels + + #: Number of samples per second (per channel), 44100 for + # example. + self.frequency = info.contents.rate + + # Extract the total number of PCM samples for the first + # logical bitstream + pcm_length_samples = vorbis.libvorbisfile.ov_pcm_total( + ctypes.byref(vf), + 0 # to extract the length of the first logical bitstream + ) + + # Create a memory block to store the entire PCM + Buffer = ( + ctypes.c_char + * ( + pcm_length_samples + * self.bytes_per_sample + * self.channels + ) + ) + self.buffer = Buffer() + + # Create a pointer to the newly allocated memory. It + # seems we can only do pointer arithmetic on void + # pointers. See + # https://mattgwwalker.wordpress.com/2020/05/30/pointer-manipulation-in-python/ + buf_ptr = ctypes.cast( + ctypes.pointer(self.buffer), + ctypes.c_void_p + ) + + # Storage for the index of the logical bitstream + bitstream_previous = None + bitstream = ctypes.c_int() + + # Set bytes remaining to read into PCM + read_size = len(self.buffer) + + while True: + # Convert buffer pointer to the desired type + ptr = ctypes.cast( + buf_ptr, + ctypes.POINTER(ctypes.c_char) + ) + + # Attempt to decode PCM from the Vorbis file + result = vorbis.libvorbisfile.ov_read( + ctypes.byref(vf), + ptr, + read_size, + 0, # Little endian + self.bytes_per_sample, + int(self.signed), + ctypes.byref(bitstream) + ) + + # Check for errors + if result < 0: + raise PyOggError( + "An error occurred decoding the Vorbis file: "+ + f"Error code: {result}" + ) + + # Check that the bitstream hasn't changed as we only + # support Vorbis files with a single logical bitstream. + if bitstream_previous is None: + bitstream_previous = bitstream + else: + if bitstream_previous != bitstream: + raise PyOggError( + "PyOgg currently supports Vorbis files "+ + "with only one logical stream" + ) + + # Check for end of file + if result == 0: + break + + # Calculate the number of bytes remaining to read into PCM + read_size -= result + + # Update the pointer into the buffer + buf_ptr.value += result + + + # Close the file and clean up memory + vorbis.libvorbisfile.ov_clear(ctypes.byref(vf)) diff --git a/LXST/Codecs/libs/pyogg/vorbis_file_stream.py b/LXST/Codecs/libs/pyogg/vorbis_file_stream.py new file mode 100644 index 0000000..57677ba --- /dev/null +++ b/LXST/Codecs/libs/pyogg/vorbis_file_stream.py @@ -0,0 +1,110 @@ +import ctypes + +from . import vorbis +from .pyogg_error import PyOggError + +class VorbisFileStream: + def __init__(self, path, buffer_size=8192): + self.exists = False + self._buffer_size = buffer_size + + self.vf = vorbis.OggVorbis_File() + error = vorbis.ov_fopen(path, ctypes.byref(self.vf)) + if error != 0: + raise PyOggError("file couldn't be opened or doesn't exist. Error code : {}".format(error)) + + info = vorbis.ov_info(ctypes.byref(self.vf), -1) + + #: Number of channels in audio file. + self.channels = info.contents.channels + + #: Number of samples per second (per channel). Always + # 48,000. + self.frequency = info.contents.rate + + array = (ctypes.c_char*(self._buffer_size*self.channels))() + + self.buffer_ = ctypes.cast(ctypes.pointer(array), ctypes.c_char_p) + + self.bitstream = ctypes.c_int() + self.bitstream_pointer = ctypes.pointer(self.bitstream) + + self.exists = True # TODO: is this the best place for this statement? + + #: Bytes per sample + self.bytes_per_sample = 2 # TODO: Where is this defined? + + def __del__(self): + if self.exists: + vorbis.ov_clear(ctypes.byref(self.vf)) + self.exists = False + + def clean_up(self): + vorbis.ov_clear(ctypes.byref(self.vf)) + + self.exists = False + + def get_buffer(self): + """get_buffer() -> bytesBuffer, bufferLength + + Returns None when all data has been read from the file. + + """ + if not self.exists: + return None + buffer = [] + total_bytes_written = 0 + + while True: + new_bytes = vorbis.ov_read(ctypes.byref(self.vf), self.buffer_, self._buffer_size*self.channels - total_bytes_written, 0, 2, 1, self.bitstream_pointer) + + array_ = ctypes.cast(self.buffer_, ctypes.POINTER(ctypes.c_char*(self._buffer_size*self.channels))).contents + + buffer.append(array_.raw[:new_bytes]) + + total_bytes_written += new_bytes + + if new_bytes == 0 or total_bytes_written >= self._buffer_size*self.channels: + break + + out_buffer = b"".join(buffer) + + if total_bytes_written == 0: + self.clean_up() + return(None) + + return out_buffer + + def get_buffer_as_array(self): + """Provides the buffer as a NumPy array. + + Note that the underlying data type is 16-bit signed + integers. + + Does not copy the underlying data, so the returned array + should either be processed or copied before the next call + to get_buffer() or get_buffer_as_array(). + + """ + import numpy # type: ignore + + # Read the next samples from the stream + buf = self.get_buffer() + + # Check if we've come to the end of the stream + if buf is None: + return None + + # Convert the bytes buffer to a NumPy array + array = numpy.frombuffer( + buf, + dtype=numpy.int16 + ) + + # Reshape the array + return array.reshape( + (len(buf) + // self.bytes_per_sample + // self.channels, + self.channels) + ) diff --git a/LXST/Common.py b/LXST/Common.py new file mode 100644 index 0000000..6ba1e9c --- /dev/null +++ b/LXST/Common.py @@ -0,0 +1,2 @@ +def nop(): + pass \ No newline at end of file diff --git a/LXST/Generators.py b/LXST/Generators.py new file mode 100644 index 0000000..e505a50 --- /dev/null +++ b/LXST/Generators.py @@ -0,0 +1,135 @@ +import os +import RNS +import math +import time +import threading +import numpy as np +from collections import deque +from .Codecs import Codec, CodecError +from .Sources import LocalSource + +RNS.loglevel = RNS.LOG_DEBUG + +class ToneSource(LocalSource): + DEFAULT_FRAME_MS = 80 + DEFAULT_SAMPLERATE = 48000 + DEFAULT_FREQUENCY = 400 + EASE_TIME_MS = 20 + + def __init__(self, frequency=DEFAULT_FREQUENCY, gain=0.1, ease=True, ease_time_ms=EASE_TIME_MS, + target_frame_ms=DEFAULT_FRAME_MS, codec=None, sink=None, channels=1): + + self.target_frame_ms = target_frame_ms + self.samplerate = self.DEFAULT_SAMPLERATE + self.channels = channels + self.bitdepth = 32 + self.frequency = frequency + self._gain = gain + self.gain = self._gain + self.ease = ease + self.theta = 0 + self.ease_gain = 0 + self.ease_time_ms = ease_time_ms + self.ease_step = 0 + self.gain_step = 0 + self.easing_out = False + self.should_run = False + self.generate_thread = None + self.generate_lock = threading.Lock() + self._codec = None + self.codec = codec + self.sink = sink + + @property + def codec(self): + return self._codec + + @codec.setter + def codec(self, codec): + if codec == None: + self._codec = None + elif not issubclass(type(codec), Codec): + raise CodecError(f"Invalid codec specified for {self}") + else: + self._codec = codec + + if self.codec.preferred_samplerate: + self.samplerate = self.codec.preferred_samplerate + + if self.codec.frame_quanta_ms: + if self.target_frame_ms%self.codec.frame_quanta_ms != 0: + self.target_frame_ms = math.ceil(self.target_frame_ms/self.codec.frame_quanta_ms)*self.codec.frame_quanta_ms + RNS.log(f"{self} target frame time quantized to {self.target_frame_ms}ms due to codec frame quanta", RNS.LOG_DEBUG) + + if self.codec.frame_max_ms: + if self.target_frame_ms > self.codec.frame_max_ms: + self.target_frame_ms = self.codec.frame_max_ms + RNS.log(f"{self} target frame time clamped to {self.target_frame_ms}ms due to codec frame limit", RNS.LOG_DEBUG) + + if self.codec.valid_frame_ms: + if not self.target_frame_ms in self.codec.valid_frame_ms: + self.target_frame_ms = min(self.codec.valid_frame_ms, key=lambda t:abs(t-self.target_frame_ms)) + RNS.log(f"{self} target frame time clamped to closest valid value of {self.target_frame_ms}ms ", RNS.LOG_DEBUG) + + self.samples_per_frame = math.ceil((self.target_frame_ms/1000)*self.samplerate) + self.frame_time = self.samples_per_frame/self.samplerate + self.ease_step = 1/(self.samplerate*(self.ease_time_ms/1000)) + self.gain_step = 0.02/(self.samplerate*(self.ease_time_ms/1000)) + + def start(self): + if not self.should_run: + RNS.log(f"{self} starting at {self.samples_per_frame} samples per frame, {self.channels} channels", RNS.LOG_DEBUG) + self.ease_gain = 0 if self.ease else 1 + self.should_run = True + self.generate_thread = threading.Thread(target=self.__generate_job, daemon=True) + self.generate_thread.start() + + def stop(self): + if not self.ease: + self.should_run = False + else: + self.easing_out = True + + @property + def running(self): + return self.should_run and not self.easing_out + + def __generate(self): + frame_samples = np.zeros((self.samples_per_frame, self.channels), dtype="float32") + step = (self.frequency * 2 * math.pi) / self.samplerate + for n in range(0, self.samples_per_frame): + self.theta += step + amplitude = math.sin(self.theta)*self._gain*self.ease_gain + for c in range(0, self.channels): + frame_samples[n, c] = amplitude + + if self.gain > self._gain: + self._gain += self.gain_step + if self._gain > self.gain: self._gain = self.gain + + if self.gain < self._gain: + self._gain -= self.gain_step + if self._gain < self.gain: self._gain = self.gain + + if self.ease: + if self.ease_gain < 1.0 and not self.easing_out: + self.ease_gain += self.ease_step + if self.ease_gain > 1.0: self.ease_gain = 1.0 + elif self.easing_out and self.ease_gain > 0.0: + self.ease_gain -= self.ease_step + if self.ease_gain <= 0.0: + self.ease_gain = 0.0 + self.easing_out = False + self.should_run = False + + return frame_samples + + def __generate_job(self): + with self.generate_lock: + while self.should_run: + if self.codec and self.sink and self.sink.can_receive(from_source=self): + frame_samples = self.__generate() + self.last_samples = frame_samples + frame = self.codec.encode(frame_samples) + self.sink.handle_frame(frame, self) + time.sleep(self.frame_time*0.1) diff --git a/LXST/Mixer.py b/LXST/Mixer.py new file mode 100644 index 0000000..62ed1e9 --- /dev/null +++ b/LXST/Mixer.py @@ -0,0 +1,149 @@ +import RNS +import LXST +import time +import math +import threading +import numpy as np +from collections import deque +from inspect import currentframe +from .Codecs import Codec, Raw +from .Codecs.Codec import resample +from .Sinks import LocalSink +from .Sources import LocalSource, Backend + +class Mixer(LocalSource, LocalSink): + MAX_FRAMES = 8 + TYPE_MAP_FACTOR = np.iinfo("int16").max + + def __init__(self, target_frame_ms=40, samplerate=None, codec=None, sink=None): + self.incoming_frames = {} + self.target_frame_ms = target_frame_ms + self.frame_time = self.target_frame_ms/1000 + self.should_run = False + self.mixer_thread = None + self.mixer_lock = threading.Lock() + self.insert_lock = threading.Lock() + self.bitdepth = 32 + self.channels = None + self.samplerate = None + self._sink = None + self._source = None + self._codec = None + + if samplerate: self.samplerate = samplerate + if sink: self.sink = sink + if codec: self.codec = codec + + def start(self): + if not self.should_run: + RNS.log(f"{self} starting", RNS.LOG_DEBUG) + self.should_run = True + self.mixer_thread = threading.Thread(target=self._mixer_job, daemon=True) + self.mixer_thread.start() + + def stop(self): + self.should_run = False + + def can_receive(self, from_source): + if not from_source in self.incoming_frames: + return True + elif len(self.incoming_frames[from_source]) < self.MAX_FRAMES: + return True + else: + return False + + def handle_frame(self, frame, source, decoded=False): + with self.insert_lock: + if not source in self.incoming_frames: + self.incoming_frames[source] = deque(maxlen=self.MAX_FRAMES) + + if not self.channels: + self.channels = source.channels + + if not self.samplerate: + self.samplerate = source.samplerate + self.samples_per_frame = math.ceil((self.target_frame_ms/1000)*self.samplerate) + self.frame_time = self.samples_per_frame/self.samplerate + RNS.log(f"{self} samplerate set to {RNS.prettyfrequency(self.samplerate)}", RNS.LOG_DEBUG) + RNS.log(f"{self} frame time is {RNS.prettyshorttime(self.frame_time)}") + + if not decoded: frame_samples = source.codec.decode(frame) + else: frame_samples = frame + + # TODO: Add resampling for all source types + # if CODEC_OUTPUT_RATE != self.samplerate: + # frame_samples = resample(frame_samples, source.bitdepth, source.channels, CODEC_OUTPUT_RATE, self.samplerate) + + self.incoming_frames[source].append(frame_samples) + + def _mixer_job(self): + with self.mixer_lock: + while self.should_run: + if self.sink and self.sink.can_receive(): + source_count = 0 + mixed_frame = None + for source in self.incoming_frames.copy(): + if len(self.incoming_frames[source]) > 0: + next_frame = self.incoming_frames[source].popleft() + if source_count == 0: mixed_frame = next_frame + else: mixed_frame = mixed_frame + next_frame + source_count += 1 + + if source_count > 0: + if self.codec: self.sink.handle_frame(self.codec.encode(mixed_frame), self) + else: self.sink.handle_frame(mixed_frame, self) + else: + time.sleep(self.frame_time*0.1) + + else: + time.sleep(self.frame_time*0.1) + + @property + def codec(self): + return self._codec + + @codec.setter + def codec(self, codec): + if codec == None: + self._codec = None + elif not issubclass(type(codec), Codec): + raise CodecError(f"Invalid codec specified for {self}") + else: + self._codec = codec + + if self.codec.preferred_samplerate: + self.samplerate = self.codec.preferred_samplerate + else: + self.samplerate = Backend.SAMPLERATE + + if self.codec.frame_quanta_ms: + if self.target_frame_ms%self.codec.frame_quanta_ms != 0: + self.target_frame_ms = math.ceil(self.target_frame_ms/self.codec.frame_quanta_ms)*self.codec.frame_quanta_ms + RNS.log(f"{self} target frame time quantized to {self.target_frame_ms}ms due to codec frame quanta", RNS.LOG_DEBUG) + + if self.codec.frame_max_ms: + if self.target_frame_ms > self.codec.frame_max_ms: + self.target_frame_ms = self.codec.frame_max_ms + RNS.log(f"{self} target frame time clamped to {self.target_frame_ms}ms due to codec frame limit", RNS.LOG_DEBUG) + + if self.codec.valid_frame_ms: + if not self.target_frame_ms in self.codec.valid_frame_ms: + self.target_frame_ms = min(self.codec.valid_frame_ms, key=lambda t:abs(t-self.target_frame_ms)) + RNS.log(f"{self} target frame time clamped to closest valid value of {self.target_frame_ms}ms ", RNS.LOG_DEBUG) + + @property + def source(self): + return self._source + + @source.setter + def source(self, source): + self._source = source + + @property + def sink(self): + return self._sink + + @sink.setter + def sink(self, sink): + self._sink = sink + diff --git a/LXST/Network.py b/LXST/Network.py new file mode 100644 index 0000000..5c0f2a2 --- /dev/null +++ b/LXST/Network.py @@ -0,0 +1,149 @@ +import RNS +import time +import threading +from .Sinks import RemoteSink +from .Sources import RemoteSource +from .Codecs import Null, codec_header_byte, codec_type +from collections import deque +from RNS.vendor import umsgpack as mp + +FIELD_SIGNALLING = 0x00 +FIELD_FRAMES = 0x01 + +class SignallingReceiver(): + def __init__(self, proxy=None): + # TODO: Add inband signalling scheduler + self.outgoing_signals = deque() + self.proxy = proxy + + def handle_signalling_from(self, source): + source.set_packet_callback(self._packet) + + def signalling_received(self, signals, source): + if self.proxy: self.proxy.signalling_received(signals, source) + + def signal(self, signal, destination, immediate=True): + signalling_data = {FIELD_SIGNALLING:[signal]} + + if immediate: + signalling_packet = RNS.Packet(destination, mp.packb(signalling_data), create_receipt=False) + signalling_packet.send() + else: + # TODO: Add inband signalling scheduler + pass + + def _packet(self, data, packet, unpacked=None): + try: + if not unpacked: unpacked = mp.unpackb(data) + source = packet.link if hasattr(packet, "link") else None + if type(unpacked) == dict: + if FIELD_SIGNALLING in unpacked: + signalling = unpacked[FIELD_SIGNALLING] + if type(signalling) == list: + self.signalling_received(signalling, source) + else: + self.signalling_received([signalling], source) + + except Exception as e: + RNS.log(f"{self} could not process incoming packet: {e}", RNS.LOG_ERROR) + RNS.trace_exception(e) + +class Packetizer(RemoteSink): + def __init__(self, destination, failure_callback=None): + self.destination = destination + self.should_run = False + self.source = None + self.transmit_failure = False + self.__failure_calback = failure_callback + + def handle_frame(self, frame, source=None): + if type(self.destination) == RNS.Link and not self.destination.status == RNS.Link.ACTIVE: + return + + # TODO: Add inband signalling scheduler + frame = codec_header_byte(type(self.source.codec))+frame + packet_data = {FIELD_FRAMES:frame} + frame_packet = RNS.Packet(self.destination, mp.packb(packet_data), create_receipt=False) + if frame_packet.send() == False: + self.transmit_failure = True + if callable(self.__failure_calback): self.__failure_calback() + + # TODO: Remove testing + # if not hasattr(self, "frames"): + # self.frames = 0 + # self.frame_bytes = 0 + # self.total_bytes = 0 + # self.total_bytes = 0 + # self.overhead_bytes = 0 + # self.frames += 1 + # self.frame_bytes += len(frame) + # self.total_bytes += len(frame_packet.raw) + # self.overhead_bytes += len(frame_packet.raw)-len(frame) + # self.overhead_ratio = self.frame_bytes / self.total_bytes + # if not hasattr(self, "started"): + # self.started = time.time() + # rate = 0 + # codec_rate = 0 + # else: + # rate = (self.total_bytes*8)/(time.time()-self.started) + # codec_rate = (self.frame_bytes*8)/(time.time()-self.started) + # print(f"\rP={len(frame_packet.raw)}/{len(frame)}/{len(frame_packet.raw)-len(frame)} N={self.frames} E={round(self.overhead_ratio*100,0)}% O={RNS.prettysize(self.total_bytes)} F={RNS.prettysize(self.frame_bytes)} S={RNS.prettyspeed(rate)} C={RNS.prettyspeed(codec_rate)}", end=" ") + + def start(self): + if not self.should_run: + RNS.log(f"{self} starting", RNS.LOG_DEBUG) + self.should_run = True + + def stop(self): + self.should_run = False + +class LinkSource(RemoteSource, SignallingReceiver): + def __init__(self, link, signalling_receiver, sink=None): + self.should_run = False + self.link = link + self.sink = sink + self.codec = Null() + self.pipeline = None + self.proxy = signalling_receiver + self.receive_lock = threading.Lock() + self.link.set_packet_callback(self._packet) + + def _packet(self, data, packet): + with self.receive_lock: + try: + unpacked = mp.unpackb(data) + if type(unpacked) == dict: + if FIELD_FRAMES in unpacked: + frames = unpacked[FIELD_FRAMES] + if type(frames) != list: frames = [frames] + for frame in frames: + frame_codec = codec_type(frame[0]) + if self.codec and self.sink: + if type(self.codec) != frame_codec: + RNS.log(f"Remote switched codec to {frame_codec}", RNS.LOG_DEBUG) + if self.pipeline: self.pipeline.codec = frame_codec() + else: self.codec = frame_codec(); self.codec.sink = self.sink + decoded_frame = self.codec.decode(frame[1:]) + if self.codec.channels: self.channels = self.codec.channels + else: + decoded_frame = self.codec.decode(frame[1:]) + + if self.pipeline: + self.sink.handle_frame(decoded_frame, self) + else: + self.sink.handle_frame(decoded_frame, self, decoded=True) + + if FIELD_SIGNALLING in unpacked: + super()._packet(data=None, packet=packet, unpacked=unpacked) + + except Exception as e: + RNS.log(f"{self} could not process incoming packet: {e}", RNS.LOG_ERROR) + RNS.trace_exception(e) + + def start(self): + if not self.should_run: + RNS.log(f"{self} starting", RNS.LOG_DEBUG) + self.should_run = True + + def stop(self): + self.should_run = False \ No newline at end of file diff --git a/LXST/Pipeline.py b/LXST/Pipeline.py new file mode 100644 index 0000000..db1920d --- /dev/null +++ b/LXST/Pipeline.py @@ -0,0 +1,60 @@ +from .Sources import * +from .Sinks import * +from .Codecs import * +from .Mixer import Mixer +from .Network import Packetizer + +class PipelineError(Exception): + pass + +class Pipeline(): + def __init__(self, source, codec, sink, processor = None): + if not issubclass(type(source), Source): raise PipelineError("Audio pipeline initialised with invalid source") + if not issubclass(type(sink), Sink) : raise PipelineError("Audio pipeline initialised with invalid sink") + if not issubclass(type(codec), Codec) : raise PipelineError("Audio pipeline initialised with invalid codec") + self._codec = None + self.source = source + self.source.pipeline = self + self.source.sink = sink + self.codec = codec + + if isinstance(sink, Loopback): + sink.samplerate = source.samplerate + if isinstance(source, Loopback): + source._sink = sink + if isinstance(sink, Packetizer): + sink.source = source + + @property + def codec(self): + if self.source: + return self.source.codec + else: + return None + + @codec.setter + def codec(self, codec): + if not self._codec == codec: + self._codec = codec + self.source.codec = self._codec + self.source.codec.sink = self.sink + self.source.codec.source = self.source + + @property + def sink(self): + if self.source: + return self.source.sink + else: + return None + + @property + def running(self): + return self.source.should_run + + def start(self): + if not self.running: + self.source.start() + + def stop(self): + if self.running: + self.source.stop() \ No newline at end of file diff --git a/LXST/Primitives/Telephony.py b/LXST/Primitives/Telephony.py new file mode 100644 index 0000000..625a7b9 --- /dev/null +++ b/LXST/Primitives/Telephony.py @@ -0,0 +1,501 @@ +import os +import RNS +import LXST +import time +import threading + +from LXST import APP_NAME +from LXST import Mixer, Pipeline +from LXST.Codecs import Raw, Opus, Codec2, Null +from LXST.Sinks import LineSink +from LXST.Sources import LineSource, OpusFileSource +from LXST.Generators import ToneSource +from LXST.Network import SignallingReceiver, Packetizer, LinkSource + +PRIMITIVE_NAME = "telephony" + +class Signalling(): + STATUS_BUSY = 0x00 + STATUS_REJECTED = 0x01 + STATUS_CALLING = 0x02 + STATUS_AVAILABLE = 0x03 + STATUS_RINGING = 0x04 + STATUS_CONNECTING = 0x05 + STATUS_ESTABLISHED = 0x06 + AUTO_STATUS_CODES = [STATUS_CALLING, STATUS_AVAILABLE, STATUS_RINGING, + STATUS_CONNECTING, STATUS_ESTABLISHED] + +class Telephone(SignallingReceiver): + RING_TIME = 60 + WAIT_TIME = 70 + DIAL_TONE_FREQUENCY = 382 + DIAL_TONE_EASE_MS = 3.14159 + JOB_INTERVAL = 5 + ANNOUNCE_INTERVAL_MIN = 60*5 + ANNOUNCE_INTERVAL = 60*60*3 + ALLOW_ALL = 0xFF + ALLOW_NONE = 0xFE + + def __init__(self, identity, ring_time=RING_TIME, wait_time=WAIT_TIME, auto_answer=None, allowed=ALLOW_ALL): + super().__init__() + self.identity = identity + self.destination = RNS.Destination(self.identity, RNS.Destination.IN, RNS.Destination.SINGLE, APP_NAME, PRIMITIVE_NAME) + self.destination.set_proof_strategy(RNS.Destination.PROVE_NONE) + self.destination.set_link_established_callback(self.__incoming_link_established) + self.allowed = allowed + self.blocked = None + self.last_announce = 0 + self.call_handler_lock = threading.Lock() + self.pipeline_lock = threading.Lock() + self.caller_pipeline_open_lock = threading.Lock() + self.links = {} + self.ring_time = ring_time + self.wait_time = wait_time + self.auto_answer = auto_answer + self.active_call = None + self.call_status = Signalling.STATUS_AVAILABLE + self._external_busy = False + self.__ringing_callback = None + self.__established_callback = None + self.__ended_callback = None + self.target_frame_time_ms = None + self.audio_output = None + self.audio_input = None + self.dial_tone = None + self.dial_tone_frequency = self.DIAL_TONE_FREQUENCY + self.dial_tone_ease_ms = self.DIAL_TONE_EASE_MS + self.transmit_codec = None + self.receive_codec = None + self.receive_mixer = None + self.transmit_mixer = None + self.receive_pipeline = None + self.transmit_pipeline = None + self.ringer_lock = threading.Lock() + self.ringer_output = None + self.ringer_pipeline = None + self.ringtone_path = None + self.speaker_device = None + self.microphone_device = None + self.ringer_device = None + + threading.Thread(target=self.__jobs, daemon=True).start() + RNS.log(f"{self} listening on {RNS.prettyhexrep(self.destination.hash)}", RNS.LOG_DEBUG) + + def teardown(self): + self.hangup() + RNS.Transport.deregister_destination(self.destination) + self.destination = None + + def announce(self): + self.destination.announce() + self.last_announce = time.time() + + def set_allowed(self, allowed): + valid_allowed = [self.ALLOW_ALL, self.ALLOW_NONE] + if callable(allowed) or type(allowed) == list or allowed in valid_allowed: self.allowed = allowed + else: raise TypeError(f"Invalid type for allowed callers: {type(allowed)}") + + def set_blocked(self, blocked): + if type(blocked) == list or blocked == None: self.blocked = blocked + else: raise TypeError(f"Invalid type for blocked callers: {type(blocked)}") + + def set_announce_interval(self, announce_interval): + if not type(announce_interval) == int: raise TypeError(f"Invalid type for announce interval: {announce_interval}") + else: + if announce_interval < self.ANNOUNCE_INTERVAL_MIN: announce_interval = self.ANNOUNCE_INTERVAL_MIN + self.announce_interval = announce_interval + + def set_ringing_callback(self, callback): + if not callable(callback): raise TypeError(f"Invalid callback, {callback} is not callable") + self.__ringing_callback = callback + + def set_established_callback(self, callback): + if not callable(callback): raise TypeError(f"Invalid callback, {callback} is not callable") + self.__established_callback = callback + + def set_ended_callback(self, callback): + if not callable(callback): raise TypeError(f"Invalid callback, {callback} is not callable") + self.__ended_callback = callback + + def set_speaker(self, device): + self.speaker_device = device + RNS.log(f"{self} speaker device set to {device}", RNS.LOG_DEBUG) + + def set_microphone(self, device): + self.microphone_device = device + RNS.log(f"{self} microphone device set to {device}", RNS.LOG_DEBUG) + + def set_ringer(self, device): + self.ringer_device = device + RNS.log(f"{self} ringer device set to {device}", RNS.LOG_DEBUG) + + def set_ringtone(self, ringtone_path, gain=1.0): + self.ringtone_path = ringtone_path + self.ringtone_gain = gain + RNS.log(f"{self} ringtone set to {self.ringtone_path}", RNS.LOG_DEBUG) + + def __jobs(self): + while self.destination != None: + time.sleep(self.JOB_INTERVAL) + if time.time() > self.last_announce+self.ANNOUNCE_INTERVAL: + if self.destination != None: self.announce() + + def __is_allowed(self, remote_identity): + identity_hash = remote_identity.hash + if type(self.blocked) == list and identity_hash in self.blocked: return False + elif self.allowed == self.ALLOW_ALL: return True + elif self.allowed == self.ALLOW_NONE: return False + elif type(self.allowed) == list: return identity_hash in self.allowed + elif callable(self.allowed): return self.allowed(identity_hash) + + def __timeout_incoming_call_at(self, call, timeout): + def job(): + while time.time() Signalling.STATUS_RINGING: + RNS.log(f"Incoming call from {RNS.prettyhexrep(identity.hash)} already answered and active") + return False + elif not self.active_call: + RNS.log(f"Answering call failed, no active incoming call", RNS.LOG_ERROR) + return False + elif not self.active_call.get_remote_identity(): + RNS.log(f"Answering call failed, active incoming call is not from {RNS.prettyhexrep(identity.hash)}", RNS.LOG_ERROR) + return False + else: + RNS.log(f"Answering call from {RNS.prettyhexrep(identity.hash)}", RNS.LOG_DEBUG) + self.__open_pipelines(identity) + self.__start_pipelines() + RNS.log(f"Call setup complete for {RNS.prettyhexrep(identity.hash)}", RNS.LOG_DEBUG) + if callable(self.__established_callback): self.__established_callback(self.active_call.get_remote_identity()) + return True + + def hangup(self): + if self.active_call: + with self.call_handler_lock: + terminating_call = self.active_call; self.active_call = None + remote_identity = terminating_call.get_remote_identity() + + if terminating_call.is_incoming and self.call_status == Signalling.STATUS_RINGING: + if not terminating_call.ring_timeout and terminating_call.status == RNS.Link.ACTIVE: + self.signal(Signalling.STATUS_REJECTED, terminating_call) + + if terminating_call.status == RNS.Link.ACTIVE: terminating_call.teardown() + self.__stop_pipelines() + self.receive_mixer = None + self.transmit_mixer = None + self.receive_pipeline = None + self.transmit_pipeline = None + self.audio_output = None + self.dial_tone = None + self.call_status = Signalling.STATUS_AVAILABLE + if remote_identity: + RNS.log(f"Call with {RNS.prettyhexrep(remote_identity.hash)} terminated", RNS.LOG_DEBUG) + else: + RNS.log(f"Outgoing call could not be connected, link establishment failed", RNS.LOG_DEBUG) + + if callable(self.__ended_callback): self.__ended_callback(remote_identity) + + def mute_receive(self): + pass + + def mute_transmit(self): + pass + + def select_call_codecs(self): + self.receive_codec = Null() + + # self.transmit_codec = Codec2(mode=Codec2.CODEC2_700C) + # self.transmit_codec = Codec2(mode=Codec2.CODEC2_1600) + # self.transmit_codec = Codec2(mode=Codec2.CODEC2_3200) + # self.transmit_codec = Opus(profile=Opus.PROFILE_VOICE_LOW) + self.transmit_codec = Opus(profile=Opus.PROFILE_VOICE_MEDIUM) + # self.transmit_codec = Opus(profile=Opus.PROFILE_VOICE_HIGH) + # self.transmit_codec = Opus(profile=Opus.PROFILE_VOICE_MAX) + # self.transmit_codec = Opus(profile=Opus.PROFILE_AUDIO_MIN) + # self.transmit_codec = Opus(profile=Opus.PROFILE_AUDIO_LOW) + # self.transmit_codec = Opus(profile=Opus.PROFILE_AUDIO_MEDIUM) + # self.transmit_codec = Opus(profile=Opus.PROFILE_AUDIO_HIGH) + # self.transmit_codec = Opus(profile=Opus.PROFILE_AUDIO_MAX) + # self.transmit_codec = Raw() + + def select_call_frame_time(self): + self.target_frame_time_ms = 60 + return self.target_frame_time_ms + + def __reset_dialling_pipelines(self): + with self.pipeline_lock: + if self.audio_output: self.audio_output.stop() + if self.dial_tone: self.dial_tone.stop() + if self.receive_pipeline: self.receive_pipeline.stop() + if self.receive_mixer: self.receive_mixer.stop() + self.audio_output = None + self.dial_tone = None + self.receive_pipeline = None + self.receive_mixer = None + self.__prepare_dialling_pipelines() + + def __prepare_dialling_pipelines(self): + self.select_call_frame_time() + self.select_call_codecs() + if self.audio_output == None: self.audio_output = LineSink(preferred_device=self.speaker_device) + if self.receive_mixer == None: self.receive_mixer = Mixer(target_frame_ms=self.target_frame_time_ms) + if self.dial_tone == None: self.dial_tone = ToneSource(frequency=self.dial_tone_frequency, gain=0.0, ease_time_ms=self.dial_tone_ease_ms, target_frame_ms=self.target_frame_time_ms, codec=Null(), sink=self.receive_mixer) + if self.receive_pipeline == None: self.receive_pipeline = Pipeline(source=self.receive_mixer, codec=Null(), sink=self.audio_output) + + def __activate_ring_tone(self): + if self.ringtone_path != None and os.path.isfile(self.ringtone_path): + if not self.ringer_pipeline: + if not self.ringer_output: self.ringer_output = LineSink(preferred_device=self.ringer_device) + self.ringer_source = OpusFileSource(self.ringtone_path, loop=True, target_frame_ms=60) + self.ringer_pipeline = Pipeline(source=self.ringer_source, codec=Null(), sink=self.ringer_output) + + def job(): + with self.ringer_lock: + while self.active_call and self.active_call.is_incoming and self.call_status == Signalling.STATUS_RINGING: + if not self.ringer_pipeline.running: self.ringer_pipeline.start() + time.sleep(0.1) + self.ringer_source.stop() + threading.Thread(target=job, daemon=True).start() + + def __play_busy_tone(self): + if self.audio_output == None or self.receive_mixer == None or self.dial_tone == None: self.__reset_dialling_pipelines() + with self.pipeline_lock: + window = 0.5; started = time.time() + while time.time()-started < 4.25: + elapsed = (time.time()-started)%window + if elapsed > 0.25: self.__enable_dial_tone() + else: self.__mute_dial_tone() + time.sleep(0.005) + time.sleep(0.5) + + def __activate_dial_tone(self): + def job(): + window = 7 + started = time.time() + while self.active_call and self.active_call.is_outgoing and self.call_status == Signalling.STATUS_RINGING: + elapsed = (time.time()-started)%window + if elapsed > 0.05 and elapsed < 2.05: self.__enable_dial_tone() + else: self.__mute_dial_tone() + time.sleep(0.2) + + threading.Thread(target=job, daemon=True).start() + + def __enable_dial_tone(self): + if not self.receive_mixer.should_run: self.receive_mixer.start() + self.dial_tone.gain = 0.04 + if not self.dial_tone.running: self.dial_tone.start() + + def __mute_dial_tone(self): + if not self.receive_mixer.should_run: self.receive_mixer.start() + if self.dial_tone.running and self.dial_tone.gain != 0: self.dial_tone.gain = 0.0 + if not self.dial_tone.running: self.dial_tone.start() + + def __disable_dial_tone(self): + if self.dial_tone and self.dial_tone.running: + self.dial_tone.stop() + + def __open_pipelines(self, identity): + with self.pipeline_lock: + if not self.active_call.get_remote_identity() == identity: + RNS.log("Identity mismatch while opening call pipelines, tearing down call", RNS.LOG_ERROR) + self.hangup() + else: + if not hasattr(self.active_call, "pipelines_opened"): self.active_call.pipelines_opened = False + if self.active_call.pipelines_opened: RNS.log(f"Pipelines already openened for call with {RNS.prettyhexrep(identity.hash)}", RNS.LOG_ERROR) + else: + RNS.log(f"Opening audio pipelines for call with {RNS.prettyhexrep(identity.hash)}", RNS.LOG_DEBUG) + if self.active_call.is_incoming: self.signal(Signalling.STATUS_CONNECTING, self.active_call) + + self.__prepare_dialling_pipelines() + self.transmit_mixer = Mixer(target_frame_ms=self.target_frame_time_ms) + self.audio_input = LineSource(preferred_device=self.microphone_device, target_frame_ms=self.target_frame_time_ms, codec=Raw(), sink=self.transmit_mixer) + # self.audio_input = OpusFileSource("/home/markqvist/Information/Source/LXST/docs/425.opus", loop=True, target_frame_ms=self.target_frame_time_ms, codec=Raw(), sink=self.transmit_mixer, timed=True) + self.transmit_pipeline = Pipeline(source=self.transmit_mixer, + codec=self.transmit_codec, + sink=Packetizer(self.active_call, failure_callback=self.__packetizer_failure)) + + self.active_call.audio_source = LinkSource(link=self.active_call, signalling_receiver=self, sink=self.receive_mixer) + + self.signal(Signalling.STATUS_ESTABLISHED, self.active_call) + + def __packetizer_failure(self): + RNS.log(f"Frame packetization failed, terminating call", RNS.LOG_ERROR) + self.hangup() + + def __start_pipelines(self): + with self.pipeline_lock: + if self.receive_mixer: self.receive_mixer.start() + if self.transmit_mixer: self.transmit_mixer.start() + if self.audio_input: self.audio_input.start() + if self.transmit_pipeline: self.transmit_pipeline.start() + if not self.audio_input: RNS.log("No audio input was ready at call establishment", RNS.LOG_ERROR) + RNS.log(f"Audio pipelines started", RNS.LOG_DEBUG) + + def __stop_pipelines(self): + with self.pipeline_lock: + if self.receive_mixer: self.receive_mixer.stop() + if self.transmit_mixer: self.transmit_mixer.stop() + if self.audio_input: self.audio_input.stop() + if self.receive_pipeline: self.receive_pipeline.stop() + if self.transmit_pipeline: self.transmit_pipeline.stop() + RNS.log(f"Audio pipelines stopped", RNS.LOG_DEBUG) + + def call(self, identity): + with self.call_handler_lock: + if not self.active_call: + self.call_status = Signalling.STATUS_CALLING + outgoing_call_timeout = time.time()+self.wait_time + call_destination = RNS.Destination(identity, RNS.Destination.OUT, RNS.Destination.SINGLE, APP_NAME, PRIMITIVE_NAME) + if not RNS.Transport.has_path(call_destination.hash): + RNS.log(f"No path known for call to {RNS.prettyhexrep(call_destination.hash)}, requesting path...", RNS.LOG_DEBUG) + RNS.Transport.request_path(call_destination.hash) + while not RNS.Transport.has_path(call_destination.hash) and time.time() < outgoing_call_timeout: time.sleep(0.2) + + if not RNS.Transport.has_path(call_destination.hash) and time.time() >= outgoing_call_timeout: + self.hangup() + else: + RNS.log(f"Establishing link with {RNS.prettyhexrep(call_destination.hash)}...", RNS.LOG_DEBUG) + self.active_call = RNS.Link(call_destination, + established_callback=self.__outgoing_link_established, + closed_callback=self.__outgoing_link_closed) + + self.active_call.is_incoming = False + self.active_call.is_outgoing = True + self.active_call.ring_timeout = False + self.__timeout_outgoing_call_at(self.active_call, outgoing_call_timeout) + + def __outgoing_link_established(self, link): + RNS.log(f"Link established for call with {link.get_remote_identity()}", RNS.LOG_DEBUG) + link.set_link_closed_callback(self.__link_closed) + self.handle_signalling_from(link) + + def __outgoing_link_closed(self, link): + pass + + def signalling_received(self, signals, source): + for signal in signals: + if source != self.active_call: + RNS.log("Received signalling on non-active call, ignoring", RNS.LOG_DEBUG) + else: + if signal == Signalling.STATUS_BUSY: + RNS.log("Remote is busy, terminating", RNS.LOG_DEBUG) + self.__play_busy_tone() + self.__disable_dial_tone() + self.hangup() + elif signal == Signalling.STATUS_REJECTED: + RNS.log("Remote rejected call, terminating", RNS.LOG_DEBUG) + self.__play_busy_tone() + self.__disable_dial_tone() + self.hangup() + elif signal == Signalling.STATUS_AVAILABLE: + RNS.log("Line available, sending identification", RNS.LOG_DEBUG) + self.call_status = signal + source.identify(self.identity) + elif signal == Signalling.STATUS_RINGING: + RNS.log("Identification accepted, remote is now ringing", RNS.LOG_DEBUG) + self.call_status = signal + self.__prepare_dialling_pipelines() + if self.active_call and self.active_call.is_outgoing: + self.__activate_dial_tone() + elif signal == Signalling.STATUS_CONNECTING: + RNS.log("Call answered, remote is performing call setup, opening audio pipelines", RNS.LOG_DEBUG) + self.call_status = signal + with self.caller_pipeline_open_lock: + self.__reset_dialling_pipelines() + self.__open_pipelines(self.active_call.get_remote_identity()) + elif signal == Signalling.STATUS_ESTABLISHED: + if self.active_call and self.active_call.is_outgoing: + RNS.log("Remote call setup completed, starting audio pipelines", RNS.LOG_DEBUG) + with self.caller_pipeline_open_lock: + self.__start_pipelines() + self.__disable_dial_tone() + RNS.log(f"Call setup complete for {RNS.prettyhexrep(self.active_call.get_remote_identity().hash)}", RNS.LOG_DEBUG) + self.call_status = signal + if callable(self.__established_callback): self.__established_callback(self.active_call.get_remote_identity()) + + def __str__(self): + return f"" \ No newline at end of file diff --git a/LXST/Primitives/__init__.py b/LXST/Primitives/__init__.py new file mode 100644 index 0000000..e285a45 --- /dev/null +++ b/LXST/Primitives/__init__.py @@ -0,0 +1 @@ +from .Telephony import Telephone \ No newline at end of file diff --git a/LXST/Primitives/hardware/display_i2c_lcd1602.py b/LXST/Primitives/hardware/display_i2c_lcd1602.py new file mode 100644 index 0000000..a096c92 --- /dev/null +++ b/LXST/Primitives/hardware/display_i2c_lcd1602.py @@ -0,0 +1,100 @@ +import os +import time +import threading +from importlib.util import find_spec +if find_spec("smbus"): import smbus +else: raise OSError(f"No smbus module available, cannot use {os.path.basename(__file__)} driver") + +class LCD(): + DEFAULT_ADDR = 0x27 + DEFAULT_I2C_CH = 1 + COLS = 16 + ROWS = 2 + + MODE_CHR = 0x01 + MODE_CMD = 0x00 + + ROW_1 = 0x80 + ROW_2 = 0xC0 + + BACKLIGHT_ON = 0x08 + BACKLIGHT_OFF = 0x00 + FLAG_ENABLE = 0b00000100 + FLAG_RS = 0b00000001 + + T_PULSE = 0.5/1000 + T_DELAY = 0.5/1000 + + CMD_INIT1 = 0x33 + CMD_INIT2 = 0x32 + CMD_CLEAR = 0x01 + + SHARED_BUS = None + + def __init__(self, address=None): + if not LCD.SHARED_BUS: LCD.SHARED_BUS = smbus.SMBus(self.DEFAULT_I2C_CH) + self.address = address or self.DEFAULT_ADDR + self.bus = LCD.SHARED_BUS + self.row = LCD.ROW_1 + self.backlight = LCD.BACKLIGHT_ON + self.__init_display() + + def __init_display(self): + self.__send_command(LCD.CMD_INIT1) + self.__send_command(LCD.CMD_INIT2) + self.__send_command(0x28) # Data length, number of lines, font size + self.__send_command(0x0C) # Display on, cursor off, blink off + self.__send_command(LCD.CMD_CLEAR) + time.sleep(LCD.T_DELAY) + + def __send_command(self, command): + byte = command & 0xF0 # Transmit MSBs + byte |= 0x04; self.__send_byte(byte); time.sleep(LCD.T_PULSE) + byte &= 0xFB; self.__send_byte(byte) + + byte = (command & 0x0F) << 4 # Transmit LSBs + byte |= 0x04; self.__send_byte(byte); time.sleep(LCD.T_PULSE) + byte &= 0xFB; self.__send_byte(byte) + + def __send_data(self, data): + byte = data & 0xF0 # Transmit MSBs + byte |= 0x05; self.__send_byte(byte); time.sleep(LCD.T_PULSE) + byte &= 0xFB; self.__send_byte(byte) + + byte = (data & 0x0F) << 4 # Transmit LSBs + byte |= 0x05; self.__send_byte(byte); time.sleep(LCD.T_PULSE) + byte &= 0xFB; self.__send_byte(byte) + + def __send_byte(self, byte): + self.bus.write_byte(self.address, byte | self.backlight) + + def print(self, string, x=0, y=0): + string = string.ljust(LCD.COLS," ") + if x < 0: x = 0 + if x > 15: x = 15 + if y < 0: y = 0 + if y > 1: y = 1 + if self.is_sleeping: self.wake() + self.__send_command(0x80 + 0x40 * y + x) # Set cursor location + for i in range(LCD.COLS): self.__send_data(ord(string[i])) + + def clear(self): + self.__init_display() + + @property + def is_sleeping(self): + return self.backlight == LCD.BACKLIGHT_OFF + + def sleep(self): + self.backlight = LCD.BACKLIGHT_OFF + self.__send_command(LCD.CMD_CLEAR) + + def wake(self): + self.backlight = LCD.BACKLIGHT_ON + self.__init_display() + + def close(self): + self.sleep() + self.bus.close() + self.bus = None + LCD.SHARED_BUS = None \ No newline at end of file diff --git a/LXST/Primitives/hardware/keypad_gpio_4x4.py b/LXST/Primitives/hardware/keypad_gpio_4x4.py new file mode 100644 index 0000000..dd977fe --- /dev/null +++ b/LXST/Primitives/hardware/keypad_gpio_4x4.py @@ -0,0 +1,130 @@ +import os +import time +import threading +from importlib.util import find_spec +if find_spec("RPi"): import RPi.GPIO as GPIO +else: raise OSError(f"No GPIO module available, cannot use {os.path.basename(__file__)} driver") + +class Event: + UP = 0x00 + DOWN = 0x01 + +class Keypad(): + ROWS = 4 + COLS = 4 + SCAN_INTERVAL_MS = 20 + + LOW = 0x00 + HIGH = 0x01 + + DEFAULT_MAP = [["1", "2", "3", "A"], + ["4", "5", "6", "B"], + ["7", "8", "9", "C"], + ["*", "0", "#", "D"]] + + DEFAULT_ROWPINS = [21, 20, 16, 12] + DEFAULT_COLPINS = [26, 19, 13, 6] + DEFAULT_HOOKPIN = 5 + HOOK_DEBOUNCE_MS = 150 + + def __init__(self, row_pins=None, col_pins=None, key_map=None, callback=None): + if not row_pins == None and (not type(row_pins) == list or len(row_pins) != 4): + raise ValueError("Invalid row pins specification") + if not col_pins == None and (not type(col_pins) == list or len(col_pins) != 4): + raise ValueError("Invalid row pins specification") + + self.row_pins = row_pins or self.DEFAULT_ROWPINS + self.col_pins = col_pins or self.DEFAULT_COLPINS + self.scan_lock = threading.Lock() + self.callback = callback + self.hook_time = 0 + self.hook_pin = None + self.on_hook = True + self.check_hook = False + self.should_run = False + self.ec = Event + self.set_key_map(key_map) + + def enable_hook(self, pin=None): + if pin == None: pin = self.DEFAULT_HOOKPIN + self.hook_pin = pin + GPIO.setup(self.hook_pin, GPIO.IN, pull_up_down=GPIO.PUD_UP) + self.key_states["hook"] = False + self.check_hook = True + + def set_key_map(self, key_map): + self.key_map = key_map or self.DEFAULT_MAP + self.key_states = {} + for row in self.key_map: + for key in row: self.key_states[key] = False + + def is_down(self, key): + if not key in self.key_states: return False + else: + return self.key_states[key] + + def is_up(self, key): + if not key in self.key_states: return False + else: + return not self.key_states[key] + + def __job(self): + while self.should_run: + self.__scan() + time.sleep(self.SCAN_INTERVAL_MS/1000) + + def __handle(self, active_keys): + events = [] + for key in self.key_states: + if self.key_states[key] == False: + if key in active_keys: + self.key_states[key] = True + events.append((key, Event.DOWN)) + + elif self.key_states[key] == True: + if not key in active_keys: + self.key_states[key] = False + events.append((key, Event.UP)) + + if callable(self.callback): + for event in events: + self.callback(self, event) + + def __scan(self): + active_keys = [] + for row in range(0, self.ROWS): + GPIO.setup(self.row_pins[row], GPIO.OUT) + GPIO.output(self.row_pins[row], GPIO.HIGH) + for col in range(0, self.COLS): + if GPIO.input(self.col_pins[col]): + active_keys.append(self.key_map[row][col]) + + GPIO.output(self.row_pins[row], GPIO.LOW) + GPIO.setup(self.row_pins[row], GPIO.IN, pull_up_down=GPIO.PUD_OFF) + + if self.check_hook: + on_hook = GPIO.input(self.hook_pin) == GPIO.LOW + + if on_hook: + active_keys.append("hook") + self.hook_time = time.time() + + if self.key_states["hook"] == True and not on_hook: + if time.time()-self.hook_time < self.HOOK_DEBOUNCE_MS/1000: + active_keys.append("hook") + else: + self.hook_time = time.time() + + if len(active_keys) >= 0 and len(active_keys) <= 4: self.__handle(active_keys) + + def start(self): + GPIO.setwarnings(False) + GPIO.setmode(GPIO.BCM) + for row_pin in self.row_pins: GPIO.setup(row_pin, GPIO.OUT) + for col_pin in self.col_pins: GPIO.setup(col_pin, GPIO.IN, pull_up_down=GPIO.PUD_DOWN) + + self.should_run = True + threading.Thread(target=self.__job, daemon=True).start() + + def stop(self): + self.should_run = False \ No newline at end of file diff --git a/LXST/Processing.py b/LXST/Processing.py new file mode 100644 index 0000000..e69de29 diff --git a/LXST/Sinks.py b/LXST/Sinks.py new file mode 100644 index 0000000..997d650 --- /dev/null +++ b/LXST/Sinks.py @@ -0,0 +1,136 @@ +import RNS +import math +import time +import threading +from collections import deque + +class LinuxBackend(): + SAMPLERATE = 48000 + + def __init__(self, preferred_device=None, samplerate=SAMPLERATE): + import soundcard + self.samplerate = samplerate + self.soundcard = soundcard + if preferred_device: + try: self.device = self.soundcard.get_speaker(preferred_device) + except: self.device = soundcard.default_speaker() + else: self.device = soundcard.default_speaker() + RNS.log(f"Using output device {self.device}", RNS.LOG_DEBUG) + + def flush(self): + self.recorder.flush() + + def get_player(self, samples_per_frame=None): + return self.device.player(samplerate=self.samplerate, blocksize=samples_per_frame) + +def get_backend(): + if RNS.vendor.platformutils.is_linux(): + return LinuxBackend + else: + return None + +Backend = get_backend() + +class Sink(): + def handle_frame(self, frame, source): + pass + + def can_receive(self, from_source=None): + return True + +class RemoteSink(Sink): + pass + +class LocalSink(Sink): + pass + +class LineSink(LocalSink): + MAX_FRAMES = 6 + AUTOSTART_MIN = 1 + FRAME_TIMEOUT = 8 + + def __init__(self, preferred_device=None, autodigest=True): + self.preferred_device = preferred_device + self.frame_deque = deque(maxlen=self.MAX_FRAMES) + self.should_run = False + self.digest_thread = None + self.digest_lock = threading.Lock() + self.insert_lock = threading.Lock() + self.frame_deque = deque(maxlen=self.MAX_FRAMES) + self.underrun_at = None + self.frame_timeout = self.FRAME_TIMEOUT + self.autodigest = autodigest + self.autostart_min = self.AUTOSTART_MIN + self.buffer_max_height = self.MAX_FRAMES-3 + + self.preferred_samplerate = Backend.SAMPLERATE + self.backend = Backend(preferred_device=self.preferred_device, samplerate=self.preferred_samplerate) + self.samplerate = self.backend.samplerate + self.channels = self.backend.device.channels + + self.samples_per_frame = None + self.frame_time = None + self.output_latency = 0 + self.max_latency = 0 + + def can_receive(self, from_source=None): + with self.insert_lock: + if len(self.frame_deque) < self.buffer_max_height: + return True + else: + return False + + def handle_frame(self, frame, source=None): + with self.insert_lock: + self.frame_deque.append(frame) + + if self.samples_per_frame == None: + self.samples_per_frame = frame.shape[0] + self.frame_time = self.samples_per_frame*(1/self.backend.samplerate) + RNS.log(f"{self} starting at {self.samples_per_frame} samples per frame, {self.channels} channels", RNS.LOG_DEBUG) + + if self.autodigest and not self.should_run: + if len(self.frame_deque) >= self.autostart_min: + self.start() + + def start(self): + if not self.should_run: + self.should_run = True + self.digest_thread = threading.Thread(target=self.__digest_job, daemon=True) + self.digest_thread.start() + + def stop(self): + self.should_run = False + + def __digest_job(self): + with self.digest_lock: + with self.backend.get_player(samples_per_frame=self.samples_per_frame) as player: + while self.should_run: + frames_ready = len(self.frame_deque) + if frames_ready: + self.output_latency = len(self.frame_deque)*self.frame_time + self.max_latency = self.buffer_max_height*self.frame_time + self.underrun_at = None + + with self.insert_lock: frame = self.frame_deque.popleft() + if frame.shape[1] > self.channels: frame = frame[:, 0:self.channels] + player.play(frame) + + if len(self.frame_deque) > self.buffer_max_height: + RNS.log(f"Buffer lag on {self} (height {len(self.frame_deque)}), dropping one frame", RNS.LOG_DEBUG) + self.frame_deque.popleft() + + else: + if self.underrun_at == None: + # TODO: Remove debug + # RNS.log(f"Buffer underrun on {self}", RNS.LOG_DEBUG) + self.underrun_at = time.time() + else: + if time.time() > self.underrun_at+(self.frame_time*self.frame_timeout): + RNS.log(f"No frames available on {self}, stopping playback", RNS.LOG_DEBUG) + self.should_run = False + else: + time.sleep(self.frame_time*0.1) + +class PacketSink(RemoteSink): + pass \ No newline at end of file diff --git a/LXST/Sources.py b/LXST/Sources.py new file mode 100644 index 0000000..23e208c --- /dev/null +++ b/LXST/Sources.py @@ -0,0 +1,270 @@ +import os +import RNS +import math +import time +import threading +import numpy as np +from collections import deque +from .Sinks import LocalSink +from .Codecs import Codec, CodecError +from .Codecs.libs.pyogg import OpusFile + +RNS.loglevel = RNS.LOG_DEBUG + +class LinuxBackend(): + SAMPLERATE = 48000 + + def __init__(self, preferred_device=None, samplerate=SAMPLERATE): + import soundcard + self.samplerate = samplerate + self.soundcard = soundcard + if preferred_device: + try: self.device = self.soundcard.get_microphone(preferred_device) + except: self.device = self.soundcard.default_microphone() + else: self.device = self.soundcard.default_microphone() + self.channels = self.device.channels + self.bitdepth = 32 + RNS.log(f"Using input device {self.device}", RNS.LOG_DEBUG) + + def flush(self): + self.recorder.flush() + + def get_recorder(self, samples_per_frame): + return self.device.recorder(samplerate=self.SAMPLERATE, blocksize=samples_per_frame) + +def get_backend(): + if RNS.vendor.platformutils.is_linux(): + return LinuxBackend + else: + return None + +Backend = get_backend() + +class Source(): + pass + +class LocalSource(Source): + pass + +class RemoteSource(Source): + pass + +class Loopback(LocalSource, LocalSink): + MAX_FRAMES = 128 + + def __init__(self, target_frame_ms=70, codec=None, sink=None): + self.frame_deque = deque(maxlen=self.MAX_FRAMES) + self.should_run = False + self.loopback_thread = None + self.loopback_lock = threading.Lock() + self.codec = codec + self._sink = sink + self._source = None + + def start(self): + if not self.should_run: + RNS.log(f"{self} starting", RNS.LOG_DEBUG) + self.should_run = True + + def stop(self): + self.should_run = False + + def can_receive(self, from_source=None): + if self._sink: + return self._sink.can_receive(from_source) + else: + return True + + def handle_frame(self, frame, source): + with self.loopback_lock: + if self.codec and self.sink: + self.sink.handle_frame(self.codec.decode(frame), self) + + @property + def source(self): + return self._source + + @source.setter + def source(self, source): + self._source = source + +class LineSource(LocalSource): + MAX_FRAMES = 128 + DEFAULT_FRAME_MS = 80 + + def __init__(self, preferred_device=None, target_frame_ms=DEFAULT_FRAME_MS, codec=None, sink=None): + self.preferred_device = preferred_device + self.frame_deque = deque(maxlen=self.MAX_FRAMES) + self.target_frame_ms = target_frame_ms + self.samplerate = None + self.channels = None + self.bitdepth = None + self.should_run = False + self.ingest_thread = None + self.recording_lock = threading.Lock() + self._codec = None + self.codec = codec + self.sink = sink + + @property + def codec(self): + return self._codec + + @codec.setter + def codec(self, codec): + if codec == None: + self._codec = None + elif not issubclass(type(codec), Codec): + raise CodecError(f"Invalid codec specified for {self}") + else: + self._codec = codec + + if self.codec.preferred_samplerate: + self.preferred_samplerate = self.codec.preferred_samplerate + else: + self.preferred_samplerate = Backend.SAMPLERATE + + if self.codec.frame_quanta_ms: + if self.target_frame_ms%self.codec.frame_quanta_ms != 0: + self.target_frame_ms = math.ceil(self.target_frame_ms/self.codec.frame_quanta_ms)*self.codec.frame_quanta_ms + RNS.log(f"{self} target frame time quantized to {self.target_frame_ms}ms due to codec frame quanta", RNS.LOG_DEBUG) + + if self.codec.frame_max_ms: + if self.target_frame_ms > self.codec.frame_max_ms: + self.target_frame_ms = self.codec.frame_max_ms + RNS.log(f"{self} target frame time clamped to {self.target_frame_ms}ms due to codec frame limit", RNS.LOG_DEBUG) + + if self.codec.valid_frame_ms: + if not self.target_frame_ms in self.codec.valid_frame_ms: + self.target_frame_ms = min(self.codec.valid_frame_ms, key=lambda t:abs(t-self.target_frame_ms)) + RNS.log(f"{self} target frame time clamped to closest valid value of {self.target_frame_ms}ms ", RNS.LOG_DEBUG) + + self.backend = Backend(preferred_device=self.preferred_device, samplerate=self.preferred_samplerate) + self.samplerate = self.backend.samplerate + self.bitdepth = self.backend.bitdepth + self.channels = self.backend.channels + self.samples_per_frame = math.ceil((self.target_frame_ms/1000)*self.samplerate) + + def start(self): + if not self.should_run: + RNS.log(f"{self} starting at {self.samples_per_frame} samples per frame, {self.channels} channels", RNS.LOG_DEBUG) + self.should_run = True + self.ingest_thread = threading.Thread(target=self.__ingest_job, daemon=True) + self.ingest_thread.start() + + def stop(self): + self.should_run = False + + def __ingest_job(self): + with self.recording_lock: + frame_samples = None + with self.backend.get_recorder(samples_per_frame=self.samples_per_frame) as recorder: + while self.should_run: + frame_samples = recorder.record(numframes=self.samples_per_frame) + if self.codec: + frame = self.codec.encode(frame_samples) + if self.sink and self.sink.can_receive(from_source=self): + self.sink.handle_frame(frame, self) + +class OpusFileSource(LocalSource): + MAX_FRAMES = 128 + DEFAULT_FRAME_MS = 70 + TYPE_MAP_FACTOR = np.iinfo("int16").max + + def __init__(self, file_path, target_frame_ms=DEFAULT_FRAME_MS, loop=False, codec=None, sink=None, timed=False): + self.target_frame_ms = target_frame_ms + self.loop = loop + self.timed = timed + self.read_lock = threading.Lock() + self.should_run = False + self.ingest_thread = None + self.next_frame = None + self._codec = None + + if file_path == None: + raise TypeError(f"{self} initialised with invalid file path: {file_path}") + elif os.path.isfile(file_path): + self.file = OpusFile(file_path) + self.samplerate = self.file.frequency + self.channels = self.file.channels + self.bitdepth = 16 + self.samples = self.file.as_array()/self.TYPE_MAP_FACTOR + self.sample_count = self.samples.shape[0] + self.length_ms = (self.sample_count/self.samplerate)*1000 + RNS.log(f"{self} loaded {RNS.prettytime(self.length_ms/1000)} of audio from {file_path}", RNS.LOG_DEBUG) + RNS.log(f"{self} samplerate is {RNS.prettyfrequency(self.samplerate)}, {self.channels} channels, {self.sample_count} samples in total", RNS.LOG_DEBUG) + else: + raise OSError(f"{self} file {file_path} not found") + + self.codec = codec + self.sink = sink + + @property + def codec(self): + return self._codec + + @codec.setter + def codec(self, codec): + if codec == None: + self._codec = None + elif not issubclass(type(codec), Codec): + raise CodecError(f"Invalid codec specified for {self}") + else: + self._codec = codec + + if self.codec.frame_quanta_ms: + if self.target_frame_ms%self.codec.frame_quanta_ms != 0: + self.target_frame_ms = math.ceil(self.target_frame_ms/self.codec.frame_quanta_ms)*self.codec.frame_quanta_ms + RNS.log(f"{self} target frame time quantized to {self.target_frame_ms}ms due to codec frame quanta", RNS.LOG_DEBUG) + + if self.codec.frame_max_ms: + if self.target_frame_ms > self.codec.frame_max_ms: + self.target_frame_ms = self.codec.frame_max_ms + RNS.log(f"{self} target frame time clamped to {self.target_frame_ms}ms due to codec frame limit", RNS.LOG_DEBUG) + + if self.codec.valid_frame_ms: + if not self.target_frame_ms in self.codec.valid_frame_ms: + self.target_frame_ms = min(self.codec.valid_frame_ms, key=lambda t:abs(t-self.target_frame_ms)) + RNS.log(f"{self} target frame time clamped to closest valid value of {self.target_frame_ms}ms ", RNS.LOG_DEBUG) + + self.samples_per_frame = math.ceil((self.target_frame_ms/1000)*self.samplerate) + self.frame_time = self.samples_per_frame/self.samplerate + RNS.log(f"{self} frame time is {RNS.prettyshorttime(self.frame_time)}", RNS.LOG_DEBUG) + + def start(self): + if not self.should_run: + RNS.log(f"{self} starting at {self.samples_per_frame} samples per frame, {self.channels} channels", RNS.LOG_DEBUG) + self.should_run = True + self.ingest_thread = threading.Thread(target=self.__ingest_job, daemon=True) + self.ingest_thread.start() + + def stop(self): + self.should_run = False + + def __ingest_job(self): + with self.read_lock: + self.next_frame = time.time() + fi = 0; spf = self.samples_per_frame; sc = self.sample_count + while self.should_run: + if self.sink and self.sink.can_receive(from_source=self) and (not self.timed or time.time() >= self.next_frame): + self.next_frame = time.time()+self.frame_time + fi += 1 + fs = (fi-1)*spf; fe = min(fi*spf, sc) + frame_samples = self.samples[fs:fe, :] + if len(frame_samples) < 1: + if self.loop: + RNS.log(f"{self} exhausted file samples, looping...", RNS.LOG_DEBUG) + fi = 0 + else: + RNS.log(f"{self} exhausted file samples, stopping...", RNS.LOG_DEBUG) + self.should_run = False + else: + if self.codec: + frame = self.codec.encode(frame_samples) + if self.sink and self.sink.can_receive(from_source=self): + self.sink.handle_frame(frame, self) + else: + time.sleep(self.frame_time*0.1) + +class PacketSource(RemoteSource): + pass \ No newline at end of file diff --git a/LXST/Utilities/rnphone.py b/LXST/Utilities/rnphone.py new file mode 100644 index 0000000..e1d8814 --- /dev/null +++ b/LXST/Utilities/rnphone.py @@ -0,0 +1,787 @@ +#!/usr/bin/env python3 + +import RNS +import os +import sys +import time +import signal +import threading +import argparse + +from LXST._version import __version__ +from LXST.Primitives.Telephony import Telephone +from RNS.vendor.configobj import ConfigObj + +class ReticulumTelephone(): + STATE_AVAILABLE = 0x00 + STATE_CONNECTING = 0x01 + STATE_RINGING = 0x02 + STATE_IN_CALL = 0x03 + + HW_SLEEP_TIMEOUT = 15 + HW_STATE_IDLE = 0x00 + HW_STATE_DIAL = 0x01 + HW_STATE_SLEEP = 0xFF + KPD_NUMBERS = ["0","1","2","3","4","5","6","7","8","9"] + KPD_HEX_ALPHA = ["A","B","C","D","E","F"] + KPD_SYMBOLS = ["*","#"] + + RING_TIME = 30 + WAIT_TIME = 60 + PATH_TIME = 10 + + def __init__(self, configdir, rnsconfigdir, verbosity = 0, service = False): + self.service = service + self.configdir = configdir + self.config = None + self.should_run = False + self.telephone = None + self.state = self.STATE_AVAILABLE + self.hw_state = self.HW_STATE_IDLE + self.hw_last_event = time.time() + self.hw_input = "" + self.direction = None + self.last_input = None + self.first_run = False + self.ringtone_path = None + self.speaker_device = None + self.microphone_device = None + self.ringer_device = None + self.keypad = None + self.display = None + self.allowed = Telephone.ALLOW_ALL + self.allow_phonebook = False + self.allowed_list = [] + self.blocked_list = [] + self.phonebook = {} + self.aliases = {} + self.names = {} + self.reload_config() + self.main_menu() + + reticulum = RNS.Reticulum(configdir=rnsconfigdir, loglevel=3+verbosity) + self.telephone = Telephone(self.identity, ring_time=self.ring_time, wait_time=self.wait_time) + self.telephone.set_ringtone(self.ringtone_path) + self.telephone.set_ringing_callback(self.ringing) + self.telephone.set_established_callback(self.call_established) + self.telephone.set_ended_callback(self.call_ended) + self.telephone.set_speaker(self.speaker_device) + self.telephone.set_microphone(self.microphone_device) + self.telephone.set_ringer(self.ringer_device) + self.telephone.set_allowed(self.allowed) + self.telephone.set_blocked(self.blocked_list) + + def create_default_config(self): + rnphone_config = ConfigObj(__default_rnphone_config__.splitlines()) + rnphone_config.filename = self.configpath + rnphone_config.write() + + def reload_config(self): + if self.service: RNS.log("Loading configuration...", RNS.LOG_DEBUG) + if self.configdir == None: + if os.path.isdir("/etc/rnphone") and os.path.isfile("/etc/rnphone/config"): + self.configdir = "/etc/rnphone" + elif os.path.isdir(RNS.Reticulum.userdir+"/.config/rnphone") and os.path.isfile(Reticulum.userdir+"/.config/rnphone/config"): + self.configdir = RNS.Reticulum.userdir+"/.config/rnphone" + else: + self.configdir = RNS.Reticulum.userdir+"/.rnphone" + + self.configpath = self.configdir+"/config" + self.ignoredpath = self.configdir+"/ignored" + self.allowedpath = self.configdir+"/allowed" + self.identitypath = self.configdir+"/identity" + self.storagedir = self.configdir+"/storage" + + self.ring_time = ReticulumTelephone.RING_TIME + self.wait_time = ReticulumTelephone.WAIT_TIME + self.path_time = ReticulumTelephone.PATH_TIME + + if not os.path.isdir(self.storagedir): + os.makedirs(self.storagedir) + + if not os.path.isfile(self.configpath): + self.create_default_config() + self.first_run = True + + if os.path.isfile(self.configpath): + try: + self.config = ConfigObj(self.configpath) + except Exception as e: + RNS.log("Could not parse the configuration at "+self.configpath, RNS.LOG_ERROR) + RNS.log("Check your configuration file for errors!", RNS.LOG_ERROR) + RNS.panic() + + # Generate or load primary identity + if os.path.isfile(self.identitypath): + try: + self.identity = RNS.Identity.from_file(self.identitypath) + if self.identity != None: + pass + else: + RNS.log("Could not load the Primary Identity from "+self.identitypath, RNS.LOG_ERROR) + exit(1) + except Exception as e: + RNS.log("Could not load the Primary Identity from "+self.identitypath, RNS.LOG_ERROR) + RNS.log("The contained exception was: %s" % (str(e)), RNS.LOG_ERROR) + exit(1) + else: + try: + print("No primary identity file found, creating new...") + self.identity = RNS.Identity() + self.identity.to_file(self.identitypath) + print("Created new Primary Identity %s" % (str(self.identity))) + except Exception as e: + RNS.log("Could not create and save a new Primary Identity", RNS.LOG_ERROR) + RNS.log("The contained exception was: %s" % (str(e)), RNS.LOG_ERROR) + exit(1) + + self.apply_config() + + def __is_allowed(self, identity_hash): + if identity_hash in self.allowed_list: return True + else: return False + + def load_phonebook(self, phonebook): + if self.service: RNS.log("Loading phonebook...", RNS.LOG_DEBUG) + for name in phonebook: + alias = None + identity_hash = phonebook[name] + if type(identity_hash) == list: + components = identity_hash + identity_hash = components[0] + alias_input = components[1] + alias = "" + for c in alias_input: + if c in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]: + alias += c + if len(alias) == 0: alias = None + + if len(identity_hash) == RNS.Reticulum.TRUNCATED_HASHLENGTH//8*2: + if identity_hash != RNS.hexrep(self.identity.hash, delimit=False): + try: + hash_bytes = bytes.fromhex(identity_hash) + self.phonebook[name] = identity_hash + self.names[identity_hash] = name + if alias: self.aliases[identity_hash] = alias + if self.allow_phonebook: self.allowed_list.append(hash_bytes) + except Exception as e: + RNS.log(f"Could not load phonebook entry for {name}: {e}", RNS.LOG_ERROR) + + def apply_config(self): + if "telephone" in self.config: + config = self.config["telephone"] + if "ringtone" in config: self.ringtone_path = os.path.join(self.configdir, config["ringtone"]) + if "speaker" in config: self.speaker_device = config["speaker"] + if "microphone" in config: self.microphone_device = config["microphone"] + if "ringer" in config: self.ringer_device = config["ringer"] + if "allowed_callers" in config: + allowed_callers = config["allowed_callers"] + if str(allowed_callers).lower() == "all": self.allowed = Telephone.ALLOW_ALL + elif str(allowed_callers).lower() == "none": self.allowed = Telephone.ALLOW_NONE + elif str(allowed_callers).lower() == "phonebook": + self.allow_phonebook = True + self.allowed = self.__is_allowed + elif type(config["allowed_callers"]) == list: + self.allowed = self.__is_allowed + for identity_hash in config["allowed_callers"]: + if len(identity_hash) == RNS.Reticulum.TRUNCATED_HASHLENGTH//8*2: + if identity_hash != RNS.hexrep(self.identity.hash, delimit=False): + try: hash_bytes = bytes.fromhex(identity_hash) + except Exception as e: RNS.log(f"Could not load allowed caller entry {identity_hash}: {e}", RNS.LOG_ERROR) + self.allowed_list.append(hash_bytes) + + if "blocked_callers" in config: + blocked_callers = config["blocked_callers"] + if not type(blocked_callers) == list: blocked_callers = [blocked_callers] + if len(blocked_callers) > 0: + for identity_hash in blocked_callers: + if len(identity_hash) == RNS.Reticulum.TRUNCATED_HASHLENGTH//8*2: + if identity_hash != RNS.hexrep(self.identity.hash, delimit=False): + try: hash_bytes = bytes.fromhex(identity_hash) + except Exception as e: RNS.log(f"Could not load blocked caller entry {identity_hash}: {e}", RNS.LOG_ERROR) + self.blocked_list.append(hash_bytes) + + if "phonebook" in self.config: + self.load_phonebook(self.config["phonebook"]) + + if "hardware" in self.config: + config = self.config["hardware"] + if "keypad" in config: + self.enable_keypad(config["keypad"].lower()) + if "keypad_hook_pin" in config: self.enable_hook(pin = config.as_int("keypad_hook_pin")) + if "display" in config: self.enable_display(config["display"].lower()) + + self.last_dialled_identity_hash = None + + def enable_keypad(self, driver): + if self.service: RNS.log(f"Starting keypad: {driver}", RNS.LOG_DEBUG) + if driver == "gpio_4x4": + from LXST.Primitives.hardware.keypad_gpio_4x4 import Keypad + self.keypad = Keypad(callback=self._keypad_event) + self.keypad.start() + else: raise OSError("Unknown keypad driver specified") + + def enable_hook(self, pin=None): + if self.keypad: self.keypad.enable_hook(pin=pin) + + def enable_display(self, driver): + if self.service: RNS.log(f"Starting display: {driver}", RNS.LOG_DEBUG) + if self.display == None: + if driver == "i2c_lcd1602": + from LXST.Primitives.hardware.display_i2c_lcd1602 import LCD + self.display = LCD() + else: raise OSError("Unknown display driver specified") + + if self.display: + threading.Thread(target=self._display_job, daemon=True).start() + + @property + def is_available(self): + return self.state == self.STATE_AVAILABLE + + @property + def is_in_call(self): + return self.state == self.STATE_IN_CALL + + @property + def is_ringing(self): + return self.state == self.STATE_RINGING + + @property + def call_is_connecting(self): + return self.state == self.STATE_CONNECTING + + @property + def hw_is_idle(self): + return self.hw_state == self.HW_STATE_IDLE + + @property + def hw_is_dialing(self): + return self.hw_state == self.HW_STATE_DIAL + + def start(self): + if not self.should_run: + signal.signal(signal.SIGINT, self.sigint_handler) + signal.signal(signal.SIGTERM, self.sigterm_handler) + self.telephone.announce() + self.should_run = True + self.run() + + def stop(self): + self.should_run = False + + def dial(self, identity_hash): + self.last_dialled_identity_hash = identity_hash + self.telephone.set_busy(True) + identity_hash = bytes.fromhex(identity_hash) + destination_hash = RNS.Destination.hash_from_name_and_identity("lxst.telephony", identity_hash) + if not RNS.Transport.has_path(destination_hash): + RNS.Transport.request_path(destination_hash) + if self.display: self.display.print("Finding path...", x=0, y=0) + def spincheck(): + return RNS.Transport.has_path(destination_hash) + self.__spin(spincheck, "Requesting path for call to "+RNS.prettyhexrep(identity_hash), self.path_time) + if not spincheck(): + print("Path request timed out") + if self.display: + self.display.print("Finding path", x=0, y=0) + self.display.print("timed out", x=0, y=1) + time.sleep(1.5) + self.became_available() + + self.telephone.set_busy(False) + if RNS.Transport.has_path(destination_hash): + call_hops = RNS.Transport.hops_to(destination_hash) + cs = "" if call_hops == 1 else "s" + print(f"Connecting call over {call_hops} hop{cs}...") + if self.display: + call_hops_str = f"({call_hops}h{cs})" + call_str = "Calling"; ns = self.display.COLS-(len(call_str)+len(call_hops_str)); s = " "*ns + disp_str = f"{call_str}{s}{call_hops_str}" + self.display.print(disp_str, x=0, y=0) + + identity = RNS.Identity.recall(destination_hash) + self.call(identity) + else: + self.became_available() + + def redial(self, args=None): + if self.last_dialled_identity_hash: self.dial(self.last_dialled_identity_hash) + + def call(self, remote_identity): + print(f"Calling {RNS.prettyhexrep(remote_identity.hash)}...") + self.state = self.STATE_CONNECTING + self.caller = remote_identity + self.direction = "to" + self.telephone.call(self.caller) + + def ringing(self, remote_identity): + if self.hw_state == self.HW_STATE_SLEEP: self.hw_state = self.HW_STATE_IDLE + self.state = self.STATE_RINGING + self.caller = remote_identity + self.direction = "from" if self.direction == None else "to" + print(f"\n\nIncoming call from {RNS.prettyhexrep(self.caller.hash)}") + print(f"Hit enter to answer, {Terminal.BOLD}r{Terminal.END} to reject") + if self.display: + hash_str = RNS.hexrep(self.caller.hash, delimit=False) + if hash_str in self.aliases: + remote_alias = self.aliases[hash_str] + remote_name = self.names[hash_str] + self.display.print(remote_name, x=0, y=0) + self.display.print(f"({remote_alias})".rjust(self.display.COLS," "), x=0, y=1) + + else: + self.display.print(hash_str[:16], x=0, y=0) + self.display.print(hash_str[16:], x=0, y=1) + + def call_ended(self, remote_identity): + if self.is_in_call or self.is_ringing or self.call_is_connecting: + if self.is_in_call: print(f"Call with {RNS.prettyhexrep(self.caller.hash)} ended\n") + if self.is_ringing: print(f"Call {self.direction} {RNS.prettyhexrep(self.caller.hash)} was not answered\n") + if self.call_is_connecting: print(f"Call to {RNS.prettyhexrep(self.caller.hash)} could not be connected\n") + self.direction = None + self.state = self.STATE_AVAILABLE + self.became_available() + + def call_established(self, remote_identity): + if self.call_is_connecting or self.is_ringing: + self.state = self.STATE_IN_CALL + print(f"Call established with {RNS.prettyhexrep(self.caller.hash)}") + self.display_call_status() + + def display_call_status(self): + def job(): + started = time.time() + erase_str = "" + while self.state == self.STATE_IN_CALL: + elapsed = round(time.time()-started) + time_string = RNS.prettytime(elapsed) + stat_string = f"In call for {time_string}, hit enter to hang up " + print(f"\r{stat_string}", end="") + erase_string = " "*len(stat_string) + sys.stdout.flush() + print(f"\r{erase_str}", end="") + + if self.display: + self.display.print("Call connected", x=0, y=0) + self.display.print(f"{time_string}", x=0, y=1) + time.sleep(1.00) + else: + time.sleep(0.25) + + print(f"\r{erase_str}> ", end="") + + threading.Thread(target=job, daemon=True).start() + + def became_available(self): + if not self.service: + if self.is_available and self.first_run: + hs = "" + if not hasattr(self, "first_prompt"): hs = " (or ? for help)"; self.first_prompt = True + print(f"Enter identity hash and hit enter to call{hs}\n", end="") + print("> ", end="") + sys.stdout.flush() + + if self.display: + self.display.clear() + self.display.print("Telephone Ready", x=0, y=0) + self.display.print("", x=0, y=1) + + if self.display or self.keypad: + self.hw_last_event = time.time() + self.hw_input = "" + self.hw_state = self.HW_STATE_IDLE + + def print_identity(self, args): + print(f"Identity hash of this telephone: {RNS.prettyhexrep(self.identity.hash)}\n") + + def print_destination(self, args): + print(f"Destination hash of this telephone: {RNS.prettyhexrep(self.telephone.destination.hash)}\n") + + def phonebook_menu(self, args=None): + if len(self.phonebook) < 1: + print("\nNo entries in phonebook\n") + else: + def exit_menu(args=None): + print("Phonebook closed") + self.main_menu() + + def dial_factory(identity_hash): + def x(args=None): self.dial(identity_hash) + return x + + print("") + print(f"{Terminal.UNDERLINE}Phonebook{Terminal.END}") + + self.active_menu = {} + maxaliaslen = 0 + for identity_hash in self.aliases: maxaliaslen = max(maxaliaslen, len(self.aliases[identity_hash])) + maxlen = 0; maxnlen = max(maxaliaslen, len(str(len(self.phonebook)))); n = 0 + for name in self.phonebook: maxlen = max(maxlen, len(name)) + for name in self.phonebook: + n += 1; identity_hash = self.phonebook[name] + alias = n + if identity_hash in self.aliases: + alias = self.aliases[identity_hash] + spaces = maxlen-len(name); nspaces = maxnlen-len(str(alias)); s = " " + print(f" {Terminal.BOLD}{s*nspaces}{alias}{Terminal.END} {name}{s*spaces} : <{identity_hash}>") + self.active_menu[f"{alias}"] = dial_factory(identity_hash) + + print(f" {Terminal.BOLD}b{Terminal.END}ack{s*(max(0, maxlen+maxnlen-2))}: Back to main menu\n") + self.active_menu["b"] = exit_menu + self.active_menu["back"] = exit_menu + self.active_menu["q"] = exit_menu + self.active_menu["quit"] = exit_menu + + def main_menu(self, args=None): + def m_help(argv): + print("") + print(f"{Terminal.UNDERLINE}Available commands{Terminal.END}") + print(f" {Terminal.BOLD}p{Terminal.END}honebook : Open the phonebook") + print(f" {Terminal.BOLD}r{Terminal.END}edial : Call the last called identity again") + print(f" {Terminal.BOLD}i{Terminal.END}dentity : Display the identity hash of this telephone") + print(f" {Terminal.BOLD}d{Terminal.END}esthash : Display the destination hash of this telephone") + print(f" {Terminal.BOLD}a{Terminal.END}nnounce : Send an announce from this telephone") + print(f" {Terminal.BOLD}q{Terminal.END}uit : Exit the program") + print(f" {Terminal.BOLD}h{Terminal.END}elp : This help menu") + print("") + + def m_quit(argv): + self.quit() + + def m_announce(argv): + self.telephone.announce() + print(f"Announce sent") + + self.active_menu = {"help": m_help, + "h": m_help, + "?": m_help, + "p": self.phonebook_menu, + "phonebook": self.phonebook_menu, + "r": self.redial, + "i": self.print_identity, + "identity": self.print_identity, + "d": self.print_destination, + "desthash": self.print_destination, + "a": m_announce, + "anounce": m_announce, + "redial": self.redial, + "exit": m_quit, + "quit": m_quit, + "q": m_quit} + + def run(self): + if self.service: + print(f"Reticulum Telephone Service is ready") + print(f"Identity hash: {RNS.prettyhexrep(self.identity.hash)}") + else: + print(f"\n{Terminal.BOLD}Reticulum Telephone Utility is ready{Terminal.END}") + print(f" Identity hash: {RNS.prettyhexrep(self.identity.hash)}\n") + + if self.service: + self.became_available() + while self.should_run: + time.sleep(0.5) + + else: + while self.should_run: + if self.is_available: + if self.last_input and len(self.last_input) == RNS.Reticulum.TRUNCATED_HASHLENGTH//8*2: + if self.is_available: + try: + self.dial(self.last_input) + + except Exception as e: + print(f"Invalid identity hash: {e}\n") + RNS.trace_exception(e) + + elif self.last_input and self.last_input.split(" ")[0] in self.active_menu: + self.active_menu[self.last_input.split(" ")[0]](self.last_input.split(" ")[1:]) + self.became_available() + + else: + self.became_available() + + elif self.is_ringing: + if self.last_input == "": + print(f"Answering call from {RNS.prettyhexrep(self.caller.hash)}") + if not self.telephone.answer(self.caller): + print(f"Could not answer call from {RNS.prettyhexrep(self.caller.hash)}") + else: + print(f"Rejecting call from {RNS.prettyhexrep(self.caller.hash)}") + self.telephone.hangup() + + elif self.is_in_call or self.call_is_connecting: + print(f"Hanging up call with {RNS.prettyhexrep(self.caller.hash)}") + self.telephone.hangup() + + self.last_input = input() + + def cleanup(self): + if self.display: self.display.close() + if self.keypad: self.keypad.stop() + + def quit(self): + self.cleanup() + exit(0) + + def __spin(self, until=None, msg=None, timeout=None): + i = 0 + syms = "⢄⢂⢁⡁⡈⡐⡠" + if timeout != None: + timeout = time.time()+timeout + + print(msg+" ", end=" ") + while (timeout == None or time.time() timeout: + return False + else: + return True + + def _display_job(self): + while self.display: + now = time.time() + if self.is_available and self.hw_is_idle and (self.telephone and not self.telephone.busy): + if now - self.hw_last_event >= self.HW_SLEEP_TIMEOUT: + self.hw_state = self.HW_STATE_SLEEP + self._sleep_display() + + time.sleep(1) + + def _sleep_display(self): + if self.display: self.display.sleep() + + def _wake_display(self): + if self.display: self.display.wake() + + def _update_display(self): + if self.display: + if self.hw_is_dialing: + if len(self.hw_input) == 0: lookup_name = "Enter number" + else: lookup_name = "Unknown" + + for identity_hash in self.aliases: + alias = self.aliases[identity_hash] + if self.hw_input == alias: lookup_name = self.names[identity_hash] + + self.display.print(f"{self.hw_input}", x=0, y=0) + self.display.print(f"{lookup_name}", x=0, y=1) + + + + def _keypad_event(self, keypad, event): + self.hw_last_event = time.time() + if self.hw_state == self.HW_STATE_SLEEP: + self.hw_state = self.HW_STATE_IDLE + self._wake_display() + self.became_available() + + if self.is_ringing: + answer_events = event[0] == "D" and event[1] == self.keypad.ec.DOWN + answer_events |= event[0] == "hook" and event[1] == self.keypad.ec.UP + if answer_events: + print(f"Answering call from {RNS.prettyhexrep(self.caller.hash)}") + if not self.telephone.answer(self.caller): + print(f"Could not answer call from {RNS.prettyhexrep(self.caller.hash)}") + elif event[0] == "C" and event[1] == self.keypad.ec.DOWN: + print(f"Rejecting call from {RNS.prettyhexrep(self.caller.hash)}") + self.telephone.hangup() + + elif self.is_in_call or self.call_is_connecting: + hangup_events = event[0] == "D" and event[1] == self.keypad.ec.DOWN + hangup_events |= event[0] == "hook" and event[1] == self.keypad.ec.DOWN + if hangup_events: + print(f"Hanging up call with {RNS.prettyhexrep(self.caller.hash)}") + self.telephone.hangup() + + elif self.is_available and self.hw_is_idle: + if event[0] == "A" and event[1] == self.keypad.ec.DOWN: + self.hw_input = ""; self.hw_state = self.HW_STATE_DIAL + self._update_display() + + if event[0] in self.KPD_NUMBERS and event[1] == self.keypad.ec.DOWN: + self.hw_input += event[0]; self.hw_state = self.HW_STATE_DIAL + self._update_display() + + elif self.is_available and self.hw_is_dialing: + dial_event = False + if event[1] == self.keypad.ec.DOWN: + if event[0] in self.KPD_NUMBERS: self.hw_input += event[0] + if event[0] == "A": self.became_available() + if event[0] == "B": self.hw_input = self.hw_input[:-1] + if event[0] == "C": self.hw_input = "" + if event[0] == "D": dial_event = True + + if event[0] == "hook" and event[1] == self.keypad.ec.UP: dial_event = True + + if dial_event: + for identity_hash in self.aliases: + alias = self.aliases[identity_hash] + if self.hw_input == alias: + self.hw_input = "" + self.hw_state = self.HW_STATE_IDLE + self.dial(identity_hash) + + self._update_display() + + def sigint_handler(self, signal, frame): + self.cleanup() + exit(0) + + def sigterm_handler(self, signal, frame): + self.cleanup() + exit(0) + +def main(): + app = None + try: + parser = argparse.ArgumentParser(description="Reticulum Telephone Utility") + + parser.add_argument("-l", "--list-devices", action="store_true", help="list available audio devices", default=False) + parser.add_argument("--config", action="store", default=None, help="path to config directory", type=str) + parser.add_argument("--rnsconfig", action="store", default=None, help="path to alternative Reticulum config directory", type=str) + parser.add_argument("-s", "--service", action="store_true", help="run as a service", default=False) + parser.add_argument("--systemd", action="store_true", help="display example systemd unit", default=False) + parser.add_argument("--version", action="version", version="rnprobe {version}".format(version=__version__)) + parser.add_argument('-v', '--verbose', action='count', default=0) + + args = parser.parse_args() + + if args.list_devices: + import LXST + RNS.loglevel = 0 + print("\nAvailable audio devices:") + for device in LXST.Sources.Backend().soundcard.all_speakers(): print(f" Output : {device}") + for device in LXST.Sinks.Backend().soundcard.all_microphones(): print(f" Input : {device}") + exit(0) + + if args.systemd: + print("To install rnphone as a system service, paste the") + print("systemd unit configuration below into a new file at:\n") + print("/etc/systemd/system/rnphone.service\n") + print("Then enable the service at boot by running:\n\nsudo systemctl enable rnphone\n") + print("--- begin systemd unit snipped ---\n") + print(__systemd_unit__.replace("USERNAME", os.getlogin())) + print("--- end systemd unit snipped ---\n") + exit(0) + + ReticulumTelephone(configdir = args.config, + rnsconfigdir = args.rnsconfig, + verbosity = args.verbose, + service = args.service).start() + + except KeyboardInterrupt: + if app: app.quit() + print("") + exit() + +__default_rnphone_config__ = """# This is an example rnphone config file. +# You should probably edit it to suit your +# intended usage. + +[telephone] + # You can define the ringtone played when the + # phone is ringing. Must be in OPUS format, and + # located in the rnphone config directory. + + ringtone = ringtone.opus + + # You can define the preferred audio devices + # to use as the speaker output, ringer output + # and microphone input. The names do not have + # to be an exact match to your full soundcard + # device name, but will be fuzzy matched. + # You can list available device names with: + # rnphone -l + + # speaker = device name + # microphone = device name + # ringer = device name + + # You can configure who is allowed to call + # this telephone. This can be set to either + # "all", "none", "phonebook" or a list of + # identity hashes. See examples below. + + # allowed_callers = all + # allowed_callers = none + # allowed_callers = phonebook + # allowed_callers = b8d80b1b7a9d3147880b366995422a45, fcfb80d4cd3aab7c8710541fb2317974 + + # It is also possible to block specific + # callers on a per-identity basis. + + # blocked_callers = f3e8c3359b39d36f3baff0a616a73d3e, 5d2d14619dfa0ff06278c17347c14331 + +[phonebook] + # You can add entries to the phonebook for + # quick dialling by adding them here + + # Mary = f3e8c3359b39d36f3baff0a616a73d3e + # Jake = b8d80b1b7a9d3147880b366995422a45 + # Dean = 05d4c6697bb38e5458a3077571157bfa + + # You can optionally specify a numerical + # alias for calling with a physical keypad + + # Rudy = 5d2d14619dfa0ff06278c17347c14331, 241 + # Josh = fcfb80d4cd3aab7c8710541fb2317974, 7907 + +[hardware] + # If the required hardware is connected, and + # the neccessary modules installed, you can + # enable various hardware components. + + # keypad = gpio_4x4 + # display = i2c_lcd1602 + + # If you have a keypad connected, you can + # also enable a GPIO pin for detecting + # on-hook/off-hook status + + # keypad_hook_pin = 5 + + # You can configure a pin for muting the + # ringer amplifier, if available + + # amp_mute_pin = 25 + # amp_mute_level = high +""" + +__systemd_unit__ = """# This systemd unit allows installing rnphone +# as a system service on Linux-based devices +[Unit] +Description=Reticulum Telephone Service +After=sound.target + +[Service] +# Wait 30 seconds for WiFi and audio +# hardware to initialise. +ExecStartPre=/bin/sleep 30 +Type=simple +Environment="DISPLAY=:0" +Environment="XAUTHORITY=/home/USERNAME/.Xauthority" +Environment="XDG_RUNTIME_DIR=/run/user/1000" +Restart=always +RestartSec=5 +User=USERNAME +ExecStart=/home/USERNAME/.local/bin/rnphone --service -vvv + +[Install] +WantedBy=graphical.target +""" + +class Terminal(): + UNDERLINE = "\033[4m" + BOLD = "\033[1m" + END = "\033[0m" + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/LXST/__init__.py b/LXST/__init__.py new file mode 100644 index 0000000..97a0d90 --- /dev/null +++ b/LXST/__init__.py @@ -0,0 +1,7 @@ +APP_NAME = "lxst" + +from .Pipeline import Pipeline +from .Mixer import Mixer +from .Sources import * +from .Generators import * +from .Primitives import * \ No newline at end of file diff --git a/LXST/_version.py b/LXST/_version.py new file mode 100644 index 0000000..7a17bdd --- /dev/null +++ b/LXST/_version.py @@ -0,0 +1 @@ +__version__ = "0.2.4" \ No newline at end of file diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..b4b0a82 --- /dev/null +++ b/Makefile @@ -0,0 +1,30 @@ +all: release + +clean: + @echo Cleaning... + -rm -r ./build + -rm -r ./dist + +remove_symlinks: + @echo Removing symlinks for build... + -rm ./RNS + -rm ./LXST/Utilities/LXST + -rm ./examples/LXST + +create_symlinks: + @echo Creating symlinks... + -ln -s ../Reticulum/RNS ./ + -ln -s ../../LXST/ ./LXST/Utilities/LXST + -ln -s ../LXST/ ./examples/LXST + +build_wheel: + python3 setup.py sdist bdist_wheel + +release: remove_symlinks build_wheel create_symlinks + +upload: + @echo Ready to publish release, hit enter to continue + @read VOID + @echo Uploading to PyPi... + twine upload dist/* + @echo Release published diff --git a/README.md b/README.md new file mode 100644 index 0000000..84ac2b4 --- /dev/null +++ b/README.md @@ -0,0 +1,49 @@ +# Lightweight Extensible Signal Transport + +LXST is a simple and flexible real-time streaming format and delivery protocol that allows a wide variety of implementations, while using as little bandwidth as possible. It is built on top of [Reticulum](https://reticulum.network) and offers zero-conf stream routing, end-to-end encryption and Forward Secrecy, and can be transported over any kind of medium that Reticulum supports. + +- Provides a variety of ready-to-use primitives, for easily creating applications such as: + - Telephony and live voice calls + - Two-way radio systems + - Direct peer-to-peer radio communications + - Trunked and routed real-time radio systems + - Media streaming + - Broadcast radio + - Public address systems +- Can handle real-time signal streams with end-to-end latencies below 10 milliseconds +- Supports encoding and decoding stream contents with a range of different codecs + - Raw and lossless streams with arbitrary sample rates + - Up to 32 channels + - Up to 128-bit sample precision + - Efficient, high-quality voice and audio with OPUS + - Many different built-in profiles, from ~4.5kbps to ~96kbps + - Profiles are pre-tuned for different applications, such as: + - Low-bandwidth voice + - Medium quality voice + - High quality, perceptually lossless voice + - Media content such as podcasts + - Perceptually lossless stereo music + - Ultra low-bandwidth voice communications with Codec2 + - Provides intelligible voice between 700bps and 3200bps +- Can dynamically switch codecs mid-stream without stream re-initialization or frame loss +- Has in-band signalling support for call signalling, communications, metadata embedding, media and stream management +- Uses a fully staged signal pipelining, allowing arbitrary stream routing +- Provides built-in signal mixing support for any number of channels + +## Transport Encryption + +LXST uses encryption provided by [Reticulum](https://reticulum.network), and thus provides end-to-end encryption, guaranteed data integrity and authenticity, as well as forward secrecy by default. + +## Project Status & License + +This software is in a very early alpha state, and will change rapidly with ongoing development. Consider no APIs stable. Consider everything explosive. + +While under early development, the project is kept under a `CC BY-NC-ND 4.0` license. + +## Installation + +If you want to try out LXST, you can install it with pip: + +```bash +pip install lxst +``` diff --git a/docs/425.opus b/docs/425.opus new file mode 100644 index 0000000000000000000000000000000000000000..5dc13a9b3ce658a9a4a81938290eaf30bc5ff33f GIT binary patch literal 967538 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¥erCwFNSB&SDM2hPg22wU-G@py1sbHBVuZ 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

+Q|mkcz{ROR`Yk5k1u!z==+Aug7k-D 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

luo=_Vj+APUeWcmdG&c#ovW44=-?U?#!a1$W4CJ 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 z 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 literal 0 HcmV?d00001 diff --git a/examples/mixer.py b/examples/mixer.py new file mode 100644 index 0000000..7d5f20f --- /dev/null +++ b/examples/mixer.py @@ -0,0 +1,51 @@ +import RNS +import LXST +import sys +import time +RNS.loglevel = RNS.LOG_DEBUG + +target_frame_ms = 20 +pipelined_output = True +raw = LXST.Codecs.Raw() + +# Pipelined mixer example +if pipelined_output: + opus = LXST.Codecs.Opus(profile=LXST.Codecs.Opus.PROFILE_AUDIO_HIGH) + codec2 = LXST.Codecs.Codec2(mode=LXST.Codecs.Codec2.CODEC2_3200) + line_sink = LXST.Sinks.LineSink() + mixer = LXST.Mixer(target_frame_ms=target_frame_ms) + loopback = LXST.Sources.Loopback() + + codec = opus + + file_source1 = LXST.Sources.OpusFileSource("./docs/speech_stereo.opus", codec=raw, sink=mixer, loop=True, target_frame_ms=target_frame_ms) + file_source2 = LXST.Sources.OpusFileSource("./docs/podcast.opus", codec=raw, sink=mixer, loop=True, target_frame_ms=target_frame_ms) + line_source = LXST.Sources.LineSource(target_frame_ms=target_frame_ms, codec=raw, sink=mixer) + + input_pipeline = LXST.Pipeline(source=mixer, codec=codec, sink=loopback) + output_pipeline = LXST.Pipeline(source=loopback, codec=codec, sink=line_sink) + input_pipeline.start(); output_pipeline.start() + +# Simple mixer example with output directly to sink +else: + line_sink = LXST.Sinks.LineSink() + mixer = LXST.Mixer(target_frame_ms=target_frame_ms, sink=line_sink) + file_source1 = LXST.Sources.OpusFileSource("./docs/speech_stereo.opus", codec=raw, sink=mixer, loop=True, target_frame_ms=target_frame_ms) + file_source2 = LXST.Sources.OpusFileSource("./docs/podcast.opus", codec=raw, sink=mixer, loop=True, target_frame_ms=target_frame_ms) + line_source = LXST.Sources.LineSource(target_frame_ms=target_frame_ms, codec=raw, sink=mixer) + +mixer.start() +line_source.start() +print("Hit enter to add another source"); input() + +file_source1.start() +print("Hit enter to add another source"); input() + +file_source2.start() +print("Hit enter to stop all sources"); input() + +file_source1.stop() +file_source2.stop() +line_source.stop() + +time.sleep(0.5) \ No newline at end of file diff --git a/examples/pipelines.py b/examples/pipelines.py new file mode 100644 index 0000000..00b8ae7 --- /dev/null +++ b/examples/pipelines.py @@ -0,0 +1,48 @@ +import RNS +import LXST +import sys +import time +RNS.loglevel = RNS.LOG_DEBUG + +if len(sys.argv) < 2: + print("No codec specified") + sys.exit(0) +else: + selected_codec = sys.argv[1] + +if len(sys.argv) >= 4: + target_frame_ms = int(sys.argv[3]) +else: + target_frame_ms = 40 + +if len(sys.argv) >= 3 and sys.argv[2].lower() == "file": + selected_source = LXST.Sources.OpusFileSource("./docs/speech_stereo.opus", loop=True, target_frame_ms=target_frame_ms) + # selected_source = LXST.Sources.OpusFileSource("./docs/music_stereo.opus", loop=True, target_frame_ms=target_frame_ms) + # selected_source = LXST.Sources.OpusFileSource("./docs/podcast.opus", loop=True, target_frame_ms=target_frame_ms) +else: + selected_source = LXST.Sources.LineSource(target_frame_ms=target_frame_ms) + +line_sink = LXST.Sinks.LineSink() +loopback = LXST.Sources.Loopback() + +if selected_codec.lower() == "raw": + raw = LXST.Codecs.Raw() + input_pipeline = LXST.Pipeline(source=selected_source, codec=raw, sink=loopback) + output_pipeline = LXST.Pipeline(source=loopback, codec=raw, sink=line_sink) +elif selected_codec.lower() == "codec2": + codec2 = LXST.Codecs.Codec2(mode=LXST.Codecs.Codec2.CODEC2_1600) + input_pipeline = LXST.Pipeline(source=selected_source, codec=codec2, sink=loopback) + output_pipeline = LXST.Pipeline(source=loopback, codec=codec2, sink=line_sink) +elif selected_codec.lower() == "opus": + opus = LXST.Codecs.Opus(profile=LXST.Codecs.Opus.PROFILE_VOICE_LOW) + input_pipeline = LXST.Pipeline(source=selected_source, codec=opus, sink=loopback) + output_pipeline = LXST.Pipeline(source=loopback, codec=opus, sink=line_sink) +else: + print("No valid codec selected") + sys.exit(0) + +input_pipeline.start(); output_pipeline.start() +input() +input_pipeline.stop() + +time.sleep(1) \ No newline at end of file diff --git a/examples/tone_generator.py b/examples/tone_generator.py new file mode 100644 index 0000000..a7128f5 --- /dev/null +++ b/examples/tone_generator.py @@ -0,0 +1,15 @@ +import RNS +import LXST +import sys +import time +RNS.loglevel = RNS.LOG_DEBUG + +target_frame_ms = 40 +tone = LXST.Generators.ToneSource(frequency=388, ease_time_ms=3.14159, target_frame_ms=target_frame_ms) +line_sink = LXST.Sinks.LineSink() +output_pipeline = LXST.Pipeline(source=tone, codec=LXST.Codecs.Null(), sink=line_sink) + +output_pipeline.start(); input() +tone.stop() + +time.sleep(1) \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..b7fd8e6 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +soundcard +numpy +pycodec2 \ No newline at end of file diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..fa9c5e2 --- /dev/null +++ b/setup.py @@ -0,0 +1,42 @@ +import setuptools + +with open("README.md", "r") as fh: + long_description = fh.read() + +exec(open("LXST/_version.py", "r").read()) + +packages = setuptools.find_packages(exclude=[]) +packages.append("LXST.Utilities") +packages.append("LXST.Primitives.hardware") +packages.append("LXST.Codecs.libs.pydub") +packages.append("LXST.Codecs.libs.pyogg") +print("Packages:") +print(packages) + +setuptools.setup( + name="lxst", + version=__version__, + author="Mark Qvist", + author_email="mark@unsigned.io", + description="Lightweight Extensible Signal Transport for Reticulum", + long_description=long_description, + long_description_content_type="text/markdown", + url="https://git.unsigned.io/markqvist/lxst", + packages=packages, + classifiers=[ + "Programming Language :: Python :: 3", + "License :: Other/Proprietary License", + "Operating System :: OS Independent", + ], + entry_points= { + 'console_scripts': [ + 'rnphone=LXST.Utilities.rnphone:main', + ] + }, + install_requires=["rns>=0.9.2", + "soundcard", + "numpy", + "pycodec2", + "audioop-lts>=0.2.1;python_version>='3.13'"], + python_requires=">=3.7", +) \ No newline at end of file

F7ib{^r5#8!n-_i7T75U=_oHct#9I--;vOwL$> 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 {s5xtcKz^<`1X()J5BXAa)#xM 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¹}zC2 z*nT_ynU?*7U!|bswR0~)PiV%=sxuZi_OETlb& zT(?Sz^g`3+u;dCe)-&@{@aa!R&mZWt*j)UC#MViNu4Y+cd5?MpoQ#1@X%QLu!OXNO zboXF!TpbDMc2${W-=ku^k)9BGbz8|mM;qc{ihhSfddqmT6;!1n)eO~L>$eNvuX0Fy&mr#kir%u+^w#2sUJau{lO?i3k^ z7~4pM4;^wdWh+K5EgtT@+~!-EaWHEOR5zfHVUrsY@rE~ru9k2%qr-u4 zDA0!XMRzg0q8>_5A+NXS7q4LOfD-Wz{4JIrfbmdnGonQRIcz?mGr?ViXx1$|SIETF zCWIh<(PaXUqD_Cw=lGI|f2&g95c|djghhhsI%280M`&h%?pFb)B+*!U@tEgpx8@%M zZA$viw^3rGAAtk8F3ou^Z&Ul!j%Ce369+PeLZ2xGC5`TyhhR`P^3Jsn?<)e5iEm-p^IIo=s#-HPjEUPA;7R0lnwc;5>s}3s-&S#fb_%UqMi9m|S_x}O2|HTA< z`}4s4IME3Lq~u&Eh+o@?6){pd^LwEcN&~oEY&_W}V8J|bLX2WAE08*XOK7daI{|By zD(78Iww|wz^UvJ_`r-JyJ(=iDnnw+2q`jmWAS$)c_mxGBnC{*2`{0PW{>9s+`)b@3 zs~caWW@FjPYT|e{2Ip5~6aGG*R@PQjRl_aJu&OPXsE-)1gviLK1t-{DF>f0A}fOj1u>A>|nvb{zw_! z+E<@SH)`~G*Mem&V8h9${pA^N@T6?*Tz;gSK|M#y9xl$dnP;g9h;@@;>bn*)74|#Y z#UfGRb%**j>k6^}2nymBnFPkIWxSSRZj*>mI+LXb49!ydrdrltw!XjC?`vFItNQ!Q~%CYbUek-`nxck**xU zJLGHr@M@zW&UgVyok6?P3X+~0Xa}toa}ho5jK5WT@&V&g9SP!|t-O$|`X_l-y4T5m znOGJ5S$f|5^b>@!19N1o8D514pm(c=E$Ob8ysp_mZ6zHl!1-T*_b+CchtFH4g7fe5 zH%Ntj=dloA044$7VpOaGq2M4y{IY^#3YtC8sJ0gKOMWV)zc2MKVo3FnVuHv;@U3v~ zeT6&ZVY<_moo6H?2sN>l6X4>0t4+dLPJ}3Vf*GN+}tgGoDG9^3Dv=%@6290ce!-e9TaYYGsQ%b`Gg7 zqmGVn*&xm(gR0hQYNS^TX2I{tPq5SQ+&oqez96LKa;&NAz6}#4^x~}60a7v=oJvi zXaa!_CQ4SQB7DDCE23N+oqsJ7%;97-PJySu*>V{c4HDrVld2^F zJ6OS9I4#2LXGmY~F&~F#a?HHS`kdaaDcT3TU&g$$&`y?R^)Hlsv%~m|7kz1Ug_ly2a^g|Y< zwFFK<8t53{S?B|sC@g$jYJlusZXW$Rdx$!cT6!unNkn{}KAt!5htfrym29P(%xf&QCKHs_>$wH~=~efA!zSw8Xn+l!4|DmT z>X9Hf7-UB;(e}peY?dDCj?cW5kjt zw#v|by4Plr+*vpUhL`*BJpP2|ZBq##RV6iD362v|_3NoBpPE9a_E+>IbKpk8q2-g; zl3Rt1&_*pLV*pV7KpfLt>nM8YX}&b@_RN2(3y;e67557h zOM7Obusfq1J|$#p3z2scERmD3T0vIT%pnbX&eh=hftPZrbNNstYKP1)B@be9=s3?v_{%(hDYvrUoU1zJn*H-e`9RUY;(5hY-XR5n|atbuG=tzmzsH9WQ!-U z9$J+-bAlG4-C;cLaN3Jm$-sV&l3AGu&xo){n+y}JNFZy_6Sv$5{xkCa+Y9^&zzxh7 z1^%vcPo;}2&TBT~LNT|M)3)bAXF_t0?NgH=?w@XMR1K)sRDbQ4n%?uU7OBTvzK3SPy+~q1V>a01%1l*k6K7@kHO)oWpgAAK)SX4LD;T zR=4|l3?!bCG&xxc#smtTy*+J8cy#)YwEPW)lUNxQd8&4m7OO40bG~|Tx8gU#R>|?n z5&6|QHl$%qCFXFKKC;bRS4J^tjH|ovWpv+iYyb3SQE=d&1~!I4z?t|b&;ogV>>JYo zEii0TCE)vbhm*Er)*RqJ@e*G^-7qqwtC`p+?C{H%%g$L)P**MEg7Q7$ zH1w5Jdjb;oSSw0vQ+b6~!BN17j<&FI+`y@|zoCJOqgc)BHrse(n^K*ouWUkil@_1d zDco|O@r9zy?ehLs0&$*GdFQUm_38>r$hPNKxK7)Z8WI_!Am<;|Wa$17%jjblKp}sG zXg~z{=%%0%w0A9ueEC@+A>$_#7z!j`Ul_qdv%PiqKk{I)jzL}RV zHW?&{LD4FNcgNOZnB2C7C`LSX0DXKX7ilb?PT>L9Tql!m zGp(=uLFTFmZDJevD-;lDZtjR8wL01OQ%zq5n~4Y|#ufGp&Xa*4n$o?p?MpLf>4Qm1 zN&VNUXS)bz1^M*GIYYifC73IqXW zFOVhOJyJgF!7~VnQOG=xz!8E{!!`x<3x7ZldADBD#zkDCsZc5^EJ36G%e3K|BpKel zX&kJbwwVh%5Slun5gPivbd3IM`d&dU@182tO@MJ=^Mc~)ZC4R9J56@P2cwEfz44uB zp1j-rlwz?9cA${Yq&?A;)DixSp2IZl%fwaR|IT~=`xoFb;5UGq$#nVL2sY>RUhqc} z?BlmVQk%Kku8P6lI~(X`lGver$nW?@RMLUlM|@L0Z?=kKio5p^8b?kg0w@U;Li7=e zSW*^>*pAYSaBQCU<7H_qRZDNd^ioF43?M$R6SHSCkzbJ#8e{6z@UFGXD5Xy5boY=M zX_Uoc_EMSR7}_r61R`F;&wGPoD3#&yG#%{oUAq20V*z7v+q7>S-^eF@w)U>}z=!*a zK*;f&x<>dx_}HLQ=JEls+lp`}_pnEIe359)r>~|&Oz7cuK7e2X^C0=>hIBFTTp6z^ zN3O(UFQc>Jnl5z+5{dTSSI@pj6O%uZY_sC|oJQ!L>2an21~edR?QE>dvFLYIE}_Cq zTap{i^HN3`tML*5K=PvnxL$KKte4mR_5l!-Gix!tg#->;Yt7bczx3ncrlF?0Ahzd1 z?G@cBiA?-u*zZ-O)Wm+5dLKM;X9 z`vF+~7#NGKc4h@|Yb?b=<$jzFXsew0vgtmRD?`@5`Yw8LX$uBkT7%mv;0C&=#?DD3 zzX~=eNxqS_ZiE$`%gpRA{q171j~Xx}{?gdS8kI~t7ltZJW8l?xqjU3nn0xVP8{jSF zovgc)N_!D*{F|ZM7ERdGryq~s>DR9E=Jy=Mu|i6OpwVzb&9J%=6<9b_}7@5XcT`A54*pn z33iD8RuQ#K<-Jyg z_(5=q1T4fD>rF+h=G^1!RN`LgLn@&e#;Dj?wNI5E9AwFP792qyc52;)xZf^Ys-#BK zAkZy5wdg>45}iBTi3 zIPr-+_rra1F6&QU0ug&SzIVg(3>l@<*k<2iBxwu`xEe5v6)mTi$E><~$bJr+I{&L} zEb-rMW4OQZy!$x;{U2-__toSfS$z76xY`3f7jzt(e5cj0RkIt;9JZL|9|pusBkBp0 zU3vt5>i=PpBdH3nS~QZg0ZyIQd`|NbpjM3Q*wR!L=h2q{`M>1f@H)AX(kh9&J{(zI7AqLPa0SOyICm)66Zy4C6?Heq@mwY zFVJkNumnJ|SvK_>_fE(JyYI{Ot4z)({Ngse=vS^y_$3OfL(O2dE6IXrRjfrNVB-|- zeXU=eu3meux!`3jp_J`oFlGK=LUl`W;1J!c3p)Q-gZu?9*YaGRA!mpNTXAKB&Ulrj z`*NR9d9*Az+39&EZ=02EP?^&v)JAGU@Bf}T|I0JO_X$6MuE|s=+7IGT%VItc$8s) zh1>UFj~jEGhysn81OCTLj5zj;f-nk}LU1})oakNM(~MkbhaLup39O{@=IVr8K!a~` zZ*DIVjH;6iFE+UhvP12*taUilJO!S+RYN#oftQ#+_b;^!u!6+|wP;g+G9#+7WkubVL>r1d_o1bS% zLF*suw!XVrsv3a$M(6uWr!y=K-5am1*{~QKq%sN+CAb`15pM;7+4{pFoA7A$??9`R zdhM{GLZr0==Q;R@D=|jUv?ZroEaF8)p23rl!Xw_@)xUeuzvJBEQ1FO++zW3>!G>gT z*t-V3xph^nKOTT+Dz^mIUy^O@x(rW={rcqxQ(jVlZ|it$%FY&f1~r+X4@==JiE6 zuQwXrnteM=fzUQK?Lw!6eSLoRvIw(F^&YZB5RHMoHQ(-n%a%YI0;r}lAvr4S+;8%x z^l~wdZ-{IIk5cmiW#{51Iuk2u*3n?~CDxwh%J1?d5Z1z=4u=R0hw9ez6|ZNcQu zpIs;;e;VS}Nye(%unBch4IANtZjIh+XiME8LlA^77fYQDT(K!du48H8kVvb^h13$t z-oG5{RQsgtVqzVqUBPvIL(*OJGs3&jT75D^ zHUpr7=EwdKwTSabQj?_jxntOoj!j$V5{p0+1=a_Ba$pYt6bX@JP!V4%EtJaJ0ZT~kiY2X?Wm|b% z4W7RrxS(FF`$Kp1S;R=@-+jG6M1$I*2Kz2}yzF%YXtYb8u)IlyIdL(ID=S`@WJ@ zqlk15W(c3g8Lme3A3OcRt2;TagQ)4-&TmGidp^uKVh$1YfRhAh*rOxsYu`C|Aba66 zvv0&4cq(b6RAy_@x_XV=TwRgRu)eq7O1yfkwutB!m$lxrd+7ULliLTL*zg5D^=aS8 zYe2|~3=6)zw0T&ly#-^4OeSAj%|`JgzmV3~_$c_}%71|Ss;rH|f38nm_;;}ZH3&Zw z7{7}--n`1%k^_}F9@nb*P768*femWM7akdmOw20AoWo#NAfZ5w#V5=E1Tw@o60dt| zLHkjHL`LL1l`L}zV`C7Gt(&7hFj;j za5^M8(IZmzja0^X+t-ZJdanx?8EbP`en_6VfT9#&r6PgLlWV8kI06x6)jZi@Pk|;% z{fMp2hjS|$4|1)6xFDq9=!16#YsoGp(MY-S$kGd!?v^S#nv7L!%ho(dDx$1WO6EjQ zNuhw|Mx~Ii#RyBtPJtDm(q77Z4XH90`-5U_4fb@!LukXDn98&zl^MdaY;*I^DE#Y% z`MVSV&xaeYX2kR5;^anaj;`7`g{4B>hjrMEoC+w8$t8vfZp^zd_xw7Z2)_$!;jdGl z_jqh2HwOqOHXUVFc&Xj_`WARv<5vY zs&k)dy*A%!%N4h_7o(KTM;%jo~X5cT?jPlrWGgW5g;y%6A?3rXA|N9zpK zB)VGfA0_}{m7jGZ*yh#bXOa&7E$fn@fUX`_oy!J|Zo2`SN@@q^3hb)Zr}Kl&BKhu< z7Jyg}ah^EoFfaY1d>elc1;6?sDb8#y%NikQ@gotioktLScu?U$9$}26kjG(6oN?=M zqObL+aY>8f;D8;OFPvU>wbx#(+DJy;cX!2v_smLG3zfCqW8cC06Hu7&fn_ei!o$6RU3ID5lqx4kHmjJ+yMBEdGZQ)8zX!&jghNa)I7^N zhcPre0Gc%Gam$@?#TGoI43IL{k%W1ADMiAuDE7R;h?kKtwSayGjiXV3KTLlvN1pMQ zDB#bor%04@QA(4AePqb|P0}4e%rBWWhs`<#;Lou|uhxXvz}SAU*S*OA&m))<&&1gxaya)H9fVTJ?1Bs$w*F7AtZxC*{lKz}~N z8zlSJaxgxsb+#~}A!Y28L^TUX;O1qh1yXaOPCd}*H#IwJH$*&uAnBGoimiV(LVoN)@z~UZ7y|x0h+-^-u=ihIPQ#l3VSJ)bH zSehPy$8mjH`$(?Rn-*bFVV;jJwPU`HGc@6;g-|*nK~$eupg_D+pb;`H_0tGjp|jox z@&z&v#Dqn}FB?M(4KI?ugwSP5E0xQ|ZSw&=&GWBmEe&2^mzcH}OmE-n$2mu-d^$_c zRIsaSMugO3NY22d>|DgHD|k5+@MC^s!{brrYl|x>iaJ6*j^;*j9C&V@%|~G&B@Fm# zA@*?JmtjVim{7ls!{K2Za=+EZ4i6POR#&)Ab_Mp-023brBUQ7cirpU+d@@?a1Zs}z zDfh)MR@!8>wF98lvXK@aFXLL%H~FRE%yV}l@3s9APA54@D%6uk=uXHkDyzpzFq#)+ z`9cw*2D$wzFI%YVt5qLD^qgljfB(1n4*=lvcCz<#)8Fe5pDn;&M?QWcZnL~yqg_qO zZXukp-u%Hv=s>wOx7elBe4GvC9u}2_HR^Ry#~ZGbcBOg0M`;=+_92x-!@ONQ0-xb> zCG6Ey#x~uw4#q^>_m+<+{XVH-sUC6Q)1R6DrJ=03;G(9`2l@frz0Ilss=@{u7krB; z8^e_T;}^8jj-2Sc@yUoiUF9UGvx(_m0~ipI&T5PLbjujGEX)RK+)|8U73{KFrfOwt zARTlvoBk}PuQpf!^u9WvUPkf|0DWdwZv%4wM+juqy>miFq;Qg~6B^e|yMvyXox73D zu>CkfwfzGHmA8`il5Cwn(vCzfvAWL;rNAUtT#x?JOPy5Un0j`zNg`sw}?C)ywLC+_^hhglV)(-K zM7d!jZH#vSa)Y#LKp18E%KT=Vz=*mS)0Q!bBHJwvO)gk@J-ayMAc%3h+urG1T!iL@ zs!bG@igJVnx$x~JNnN(c$+Ngv`~e)UI%khxq?JLmvB-to1A#EJq6$v(k<&W%#(klb zY~!mhZ^yp*o*6Nd%RPVfp%w~EFXepj=>Wz&hZjI|#Jgysk8e-|w~ie@h|2Y3FQTyW z5^mR__6@vrN;tjOs_*fQbmf3-8Qd8wj6LmfQ-65~RYaCF$WH0xsg#9?69gX9pa?#u z`Tl$0`F!j9>OqLMABmc@HYun@D7Z%5ujPtvcM+e_@h$TZp-BUdz1648V(M!mfvBtHw*q7v`Xf5|(NPV`m7`HjDaT>3^q;jYyY2M# za#rSTBg-jGT$IPhSq@&j)g)I;tqtW+|EvCkQ zRToHK=&nUtr+l!fefD7@G?8+7abqPF-2htNkZdB&=qp%*blP$wUn7qt1v3AfPeqg^ zN0RWPpfxF|XlTiO4-=YUCa}P0aJ483__F8H=|>NX>k=ksN^24AgAVCDo3qKXkP=}1 zxh{+e;4#s|U3}HpAg{b+*F#on|035C!0=amn$@9-e|(gQBFVA%dg3smg`vscZFhn? zb_NsWcD2LUu^?6w&%uZSG%7z!*&%dHJQ=}%PAwBTPG536=?Dvb zp5Z5>6@EU7-IYgU@3l5bltHHI9i&~(iYgdvPkuYYpdvQjp^R>l4kFNzztAVeRpPrqQ*cUw8FRc zp`CX;1nm7MOac%5)mwxI`-q!JppYG>>=iXE%*jjZ_~x?H$?4_r0TzApjzFp!twF7~ zU1ZT(4u+CF&bY1c9%zXIX5z2*NcaLrn0{}+eTC-kF!d1?ruZNoaG_K{jmz8fCPcsP zq>+;GANSQHd8kp_0&UTwY_+U4fG3@oS0}hxhgIex1~jc)S1rf70|Lsm5(rK8aJ8u1 z7&TdlJAfZX0XtifOW@V#0(Y-|XDUYlKr~c>%_7xdSIirAMbwa3Nt!>yPS<80mCq+o z&s=nOHM6m<3-2m}Ms!u3BmQ;qo#+6Ns}jwhy%t1FACG2|nonWMdDliubY&?XAdYbM zihJYshaVAu@7hxA!-|Bi_nRMSD?V*(m()ngAK+{O!g&6-2ldvU}8}zBV)UsXW+VuKBU=LCx&F7+@U% z*W6Q<%B0tZ1%Q@eE`V3GZa&GGCJ^LmP#6FyDM;>5K_TW(`x%kTV%$Z09}7}SJ@9i_5Mo1_MTXu}TG^|8&D09P|B5U9mF*f1>K}>p!M!CooJJe3S zZ>UM_P3TsiAyL3U{lAiYU+^B!m_Q~!~7a8vB=r=K#$yOh2grYyxv};)YtB$FC+*FSmj5Tkrx*XTd?BaIQtjW+;Ry zE8#?#uA?{XKOWilVw#Bk??X2jZfU7_m_d2l{=48|A3q6SDTXGG>xo!O&>TqmNh>IZ z3r9cb`@2|n)LA`4QY~Kh6gDt{P-Il=T!N{Go1txU<8#$G5wDQRHaY3AfcE=^S9^)8 z3e0&gu&FaWC|Y{3eRrp;}a%H`i?bdd{lbO{Vy$3u@8 zv|98-OjOxT)Po`#eQh578|g6c6JJ1IH^{4{Q6o~izF}Uor?4ue@1TOi{$ixh%t4N6 z4ldlz(0-Sc9EKggVa}#P+$j@=>^ZhLIM*l^mu!NLBnB}G7&rc`D_J9vxK)>RtkbJ_ zxcSwx=E$RHK~Eq8Pb#RQwAr+5?Rr(AWKIWYCw&+7qNnVX8fDb&tQ1B2gZW;E9jAw# z;>8je#Yfb*}U`{u;S(A;z>)0M+lHzF9eV!;M@-A$0M1l;xF_yEv*r4jfL@R*o_&^ z0Ayb~UsXDr;=~@*f-9%haUbFbgsG#UrquY@hJK%h;Gx)-6p;M7a6Y&jNG&LvfWa&;%FDLZtbZ4LY5 zgu7g_Zn01R{Z*qs`taPJ5eX3iTmU;X<9-p_d=&yD0R@2RjzO5-wkpXO6F*`JH1RGA zgJkK*y||jTf8;oZBoMeLIQB$4VcMO`J=6HMj84;H_vZpD)OSWop8VAqUt4X zF@$~}WmBR#iM`w{2FfR^yc@;aHToV3DI5K=tOf>SmvUb{s$W>Rrv_Vzn`Ug7uT}|3 z?A#g{C>pnNsG6!jdq!0|NJ^}FdzlS21Y{p$5aEoamKgRmoqCm>OMVW`RwTOV4T)pK z`O%qOO{98Kdf7)o(*D$jVp-aZItav0YJlyM4GS|UBM0a{Z3Zt7xY_*-edOHaDJzUo zSmI|^(z*Z=3P^bTC-t@HE;q1%P6tn>^wjh}#3c;;=Ook9Ch8l`7~?X@pE}md$UKs6 zejZ0zE|M_iKcfoN4J_+_C~NIR9(Qb4^7$9g{7M{txn~j9w$3wd#6#*B#1VGy&jaRA z2kizbX=w9iR*;6eae``Wa1+Q0Qy&;8#7g#_uF{2>PyK{UHAq3YH^f6tqvI&!cpBr2 z3yO1dI8aUArcVg~t{>Q7!WB*@HS&3@6Y6&PCru)xxM6K$Pp(QeWQ%>+AjduA()QA^ z@kZIF#+G$hz-ViH@5xo(fymTI(4dFw$l&dPf*}upL85f>9E;e~g<=4~0+ zyAedV5De?p^0-0>%Pz$0|AXMlH{7bmLpBt}nbHn=-*^N^GoSSaB>H1cNHsJLzJ-!k z9HjQ)UBu1T>aGe|4F}>b`NNpOt$=8K=cR3#oQGt2 zHJ9;}E6j0c^kC`7AH9lS^MRMQ^hBJ6{2m8~VAwLC_2mDHY^tbffU)rp@cq1OI)vPn zB2iMe%{$@ZB{U)nRA|S60Jz@&ohtw7gnyEgt$%=_KUw@auq>~NN>hg_x4vU5$w@56MCxl$o%3Hu9PVW~L-KJ$&yVrnl*KuIG9PHnV z(#BZ|90$pV?(r@vYW%kMo102d`BLs`Gb^K*C&rI9gxuZ72SLBBZ63aG&3-F8Pl;x! z7~&1$?5UHcMXHvPudCz9Uu=V=FwM@IZ~&Hzv<}d^E61X~?Jiy8rhUkr{5WN_)e{$f z)oaE}8Ig+qSfRN&L)Q<1xPcvW53Pa>MZY}3OL5t;*K}dVMcI1UZ^UI@_&R#PdKIsG zFJ&h4X6BvmV6%o769MG_teYU{pj3c3(k~zeHhVOdjWfb)6cI7EH5YH3kyYy{S;rd; zQ^OJxH)vs-8!03&3#m2)Ngj{j@cG(Z(%4LSG{Zzs3!n_mtfB@+EUkd%7B#g^n2aw4 zHRlA@O`}roR@O0mxnyb@JDEROTwjYfW)?J-o)oCPgTZ}MEQPRja{-vU8S(mIBN3Qi zb*mypm%M&P>1HG5Ggc6K&2KR$eP^Cb1A}T=8)cTaZ01$uULLd&TagIV)4B$DR~vG+ zs3kpd>%m$;OLOwGWlb-KlQ}*yzmgMc>G!dCB#p({O85Q~!2XAiZ)WCp;FpXu;!-{r zXR#GgOg&Qnl}o%Ies3&pLugt8<*{IfYOpc0XoUs8+e~2GpS81i3>Kh&)I3y-fdrF23Cu8yC*NED?au-%VCG4g#G88JRYo(X^HMt zo<`f$rpcX|$_4~hfU(Ks6-P@+`EN<%1GYIDnU-Hh9{!j z!uH-*(!kc-mNnIsQU5D&uuOFz{aIj*LLpen&=?tT>28)gW2MVcKa1Fe=|L^+d-3C^ zLF&UFc$0laqR1WBPQSAou2BETahXKoe}j66hJtHrulKH7^2{ zG?><%1SLymtqmgQ`an~pruJY>16 zdUIlLZKpAbzfoy=?va_caeGmqEq1gLv9JUSe9QWr{9q&htYKAFl|8u1%!erTu$p(j zv2>1KJz8|rk0_W+G5qyb?)yK0_HT|DVBX-_ru`kwSH@wz_)^4)cBwyPJX;O=+96|A ze%h0pk_c5M>@bK`{3qXk2HCw5_de~rVtATvin$Vu5hz#0xt1?^NQO620s=~*9tr$& zHnfb}5Sn-Gi1(CCC?0$9jAMTj!CttY{8B~FWC*b6opuyk9IAIo>3t&5=*47x0|tGQ zj5lurz-~n7wl{u9Z+HIQgUEtFY!jPh~H%!NdT)Ob(OsHg0MB!)7U;c#W! z_jvzM7p|Vn|1kLpeP2tITfd|hJ=Nzv_a}+3N)G!W;qC*oRHihCbm>94n6%xSeoh5w z7jpp7Q$T_WL{WRH`8PYK_(3Ng)&xSDUT~JazFmoiqVf66&@Po82aBHp+@}|FfMRXu zN**xtAmA-)hBSxgs zIphQh6xP(m;(>Mk4sFe|CuoI2%hSrd=P1BR_c(BvFbuL=BPG7hnO?N?H9sJXEC>ve0YAk6dAHBmt3$c80LR(UQVg2+Pu^RUOIDgjSyA&H&FW*H`62^_rL%F z>Tj!SsLK>r@7_W>Uwu5uwHpA}55VGC4p0nmugWZ6iE8q$Y;IcYH9GQwm?lB=S75j;DudXr9r8W31HR1N$FjS8^3X1qa`1y zty)jvAI3Xizr_SDzQaX!q`IO^ZhPzNo7rpy~67#M#a#tic2s!&s^rQzS>u- z=TJF7MZZ$<8-7O{_%S-_6X(@oz1*0py$}k}^=lP#80m9x!J%I@=s|%$Rax1_fJIqx zuWWg@w*Xy7WlD)Upo5u1XR^`UQ%o{DL;oP}<~yPaz(~~b6r8+{;^Sx!{Bd1X66K>1 z^3WUM)V4MV?RVP;!c%a`T9Z-0=WkVu>~Wc#R8f(#>1|Bj_@eRwHdZP*^5{r+%2)a@ zzA61V-8ap@!Q&(;)U*HD36N2T9Ov|rSkbpn?RJ~o%f_hvpu)=#pdm-jfe1VyYpqT3 zyP;b#>nJpUBv~gP)EkYU;!pJlL7MJWq5NL@r3;l`w=5j+?&ubw4wnMg2o+~01|nZ3 z|GtA_-Tb8o6G4!Coav#z_;)=-JnYq;bG`>PRp{%<&@0V;Q;R2f7*QfU7i8)DqsUxO z(Q9i(&A}S6hhEk+wQt9CtYZ#2h?ZS!_fDN+addBe=QsstWBt8Qy`nw2?{Bab%7JQk z*^qMl03L(kpP(}N);jO)gP5@_9MDQYy|T~8LEkMie6~Bm&N^zDr=56j9rbz}SV1?m z{0j93s+{aY_!n&bvjP7vU3c1U11Qz470T$s^>wGxJpYX3#gLb6yF|0RhT~2iWq_W+ z+=DF6T8+=ndjw)+b0k-T`Q?yEI4se3w|LOu+RvLMB-bz#VwZDLrUb?p-GdV!Ht+zG z#ccW#N$oiO3HLfks+Mu0$No=+&|^I>>5R$J4B+(DP8GS67kjtaEjA&?P{ePp>J|_C z+6VG)Xz{wDyMACG8_{nb)%HOr@eAw9s>L4RSg6?wzNw)}hjgpoZgKoUF%g4j1~-92Fy^R_g1#oQAz@AqUsUKqV5pZij?eel$$`a^z6QoB?F9ADyt+R%mGP3_ zs8a5kxxBuRJ;MHVWjm`!xH2|JwDeZ)H1J0JM;}Z<=K#$t-I`{wqKX26Jnl;}DW|@| zE&wJb0I*e7#J+zS`s13EO0Mui7doxKfjIF-|FASD*RHr`+#gm=;?Gl4<=YJ%I*rPI z+EF?K%49>g4@0%gkQKhRhy!*b6g$UR%)OMpTQ`I1ae1QdH7SVSuivtWHpNMeFf38L z*OnTP@5_?SS1AD>xLC>J+pAE=Bwx%{cl8@bGhK07c|s{!Vo@l|QBpaQOfLtPl$fQV zasuPw#RQLz-}3gV@f@zb_ZE{*a6ps21(p#x#!woQ>X%0mU4Wm@x}0DzUYW}u$7;i*gA&Eke)tza>sJydm1(dDd)@qP$_ zY*l)!%)w3Qx=Cg%jia(;fbu&w36yWW!4L2x1HluzPI2Rz_{@iP!lbYQJ@b* zSD6ZlrJ19i&Q35@>|8Gci;GYnus!TTCJ+k3R%h4N{%Mr|Rqt2^q=cc`8X6j%uw-lp zhjGuJ6klhZG$03fqyiPSbOoy&!S)kFc*|KKg|d@w6Lf&cJhHIkuxAvX_r>xK);Ej- zf(0P4SBp~aqKJMRIBit3ca^L%QmYeQWl?Myy+OFcOP(M6)(=tx+t?$U{`q^{-!8QU z#S@8X4bpN(Uw*litoQOktf*;u&UEGbrfmx$tPL_YL!vPj;71SX|G$1&NhQH^?)veu zC{{>7@j#aXwu^({JQjF;4I&Ad(Y$fMIyEOuG1{a%LHzMTxoYq#f*q>~iehyeG|&v& z8+$0715wUhm`Dx{MV?b&ojT^Cv=;H2xm~AqZ$<#a(W_lOtOq0e)60x@+a4r7IBO7x z`Hb~&KYphlkKu^_$yeDK4qvanhx7Lfu}XbZeQ13nR;APOqTE!XZBFxJ9p~GKCtwVn zEKh}jB>=Y&IN{%ePeA72{ZUuHT++vH>;8Z;*0zkP9Q?T=ygwB_YmQ+RwwTrkWF-O+ z@^GG=&?HIOeN?xpo5%I_{9HNK6QHsl*D>`4uH>z~!($$>PE#(b5?H>!pSid`(`xN| z1+q5QY&=9eU+cw*Q2qEN9?NK&cUg zCxHfvo$D<$=S+P$9_Ef5!gIs-=LsYwK#y3-DWcov(_n_qV-_Y?d%K4{2fF-l$&m9q zXE9Gy@+_{lsn$TNu9Ny4$NHPmHCjc3U@Dt(7%ElzY~Ae@1oEW0!<1YfM{oA*o3wK+8d=Jhq5x~- z=i`MF&WjfxsM0BQYg}Vh*Sx0t508Gqh_8kPsw{6j9zM5zT4w>pA3?AWpf>$3Hxfu& z*DmEIP0hVuJy$4IMw@+uL{OK6uARi_#Az2NWl<%9RXH*-v zOUS%?6RR%mDO9~4KifIjs~INL;SRLAx;-6dE_KbA*0Ir!K%@6`WtusWbn?}CQ!>1( z;EGYND3<$Gp6}x6UyAcR)USbs^8MtB!K)&rVPg`a(&9BvV<`HZw{AvflC`dx?dN4< zc6Xm_cyi@;Eb<>531kt*7u}y2#+e#a=wmL6zltOAtV1KFEX+D`R+iDazf8nsDz=NT zMIyjun?0qzu5KaL3JAy*wB+)U)y^4|6U)w%v|HxQazMI7Jql!vV$gkd3F6p&K z)~$HKNNFj16wfhIccq$#Rv$*Afi)I=qZ8{WH?`9!Jk%cf{|RUR(}!mQxc8Rq?P-fF zv}1Oql3lle&tu!sK)ztS=D4}2+Z-@6aaa0-DK=64MF9#*V<-l*Ik?gdaBBAFiy55Q zv98Fw^Wc1sp~ri~JVF;;+1qH?{*Zr^R`-z(jJ4`J9u~Z?-PEX!ycS3HHlpRYI+OPC_RQbAxY1n- z=VWo!U&K+V9O)6EHkPp*ZEP)+7;f~)8JE^3LaLH6?icpzAoDLKQLBK z6;WQi5QhEm(Kf+wI-sRt)t{Yy$)!s8%$y;KmjV)>kWHm`Lz7Z}|*S@D|jRE}jg@!j)c zos=$myoKv{ITu>KXDk5&oFKqsE4ca9?QBqp7HW$gAQZ21k+1x*0RX(QijnaifYL6J z{F^_VAyQw~NS8Zz*GG7{pr?LdMFd=`uFF}yLu2^kl`*g580ke#xp=_)dLft;Y!UCmZ5&jw5Rk{d-$LO!- zGcg_%zQa-0cOTB4Nw|D%!Ls-7nEi+K)E&$q{E)@ET=wU^2p-MfeIRN#28lTXaxDhd zF+Kd|cf`h9O7WKkxy`?hE5?BzBX=r%g35FhJ=4+vL8G!J6!o#zpThK(e5lEPS_)zW zVi6Q35)PGIvLY&B*io;EJfz#r4$RGVoV?T5>Fc`w0F~#m=)Y)!(&94P@tc8GiUg74 z4{*?PJ1odPmaQn*_t;GO)LII>7?!&pM}zmvgr8Od(afv_vuhau#43nT)}2S3Gd%Vj zxDQk`H5E{5Z~!Ys$xKg6P6T9pa+E6UvTU5`9Me}@m(D;cHhV%4bRx~+tc!WM~_nghA9yTDqBFaYVLOXV`a|dwV||qP0<}Y{IPPfSF8NR-jQTY?Qwm~A}yqy zvu+7VymXxX%@`8b0LXEQeQ}4?TRLEeZ0Rr~;B)l=H=*IC`vXv=OSr#RZyy9)@jk3TEzoO*^KaEu95)@78brHc$4W@0jAWanjSAz=4t+?yMPT&+ZlCDV zT(_#@mbCu>-+!3__k8z5f1ofC($|92HJuSgRvMQ{_P-gn%e0Q0GrUkF^QNO8f6n&5 z^LSmE_!mzzW~G$8ck0=m@jpKyJ`SQAd2&nCHSPW+bPrfN@gMivvW%IIHx>A!%Ss($ zG{k#L=0GE0&Z(o4@zi^ThHF>z-l1~E-tX!k;w?b`xcoL5VTy?sxVd{Ka3=cR(yA8d zFfpnd<|S+zfWN3;R-)4LT@0}k;z$GMGFE&$Vx35Rhs(n;2f<*LY=I0NZ@_d$=Q!~~&sBj^-B^JMm@7aAihnY&lmzBDg? z3hXhBn937h^bNM^-gOLpZ#bFmx12lvUOmJ(*^`|Ob0T#vIs53x*K5;fmB)jyTb2mhk z-_}&KL9DbzM`wRe9jcjW{h3JXh`tM6|Gy21o@AOiVPMZtE z#KXSyp1ntB<^=WrrBL83a@Wb5W6P7lPUbR1K-V%gcD7t9`Y&OPXwpLOaH_jMM=6bm zzu<)~*=@!aq zA>Vah#JO+V+@pLZeR+vK44VKZw0i49i_sbC*Hwq{DV*x|Zj(+FW1H%b_!YI9mWDVg z86FN8i|pOdNPU(x&cX#mdV?@2Y>ltGjkAW=`Z$gX-Q15_5mTGn?dU^-_WlWiVEFHT zZl*!dFLwk8U#0!(K#>t+kyN8%%%`V{JqhZuy1Q20n`hkrQckv?9%e$7CNDYt6U#ojW}cW+b<(k9e~Ll5!^5mVznM?8=Az#cZHcZFknL!! zpd!g%(4Q&ihn+6+QlFG6VBJ}SGYD!*way*p#c0*iStW_sUYNzwol z+JWM6{>xl9B?a78zV1v(;iDS~+a)Ml=;4dv6Kj(yzOmk(!S@IApP&eHH~2&UlX}Sq z#+$vss9MV0sv$Ro6jo#>uLf3NcTHGL*lioUXESOUv^UTyJ`QM%6pZ4#&hDI=t^|1C z6oE$wVLb;Eh$I+u8Q@!-eRc8m zm=_e!{SXAYgtsq-`Jgkj$#}A;9Av!b<+!WH>jz-Jt8W+ul|0Az(;uJBU@5k9;e#Bk_1dknv4*nR zF){M{YkPa6vMId6DvrjwJ=Eh+B6MM z`=ncKa3+bX*e*1n&)O!dQ11KSobkil9ouF@(XuCsO3{B}Ii8xf+g(jmYniQ2UU-UL%rwy3fxB+Da7;Kv68Nw1(4 z0hiT;G$LDj9ZsZ;LWwB*Do2t8B%2b_^Pk`<5y~0PjbaCA4vF@IN>o!$w zo0~9a?ay^~H+%t)p&9$reqN9o5DluP7h!iLf9XE~_Fq1Drs?0{hZC1=L4-9(@EVQb z)p*_t+;;B3FZuEl5)7Se{M4j>Q044v6n_^x8i=Zm!66&QMdNyw=%B_;&VEE$S^HMB zD{k2jbn=7HNIj3M7gx8z0E*1%Rv)dm{Va=yqOMq#4xuwbz0ULkY?xQ=rA=2|S-d=) zWwz5}JJrWlp!_Z`e;-Gim`Pio#1Y$EV0V8cZ@)5*JHq4y4e-DRD2;xZERAK$1G`Dd zhSh2%6FxBn*H;Mm>EpGn$PaiQnR{u&w1*QZFEsG@TBU%xAc&MCMdg?nr&ous~Egby*NMwf+4nv9fty3qT{I=Li5Y8BN)N=5!=R0QE zR4g4>L3%1>fQPK`<=6L{2kD6>82h0VztL&~<_pph;%mT20$h36WgY-BY15}wHP3p) z;z!2z{OdJ6td?(zb9o?_4N*8(_={q^|+aOU>3A*?r5-P>I$r&59EUoC!ni!4j zXB4rYjx&GQKV%Qwe-Avw3nWdnR9x@}_^Z-P<+Fn_A;dYWahlj+TCEA#b0gaqC^Qh< zj!qP3p3Mk#dGl?!;S+@Y$Q}~NuR-)yRGzO(Y|(vVI~BprjhBER4@^ynQ@d_WL%xL#Me5A*@yuTw#x)nP$=J9d#=Xi;W;Y~u)1!j4Ca$BzcdPZ6ULVb@^@MGcW zJZ2f{<8_GzCpbgQcaL=U#27nnuT~q_+63f5@|pCXWLHyKmq>m4jl|bxA~u18 zN17?v7u&eNnu5QXKXjIUhyEKixt6@BmFHG8W^_Y36V@A>2qoD#wv?wB#5@B%4 zF?HriD_Xz~f;dv0xBA3gM6Z@Xs>t>le%rqtN#3W?Z4-qCj5|j9&|Jw0femAGIqH9K zS7Wiv6#Iqo$s>e2whurcP9C3v3>7kh0Heauel^4rkv|wu4h+?Wz&1Qg!pngz|B*?- z$Xz;&c{A{~{Y5ZtPcF(O%@RwutS;}+re}=^vx6~rMM;d&M#k$qCiE__K=Pj;1OxX2 z1N5&to<_E|S*~coY?jGnNc9=Y&lqt7-~o@&vm#dwhA3uo!jF$&n%jadYRR=6wQ@8n zb9mbMn5uNb+unP2#)sX5)fqT=_l#P;0Fe#|o^LEEV4E3O0s((F+ywZfaq5(zI&bG>hM1 zb0~Q3!8l|kS0?2wz=>(o%=zhT-rhN2iu@A)qAJefI8Bpj8|Y)jNs)WR30N?`jp<{> zi(^5p+`ice>aHej^v#t590=L%AboSA!tEK9D9!xiiC4$dQUCxS_$9@{!QWqkZKdZ*k|6CH}HtNC8f@S-W zplUFSOg7StH@+2M3W--?X>I^UX7uh?j*;sbIuN&R@}S>FMOzL9A z>^G0@oBNa_;nHbnH0|l}>LApnJ{&-Qbd{Gjc1k5xIk=xD}8gB9_O z;91*L3$V>y`_QI z8+NE6*2=$}y2gg7aZ`wD^dNRuu z-zP+(VDLA*4X*bWH~}oMQ1a%C(1Z-J$>|r6g6|*>q9Ho3u(Dc)^=3XK5(J^%Pxkq- zeW#iAF?Yrei9{N*+XC_7`1^5X3jg9*l6;*F4QP5c_0R zu77i)a(|nueSM1hYdA_pkDaVM&BPQ^zOvol?e!#5!=>jJL?;xBAeGsQ*q7VVIPT}Sqr zHH#kZ_@_x0oB$mp5NlYh=!J8~9gMW&Oih-4jT#irJ$ngOW-bh@R6->6`BW$aIY_|%!M+~DB%MRaLY<2jQOCN-MAp4k;ghR zaiQ;83IEYKha7uE&>zy#Sma;9ecJ}HeqJz3}m*lCwWo^|aOhbBN@ z9{{ew;)rS0gSWc^E+-x@i~Q7NiLGa1fQ$h~&P9PsOW9ErdJ zUZHC+m_BN5zVOyfRXHN5YJ-rtKXkaDkq-84`MW*uMB=2GZ!Itw{ zU@U$Nq)>xm_4r6Il<>UDL0s2zzZm<{qN8kUiRflQ<8lv_eq0TKprmXrmsLF&`C28vvZ?L;8NP5% zgXO$kcr8^&S~6r!9W{nQ``G+3ebKJ@G_`Tj`BPebD0khU!EwK#AXLvA&Sqvv1?ZJw$C z6Y8VAnvt1)en@~^tapF@mOC9I-HGT$*QXkS8-qxo)PXE6lS*bq>B$jRmQG1Y)`>h0h;205zR{JP%#%ziN`Hjd`O0 zRziEMAa(mSI>(5C5VZ;;PCXsEK$W*$jkV-M6&mX$;c>Gd3s&3I9;Bw!v!Wi z==p=!IJ)$6KN#`!{MAw!U3pm9akQfYV?tPxrNb?powy*GTFoRn?J0@TzZ05pB?Fl7 z9$viiK^hi*S1vpc;oQpz#OP2n=cz!)!-WIN@00f?eLsc0sJpPi5Hz^=D9QTVP8x7% z8QB>(mn}`O9Y>@eTU zP7I93^X1Syu+A_sbSeP{wLx>&4!6y)+NT*crn{=0&-@Nc{eaTT zzxeKwMnD89io!&ZED)mqZ2+aiPKRo-Y*iif=NvS}KL*7p)CVqcsIyI>C63x(#$c0# z|92XSo=k);eo7q9f$vKcA1EUxi$-|@4S|MW4D=2?s>ulil2}W|#{|%;UHr#&L*f#i z;0Tvr>Z>MX$%!NGc#9EW9sGwTX{XT|w1S=|@D(DAm)x-~nP{WzScw@dHRCVV1@rss zi&`)+4L@E2Ep9?LO`yP!I{+v~YY6TP<3ysA#XUI;Gw*I6*-B=jjnM88M=5v_#ldE( z@PQnK+$V!8NfZpoqw4V&J_G)x2o{6EIp)&Ux|VuqQ-cl`LzJ6Hv(bwADNuovON0BA zD8fQWdS}IRS-#N|QTb8FA>uObFi2&Cb!C*m(!je5(7gus)GVX8p7Y*`JYf87&AS3q zCLSjrCx|XbVs2!U@A^)U29c-h1~zZY{6zHb%4q7k(_EMyCWkD|`WWy)IQ<9;m%A~Q zul)Z9L;qp%H_7VmZ(jxH@wE*UTRSDvjODV9sIWwp4wr?&V0*-2TM3k0VJn0bZT2e| zE!9;2SZ}Bbo1OOo3GtzmZkCY#kqU+!U)(Z#`zUK@2+Yz;O`Ec(q96`|gFE8*=nx1t z(J-Me0IjZLucABY3LxF*7vQx35#aHM!ww^7V0QHB7?~7^CsxZCJl9h^!?%k>Fnhz2 zY{AiL@^r6K`D^pKk2SN>qHXkbu{tq z*c-nUN0zhj;e1u%XT$v2Sy@d)#d9ls%&?+VcfzWvUc;vFfK(RJezEklYUFGslyEK8 zm9zlc{B?HPjVksX3O)#72-!Hdu2R$yO!p zLWw>^ZoEchq`W%tZ)oY75@UvdxMA~j!==uJ0r+0aeACTYgWY>fVf+cQ*Ix*7x)Gf%^e+L<2Ts4o zQ=7=)GHs`@uY{x`dOh3mf{eEwi!NxL*=M}`_9VJj`{Iue*PbU#@f~SY`OHnembDHf zD*>s?SBEv2cn8(>XSlLbBtxgm-wv%3?MOfpH2=!lT25aGTgviXj2#`0Of;KMg2D~w zbqF!jaVZE*3&y2th8H#dc5eFZM!1F6He}gZ!!7LC4-&OCk{0TmM?PXmFG~ux6t{s+ za_6Tb_{K90mhN}OnFvX?8+_Q~=#eQpztP!}{hP{F&vQUc_xU6Vh>?p$akBU7)xkU; z^|p_@O0F7ITaE^p(jaY(D z5GLl_yIf_rrt)Txfjkvy>NTr*8g*a>SmwZ6+ZsJGwWYea++#$0c&&$aGxRi0t=veP zO}|gn(CP2^I5*UW9RSa#qkPSu$+#HB1hbU7q?q`>kI&7B^|DC<1AoQPDhH_Z=1^;eH6 zL5KcOyi~xEAGDY+ChJ1SH-}QJth%aVD)!|H{}v0PaN^%8_R5SFD|<61wP3MXelLLp zTdUnRFId*())s7SiZrx66cAwdXV}|+#pAd31bfcv!qf_fyt$;bPI!iaye_mI2c)L%PrGHaaW!h%6bZvwa=TF`7ltx~5#QXehXsgaaxq5!@{^$H zZGyiBHiuLk9%eIrABfWAuuHg7^_p7a38Mfv~hbTwYOUw;L=hG$t z&&(r~75E4WSx))3D$z!WcAROJZ=s{Z4a6_9`8x{^?N3hRr(0?AWlMoglkt1;y=&SW zW}4-V6fLqAd#MGDGaD)v5DgtJtu|%$LOAUaaWz zoy*u8$e0;e=5q8x1+5eu7MXs%4Wj^NRZe><$Ljjki=(Mkuz!SeAE91!+eD#M2Y$aR~u?VRDdzMpDtKW zajXfJv&RAlDzdRGkEHC^$09)cjhroj7VH(Y#4>8wl$#q%s6zOR%qwoM(IuCeR{$!7 z-8s>3KG_Q}Ga5Q`7G)?$VPhRBAoqxP^u)+ z_lcJ!0r7H!nKu#bfUUHd=0Vr~vPHaiX8KD6__t0ea`AU&n;&9*QqHnwl_zw#U86jQjKDtA5ienQE^jHxu9{jf{TM8zl`#m z?z83)Pi4_okqNU4Pu3{Ob6agx*euo#dXp6|lCxN>C z6rQ0UgiKZnK_A>*yW8ECjY49N^FT)n2{tdeM=GW$7j#$`YsFTGIW0Yk0?OP7x|WbNUBhXaV-$gicH9dfQn(FGF5_gl8&2gK$gIwLWi#!*(;Dc_%Sz zm5hgO8Hjy;+-Ubc%PY=vLE6p)d>P5*XO-#i=JhU!!5&%BPovGO>QXhT?Fn@_fd>%i z@p%O*T7}wLi;e6s`sy5~68`&}3=r8Km~+O*ki5n=YU_AEKUQOrpV42GS+6qGk#Vk= zNMHXqXaDI7{of0?4>a$i^}JG~F7rWA)rEkx^4dLR05kx>-x9|Z@$$Fd%E&4tU0S>6 z@iBM|F&8dH028o*#=Z)t=prW+P|?xK<%W-la{Y-J$_*90XJfZt3VC6scgc}8h-Wb3B$Z9A?@umpJ>uHM6{ zY9mh1pmByWBPCrRy?q9naj*V#3{zA|D%$N<)My`~(d)@Gi;`T@WD+E)mp%|UXe~u* zO2;_BNq!!Sg`(*N(GF9eH&ASJrHN6W;?>SAp0hawK4z=$9@gY0U+gIlvl6TD*Cc+f z!!kMnGx#grYdRGsk0M-;N`vy}U70j*b3$#8IHi<{SwASn^C;dIQbl<>vN@7Or%N-D zrZ{ZNf62yk|4TMT{JYJ}pE&COKsNU6YTc25cty!C^>#_?8W~81;{ed-;@DLX=GFCe z380iCl3_1d;A**2a5X-3t5r-rl(bSY9crmeO$z#&>vL=L zJ5P}J8S2S5E#Ng4B+|8-Jb;$3YO5=uY>56z3iF*;X1NgY6R^rr_qb6g zuy$Hj-^z9lKtVLIkvOpY60qsQBk@BHvKDSO{1!8^Nm2*#0r)=Gdebi?getNi_bYuJ zFg24NKvk8u^@{9tf$ZiDr#t-&=<_(0fgD85>riWvd!SQV{H+!q@)`@JwFbA2R)-~l zJaMDn#Aw6?NYe~u2lG)w1`r1?&@ak6rQh%AwuTdOko%EJ-gIF~wLzFMC9l2o4dpei z3g33Z9t8@C$+&|@-RPd@hX!O1id}2ceOC;dJukC{h)0bI-JOi4v3W%i$KQ;u>!XNB zkN60B=NyrBb!2HEb6(hV%0NK+9e1tw54rmP+&=prx%u!c*j~xr4+6;tth@`Md$wge z7l*a0T%NrwO%x_+p8k9?N`tfjYEtuI@Ov<*igofFl1aJ<((Mo306qiW`@~uM3>nls zLt0gO+cTQ$Kntg%kz_$Jh;r=WGf`X*#w{x?GDRrKQC{b4xEY?M66JdPxcW`+I*S4} z%D00hx;LujAQWmnbdQtk*W}2fHhYC84Bh0OFJrfVMWaF~DD**pk1I@)1VkcZzR@;( zh9M+ZcweP8rz(=LOmK}f=lyZxJ5plhykVRKx_?snWUm@P>bW@l5*#soVu1D&-o9kJ zV--U7n^l{WWQtuGcBdFY-N;ttJ|N_@j%it7>r!YblrCGXe>N3yzb+Jx(7oFO0VrwgyTx|xXNngodk}m$IEKUS zsL7ByzjL!=a}^?(LSyk-901LFK~m_X`HO}brJ(an9m0M5t?9;uMCU;#9-%cb?J=EQ zMN(haoQKwWA)ipsk35EsrlyB?GSRGcOdqwAyx;zhvij!WHE>Yb3*Bq;Fj)kBz2*=K z_M+b0u0?bVD$_5f+Z@FYVFnfz%hY@Oow=8Oy{?Wm5M|bI3Z7T<^BLxMq)--pCjBgS z3Qj`Zo2;-kIY^^stoa_3ifdEfgLgmpj?ask6RCFrOk8!5vW^=MfVPHA?JxHjF?~+# z;jWFv<)*9{y;hV*Kx*K>OPrs|VK{p8SY#6k2h zgKD05jouzDE(iQe)G4H(Xvs{B1AnoqM$j(JcMvZJPqt9gj54o{0{15#I~~M1WUCYP zbHwmQnW+OErLW%?$T34mw%}al!LQ-m?nO|bNq#_Ube@+Eo#Mm01wvP1YZYP*&hxH3 zdja-A0NI1*M~!Do`T>zwbKHJs`EedH6r{y@)_V_mG9C?^x2*0A@2JJWov82(X6X%C z#s~H(*5Lgu%eE2GB>-t^(@|qD^XAR*vs7kVEVJT!ePAMj-V0tbXA8z1ARM{lmL3xO zZ#&hx#`X^d%1r`&Y8Co&e;HN1RK@Vy6}qby7uhaBB=b~3 zNNW)EP)6G262O{A7f641Fs6GuSr+8xFzfzd=-MDPn|N`%>a?gmn)ruk{ZBX3)AZB* z9D++)WAagXrgBGtnEgn4iTdsdPybfH{0@e8*hSYeRgMe+a#Nt_^7s+-?+}_S`T-Xw zqME+PK@t%#a26Px-Ls|S3?TdQA`oDGI+F?+Cgom$f(t^Bkf|#?ML%>LS1@Q@6uVLD zC~Jfx+l(nC??pZS)=+hMjZHGGaAWttz& z7-x5mq#IJE?sQ8yR0uQrsDA6G`zPMNfiq-*$Z3q(ilHzxOHq(R)Gx>N`4J-QV?#xI>`STsW-#w)`x( zT7eT%84TF=$b5tL8lUDzm0W6?=P6?&6`BqJd}#%VYB)Nu!BRFiQ&=Ov51|G5^WOAPkS}Fdj;^7SFCQ>_L%e9*E2jN#U8~wL3o7|@ zihuk@htIEh4uJjPjwz>+%*`4Ph2fz|Ii05CzBqGg)lx8-kXu(&^fl!J_-38Pq2dSw zCvo+mwChl0w5FXWm;Ybn0RR9q@xd^`Fs3zF965;M*O5hYcyFQZisX%sw-Yu93Xg)`+(RUhC4QPg^`C&$pXj zAv{H|q_~>H`AzK6ZUOZevcX=|LUERSLlyg>2+L9r3(r^mSb> zML7C0$G~}TS872ZtvN1^M znnrA=0c=oMgY`@JJw5=0dOJYH`IS2np6$holT2J3J;qhYE@pCzl%_E`opypuN%Q^t z0?^b{B>08nZN?{91N_37YT?*rHzz9>(l)Dam_2In3a+LCN) z(S9f(MvN{dnKVq}IS#{d*Qm)0RtAdX-%iWIuMgYQwkIp)Q@qGV>lE6pe*Adu)5Fd= z3A*n{AGCLHdH6xne`vbA^k2If<|&vy`YF#Ir}aV&xPh3^)UYGpKnnqy2efqVnR~m| z0A9e35ne3TR?!E9n2f2eI5898q5UzG^5XedQ(Dzz7+&Wmb^_7W;cUT+&F3q@VVMa40QerB ziHW-wvQnmhsSo<#qR3g+DqJ#}7p^^b{uJP=1V)5h8(-gUOxY93WB$@>c_ItR;y&9r z!)QE=2cJ1Ge$NZrX@BPX_-&fC=e95RY$Y`-UzI+6#rPFhEO)exe8TkHRsF02@tFJC z{Zqx27(5x&w9bn}Cv(iwcp$(bbmz>TK9H(kxY>7M_{?X)4V$=^sv_iMP%O*wX<{#T zi8m0L-Hn4^wTQuB=LiQ%xTiK%5ZDtCE0b8*Jz2rnH?XSKO0!o)S@aktVutBeLU@VB zJd|hfS3wQ+K1aj|d@?U2W|6d%5p6_Dho@}hb3z2ZmD7)i@O)%bBa%klQLf-FlCYMy zXC3g5)COa;t~g(a4`6l2bQd7E6iw5)$Sg)TMUb%UK5p;NQ+PAo0w5(xLjS*pD-IO4 z$ghM9Ge=W2gN`1`XP;L!*wO{iPpmUAV0htN?hgY$k^6ZIiUv@L93vw0_8$K?X zhSah@f$u%N%9BuIU<3~~+k8XbXzzVoxdi|nQ?9wFYBP5I9?60xxP0z`WdChxGpHUA z>iP4WQliJk4RJ61!sCVI|FzTrr!ATXAgPlA6)YyUnlA_Uo$P++Z3sCv-2k-b&}MeZ z)|z-pahVytCGm5xdN&j>YqH96V)*HEJ@PV*f*}+fsOZcW?U&IFaWLmBUVaeXJj$}{ z3*hu3*Y8E28kJT6>sBluMI0zk3bx;RkphaT?IOV^lgg$9=(hn?PM<_-7g6oT5r2EIl?dDEIDUZbOYkQQGp1 zpgpj-I{;L_LD89YKe>*#f;_-DA-TXDoc0bjMZeTt9b=Dxf_e=J!5tRnlgh#JF%?8O z;X#W0nQ_Q`>yDQQds$lO{0%d@mi!c|@ows1<+ z;gnEx7U@0k#UNc;C`gqV93%jo2nP1ecn)G50<}AXg?6QE3$!GKk$E1P&QiSu0S4)e zce9{j&K$9X7su3*q}bYjH_*v1_r1mV0`Rw(HFrOwnm}LZ1wk_vVz4)QVyDLp_x!{i z$_P@}r{O7Y=3uH4KK>HGlH5C+>@=@-laB2sqxUJYJSX}UoVdw`Ou727fzo4%FaQ#` zc2l2Uw-Iz$?jxGT|4%{um){h?-6OB^sfVwZxGNj3z)Hh_f&5~(mK1T|H6fZ6fRfKr z##&}}x=;WpptK4fP66P)kFB^+EKb>o@Y3)gx51FRsr#QHJZ9tOjMJm;TMc>4-+g6J z9uIBca`!U((Me*O>$!iBJ8<3LoQkH9RLFLa4J?eMwyOQO@vaOOb!;T?0Wt)fH= zT<3ouNm1d9l7Swhdv|OOR9}@__-vJteBtKf%4y|~T1ECakM1LJm!be#yB#kcaLEpI zDOh97?=oVdmMI%QEP&~VrX3Th2BHI>=EIb_}G_FcM`i+zr~ymQ;>Cs558~zZ)6lcrOnGD~dj?Fw*kwvmmQamT z-HP?uo5u*~Fb0Hv*L(P^s=7^A3MY@A5yH_`SvyqIkpj_&O{Z4qeXDdC$1(BFW7T2U zO*s0Gz@o5=}embVIVG=%F)RCz%?EDD< zWit)tFys_Y_{qbi_5|-c#jhA=rAd=G{8f$ZtDmOOPqmUER#`SnBgpSxT>bYCFz^o_ z{SU`Il1F|y6uyn0rUWhm>7U}|!Z$aX#op3e+EWJ9h+Mp*l6`1ssA*e|5$lH zy;-U0_W@$n2F%<#y5zgr`RR;*CYJd0wM#E%^0H23EuNi8-qCF1zwrY+9?uh#0%3MS z013uID#WL}4ygbRtiwDAxyfjR88QCZy`kGis(Jt1b?Q;yAX8j@o4y=`hMa-&lbh>( z0_N2!>6RcpbbAK{jHp3XQ!|hLZ5GGL7bJX^oEG*4A*7~su1O1zv4_H@iP-eq&cm@N z>$Jv=E0wXSTZSnOAZPI6+tU19vB8zX+6X7cjTL;KBNje&uA>2Y3#3>e`h{{ERMb1t ziM12S5H&IxVH~VI)XxMie6K60Ox9Q|u#!1kg_->z}fFnXXd(Ci0me$$Gx8Wy)w^4q*3^XN=#a) zv@v;o-D4lxy&Tvl*=jBqf`C*=&;~w2N67vGd2kPFTu=z{SyO+9E@`5QI(6R%uYgIU zu|iNjSqAnPUj(U5|8C2Wn)2$NzHS6&)jWlF&BCRsuKO3Qt$@R-6RRkm8BD31E7FW( z1xpdOim^5;8qB(^#FjPWRh-gf99dEgzG+U5=fVT3?$4v>BQVyN8hMinqUw(F6s{7^APg}w^DxtVM5W++oer_V zg|gPoFOgG{aWQcbwcO%nc*y5!?SXz(&tlO1Aizfl`7xf!E@yB?v}A#PR-G(y*ElMPh=sqXk0{yiaNv-rTc`2+s^ag5(=n{n1; z_!l2DcJ0Tfu>+kVPhCaQ-~+;ylpUi8{xrAZOexoCM(NT11ZbnM>&lhgJNtw7?^2@2 zYZg6>``HrcSVb2ylJ=sPU)LU8qDcZosYtZYe*ZgP|L=ET?!HHuA2f}{N3-i|2i@JR zEs!q(M!cGo`6I{>W4dQ$G)lEZ9HgH(Xk97jM>PHZxm{CvaZ1Oz)(z{Q?(#ioekV)0 z@y872SBRJe*jaWKaNP5BeHSQ{UL?3&k~M~C0iLRxln@EKPa<*vJsTXkQc{X0v{>U8 zvy^WP_6Xr1AO{mS!dfaQ#)Lp07p_rKE1DnhzH|>-wG18t^>C@4KGP-tYe5pPOab&9 z2B@-U^>0_|bJF(_=qS1qU_jTtib8{K@%w%g{6d2?yMj*hk1-u?$=?-Zol zwngctZQHh1+P0m!(zb2ewz1N-ZLYL!o0WB|B5L1=igR|o_5UB^X~s8W#2l^n)(nh2 zbzQlw_+-jb$R&!ED&CcRWf2V20Fl=NnKfKoHUZNcSbnh!pW}6FUMQnE5*Hw3D|)6k z;66(vT-LGzn~XJ=*DDUcwy2uLd+otf5)n`28TSuFPj)(8X!xX58a5i=Tt2w)oezw+ zEv+WtrfMDC`}u{LkV6MYyLR^-F6&Rxi|>oB9s1@b4*=YgXbi<7NBxlIS80 z;;+9Rgc0oN0nwk_bPyp&>TE1r9vd726nA)L614$b2zRv@>s)5=b|h*sg(x1XI4!l6 zrS1$zxf!>tbL?n0SV<)?lfd+SGC4SmpXR8f!j6S;0CeGjL4BL}ZGLo3tfJpcEM^8D zD)wMliF~0_IZBxdO1GSQ7Li?}G$a+zl$>Z5GVum}(}iz8<2BNp8w+3DZ z+4x(xMR_uh1B&eu&HvTsZ2WHAFpk{&f2Zyr|Na2@%?-flvl&VWM4taFQe=PWJ%B9y zGeMw3dj3Sn&L}683h5Pn53H3Zb|{LpFM20>e=&lTCo2+RmIWmgzn+I;oWa($mYDym zd1GxxMa=yxRriqz_pWDZ&v}&RoUF$tz$K)3aIoav=>`bDzK{wK*L?J3AGjDx4F z(a6LkP4*hj_D|H|S-%1sBj&><50Ru$FgEV*wq|_${@9NO9Rt&k&ppGeyL%%i!ZYW_ zsg(R}a*H-F$iRj$jSF1LZF92$$- z3>mGFMI?^di3M#o&ebo0Fdf{xvsR`oi@J^{(D6#~JkTcvS7{GIKww!g!%xOBr{0=c zh(nbqhk3fwc7ui2V&Gjh(@oKrU!t3WVl?uwkmE=CF)Igt7Jp_2q$SXx--d3xoG~7( zd442ZW4}M&=-ekW0E8~7q?NryAlvOL$j+yrF<9+&ko$u`YD5daj&N;I7vNel(W!Wm`bj2zSlJcJmB#P;4MOcUGGN4gKnCBH*~Jn9 z{Aqhu@p)Oc;;ILUBotp%D)zPR`j8wkC>sDR$#y#Kz$PMrT6ml-ySi8wiu!fm)=0mL z`Co@V0l)w-@OQs_8NT)2v{t1eAfR?Jej5Te{>5&H(tP5!QJ^E1rBXCYyOu8cjuCne z5;UTKw*XJ@?9~Q+*X7rvk<7RvLQQrV;kqcKgMTq}1vR8uFLnryCLY8m?~6R|kBguw6;Y07!2w8mCp}Y` zQ7zN>@LKqi{eVf7LQM|dwl5xNPr@&QYjcRP{#Nw#d8&d%3y3F?YhKvC#M6y zX*v|KAm|Y+F==l#kk)Jz-#q{6T|J<8*u2VL3YT8FkU5YUyb(%6WbT`mX;Ggi*`T_6 zAE}$ER;*hupmQ~LZVu~DXvS`0P0Mc_Cp!s8iT=y>5k1zJK-$#PYeSnGI;j+cJ@pHH z_C3R+Vja&aE01XfYKG4#3+amrfP#S++JvVus>?hec(adclIbCeKW7UDGOaSNfFR*i zz_Xqixt~*qPS8A5ZPjYXynHkiSUpDk4-Z@m#2fr;zB54x`+WmIbuR|;_kGjl@cr-J z2{w^OY+Y8+A-Xd*B;!zkooU>h3z?3}n%Q3A4Ug7JV?4@r5|6)~MIR&DGqAH3uCJnY z4C)oKa4tM&YudXkSbbGuKmCV#No)mc)bx3-xs7A_Ynp+TPcMyugdBXa)&hxZT1ilj^{R#}_^DIAIU)K?odsY{(U3?_e9|US0?YjUr09hmRw(a^36g6*pUdlM z_bmkfICTG2iJAUl8iLa*58G}a26eBWf0(Fe$jbMkZ@UNoKJ`VndX@ndOboF-rlle_A*jF=2HIngHI)bW`D5%DV~nyS?Vk#3_UIaWzVEA z&mRq7F3U&u-g)uQsFqX$3T`k;WVUyErlU*5gJQeO}x|v4Z z0pJu^W}*zc!Q;CSr^5Z~@66_u$q5xEnY3be>kn#}gEvkKw}&Rx2~p){()O4NKc~>! z*X?u@T>21x&v~AuE;xY;-8+?aD6EbUTU)yz#E?DQF`I{KQ1cv(z4qUf8I1B}>95#P8i|Dc@YWG2X$%eUtl;65rlg|ka8=va{;9a z68_k6dY*Z;B#>}#=vL>8NcapCGH$i5%0|gvbl1(&dvsft7NE{~Wik#^=VhU2Tj~&= zQB%;xHbs-{G9W12@KGLZ-tFXL>DXxKS3B~5^WDjYRsG@~+RP!>Nk*b+J$H=gQHf2J z-Bd_nP26oQ@b*WJcOGK6p&Krcky`+4a1BSb9APQHmHk#fK+n1CHOb3N0 zD)h3Ijfv_J!hf4EYk?NxoOF9AQDl(MR3rrjaoW?GM%-P`(Dln2v#Z33EuY zZbOIX2FjxK$n&)SrMWs+*UW?7-L|H6vmL^8OIYzW0Ao#2y_(g;NAnS0P^b~a0_1yw zMr^VBuJVW#i-P~b+_#7kH&ngffZ+G0U0d*bj;t<2b|0VlP+j-{RCW4_{1cejrH1T< z4g$u=OYdIIf}ym9!E&Kv5tELz*8KK4@bDF5)?P5e{zTi|f!J-MepDxLRQ(K@zdjPE zExs2iiV&FoQg$uFQYMJ>;e84xc8edc(_HUc_>YM&;@4sVX=72#XOWGuq;F0lmjHJv zq@T-CBe2!ic*wb!KG6=F4S>4;p>O`Z;^(?GcIb#TaC&eS3=7yp!@jq_w$OV(i`h!# z183F2`o!~>@!wLfb~fF^o*!G>QBQo!?M5Q;LW9q9m7@F@pc846eY4jPNkw++-0+He z0y*{z33vk#CWMWC#f)7P#g7A)wa+KXH~ly-(ASWB4@|PoY%_w9+Xj)aafVbw>%&bC zn;gu4HYVmu^(pAiqV_kc0d~mqSvKN7hxTpd$=KH-Xg2v`A_iRw1C$9U59^ZWHXd+@ zCo!lAPS?gqwy@pT1N{5)xM0ve?E=5q5jMJh?j|Fxg@KIb#OQa|hlrQVBGPFTybz)^ z&J;NR!Qp=`VFqrPxd*1Y*-WNS!ny{5gWY5yMF%1VpyR2gi8j^1*#;*kHTOdy7M$!CjnT zDG%>Q4Bw3-mf#JQfzP-ty$={In#tRnb+LLcH6;w;ZzXx^F6Bvr+Se6bEW8IqgWVqX!F1#jMQ@CciP*BG={qqjVC>3! zv6Ke!WT2i8rBMF2iosMg>3e39RD)7s^Az(@f)IozC*7Jv(w96<%&H#;Ydgw8EwU4y z2Hs*RVI=#KM!3w3eO&**t*tqca2Hl+!`4>KoLCdEMk9fBMlth^cPI7fw<++`Iqg|k;K8Vf};lP8xO9jB%;BLrE}gd|bfkulIB$mP|lFrc|i(Nz5_)8nZ+ zZZoECs-yrqPg{Hs6^ILI`L!^xOVwrT&En=zhZ=XXejv)T>V{4`^i|CVfjUcWou+-% z$;6@j03D3(8a*~TI>~FQFxH-nw?2%OqZN320p=D7%t!%JQuCu>8t+hTfp9&|v6^}J z|3mKrU~cG(`e_Sw(~>3 ze_T{;_sstI(|q-nPin7XcyBKYyc8Df$;)p|gED-O<&oTi69B8p^S@^bwwE($_ZvKb zv}40B?er`MghV8E>kV1)AwJG7dZRv>4xT01+wus?qK zS|WEy^gUvHT=i`DSY3bt45fl&FWsF^xudarpx|XDUQ{VB+AWSiolhREhZ;sWk|qAJ z88y-V2Rf8e>@z3j?dR2qEg^ZK(Xk41%o+%;T8)qmt@+Tv`+@H54eR~{uOyPr#6n0U zBJ1TP zC{j(GsT%AD@x20VNHe`lt4hD^VdXC}lcoWd)qEfmKjg_S4JyENAaKaAx}@#>Rt4Dm#^ z^C5sZOR`i}k~2BW^^HaBL(uHye}lPh&nGuA=O;KU2%+ibGuL`pft z86ZBY`7usDP+VH3`5Vupdg?dk5?FsnB@w!NCJrxIkMtrazzN z-&|P3^fJQ$H?8rq32<26cjOi`9ubKUhN%SGZC@1wO?46;XR85}=O*MF91$eV-GeOv zr+k}RKRd>=Q1=NHdiZP*5Q^pPcVea&!o+!7(rRyr)$4eE)kdUBJ4qmM{%YBRTFtJ$ z%nTW|U1N3pB(<(zZnv)Lr>$vKgI zMAbZ5DRVkWD;Y6CVt^cJUh&zfgqeAfA0(!9CrTi89qY&;8-&1fRkMn7r9h9Cm?j_h zE8auchtFvk5B)2*zDDAB5UR(aQSyWan3M%}?y3&y)!wt4DiiXSr(tvG-3DZ|>-9X^ z?zfMG*}y3rtSgqS^*Uk>M7I%-GjjtXrTFLDWPWWi93a!BZ_YpfpR)Ji#A%F-rDVX1 zW%V9HFo0Yk9CWSosua8UwWm2H(Xh|OUIG)y{6zE)I>>XCAWML~$kA3NFm0@%hGF2N zB62o}UD9i?gznfR_l=>@#}}xY3%~*Z^u88lFD^6;#0xvYHZkpj4#PWe_^-yoUl>Gd zlBH-$q`ll|ad#M16HL9-3Q(!r2*ue|UTPfx$Q*USiTEvur{2gslYa1*a~ zEY5ZVe(xSW>%(t`-%#h`5`o%wMomxaO?zo+R?ibXCQ|qM>jZt|LtDjqZ&p*jJb}o1 zXBWYpK37T2{1G)z0`k#JjfW(2AZ45TrfH4!dF?l>=a$A9%dDY^+cpjTWd@fMZ*TrGwgA+IOd zWV(c{`8)fy7p(8NV3+M{ET6N@Yhq8}jVdEJKJVCSOmB+z($j2z$c>Gk4x(;-?ya;(C$z`7x^|-C}t!%FF_rp5Ce^lm6!jTDM1Z}9;+t@ zyd{%XX%JrUm?_ksG&dRO1J~+_13(01jM;RFsR%m=V8ai=33=fy@v7794QLT9YLd}h z-*Qnt_hK3f>5Mc&NLk1Ij@+vNo8Q!&P=qFvPfY;>sk?BV zov8b#xbKqzr_i0^&Ab!*;pEIJVnCTN*q!SzuG_*n15q-ruWtk_ z281BZU^bxp8?6fG4@Li!z0#c zb#Ru=3ynE$Weg;9oq@6O0t4e^+4f$HVKfe-i1Wa%rM*_0E!hU~lns&qFA__- zJavuh<0cG31T$6po4oQf&!=4E$42~*+fO=ll=S@oofTFZNTIrP1nu!?N%2>g{MVw+ zE!V|sNd*)R4Ql6I%VE;ZVqz^=&Au43E9us`YPLDnAt0N6hc z!A*^RYrEgTKf;NM)of}Dq*omPu`*JH`F!-XL#n1}PI&r32j(kDztlOTEQYr-R?(I` z_~+q}a^9pE)Ta5|l`YG#+)aWBw%%UsB5+KS4KY4uTI|f4Y`HbI{EUK4TUvKK`Vt7E zp}ghi+vbUoIHCPZn(QS13EnPBA?~9VOS@BtS+AVJxt-vkHRF~g-$$tRXj#3w*$%EhnA0FzG)X2|op{Dy@QTaO$D z{@4?6)bQLLs}YQSqIZRq)TZM^aOi$tOMa+(eoMg`&6t>xR3wQ)Pjha&=4AB)U9`KX zi^bP-UZJ*1gT zQk0ex_;z%S!0|7;&HvWZ1q=*uKfvcZytcan`B7P4g!ZWDBul(3*=%OjT!*m>Gltk# z#T?qYd=zR_N*KE}p}ff=*(2ff+>QCVkG1a5?3Ur9lvU$3x{N6O@>yILsiOj8t)Sc{ zI#P?a5d)AL7VKOw@Vi-zai5#e)fK=jmh_$?w{> z@}5|Y3!09NKcGUu(bOD!&4-Q@cW~Ggew9dNR#3J(JqHDI!_MND*=F5U?zx3a?xy;i z#8T@o()R{~fsixFd4668CQ%*QMrtdEtwddba1cL4SOeeMAK{;Q5u_gg$#%z^pC`2B z42|(;940+mGix)zue4Uv-T;r`Z7(c`35Asttk*1)>C`m*bu^Kd$SgW_`rkzlr-}%L zd_N5HR%yI{#opDE{GuT6&!20ak=a1YRV z){3BuB_Oei5lWv^c2%i7%T>jAxz)E)=rWMBtnxW?5k>%^hVyANX5hg-emn(l6dZXI?~iX!ifI{l=E* z9%-8t-8FTsvehE!vk2R*A)2Y39^xFp8)P|1fe4tI$!4*qgJ=cs(_&26`F(~{a9;o4 zPhJ3k@9&#QVD!UdQcVD0_684T8@sAj)H4X#lW3b?G20S6@A@+3nKl^4r!-4juEZJZ?^r%mN@->+D=lbf-?^>u6 z_lLPW3KI=we7Pn8yp3qXp(^(=wJ1{#X02y2H=ktk9lysBvP*}xA@|K(buoL>2Wrvh z!a$U>U~Z9pwTupwI?c^2yNXRp?^sJN;OR(-*IOSfz>;6#H2_GEDuMMTlHVAsC@_32 zUXmyD-RONPxWY!jNV@`10nk!r$ziuQAGQnQ?QuiPDWzu(-MRJB3 zFkXBE71{+lZ$F!+1`JJzS)au}2NU=RBLc?JAF}9A=X1N4D}oGQ7p@9Sg!Ot;Et4*y z5wS`5@`SbAVybxv;em2I+m5DvNPTTU6KERC$CyCy{INo*dG*Mr_xn!}a(^?!!%TO5 zCaJz?#Y9@DAZ&uQC5XZz&F4=$J}RAV#U7>CKWobapjje!2&tR6vu7U(l{@upO6tuMh*vp=fx%D+ibR#!(<_f|3sv4uR< zhuOe++1c^Ov?9=gCs$nWW;Olp0mVx~157i(CS4o4@a;~>ffaa995DmuX8%xb&96Bw z>O$iv>ZNqeTg57C%lK^a?f_eKt*B*T%BJ}!w$ zi!3cU3eCHW=$FoGDS^&ZHU1mPfVl;qR5!JNLBV6RUUD2XJxeXAIntd20xd6vK*YNO zDvx~$U~;tyup&ydG-h2(^78=#wDrGbV=CbP?z8HGXt#! z&6IBVk;Y?J=Rsj}!875spwRzx_NML}#bl3bM&Zo;71GPG4FhJ0hH@v^1=yQ1GvTKS zDc4mCr|44q{m5eS%hy5SAemI@&}1T-DH@S$7hCC9I;jyZ&mhkDg^`xL4JUuM5OK55 zxb~ds>Zaf$h++ads*Nvs+Y9m4ITs6H&CB`ikGgc{!JWu-A`_bCC<_y+-a&njjkLBV zzpj?q1{;{=mjjw9&eD{J1w;8PfaO@KiC%TDV=J{x-8JlDC0#r{A+Sn-ZqeWKN*Qa` zyXJv&OYma}OuwE?B!w*!L`XuuHK^^@pBjiH0MD#m*l7+va1zC5@&UVjIDSC(y7juNeCuz$Nd2{ zi={f3$VZ{2@H@~stIYvFupr#kNnVq52sI1ouI!Y~W^2AA?wU;A^ujT3$h1R^F)=r> z8zdOShy+0yR7>^S|hxZ^T zj!FjM11bqNJ2{tq!E-8IsSk4rw&f@OxF0lG)7l-VPJ`EYbC!pUf~2~(0uVeR=VaR%m@5r(+xC^b1;02EJ@5WRoWQL_+-MFf)D$X!qtjxWU}`R4mJP{3 z_j6{cd2KS`FMY+2W@%-jhtuuyp*z?pFToS=8Um_E$0P8~2py$JsL6DxCYNi8o z(~`4-rw|S~z>}VAfJMTsz=~t~R=55VKAXe6mqi66h&ST+5V#-BbEsm}SnS7_zdPzpCe1=p)QTWf z_g$qbQ~Zof&>%1JM^BDM5}LRF)^P%wx@|flTu<7Co~UsQY4|nvGpF~HIv7MqeyOmQ zdDZUquv=6L5uO5LW?r{#p~8mqlJP)M&{!;L%acg*FDFI;s}&R5n4TH{w=qV1 znMIo{86U{R$o1MwI$x}qjk{FOZ1J_1fRvua?*jsiZhGp*;dZFPD~IXS)y4rK2%|Twxce5 zzLRW|#Lcbz@xm$6wSJ@CElw9 zfSPAZK82`)P%T5df9<8j(A;GCY$h&bUK7*b^9~(D=VI@(AiUu*SWa;``x{guo~)wc zo7m1z^8L==EagI`@H6fdYPK=z<9}=r!DlL@fk)p0eUhOf;!7ZP-(Y7PpWqp}k;oOV z^{5a0w_!=@&d7bHFMGE8mBEWnPQVHEbAZ%`B$yMVEDEUWMXu&=Mzlq-+#B>lZGreM zV9pmbA%FxYSu=xy^l;+|l+y#$DYbU~^Phl|g~mh33A%2y*h{>)xGU#*8U-|J_b`S^ zedvbM=#i@t5m6JoF&l37D#59!=foZ9q*sa1`_hsbbjtJz^xQJ|>3)lGY0dLHN=Hh> z2t9;kEnr9Bt5Zb`)}ma|TJDxVB5H%e{ShL?B5~PSb_Hbx;C*rp$8a7u9u^1n+V)Dk z!+)irCKPTw-TT>2;5}|mSyEa;qmyL!{idBROXct{CH2m?VJ0;xX#Ygf4$vzowm?Mj zMrm5=DTmS1pZ&%5bzNu^%z>xb`eWOGd$O~7AbgA>P0n;~Biqpnc9kOkycW%iYD^ zmDZqckk@)08$PyIRqPk?rr`2TT#*k`81O)=>&y${pSP5ad)4gQjRyKg-ZdBC*u8&0 z12P$_swZOIlRi8S@6QWi(lpGS9sq?BiGl1t!)2<6`fFY0uvtO0LCdc+-914(A8ZX) zY%m`tTn|XtAw)SL7Ham_8WzK|n~|B5Pql6&Qm!+!rEQIvBl%nS`%l<+Q?ohtm*^M? zBp*?e%ut~IZ+wCC&teuw2ak3}QJL?xvT4Z3Jtvf1i*05weCfag4|>_@qTdbCte@+(LNcte%qdgpF-CoQQY=U5uiKElQgW!!|7|oXtMV9j*SxS!$1^ zc9UDHeo>!Jt6O6gBF%yE4;GbDo=0q$u&%-Ji+E)UQe|3ROD$T#1>WiLH=g)MV%Luu zj5ps^yoSuZ{}H+WwTS2bg71GDnV9HHg!$HQXy~qQyHOZkA?u^+u)fdXkM6KV@hFxD zhXK}pwtPkaI_Fs82IYVm#K7-|nA9s!hC4e$3y(==8hS`@hwmlr!29uRt9p&n78%zn zRU#7Le1xap9vAXF&|-uceo#Rmy0PfOOh?DHRWQmiFu6<3U&rVKX zn)h4snxLGuf|)s^%ICFs9vQqwGpJq1%+#pi5)i!4=w%44!%CI?KvO>?OlYbK7uw$q z16D*?Qc3X=Uq&O7RHJXrk*VNBLfoSefM{~^4`Sl?w{35;+`$KsQIn|k@2AGxj{!u1 zo9xcaA>1rrCLTDk$so1~ajW(Kh{g+v^2w!SuA$C0ahx-z+}POVv^5b>;L#W%SO zTmQj#p01ODG|Y{fZ|&lfJs~d!a>@Zt7W50S5qVyy!=R0t2PupoUTJI#Nn&nuI378B z1F7sWw4DbqMdd*N3frKCfOjIv`qPEd)&^(Kk6G0P3fXoJys*?d6Sy|J>6T>sHCKKs z35NbPQ?qrw($e4RT7eMz8cOBLAk|O>h9$J1#|yvix2n?V2(p}OH7Fw z)rmba#a;@2>fg{OoD1-;6Az6Gz_K_8d_e=_fYZhBOM&Q;>7h8$Dh^Kcn}%z?$IuU^ zl|05pk8!^lN6++l5Mft3nXl2^pmj~-{)AHtb)&m^4ckDkA{N&cJOt5T7OkJ`Jx(3? zLw zJDc1-X+H(kVxN7Y3KEa5YbY84y3#atT89?7~~T26H*ILu3Pv2IHHk=u)bORl!#g z$AD5mU_$$Kigwo0nQW@2gKsUNgv7B)W2)--UYDNr$fkGEr?J$PH9Xzjju3Q1N0U}K!#LJuAO0AyOSXV zxU;0zC_SD9x(%n8xh3)Sdz}2HU4L2%dDZh_)O_S&W+K?LvOMGafbn7oR#xWDYS?E! z@WF1LuiTsx5H3k~PsZlSurZ`foG+i8xse}l-yVlf!s*9k zg@IyR?|)ANUHd}8+RwROJs=Z|^3;gi<}RzsoAoMyf(Au>qK!b7vKr3=DN(ep*J_O1 z)>r5+mq0~yqv_@MYf~vZQgQTZ4 zO!Mk(@nH=c!lOw!pOk#aJ0HR+@Er~uljX2N{ofJw&s~_WUwQyw2!xB*rf2rdYahnXomqF3k!f7KT`Cg( zSr~OLoq%v#PzyEFbn-!8QMyyJ)93dkJEv&lu+pfs8D$5z5xl_riYQgs4zQ0C0G0szmTX&}}Gipgn1g}dt#jAyRj^a6# zIBmY^9Yb>8c59Ybt*=x94#AnuTER+Ld`s-pplKXto zj;<4G^0NaL9O%wMsr31;1cvruiVqNa>$MEk=2pv5{gtjn4l!#Hm0A14FUZfzWL`Xn zgkW}@f|9++Ij1lh(GkDD(+GyMy`>&dP&LYpHrrpRw3~-aExlxg`oMy?46)~}1N7HT z>SJ)KMz75-$XS{{0Jn$;A|$Y-EVaaetUutNl!oWsL$W3r+bUoKEGk1fTfvkI@4^jv ze~C(NG}c<4T1m73_-Fw|;CtCtE>Z#fDI0BA+XOd^?!W5H=Tqj(GhL364+LQC=8k8f z-SIRkEXD|fornVDkA9_woLK1aJvPm#%qEy0j5A&{=~v#K9JgOWU#8JhX0+QqB2iOO z45FRFBd(4sEFwM7SYm!`^=HaRKxwD+=JgS@wRH|2#%(*oyhp%%GLID#B>V^iP+I!l{{cm@(4B)vM()Z`Q02Dy`$2eSV(~@4uM1pr;b`c)~(08`?i) zbf3OhMm1z0G!TTz;XN*Q9{NyZ{Sb3tV}Y+9RepUOe(fI>1)9ub0`!biYNh(`` z4f-c$|DuMO;rs4o(At9i}o-fQ)Tc@we-mz|4>V;uToohbW~&hm9q4Hdrz<$bEBgjiyN3 z)|w9=OIb}%7&~y6i(q2NEGl`>b=_MLGSQS{yNEKIuYYnJzCS4$4SJ{-(NNQeG$n2T zluj6@#M$#Gb%pkJu{g`1g&SY%NY|i;`Hv=gpQY z9Q?W1%L+GA$hcg&TjGWbtsZ6WvV0v#3YZAto4L3Qv6b^F8^^7S@L*~ZnduHH?}n;;6iD4&p=-oJqFA6vk{z<1o!8}H|B z=hbh;9DLGW00V$%_; zjk}umx-Cx57b35OL+vSjjOjD_!5x*LTmy_vCP&tPun^A%Ru_L?s~A#kN8%F6%C9^KdVo3 zC{b2avILHc&Jm;om#8inBuadBg_?G1*B(9^zv)ziA>U6YnSpIcz~=MXmx896xSu*ld)Gg zn|?p?x57k7sD$I;ro62}&Ooh2F|C`2H%Eq20jDZL3}pKJ)8uBo#fzy^v<-H6l9qHR zZgjt$bxf$^B+@nqttRD-#i7Z1xO^!e1LK9Hs;dlM+E*BI}cv~ zD>EIba%Tl2A-3`Xag2~S<7I3XkKd#WfaM9#`FhM?U|(}IQJZL`tWc{GFd+I>9gu_J zQb#EsF5~=+>8-S1&Ke;@PtZbLU}hJ?r zmw7oJp#m;uDSUoZaVbdg&N#`lv01uai|GJj%!$#uFY_+F+wqmHn|ZK*)xMK`F{2)C z31Jfs2k~7biCg4>scy?E(N3Ql=-47t!G%bg4Dy)_*3}^ksEsEQ6m(H09;@)0Z=}Wg zZ!9=*kk8@;fH`BNJS+1Vihjc^hDXisSX9{lPrG zKSB_=K(qcvb)S2FN)8h}(uCIbhEud+>9-);2-9n)#*BVk)F~_@zKO1+%tQGy3RO#~SkG+4@*hcS}kZ`%}(bxbv?ij+-vDZ8nkE`3jlF?^$k|AO8BZy7%X%supk zDFW^VH*Z;BCSyy#=NQXxXTOQ{2^Kl*cNw5jS}9%nZe%NbZqdaF z`=4;JivDz#3b*uaC!4j({aC7JYbqm;9X8Z@Ac}9q(KzEv#0-l+?ejq1w+&@#u&9_tJPLe+6M+_uTpDfhz?( zf1jQ5ONxKzqnI@enH=ISz?f&5Qt=>^NiH(G10Osvne{7G*&Ucof?YLoK{(08;l|;$ z&$W^SAr$x)d`_+pO&r&G*eMHB!(M+PGZCsF#39AE(b~vVef@a;nwl#8JVCYpBO9aq z{G5p>d;Ax&v7VgghzOK-woPo{?@Fco*Jf$Ca|c~s*UEdlDR5j8 z_e@C$W*j&pcArXfeNhF#SVU)6W#YaV-{HtLe4o){F%-GP|JD}rbgL13MS#bb?(xQBQaojaZhsUyOlg9ox3d48 zX%L8_Ll{+AO*?&>1*i53g=@bpRJPR)gHnkvwT$)(ATQs;ppsWFqF)chd<{gdB-+*IR3dcQw}Klnc40wl zlkIOdl&{gxZ2=8{6ew;8v3FljLt;7?jKIq56PS~6p@2xEq7jSo+kGxX(*GC`kILq> z%*vTrd1#Vcfo0nTZ{c5ti4`Wmu@FuL4MbyH5!+FR47d&2YX^abdC=if1W{(miW~hU zrxyAF6d>jz;K`sv6-4tPdd;{2B%C1i{Ui>+muT{B(?w%dy0fbe<=>v}Jr}*m3z@$# zM8(uC!}pe()O5+-;TSRvMLoFHa^d0qK4iVmEA%BQYcC>?iY=CKfjMpQ_C)%+1lgun zT;T)*N-c(FL4nl(kKENTH1sfqXLhK~e#VT_6V@QP*eqXor{bL_`qWXN`LN+Ob=pG< zO^a+@6hLsVt#>*ENm!^VZY_ma?VM|@s`bz<>S=Fj+rcsZC3bMODR!9gD}pT6RA9=u z`lE%3{7DSbyYwtF0*}I`xrBv<;H!nl|B_&0n9p82z)WNs%YoX~LIavxE}l6PNpOcq z7#ETj`dE@H3fG6cWdy(lXi@GLG`1U3Qcz38eg_83#a|0^MOpjY*AYOjXAtH%=h=Ut z^{>jGH-Baz5%KLPtNyOYMvt>}^UPpoylZB=0Jl_%5tIO0C1=5b_i|X=faE1(Ek}tQ z>myiJo+Hf!x~OakRqy6=&D(=WR?6%YoiLse0?4vBTe<%p6Bb^PLDu;X$7j4l3u-6c zR^-viQeYv%3I52fHbk+aA~XYIwmLUv#6B`5+oFtRU=+NQ^5#&V7g8Ez4u;ubY**7O zcxbDRav`wZ%9OyVaS5hY5*7$1D%iU@r_?vaSGqPYn&X`76EiNq)Us}V-@5}c$w0vj zzxUMo-eH^jNBCAB2Y_Gj$qp(IkpNLHqo_l=bd2bdYr9UPlYjYqnIuy%_1&N;?D>{O zYYWSkQF@FI4e+gWs^{>q_+db&@KZ93S*T5~nXq|2O&ae~kc)G|m67Nl;-{Z{C;ldq zB1u7`kT-?%9rAc+h=M)>7d)u-Hfrn%9hQn)8N^mACk8StQ4#40s`v1Y$I|hl`Ea}>9+qUiQ)wb=`wr$(CZELk{+qP}vTW8{%I5B7T z?00@WQJM9t;);rRDl_jJ>7fblLGrWpdtiD8z4TYWa>I}u)2HF+@d?(b10J-66O|su z2>(_&x1RD+)5(O=56~z2+OD_LpeCX{5*zk}|A9-FtdKNcY&F4v5QX9IOAN}l{P{^81o>aF_n(_!e)v9t`^TNrY95DI z`lsrI;JWKHwm=LrMpJPEf+(Evhx>c(uwJlu`C3q?Iv&M!pbPMImaqAX^OB&p@Ng z78NRzz#DPDp$5p*iC*78pe@5AqYV`fmm$OiF9cCC|MkAQPe3^KxGEltNeE zC|vW#%84APa?Di!DiOqiQEIjQ``0*|(6!#;HNZ_$1)CoDb1|{YD6prM><07ScWXy8u4Sf89qK5@))77X zG8azlgJ@eXx8u2_x zNJJ2+^K4ANRk6JoX^;1FSEl<69tNz-)i{cy`_d2AEU^@^C{I?O-A}wItUvmLarBU3 zz`{`Hp{xs%VxqLwERY;OO@Ga&4}us#x(@ma9i20nr_m_+b9oflYnyA~*#{;FNyMxc z3vz>B?~Y1YCdW|c0jby%G}Y>+;zTzwA8a{EiGWbOQYT!rhIIv?I{p!)5q9>R>s}+xzX6?O zdXq0lB0g4ZhiCgkHl|tCMj5$SP`A4+i;`Rr))3Jpm+SYR#Qnn;{s;Ks=iO~nP%`sR zE34n4<-{ug;X})72*!`oe1@ZQ)L$Wxp-|0o9|d^?k%8-&y)audvx{S799$EWKssWb z-4ksUvN!3s#sh>#QgUNOo9|Fx%{<}O=epy`MUxV>YFIjAU5N*6wi1y1mc}`h$E|C z!!!?Cu^+4>>YZgj!SP&Ye00A8`d=A>=s;7pw{xspd!=w+4Ou0?@JmZEU2>?8=E#H{ z<0&g<&N%gKkD4co-H8axqv?U9GRvag6^K0%A<;Z;mvSpI_Z$s<=pSR`lD%39{#5Eb z7l3_=nv}urT*c*XH2xK-{=;iW=rfCA26~Yvu_{}xDO^qkl~*krm;hD?$lkij-V7ad zV6&s@=(A+Ztji;{2ZR4S-hg2b58cAe*;J}goW~YCzzUwos!0%r`COl$vXt4~f1SzFD^HVfNqyZ_60OMxRRSiJJUiWOTWsXwVIv zk_Tp2Z2t97tX^*nus3~02~_ogv%kf(E6=_MFarrye}nD#J5GBP=_)-msURNgx2s{I zH?gJ?rS9iCF8Hj>6v!)p2-vATBFB7ofUPSJ!M{Zi{KVfsH_aL6`#Kn=gNv_OUT30h z73!!_Q|}GgcC^_|s5RVjO&4H`)4Us85JI1Lo3E|Z{aM|&dtl8-uOwT?h#$!SGX2Dg zLRD(Ku)?1!XBFIBDV(+coazQ33;HXE?-Y#| zi_+qByOYW^cdmWAJ_!Ei@^OlJK>5+;SG;=HF69lq3b;rj-cOs9wuleP-lYp3HJaGBw#bx z{oqzeonv92gvWb=8!Nfa$hq(F|Qp`@He80Cmu6%s(AMPrF zlj2NdNvPlP%F!rH5}?la{Q5#m-wjy|SA$J$Ap(L@9?oq3%^`{~rmd^{(miH>D+al# zMfpX@y?5X5?k;837@xv}QoZ3t50-ybJ99Y_1lau<6&?w1JNmMIx;fO%$7(5u7Hl}> z1~P&p#R9e_F}KYdW_)Yl-l9gF-d*RA*qxZLZ1aU{y@_RZLC2tE)dBhaIbHnFx7`w@ zJMO6!2DF9*6d;|}qx8*mIuM^p;0neyUt=Fin0xaK$qT}DG(z6@kYiDnn)xmgH; z(Qd6FxJ83N_8?;W!oLam#){?(Lb^YZK6pCs(A+7%seFLvb{QAr?ayWNJsXev%m@f- zBS+HD^ohg6OFZDTI4>X${>Gz{a@jkw>4p4$0L}O~k1+plar~P!J=V_w*grgyh6Zgp zkA`(F7|T~O72|f+k2NoKR8QEruWv^G!8wH6>AVAiP~V@xfkNk9nThIsm_LCY`3#*k z>SK}YuKvZ+WKv?s96gt$Xhk`Vv8ySO7Uriso8t(9x3$$3 zGex4D)@f6Yfgv`u39Ppl`x#Ie^@bL&H?zioEq#Df3k6^_;M>VYxDp)=a?7|QDTz;o z#0`moWr+lN+5RF?N*T7iGF_J;jo*Tziwlyy@JGC)ozKMf4&9?D(>1;gX?-!l_UHNk zh*WRtddtC*tr-dFvkfspg-R91W{g>r1$oi2C#zu$tA+&?ZAll$?N%Q+s*p)C=s{T; zyenFk{~-n#v)lh>ol|%~Wy#;OZoJny28QTBdw&rrn|oA-oA!>2u)rO@r zP;BBonE`*+{ADACq9RuPXAOzj7_`mI2?v!=F-VqlY{RSXLCsooCa6kGp{A-h8UkQy z*Cu!|bnfDWGk+xzs`l7o^gWo}G=#X@-Q3nqBf-`6p;i$y%JH1)v_h=kRQY6WQF5;s ze$mzfEEl5;ekLO+J2tRM63Q5j*LdGa!TUz}M~U1P&en|xIcty-RWlI+^8$!4r(yd$ zKr;`C0y!3sg48WKw*J#{OwB-IpSOOS`4F20O7Ye5DQ}|f`h(sj z@e+5*Y<((=jd~$(J5&Xo|DV7Ez`y`J#!tI7majs)ESRSX<~GHM0e1&&ovt=?Shn*+ zAO3C*E2%aV;SwM%dww-^>1B5d+^o5(m4_a+{W@qJ zsv)oXE4-#^iGjUaMvWmren(5cW>laPSdB}F@_}=V40`=-eN=JFrDNZ<`Nr&vc=RdM zCMfwPs$AzzyiOp%=F<75@dsQ98aA5wYY6gwh${K+aw%X)AlcX{wUtMZgj@2J-&TOA zrZCoE$TNui@t^o4K*c#nqu0jd&T7mc!+(!$co{dDXcbXYiS1 z2vo<#xSh$zai^~2a4NLbWXhR{D_B%KwvIBCFXB&l(%>=H*6W%63)$EpEDLt6`!VG@OJ zx75Ua#6Bg7wH~$s_e@vP<`UgDGOhV15Q)V4``FkK?qRFd52-lvG)|ZW$>hCK;UQ<- zgF-Na7c2Q@&;St$k+g$9@r^AmcYZ5fQfnySYO44;K}7NE?RiS*6v)cF^W_ssu4^61C@s4 zDq*@HTvqMEAaehY70;pru6?T9qK=TbKu9s{9V~`gJf8e_q~hl+6h#kzNH0R_(4`+G zv(~O}WiMg_(2Si-B=M)tGil4Nt}cl*lDb2@1Q_Uez-0zL8Yp}WSX=Y2HFMBFqn7g7 zvthWdjP^Fa=hQDh^lSTWA0)Tbn|L};&gz8vwvqkyB+?_a;>f1g6BR;Ho;)X`k8I=ajZo=IsOOI3( z=4-Fz=VbWWlpLFP&aOemte)wRp(Gx`=MR|6jW)j>K)Bg;S|XG>bzqT6vPm}!cQU+N0GAhUzcg?^LR6c_HaItLZC-u?)1G2-1+q4O)? zugRpB&Hc^@=I+}C8TZNI)Gfqi)Ub3VxhkKEhyuTas_yAjY)cs?^58)P_9cTZNzg+q z`!K?;aT=k&4Jk0UWPx7E+kS~krg#ft{6kPPmVpbpu009RaD%w1G~`5~LbATg%Wa`f zPv#aR|BS3yivd*xcPiR!i>$J=Vn(D*^Vl5~TaR+RB3aWe{`KOH9gWNg5^jxZuHcZA zt%}KVlMxZ5T}3frAyN0w`2F1h=6j5JC|jLZygx>5h{ehVZmq*mY(1pi;`iHPEada9;G*$mi8dtSUhG ziszBBLrC@XD6I^v z;$rtgc(mg(<5=ExhBfpBJ$|{r_+Oz5-u&H&ZNWgI{nf$)#h~JnrTXT=hA&rPb>{qa z_SV>fh_IMOcD--XUY$a6kG1gnwf=Uds-Ag_v(|2j)@p(;RdP7|R_6hnE{FT?#E%%% zRaBG#0-WcQI*m7`S^FWpP(sqM{?>#uoSvup<#x_3bAc9adr@4rhF81KAkKq3CoD|s zztV-j>tV;>RCuzYC1+mO?8i3R5*vvJ{#G2Oe?Vp7CS_~^jBXy($gtpBD%Nl#uk}p= zWD)yz{}&K)!}Ly00)!&v5^&T5!=@$HLjYY#E zu|uGuy`NaOq>BiD&J6=v-bQjrS*WKV@7{+k{^R^eCwH zx^IqM1owB1tDJJmRlsl6j_ZIORNi%z>PkD&ya8?wR+T1yYQGay#=blYsFLh(E0%pv z2|Fe0YUpe6UJPK9aT|06gLQPJFc4A>>AABA19E$@H$fdVr_G{LDJLt%WSg})RI3IP z|Ikjlrj(xDP%z&on^y^A4(k9Ss{AmL`uSO_186bsyRzJr4L~s3Ps_NY9UY%fk=2#j2Ad|@&BVinRNJc@gB&=OK$F}k+)12_4RdN<3M^$+wRZ&p z?=l*w+b|kdd$$CBC(9VzH^Kn-rsvS9oh4WS9@3z<;#G&owQu|#ctC_yz5KDNVvjm{ zgDQG?w?cZ?i|$D0`nu=l3-<=|KKW>lr`7J`n*tt7*b!51NCNa6Go5J?no6c|;)>X+ z?yI8peGZr>%OsJNIV)nKQl3=<$ntK`xTEmy!n>|8Wvqs(_y?V2J6PYlYp-7se(MpG zs@$5^UEaG73y2*nVDH7W(vXE)uoR?P((ipZX7s~L@UQ%{mO|ei&20bgcejSr1P$~H z!RXy07l7_N-KF6>aVfZ%hFO)^Fs{O8(yD7V9v1s!n@$zNT&d4B{(oQ)7#?_% z`{xz*blj~YLXMDu+VOQtD+S!r&V9W<-4Sx6El!Vr+LmHVV>5!4NHSf%Pli;*c4p?0 z7NF{7Dz+`g7GGgtyUUIbuy^dbXeKQ_&`rzk%j*`Ypv3Y9;;Sq(l6$}Pikz|`qw31X zg|-}cG@7snXxA6y2e7T;COu)Lf!7@cP=G0A1S|Km;rAtE7AiD2R(p#iOrM;vl?)CS zS|rBl3T3%Cfj%q4yYF3!=>j8P=bFW7k%J*G#T-j-nihG9GhtYW^&(TCU1%y;UfwRb zyMM^yZ`)Sv&9Dt|X8h`B96;T?T^t6EC{2tWE6(sXz+-shtnR5;PUUH&WOg|$|Dr9p zRX{}LFtN6bo9CYd89#B@Ou+vXsSf(TWnPFGkWKAcz2eYsc9{W6tZ*JhBF}JTwv1Q?-j|A{ z>9~^B|5n`MIElUnO|YrMWC&mmQn}1{gVCpkw9H(7Sif?&ig8qTkS&QC+#r1@H=4=` zNwkLMd~em9^dKUw!e$N#_nF7HJVyCI4lRM=5#VR!#4S{q|KXSJc?M7o4Zgec(c#K6 zQ@*Lu0Tm>)VE_vusy?z2hD?Os^3-4O{Bt>e%$*7OCT z>ilEyhKU~{_~;J*0&>XJ4_u*`gdy_Ld-qB26xU{MGK|5f$LZYMxXt(1dcGMPmS)KB z-@^;T+{?hgopt_utLDvL@HZPi0v;}_diX3H>?^AU^&4+>v2X9Swc}l=qM<`&u48slhV->Dw=i*X5sD3V)%q+)1ee8cs9^TC)L^U=9bEB zg2M-?gF_ZCNh-LRav0g|^>NQL+8S*A$G%{2iknFUttYxr_OFr^-)W=E3Nf2czQF2N z$EuE`_*xa2dr5llIGC1_vAjXPMHnt16!1lp9(+Qj1KeL7n8NcHXj~JX> zz9#V`?$e%%K*g2)w0V=3wPO?(^(N>4PNH@tqtjwBX?sqyd>rH~U>k8HIYNMM#p)l;VNb7|;(QQ-sLw?@bMhh5Fv{d24Oh9%L`2d0(+GoMOJhiB9qwjow3sVrl z5uP#ooM4@2jT*PT?9EEj>GSPT*4SVoAYMs>>rQFcuyAkU~@8FH5DuwL47TwLRwLj;n4oQ+E{wlEuFDD4fe z%ojPG0^C=93uu_;xK70js~3V|Dsl_D;jyJ4hVzx-#MxuMZviFY9`x_b#H1Lel!2Mb zfL+aLzeRtVXq&&+`)-+l)}e{9WPgL>s{p0Zwy+ijs_L;$`I;9UvG^*1)akX zYouu8d-(q%-D_`g=~QuFF;L}C7+JvQ?^6MYF3OX3)2^#5!FehTOA$|@7^p*h5^}45 zFbH}Lc887d{A!k$0}`o;j#50sA8KZ7nYmka2wk{{fIgXIKV?&B524LLH3$?;8WIjW z?!q&DhiHf%8v8BimJdq~$XurW18ssQnx5h2w&Q~EF)-w%T>vZl4jw;vxFfr4^K+ZV z<Z3*JQUznUSy&ZLAg)@M%wyE!8stMST>XQ;G#}n_vIwe`At{}tQ z=vowhGpA{0q$W$V=rDw7A%DCz|He?wPWa|8CL;V#7-HbzxdDExxX+6&RM6;w31q!K z(s)CW??;LGnBS@ddlG&m?f|ECyM{1wRTqwb^m|88*i|{dyB_ep<=wBXFL*=PP%?0+ zSu^R?m&x%u-&h}?Qv?m!ON@O1$_?4?I2qyheO)KY^~jQXUJ(HFAk5rM`1a^#eC$~| zXHeHr5UhPlDEZf3XJ(hXQ@@rS*pMTAqPF#FhlDcD>R<#ut>9&;J z-5R8m6jfDthvZwE=+oWqG(yJIhLCeRoeMTCh`%RaUH|-Cn@o~seue+N`o8GLfK>nE z-C8hA?%6R`_?8m(z5d17mxN}DRoD|TVBC})if*MAlMBJ6(^vnK%wSd`)xcHwbEWEyd74!SOj3a1FcwBzA%w(22MGq&@iu8cBel0YK^<2TQ+<$Dc5C>~SI3+-Ub za0jj<9t{8)fn6|WYEB1YVYJVvnEV}3vUZ?r8<=}(lNTdiqGX7e?~_&&Utk;W^w9@h zn?oMrT(iAyFU#j@?dc2x!su<4AC%z z!2tO2r0U6q5U7{u17{%$%H(Hmvn2hO@x8Pmj34a~=#;0i(5|4Ok$`|Rx!*AM?Cw}l zG7ANDitQXl$e%XMLXk%x0BHj2G-2Ve@a<)j!=JxW5RciS=|MxB^YpX% zQNFd&Gb&3N&X*j)m^zdT(}DvGf&}Xhv;z3rZ#+xeE|?T?g`VhVh2$A2{H5Wh2+PTg z*U<0FmgE}miDy{$Jb{+!-Y2RlnMO;5*`ffCQtXoyZ@pO}gDtmt9UILS_|QicyD)wS zAspB4eG}tMLLKr9v-2)gzl+zWirvBFiyhdux{Mq*k+gP!fT-h&`e#L33>1v3ed}Bo$@gB3`zl3)*Uz& zykU6%mHZH66j6)0B19_Nq@tm=l&MW0jSC~om5x0(g^pmkec9fw(}2vae)J2H;I=2` zm%$wuCc%iaR1gkKwnSpICRAt)Ai)Rw%pX=wL5fHmJCb2yxbuWB?yA|8p!)o*$m1iA zO*})ORovJOV89C|q;J8-a!WoB|_O-hn8kCZp{- z8V+S#czVlsK_X@{_Y}XI7MBelar~c_=iZQ~VBT~LxOI+FZ?rF~#4h;2vp5_9vHMv1 zOO$2x%gSx=Sj-53Fb4VQpGqu;Jx;NvD-IL zNU)4Y-{Jlq)$4MQn$#-~qjh~5PIodP8TuQ5G?dqNeB^!nP)=lF-cIx9_>1{4FI;-I z-+k6#&x0gUA3Bop)^1#emh^=5D+%s#ZR;>{#a#D|2fXdiUp<5+?NN5kK6S46%ZX)9 zHk*FtwF0CeY;dGayuT&%2R(mJRi)mZxxp)@#}QWXrvva?T-VHqIfs=5z4_z1rsr*0 zS_usCNz$quhb^~oaRA(3g*AsBYiG&jJk4=G)ud**7oyhZcrX^{ezuR&LGX)*O|)|4 z1VKqg{LThOIDPqFn&SATxqs`Q)@9N9=Z=NNDr8^#X+6_48doF;mAj1B0z3!a7L0Nt zuu1u8M!M+c#Xl_TG^$tds1i%PL&J~R#yYjYcjDZhyV@H^94vVT7m4W0qfH$yaN44f za~}nc`<0(H1--l~q}~H3?|$Ll*w6#uw8F>0A0>JxCbCiW({KIK!Hl79wnzYS~UQY8$EbGmuyeGFP?Wrh8N=f(+C=09T5FS5IhDR__-y2XM*p5NQD-dnuCVNY#4^-Aa-D>|W&({m^GYQ+ah`O3N(}td@ z#7c#!Bc=uIOSQ@%^r~xyM8sqCz8^4{Do-4p^RCU1T~GVW%9WL_5s=Rxypl^4pInro z**Zxbq*e^-p#H~vBiI)B-MC9`#giaG=qy&|J*&gAQ4AyJ2478g%3V;0rPI%cL|yWD z2|8X-t!l^y#Y^n<-f=_Yq~BkZT9^Zoj(z@>Ny8w&0eQbPMOL4CgwiCie>q*;nb6=R zzR_$tm1Z*K6YTDaoLXP^Vi&;MmydJT+rLyJVIyF}G3G3%(>TM_r(;427XhB;YYK%- ztJ(;5^<4m@L#D>b8!I0#jaL^A>xU_P3a?*~e2b|Vgrw`o6=X<{|F)?6qy?fI5@zdD zYbq5<_annH;#U$7Y=lOvFLOnQEAtvjxFkQ{-;V#5r@s~@qDAZ~f+hj0szU#W+ScI@C--ud=~uy z{nl$m&3zo7sLWsGWW7Hho7rbzUg<@~hMX-#&ZYwA(S!7uNR|!Y1B7m8M5IqZ2bZjt zt#!_!Vd+K`3qk>cEOsi*R`j5%wl*Z+p5x|UN`;fd7;3M)HhH;#ZznYM{ET#|FiwN^ z{a%9v0AK^8pZ8@T$&%v)&GO?Qk<%NywI`UF%2VFhmlqTls`^B}QXaK>W~4{^<31$1 zS7{vSWx@3jtR5|jE(&}uBgcqERa`4{Z|?0Ngak|dQdMV!(Us1yVw?qxZwwYyy}2`L`?7tm>v1BWH> zC7l+OdX6?nXpb!{eUbVuy?`eIE4IBP{$L0Tx63#Vm;XYV&fix>Pv=*ox-jM zw5cUwtJvNxP!{WSo3*}*|ME$}0MAsU^?i-KLK{EL193>1s-Tbn zhRU&`l)-P3eX-bjw<5R5!L3SwvC4Obgjl*Z;X!Af_M)|%oVG{pNGsScN)>#QVsr@KO+!Y@5!RP!e8XPY5^q2fg z?Gt8a&b273QRdr(;0}X;PLEdwqXh2&sMW1T%M55eY6mW3L3bBPF%OkCiqgt`Ap^7; zhE3VUKPl;!FOHsQBIaD$qA9cO!XjEFp)M#wZEUjRcb{XnPDRV7AssKsfxe@UmCWIA z2zUs^lOYXJe$eC;XZ628Rmj{nxeJ1k%4izDRF)`UkrWY0%*=P9)qPLGaaF5^UwMV# zW-Ux#Y#TrIw@fzq{&r^2G3qmV+LEd9V51pmPo{iGA`05f<_rJXb_|7WH-=H1`{ZBz zf^z`5PWyj(`!8$vZ~V}c9a6+3`?CTpJNA<=V+1wkM0jKgI;T2_hm%%*JGI>Qb6dxV z*gL&c9#<&GLrSc5%=W<No|Tk&hyZpt&_%f^U{Fxvb;#4S`T!Z$2GZ*y(j9XiytyfiS1JyTBYQrD#K zP+?*5U0OAVB&&R18`MtLVXhS|dVJ4`FHV1u5}hFYXi+y4<9b<#{Mw>b8D7=z90hu_7A}A=j6;(gC5zSsd~Jcsg!HS` zlPXD2@(qXRJAIqyIOJp*0bboFn((nE3{^3kZo)F4LIm!rX zhD1drr1d)pCyKCprmbspkBeMjoV5Uc|Ldv8-oz&L;zcDpp?l(v-1O77UhpAs+hD-l zY;z~ReMy^YEfeJ1RhB`j}zNnz>$MpU%!C;&g=pksxF;!rBUK;Q|qxxz%@y?)P6X`|k_z+@E6; zFFYY{Uj9^gOL94}BLB7!$%GmpHORihv-|rlo*3VJ_&o`R`mdtLtPtICM+u0Zp5d4z z>8%YV z{uZ^9y9(BoY+RsKuuD4Qt51^n`K80g^RoqHabgzJx}a&`38PEd<+>e(+a;-y*BF{> z-37saH9r`#NRLi%I?{@V#R;STd6HBMknIkPN-N1DMtpSo`4Nz zqQKwJX8B*a+V2SO7WFa;*Yt=crtZ=#fmUGQTMnfvR$kiUpIMyVbzlDhYZL36dXU=E zMgti1k0oEnoeD7F+&PO?px=R!aDo2z^2~FUbtp5rV|I*1>bPG99T5lJ;Tk}R?FUoe ztqYRETEjBORfH#K0c0nRLvX#R7#6PDpjbSTaxBeXUv?vRU)p-un;=zrUH)z4v9iH| z_}&8#%+aGsgLX+%TrtrLMW{7_$g~`$-R~!F*cc0y7_E_+*GUp|rt!;mt|6-gFzT`k zJH~s~i1nPqbnP2p*~AFFqyi~>(ZBHJRL}T%fNz1M6)hG^7I>#Gj2>XtQR_f%Y5JJG znNSs+!QtB?!aH~UlZ7R(*B+ClN_iQ&zu;?bAS(L>dPqU#=D%b2Um|#>e_QvLcdzmt zr)f*ANNMwWfm;0@UlgDHjfh?nGfPN+gDkZqWuVoF`AaWHPl3bsz|5K(as z1(^)0i^}uaQ$2!+;?0-r+uN09Dw8+5lSs_@Otmpyaa>lmUNhBLwV#YP0EjZhH~#rB z_?;*BKE2m^hINR5UMq=AdFF$IVWz~70_EvApB`LvkOKjR-}e}*I~;_)=pk2L%kH*!igIU>wBF*I(=Z$8yNtxea+X zLa37uf;ep-{K5KdZXZ40Z2i|{2l$LGb#L-g&`*$Cxt>$VC?5Tp$hrhCF(B}$DO1Hw z8nE{m36LU5qDwJCLjV6iZCw9<%f@Jbk8b&z)AWB)HU`unhDhK^{4D7A5;9n^l4zLf zA)!z4GROzvd7k<0=loe=+^P!H(=PhRBntKhBYkq5j7_n`+=Ig=Ok?K;ROo!)`)jvv z%f+WRY0W=qbdjVw_N?z*dbSNOR9hs8Ad6d?!UIb)E-6Jor-oyi!VDP9_;3UEfjos* zz^0d_lO;L+az-}vz+DLJe&t0GG7P(l>EgEYK>gYFt1qE>*>>YMq7?HIw?shYN%+SUhv!#=(9I$ zaBt&*Ar2GXglP`}c_6wIAEWzgK-SHJ6qX5>4j|@5*V8#G`WZZlZhZ@2iw7$+T;?l- zVo0My_;9ULh}wG6z;N*VHZMr-sO@4t7Kz#gYgtj z?3udF0UDuk&WL8|Yuc}=;l?FbFZPq%9~APgxaQgL92r*><4-#^*tDokqup@a;f+ZE z&$*@>%W)y}#om|_VPQU{?@oWwCP9=V5<#!Ab;8;CWQL=3kbgXx8_h}xaofWqs2+0p zVd`_h_t981`3d&ia?elx*sN)sTYng41mZ~T?BR~?I;TERn%auRmLAij<*l(xy9oh+}_W_%cO0vEW)FkMskgh&C$ll#0$sN%;k?H|PM_&?L%o3n|gY9wD6^$l zN+zk>#tLE!q-7G(XH1Y$!d6|?XHhA`XEt$cvaY|3_{9O{D0K$?^zI$b?|&ldU&Zlv z0rWc?U#M@I9^K@D-VfhfZCq}TTI!eEki7YUh7KXF7$;n`7?i9BMOUJo`81nc$7I6=5 zBfV+3sfq1?#ny>a`oWJQdtic>>fBYz4Q{(Hri2cx&M)h3^}wO>eqRU`gcOxggORJU z>2xCriTw_5&J&BqWa(d^vU1=P!#HD%W4AK@UFN2%ywI{Jd>#P=1iA_1KREyH1eK_0 ztY{x=Ep_9uPBT3AQMsBy$#WrPE3)*(e^7)5jCz&+)3FL9Ju{YQP75^eBGHp|=SN?= zOr7|Z6k6_v2ZT*EfisLec{XhvJMi>H5O(1$p}Md?coY(4RXC84cZ)M9&a-rlko;|3XrX_2=E;%e{F*FSh_LVMat^xC$kyrB^4HGX3{HPJP_ZBWB* zvYwxp|L(!o(y(17RYhujyc2cCzy_U5&vb6|%g!}suE#sPt>2+A+FMSt=45f}K2x+H z91HL3^G^mnW-h-RG&X^{;8n8nle*~HrEp9nqezzLU8?`43_g$u<8g(M$1N{H=gW_Xc2C6twzz@0HfNAJizZ|u%K`#$vo195w_#o z<=4Z8Sndi!zpc}#I?(tn*>;-rn&SorR6rfY*Ec(G=!EPPg$1xQyJitodeo&$Z`X9F zdqvRiK$4$3Kz=_d6n~B{2EX%Hs`8$ge{H#|gxHMYDgQ9qBdtg+vnvXLSw*F9@f|yF zENa@HjWmbBCw>etKpA`r9HhL*UShw!X3(53;Gn~;@Ii=$@99|FVL16^MXlXmVV?BR zX5lvD34C0_KYl|3PAjui;{|ovqX&=YuAWJsvgI0YFy5olhDkR9U;5`_2GV5h?MSJ# z0)fTQ5}V9ejp@45?joO;`|4bVT<1#+$m&lR@M)XR8Exkn>B>^OM0Pmt#5aO&F04@!U8x?2ea6T6<=n ziS+1QwJ%i8#oR0%{RrBN~sW9AkV8TJYHxeNv&VS(tC zrX1JYx|goPb9c?{f5Puy#9?M;fM>p3x4K)?Zn_IixSnvF-|s*~RHg(d*wH~q*$q}c zad3pMnbCzE$Xqfq>MPMw-PSe)^s_i0bP)!<%3yIs<4r^*K5H)R+&dreqs>?=lV`wM zOJc4{mo=hCOD-V zr1Exb;WjZ{ECuVJNv-I%#ff;TuKYA?TIYQ{jGwq0l^{pX3V(kQ7T(0{S}X8v_@ttL zzATajV@?M%gP7JbWe(SP^bYpE&iZlfvn3da0`40)@Fw;tm;G4N+prLV+L&VU$@-}W z=VAtF|VNw4YOT zLHF?i&Y@}{CU9}=Gfr&yJZOZ6ix2Y4-u9P?2P`8$a<*%`@V~fq9Us&s!7z@0Ob_H> z_|2p|uu~8=SoxZ!u+q4nCnX^xRkl(AJqH@`QYVm9m-C5emA-WDZdzVnf^~@H*8Ksy z=Wpy+q+NwFR_OH0F)S!ne5$Y+Z3vc5e<8PwmbF+Z9c+h^VI2&GEEXI;jn&&t%%;ds z*&7`~f`_f89vqpS0m1TwqY~C8U}(-eIjp7m7hwJC5a6-9ADDi$AII#Eq4b+Oi+Ygk5XS4nAy*Agaq10IGNcGhR?pjr7fJ5dux4`nf|5h z5=oqG3v}~!(aXRew@v`ZTR`O<%VLR?z9c=XcKn-HOwOec>P{JVvv38-8XS6oK}f!8 zgc3Qn!0{-Etb$pbpu+67yT@B=JwMl9lt@U9KcUuQge7}3=G zwt=X`1X>1i_g8nic-U?mHmZM#tzQv2)nA#Oh?1UZ|$eS zA~68jsJ6V}!%7y;r*%I;i+_%GQKpUs$K^XFjCLrALvaj8IQb~I?nsTLX}s41p8Frn zMtgyTl)sM4y!;gjV9};X-*w3Hp4>0W6B6r`Lbvsk(_7fXY!k|7Nm)yMshw80gadfw zTZe!P0?-iNV0+0zXgxM-`~Mg_ry$XqEnAmu+umi{wr$(CZQFM3a@8)|wr$&Yci)ca zhweWASx*@`^J&Gmaz*BxbBv3mJEaih1WEPI-0>Q)pM{|v_S9E`vEOFZtG4eUVw7Y> z7_r=}gK^zZZ>lOu6aPDJ|NHDD{R2Hj95oJnTuc!{$yiAu=}StK3gd1?IXH)&YhGL# z09Psq zAwX-4Xm?uU3I1YC@aJ8vGGO^vk)C{alQhBj3n^@^&-(2SXj;bdcK1&pe)a_oK>)3 zsE*mbG>6cO?q1qlll{qC_%N{0g{#u1k0{!pNEP%f*!tBow{Tc-ua|Wj{PAB@TfwH5 z(Z_x^L|T#?{3JR4ot;0xN_|V62OON_k||dYKxtaabs!~Nf0c+BfOlA~twP(Awk-Bd zzDqzOOz+UCcuG3E@#4(sHJf%lCYvopc2?pqak2_R?22tmNk4zK$F!X>VYBI{ zdTeuifi|~c9MTo*vxiZn*7)Hk08I$vafzk3mvlkd(py=`hj<{rd}PwK>*EguNWj%Q z>gk3Ho5K|q+P`kU(&2l!p1LXarjX|Kd?$Ora9pH7cx2Vk!-B3&#Ffn2aSd`-)^r6* z(!8C3f6|*Y3k)jAefpi2YA*o6Xt?&Tw2!%W*kR*3rLTi+;fVbRW+>9uOM9S%K08kU zxd!u^ZQyUmS^}PPaRbWl9NC_W3PB)20qr295d&~hYPZnEYTg5_`2Tm#{;yg32bhPS zuP3-+M^kmudralAPxJ3j7@9tQ=&y4mh4-I|FCar_k(aDE4ewSb41HM}U(SRfGb$p8-FuXAz_sKkJWy>vj=z1Sqw+_T;K1j;abr>(YiKb@`h(mvm;mn430aTuZz1>UPO(NYJGQv7YaQSF{sJpNM}F% zpH2rs5k`af@&vwBX~D6MTJ0tvY_fqr@sS zrHwI{$@sdOhb2{DqY6EB9Syyz5o^Urg{(WAK~V#=-cR_$CXg)P=Z)*ow-ZK=zYUwY z`U#$T!5>!(VFFF}LwH+oYzQyz6>)HL6l$JU3oiHcsijm-F_(RFk@AB#A~Tv6LbGRk zyaIZ3fc&`P;TIcxY&xIGhRy@a~&SNN3xm>o_-SE z(b}>|$7TTi>m11cq^}o#a^{oKgDLIuZVr7K2qOv(&e-vR%dj4x3o)*Kx?vLAbJHAP zTIe(YaF5se;4P&(E_R(+Q*&8-8W1^z&c|jvtow2#LISzMyHD1A7k{z7kw`0_}-i!FmQxVjeJMd?yB(-D_AGzA6?zUPkcs5^mH}5SlzF_WI$A z@L+I8P#^;BYEVYy{()jQ-~NqF{xejzf$SMJDtFR5xxI~?hdU>O`&?f+!*S@lYMm)Ad4P=O)rJ-9-Q0w0}1#o5Yv9|qHitO5MeM`S-~6}{UA9AJ*$hW7XCNI7`Yo1 zDJe6`q&0b0yH2NT0k8|q4tE12VzZpmz~}7xWnYKiDq`+pd+&$^wR~;D#_``dumy&Z z4pBgGW2~2qGV52W7mL9GiL$4|NbWlYuMlsc z=+|AmA0KoarSJaSr$v$SWKO7p>S|iJyht>1k3}2&9{X$0lFA4M@|Q4xq#d{mB=W!> zVu!trl;=i>>L)`c%|A8*SRO?IPVJatx_k(65%kPXbW-%UMPB|6f4hGjHcYy@ER)vD zw#iA$WuTvdnt$GbkAj*ObL?h7+_Ut}$-mr67yuU2b#M`Vn|EU7umWF<wW2ptGY?G<>Lc9LUA-ZTHo)Ko zv|UAX6clfzWO{rlOxm#5#W}RY0TD(EF zI4eb2YrR*Y=#TLs`WZA8zpB=~%%SkK2l91R8vGMhxf@-e<1f}Gf$J*B^;$`xC$VnU(HTR?^|IRm3*4(6E9O` zFO|wA-7R46dc?uzB5R1_VehQjl4zM6UmLy-n>JR`QfGb3BS0XB$vpVRUn1B4KQa98 zfT>5`UthXGzl?Km-ze}*MZ`gO<$+kOg}^SL9l50hrPDZzoVjmUycsRgF~aX`JrArj~0c5~Snml#?9c`E3Ak-w<*U3{iP)qV|} zuC^@+8)c0lX8FC8p1UfNc9kodHCoXR))$g$EZYhUOLs+B!e-G!+QjQ*=kYS^28f40 zbNlq@OZff5JEqsjHD7@Hb6eZEzG#0{@H!Dmr~e@=#Jv@@^v9>5RauM9Z2Mq=90?BU zTH#m9BwJuRs|oz8zj1DJ^h@IP&9`)30^s+&UjyH_q=avf53DJC6^#(IESoR~nOxPt z&eu$aN#snrYLrwup2h>rD(>lY>#sS&>Ue;c0-4QIuKbOxc-t1B+^PaBYJDK8N=88m z-!$W;Go0kVzTRRH6S)qJD!)^8?@_!Trv9LRsmVWF6Mmy{nhxqz43}}m*&KlM*Z3lS z6QQL%>-2#Jm)J*hw3VioQop;cmJ}H_gt)+BOY9w=-A{wpbdb657LLax7=#RJu2KuQ z#dt;u<>v0Lsf&xAAl&!Bf10`G4r7zx5TBMIAa8)&OcOP6b8^EQj#jEUPmC$s?vC@K zhI&}&eA@M5sirlroMI4No8n6bGbwPJsxR75bym13@$6H*BBSoA zi5PD3#Q!%)|1|R33)MH+=BHFG`e4+7*b^RxTM&5;;eKj@6|cCVV4*@&mG+FABMmux zr;O6i8UO*G1e;a74Ib`R`rc*HiL3IYtwDOPsI*BZ7`ls3?Ze?bm|s00L5#IH!mC$k z29(@V5=j9O@-slypXDs7aH|&m$xu%|!*xrKi}gWP^=6o8A3hvGQ%kiBzLBN2onD8% zf{O*Tic}4KjG<_pXA$~_SfV>Fk%kh4#QwFOYoaoKq_a0QS06=9vdA()dDO$+CTfDl z_zrX%&`aQh*CSXO=rnPO#C7i)46jJUwmK?r1YevzDg)ywt!>wJoOra5oz@E8&5qZ> ziDoVMm2WPB$_g&v0t9licq>&V777LlSv81cD-9p4P-LFehCl2V3_^3n7#&Cki~bw|TX8jC?z^Yrq&GaOF?$)KmGjuZcnx|t z`cWY%GI>qZ>W8>=Iy7G>O2mI2wB^hId0{N@-n}bFS-ZKFCq>vGX)1%OO|dBt+HQnI z_<*3mS$LWw_&tn31X|KNI;6{BA!LusESs)BVY1S`{WvZ)yXT|=xxoNdgFcZptEnLxgmeh;MO7sIGn{S>oI~sCLX}l^xLRYt{ znqI_MlP&ady-|hzE^{a14Q_#?*sTcS?J^z(Am? zVNv#u*iLwu(Zt|*je;DU0G(>N?#Ggy%oe0M??Rd|?~>gVLY-`9!OX@MI?{HmJBDmG z1Nka{fbNAo5*-Y;=$Clg?y}3+SQ~Ce>Ae7^KlWqy z{9kF~?f*_2qyPQd2Rs0y|BbY{EI& zm`o2ST#i#m90_UiD~fEEr>u24DhtBA=vpd3{6dDSES}t34s%jqT3g`W-~kC2)-dU=-m9oXfc1O7~JAy5rE{cPl$fW zUeZ@J%e?HWPDpT)8=1Kx=cyIoaPpsP*%DR0Gmta7Wuf2=aQk=b0KN8cKbv=(;6L)= z7@0(~bW#lNAuQk*3|n%x#S!kA6{kgWBrD``_`03^f8)Y@7P`Zyrd` zK2W~9%ii(Yn8Ig~bAAVO2I*Kqe-F)%r=+se^E)A8Ud z5%{VHpdKh)lO8Lvzum>csj>~c^LQ!pKSPOFD)u!?5SUug0toEl7xkJ9#*A&SRhXOUn2KE8k(v*ZUmnahWu$|( zCoF3YgrGMH3THutlm>+YNiyhgo@Z%U@+0Y`ZTTk`{;ok4Gno1`ZyAJ<3n+%|gm570 z^$q-39HkU{J{>gN@J$_O6>0eM2>t!L75$#Cz+lhAFJ0~+j6@_S0X+U}BJZkhG+9 zXKLkCebTII8A4U1K&euf;uk(~`)XZjg&{~&$K@2sIp5c5Bg_VX2sY3Oyi2Imh$vJk zy7Q}Xo>8d9!{`BoSY_{K;pCK{2)01*HNxEFqg7N6rh zYou!yC4G__kkgssHGcVsA;nujPMr#Ia85Xhk!iKsO=U6FM}Ww6@)>S#zSZbWl3s`= z+qi?iDA>%Y{)K)hfZga=W#mP^hhiv<ee38?CTLp!g_&&zY^p)6&g!6*<&2sF>-itLaQ+MJ#JJy<6*Swo z(WjK<+O^nQrFddUT}AHzT(@_Tm*jxwbp)~R;g{`Sjj1C1c@_XbRZQ>ss9NjmwKrF! z)Z=x}=;miIrUBkzHX5yNqJ!7ZR%t1nDX%~R%qzs*JvX0_vE0u&{9WDo-;yDFv^Qzm z6nZ}xzd;a*UU9B(cj58atnrQ`dzfXn#_ z2me_DODVn$1rafju$AvmC%hfBtM>0Rii8tYMRZAe62t*VffIm zsf2E0KLHiGsL52go}zg0IlcH_A@`p#Jil*!Q{T-3Ej!0AG+xX_(dL+L@`{MGoEXW{ zM=Rg)#tF~kuG%LcB*XFtyt29^JC*bTMruPmtaiiZ?Usp$1tMp#&xL&3ygdS5JwVu{ zKnA4MD{Ra_ENYnka05p5D`1;?#}UZ!{N1IgWn!(H6xF-t@NE^j3+y>oKZVI_O8e{& zf}Q!)1RKz|#%EYHQ z!(r&0YXrM$A}q002WiS1DH5?74e`Im^1*JoM9lS30GmPF-c~PQPkhk;jiaV;>t6#J zQnal77)RwmJ2+6CVcPch#B*xXGtM5Ygg;vRRIRpa5kJm<)k}e&=UeY3et=N`NtiAI za}1fJRm9lQ9=uA~PmMuBGS^Y!u(MQ+VSJ0+lP;86xwl*14aMt({EC!9*vK@wj3x*_6Ib$-}H{N<*LeP;UkU90T0^+8JO{9b7!F&;#&p7__fa4e7s>{c{d??r@P*aiTqbf8wZT2XBUwKv5+7rYZ6{YrP1<*bMX=qj~(`a9iGBt1%oG!yd|_ znNVicHR=c=hVWYkTTNsCM-JgJA1!?i-7_3XCm>}7+7Jyaf?6BA;HEFi!{)RTNu|=fxBB+8%L1!juXJ#1E1ddS5+3eMI4VM zsLHF;us3#e>`yD)xAOQ~W)2#2}-9RV?YuC2-~?(74x%BCRy=IUQuEz4aK(N%PKG|zT0RKMalo5XSpp? zK5;}h_ADoWkZ4=kp4U8UU5=65vk<|)$H{(g{Haj5;=CE3fL=F8jBdqX#lZO(mqUE> zkk8G@hy>#Xc2}_*FF{={)4QD~7hT5Pp`_0m;f2N-RXFGc_fS-BsGFjHuv_q{_B#*E zAjkrsNK2j2GrxiB^s}OSm2KMDq=HcKQt>~OqB~^bIBqY%2|ncDZBL$Bz^c>w6wkW3 zM6AvmFrT}Hr8bgD3ofHc7HHKv*$4j6X*3q{{|Dp%1AYQBzL{C> zO@bz6F-|PxbZpcWQLD3AY|q;hp(^T$i+VI1Q;k{|tRdk=7FcJ+I5aF;5sSv=C?!MT zbJCrZR|0T{m9yC(T7+nQgjojNAbha-k)#+m-wU}RN(`2Qn_Qs0uOD1bx|zdD6u~;T zjJT!-u+U#>7Rs3{IxVbhb@7YpE6A@0rXi_X%$IyBVNpBZwv|ldfLWN0x~?qi zrrgDZpRZBb3!?b<_J0wu{pf_O%bY%8USq`S|4@b*s|5u!;f_LJcAf&uBGWEomaXt5 zH!?##Ym$Y{#&t?))v$wm(>(WEC6R`a42GUd(2}dV%IXLO15~LikC(0P1J-3w>$g8t zu}Y7ZTF@RQY|+%LQ6eSjli9e&dlo$qtkUx%YD>|iJZmmbFaK;#dM-X7WbRs$nt0vX z_g`AAs9oehBbL1Nj91ryeqm68(? zb(>8?el+%7@8iXs6waYwk`NihrC|0ikAu$XZ59xCT(2bxb?Q6BE07p2fJlptRL-BW z{KD;cD80t^d1h_~s~c7P^wpCudM!N(F&io`X55J9CiNMYQVP;N>({$*_8ELw_CVKZ zOn;LDcOP11{ABS z&@~Bjjh7U(V+)7eLvzoIaZ8e;ys2lgNohBFj=r?a4)Z4RVnQQY2RZKJsoB*IS*&bU z5O5u&rblc4OGVG9J^kO4C;Tfm1^@8C$BP*Ar=cwQc+GRp0b5Q6<0?Jd6&RrD9bCL@ z6Jw_Kl(>z=KRVbj3z}*og${1;tZs{dd-cyEb;maKf}M^>HgeA|A*dS@1g`QAs<`XU zd~~I3O2T{^QG`BwK>ByX>j1gbvh1{~45rmISIv4r{)F1rEP!eldZTlzYjg zq_b*|*1MB_(J_s`oxR_76R-x4S`tbtd=821TQ8irpSx|ZXj{G|n$`jEeX(O7>5Z}t zWp=ABmNy0NtUX{~M_8n;ej4X*6D{IfxVC^tGL{y3()np!@SixVzvBv>7lSZ0cwwY= zHpV2+NTm*BlHSI*+vv$BWYLOT7R@4=#aQ7e6eCB4F~2zzwzey1Z^nKM3HYr4-i#&M z`~VAh4LF;A0UN69PY8De{r0H*D-Jj{5-E)iTYQB0jjMq)!sq9{zT)DRBp+n4Qe95pWP+lW>Y&98mmo?AXS zHQJNK`0Rym*W^O&&o(Qb)tJsfj|HnhupPgkvur;(|L}gn0Yfs|zqOcT;gqY}ktEi# za(!Ge!JWyCHBLf@Pw1ohw~%*sYZjnxCo|-;CNeI3q!~3xD0`5pD7z%39s#pT2_^+X zn_n5b=T{Mv^jM+&1T`mN!UquZJb#IF7Gf~8`i2aWpjR_?Q!hl5u_-fA7buf_5*`nG zAhIN--ZO?m9*Jx6;lcKYo%2Ng&|`E5!OjI&e1k0eZjZW-)J7uA`5jiRSBAm-O4MdoGUNry4_@dzaaJL2wzLO;&~#bsTE@;eR& zpj_;neHgm>a0GxlM~5y z$ifFN`P-2!!%Zhd;9PYF@cTu8k5qz@dn8a%ZheIhAa$=JYQ{5E#zH`&7q8-XK8L1W z-w2o#^Xma4(CoCEfrO((30MdlMgn$=i6Q|jQPNlOXKL@yW0oNOwVfomkVaw)|GIsS zLGgm2_L~gMWP}PuBkp*YWL7C_6r&EBIPS9djsI_E0!&ya3**_uXdj$5PU{(%A9~fH zXXtg72*`Ot0ekzA#9-+%?>Z;^UnBMaufTB7Fp%xrFGP0iGm?qbE&RrLcGl9pF@Dm- zMksj-c^#qjPYm8zO&RUvp4Ur-&W@zzCc0WBTm$&o!Ad|dc)@n+vDeOPX0zmQzeEi~ z7RT6{q_OKHpNHM+-o*1No|xON}NG<%ti4a=1|bZ}@$G3gyp zz!$`qh=uqSwiwrHD}9lo7Wdsn3&TtJNJGtJUUt#`=^7QAxc&Rx#ZbeL}7hyn1HVK@FyLc78l5t=tjnKc6+nfIz zNP>Z3U>F<-P{|Yje0XVh*Jn4SZ*@h238dAq-;4n$_lq$vn>L=p$sEx#1=GgQ$TCc( z?0?@W*VCUD#G{=NN^sM-GJGMPIcgmQD0R5=zIjT$D^6Ju*18#4>-;^~ww$32G6A~P zoK>hd_@Y{y=|`LkYUkiW4e${l_}vaYXYo4J;TgLsm?uT))kx1t^zz)S!U(`!t7vDQA--i`gsKH#SeXg<9rkX?K-n-+M zrDM(Kb`+pu_M^^E0{#B8Dh$+MD*=-MK!T~7A>&^!_g+)xOLs1b^Nn8C9~f@DKBaGO(oTZjaE(aaaH5&i{*m0e8v@rmdtUkgfUAd&-lSMOp(*Qg@gqK^=Cx zAB(?Gk%-F(?S&1Rv+4E2{O!Mi8vqP93?B@@-c%qLQ^xt3NL;8d1G1{htYds3)yf^_ zI<9M6szzu>cOAwaN9iu=r7^;|1!v=zM2S~{aoeBV=y4`jQJaQ?)H%rm*Kc*iF#Yy6RZtoXvk(NJ<;AubhO9je>4wokVmm~{B9aNk%PHxXU=}v zSM;$xf&n%~h75w17UyEjwP9K3Bmz#g+zJyKpf0U0IUTSh8(ELXj9y@Xy9czp+GuXM zdgo`ebo_hz1!&N<*~y5G2S{Q2M(*?0LT5Hvuy&H{ut~d&cDSDhq_x43k*{_W;mpC7 zTj-KVI5P*vj^t~;o`?VStJJ62k}=4aIe@3WJ0cR}0XYyAE<^Vd7yfU_@nfXJ$I%t~ zT&%BO(tG9~yUQIB;O{FBwrOYV+BMynaxYui(wEvo#W3K=}?3kF3{sl76g-jw1OjtBg`3~L`fC*U?B2c<}`ILfgNtNg9k zmg-U{!wm9#)zX8w0wmg{;c1ZfJ5NZ#XsVXQZH1 zh<8iIO`$=U-hVBdt2s5B`g>N&dBmAmpOm9@p5O=VUrKa&N4yx12&S7cp;(J$W{jKCF*9{=#P&{bt-TuK)AAEf+@sh+;Ug2kT z#7-A%S>E0pz#FappK;tu2;aWopuFxICG|oz(@{Et*Z*zjIH!3pYYQn#+8K(C#z-Xa1{&K5{Y=)t{JRgm- zVKm)Ud32|nEnZ{$BdwG}+(y!`A({L9l*8h!a6PZSPtZK5-rfA+4m7(1X4&=wou(>K zIS$*bStFY!(ZH_WZ}hfnYWdn!I+1*%rOLd}5RHM3)}y*a#M?sW8P1#ZJWxxW>@IYi zxeWe!)_}@?C2Vw@sJXoF{WpnjZ_B0R$uh#G0$6vfm}4+ALyM=bU>n`}O4W@6+Q#qy zk-xv^$i*E|y$WW69jwVB`^4k73{Bzor&M?QAvaApMyPlRIA@F1= zywb3=1E$YTNr~(Hdm(ERz!q1Zx)Kx@ z1jA?0^pIg!Q0IRrK{WN!giSs9rct#-Dv4nHhV&jM^dcibi8o~Vk;`5$+U(n=-`{t( zi*KutE-1AH-eATWw*J)M@uFMxcvha0;RGKLd;@`L?wf5{R=E9HpnCS0Y#3NV6xKWc zZg)TJ5<@>s=KC0z4{0QJAfB?g2kZHP^2V`JiHjV)&HqRC0Pw#t1HO&+jU-xJU?YnH zl}7WImWrg>4#bOsO?FQctn$x}=3`~;8CtbZ!kE5ArH!jIhU_g9SFjW;AaT==Ns2Ns zzZ>qmIq*LzaQzmG^2o(wivENwE#qncSSeF#EHLtr`Ll(gPoSJiHgo}ES}Qb)<{@2L z$d1lz3P&G*)VT1DZX;rW2|_?#`D}t`$*C3^h`?8d=Q6SKd4g0f-yMc*5VnaxZM5|u zdtbU0jBLcd3+QjGz^`B!YaV4EIsB!Sj*g{j+W(ET@%q?j8DNTdCOiaTpOd`l zMjp{#aG~ESNe(MefScc$VwXWcW4;^pHPMX|8dX)3w%uuRxh$Vk;6m8E+`wqB$=%Ev z4K^(gyj{3lRsL2nFnnQG8go6wq!sdZ zddp25kzMi2F6f16wWpMnnwN*GQd+b5jY+aQ4Fl&p(`?Js1v>IM6g#6KF7^EwQ);jk z*3Y42(#ND_#+&pu8%K31J|CIY)r{CVXS?on21p7FkTXN3m*)Ma78!-8k*O+QYM_73 zFyJ?UyWeiu?-<|lx-QtbV)fb;c@Ep7l{x5>f)R?LVl#m*D_buk?`l6ivI) z5bGpsap`p^m|mx_>s7p>%Uu@P&~)Um*L z$WWzY%ls}X+RI>eo^z-{lwRa?uIWo(Gte3!?LF0?)m4;w)~+;@z%6(|au{TB)fR#K ze7TdyQYh-%@C@RD0fCUC^i|^+#-F~5*SczG;%iF3J@4nqV2yy)A!js7X78O52gasE z^;*u^mUF-?$_1V^v5$(^*$~!JUY%t0>w^xs0d1Mx6Hp0hGghlFPv2kvSR6g_6z~yy zE7fGCygxKen;Hwzqcw`l1EnM!O~t}ef^VrDd0b{jxw0H8muC?5xwKOGYblR4?= zq^8f%F{Z3SlAm|qN=@wl>9S72&K_ttzw!18Pvk3zPNZ39dQos8Jrh(18QaYla>yR# zn>3@#3_Pq?4Z+IiVPu)~XW1?ZMrVL3s|B>6eD?Asqe|3wC^~DEd|qopV`fALKuYlk z=522>2X3x?0iv2vruQ(lNk&dy$#GEdQo7kOjS=M9!1E%axi3q04~Y{P)_+zGF}LYK zBg1s#UFk40j5R-}mSLhD>%=b}^snLj8^zB%+1q<-|B+Xp z+BWaTJx0XgiN&?Nr6hoOt~AZL;+Q!#H!ojkD)}j#K}*mZ>=ih)|Lfx*zH#J=!>k-6 zjiAjF=;!tHcm_a4AqJJGqM(O#)FH2u5?Vkw|6GTQm?ffS;UL~PwfOijklBIQj$mv* zo<%rb1b^(@X9{Z~OQlk{1E7Lnilrm1yl*%HwgFXPvvt9L;Gu#cMkKTP|}T^Bd(A(EP*_TS}W z911cQvIzQK;Izc0D2Jcj^^JQ&OS3eM`WF+F~P2?ku*$~Rt;_Qhr zH2a}qw?~9~BY0z+Be!N2eUMkhj-Vb;tbiY~Rn{7nol2`ObKdR7-<{Nv9)jV4RtWeq ztBK?{v-;GUm(n~|oL1xAUo>?&bij(9@nL*?>NLsF0L~1)aiai&F=J56*Bd^Vg`3}3 zcoTN!|08Pue*x29N&d+TSrN~ew{VDdd z=<)-da8Mxm9H;5uwd!x#@NbM}yK6JE!YRDINlU_i6-;&`e=O!cFAqP%4CrZyB}Lzs zvU6AMEa43zf}@06A?;v-N&C6VVw`k0CCs6x@r=#V#G`(5#eKPp#}vRu#RrO&I_PaWB5Ik?Dr=6eeal) z4Y5t1*b-)079s%K8@{*@Ol_7B1f8j@u`4SvHxLq#2+^#%vbMgZ_{l`afHwZ#TO+>( zPI4rym73)RS{N%!(6sqtUk05Al|$d1fgSO0PF1vEE+t~&2#YW7fm2h^eQt8oV0)DW z8b)v#B1yPht;|=;1_WpDAHsG=#!p*s9*t>F=-H-)*gIt=F)aN6_l-nNb&_Z_#FxH( z=^%W>fh_P@{gHP3Ez)wH4ely-!tD0olW_%EGWe?N3Wfe`^!)I1naQv~bY*iff7kN+ zwTd3`t+G434oDwi+RuA4XuS|T`JmYF8?bLm; z+LkY*zJy9Y9J51UMj??_BMmXNQQ04!AbehCXau|(Xire$!(yG1VruLO+R&Wmx{>K~ zo+UC8)H@Ucy?LTVAp37=`rW6>@ZqL{B=ym2YI4O!!z!Ns_?MursB-C62}_(O}%7dD>ovFDRjn zYK%FwNAeF)d5<;El^6Cld~g2x{2dXe9k;t;(vL>+2a@S1XOKW|lOITaLLza%Kax0m z{*Tf~<|FiHO*niTYoI+x4A{v(};H&01U&@iuLIla%AQv+HMcbqKjBFwQGhq2Gbg{LtlZ;yEMU8JXUD&QrYyGtpdg;uGCiRWnZ8R!)rJ(g z*0j1re!VUGwr~9EN?ygIHa_fVQ(tiwgo17gX`HmL67B8oIxelfTJ8mm+Wy?57LVm! ziX^NYwqsqHLQt13sIJi>tiH$I2sHc%lC_fDBgDzEdL0mEeGAK-CJ%9c zz~V$1c16PE7%flB|JDM7;M~E~esy@aJ`ES#^J0)b@BtBY)0-|C%W2Or6VxrPLXNW$ zX@`Zo9--XeR5T!934~ky7>LiXBb*(^5E%`HPU#AyO$&X&LAQhf zvLT8`RpW!PIgyTLNHfbXn*2&q^CTm%iDqS-hb7389-Z`$k%OQP!O0nOdY#YsuJfuJcs)2}Lhj`0+@#;y;JCTp6`#qJaN%b(wg ze4bG!UN75A(+z|i<2Dyr0W>eK%A4z-U4*odgr@=VFnv9>1A)0W+?%lvr>a4Zr^Bvp z;#R7Kcnz9a{gRe1R8HK&0<2d`I6Qha*<0=5xjRhQHL2^O}hnQ_w3Rs}>CXx_YU|tKA z`VGRtxs($&^d(F}4Ztwl;Q6Emc77#`W+-w^ryYqqs%~#qiR^I1-5CMx`Qwz*MFYa| zD8h0Dq(ISSb@=<;)kb_Sxwd)2*M)ANXSIj^x!%3WY!Rk&hI;G}E8}%;Zd^c8L)cbJ zqK>RQwXO*VNrN~S+qYCYex!hzr5RK2l;dZGMgFtsq0|BJ;kw0sZa$=ESlt}ZD-k;I z#k%&abqEx_(}TeFBlJZ@U*meL@SS)~WQ27#EC9=^SWj-BBLTa!C*Zw0kz_L_;O8`E z;BU8aC)m(ZfLHu{1_fB!8AYuW z^f4TzRpx+(#)nerLe3qCb=Qn*zRgWY6v>aN@|AZ(iv2u)oa3H_;c8_4x z^uW@+-`)Z{^EcTD_|a{8hC?wdfwY?cTp=At|LQ2i0Od}dE9Ig~l(a(9|7aZz$ zG8cDM=nBG-FdFQ;3;@i=(uVXwoaZgkI1dKnV~U7z@d%x@gGJ(XfLP`BYWI*)aY~1C zgvJ5yGx5XF?ukRIsH}S4Ta(h&S28m@x)3@9%EfO)Rr5h8NDdZHLyEqrCY%z25+}Y7 zX}7t;JWB=pK!jnB#b8GO@IL4iBCeZ?LG>)yiV{KzoEY+g5F)S#<3Ba24RKeGop3`&Rb5rEUCkJp!Xz9pA3KBfE)b(RR zixsmdC5L6zmL3+UiuWA3R~0J2_FTC6W)nou0?cuckaVdI z;XIh@_TnRUajz+jKmgSPgEt$#4HhUU0xHkWu*quojv9hQad;FeSE7*~E>S?SZ*wbj zIs23)dUVh8twv4t_^Ys(Fu@90I*&A}V3PHjApc%;U`OK&eEVy<`h|Wgv1(~X^%tRF zSUmsnO36i7CNkY6$}HYW0@He?t#j`+rrDH#0WIq`G% z1_YNcfRCgk8Dj9p2FwYus1~M6#z;~wZ&VqP!!DJ>cma`#Y1=!q4P+i%8pm)g^+IkV zx_5ViSHR-PKjej!3|K(Ud$e=Lr8F32WyK}#d`m?(xIi>?7jtE-g zVtkpIz@CAnZ`4cPGyV)ib}gZp^6sxVQVnSdhKIZT10T)LDHWcv&zfm3ba z#fld9-33$VI3aa$g900ZH6+)$XP8{7Ygtri4m{s1}j zP&>C?OVH+aGCteh!~oXkfDTKj4phu8cu@Hw796`mQ23<%BTe~Va}Z&@{~l=nxeEWy z-_PGS)U_J)NkQb+K@(ENqyvajihgwkR0$F54&T$yYN+qSC^Iqx{AT(!w_z# z6u}@>$FcFI@P2HVxW{u7N6u4Z3SsUgM^YtFb{vFuh81h~k=w^3>p01?{jTBwtsOKS zA&B{CuLYRiBl7s{g&5+rms38caxK!YaTXL02*M5Fs@wl~`w|_?xOw&JQ+R0|d$7475{s3$1#|@5u zfGb@?est15m#41P*?70O6z*w{>=Lo6kbm?Pc|9;rih!ec4d@NqWwJ9tB|r&-zSfqsgcZH4be zU|fzrR;TUn*0QtfSoF?$S}pe7qZWye%K9N-P_rMbbvzJ;xkjoq`25vcBheZ!L13QsFXjGxoclH`>Fa2E9Dh z*8$}%L+e;wZJt^8p0VJM`g}gE1-sDVjK;qn6a0TUl+kOQ_a*5JjXqja;O78 z4GyvGUdakS(xVYhu^l5xlhY&4Ka`&)eAq3&c!!M-*HE-Nhzk0Q2zDPw!~2QMRVnt*V^Q zk^6=-ywy7FKvzRPt-eIuyV2=Mt;L08Qt#cH>K#Jy!KAD*@F?#4abHna*AbVzl()$B z3ew}L%gdAPP!-fh;}Z0-oem2uome@q-6m_BB$EQ^m+$9jY4l0Km4R_Poc)-{u3$6n zoStSnh9E_#sm`eP%ym&b{KEHA5hU24!68nA-^Ca!&=EcLMmr;)a3dT-vT3hE_6hjpvN8yGGP8x$>(*}}p{Y3*N{o(PRTqHoGBU8|qL6I@^@K(c z-kdmMmoh8CPC97Q;)Y83J79FSVpmWQW9@b8{;AyI7AgCBEdg>J1oF& zxqpynQN;2O{9A*clB#s%0~~!R3o2x|Va5XWg7@s5P?{r#XSoa$pSR`(ZJ43{Be3@0 z2YBv@Uyi#mYqQNIiX6K#Wv9Z2shntO6`&d#)wk?eXZ&eiBo0eXMkF0At@wzy7&U@S z*K2dH2y#-Hn7>(Hj3&^g1`oxW9z-wfs{q_Nv*i3a%#F`Z`(m8--5}gvPF%Hm3x=uo zTH+oI_?Pye$3sm93q)ue4$W=*VV)p$=d=wHSsa7%YxzY_`wy=}$Y9UUB!-Z{H@vE5VjkU%)A$CNOZWp##Sa z`2ad9n8KsHmNa_@AUIK*tpc7M2O@cRd0>bEhv zPmd5`bSO}s4R&`O3d1 zpk~UHz<))4^qFYE8DJis(p3(DgU#~n@^TB4%chSo(bYz*w|%mHBVJaLf!xrNzOcQp8= z8ua~VCaW|RT_a12AQCyOFdd!NGc1?D-EMlc7^QrOCtZ;%ANuar67i4sCi0S(8i;3n zhe)A)gGG&bPD|Z^Q_$X=&uP`$<_tc4lBb_-J)|ve2i~pl99S&XFAdBU3AU1X znR#G>72Y|YtK&9aDi}TVvvJe<0_1Bz$Fq=cPmZ`_M6%Z^cRuoVop|YntrLWJxI%Uw zc4^e__8}S_;@PS;MT3VVEP@v2as~}gBP2>iMtMz?UwRv=vPZ{wj~^=9_Dqhi(q@yR z*NCl1-h1U;ziU~mO}`m-#PWV`*YE@q2#kl=_-I0R!ccsJD;{zO&kH>m6~5Rp044@r zRbWkDHH5_BNp4Lew~1sFMQki(N_I-x&Hbls%<*5gG3MWLP6w?^|ATGpq>@G4$=q$N zlv^m25!wQQR1ouAv4X*Qmp>L&OJNZIg6(>0#QytT1c?U^dL%C-k}rCWA7T9Y@VGmJ zy1cnEc9f_JSbUiC996Z7` zE-b3bk9n$R@Q*W;DP-%0BQh8#Gi56hKFV%5`iuqb9Us5rmMwfj`qb@K)`sJ16{)V()WIo!8k;9NBeRerYRlG-=DXdy?;J*G zyeYg<$fHzMmdb1l#4^!IjE2sLPW|XZj`D8{{K2HI{I~GBFeHTESS&6mt@@v&)X>^S zJMNA7^Ob}+>#?@&bYm4a#L6aA>02(-z;TB=p8kJp`cDHG;BK~Wwha&2>U0v*a;hwx z6xSL6(Hhmn8iCNWomS^MOxC|RoH15I5})`KG|lGAWtew7!xR)>nzud}|7R1z|J4l* zz>(h7YIw5AMjcK1RJ~ZM49%jtHVA|BkyoGkuh*qR86zcxoL6N6`e<4Y*sV?$IF=H{ z3PccJQEy=QG(dX1cGI;88$(x^5X-qh%n(w_l)kSSl6Q0;PJY&_4;f^#D6TFPkG8}^ z!dcwsRW^>$)R?z@uxvjD2;tDrASbqE1EYg^wgoHG82qa`y-ce4L!-7mJ$2LQyDMcV z_v$Rl!~4=jQ&c0=0Xz6=55CX7C3W-*o}3cZ+EX$R!J-r*KQZ)~-qg7j5e9*;F`@hl z&5{lh=BEn~Ro$zz<$%Arjz1pSmQ?*tTOZQIwx8BK$!>)hO2m$4*ByLAnZK=aQdG*= z2h8;%!E8`Ygy>igHcR4pNaL6J;|${W)t$imtmiqIJ*H|0E%1EAW)DJ&jE=P9M{$o{ zI%Sm5y@4_PwX`53tuIki{2HseK8bxZ`Ky%9!!_g9lgMA(5@KT80j2{+oMqMd4lfJ74CX?_fG42r?vhHk817D-y6|7hCYGnw zK?#+<6y?SKylr3Gh*@(2W$9l09*jBL3O*q0OJ6VJE;^E<&3W;Jr*LXT;{mOoyo?^& zoA(*6NdQq^(X}f?9U-`XvnFPvTjf8`=|iz#|C=v+cdwatFKEf%_xs8Aij%=*cbL<> zivDT!r))k4V~!!J{0*uP!3}o83uK`J8u1uvJIrt+PQLh;IRre4K-k`>)+8mU)}Qn& zV$%V&FISDHKwiajVhYV{_}C^Q2^C$91h~5tomTbJps=U@EW#>`9DDh5zk-)Q@1=4O z5lZwYQ$oxOHarXFs9L>hD}YF1`_0yu1=5zE_)Nc%=Y(s) zc$ttBJL7=Ff!>?ArYji&s78K`cwN^&{ehzeBO@;$=o?#wV%zp^862jko3&GrlOakad} zjBRO^SVXw1^teVhA_+RPZ1_E*+eb*sFIZ@9WE&rYU24HbSq_Y%*^}oJE&TZVvqE== zi(>ML`spk!y&Gi-@C>iyi1ZO{GS)4{*wM(+7`bK*F&l5BOcp+~^ zE$2d>E`88YXm0<6YLuk3=~}b4(@I)BZe9YS8r$h6kU&;UB~E_zKX}^k4ZtD{I$mQN zGZ%1DenudFMw-^qCcXSfl8pl!2{iuQw~mjt9F;bA7>{;L6Bnc_1z=mZ_4X9cmUc!M z09kTiDM7-2AOb(y*^hJyka@p=AS$B$4;R(yrDjiM#hkSKOrN4gk52zN)* z3iQd?zdEwxXT+#k+eK2r!_R}VVCB6j(5p0g%4DJ&%ywHkbPj(Br;&Zx z^~?=-+5_KnKWcwM$tqPASsG6o1d^n=n|-8u68&<%%pCwAM2m7cL43cD4+CPy?&%T{ z&X3kA{zaB!AP)};zuZMOYxGTZPi+$PpgF<=q?yb8evy1;um+D?3wK+|Ww6f|@(9pW z4F;Ak(YA zrc}|a{k^K9sIBo(g#8eU8L?8vJa?st(sA3fMk;>nb12<+H&+4zd}Q| z3PeriI)*c9_T?Viy2O`0K`5;Oi`)ku(hEz16!J%XENn_rQt{%?kIp?pGyENIV}pe! zE?V%CtC1P_bQB0{u3W^K=r?pC)9@M7Q*h*a;u1E{2n|jKPJkamo?B}~C)*7Hzv-p- zFV(0uE41dn$1ZzynjOUJ4&#V}Jn^V+#*|F!PO`yQANW2D;@wlHeQ(tUO2?d%5~l_+ zST0?3Ua8O^!Pww~uck^L5Pr4TvNY_-i9*|1Ly2Qm4a-XiFrqa!k2)XRJ4#Slwspyk zwU!o-gzy+I?wh#6x~^=BUx!1;JFy&@?aJ@s)?Sg*Yf;R1gxjHWe*2{1243S?HLIt0 zR7I`u`}WAhrcaGy3`4yz!J6P0vqwuTi9lS_W99Y z!@bQ{2}JdD2{{rl27|a@4xr}jZZcA@oyRQc==l;`L~|@;QjR z8tF?_<95?&5wb+@5Y&#m0@X;e301*t`(R%~Eg7f^mw-S3&u)~#2qt>r7s`7Wv)?&+ z>TFWxRm&5OkSMH(abk9KMzUFN8yi9)|LhK?l=k}ez={|aE&Cb+$Bake!YKQL-!)LZ z7R6L?jr{YomJVP`iIhM_>zwC!Y#d=Az99nylF8B%b3qyPd|>-1R%?q4#{DOY*noE&thsw;C_q?ovs1&7rv}&*Bjr&ig`Jw%u4({?xmdsr< zn0luB*d*O{G3_tHNCf@WhVG31Sa)sEzK--RqdAT^Fbe-x6A(Z?tVmuX_)nYVLSK6# zPT}TPxB@|;h4sYA>L30SpSQ5V3Rl4a#~J4=2#3$0aub0R@2`5^hVJ;HAQ;v(m#c%4 z>D`?1A8-aF@gWB5eA)*9KCL6rkDUIi$B>!s!!2<$L%=e(p zxb^9pjN}U~z)zG=bljf{A;Gte*PhX;&IG|NXhynySi@7LbBI*v-*nQ5r-VmAOUQ2Ci+cx>f!$$mFexu8hBOdQ?m}etJ zI?`FJPH~v%cwM>ai|*+@-BA0U$k;zfVmgg!3zdDAH>=anG1!inX|`CByi6C(p`k)J zTXnwIs^q7}G4sBnooE4jGP5i9dQIj)S|B1t(%L08e+fVeo2~YTH)19H1f8xn3&={&k{nK^?s_*uQo<3nD1CGw(KKU;Q*v{_x<%Ci=i&tH%oHB_ zd#}Tv_#s#76f?|bLQ6;&5f(^!t?$vIJ+YI(>%<-WPpa7ZqPK;KE-6hUqw>Dm%E(Y% z>8m!4(;z#P;swx8@^mL}NSabEg>vI7wehDyy|R0}$hEkmWOmr@OeAKZu`=YiSf>aY zoz_*VLOln&b65Tp^j%hQD#707HdeTpRVGiGuw;uDv+z)b70AeR9MIP_aU%HP$&tya zjw+Ti6WwPaff~y(Sj+Ys>W18i6W*w`zTWms63448RaLSjJ1j;t2nUVb=Pp?&?3uWi zQw@Eqf1x#&OA$6e`%`58afAj6=1=?PLxBYQ9Q6}ZuW2B~A4SzbTn1=!wC^&Y+YX`y zNm5F-)_49-AV1}i$;M0dk_p8I!{?c|lzY2GQrTrh`~y6PGiT zH&s$Rke^^y0)xu|n*pKPtjngEN=nk@#URAvnd^yy_L85JUO4#?&j{pNkIeXNBY0I9 zaAhU;o@h8h0dy@29-P@Hv`tKK+jTm2ytMh}riI{5g^ny?h>{cwucdqzS?4?7A8ej@ z7%M?1^}t1ZW=J+7674U(UsSjk;J-_0D*G=@<%rU5fXFK+*7C4_`s=R|GId)?6FO#& zFG>QuSWJEwBj|?Q9{@aqUIlP!8j*gPp_h;YfRN-7uGTNGRy3xY&9cq;=IB?6MYayd zgvmS@v&Qfu+L#72u|LyuN;H5rKj|BFjQua^gJGV6VP=d5lelossXsZf&gm&AM1tHa zZVjQv?Dx9ik5dkt``aR3mW(;s!r)qp9!gd8Z^GCwe@7if&duC58htTY8mbaycFGoS zHx>DztXd~KdK~(FBRf)L%NAVXbx0ECWq(N{Cu*kfubzoU>G^+hUmPCv~rR6F{owZR&O zuE%i5Iz&efcW#7R^8osS8grK1vT(8*idQvbcu#*&9s~{s_FiENzJ$%Kf)_s9&bgXD z*$N+Tn^7-Z+;74+Ezd3puVjN8*ok(KcZ>naewpllTX#?Agv7veO%u&r(cp%r{c=_KxST*5}qDSrZ05SiV~(UM8qN>baBEoFv&So`|5mB*}55=UH5MKj`l ztO;V75agR4jmsIYa(sO*_2fJ*_oXZyQ3^k~1w3vBD%W(Qi@$%F?CoTMyJ25$Zdx~i8vPPxqKk;=(MfuhE5Wrb zlzl}XY!EV7HxD==XL!Hz2rx|9icdb}M|67Yb4~g-mN&3m`ILD(U?GR`nBSSaSq~6= zz-JE$0umdsW3y_B9-gWF z^u)a$s_U{_?>Q<4^o7_WPCFL3TPWB>%AO?;9V($^In`bs=nzIn)!Zb0*p8}l)Bduh z5Pnqqm0EbMI4SVYEP}Zkp5~r7^XIXn=cD$H^VZa;_@lKs>1x$dYxm<-5#B5-;dbY8 z%}^So8GuUzdcwOPEduZV)Qj2vxhrOIBXs|?wsTlaZhD>_>@^DEP4$34=O_VhOB=Ha znK~9{6^roNgt8oJn5O_N`}Ne7cGp-(AcZy6(ii%%>7dqny!b*stw%6 zpbB1JCd3tetvRC>&JGfTM^umDFsCGwCZT+xWIz<#QOjGN?Vp=4qK_-De|$O)Oa|9A zt;smxNBcUFhi}=$)OeZ*rgZ*zvug%EG0E9d4M1I6u9w5=NJH>U)HU18U3wg6qBBn? zWHJ+Pr^LEVS2TpAq51VzY51BUQnM1XN4no60~+eh^jiufSWS@~+~${Z>u)f>XKh4Z z3D_$M{KN!GLdL6^(T%TgeH&;Lc!Zb6iDPQgXU&-XhnVDGJ0yJ%6UEz(f+NtB()Z_6 zZ?z6v;5~0qE{{6DcQd^}83eJ&jert^EetsxZ^zD{40WfL_`FhmYd`^=(7k0u{ilVe zaxcX0DCy|oJh8WfpQ{^24JaN7ijR8pB}SC=Rq*Q~l?Eq42Yh8P0h?MkJFWD}YB6n- zM-?bevs+9JJ`$+?~;oIoPNlH7uC`TScFgWW@uhr70_u0d?V>DO6qP+WHDrQ!2c-S~6 z8kh=C@(v4ug{j+!7XIu0^UuAm1G$2I^g4e^uLth`$fsfqr)ky&YdYObWY>Y1(vchE zD|&^n3i3Y`CQl1_eJc|7kH)??*{wofzF0)0=iDv;wgY^17bX3?Fe~>j9@q(APbR_; zZe?U2=C)xRRgWS%2+4irR;l>ey_Ug49G5WUmKac;f0uPq7Sg0~W- zRTddbsLE}z=;g|ez^axI+1#3?w{wq=F3+Vc#}uzkwMy<|JQAseQs4<$qj5g$)DFj6 z6>KR17+eGjPjk{u@)Q=xR_u8O#9E#jRp!o8H?KuwTVKZjEy#b`qN5@$#FBr3u2JHm z;MOWcJdy*A1MCS^Cme%ZxM|!pH$Qj|i@$GZdXklmhd=MI|^t2{gcyQaU znsi%p6VEZ=#wD`F0Sbh4zOSR)y|o4Zs^gjHh`+Dg$C7f#DU7}F;c$Ot_>?c`dRh+F z=TMg=DcHU#lfnk_rJ)+FnzP*j_WySVftd&I_#at7sGUTU7i25Q+RCbjp0q;!qW~D- zl|*3~B^;X!9*lo}LC*gG*;T671juo$Aud626u*XpFH-S?Ei*mgb*Dvrxd5*x#dl~* zXL}q-XxhqA71+}!Rl&@D58kh`3@c%z2Bo`0`cPz2436rUPWe1O#kX;;4Jgf%BeJ{G^ zkT#}h7zBwyssZWuwaovf5Djryd+}5-znf$fm9MrC>5xfDySw`1y0>fRK2m`GW&a&( zNilUCFpU1HjmqOj4C<8_r?ampj2`8iLcjxX3UU^zCu82a(ban3xEJ>_l6p(6m>S<> zKh_A*d-GzG4zOu3L@Z4{6)n;N&b#l~XnMWBUsi%clj3&7G2y^U<0O+6 z<3rys!gPsEi9PYDNrV01xmhgQL~p=b4F|f09E$OtJ_|1WMO`Th1Ie7`>(x3+jsBYst!YgENTT%>}ilYaxD{&fI` zV&HkCUp)qY1@u&@IEOj&Vee_KEhef=~q@`bcR8#;AfVY6xUP6;nf z$3?#?vHWI(1u(k91+qhh^|ew?o;9BD(tEmndd@S`S2{&LxR*C*bIDT^GMX(oA%0$G zMN(ui>m5E`&t>d`DVJ{vc=slEV)75D&a-7!c|ZI#5YdUqWtqmvIBNv2y!u*>po%Kf z=_g1&ScAy*rf76c7Pq_?LWX6)o15kg?S2!d{JZI}fM7Hn86unJI5>t#7}6iNd#eAH zd^k3#2+ewX+ls}^uh3$7qJ`pg>3~f@!m*Eir!H+(iO!KZmr9ed=)$#a-2qkFGk}>H zU#`LLmj>%GPFQ(Fn1k#@>J+|gE(j7;SJpib7$`r_ZdDx)NSg?d+yVghViW1~pSH2- zf7!-Zf9p+n=_&dTwz1C-7_X69_}?$TNJlk@`mDhEQbGxrP6JH=NHJ?6Krd=YWBMDJ zNu6ipLC^xaT&|O+Lwsxj#O~Mc3?AHWe^PJNX(0nq(BB zGp!eCX1b1jn3?J`&%iy?CxWI>KCH_{+F2&v5yCuSF?fC$vP&`t)>>1MkHKt5cr68o zupLWYQ--Km^52!Ap1(1-f0Z>x_HLO!9r9c~qA(?753#H>GMmG4ijXROg74*!QXDCE zJZ+``ZOS-5Or>(Bz-LtgQ7(TA43z@+Z(}MY&2Fp;t1)e>&vBc2Lu!Ainrq~Ujhyr{ zH)f30Wvf2gX*eM&1>{4!HQB%4Jy!9ISSh0~s}t=v7e|<$v{61yN67GyMqOyA3nW-K zoABYv`YL26hi&v2uVgR#r2H$?e|4BAU}k2Z*pZ92hprQsHBK#mKAxz(3gKosL(Tg4 z&m`ZSff{;NO)PWV$>t6-!!HnisF*T&9E9t>=&pNyC4cN}k=)g%uz0ulBZUzj)h|q} z%h&qe3H=f9N931pFFO0%rrDVM#7v-ofFRRMR_NE^Gs_nxj-7kpgMDsrF-c4 znzv?h3eAvIf{dwDAD!_PGS8;9;eh>~SJ3CEx3s|XcB;Z=n6@`b+=3RnbK9&5ARUpdDfK6DLHoykH*p9|w;dZC zfGaoU{8RzzxrYwHR-rkAl4sI0=y}&Qf@Z)Pm%m&_lVK0l4Oy7i2PRavF-h4{&3S!f z(s$BiOPo$!w}OswzioUb0c)wjIqtMzVIao_&3Bc+?lmuHuY(FXK}akD3T14Q|r77UVj2y{hv_77$|o40NsGF_6^8fj&okN55s zXwEzLu46UABJa~>6pr*`GU8=lKq{V}hZGP|^J$B1z@wv*KOtv@=jic`GlujEXT2%v zzJNo(U7%64tpmCHall@WCZ;VFcxAwTzc>>F^v-CG+Uq5HwZ}+xs;IBAEooENjj-Ek z!;GT3#m-(jc|{8CdPuZN{sghL)!xLque{;oD5@fzlS6*a{4;aRQ;+bEcYnqe%nO~{ z?8Rfbshn7;z4mR@!b+F&g*)uWQE`+~j+sFbTe^HfSPOAjN(Js&wmDFFEfW2tTos9b zi^eugesoWfPZAf%p>qAfX)p|3d?s5E{-tMnvbiQ1DA>4%xIVLk0_?l+x#UDtHV7gK znjboZlE|GNMXbaf!wMj6Pr#bUWo*!V48fS(e}Ku_1D4mV!atIToaxjXybZz|pVm!V zmyA46A6tbsP{)qvTu)mzFRQj#^D#YSY9E6G9U21?JphFzeUuZ0o5gO=dkbJEh;!+_ zNfEy$Diwiv@2^;v0xAYu+WCAuV>>Api3)tX9;F2c!yVBY2y}rIepaNtlGc&TWCZBq zQFi4>^)pof03ai5yJ?epZS4gBqPQvySB#$_4v;@55^JEMqy;c0KK+jV(+hK(Q8dwM zl|%feddk^bydd~n!UYvn2giW)1F$N};w$8PxPBkx1~m0~HRxk=MJB5gn3UCv|7^*j zihK*@j~9{eqgu0^FR6n-9YzHd-P{!D9!x0JR8vF{Ps&V!M&j#Lpb9)kM$t(>*^1>- z==tWKxL1R*n-f{(42L6B$yHFWoc<9AIlh6oXcWeHdyy;ppB4WDCQhLgGauO$af<*g zO9Q=%WQxUbMp$XLDV5%766sFVGk|62QO$0S1=w<>h^2qV>_3EN7y#~I z_P!Hw;UIMvTWXWmyEf7&l$3}1j#e$(+Am?Cot=ks@cvVO<2&J&=H`10-4&{osC#|t z*q~KqPrr=4_`FnUYM|F1gD=&O;GJU!xoX_|`<4{ZhhXRH!yrAB>R2BNL2#WS=R-EZ z;2eu?1)l90dSy!vfWQ+ezJ=+K zP6|*$G8TR~tBZ=}YxU6CJBzo6#9wLF@vm~D6y?Uvc-eU%l!a5 z(1iG#+L6)Tva@fWa|dGKQmQ`FP!e}jKt0uZi_e>Qh6fh|%|E<% z<%zlM+U`HQi~9t-wB|+HlEr{n7_MVUny&vQ zQRl|1z1gqQe)>co`_93rk;MMaiinost){jWd3gJ}fT@KKP37y9v&^Cv0~Hj`FWa24 z08a1^k7d~ zQHV;0THSY#M}-ZNTM~Q<^b#@gybkr?)2a_%WV|U1wC+!}ZqH`nKbMrf#U>K%xEji; zkttjXig~Qbs>&k`j;;d21wF>7%CC(K&hVlYv#$q;P8F$1xq~D4zC_m}@{eR182IJp zrq6^({+wXZwfXOp z1rnk+D5%R~^z9v$@TJ3oErBMWgC3Em(|uX5Rw|T4NDw($iL^8kY@JMex=?^-aBFIh z=fz69zvd5fijZ=J7NlA&W7KyO0_fwmj zu#>}EJI8_-jxQODq`jNd2K-dzLMCE%)H;XVkriuTL*4V` zy=J_28;q8y!awr%|HuGO%)rdQMLO($*Sp{}*NtJaye02!GoW+Waa5neL)#B-6nGT; zNFe`m?Qr+vmkC3wm^zJ7%|ZAL51R>&p4bA*DcSPj8`Yi_5=1q`L~?*jlpt@Q7pxr` zsXdH89qrKCdKr{;hG+XiK7H$PQJ$1OjFGi=hi9zDW|LB47V{^;te&y|SX)@w zYQZmYrLWaWxqr!)C|wtp@qYZGWq2J-2P?=R6Hsqx20fls9rg0!J6ru@mEL%GoE&d{ z?$|$E>u%^SMA>(2n&!nT-8Ihs)T$XRdJ#ESH26q`!z3n!RHQ0(R~ro7Af7yXGH+57o1iu*atQ(WL-1fIcgn4~7yPluo!-Tz&hgMCw{SM)k3;Lg7ux}H974z7 z2f;2i_(k?DFW5hMySSCek_rzcy8OG)0ldWQ<#8U`A74Z37mw-09p7szgV+S##aPmj zy?ma*mz!?gQOpO#?C}+EApCEiMsE&EL>Q%V0D?EXW`0}KPhPiLwcKUWI*U|2hF ziEh$vPL0I!WUoG4^&*|R44L&edRawI^0e;RdTw$WM~Bd{H3Q-4^Y$rII-jw6T@c1) z%8A?>jtgLH{w|w1FjO~zlZyc(|1q^dkt$lg4s1d`?U&BW#Z!>_;rB|kTP-MHRy*+fH^uyq-FDk+tAVPL^vZFQ~PFPVe?{NGLkR5vlq|gqcDVh;Z#-w>ES|b)W~eD zC~-PG`0L|4a+qiLWurt=eTmJb^4!Hs~=#$oCG-<;9u7EOzW`j&XzIP zP_!bn3w6^{_Lw{or?^DOx(jjHdQL^HdWQ zB*NiFSWmKy;K`Y6KkVfPqA95s;=dbSXgTc$n6CrU+=$=ZEXRB)3p)!BgxJ9c%ZiP9 z+G;5Q0;7O4J3J0jJ3t&`5_A~svZvtAMSN{M;hADG5${%QS?|!bg_b1nkC+1Hc>JXM zD>hhn=z7VTONp8fpl2tk$mkCNs4F{xKQl?QDdWF@aZXEevyb`B=q0{G(2~$b!e8;NbsLpp&c64a}e>@t0Yzt8r-C-I+SUjfns3j(MIxA#99Wt zl3Rxy?;q_ZzTE(eVSnI^IHA-|;qCz?&kve{WxomzPH5V^qrK?i-tRB$EFt}npYE)K ze+!RWAh%zzw{5AAB>Pb=GpCJCZJih}C55CAD;u&%e^)iuQO2BqQ8!=c0Gg_vsTbb{ zcrT2!KcvuVNZh&jO_u;yqX&aF0cIQ?3U9V`lLX89t@EexRY1D%7MC5;3MWsJoOAgm z8r8m{Pbe1^J4rC_?CinS_QZ=m81buDs{M`=j6*6}D(6f{<~g3|R@z3S<0QVOrYBY= zq59+TOhK!AL~@S&+9n<~4cxsDHB7p+|3AX?e`OfHz6RzizR@aN9%`r0HD=t1Ze~6U z_^56SF8zag;xF5weqA$WQQ*wC1f5->#K6B3YAsmyf`aT-=R!Nofo!xG_Gvvi#<)~-aZ?$!01uo{WT$NQZL#y$?na)LJ_L{PSVGm|y zRF)JWQWH#Pk84>Kux)(%z+zwyy>Wq_#W36??kZ_%o$ch|T3y`azk-(6l|&k_}fk;E}xNSw}LTgeP-35RdK}x<5CN*^iqD^Uj7v z`wc+eI&l}&OQaOqo%j2`Xfg%gBm?srXE9X7k_$G3_$DlQy{v{3&d`>5QSLOvn@Z9E z=)*4T*#i8qFnr?Y+xoSfJtNTdf;%K1h%1`>1--fS66e8mJ&Nga5$~`!_L-hUrs4;v z)6q0-s??|P)kbA*g8Ysk^oU%zqcXTGdkY#Zy$!?>1ReGo$S^3Bx?a1oz=swJ3q(It zszmVskYo$CfB!(p@BZ4x?JToFhat~xfCpZab=UN*ZpdrXIfagDD%4peGUxTr&A9?& z?=699+UQk}&G%k40AT4?h5i>qBl!r!NHMfuHwmk^n9K0@JD>_Q7MmSnzg6ql2hewv z6bd8*JZgINl~JZey7#dJy*Z2@$no7ZN1-o_!~ri|+6VeK2>9G2x$3wCq2f)=fZ9@z(kO>U8)&;|LD`@HmLHg2*o;kPed%gBOUO z<{=MDVB*gr=c2;hxwXW{2|&s)T*-1>N7KY*w-fk6*%jEu{uy>@G%_V>hWf=Y5yEA7 zpYFWth0ta11^$}r1d{+T*%1c?tZ$tp%!Mq-z!*w^GkXsiEr zze`==$*wd}vFI1z%4K6f+5jJJdhDLHQD2<<)yGWk`cg+(`p`5Y?WG6mR;dZ>_K)Yd zSCZjZVJqP*+T*mCt;6X#;fzD34kTaL?Rekf&3;(EF?6CeF_E*QVTY4{JD8(*q!1;IsAv zVD9|7V}KfMS=7io4L%U#*2rbibjGR2NqVm=%TwQvZ@m-s)FEf!Q$z)7v-2H^?x7C? zKhZoInI>>^W14-j(ld%?4Z3f7se5*hW5I@@r|L$Jc@EP~d1Q-&CJ0eM0|jm!m0(uP z4^eoxfcds-pC5CK`I{L6|Fy-*0^ZCWx-MWPSuu7RUti~Sks*0VMn{la97orcIsI$* zGjV~mfWhvIKxsf}pv%As5cgSYVqak|cj5IvuzENB;6hE%JiDs3Z@}>R`<+3k?LSWJ zuj0xzsN^vrC*y?vrCNu+fWt2p>&gcebNFQ)K|9WbKMqlyD?V5hG7#EsajLqdi$;gL zZb8RyzkMBUD`pu(vQh#U{%7X?r&<0f_&a#c39)svOQ^Zu7@-baS%HdweA3zi9V0U{ z_6l}lfCQJZZmVdMA4{+gn9p7VO@qG19{O`Fo*M>aV=bDF@*fR)hHseVG<`7xS-xiR z$y$7--cl{IZ86a8h4e~IGWLg(XfCMVU*o^^9#Y(IIr!Ge-yHhJBpuufP*@ET$qeba zDqtBLt?vHB_n{yDkvTdlfTT!D)%B;Zz&dOm!$Yg5KigUCi>FQ){f2bvU))s7IbL+7 zjs11WBwfJ_e>RucaEiK9|3IKwhf-f{FLStzfv0hbVpRLVvlwhVbfaQ;95l9ep1Jb` zAf!s;h=9gp$K>_d?8pZ9a|4AV^FohhqT2ke*fkuQmN35O0D=k*5IqDt`yDl8(z>%lQIp;??R^hv zG>s(!zryKZVd2WS0)_ip?m&kTQ*c~T22nKhWFAt15||0_mV;V1gk*eQ8sq<_DRC%YMCcJMP;?ZTTm}Q`|IPkVxuT z2&w|uhU~soC?UQXXtq5KUILWfhp8>LZ6tHnr=czM>fb$3?i4NNuxN4@UAf9Cb*>Y!&f$cBV@)+Au>U^-{-4>V-0FZ0YGwg9o(kif^$dOY#~2i+Z&4MNnKxY^4zeQuR+TEp8xE73}TW#+4j6dr0nTkcPX1*m04kQwT% zRgrFO@})1i)SXH1U6uI;>BM61_O#ogZ>rSxzK~>SV%K}#04*vv(m&Nl=p)KJ#TmfT zE=Cqc70h49jLVXsEVrp9Iwx)u>s{mw@#qHDbxIpd3#C!|Yq85nw)IE3Z3@i`%kyo8x=mn6=n>c>asW()>iMXH;u+mgy0PzizHhW=cEw0oggJm}q zgmVszF6Q;A9h>0AY~n~v z1PAgNq0V1GV5F{-^8anV)St|^lL|h57e{#$d_IV4gM+XKVokE%rIVRQTSnQwxZ(uZ z2_>i5%4E61j^RA*hUFLs?w?c3E^9foS|DRMH;hpm*#RML5GWxbvIxXr0sT!d<0?1S zYIn81m|(l%I)a)Kp``^?l|yr3^Jg@|5cw z%r-5#QK~+%t;RpI(zWP+M$?SS1WZo56Fi{}SO28rf8DiO$x{8jluq{c67hEs1qt?F zCEzBuSIl3*qW}Vra8|T{0@uUN_DA3f?F$ag&lh7Bdw9n`R>b#YM62(!3+Kv> zTl7J=aCHMMGIqRK^=VnjgI|;OV5Y&|*SJS^_#!oJ;Opa{;D=0?L~w@2=I|UU2|YnP zT!}0li%}eAWx~p*rvy{) zf*kzf7)WFi#Fc9e8ev2TLsDlEn}H*gV-jL1!Tm<>06Q@GXDX%vo26{a?pX6=9+ zJJ=E<^F~JM8faH-1>kqa(1DO`p3Qo$ABv8@gDT_c7c74`)^J%UXz#f=)LRj4G6QjQ zcPl2aL9U#rU)Q0sV*5ZVtcvLXqW z9*k5*TxSL6(DJNyV8N#?ANU^c}_hrHYb>Ll2;M=nX3tf7B zQnW=icZPG0A2w0zhDgFUuRu=mJ4>Jd^P8Rj0?%rCB9apv~xyqY2E z0z7b6$u*qtJ{@>OR3?(RaRrgx^?=%CzPvEjcqeob|=CI`NX2&RsaTqARK6uj{IvYZ7{ zV0OSL6$FmGvJTGh-f;ROk8?h}R_;O=G%_*_0s#)AGo(0`rU2z&xtAHmvwTi$OibVUq) zoloTteBxv@zKTC}<~e(~i#5I98xm^`S`q{#ZU8^PzJO#eIUec07oGRpu2G3d;B&uE z8#NDgq4n{oYZ39@I-UkfUY2Wq6E@6)OP)~^VFI}eWj%NMzFi3od##w!3mPmHd@57K zOOu$%n%=woMosJsMO*|^x}{0vZsCI!zhZb@yY71VmVc~x=qO;gN@roTExGLRY9euP z%tN|y_g5R=YW(GZjGaa`{zvR z)sl=p6=g1@S@4^fXbP+KepL)~2BEEtD<=6cu#3rTj?DN^wt(6L4Lby^?w+&4N4wi_-^g zC$hyp+`#+p?2b)EPYk8R|0MJuF`&O+?lBe@RKC2biLO7#q*3qmj8na$nIq=vAq|5T z1%fch@8uE?19;InB5{ySDVGjGw%<5m2Ah?&(?(mOKNFa-m|3pVN6uDJ!iys$&ar#H zEI^WbriUNP{nI^>w8<9?M5awk0MS6cxGUu>-MHxSe5=QBdPch11akb2k(Asv!fiNr zrEox0T95a}xELlcj1t!Ia9*-t^sU1Oze%Q_cy!U)4Xml!LQ73xEUDg62g-alc;Oq! z0C%^H66%wLh$XoU$%b>o-@Xnhwyd(tChM=1LVaoJd4g{K^l?xB?Z-(n3ewW7H(NXH z3X%2k%sR>LI7EI%l(!rL{tDvY+i11xWfiV?JjIk4#NlyTR(9WAgs>F%e;@qTiIP;> zU>H&x$YS80y87-z+s$Z4)Y5aEM{`lw@tEnwOltU5KbP0I^cny9n?Zf`c;treL*^;< zr{DWZ87?KFk^Gbn0Rq+l$sIkUugzk9lEAp?)Z7ec9o$AS#Wyx9k0;da{sw12C1JnM zP6E*DZ9QOyU2YJz$6z7ZEJvd^aW@73PlBDut9RIw!?%wn@(SwXpopc`PbcvF&&loy zc>SkUuuLcitSxC+|ET9Kb3b3N)YDxE?SdHNqxM>ceVSKe+u85>W{26Z-+dj%b5Xy1 zab(skWa0Tc`6M4ubEO&&Vl~8YDt*n3J3<}XEqft(loZDiTy9TP#Wm_!f2`8bhuHzC zQeLH8tww<5HZ3I#AEscviwU&w{F7pTgX(=-DizN{y4zr(2b`5Nk>FS~?(<{**&8yn zKB^`72WJ0m1(;?E0QehuU3>mb$O?%Q{pKs)(8U`fBNeS>J03Sby#VAMsm~h`5pcgT zs_}i%F^s$&yiP}+W`S)=kor5-dSY=CArNi%3c9K71;}IAwL?`sP1}v9^-U0Y2|Q=a zPKwJ;g~|~uUM^#(*(4gYFuw*nQ6xuaTnj^>JKi6Oced8%)qlir&ydUaCs;X}rxw4a zWQFU740-K%?gf74C}(3>k&5itX#^bKL`WuoXltf49zdN005}C2GzOhKYhN5^yF;<{ z(!f3D1rFTX$rCn^=bQ;gd`Crx3vqk<*D?Uq3?RBVwqA+^$@GsmV&ssn1H@fJF=EUX zW3!DvbG7V-n=sHk-G+)Oz$8cyP_l86_?sItDvH&SXEa3X(H&wm`-J8^o5{5cP}Siv zTzT?YgG~GTk@h4e1<(Zev>V2b5$F__V@#_11WHEf$nhQr?(RSW5g*H&d1#g*)4Is- zd>I#*>&+vjN=s-PDS5^z18>0CAN(Ri5@x>Bh$YBXh+cVazQy+VkB^SPiL zuV=;S2pdu)$7J#UhTne$fT5-y>3cPoHdpbQi!J;8CG=ywU3U$Gr<*)&2gI+vF@pqN zDLjPLJf8JHa?6|;3^CR8pmv)iCAjrmR!98Y^N7qnlGra>wq3XxJs}>N6@pjjy2N(& z^VxURV}*#SYLV?{_Dj2c)JZ;nM^n@?9BWU5IAOt}%I7Zt?n&?^K!GZ96Hz{8kKQYu zn9dlEO+-!MA?Nb<58{vA?Q9m#0&U`hOaX%{;)$?iP_%rvMxo;p+8gh-(>;9?yP=?I za4@#lIfa+jHltW4ALf4LkY7DK9ppH+7gbbxwtVHJHa~;68dG+-0I&W%3FN$x^X9jV z_BzP-m4|4hkP$>$fY_`-BwEk(+DiG|EB^cdKSorONw+Ws?TmqC2|7*GmACtBbV@k- z0g&7$E3uZ}PMc!{_2Ah!e5Qh)07VF4ArXlWg&y5bY_m0DeSb+^Av<77KKu8$WPaR9(irD#UOkmao!K!lIp@XLNCLmahMf08 za;xdTkGlJ+LFv*dRUEMR1sSSq6!l9EiU-2;CbrimCzaMA&-fc|gTb+w;{Au!d$<*2 z9$(i`aL3A{GvL@&xX_wJ2`7VBu7mFy{%QFSrDG#*;+EJ89*L#5=kd2A%V%U(ot~A@ zMyG3dOx&)AiCTJ`O*bmFtu5oMleZ%)nTYVpf@&Ly6R=mEx0;e$a6vT8c;AdnGTC$D z{?|W)?*GdH1Jl#f_a%l*^r3N-s&~9BH}I!56Exta%XOxxFh%5(*}oA!f*$~tv$?}+ zz2>wYq~+x80v)sR>=!ZV2At`{_4ED~-x2X+l6!e5S2x9^@KeB;BxW*`LZ&i%F1StC z3!I77#K23yER&&#qra8}a2mVqg;d#CVDF`V8$xMAJZ43VLrT*Q)`TSFs|z$cjC}GC zI7kbeHSE*VC8snTbI-c69c`GfT`Km%2nH=OjGXS2m&KN3=xD`V0NU?^!;( zxCwTe_@cs2hD*FxP}ZFuVwwqVSMuinFJfJK-W*r{3@)WF|ZMqXfiNFyd>G1zV)1|gZF|JT1=YtyNoO9owDclwh~}8I z6D)4(A+!vsH5|g|qK)oNb#4{;xS?Y z7Kb>K<}j1xnwPNMji3JYf0Dp&M5G&wqMpt7h#Icjjr6xsFbz4<`T_*5=+%8W)<7N; z(+?QeuNUCMxDlA(9>P#hhH-7xby}Q2P&C&ta3}qhT}z%!yJ>ghN7(S9%d9%U+h6QR zbc=0Yil+w?AUS|64jyvucfqhc#IRqw`Fb-t5PqGRYC;=2@5ycya?}G$BCdi;9d=V> zWsTmDR8(h)3(3pZ-#al3Lr6cPz52?&)+tY9&>28EqZuIC0IP&KnLB_eazwU zHNE}jl=N@Co>Wjn1rlx zdMlK1v9*_xueBMi2M=e4^fWt3q!Ad?T0~=n$c$fU)?}3nKQuaNZhH-eVZGp0x`mUe zfLA<6?>*S^T=qgIGuIBxToq6sD32H&N}j2Wu!zKTjX1O~5+wU0-hOLM*6R(6m*$EP z93m4Sk+%3-w1!WI=KDU!eC{EM(Tw0s%<;qr5aEXh4vBQSZPMHq5N;A=sssQ1LC||! z*{m@8HFssXhM_dNYau+JIo!1~$hzXX)w_)N^i|OmZDamxz@Y9An_))70=(skJ(Naw zDAr=xgpNd!8;QK7f42rtieEkZmK!U%m6@oiq&U@NA$$IgB!wYd>%0H^GDoPqunPYk zLePJ1)(_zKJHX%9=EW|dy){kVX;i))pQ)1@SYg#tzO&}rO`X{Ft%2Ds0PJ-E3URJO zBq}PpJIiY{$P|%q1muB6zVgMUJR+Dz!-2j2Wx<{5tChp#@0`FIwTv< zSxBglyGhzgk^8`E8YQuY{1`M6im_I{%0s!p>n$yx1E>ORSUcIuh5{_gBB;j2M@4hx3)Bg-sC5008yy9k6 zdR04m&i>AjVJssZ%7L|5=>cu9Xnh4~$5H$>A3c+5vkz<;4)34NWEG2j<-jCq&1Yb} zD7X!Jnuo8lk@F=?ZCYn^OQb2?uxki1T*!M~n`M;fM{Ec_LL_)qr;ve88`yRxf z2tkC56}P;F0k zgSVypIR-;snG=Y_uQ_faKsDX+2eKtM5UqfVl}iZrpkFg26czCIzg(cDQHK5MOFNe# zXW9&3umQczWBIR+$Qro>eORe-tUY%<;HwPtq69`GEP7Ht!RpE3zX%qLn_`GZfdStz zWt_0nZ6kIQ{7aV_dz;X^oB9@vJj&gPfgaq#Nzt{_VE*KZ_XP{_dv6LC@(e5ml9tax~=rkNnI74w_$b zN+ln;3JKH=D3$Du4e)*28NjKD4&tZcHc~yrm?@EIx?f^LR_t0wQV1AhpM!i?2k74g z@9oY-*V`42Jbph`t%oey4Q~;5{uXN9S5_)$K|jC=>FPSJDaa_>_EhVW&dY~&G=D8^ zBiTpIH%*g!wpNtDq$pZbxqLe|s{>M81~;=L$mcx>Fto)mxrOt;yN&q@kADp-zp>b< zf&BgvJ7np^(&&q843zQ;zZs^SwC(E^euV_=pM+kNAzzF^8|hnLbyZyEY3&Qh!vOF1$_yt=IoACYb8yT55=5ouy`f5b z&te9^iLZ3FfMAAG{%Hz07sppq1`#CeLH^UEG}%Zr&_xxlK$vPx0|7s>sK|T##$>tt zCRuQzk^!#~W;pfddyGFEwG(FSTE;t?(l-TOJ`iC9MF4IB(vEjV(1Y^JP@hf3g zfMf#|!qS*~#=zkNoko^9oA{Q@o4nwau-K7lM}WYFW!&}>!8qcl6_x62S_T&nTScSR zX4$=3nu+ZN6HKRXF9fZSibnuws9Kw%rR zy6t~r_HSY)df=I#$L~=8g^#uMx|Ih&OOwHs*p@%~lf_YJVAv9h#b)w(EzIr-z(rn; zGs+Vx@^epoJemHEE60vtb21lwas9>!06aHvIszu0M!w=rlSKn%hzI+FbVkW#>>mK5 z9Qo&&N(m!;iR5O$ePr{Bu8nVRJb5d*NErX}vFyGN<5#(G3yNR*EMY`CFr3YISzOWS zT5O-iyJ@aG{LuC70Y}O%b)655ErP7B)Hin@U#nb1nTw?d^^yX*b+49{>twI~5pKvhC+_ z!9~_s=ppnulke0EDas#*F}@o*vn+TE{c?Yz{*?R>cCe}Wbk?IJHP0crgvnC;l|pIQ zN0ylU0FP4xbC5lnV_?-oi+U+O%}#?mj)_de9xdQ7tSM??fzsx)9#)Lo zZ&pnOkIf%v!CwcE?et)q<2KqEG~n8>Me2C%)lwsWn12+!njn4H)|eWB($1 zH3|6qaxcM_?5g`WF#cBwc;Erx;bw}7d0bN6p5Up`diywVVWOfv+e}jqxdOB#VGf4} zMIQAKqUH7mr9>ro=i#9(!P9WRMe;Z z_KkMQS^$2WkfPWeglkV%e8F=GrGIUVVyCD%0?J?AcjUPx^R*oHo0(0qv<4%YFUvI&Vfq28{Jr(s-#19u zIH3+X%U4y5(9uK!Y-$;FN0I@6Pj{oP7@&1me?%-b!^&5B682etXic*RN~UBwC@1sF z(>d9VCGRFXz}ZmB3^dl-W^2r1zC0FPZrQFsT=p332*BNxZ<1&>OW(gKdh%g>uYsQ} z%O}qE=F&8S-9fCoxsih`N|DKY7=3STHxTKt{QFTyr*U2s+r-TH3F^_n^Rj3U^U}KL zOpx?ZQ`G8VlegHL`bN`gsuH`q=pv$H)urOyuE1O+mIkN)CdmkF069xjt=>W*cl2$O zjSr;~+A?f{?wMWEdX8*Y(4z%Ujk4AkyE~NUT-y6n1kDfoxL#k77zgjn9zRuzEvL;F zb=$em#~CCEoLlJPg#TDq5TJ=6 zhaP`!ZI(c5DJmH5M&}ng@APBWgdWsnk?zAOvh=OWmNru%&4+)DUr>?cSO6LMzQp2o znw=~xKoZvms0?VmJUn`itr>+3I)DiBe!5Ux4f)_1c0KKuOh{~e)=!vD zwMae2QK2++lQW{BdU?2C007RnTRB@GsqQkH7I@E1S|_#>xd32=ch~w3%3!nilI7hU zX~sSQ{#x;|jMS}bKs|EzzeVbw6>ocQ=_mVi7pia1QK*pVRY1c8({5;h>%j<(n8Bq4*V;QcD8Xqi7Ec1eIvHQ278WcMZm(*9h72TA zQfeL>hbmgUDwXsrwHORSX8)CeZ&bW6lK6l}2lc44fpre0vr%qHbz$5{jbqURH0$Jg z=Y6pOStLe5$xh5iFPg_ld_mC7klrKn$6wWv8styAwc=;{vH$dx?cP zE_{C;-w$a*ixg_@>*Pn*&0xg2+Zu}m?c6t3;P?)w4h3-G`x&FRLGTUGD6nWxsyG)M?bE>hu!Rnb@n;N&-3b$W@lUs&GnJV##h`+m=aV-o9-nc2nzNV@nwxiqPh{7dVQln8Z zX(-pzCaZSYPmFuL`)J~|{+xj7D$5oY8XhJ(?;5Ux3#5?V$n7JXUziD~fRVpck#WVs zj8AFYPD81fndR8G@Vic5`%01!+dH6fh+K`~%BC@#6<3uzA~XBFmK&8e9?Xj)Ne}rw zG-`9=;W8-r)--?p6psHHum&3IHtwDZi?a}S0nb(@#peEd`IaZv@G91;25X!_JpuJF zZ7HncdR4y?;WUuSO({ZNM+z`y^>_Es>fXE;)iJEljE18C`?0Y9KO^klT^Me6{$PrV&Whl$%$1tNiiFhT7jE<%=XWrsg7w@v#yYIteerb%Yf z3ebm|j(rmh>UMC1nM=KDTL-?il>7%1L1SU>_?(uJL^G<5!1xJtWpQX>y0c#G0yvhIgzSU+U{7T-*O5Me7!`=(<5#3$qT$n`Apn?w?Sd z1W`07l6uAk+4BUeX``g`<>3JYd>lkn74VTxAa(`_6VnH1$}R#DZdrxa`a9i8Q)or5 zVT^7-D>nmIe``7dL1jl~A~Fg+ZFPBi^RoM~_Jq$i5{Q19Hi&PeA>@Zrwi}Q1k*a{Q z#_uGN8Xh`PBTBg^9TK-iz&Pjo%zLvv)1?3YWrJssu@OlmNY(ZF_eps3qQ->RQ-|E-x7V4;xu;j5jDQ9CM!|=&mut&1aaD*iJWtGkCUroe z82-=*L18p2NTt2(cU6m4OX2}LiHFkOWg{8HZ@ZM@H%xq8fLxOq?^z{Jy)3Qk2{R;i zkW<1XeBW7VQ_91Wb6ivXe@ELttND8D0{Cq@Fe+CeTp;#R)OubLP`_Zb~Crc&xg7NE9clOG@3sK~WdqIM(|c3?PNz36=TZIevZqo~b+DOS~<9;(NgQ_9nBo?fAH zZFn^Fm})`)iTV53n*PkpRBzN@O)-C}SKE*qnLtp|Dr7V+XY&-=b7>WDsA^mFPCgKp zp^*%-%!|?y@WPDLi%dj>y9%a>{akWrSImq8Rb<32o}B?|;xa`lz#kq!B2UPn2$?Bc zmCE=#4sKoLw0g92-K?_y+tLwa)p#Au2gjSL_0kyETtSBg^KdMxjYw@`&PQYJYRbj6 z8PP`41VO9~u&HQ6pQL4ZgS6Ae^A!^tZ5sq)!f4uZzwTqsgQ-Q66#_iOcL)E&dJUSmZ}1*0PTRN`5)%RIb-t^E-H?mqF?S(eL}e#5-PUA9=lm-3} zlJrLjh#XfjTzs)nnId*0t7$e?#3>aX{@RLyTkXI?L6XH(sN9uCNqa_n4HF~x5tdK_ zkSa!^rFDskdw&Nw9=$7sd*xP|FO1GIMKhKKF)-wQe`fm_v*3A`MtDmOI;dbr2aOi)q5-i{c!nuSsz&}W`f>YGFF1`}0>#;e# zfNJ17$ejt;t((ZpT~j4alLU@`-dsdSq19K0q<)_sjd)L9Dp1XaIWBQqgLNKS_mRZD zT{2^HN+?=aY58yp+Zs1xt8#95V$TJ%TP^KrQD_p~G&|c6$;R$8s<7^aue-Co^#&59 z|5%Bo`a)bd?QO+KXk4+)#&IBJojr>>lv_G@t&IMLge!y{+~9vDIEg&C-QZBW=5_%e zaYaTG$=JX#@t?-kw-z?!@kV<6%yD~ek%7LuyrGK#DOp?DMC^#6+8M^LEkgz2KH!&& zHn1!}#*2r0*Q*@JC6^Xqb1c-JM*=%rRgT}btJYC!zVvhJ{7Das|2tS`=P(XhE1qB} ze5XJ#M`f6Na1}|5z7T{YB9bnABULj>{>iQACkRZFpegMgIw19i+@F|HRjY%#|8Kvz zPDb&Nv+ugYO3RH3e)|dbgd0;wAyZ@oGw{ButC!GzsxD`*C?dqz&8x1U5fTBCP7oF= zSC)=OKoan6M`Rz{%>cbq&NjrU&l}pAUQr4xp>T^rr zaZ_tX%Z2o=ulp~O6r>c8#qex#mi^4j>~9Ox3pt=%6L(L^l=|z^zY?Bso=7f`J#jvC zq`q2sC!cQy>wEQ}s~QD}3Hj>&?O`{e700Fldo?c&jlJ%5Dz_D;+DeWxC2M*I8qdi$ zZV0C(lNg}oxp}emx5PGaQA919xhzIckf^%jb2;iJFm3g${(ta~{QtrU^8*hv0JEp( zj8*%4_D+Gb_eNgJu3cr-VIcmoekM-{tFi2Zcpa3ro+3u z4N5&#$Ec5`R8MXy%Q8ikuL|lxVWCfO_rOB#eg?M>IzuswG zy&-?8PA)H(wZ)4Mdkm~161dH-fB?FaRVU_Yc20b%jv4HlR8+LTWi=YXTtJ<>agFhD z?67$Kv7)_-I7s*xQLe?jaBAf(h$LK&P_c4Rz5two6EC$=loDC8@jl{!S58fJ1`ZNU z|Mf)_N&DiQ3Y}ReuV}{?2OY;Sp3eHnsfgGTd{>CaMV`^)`F=gB@w7`WDtB#0VU=~@ zt_=8{%9hk&*2+G*&6_`%N3vFt>LqAPLL4?5`7Y9C?ho*akRx!gNwfZ-8JQfnJ=P)a zJ<|#Ah4!owr#`wduNu?FU3h)qtmxt8s8QlA8yHLBJF9&Ao7Gz7bx&-skEfu&4vq&! zq!5>9^o?9Mj}n~_uFo^N8RO9H)m@OMJ~4Ed&G|l|{m1!py}k$IV4oI3Ht$Iz_xNm4 zXu6XdjIOmg$m*P~-PjqPCEC3kXiS;*0Os#A%}?u8r2u|1|MNAKA~}d>XGt%6kI+Ba zPg=3oMivHc^RPU^2+7m9C5*c*%6eiYaUmP2C38_39*I-e zuaiUujH&$Bz0s`?LUCFy)?pvJaH<5cQZ+VBu8t19DSSstANMx1+=YX+{*qZ0g6EG$ zGC{`k-NrT7i;Uj;WWR5rG&*|6TxS3I-uHiI0l)qH0n?r$2#RnlIjB^fxuWnIc@8rs zZRZ~ggyv;=X^M!$-FQPAUw_gqf(ck)e;Jc`y$tv`=u+dm4VdLl7-NR#-fB) zYWx|Sff`*n?clu62w^z}S{zS8{|dc`n?j zGjkD{ep@6Oc{Yc+C|w11*Ue8eI(-U#4`3|y^=#xJosC5JM+NeR~f+yK# z94FG1Lrgh5)ww*K(gbqS7^fz%)R!Mr7;9ea$YZ? z{;ldPCpAROCm|0huaJ=)3vp|clfZqon6JWyD@Qy_jk9)jysC&?ow^&%?f*&FzsS&Y z&%khlw|mo-I%)uRD{->Ja}*R*z|S^$p7X{Ev0uE?tevLAz4x6h(!0a4v3;&?S( z$lp4)UrG~7-7}T$&j3bl=0Lu~-W(Fr9jBLqPBZBoV&?>7numy1M5kJ(umR68yXSEXi0=H6dkHIB1E22BgaM{@QSc%^ynUoFcO6iODy1BL~u?lf?G22 zgWn7F$$wkZal3*-w$tM2SSAB>lH+d$2-1`wYdk2%f(GOFVn|L--CgB+D|&5pX~OfO zBwBOow!-pzOLerxiN^Mv#YU0mqNlvP^st9tAMQBuXaeA0CS|hK)BL>mI!;GJ z$nfR1;{}ujo4(v2i<#A|_%8I6f>!PSJynGJPU{ShApFw1lUjT0zHX(6=!`J|6~cSp zr~efIC4HSTh=2luGMSUe3$qsQDUJ}$ogL0@Sg^_O#7gL>%s+$-bf;+NCy&b)%DSAD z%gLT^SiNP0pvPyMY2Fr~z(>b`3Bc`Cb_h1|!8!PJ_U9L;MWkN&&V8O33P)XPOx<{f zBOc&s5p7}9w`g|-{sNiR#1{CxN zVJ%VrG!WS|k>;JSIFXQ;pkc+QR>-3j>x~m0Kva!=?<((xP(+5&7v}L`nBJYr!ICLR z^xY^>JlGg+n6DW0W;2TgB$pj=$q_qGA=U1#?fk%zM1sGU9hTaP;ogQfG8G90@ev1( za{+|=(7%B3e@g@R4!}G-dKzk0kXs?H*(nLDXKG9ECdCJVjCCofMHpH4gU zKki8UJ%mj9ZKYOdmIuv7UbS85{gP(`e}QMdU-K)DXe`GCUe^D}OD;e5ReJ=1%yUS< z%=3%wl4sAQ@%kWl(=M=LmwJ_{6~IfAg*L5o3&Nu`@XXS=*-_k@v}lXg5kCUjCkJ4p z28A9G$-Z;7CTSE3=HMaf84jgiJW&_aM!IKu0iYMZyqx!5pnco#kf@>WODis!`a-6g zzftlloA=DHjZuS_?GKM1Z*mR=dBR=0k+YJeq#5-CeT0TFxsHI z&+qEwSQ7xXBs^j|V!J^9Xx~PUu}4XTDw{L)Sm@{CFX|LwvL=ljYLS*8S++`R$pKf` z$@@_p?|S-1+k9B5_nrP?N_Uca=|-EzTE+q+B)sSP6a4me)iL)7dkNk6(oP*d^8iv% z;)e5;D_OcS7n?XcE$YRlW{5U^NT&w4vZcN!1!j{CB z(HRL@xFQv^KF(Vu>1^bWi(V(-J7i7}#KnWRae=Nzc4s7RX%!K9CJ}uZgi50GtLh^n z^`^sbXKZv5DoH|%Vk``pOU_X29oFN?xmtl&ZPTkC(BrATfh{|kXkL`GWmJ350%$n< zMZ#yC(CqbpL+C$P($n|$(oetwqLv-4R3G2y>`ENd+wE}T5B)@_ z{={|Lq^dUggcHJzkzH5}QVt*PE$qpbB)MEs=o5C(c@k&~M3=rO|Wn zdL;GUGbxhC$WZ>7`>j{XCmEn0n|9G7YzL}+fa=^(-`)t>YQ7 zaWhCYhSYojPDD0Q+qLi@5~&?pKbDaCz_@v(BL)2ah&e+9ga#2(Ny zjQ<_zCvm655VWhDXA0G?nX>a^&Bj->;}7;FEdUgoo(J$=e}mB9m)euKA1uMN8GS++ zZg`9C{Ti7lvmNZEwYLrmlHhB4#4M~fm=kwL|MTi8+&u37pmklK=`}nLZs!o(LQFq> zl}DHFpq>j>^+Xal&%n=iq!F@BX2>o5rc=6Y*m**~hT_9>z$OeiRpPX!rwTi< zV;N0g<%+2jPrW37WBc3g@zqao_7ulN&9qO3$&ku8RUrD&rrYhag@Di=&)MKe_EBG4Un zn?iuj9C2$qkL~&5mbwHAJRUtd*`eT3gg3Z3o;we`Tp22e|A5Z_^$O-s?%wYNJUx^_pbqe2^1e?WOaq`f z^ZWOG8x6hbUEk2zi5mJ!oGRMc*$)tNqF+CHj|8^k8ArX}3T^ZpBcu>LN#dCRRElD` zAef<%Uf`oqogJAhl)I2Jd4d}sTHFxRZF2?wsNj)8xovPs@lOG`N5b8lJ7yYae|i-~ z6&;;j)Va2wd=QES><{wK0o0YzcLI#mohIINJbxRrw)PX2^8(%NAIIU*-E+$j)1(p- z%e>WA7ss|NOL7KG&TT$c0^dnxLf|%lT`HA{&w^^{XzT$e35??Pd}-67AhH9Smbogd zXOwvw&xi)XOG+M1WU!?B4>bnaG;7byAhlvos)WU>{dIn6$|P->|Aba_B1VYkB-~Zc zZ(F#wPfe^#FV=v+&tn(J%mdcFde2p|8`GDWMZ|jV=;TlXJ!zmiS8OPts20r;8*lvD zNwwf$P7(5kXK?~sH;>d^VW3bS^v|7P$A;0rwK=RjYF1D0iNl>F5K0r6R?tuNH zKWsT!>8LjnwIS<8M(B7!{`wW0d$FuawClpXCt|q~5|3L*W+Zv>Wn^IUvLVtg8~fQw z{eaCHFbF&YdjuCY}mZTc{Q>N{g??m3c6-2X!7|MCO|=Ki@I_){qRqzGyUbH_YcH1kHUG&0xz z2l8G_6K8XJMQsr?e2&Dt>c?!>`YUs`oxqHuX`VMuD+B#90u7(aFsb~|^mZ7{C05(i zi@@C3+uS6D1VrxF)rM6h{r3^`y);xWIdOFa_$mlOX1FhKDlbj>aI&>$pA|*5?wiH* ze%|z`t>x1c+yV1J%o$(T*_5m3g5y9VnLH(lfggHub$0~tM$N~r*vfB7M94WFER33Y z3@GJE7p$Q1IV3=Uk3?Jhc;U-_2*3JtM_&3oPCbd%je(mXaPxd5-czBP^8hLpEld3H zz*^L@P4#@DH!*{r6vu`e2byAS@v+y9b{FaIGMkLK|AA~wPdA?wTv`cP z;5sP_f%h@w%|E3f9OR}qQ(0%(n`bpy0CABwO;%!*Gb3ZR*TBG!gWc++ETRv9iE zZ~NXe#DHlNI+$Vu6hlCrY!GpK!3fM7-gxyag$wC`DUW;G0@4Z1A%E;b_Pj8;oA@hS zJjv0d5V-u?*w`f@$^ZYt>Oacxx3{04Gv$a!+8H4mvgl&bZnfX$6kj_Uuo26OJU?2L z8Yo^;xJQWOXE{%DndD`Rx9YOhiGq*!m!~W^zUBe=I~4EzdYuZ?T1a;Nun6IU1ZBN%7xK)- z>I48Wm(~xRdph;@Ypy4*Y?yslc(-U|=W^;d-#9w86 zKybyMJ2oTZ)tmtlriF{F!8W9WH#8zfwC-R#U6#o`(+BjcA#w72zWN`~c>b=UHuy z`UsqcJFMGVqlH!REnfu`vdylsre3Pg_Xng1R-z4P==dotE?&>I5JDRc4nRv3_4QT& zTZItE$ZCw^9;rWZ$SrV?m&j=6>vhhoA&lovz2pjIv+c2T)z5kZ zbh&*Q4E9Ru*xH*?>nxLz@u_vAX$<=^s@a}pr@$eM#z%qiq4VdmUBr^jr}LOX%4qCt zdj=+THlt|zNw@JYEjx+Q_IYr+Dg}C_xtlSTabYUhx}HR(U6adLKla1(vgaYM{XiPu zbuGFiLzXAZJNQ5~jc&>X4AEE~Dqk*g^MZ`T$2?pffcAI6tF?NLT!AJ$da(U#=tNb1 z{m=km(+Z}NiKvp3;9uFe-G-J*?D0^A51Y@i4##M26>fZOUW{;Sb#kNURbuae)4U3X zX>Jn7y)G?me=n-xErz(A-WdvJRfy4)EHLEr*?vB@YSkyP-=OqCR#aR|F3;Og*~Ecu z03z|12PyUS()K^X!G0?&Gq09%N;6x8dXn&^4dT;3gq~|(jwAA57a5D*fx59V;sp-- zOGX@lJ~9{cbiKBAU5SU_BfAu;1WY;XH(Lm^q{OGAoa3L82oR%!mE=4*JF4-wpzDaE zk}{3(gniXb<8M)rs|omkUY#s(=-3F=4Tz4(q*2TY2*-h1jhy^wzYpIOpAK9~d(wyH zRgo9LR&@ou8=%&)BiyPJ?~5MCF}?%f=?S^8l!QI_X6T7sb3k2a69e@tHpl|+p1foe z*{)dCJa6bF{9#QSacFr*Qcs!IueY!wu+PWi+)B%9#?yLjp_>eS+9qgNsqW(hXEGcs zQo(C>GeH%i}bK5gVc2|XElhX&taD0q1<0mT*7Oo3$OtQn zW%fvgi{%Vo_~!{esYMT$8jEQi`qUf3LL-NALEZr4fnM1@@$Hvr95iXVjF&qcM2Zrt zL+tym9zv^`Eg;?y4|k{N`ZYn=WEdpt-{B^4xxE`!ihpHelRYY{Nna-=@RMsIpK!vK z#+S(QNMLDRgV7#)5SVD@=ruh**prEJPE-;CZco1Pi9$iT=eRE@;8Mia43vYMKVA7l zIRMvc(mHt@&oVcTs&rC*$#7pp6mrfau#)L$p|jhBp5t_(sR;HIt=kKwnaX*tmcf)! z#`{eX&?NxozJJY;e!hn~n5kS9yeeEDZOfifj!hQU3jIEW!50EKi1d17J4-9`akER8 z@-naI61mrlE&9>VCHd6qF4=8l_1*p-%HA=^)2G?7KT2 z+qS0h%-OTC&$(mwfA-#YS(W+fice%!#W$}^Pf=V%Hu=S5<&qD?eOn{JAd-&q0|^#d zyoec49Xa7-`6sDoP2=p#m*YrQ(e{@${`sP)!b19!F@y}NuJEW;z+4!e*6VA*?th=% z{&z2E?+4E}D5dRe=6#t6WcN@mIb2;GYc@Lo^O0C~Qzm!y!f%Eb53ku2$BtQE$lfSU zB|1YR7yswhbrBnqrWChB;&t676O?=LR~!UU-KETiV}R8JfeKgu7cSeMz)*OH;F*`! zUVagyr>hHf>iaW2{Rd>suXnE_e=u8Ruf?n)F0a*_4>8)sg1AVK)sxs3C+tb!oHaoa|Sri4TH*0T~<@vFWPQ?^_|n11c6SkI^$U2y=@;+ zU*>M#V+lkippX8mdA;`9XRe)=5@U7&;x3@^sqt09jR6MWB8v+|9~pTr-{2^_fprZ{ zpS(9=nfm!v07IC3H>}IrYNtp`bzB&JLMgynz(!=>tAcNo$Bhr9m_JM#27Y}9G4wAW z&3!|IP}qn4W0VPecRG4LpzGxO z`b>M;8mcV6Jkm+fK$!>+lV9nawhsrZ2pIE=(bV<#TxVxF`g;^;jzT$fC1;j|TN5)rnlVlGyxBc3gSFkmWS~N+wPtReS_0pX z_Y)>!<>b>>HZqyWn0AWU({9L(<4ZOYyW@s=Im)$`QV5jnfRB{MLp3lx9(QJPi=xQx zRb`lU^r(V(DYRCphKpjB+sHpxuJ8w1TsSJZ#s?q>N&Icw>bjKv2*8pk5XXd| zIqd;JGcJIyvPp}T@@RRljzMySfow&bk8WPY>DzWVnd+2BD}%YPC<7}O zI(4I1n(cZx?n7${EBNLs1AcHC-oZ(kQ59#T7hf0N#SI24!C!-iPN4shP749LvF1C? zqB;N5nhyx5yvFrmh^cZI-Vl7$+UBz|#`!);qgzGSIPv-bE=fLTzE{+&Hig%MRrINf zvHbiG4mxP07)w8tuO7JF!zo_s-#9pQ| z%MS<9$uE9uw#UdF8W~l`(n-Sn=p+V4A8Dv=A!V(KUX4jfjqnr<0rxCV9u~dHFW3HJ z*mrp63y6EgFK&ghp48d-o>=ki_x-By8w~-rEEBFx`Xy*dAvQZ>c;V%5Q)!2oiSCPA z*+9H>EQ4tm3`3uBh$!{W0#5He9QXI@jv<{gw)s{&;J<#2o5oa%qXdTSJl(dW;^H_L zm@ZhP4maSjfQ&!Gg70-ssA@2}r>fAqK0~&^7H+*MA`b~;faNJ3WLCM7zOAm<5-Fsf zBy9ELXeZVGwrKBn+LwqYyIEfr}1}r*+18@@bzvPW#LJ?-(~WP^tPAL%TdQ zEHht^%n(%2&g-i7@OU7*@9!_SFw(BfYuUrzI1FWXN7h8atgg~ACnNF1G&iQcR5Xgi7IIxA&< z>sv;d4m~2LSGUPu=lM`$B`U^i6ug8fI?ApJP{?|C;V$>Bni#*RL2S}FsvVxX;C(69 zJxNRwv5L1IwQ(Pb*8ErS6}~M*N+P>XDh+mtJUoc!VEVKSVNe#Hod>{{-(ECH9oP)ecQLsLL zz8r*n1OUT2ARFS5Va*UmB5djS% z{MBgClLyIIHqozaMT}=eCcGhJT-}X!A@+hRg2PWlufUqYrKhoy68Z!wkCX%S9Fa7{N=sh;4g?@0pFptnJ{zxc@j)9evGeY z;I=ODmEDrQE_hUZz#h%?V2OcDynwCJ)O)&&ADN;=^n+|*n|?PCnugz>yhBQ@A91*v z#WRqkgXgW>JnZ{x7=5v_gocj3ze}8JvIi7(*+>X5_5~lqa>P zGp*5~*9emuyk;O-QhugECAcwr8#jE0$`{!n$6AMGkS0aZ&basEUyI3|PU&~O$E`e^ zS1mo119Az{!$$nzpask+pg=e7!;hPOWsIBFkIuhiDuiKqW_|i1vA?MoBF~oCY#!j! z{bnT)8H;sPuaiv{)CSDOunYT`sI@AsCiDKt>=Qj}i6|#)DLd(A2k;XkDoW07)>2`d z%o=A3BF8)~jm%RE4Jm_gI(wNHb~TB<#{2g%biZ6$K^(m(eM8vJq3-#{-9-H}ZvVxD z=?{Et_^n#8TgM#6BZSQ$4Of%anGeb~^XMjdg7(GNFA4E6H8#Wwc|Z@s38HlQyQrZ# zevBLuXMyck^X@Enc-0D4-aV3Pd$JpWIZ@X(NT+z2J}s?;fausKuZ+z=Q2P5z^B zT{+FS8HXw@b-8{7J3rYl$Fb~PN@Ca7DmN3G(KDfGUq0N}&8nYf&!Jzx4lqrRiTJj) zp^5>-PLyJAF}eJXt?yXGn*CTm5M zM}0%e-UXd4YZErHgkesumXWpS%q(*e)>3RbY>g;YM> z5(u8&NTp_r_ePlXyo{W=;84*!8F_{pxbRYp!o7jrY1IfYYhqCwT z-*wIIn%TiW*g+`|=0?r5K))z*=NiLB4YS_q4fQ4rH-~ve&ZM(LW5Fz5$;zH4WZR-_ zvEd00bTOGl?4oH!9g z8n<5XSjtldE#S0^o+#S!dO}O8#CR^`xRyXHMbhFnxdG|!5I?SF5U`>32)*co#@--; zHV`pr$TJ1ZW0pFhsOdiKeDZnz^fyKw@Vb3OizhDGVsHM$b8-L)StCMRQmzg0RF%+{nWxK)W<2xUV35qs8s!xP3%F z>y$Z_8AVs3-naQ}qm`qZ(jzmedAIvt;QD71IM>}U??8fpgAW*vgm3mR8GXP7sxBJE z99v+RcDWT?n+8#(W~&!!bjg8PGQqunlb|1lFCcD@xn<-7_RLwm{ak!L?ZmOh>su1h z@~DqTuZU}@>CPlK0P4p3Xr(&=Nz)o>P=YWCR>*jVS8l%-OoX$Em5}FUScmb% z_6!Ox8mJu^dc;1`8yF+PJ6juRGw*od@ku`I|RQhDR!Q=4!{5zH-oFtB|8^Fp$N14EB|I!6`o=OaIil=<2A43?pA!Ayze#7 z>!Aa><@3Iv;-e<_#DPg-IlFOZlr+=&8$&vI@O#nLp|qg>)B6x zgWG<~;XePksOfR*tpZ~q{c~(XBrQP>Y8ubenEDBJ@!;vNR)2_56XC>yV|Lu-9QIuf zhxa8h-SW<7FehGRrk5CIj641axCcs!VoOH+1v4!%)2$amH4MLVu{Bxuc_qHHHhNQ|JMp7`Y$v52>`;} zwIg>wcVVnWsT{wpMC8Xm!}ni3fCpw!&|dS);`@#s<`bpz^Cs|uqQ+|@xQM5FuGf4I z2kZrfYB4FYSV=>(EPn7!d?K4#n3;n9$RY+vB^@t%->i@Jklu==Imv5~hmZALuFQ7O zGncQvhgmT>R1|FJ>-h8`d1B7I7$`{z#wng&8QJadY&JXotl!6%P&4u`<( z{>42%yx5sKx0XYn+2)#oAAxpY<`eQVw>so6^`{4|K`DBd+oe=Bn1^c$x9g3>EQ>|8 z@}WdXiL{%Oi*1D@mtU`i-W+nLCj3vLd%-_zxEY8NMx=CqrM`V5YA+RBP)N|=Z-2)K z8NPo{J2pzFNMSTInw8lBCCWn}t@=L?-~MI`c^a*Szpm;0Q_LW4!bXkVVsvcz@WLen zT=t=%Vu{8N<>*lt@L}d*8^v=@w{`vC2a+XWz(Rl8YmR&52$IfqtFvN!vp(f+u0N%6 ziD>tdvGOK~!9J)qBBigUrGznzR|F7Kjh!D?_tj|qcfijns2&1C>%Ms zzo|_cqbplU_>;gy22U8S=Ns<}zMw|_I?*odBlQa3r=n+6nS83vT^HUwInF;6VZdaI z$0IE3O2d^#)PMN%=IUvFuLBp2^_zKw>mqpDDBoBrO%t&z`AT<=c9<2vv&iwk6829v z1Q6z{FJ^6S_U(fzb^4!W4MG$GRsFLsjT=x@U0zhx@~7R$P>unNFA-!KB`3q{tMU`M zdQKg4%fChB$J<{4u>gTZCW2#J7Wfr1ui?P*!k3kJWd0n1Jn2?j+*uxrBPj$##nD-xYtK8x?$E>4vQxX zTAUXF7CH5Tdt(YZJf>Q50K+d!Hpn2OY}PCTW<)%PjT;6&bYCs&PP>}f6D8)@61#Iv>hC)ECBzn9?wFcUw4Fpi~`a5R^*a1>W7@SXh@ zSj{W6PQ3G1hU1rc7z^zn0rbA1Q&`(!5Z@Lom`u>8Xz3||8~q(VE|DmWoI75fR|+Zo z5e_2Yy5sP2M7d^0irgbmUTKH6y2@59x}$?GFw$3@&V>+0EXE!MC&^yjP?DX8Un zCSNu5w^X~2eTVti06_d37i^H1c5B3HgwJHL{ZLP;yl8pd0jX%|j>$Abs+2r-?~@e1xv!_XQMlmn-@!@j&_^I^#^25p4q z_}OzZwZo!Oaz|dfnz^QO(9Mjhcr82T64VPQ*`K{>`+v&DnBf28i?%h^t>FE&swxQW z{|(uAMKlO_x!7=!$?9n~alOa(T(fb7z9OAz*xbgL1gMWY$P%M)9|^%vsNYO)y_0u6 zcdmpo2H?|b+2gUEWF&M*dz;$lDZ>cADVp1tR9Xfkc8s{Wy9w`Fvk)k(jF{Ce0tQw6 z(4|ye{x}sCT>z8u8&!y0cI<^GtVTUM^O%n$cX;twVSO!kT z>*}IuA;ynVo10*$ ziNNaehamVLC23>fXwei_(fnSD0~$>q?bhd%N-AfL@j} z)!6wL*UJFuo+Q#Q7m6jEko-+$n)}-G)&&YUI8T-o9^7k8Mq&m%7hH zRmor&S+R(Gw^@2R`ySMyMRPX{F}>X12{MyojfC7t+r1><#Q}e|S3o6A8Ct1`WS8(l z9FZblLnz4VU~Ds7D*PO8mgS&bV(jxw4|Sz!P%r#U8##=-tK^RqC`%xZ$Gcvw9w#XM zTo_P3GukF5k6Y_bpGid%S1o%pcH9gRRL-g8C-f!G9wlD~lQB=eP54G(R|z&f?^82Z zMD={_!J;1vj{7}5)G$Muqjxj&sTB`gBqKzdqM@QrGay|MS!(hsMu_BgYD5mVnVXbH z>Quuw7@zZ^q;HiIqmkRebn5IIbWrOvssc1+ac*?0tEs zktI8NBDFO=rHT*+n$5Q(6&aoZBxU;SbT3eHSH0IqWE3eBTJQB)vsviMR5Se;{nQ3Q z29DeIIrNxW5y?n{L30OQ(B%G|Mj^euJb>@6U6NwH0G|d_QgZmd2>xj1FbZI+VR@sR zU>ei2WNHQk03A@Po&|wdgasi#>xQlmD8Q~gMruAPrzoPmos9!neX8XUe80QlM0brT z2|WP$YAkS(8ygvKO$GHt)pwI6gYeZw1_AMIejOUOoqt%z7`j0h#jjMZa zYxB~jVE1`wE4U0mLgrNhqwy~q+jGiJ9xtUhzWQXvD{O&Ied;1D9Xv){U524pjmtM4 zmiXY2C0I=)jzIzP4LEx%fP7CdC}}2AXy%0)LKh)}rTXzc<*g`ThgO(Bq|lXaz%k~= z4KHW$7$Ok&3lVaC1OZaoRpQRB&7a+!h5iy9AyWL#%Ct;MLO*6c<^Af8d*DnqaTNtQ zNYf9Oz8}>3mVSriGS&IsH#2B832}JC(Ak)jg8C(#b)il24Oh=L4NWFNa$);GQra|Z z+-d^9;vi~L2@xePVpL>PyX7&@S|e+BcS{<| zSm_M9$~u!9Av*${ECSeY*pqcVk%?C3eCp> zb}AgAm!d>6Og>Y%wSyy|k~?YJcf50B)4L}bxYj?Y7+?~tn+SE30>IHbQ_g(zxD5qZSt?8uzna_k{p>Cfq2TXF$y3r* zD+8>Re%qGjG(Z$QK$H6hvB%~PCh>|A%K3wyFIhPz1tUm4cVyp`n3j>hb(iFR+1&=^6^|!37NI@S(>-2zho6YNL{#OMbDH9v8~?M>dlA|Lm@Dw(!3;7O%jgfFCyWCOFg0=EB9m$q>MXAGgXl#={S+4E5S1 zKGGw6n#lqgJ9y+5IHNN}KXEkg1I>Q96j+Upgkm}@Ho2`{kS}biK%~nLnk+14Av2&7L3aqDQE0Uc`ed*nBEX-^5z>MIY10PE`?hl z%^1bZP&G=|pjuKIoSG1fWMt%cBqeAS1 zN@3Ym18Tkv7s@F;05#2UxiP%$Rlt(gFe92$fU>XFLX*Kjr7i~1cB#!#J!}Hc9<;@m z>~fmQNr0?ynNm^H^Z%#A7zhXt4?h&byd*%HYrCj%R*lP(>+es1S=AiLR0iY2uhepf zbjQfDX}8OECB{z3^mX#+?pxu$1O3Rs-z^8l153M1IQF8zEnIGVZ?r)aJ8hek^-+zL zFrDOyyPG;^uVknX^3O%tQ24MbdRb}^S=bif0u&FJSj7xk$7A6d!KgnmpndiltI?M! z-a61vlGWx)J~AR2W#jrY26(n%SIK8H@cDi>x1a)zHnTXSc6bYqW?1K_Nl5qXnCwor zEP!&Q<+PZ{LxXKxMHccq{ZyQ8GlO}`fW`nDecs@M!|nb%I~l`iX60hbGr6D)<(_vZ zv#xyHFu=r#xF%jUjyd?%%jWF`Ljo%yDS4#Clo$^Kgd)waaw~D`cYy5%(khhJ#`$*n zb9ys7O&N}X_2H`NGH&IKK!QzZ5~yHq#H(Vxpf#$yboaQ`g8e%v3Vz!05vB^()+=IZ z6prxnC5c>WY!O5Ue16nk6s8k94&%=B3>b=P4n4!FfuR;}-uq~=ikR1f36)Q0FA`G; zS0QnDs`98dC1@8DPfz4(LN3HIRv3H{E}u7U_H`sou3N^G%IQ|Nyj5F-+_wR^a%pl^ zdj(rtMaZ?l82NUFt@5>1cnHsX;zHAr4bLgF+VBHJTP^PW$*s{HTmJyS>YSUv*-6`Po0SIpVQxqhc6AdD&N2i`A_swg2JSyR zusl3KpmgA%k%4n&wYnR60h8pnx_$d1Rjlt6b9s&)DwH))Q4yul_x(8>0?TBGOrNa_ z;hZ_LvpBY86|knh5f87ApRHP{7>wBmC*JI(#N$6ZIwg~FXgh(lG_seJS6Y9CN>1e} zsGWB0;k_sGfY6%}sn~nJHfhQPBGlc>%UoQiwSPYQnDQfdf zMvgo~luj%K&^EDl_L)#lTpAs_LJkUk^jn*MYUvO9$2+ zl|9^SD`l9v!2VAB-gQ~2YX=a&0pWWG0<1) z^P1{ihlAK}1l^JmB_@WRX7>@&2g4Np#rq6X=f*(?3ZTTFy!dhZGDCkSL7-4es$Vx= z8Cub}GRB)fm6yCjYEGJ<=COMziErlUB$?y3`+o3Vl-G!aySAZ78!l|ozdVf!!{(xT zu+t4(Kc9Wk?m*%dvHEm6%MQ4^9v$?vF+Eg-P5v;ikh?xI^5w=_@_h$2 z?MZ&>FFc;I;YraiCEJWLM*8V^? z*N=R`KjUSi@5XBLP_+iSUUbX52<#Z53sw=w2Nx70(Ilw^lpOJT7@=E6I=b-}CoBz4&h@{y&n` zj={&Ct|4+wU(3}_CP)S}Ku$W5Fdlr2keBs^ED`9?Zx$q-=YPVhY3h{aNLGtd1_+`%3DW7KwilhNg8xG> zpE4zpSw?3q{yaIfZpIt79%#lxYiSsq?5jGU5${Q(-rhUPVxtkc{$ugLQR{sX)oZOT zc;-a*<<3lMvvg=xjOI%vhKk?;)yoG%0&Ht+*UaoQPRcAPWPM z7CmAqnL3}nG!@)=Rsei)deG1iiQZrxN4zBwiOA=4R|~Au8l9lpR$4IPoOVRBqJr|} z&?`b_zBN5vvg;ej%Gt3c-M@qWaEb19Ljv&o45 zEWjNnAI`@c&i%W|pX(zMr<>jnwQ*@?Q71s9i#uf=C z5XK3vfr*XEg>szDtRSHAbwg6kK;J=gp|tFc4uDNS_m@?3kzF0%st*76HDVW0eA3@G z@AADQFn*HFAj*B`dvMS3ITAu4^eG55Pj=!Uj-S{Sv~cn*9Dr18v6G)CwuZq813ir;gvJ)eUlXwf}4?*EzFd}W_6 zZ`EOoW?%!Q!)quSZo*p;f6mx&gG1DRJQldHO&z_CyoY5PY)6M(lP6}V_fu7-TAXdI z)RCJ*1C8bsgV!mrDy2phVC-8vW-FviJ3C*Z@Zm3w%NlAjWu=O}{XO*1rh8X=__uiu z7P0IZs%Lg~-g#B-v7hszW9Ze{#z0c36g;jhV|Dr+cUdYC*Kg)4f3vKX)tjj{VFaXH zu_Cjcp%_e}ED^|sP;n~S0znN|rbmfTwLB7me=EQJOORpS$=gN_b2GPplKe1ZdpEtU zZR_dtk_p6Cw+_ZaC7uv;Ni3RFu&<%WbDi^(n{B9owNI3m^ssetm z7q_|qo???D4dUadufHDmRSvwhT@GSG+UVMLOR{lqW3T;S;Aw;((Y(Xm{ylC4J07gd zy5oCh7i{y^$QR&s2N3%L=!?#Ya05O@*t=&f`;x1NIeN^S1hx5i;h}Y0oDYFV$Ui_( zZ?YhqJWx7!w590%pAVZS?lV{~Z|c-j>9e2UeLZw>6;29*Iy7vke|U>h(e9coey%bO z1wN?k8d6s_bOp4l@pCu&rV;ob5~p0zGPgBe%v;)^wlxMQsbg+$!`T$M)kmg_mgi+& zR?`ZA2;+cy;1~8t^IGGF!>tjA4C29^j=Fb@1*UlE`_ONGn(v%asqkJ!8q=z?h}V@avebbYNGm9R7vUp zxm<6deL>R#K^C`CPfW-sYzA^&266vhV~g$Tx?$j31nGQ3%Ra#I#Z$ zourL#HGCt5ov^~BQoi?Tn5T(BOQE#ExsK)+F9x?)rxdH_chlWbt@)b0u3mq@9i%s< zB{N>y1|2k_T#{d`WH+PMf2?)08Gx_ixUEbaAbAgrlf5wxcQ2HEE6E3fD@U31Z6#Ci z5T{}INYEW#4LZA39Z%d;(`oTRUl2R__@G9VM23gVG~=W$TF7I%4^;1nh4m>GbS`={ zXwrsv%f!;h7_Lk}?`8Lez*0vz8sWu-*5dhG~CSx_!HC zm_&Td3xMowfEs**`hlpQ#k5OfkWZM1^ur=o^dhF9T-U15hCt91M_xQ46yvOSVg=}` zpI*t;1;?hIDE^(`sxlB~d-s-{@8wK4o& z+mACe1a^LMoZ0QY+`BOK_$aBGqc`(eNpyjL`7Ctv=SU)Ij$CChzT)dzgcU~I0_)NE zByE2Kg}#K3ymD%YPZ#EJM02HI?0QvYvY23)PxjZQu$3*kDtqll<7}*kSAP(q@P1LK<%U?f9KN2=1X7EnBHLi=S*m|^_tb-C((sSO zL14M;*Az?0=(*)6jV#f;7tci?oXl+?tEW*o9@n?_o1(9)t*k$7&NT@n{=nV8LDqn_ z>kQX2^Ia}O+aAX{k1#lRWYqMPc0Dzf4+!gxhuF@E%zExg>@ zQ;mY>J?|YqE=KcFrfP{iTTe8*>r%H7jeiFi=B4Rpa)c^iwwqMZaiH7mI)SH>7AdQT zQ>k8F_DW%`dA4=a;=-BH)9sXFr#M^w$YMNK2SdAIPZ$uM*9&dJ)}RDFZ=BCqu&Z#p zb}1LLJwTCj?Lw}=N@p2trxQEgr1;6A2E;E9u{^8E+}b%3l_<)ED5`EZR|KAsiPHRk z#_WIX0${(HL9ytO;Zyu)p0aCQIrQe1%vWR%4la{mq3AQ_ZpVqOJw|ta5A(EVV#tY^ z_z>=cMG_-t_9>jBua?V!35$bl$@{<*-~_616u-6k*oK^d$*np}I#2=Ry}*+eId(ET zkqX9PSM|{6e|BT61eIn#e7ObX2^tF3`9Q6axWgbum!M+tYK4bX|51;<_Gu&sS+4k9 zO#4b(JOmGHF|XBwF(*Z+WEHnnlrh=eWC( zP!@s2u^>cdd1oxWx!92E4Qt_^_M?+;HI+78P#VD(Aqy@KrFr4_emY!)G5%&Y?}2&t zO#aeEWZ4rc5}Sl*6Y{Ki$Qr$O<8)e*2vH_+%2i5jbbGn$`;E5ECTY838!e556mEla z>gwd+RLRdrC1R5tdg2XvYcfzR4lm!&zM~RIf5+JiWC@InWpb=@ihx2i{gmH>!sxep zAhHP~JPhM#lKI}P1hd;1gRTyzU~k*;y9e(1FHRzWhFn@UmSaqK+_0leeU6tR+nP=O%o?_t{k7ZQ)(nkbn?c+c_IOq~nxoNMUtjPsp6V}d31NCdcCRl+KbxE_>O}EZ((6@BpRt6Hm_CQb6pI+FXrX)n>f6SjavM2M(3YQVd;;zB!!tc ze1U6j^>{n*JKkU|wh6-?KK7P$f7lfp44OooQmB@oH}Q>$b}-Y@-zjzOF;Vfgi!Ed^ zf*^b#ViLUCwisoq_Sz+h7zs&(PPP>{zW#-tukUOi0wtYI0rNR${Gl6otFDgSUMQ32 zojZWv(#A1)+l&&Mlln6<=Y<}`aywpXhG0$7Iz={CLdJ#~u$$D)*1(xdFyucb57c!@ zL4x4r1_p*8WNjAV#&pA!x-+`f09MjcGn$h2KV@UF|6ex7|NDIz2W-3l4cT~y?e#Td zvJkE=m$)iOs4_rU;DF`sfEP#fxC^dVLoGn(Znt^vQGVggo<@DC>nH}(`_3oqDe>Vk zo7-Qs<#h1AH*WKjZw@^JCW?4?nXV_%YN%02ze+{EvHZey`VR&3f67@( zI<%I4dU_;Y>+fF3z$dIiPV6i^7a2s}TBX@WgkKZILShXsd&hj==6fDD!Y8CZZW6kD z)>MDA5{n~eCLQJ;LLs5+4}K=)-Ci)95-O3)|PO86i~r$XrUN*|2sg9(2~nXD432b{)>JOY z^*a?ya%4hTTz&(Ze=bwI$Dy&JJxwaEe7fX)(7VR;S-2}RsDF=3^W{DiIY|kVhv5JP zJA1(RkaJv+jw%`SZfmqk%Cv7yrWtG9S=KB?vaH=Vt3vFiLZ+`VcZ0ax%)Y0xGF)2_ ziaj!oudJZ~lLzv+)B7A)zLn|h#9?WO8&^&I$*NGo_ix`$^PP}c)?#Ml;s0E|JgRNoIqx%Nc&KdVt})kDOtmnac=%g8jv<`Qn>V$@ zVEneBl|{eOIN#<5xF#Hr)T#p&W&9DZJ#0mX-zGsiqO_#M2@AgU(K6>xv3HCYGP;8(59LIZF@30dyoFY{fHr%V*WK5koc1)D1?8W@WR&oNku1#dDL zmH1YKvJF;jK&9W)1X76H(8xIC&L4}QdFsg0s=Kac4+^E(YnecY|Cz;8xITU-@is0c z7MwRWY11rLTv>@253-fGVN;A@h#RrKeC2o`hZK~WZ2|E0T9w!Cm2%{LbGfHtX!M>k zm&B5&RvhWF7(iKKAlQRk1|_z8Tl_QMuCA{>7=baprsDdg&7ya^Eg zlod>VM=su$f^HS(wPx-vJQL(mv%a{S z3_z@jm1h7*9$R9{*zayQX~a>kk7ftIq+#$q=^Pz}*jH<%KcLzwE#Zb9FLorM5#Py5 zK-gc@>2&ky+&M=C=pB`l$k&|*@PNWbAPRldKCU442eM`9M?a#|mfe|=w9{)vC>!(v z0xq8OugLj420g+@DBSg;i&_moz=UEZZ?e?8)HwFb2RVpJ#pJ^3@%TJPIc#Eb7yMMtJNZjOjc6d#ZV*|N(uyNl7xK6T3n?vYo9`o#wzRAkcf+%-t_CHSgvz;(^CMWL4LNol5vS<#REi zsT5Oced=I&%U}?uKKMeTrn}l9{V|%lGpd7Aw0~N)U-Y$v(}V}$>k@Brb((rSe6_)60 zI-8EplIhqxcxuSkYo}FpD&TO)`C_{Jm`qzwTNR%!iQB<9eIO-nZ<8+3v2I3+?zqKz z+p*ZiGSj2c8J(MNYg9^Ve{+A>)9GTidG?QuLO8kiK0rn2iA^v4J4wQ7-1+kOO#M#K zUjHgO^U0t*(j||&eax`6;UbiU^N%CTE++m2Mk;nozeOUaTl~unV?Fq#dR2E>`6&JA zY&P^M(V3vu!D@rJ$nn}QULbpJYp!Vmmkk+NI6)=GShB*to);GI2xZ z(-YevMXH*oZDJ)eGeVjrv-LP13@(wLvqAyC(}o!nWs#2n%HFV>YK%dK;#c_JzFRGH z7SD7pb}Y5_GvnX7F@%tND)&G}UwijrG>=2Q4n`nC#r;i?(?=|+YJwnMZekDk`^%dL z9;AxjK#(*C{GgBf{#lsR{>RC<)xV$K&9$&C8yw!PHvO~k0Sr%)jXld=RgB5mVEM2C z;Yukl6guaJ@NgGbMxtBJ*6p3~pV^p^7GwP}ax2%t&|A#LJ7#^T4eHQqYI_uRR)VSL zZzCqZSN}W@kX_smV=yp8ifr`65gJj>b*t&!U27+XK|K-Cu6QI8DP>4)*tE_mwyd+`9TIqE(5JUJbeAei=?+hP-hLClS}h2I^X;dbg4^>l#q5 z_%uSXH*-fj{cQ{}_Af~P$~~}}F+=F6L|$Wh0!fCqZVQ(qIW1G|M8Ek7(BjG^#$^k1 z$unjr$(K398?x5{Ak9Or_fJ|U)!(Kk<;t?$F3K1*ifu4jVhKpg>8Sph@$FE33R2ks zxvmmX&>pD~D817fkZdQ3=yQP*(L}DR_9)=+1;gUwJ{L4IAU2(wZPm6(4y@ljx{l-w zVCSwNo1^VRP(Wv*dUEd?JdH$}KkLj6s7emO2(11+{{AxxmKk)Ww?#!C+Mk|(4DY>b z;qTNq96-l{1_}wKP&UBA8OtC}MrJx#dV1IrE;b?=yt_R44}OGnRzYB&W17&N!~O+0 z9A!Luei_?yMI3Bd$SXT(fgstFmZ^&TZ&K6Pil2#px-#=&Doe=-Tyn#E*etXReCiIX z-cL}_7^kxGQcO9e*v^s5sbLD=e!~O(@$V&QrPPGSi9g?q@by4~0a@{MNM`2`F!Y{2 z);rgE!NG29^@<*CT8qHj1S;#SILN#qG1oi(e8Q*1%+~whWih1 z7awC~#g&GwyLy6-o~r1WuG{U2*CvMwC4?HEcm*+Sa3=^%*9aOm=4N~KMO-8ew50Z&sVWaT!jVM+um=%|$Zpr_EeG&9rj@mR8S zs2yV(jz>v&=j>#!-1i5e7Zmbju^PQArMek~8RqmAN}rEaG)Iu2MGwd@T+sBC z)YNqQgI^F-`T!l3Ve-MvM?!ZXmK(R)PXGNV^G5t6@#yT-ZIk0=b8}N#vgP8H z8rJ#{7D9{_^AZ)>ME%!j>lZIUYK)}%W(ccT&qTAlhF`Lh_ZF#qJNPW_1FM?c%_EFHM?BomSCGwfv@x;ekstIGYIogmeR|av1g#z7dkmyufh70f|qOr;v z;2r@>?C|Gp>;cYY$5ucb8@lh$@3okp2^70^FB;`^6egO!tEYyoGd|}A?ppXL*`6Nu zCUs9NS)lAo)bYb*&Ja2nwBl0(Kg1g1Znf&#CmYCw!p5QsGdMPydo*3WUI1$aeiBK?(2G~?$<^phR`|{Jo50YnR*2oa zx7(O*dpt2+gT-|i4wPo)G|r|YMzUD0MEprGgIE^LlqhngHJS7x$VTf(a0P(_e$N2S@R0KiP3YT+Ea}qZx6LLi zAA);Ac1YPIEQkJol)Y1sXhE~B+wNX%+qP}nwr$(CZQHhOueNO)cbywM&c09k-}kK| zDxWI8$T_PrbBs8CLVC;-!BddqyWg?y;W1BCtAY4&tb!Kr)U?|^Nbq6PlTClj!Aogd zQ+=e8XV-lYlCYKUYk-u*Ls-oJ&8MEmXM~!I6!Uiwky!+ zv3j@fN9B4V<4u>~G(o#w0W0_M*OPO3zv+i-v9573b%D-a=f32uSrXb}*UM*`FC7LqLux?sqO5)? za2^jiW%J{;2r^gO>t(rXvQNJR3O?d2KVc6G|0q`V$d#k%-3ch{U(n`>);ev8+;7$R z%B_^R@nxR_#x4!+N>jpxsFK%GTrAU*u2p(nK4PhF z`E#v}(kd17qOfRGZte7f`Hwg?@bD7HFK~AOw!*1u{5Rj5kolTee4acSOzEIPE(k@^ zQuyd|MqVz!#-d9*yXn&p9t56UC2zg%NJ85N1j~)q@uy3Lk{!eIF5!e)5n_D9(?Eb! zGmQZGyE~s9KkXgLbOp@1d~+2A;5V+vOwXLqJL0Eyu8)R8le5(z$+|B=RixVbxEPO?%vW^^<~Hup4Pg^H|Be;%D8s+faeCzBin ze;h13mNyQ>xfTy$YHCNm{d-CF`}O>)9m8s5lHha%ET(h~sDjMSzo6$L9bB$f9b%0+ zfS~hfb2Xyz0T3B$dyVjHwb`;WV;#ElPe6AXe+&FA98W#`lxephFV;b4cnRDFSH2L5 zdMxz^AG&3==FWxlU2opQ3>X^$aQ^*Mj0HZaL5UOnh{eSs^$b-j(w`_6?@^6jUMvb# za@6_jCWH^r2Io}*ZGP@&uxi;8C*K3LDHay6+RXl~snCGwFU({sfge%m9!^J8!@`*=h$5io*B2#q^$bBo?JE;w3> zYKNW-)X~&Fw|=VpjYV)Rw!M&4)~qu~U)s}8fb&+8lJ*&lNM zPT-ccfKw(oJVeqAGOz{=;IVi{7|!ABJeZxW9pE(-joxfs!Z)>5-B-} zfvlYGCB~hv(&{dvkrZeUD&ZzB;{c(^E4H~RTvZ^uYM!G3w`=^_u zJe50axS9*(F0CSsW$NS@96}Nci}M3q@xnujHQZbv)8);Y?l9T%8?DQ`4Uqdb8m@8uOY50J zAn``0r{hK;_&+^{Hgp6z02HlPJ|~W09~~e96_re)J67ThzId?ypWUN>T3hNLCm6Ig zx4s8qT*xM~wv;~s_DPq^;}xHoxGCjqdJ_*qeT-GgdL&@T@=8m@i^5Jnvsl$d3C=pw zW$a{;(fpc+$AUny%*`&_*|%t822TkU@t%&T9kJ>C9(iCTzxE9+>Ldw+I_#2B4J7lW z7zqZ2WcQzFXwm3Z{wdV}qyd2Iwb2SdQl}=@`%s^1vq6U`-{>&%7;yy+VZo1S0HVGden&TQy{FBX{Gi9RXnQ zcY_)HT54($mbd?xrT_K9)ECSw*SXK=*H# zEVWQre;qd^+w*6cjNHChK?a5$;^A&b2%Dquqtu|JBwyzj)!HL4Ml6wCt76L&o)<^o8N~|cSKNrBtwuj|>y>eM zsb%wAh3`ei?#Il?1aJ)59JvAlLN?!1a`R}(niNs4j48p)n?F*`{~DLAzo)Tvz@jSo zv-b3d-Nyw)Rq4JZX%zX>m8?~f3|@f>fgO9Fp4Aq@+^}FgxC`)OSN0{XZ~O?G4*MlI z?UL!xr%StMYcxUui*__Hyj*}-#^Pv8h*#L!@4HiuxPhm>{DFK{S^5e0LieS(Zo8Xk zey5q-x)NG9H!T2KrCbv?l%i{6q$8Q0)+hkKb%91L_q#--96C1#H-vrIOq1Oc0n4fo zS{wOBXD9U>JxTh9Z0KxWg;N+Ya;-U>=jYbGKF<}~B9>3tX9QE{w{~T73@9+EOaIPk zT=&7~C;L)v=4@y0hsd>M18`Jmp<6l!BCB0U9IK4cDas+B*5<>AAAIg!U3ao3M77?S zDn{n^K7QMX^NXn?BQmQR9WMQG#yR9h%e%GDu#?H{<~KmT20{!+wh_g)#Yr3ZbTo~$ zwQpauOO$W4Vw#4>*)JtglE+iF9#v}=R&do1pe-b$XyP++`E?BXLlDwg=@}n2%5Zu1 zC!=?TXv8R$RezwCH#c5X zOLgD9gnG{W3YzNAgJ3w4fGS}^r{A8BO8}z2F_UV0{o_~^U=THL;99*2TnM@ZB z?W4D*xCdMnMt8WnVk~WD3>2_l_aC9rf@LbAXrB~zLl$A%SnaNDXi*}5rV_wBzSdgKK*ZxNoWQCZx! z=?}wY?>E?qCyn!*!aL#D2H4zaG?VvtFF=Ph==BU~b++#E*%9DABV2u`m`^;EErwy! zP@wU9;+*ho+v<%^0W}>5Z;s-TF@}g9>Wr;R+sUy#n|8W0MMWVMBL)ozB|fz3u=(mqQBQ^`003OjLED8?p(Lv4 z(LM3^I`m9VbVJ)pGAz&sMgxFKgJRsaSN%NS!Ws(0!&#jE7~2uFzfE61g6dUMB1EnhV%`w7#RwUid`3^<6SjjMh>&V>CRXc`_l2osm2}Am_7R}|+Uvp=l}9CJ5#BPF`e*^)Bh-mV1nvJ_I6F9}lL z(yX%?K0)Lu$S{L{=ZveVXb|Vg>;Z>nAWp^R(2@?8Mr};24p;ZLRt?3<5f$co>)QUpIkAuQ&4XU zgR`~j(|YUnRDpRzBR!7CuG2ZljfvE|eyuX6SLJi2En%YosJ(zAZ(&r6X24cVAdNN? z;uOKu*A&a*kf^6|*U!13T&pj=uOdjH%Tep~xP4BT`fHVO+_D8>D^8KrzzjKmS5M`G z-{*F(VR=UaH}odG6-0IFmEu&rrKP7|{WBHubqVWT!o`%;c4rx)D4Yc{5Ps5bl zuSMWdf$1yZ$=vNbwBk@}d!jU`31>9MltmfdBv#`o_(Hkg^$pl9Y6-5uM&{##gQq7; z=m_DcGTfi?grv=Nbz}EIg2;6|sco0r(Bt!Ru4jg;M{17V#yj-g5dRBP!|7ZAY4SM$ zo62spcBYB$)feHj8 zsuaLQqu#;3A(`#;Y=BLa+T9VlSzH(6Ijyy#I2bOxRZ61hae5Z3N3|$ zAl1JR27BdkYeG7~{>)2JVFqOUSiY}26imx|4LA5JLG4gF&S>c0jW(vmB_8%{sho(X zk6)YyCCa9-y)%x6g|(NNDU1w+Qk6_7zIxA}9GsIpV$1L*&ybj!V-&lcpeAUZ*O=yn zQ>HoQDhilVN>*X4NpkpNjw}9TfvVRFWbwDnQ5Sy|Z7B?I z*|Z3&Dlcn;Wpj=myDHTX;R0Q0-&0MO$R z>xeSoX5{&d>}XJsnLWFj%w45_KczasOda=%*`fQ&7Dxc1^iAhs zlWpMr_yI*Z74As=jGNRSA1*F-G$jsb1jIZLu7MiOfDxuv5vZ3Czzd)}q=xd?h?93e ze&sv(GMsa`h78sVG&2GPy1$w2s-@ZO$)6ZdL5NWM*0e9k2HAYxR$HQiVb_g^Z7~cc z052bgS0Y-mAx!O20;_v=rZ@i|tp3vy49wJT4-Bk}qgUN7xWQvT<_`%1F=7$f-z~z* z&h*ayATp!kU|qVSTDUPM)v|#!8$*<}HO3C3&>dy6Pz7Wy4S3}pf;>|cXC<`4br;n( zmc*lX0N}$#v;)BGaRkyOZupI<&KNR%nn@BE9=?e1YnD}&MPHAE3mR2$?TEKn@$X8a z?*#U=w74klh!V@BBDmj&_{J?u`4wbSl{hqx3axRTS0~GF|mIBSE zGH2ekgJj@9l7~YVkEcE-uW$*p(cZ0jhP1k?{V-kl>k}xf27&3HZgNXX;CDlLQJ1U| z%J&_kxBS|JKoLlWr5gOiZLVIET6)flDna_?+v0FpdzC%EUDKMS*WZVW54k_Wt)sgZ2-?k~%F zQh#bp{&P~GSbH@C`U??0rKzoFuCdPFa@I2#E(W&$@dK$+>WDP zz2JUG=OVMBOuu1iY!gEfOJv+}Yf{XBT_SlU8U2lD zwwbvn>wnIlU98Kn*KOscCKM%tDZN3 z8S>}XqX=v#9WSs2`Osw;*%PobOi`fd_vMiXZI>Xf)zF}$DDH(0*_>`ytuKlG9pwrXPJUNU5slq7-^wRGIqgsAIEC&0Ro$DfEN8EgFZ5n3Osq;sA zfe}dg8jez%UQnos(MymKOk{GKD3ZVnz&1LD)CW=q0}Rfe)!o`iq*A_M*l1n67U}hm z4yxQ9?%3rotj~4@;A?Ts=%qIavo`U6)AYYv;r(EQnqn}ZG?ef{nwqnSryOhl8%Weg zkuVnx6>d`3IQ>g}*aw^U9=1fr7BwyV^J!>fmdmyX#EY~U+n*}YbbRW$Z={_+bL?dB zNBM#|oLZgEIRi)xM=IB9RC(GT8iYGCeQF5yii8dqDHKVR%FVPhYU9Fo{fI=VS(LB# zVQ40L9Co3AzS1Sc+)n6HUZyU5uIa8*ku~d~6|OWxN}b7T+N?jyk=En&nz?p(AE!Ie ziU`_j3EIP#dM=C5h2?-85@3K6n4T`jZjE%~Fz5_xh%n#XQw^FOCNJFbyl2hE>CKQ7 zWxvsI5Ia$~o}@yi=713%?vquNQ6kM==*N*O172Clta#561eK5sxzXpd+4bj)ac6#> z$6JLca;GolIJl^rp?@&kOA6>JT=XhZkiUh3hJ-k)g{IZDIB0_feIgt|c@?Xd#;REw_;ey#!{+J1?Js&%Z@qQ&mPM5tV!%D{&PzoKs|QE=j|x0o;ANx>=_(fY|&RS{BFZ1A!Wk&X$g1B{gp9nQD?{ zEv$ytMt)-oT~kIpTC5_S>+-pVW$wEsorN! z+(;T==NLjNM+Mj}^~dYsw)1Zh6#0v%jhrp#u3vuai3J}MTJTEm zVww`9M-&Zz_T`Mt5#D0yQb){BnGvF~J&MBKi`MvOSBNdms6?U@{VMckIU7(PwcN~S zQFr1;MYRIPq=Z2vM0lTOkrJ|J=T+~)n3VV#pspKk&}g_Dn?a}su_vg-Abk>45j8N* z7x3_{WQz>&T>&xLgH^DkXf9(55m_iuHV@wZyM<6cDo&QBFtn+G(nc=)& zh@S}5q&Ng-m-D4_7goAxS3>?@u$w=KF}ZHm!&SRs3sx?CkZ!zK)UsMDT5(tvqk1TDbK>MuCMD*ToUfL^3D*bdhTQky`_l7_8i>6AhkVVN-FLZ z=9~KHuB7B5EI^q=7*FJDcR&l`(dF}WN_YkVj1?h0NNe5Zc?@s$!8Q|#dCiQUVC~2i zk6baIX9ekOFLdg8m{Gi*ur`9A(oh2N%c@CtF?P(s#SV67Y@9jqBZh9}qN}_5)8&e_ zEJ~?!XOkiys{8xH*_8eQ*KiS1;+|Z}~Z{lB%$jh0E5mKaNA|kggIV8r)3nW?H7= z)wy-DcMezan*EB&%`4Ga@CP0e<%|M0J>pX<`24;-@^G^7K>R*#)id0^xye>^?%~|> zZvhn{%FNb|hT|+Xd_bOB&%XFPo*WgfspquSjsv7SLHDqAAbxuqwPuuymgxfc;j2!e zO<9=Y6}-iRS%&k;1mE;MJ9|bc@%Ex9?4nkLJXj(Y@?5%Y21@%b-x{BSMXvFr-cfPt zOn{|c8=+p34c51WZwC9rSFeyQ9>&BkvQnka>=!4FLQqXG< z(_Y8dS~kQnM9Aa7DptUx(ujuFqzySk$i-yHaw`)|9=NNXGdyN}2OB|U?qHxEoJcw5 z;-fZa=GX9*1HTiHZk4K|Ayg_;U7h%E54|7OPkvYBN^LAov&1P{ zjxuLAd)eGS(WG@S&?AXu{r@wC|8{} ze_)hPUZZJ5L4JtN`_UZMdC{CFb8wLEKY(&Y105{jprqrCFN7a91C1qoaO74bQ!&3k zw)?f3unYvx8Ge|P4Ur?F=1%L8=cP+y^vRi^_S@dgtrE>fx#krIA28Y@T;Wb^AvTl- zf1*@_Oza+I#ExNLN`;FLjMI=aY~>$@?t^Wcp5h%O$tWSb|4h#hvxiaf*V&a%?@Dji zz5KaL3J~ZtdE=?1x(J3-dpVsYbChv}55=u(r(}betj#qA?2-G#R!GGckZKDyXM343 zQ*2iC^C{8(qmcff{=uAh9+5-TNA#uN`i(WwCl|BCb&qQIdj~)Ru-*Z%_6M<5xcEv& z11F82UhdM|6~c#mjyC5q7S?>u)yK05HOcvlfWsdqw3k$L^X=(y*fN71I_h*p z`m-C^FC*2acyUxxuy&j`$cI<2;q^*_aVTv{+U~QHE+TRf-Q?8&^jcTg*pA!ey z$OJ(JI6;0qqX!D)S6Qu4090;sD6ZbthAk4^b)IR$lniIqGknHzd4Q)ySLc0rCE()~ zzVP(}hds*XOFGgAaD&YhafAw@vFKkHc`R#?K0qq|^|sDmU_dF0MjxoV9YbtXw8vZv z^g|+Y)Wx5>v?6~6je2gkw7?P@BM%v503 z3wME}ppuMix;}k`wCmfcI`-)Cz#L~6*+F( z2GOvaqM|&H;87lM_AJM$NeL=(tWKI`>&Rb-GA7&Azr9bw&i$<1#Scl}sKe5jI(tsP$bZXTL zaCO6c&sv>ju68e#8&VR@i4sZQ{(nhv^;A0ROa8w5!=(1jP+55hMFcjtHPbvGbEXa= z+l5!#nmqb0=4*x+GogFJa!D_gQf~)%fXwZ#39vhE#7-uDEPVf|Y;pS>@zJFKep=d#mC9T23UARJClh1x8{&@rV`VM_*m5 zxzg|d=8SLHvo{wJ8%7d0RhX-~8iH59WRe-eY^7q2d&q7zm6fA%iLjkLdM0=b+?NJ} z^4$Pi&)Lc6^=HJ;;P|73R$kuYzP=jbg62z-kD zx&}^qPB5z`-&oQhqJx2LjuYX3vhH^{E=nK)4=7z)m$d)fu76lsCLEtD4-d31EF?!W z9B?`h#IFGd>(5rd4YT3qi-OG)VJaZ(iY0)iji?Uv8+tN_8p6Rjmxt=R4TrV>oaUa2 zdOf;jLeo@VhWexs=?zDnY zQUJ}E)z8$X4?*u9z&^y^`?YSUtT{18&C{HwX<=--m1}}#)M7y$CKOf?w%+}aX|v!f z`B}71-uNpRNa{Q|eZQLe#a(+*>W6;v*XgiEs&b?MpM_t4-~8guVcwl}$q2{@C^Q$( z_6M79_Iq?CB+CI9C$y1^r@ef(@!w}5@2mQk#azX>p&?X;Y1R`0wHh1#8tz2aPSgBG zJa%b6o{uI^f5-p`nKeo61Tiq{hVCfcuia9zgu(Y_UeaEEGu9X8x3f6%*z7 zC8?HLaq^LUkpAfCiP$Nb0hN;5X)2L<~M4 zt~f%+MjNuF&#!nPtLS9%f&1v*BPP3RZL7rU12Bh*&i|%`5c2jv;?>-G9BOp;(GoxW zUd42cch+qkXYmOoLeVTm9C%*VAx$)!{4_DhU4KE})qQ4!76CdR>hk+FSAZ3uL`Sta zd!76J_ajN=l4*1Ix4WX<%E!GF7VcTJ9+H;;F1u^G*Ca|!pEIH>Vtu7LOlt8B8N6#_ z5U^W|ed^R|(7FTQBX~qo2;M@PnDTxQ4k}C$R7{1n2rKaY>>gNmf7_b;{;O=9|KDX} zf`6yFwH+z+zbG4fz6Mwu%j@sW%9vCbp&ff$t>DJ7;W3c7(C0y@@X;$hA8hg( z+MSQEfYveh$F4?Zj%=hGT)rznzfIc)H=m_{;?wKubuHYrlzejUIGcvb6b7+rQw%F; zclFA{9*bh1$#~1vn|Xw;c-buibDZ7o(!wS6V*`y%Akm^y7lD92ke#B$PWQ$Xg?++# z?AImY3W;D2G8C!^X{#|`G`f|K&nVQId=QP^kBeEzENp~ zg_b^&OS-3rnSvInO12sV@R?M{X(YI}u+M+!F&ET&AyHEU<^k@ch29l*fsoW2ye|njA`O=)V3&<2Bp) z8x-Kq@moCef&-}CjZZ;*3KWXGhDMkvmW z?uk!>RR?aM(>fFVs1#sqOLk_Y)}l1_mC8Z$uV1kW`2`i99GKNIAFEZ+)z0=jMV?in zQR@kWJMQ7@`mq2pm)yD3^IfbYwyTRL35TTP*cgR`Udo(E?EtSnrqmIpA-(eIVt_ZA zhA#b&`@QGKei8rg*+%LTV0=~>o&NIUA^3${OPgl<1YFTL3mf7W4@K_K0l{D8vFQ8T}Zw)P{N|u3j zTKM-l_ntMCJPrS8))N@IpXqA|t!(6rTM0G0tS#$~Bt&Z|z%{1|%$xqnty={(`tenj z%ob6`kS|=L`p0lWMbjRL&CkU5pd#U6?k@lL_oc}%22H>laCL5apQ6(gXE@Ze5GPBl zC6j9Rj<3(4Q@CX%_}SC&00D8ve~|S@14A=3a~1Gzv1I5Jzurq!&IsrFyYYqH&?0A* zH-hP*ez4(@QiV*=l8*nZ)|mZlS(@iFgXZ!2-cmJeKFieo`q=}DhomJ+*y2n<1a-+8 z#u)FRKE?OUiJ5E%-b|)1l^8hJDvXrNN2TWw5;OBr&j_!P>15SGNMit5X-s%_L`FcX zRvt<*&W*S7OqwDCnr&M9&ZGQqeJx8pM7Teff1+@oHIT&5rZLcpmv4|Qqv*8innUeD z`D|M>N=wO+^8=5bJ?@BbfkDRs8%@$iV?wcJS#PO&(<5bgGlU^MB<{M~DaC5Y9GouK zKjog2M>Tg6R>KY)(LP8Oh70=$UA--0$6|mOojUm7w=QTsQ)P9!YihnW<@Gs;4H*;B z(X!MFcqhd_zu2DLL*Ro|kNAM+I>Pnh^S~)66&mF_t zVt2#GSnupF`imyf2b@qUL%)y}8T6-la?Hf}j7oVfhQ^WtHZ%_6k8nqU3UNY*-ugwv z0pXI&w8g&u3d;(58o+iVLwI0hLs(+l$LOrWRPRlwU0;F2=z(L$+6_(6Gxkhn9j$TV z^nNrPxV<(K{BS7&K>nJME}WUc(OXBlGtb!YubPRO3lt+&^ciyevq{6OL~6z}g(@wd zD*JTFW%$#Z2RO-6!uTt{rv^r81uT6il8cI3|9PMwuur7X%S;* z{xx!iLnqu)N-C202o83V5lu}DYiHikWcr%qjH^hT4eB-%h4u6CiQ6844LSQZjc3M0 zkfdfBN{V03EdyLg7HRL$#0__zGKXnOiq-W4k_B}hb)DpmagfFnvw37U0*u8 z^y_#yc$bf<;iU#s)m4ciiVpoZjVu=p1FJta*s682w z(oON<9`|wUgn-Y5VKIvB5`ve9tArqC!p$mK@}LBopD!su3o{tSEGK=vnNGQm5>j`B zcz#oCclMbj7c`VxEj6o#ZK>|D1%5KClffhK*9eXuzdWb=L4n#m6l<{ zVGZ=LWYE$riuiSkf82}7B`#CZ70tvfy%sdl!hp2ip<#fAOZjDCC8puJ5%}yZzX?Li zRr4K;j2{M;ZuF%x6XGstH*;k$V;(X}j|wr^PWfg1O#B0vI#_`o{^?l|P=!q%GJNek z#1w14j{9nwbusn%*x<~m97t%TFM5(%yY#<41nC5tecdugb=8zSyGJ+R@I? z0ssKPjR`RxNG9N&Ch61lnz-zryOVTO!xUCaAq3DnmW5)6OuDQl*bHb}kJmo1bWoFy z%2;5+I2b#{h5$-m(~F`{Aj!a|g)oYiz1PR59Yf<8^l{SHZGtUe zL9d#oMd{u0B{MC=8J4qD@<#;kAsrM|DxTH_0mathdJH(oXPSEtlWsQD`QnoDXd9Yk zM>Zm`d_ZxS%}knWvW^|?nc~EF4s=M#);l{8 z39d9%(!}T`?Z8`@iw1d3DB5eXfOC*ys)3vXlm`{9V?;Q1Uq zoSO#KSt*F<=-%}X-H7eKTLTMYl$cs3G*{Xg%RPcwq2hb#;5|lkHST~r^7QtjFDyKA zWdj4M6f>00VDz2{N0EZQRdepd-KxvO=8p6^wTnselK+3e5C8z~@eBCfIPZihY1|p{ zq$NAVT-uWkrhV`yUJh7f{&Wjn&5rVyl;oT^)qD5DFjydC^{YyP+ z>^=D)|0@r?nk9NXsvjQ6RiKn|@`bo4v?9M4%Zcl&tmY!g&j-+?Oe0p;Gn^?=GrG#>By}2Dgo08BRC* zLX!haa&dh-SMVF@Y>7+tFQfNbcMLJAKo32;ip#hAI zrcDG@+@t>hYrZe6NnC&DMm_kyZWqCP%+8yVPydPLF;OkI+{2cidrYcN1r!>807Cv` zc#`j^L?+k}8ih>ri<|Tuo;3BpF?$(IejZd*F_dT+GV1Ic&l)E;7~Dp+OpP?b;E@qGR^mv4gTW!*nZ8)$Nk(_YXpdbfb7on8b8v+_| zVE2%=)7!az$X5DZ6;orqR!Ol)JjMzhr4`7&m8?NFfYKeju7GWL_FXO^MX9Yfngtu9 zbk4c#A>qd>UDFqQCvd}a&fR1ro?Fm=!llg2OYo;V@NsTy|Cg#qG+JM*azmz@If;QIfLPW{7j%FY#@@A z2d&f%Htkz)`6SEC!)f%c>iPm8_GV!}-AU>cdNJd&`9cZ~)@ad#%A`#@dGEorpEpAv0ibhYj58 zd_nFXH?3MpLn$VHsZy8WN;kD=E{kY*wgq5wX}4Pl_Xqj#-o3$xwdEV&bC#+xo%?C- zb$-pfleO%vPkE8EE7*?H;-h=D-S84>YLpK<%GPXZycsF*eVq@DmltUBY+orx(>wqg@q{(EH*%Z)Dac31N$g> ziX(zU7Y|a;?l|C;YkC!-%QD?vTov!frf>UsdK@1m)B3SENxL>bHk}^y9qhEuOY84h zD66+deqGT}32gv+m>igne}#vMj6V{@5gUt!eDNUu9-8s)Kr!1Tqv@(afDhJOV-OWc z2j&RIP{n``tHB7yi5{`{;qG`bC4xP zrYcua%?iJxJ-49Dbz`{*XCCLiCIx;ro}SlXTCAN+A`Xd@x5jp5@;HEzO$_K8L-yOp zD*keFv#aP7Ot1%ah_XeU-0?FGzT6oR(vJ{wtV(o`uVH0e+!#ii=X`#n5=v%6CRivh zR)2Ey-`P{M&pdM)BVNthE;`2D_z~#!`DeV4m4KfK#3>naIQiK&l^A4dm8${IrZp*B zOk+dr@77AE?KzXvp{~36N2EFjr=A1roFHYslOx=pU^c1j_g=FjN=LgnldKn&V+J0%nn{*qcUNJ z@pWs>Xs%mb>r+&)G1{tGq8`+OOFxnWiN&ky$ZdG~tErKnhBlHk3PI1ZcqS#=&iS{} zRICMB$76rrKUnF{A|}uBI!NgW7gq=-5-&*eI-+yb0z(MQebp=Cz%RSi>Vhx?>F2HN z0^Vn5A!)zuqJ#~hO$*W;pS?7A-pKc==hw@V%HDSrV37ri1?XQP80mI7#Vt!yec=yH zcJ7uw<+49;#dRg3*W^hYCu;&5#-Crv*7VMtdk-jEXnc%uw7L}19i8(z#S&7#Z{oI* zkN^5gduocLpPxsTwqFw#SWMQ5y>kq1vx*UrW|M1KVY1^px)9F=J?KtUGTbT;V9?!! zGQ$t9Cimmqapjs8$ThC%=Z^+0(mQ$D=WiyY-KYU))?DMN36U)U_8h%BC~|Sp=Fqf% zC@XTMORoD@B@uk@t>9K+dIK>GpWthuZ?FE&y}Y;>HPm%7Kq`NNm%Z_!uDet13C?X> zqE;|TG+Ta*0EoY+sgUX@HcLEr%z*kCzSc#X^jMn^Ugs#UVa_vK| z%ws}At6uh-V>QN_YkgHEHyFW~{vP>wStbHPf{*{_;VABY`a5oPHg&RoMhWjco2zvA zSi0gdQKquGynm%$(I}hcg_>9z{sqzek1vchd33e z7c{mLALx0vQ7r5gVcRUGP`|!~1;J&x&j!XP{cpp}y-zUfb=Bl8^1GC`Y$e7v0Td=i zQ6L+TP39lus5eh?&%%NWUzgpdsLfQBSxv0(%IoF(;~pKe@66l z9@`*gXJObjC4`&kyT`^+>3ppfjwPnhEZjwbl8=kD!QGq>8gIhSEYKi z4pN&Ns+TOFiT%kl0=?LrGA>XE>M$`WOh;%yvBJ0*8mMQ7oVDq6E$c2tG7fzy*X3*pV*j3N1dlkNZjz`*zL(%p}$ z83NxnBosGK!iEw;of_*!cBgLeJoq1Q&3~@opt`hz(}anyZr{?$s?hlSV(l{n!ALQK zy=op-mZ7lIeS$;V5`g58Ew-f{jOjilO%Q=B#iz)l$}$MDABT}+qP}H zcU!x$+qP}nwr$(CZQHhO_v|}!^>XH%Q!llmBA-@#l@+W0%=|x{(;STIlM$}YbC&$z ziR>7?6VC>B1la$2yWdNAqqQ5%_w@%`a^Hr{HVgzsGwm=DC$!+2JdR<|zgp&jS ziTvecBmVt$7nwFlZuFbLIE-piDo@*=Td&e$#ld&L+hfr53+`O}8Jg!0tWfQ(Ps2gp zF?|iq4gjm3bnAPB`Vcf&{o~3tEx?9lFLX!uF68wWNyd+b^IG$v3o`Us#T{s!yn~-I zo=;;!L*owI;1sGle(3i80esRFCK&!+09xf6q+H;)a35yRlEYX22$VUa7-4|l-}-7Z zitF6e@x>aM;u@{(LnRF}2#4uN34-!)WMAW>)?)P0*83PWb4EW#8Kr}^jRrIi+D>{o z7?!)ew4XakqzB?d$&i9r=yd*09b7-*a*YA2_a%M9MWlWP5L2Os&0=HTgOFI5H>Yew z^fL3=YdmY*O}AFDODU~DO_ak8@fF5Zb8{GnQjF?tF_XR~;3+0L3WSujhe_QbA6tCH zPrlXz=G+f>9)MNxW|LfqV33TT0M?Mv9;bA}FnkxKY(@@}<{F~I?=k`9fEnuNQ(jp8 zag+A;f!(yH!1o@z>a6{HU%@`zZ2MD$C&;cSxq!f7B2q_NX`sA000nI zglI7ILSBIY2uaIISm?+shf#6!N7AT}Ub#qM(Kj&^_qhsK52Jr;&>=@ebse?XN24D= zPG1FyCA5m^mRX-mSn2mRu_2ZRN;tde@eSqFe1qp4zb*UkHh3cf?lgkRz`f$08k-sQRD*NtdQWY{ z5qmlA&39k4frtsBP!veODxMG8xiQ0MeYCa__po8_Z&kGi0eW_RP;DWm3%5Db6SpHr z`v-5HWc@R=T*V5LH`HcumuUS0*ti!_1hl>33}L)$EXD+_gJ8Nj>5^q<7f^$E;f%A zD3YgO%1QB3sZn}?Qscxar#ZD0Iik3wiHXgF=gBKZZhy^gyTE-}b{0S{D5&2)m5mHNB(>mS#$mzuU1<|XBQnz(P;K+w%J z{CW(0hgoEyD36XcmHMP~A%y2_hUjJPS`&FihdSsSq2Kal^tC&%30U=&Ia(GHIpY~| zdUSuHs8Njh06sXQ@KhPsF{E6Y^`j zkNDQ4PUwe#?78=Wqiy!sh*{mq8S~32_mex>Dn?#kLtIg5kOxC6Cfn3fl74CRV~Bs= zWD=(G`jE>|o^xD$U!6yrO8(+~8_?f{x67p__IKE!-SIi`tXAq7ZTj)GF7Noc`aYwy zYWWZ&iAR!b`A^w+>VIToqQ84;G`30bFUZC#vU5YVmmA43`Lq|!_I2w@%|Ti~EJi#G z8NRqgoRe(j)M(b6nz)G74ypPS*N7S?fY+LeyeL}Xd_r9?RH}TeFg$vURE$N)zM&83 zNbgY_ZDt<~$(=0gA2w<7tvJtgNk{;ta4L_sxF}0@s!8*I2G+N5=aTUmR^_xQ4#tKK zejTF_(EXtGEI-XQUL0?r`Wka%*%(n)pv&tq`aawCh=@d4DG2||f04m5gH}ZAuHtk5{c?BtJjKGq>%c}6+;f66ENq$~# zN`H3BIG0Tw9oWdQcDGV&Ay8yKf zBM#{*m0h|Ok+579{WOu~QAbA+uwONu`7&ej2S!Y%o&D3P3+utS~N{E~B zTD?fpQ-ws*y_S-#>+>X?2@jSU!Oe~``Wc8|oF{-fW#FLsw}8fzV7+3K?-Kvexcc`Q_jyLLWW`M_Gz>f zXH{DpXGR-M{QFni43@eyjoXx`sKMp z4c0XONR{r*QBa>?pHDB$O2o^s?o&=x-Dq;R{v=7Q2?I7v34{^!AIauetRlru7t8e+RLNuD)0sEayEcdl;83eg9I@NfO;}Q z=C*hD;6xPk8e4*9L3y~^+5#z}=l;xuuS!=ZyspPfELxQl6=Lkz6608RhH#`xk0q^i zjPXLTZZ5^aE}@o@1(mi+loWtYV&*#RyzSE^Ne6hhzs?H3IiXAx46p+lv15ou$7T&` zsZ#PP?8!Tqr2WIu``>{5^9AOsTgcw=lF13)o^|0|v;?D<5jR^yxW19lJIIw=G6~Vd z?6;`bzJtO70&l);+|j*+<)x;0sA&##r zN~`7w%##rMt?vg5Q=AYM#V(=MQp}6IKEj~UzP~{WDuY^K;Iv!CKqrQ5RTI~Oug?0A z#A`f>j1#5SCzUY5t#X|F{_F2}Tq^pi>m$)b5cpm>e73x_;Nk(W|70q_QfM)Rm4a&6SX8zY|l)MqT^u8OyUQG}nf z>A1ypLPg+T*IOCQVyple^6@)=|641>s#IRYv1oA2qOR!4$nvYP-icP4rt!G%UgD3(o6)6!QD>K;r7Gl7?PTiLKsZosWeww`ja2zVJZ|goqJ{<=gYAi5` z>yZuIfcb(ddwD6*h~;DkbK-Hoe{)ZO??NuPK)BwKEnLLq0Jd&8FA`{#z1`%5L*WPq zv=$oMfA*V^>i1FYQ_TX<0GaSEZTYm;e5)b{0wK-G--9EB&@MM^>syUK8PVm-* zLV)BOxs>ler|`ccc;S0tdXaTpepxl88hf>P`57f|5z;E`H1S5~*-^z?g;eG^9(#zg&Sdl%U^#|#dH=?D+ z2<1kG``V>c0x!}oq_jj+)B~F!-jC;JB_gJz8t=+kF;`=eV1qhfzg-x0daq@0F}T9# z^F-H|G3_M&ZP+{BMVgu^r%EgaXdjivQ)K-lL#OWU?3kfvXj>6`3ioA}xpWk}8B3xf zxcJJCNTbE`#;)HSM6z>esqODUxPf4BR1g6s{FPhnrc>@>tiV}%riXtfQVPDAa5IUG zUw3O4GQzi1tdeaZuDQcgkz*fq!L!6x1j_%Od^*$K;mrZ#6X=@QQ4l0P7TO9R-Z|kG zTcIqjKFxhAozSIw2s1G*4?K9UI8K%6A@H$Q%X1KAYRa84&W2}e1fNrdTh=L2tSPltOBg%2SVcm z;EN(Pqw?pOE7^B0o)hj5@&m3tGp@XzqT~9$WaP)6q(IklhQzVRpxTPonc7`d77)A& zIFcL#w_og09T~yV9GKn@xzdxq8GC{u+h^QK2}(G`79YFP{_whbo?{-WuEt5)p&fid z4E|%cV12cFFnFxIO0Zx33GnMjeL>FBJi6sxZT9u{JgrZ_WqAKwp!;wB006(iPfh~s zr*(s+XmrrA{7c6nH*c2^G3DGy{5yVW$sqNuBUVo06Y1sCi+8b61u$^@c{$}=;BFXM z=-7BBiXFEgbEZB`v4sOB{B|HvcHR*AB5A(_m-2rc@i(Bsk+`P0N^7=RZc4onLBWQv z%yo=L<=rbZp6UNq!lvZMdL$LrU7D$xVEwqRz)V2RU(9FCO{7%Pmibu7PcMhNC}!$n z>8VsfnC6wj;yfhkk@A6zHcrpF>eMaNT)-X;J9al;G4aJ?y9*SHW!}EbQcK+`>?(Uh zcVT+t7pQ?W05)J|_cVR1#a5P8-*WtsCZ{5s-$WwSoK0mAqDXL1=EAESH8KpvE-QhV zkvOzCLGViuvSK&h3_t!1H`*>s>*}$DWF@x{Ys{G!P@zdO#KUu_tzrN~jHOC+_C(O4 z1Y@|;byM-^#L$I9G}t1k7Qk_+(bW;@0g|g$={=c7c=JP%0?pho;2dyhdLP*Z?S~X$ zuI}^=Z9AHC+`(3eSFNSD#e|4bD5d|hAqYWul5au4`D0j{6=^}Pg%sKk^e4vWM zQX%iDXkpl_s%ZQ@*lQXG3xXZag+#t;i-U?&#zJhVZFlXX9oqEA_`~~l9CzkKvUqza zRT~!J?T9bgsrO{%rr#*d0-cFcbZy~U_rHb|4GCo7cH1Z%cgVW? z+z{owv8_-X7_t_2H$*4*w=eA%7G_M9l~C1oHr&OH@hNIC>EX(rHTuliH^I!ev0?HU zu!Y#hy$0DDQEy!K+ zr2{NdAGK3;e=jJsD=8|c|9SKoGYE|xeUIaPRg3C6cGsOxD79#l17z3S_f8?%lB)T_ z;smaD;%?H*7AI(>=AYEL%Mau_u^>9tA2MX^K6*QBysw+^Z523h;{to6$4WG82TKd= zpo^MS^Hz6IJ#jnT-8X!{KTA79l2=O=S0^(isXtf5mME1S1HIk5>p0?{&g8c_Ds^`t zqMr3bgBzPzCydyk!ji{(*gA>LS#B9wucX_r$n6t(JgJ9)SsrMox{;rdd~LHCy;>>z zs(*X5no*PWf24~@>$qTkqX@sBlzG*4%ioyZW4iC;$%J5{hx|K9@4xu$oq2!(=)yNi z;?lx0IR2p8i+#`o@^@)#bpZ1u3Mu@)ko=f(2-PdL!Ib>-Y{{My7JBHtF8DH0SSZzW zwq$@xZ4!~(JvK0S?hLtA?>wPZ;9Hkl9gQ25wWdg&7hh8TD>)*pzs5XKn)3XVx`E!& z$Eq#c%`q#h%t*nfXmD0)Vm%EaqWXr|9_uXvdEtbOEydfgmJx{7J5zNknvfVF041g6 znM^fJawa`X{dl+n|X>*5S zLo@M7lZ(M#Jv@p)2K{%CjZX%-Lq;s!pSjnaaUV@$Vfh?r$~E=!kx8NS)-lYVkdtBi zYc$QaFTO@7$v%kJgQ0lfAH)tN7eO&fk_`(V30-U(bA?hGz%bDSkA#V!h6};$D9by; z_~#XjJHCb*yxBCfmtBIV47|Qyue4OA*DT@%ue2Ai>Te~him#ICFH@pa$1~6tOWgeO z^$(}+RS*+&yLu5RFq0Im>r2ql;{D;AbQP&_ovE<8QbGcMz$*U-;j#b+KI%j%q|0EqM8|qsiTBs<= z-?AiTSaK0jz4gDK`j_r_J|`g|pNkfI^}%VrZmG%-_1+$8oUkgZ5q*spNI|^IvWEMo zyG-_}9UIe|;CU&_t0nadWx@gvS#>IuDU4;0FWUGp9Lj^zDr-c19{~gD1-EUf&&slo z9iiI~OUL#fI9D$7n+8W$@ltH*KB!Uj;}L{dsJ}sd^qu)3`h$gqZ!{n5vk^!=-``Sb zacma-`d6<9sv(?=GfgjBcxr)7>q&`JG@?4Lhpi-jqq55xYOG2@46pCo;!Lb9&nKM_ zihb=|_#{ZwchN@qoU5~5At@s#t5c27B~GS?$;4|^p-DeV^ECR~o7LD34rw)JZ5p_@ z{%Y~A3GQ&>@$u3(NS`1J>_Siyw+1=bbHyRO4X}P;cO3F_VA#F>j@U^H{6Z=xOxw(` z`WC*jUW{*|ztT|M`$kZOlB@mmu!Nv`J1E-5g;{bLZh>ZusS-mzKX(VH{DJe!w}21x^@dk6V3yZ%S4Tva7OY09e4mtj5C2QZsDv$l3KaV z$$V3HxPzlqx11M)VhcAXQ8%6c`(Rd5F(@lt9x_~gz{bQ<0ng*{vg3)Dh%)3EOF2|J zg&P9n=dD*uv?ON1u0lVpgy)5H|D_g}Os}Kq1-3EdMR&Q-TG8h?Ma_ zfIvvEF}z6|i9AsPiCrBpm#GpMvnruPUeD0vJD$O>$ICJCvVy^>8ewE z$ROb&q68YG32uKlpD=|&wW(auX@6UAWo6{GgcW1B21DZT*R+KBkhTUo%B)v5d{3YX zP|GG&i3`wdRMez2Em4tyCC5T1vHWW@M%I~>?Y;M!PQLw{DKfj5LRryCE!|T4q_c-8 z!agx-uoEC7TSS+|(49!9U8O0p+j#GAG!OPOWfqS-3gH0HxKBDqqjg|yY8zl0 zlWvLea$_$XY_==uYJnYPnh(?D^|ebJSufdEm}nX=VC`RTz5u zgn!Bp+qYu4UZMN>M@_ zoWL*RNQ=-&vFhLTn2luOa45tj0A1nxeq6tQRvoiGZIA`!=PzU+++#o2Gk{MKVqZdk z&zd_1UQq{i^++;A-v`8e206MEi+~LtBMykGMqzT40C7`0W=fGsEH4sg@dxy9w4brd z{%^4Ul{GLoH~h~J9cM~3m~Y~pyypr2if_m#or(fCq46m{YBL${@EpJXDQ#;Sz3n0A z9a7Ug*mk0pXnn5HSVxR^Wbhi!T3iy27Q!lixb}9enXcZ8M8tPl42!oVU#0nqUTP^z z=^}$;oojVN)^gM`4>^UkMQ1>&nK-;2oCg!=>Cf@At5mBNi3k5W*iw(VN(n_9?xVtE z+B!jH9Sf{?yHXyTBP?>YBm~xFjv&xLu{dDuVRea`H?@`|_@8c%%Y@=XS4ntoo?cxy zgXGw|o}ez*1AW<}lAivVGZ3vZ`^q$@>~o^T?OB0JdOc{(hVH3i)&6W(gtvL+W_8a1 zbsr@%0PqQm;fC8YEf<>NYu%m1RB-zn{_1U0`f&HT`xW@(DY7PYUDwbvMG$@@0we$c z5>eQm_2qfX9EIWe(3In{KWoefsM+u72p$@M#9Sk*@o3;*#N_TqkRsGHPD+Se z=Se2IALVSt__Sl4OZ8br1fNWiWPL!jF~Fw>M!rcZH^kdQCWRnaTb6Qf_Yo};PviXo zEBJtadJmg!4d-@VWVI-zxr#dKi6Z|M-u_n%7zXCsx9%Z8^;x@Zj}_jtz_jzBCr>_V ze*uRU)Eb@VCXg@XWy=Ww?OH2r4#J(&kli&E5D1+u`i&iv9R1xi-H=bNdJQdfEMxmE z&f<=i!pb@B>Kx`q&tNnk9j(gz-ttdJ_6e~COXA1SRSx__v|JFCf`PpeHFV~wXS|=b z4LsoX+!{P+uh*B|BF6dnjANiGyT`E4?MkLS#g)ni2i&;Ki7@IQh%-8<;B`~Nub39tUgdd^!m^>eP#A$t?S2{ zwu|q<>~tVmG$R2}qC~*9`u%K(;Y*~Y3D?|G(zCw#okmYMwdLNsrFUUg1LwyOQSlw> z;Ar1CfA)$OKFQZV|HaRk0SnvZaWfS*2EPOO$}5YIf{#MwjNt$|;d?X@Q# z1>UC>gv!{b`AxY;P}+S;;)lxxX+)8lPS(`DfVx_UgXWV7YRihEYOdYj(nJ!a1<_PC z2+>MMv-%f4HF?|_8=?maBO&j2FX1_!+g4h*jwHX6tO7uP%aG9OjykAtA)ZdHG4_9EHU4IL6qy0V$Yp@)m%>op1re6^It^fpwSno6H=SV++BA= zgjBtTahLX>Z7V7PNc%>|zomC{mf1OBi?{4f2FcBHRewb+WJ4@xPg*J%{)N`Ly>NfxMhYDGgsbUje5GvvW%yt6~ttz6LkG@aZ zY>wiXm>yV8tM|P!1Alp9L8OH9U15Px_)jen5l;e~=xu`P08nS5I_|;Ok$FTE{?j75OxF8B% z^$yHkrI7i%m_vn>M7YEwXtrvLE2D zLhD&p4eb|_?KaS}aFtgmD3T~QbO`#T@s-jKjt9+NyL=WQMejD_K`4^IaM-gNHDwau@CI!OByGT+Vi!DZJgE#$@iks)uraUr+~NviC;&j+Gsf9_l1J% z(s)D@xkwd7YrhPAMf@lIZ{_-<8oSr43As0YH;WBwXWQhKqy}7;Fci=Ozwo7*v)^o- zc9vpW9f)nLxHLz#KxXTREh+2-(`ECWRy{e>>#GA^2b9wpD)D}8M_-%wLeAAqzckSy z&;y(VP6YkFd}u8b-|}U786Drlhuv<_&QLc0B=^l;?^?-5lU|d?e!|G(Wi}lpJi^H- zsb%8}+}Vq`jgVQ=rfyH16LL*Y6J%A!ezfrY8~pueDEuTtFT}RSjzyam%iX$ck$L3; zzqRaK%59VMI`kmfU!wsd{2YFkpDR9)Spad~EKHlxPFn7ZtEhzCuj^B8#8uy<4*YfL ztOPJP=;!EWcOQp9zI%1(yED?yE(&9BKhIE$Hn34qhf}(CPKzEWCgzu*vWiiVy`y>L zjH$=|>knvL08AfKZ~Z(#wIo^3@??(+8n5-&5trar|wuysK8*7s_8V* z4C@NfQAN=k_v^6;WkMw_`yh@q+R_7A_w_X0gdy+MBa$3F2tCSFMN`7I-ig~J@V=w+ zgwDuyZLzkK!k6~8Hs8zpijnlt2;__Qc*+#TLo}c5tF|a(LkF7@ZH>1BFYQHzRP>EUUAZqA>Z38C*I4vLZx-33%X#RKU z!w*UG#n82DYyF+GoND*;xpif)*?u6+3;Aanb%Jw}H(<$oFPR%%P=4^9z>*38*-hz* zu6Oiy_OWzPu4@`I+L;i03obJrYDe;O#vP~XqoC=IkTp9J- zI6Euphi2^sr|6aSVyAUz>loPFKsjUDUF`IB!3xu7T(nBCWjl&nP$X4c~IM76? z`Wpia3@xvC+TuiQmtJB8+qbjISC>6We#1m!ovYN5g*YK1;wJF(7`eVi6OmXG{a@Kw zz#5DeLMG01vvWyQoQ20H_?++2-UY5LBHy9PR)t;vayV#(_Bp1`bHNwCqz{IquLbVJ zfU>U{2jqg5<~zlD90MHdNu;uDrd@Pd_I<{*g2`NMik<}xnq|^$3V5+rPY2!svIS|`G12!U>Nw%TY#vy%(mH=`wGqPN`X zdzEU%wU7n$prpz78rMRj@$M)){N75!;A9z!rBhGMb!PfGf|nHJFa$S7Ml^)K-_w_mM7sf@dy4*a0Vs0d_4xPa$p)|9AR+4yT*RpQVW%ur?VsWj7Np|a{S8aolszzT`j1v zPmvrS^9{nKG+qdJ4UK~9I>qzv?r2dfi4XS?GS$RY1PQ>v_7j}mCZ7R~-O%o`Rp*(* zD=M288%#JUV>VmoNzS1OW~?pu@=f&f;$>9|@pHq0fY@3RZKrtLAKG(p6iIjK)_}lA zjknSbH(Ls#XCj4k4|1k5yKB9}V=m2>`(@CS(+gaeno$PL_B#nwx$5=i zTi?0DkK#OOpBLhY@9Ib)E=PYp9-FR1=ud9)))pZe8(-;ggK zIC0jXa{gf+a~Xne6!1zoap$^hAgyHv$eVZ`zXh;x-G^DA3G(F3_L#F+7Oe7ihGpNgu$6a)hl=hwbq0R+tpOA>=v`&>NmroXojD0cab+?I#y?Rc zx(=D9D#8Zw!7usuU<;=AX|EJDohvVT?WvoD#Hg$u>qno_aXneCw7!*LEf`NqQWd|X z(8*k@83nav7^FsH^GpsUs44ZX4jcQ^S%a)%-M7|S>k<|lS_*6SRVAloJw6!C8s5EN zTX|c%1o7_Q69yVU>H@6ZtR!q4;F*meX+9SabO4PSn>6Ry{MYValI;q#8o!%SP*qC%Y3f4YyB{a_rmKl z@CqKxT(?n^JHx{lZx!4&2YW~Gp0|yaFhrQDEf(`Gzy$vo3Z>abQq6)F(sF6>YA_Cv zig`DUtII@3$8i?rQd>(w$O45%ndnE?JON{eCA*&vckH9TKLorso#p3R7<_$91`H=^ zq>d^z?FM`&kTC@~Q2H@)Lpw^uSG8lY_ut}>mzU|53Fx=sXPAV5u3L=g>A(}Tn0MGJ zm$w!*Oq4V~Ie3UzCXj{4cW=4^hkB<3XD0T*oLJ!lf7E(CDGoU#ZmHNCXV@o;*c(m> zYtO*fO7Iv_&$FJf%hZ)2c=|%j!jiuk43x+t&sk#>^U8zgq(ea|O7oI#fsL1b8)E*v zhg+TK=?G5I36gEJ^Uqxo*H_+Dm@FlQ%Y70?ECfWP?>s&reSq$d4k112en=Lambphc zTg1e&6kVd3D=ljFqwGQXZ%T$=9tUFj!$bB&@fxs8bv_b~!>qD1L@lw`rrNpLQk|r# zCsGwea%s%%$ZBn%1U>H>fhWoM(Wwb8i*7Me zEt3U{sb)R$SP?_hCYd($eO6(c*9ZVU;eUX=0eMf1D!ZnX)P_0OjXai90O+DUvVIvX zoZF5M?kf-6qg+rqMx_GS^jeZF^#u3#d3rXtyd>(R^gV+xoo&I6UH|BSI0sG^dOS^x z2$YpC^pExTJwypm@$VVla#MlQU4GAVJy;~OgFOrnje->bp43Mdlu|(azS^6I&NHDV zMhlCOp`@S-@!(b)4p*?(s;YO|*mUaU#d?+vn1>{tf-3_^RyLO0zyx+Bh`9Zja&(Lh zQqBg+7LA3WB-Xlk{(z_J8R3=#`wp|1f)>L8Y}h=}ZEwr1R_9Sm`GnJNZIU3Xtw}Ik znZ95ZYeHvDNJmcCF4!n=G%eNXRt0BP>zvquAu8O$zt3ye2QZ(7tKgH5Pm*c2pl|`L zXzRJJ_1!D%nzyvYZiD(f^oaGRGkjJyn&!@csW23J(we^ZB5|R;0?PABMh2 z4)2_A+OoO%>akauNV+VWvzlZ2AbiwxFhXP*4(je3o9DnfCW_0PqqhVDW&J3BMCAB2 z*SyC{o;B1k4w@q$u>PY`=)y|YZs=Bp$s(eQIOd#kuuz3-py@h9+vU`VM?}O|GnxWZyx2FJQ}`n`&uD5102oiriJ zkdP?7EL@R{hh`3OO9@$IU@@I8=Bx^QD=(aMws{5b0C~4uu&0-sqSbCwp$1=kqlu;C zatY^0!=_JY13@LX_&R4IUPDU*{N$_k3(Pg{hd>k2105}?{}8fYRxd-U2GUZ64x<)# zt$NJG##zGIdgp;Pe%|NGq#^glW4=HXpg|lt%x}~TEJ4hV6^LcA6SfwSPkF^KlcYn@ z2SZZPshfLY-*SA>M@Rp;-Tk(o!GCruG*4ks*mQARMsrIl!>Btyl0~?W9brehR$YK2 z2e0aB(u5M*jX#`iogj2a?_m^8!Z8(!p^^p0(S}Z-#gyJJuR*2;{xrg?|4Lb-;?rv7 z)rxqt^UFQ)9cmO6+n5+X@^;wQK84xs@zod3O0DEZ`rbsEeoTjhXuTsHVjRU(Vks z{UUI4P|zm1IRu*#Zmw1qmgEZNQR;Y(%;Z;Y9Dw@(ISv@}hFri~My$QCcM|@7$=5)E zX5X;)itQ4)&dyE?lcF|$3ig~K13hXbS+hhxU(rjWkBj9IF_&ty=>~=NSgL#^W3#wR z8xe^G)Fm=^_07$F2mU%}9Ss-7d&!Ph)twjnYZN)Ua18MU;65(DZa-SjVFz;SI{VW@ zF`bo5&u>kH1pKb_R&QMQk=6rCStO7zM_amYpHsA7sYZY(_^h?3tM%KG^GY`U>|lZG z=86MHdhmI@6f8A8iKgtfz{xBU`fu4s4E-yv{?|Oa*T&~a*OoG9gwDR8l8XAV3K{#srD8NPJyG{aph(giuqwa|9#oMon8 zwL_^H6~fW0aL@!>9FosN>aPYJhlw^tbSThItb`*{LBEzm%gl zS4&U#QM)%@leA~iqPx`Sjs>dwYdQ+Wt+9(l<+C3R!qvI$Y~xd01CKs717S_{mhnVdODpL@nu$$WPx4?6IzWyT`xq*AR0iIEw zs~(!q?Wn(w_h?)tRELXg5DvAL%pJ`Ho3e*F-MiQW@_dh`V>w2ZgNC4DMi5@g?AC5K z_b@HCTRmk^tVU0UjL`S?DfV)K&|YLhPbKby}7Y{)L0|u3Dr#VID@%gPSs-= z^Wzixhq;v0-0|z9_xVN0mObj*2GuemrV<0b`%I=rheNAdLWgf0v0(k3!vq%XG+C{rIk+t06*~TYyf}ttP7YI z0(1NT4+RVv_CJ?#5-O@i9b{akYvhp6Lsi#8c>D>~{QU1V5$l5q*L?N`kwoGNY#h<`bIzvL~Wnp=FcM zF@?5{!(=*&lXAD= zgoVKI)!CLcf;WvX*xp82=&od6bu9eNm(FT-2YmXWa3CX;Ym8!<0MZKE(TQWO<(7>O zrBZI<3c;i`GQU;HH(cPao_DpbW7!q4HZU=4e8yV3`dXSyo;BT3rQ}{nU^pUN3 z>&N-i^!;Ew3Y^a%fkLJ@IX-pOWQQQmZ!U$?sw^UT*2dW=u$$Uj02rsYi|s#oOG@8A zi1Bv{UU!`>Rt{rbuqIbQZm*vJkv>~k`S~9~HfmgeV9kUw7tqaKu(XWKt-+s+7ZUuK zmNR-9ajn#~l(_mIWn2nhMDOv}W&Lho9Ka5r7%7$!452_o*4Mq?%Nsw>^Bqd$9DniC zfzf_?WU0YemVQ4@8q`Yw`9gh9r*&a^qVRFmu0!YAw^GvZj-mI@8~P({YgzQG zB)wB7|JC~7n>^lujG}lRi5-uMe1Q<+Sypn%svH7yfG^HLAO~j`&XreCim_r^aL$8* zHZEdc;6RlG~b~Zt)2sAiVzr^+DZ5sVYQHDCWyL9lie|GJ3zxu`$HY zhcK;H5kVCGyrOWFbjZq6ymgS59I0sD(JR>ZV!i~W1d4*XYzL=FJ$ZMG1I>B`1yFpE zXe{wG*qmD$N;VNOa4LwF?1^s^SIfFy^JMA(5kT=Uv_x@+)^8~A*5raxG}pUeU8IuM z-ioIk%>6PP5p4$`_dRw7tOtbFr`7hsO9(K%x@eS(Wq>#h@QvcIK&>S?hd|z zj@o!h@o?50COWw!osE({PAnm;P;d|fJhP_T{||(`@VqlWuU8uJc~)}5A(R3A4R;Z| z(uvG^EXT36jpR4%=NvLbLbV*S~CfF_-ds?F;4NEe1qkP7*0 zTDdAOxXK6uL|jT}-Tv0Te0cR8!*$q~sZg_u@$>5;`x34wOm~hg zSoUEZOefl155^v;5zZpmtRt9MCrB^+!vLa@wna)mMoRw-oasW&HWbi(olEX}c_shZ zp#n|YIroLe-m0@f7FNi~-Lt1zY_H6gtfx+~zoo;=%Z3SH!V5+B<3AiO z{7&j=Zyr7IX(}IE!FR2xHf78QztzvMb(Gg#RyCtUk!<=Q>o$qb#rnLVKa1t_fuwa~ z9)g;5^F-hQN~mQ}pVyL&oJMi&mSNbf`bY2*S6}>9oUs$&o^w+s?QtE`rxFp+ELS4j zK8rC{B*;+XtbaL?-f`EMvP8J6-8xu!R%#yL^x2j^hVXip#5znhW<@ES#w8ahd+U?*vs1v@iM&B(6}qY=C*0*a>myfhqHtCzWiKsL<=qK#+Q2isU?uC-XSg(Kf8;Tv&uC9a_aO0BS zDYUNW6SZ?>-8y>4TIP}Ebqwkx z&`8Q$#^zg+G`Vap24`p2aeU;SRe6HwMvKY>+UyOGz}0+WQDWR!m?601 zCLi@a@#+D0sRa8wxL8UK1beZt&^Vtbsf?Ri5FEbEyEbnocQZv0{C5Og-Y@^=tDalc zK{!c*YO_)2z4i=joStC9Bvf5|P_ffqIJjc@44wn2=zoYW008)&uP&Ye&>s;i%(g2G zbadoFC56KK5*H}bMABkKv^rcuQ6=*Q;bzimm`OOW+FybN#B)8C=iBfcB8ON9HnD-W1LemyAnwsOd_OX#>G z=evHf9pkyE;gc^0B!5TAVj#mFG!Zkt)%?&ZX+x# zK5uQ?nj$%Qq}h1*di>zm@pXtP$NJ@T^VOSXYw{CU)iWr^Iw?+cEx^~9eE2#20+7H` zzN{Sl*-B;uvwewt)4hdNP{QfpI!i}9rOBN8e;9kGAlsTnTeoc6wrv};Y}>PJ+qP}n zwrz8kZP%SE?upoI@BOb6XGDL1n?SX>$ix6 z9~eX%k%tR#CBH!$d4ngR1%;f>0A@Aj4&kgj+yRKG_aqjN<@$r`n7^DA7U^YypdGr+ zSx{Pya@9&uBdj+)x44dZiM>xm86FS;=V{h=Du(+ctb#$F3>_cWmGvE__cz@!4991A zK3ai=KSVT%mfW!Jo1EKp$vV!HW0KJd!IOyL$c}0Kf66ZpvZlo@tuDEh$8SOJiuq) zEhFUJz+#L=fYoD>ubk6iW9|M$&(gd2fiL2nu2-VkQhI6SHu70b8C2rlBZ(xFng-IYfn+|Ri^a5(>8JiL{&rBrN!Z5sS=swqRZYDgS0jFL7eiKSyb}elZWr64 zm}&c$!RicgM_+%_)ewAL;7kBe*}Q9!L!oz{=nH%N)wFIGrn<$a@Zb!^*h1L9ASNw%pz5#I#RhTo|_mk8S} z8x^(B4qm{sT5Gmiy8PIjt)`Vpc-BU@Rxl#6QJ#Xu`EeQ@%A`G`X1bEfXqD&A`WY&C`O-vWX&}`;ZXZ zj1Sq(nTY{EH~43>TF@ldre^fgu$>r7HLJA@DWEylHKC?|)6;7k6IbQw;gGls_h2dJ z+PP9KnTr5NxWc`!6fAQixVCD9H&)ocgg-#*Bz701V73EnPhL`s&`E9k9zKZjQT$q^ zXU6ib+30#0mOhtoiPt#c?DWgEas{%V8`CIy%f&{C%M7p2harIL5%Z>E?y6sopaqPMvdKdHMfB7vIA;+w7rmb20y$xv@vsE2^40=;n6OJMWf;<^W-0u|`P zWn{~$WInC8eyhyXuqJ7jD5uaZrc~y(PC!1+4RSUG`N zQ163m3Db zW1L4Xz^w)PXbcD$AX;zqc)RIP$oRT{`3N#PklWARqbNr-Y0N#i*nx>z1fGP1!~15j8;!13V9KE_|WZ$jPC` z)e)$(wOg}={(x-=vn>K~K{pvECrUtULx;pc!+zdjzGG=Hiv=@SAkd3Om4|aVkUv){iEMlSskjDu? zizYzsYQnx)(zR$v>K`_BirQugTMME*D@2Y(K6^(T-8(-G>A`>V>C&* zYN-0jnCb2m(OjnBQF>wHz8LW7!Dx|n<*%}y$Ar6+l(^=ubO;imA3lrZpm1YSpB{~@ z-187PF2kbLpeVEw3BGS7Cn)aa$5N<7J$OydgBIJygIs@N5DP5{PR|2R=zo$kARdWs z-!k`B@}BGs5+kHS+`oHEs)p9ql=8F3&Fi{mT_u^>Shb92ZhfImN`DpXq-QdUw_%BP zLkrWcCfh872_HeL#!9_a9%zoPi6&~!D?N8)Io6Cq%hEV(&|*1C-z6!=H@U>@LarxtKc`6zUXXP~}v zd)$4m^QwX#dkB0j9dz0_%T}~!BL>FgIg&hu@#Y5&O8CaVb}h<1@fbj`T)W+%`S&y@O1}~vcH1r%!|1KoqQ86`zTcjAh+@ItTQoN zHq)V-K3GeuHG^hnA7J0m3_o`m_1&RO^9H2iE;@^_?^zNU*`=9Bw1OAWP1}@@W;g3_ zEM$p6^Htv;;xBbz61F5b`7?)gRxy|%pYPaW4BY~DAknEF%HG00l1ayET(>Qx z2OY(KlG21*M@+8iCN` z6W!%l!WJzLg?0Ex)cz&%zyJW;f{XI6?I=W7jRn#sJ&brWEk#cJYNXO-6$fvUu=Ca( zUJ_!&G!pxp9?{g!1ll;ifo21!i@WxPClRH%sg#->*o|4Wu|~$oP`SUO)J4JybVIUo zxp}&gLt$pe;-7*H0SuqQ!D~tem#i-gZqh^~0EC)&tGjosd5S~alMDxNus2fqgo+DC z*2uN*jJ4Wuj6555P5QP`j13K?%It;KUjoa@gRut9Ez#fnCAj>6ZJ^`#iZ@^p526+? zb4!QB+oXC28b}t*dZG@D%~X>kvEYtLEgEA0$}kE_@)UNa%Gzfe?M^-Hnq%FVqKjfS zf?}H`9?LkzvEDAPKa4)ENfE@UQpQBb@rOfB#VI z=0{4ot$0dehY&#T=U0DT`CzkSHHg>^tZu1E`3`e*I1H?}0TYC(ItSb`(|~Q&luQ@V zSK}s)Ha0v(GDeI-klJk}QENx~4j4G(Iq3nMTe87X#sZg751o)CI{k#395;&KJ~&VA z=(X4obMqCb^UqRRzS*R#EER(VS&up4VkcNzpP~LiW+b*HGwto{c?`*~>$YW=2b)cU&B#d1;dh8H0JqD`iI4|KHo#w4}@K^id? zi8(63_x>O8`}+kyKR*n^B!7>0X()7%-Z_8A5vmzJ|9Zgz0O<5NDxvkd((xuPD)IFS z7rAxPfrP5R1uaOFM=u`Ew2{$GXTchuL%A|2VQwUo5@2FFl4V(&*b>Ypa$%X@$=*ybdW?4>bM59K*r!# zkVlUxJ0lzVNMmk=lQJj0>%m@^5IwLPC0M0InAPcaKb|n6 z`8YM@bea$=e58D8;GB+RhSEql9VTubcN{%C2)l=kob*O}u{#Oh)|3QP>oX zadQedw|=cjsMMwgAs;QPvQaYU;1(#WFDYDqwR*kDO4&#j#SdMHZZ>_RC zLuz3ODOuX{Jf#B<5ur?{c+YfydAAN&_W>FiR!$8^Bg4}B_#3u9XPVxlFc%;zu1@{! z7Whw}DIVqrm>DvACCfs~s5dE43 z(A{%?@3D3D6PKNQE;P?6^}R@Y)h0)pXz`L?J(lhGN6{|x0p2wL4UNppr}L&MI3_D{ z4(Nv-N^Q9d?xD4q-Z06m*jz10#uF(55d{E7lbeM(YB? zW_XmJh~*rIxvwddNckxEEeKX`2iV7suSVZ!Sj6lH>VP6^`G& zD+|xcX+B_GUv7PSZz7o=s>`FQ>dx9dL1FA!>8F7)ApCsElK~Cj&A#7JAvR(st%`L4Fsby6Xs4j{eOzECB$OBj_vJp4kbAtRPC>AW=o% zl=`l@J=VQw8b`X;kHV1X_PAi6^0o*KRYcfWKe7l_K`4&^MZ-e&zWPHb*{>b&=@(vP ze{apz72-_;tdahP{U=~7bQKcV+89emII zCk?NCikGXa+(WI+@jK&*QmNRGh8-9+CK#A&SmZ=O~VI+zZCCc1TzR zM-_5%DpA-+w!~NJSW~`>nN^=3qb5_O$E(dQ`=~}97!jJ8CLKU3nc1r|ji{!b_~$mV zZ(fi!JS>0ahE&OT5BK^Ewo^|Kx_+D&m5%KOkQeT{FKi|#I8tD24Mjiu+~?qNCwdc* z$ouVaN`_$G;dBdtbSZZA-9mmr`YfVqlu`fIFSvk)t|-j@3nCxx8&@`X5kHtLSaxrQ z@1aXvPMBj?1-eaB#8yM=H~_Yvdx0NdJ7^%wu=#?}PGyopR}GZ;ey+7HRnDu}Fc=U@ z7$>fec$N-U3wbUR>DdrH?-nZLR3QUDAt<2ax4O^g_u$)Z?MSi+$aLworrOpNG5X6y zrZVhg#8rN|k@_=x^8CK%Ddu-}`0(aZ9QfzP5-b5EhNHZwD=2_LHX@)Z1Kg7(-C=+% z8;~%U6*-5kN7yLpg#T8$ue&hMikK5dY6*3t zaOEUOD`I%hsYDspfoOVTjn|w97}~NxL}^5=X%ZPpZbcM0PAoxK#VXjUyezP_6R&} zM>$@Qmi+^hJP$wc{BQ)~t7$>}Mq)p{IdhA25;b`pS7EBz9PHojO%gm;j`=d9ihs*g zg5_Q-HVQ?O&`x6^77gGAIjbPcp{7Jy?{tR|TTLDebB%u|^w*6D45w0o0Ecx2a}2Cm zyjb%R2WwWuz^b{}h zkMR4ZJZw5$hePItPo+cL(9oXgu7@7W!rKW`g(vR)0dKDgN!Swo+v(G$H8!*a8Cw}a zwjkEghglRS^xRx;X_jc0C0-bH3|a)CL_gpTDj&Yb*S0ho*IH~W)2@Q%3wuI~m5tcdDBYrw1#%T>zSeL3pqV1gvv!`VaV;wiAIm!)Bm$~ z@m$5v%GW#ufnh=ucs0vQB7Aq@j=o=zo`} zZ9#c=aZ$yAdon~4nK3f!{Hr9A%u*u+CfSh(ov|H-CU5xj!hWV%e?l)f=wYd2g_tJQ zjjPmWOcJlK7O{Y8tXLRN=*46#k^OJ4W4|WwN zs`#n6rVo^aIUr~rJLJyUgP34z=u45bKpRQ#`hgMh*7}3C2l6r}4LGJapzj1M+J2!+ zgt{-kUj?7Y!G?-kQV7f$1ELz#MC7H0mdQ*guFF2XL2s!YDkuP}dC=Lhmvx->H_vC# zvM>vT>XOv#VAJ3lg6U%=s@*mYXk#EA=ey3?#Jkx+L0l~LSVIW=cnUaYQ<7WYs#qgE zG?=hnX4QZXs@`)dCnVpBPhrho4H+D`J;%{(VIjiH*tLQIRlTq5aplsxT4PdrBGlc0 z^3mz<5F{CwBuFP%vLNiZNfua#uL&g#bx!RQjD~Y+wO0o@fEFDzV zWg$$vPZL3ZUTyGnM{kb-ez=`!zck$Djjbi57%Ym*QOTI%mvt?o{zVl)q8-$m=36#p zjjC?40xBcSWDH5Wyjm=i@+5$3I6Q-gcA4n6Z zzmM1`oJAx=$0fz!H{04q(vLUC!yU^lO=qWqI|C&fu`>ty9ml4`Y6hK-uX9q(6_jT=9$)(`R zq*L&7x0;7?M!Gd^xS*8M?f3rX5E|NV0>Z)r5}-{x$dCDJW4iA0RLfdIHQEJuj(8ne24RKVpvHuf@eK zeo&iG&r>4fql8wRV>w#EwR&U@*}QEh_X4M(2*fka22Bf+H&WY0F6g&o`qmZHH$uE& z^DxYmdd{fkpLMMb1OrQ6U(ZvY0AFiYUDV2Nq6DvF06_THs}iv7jtCu8m4Zao+OBS9fb&pv!ed9xUr|o;b-@Ok{Jj2d3k<@zy)DZ^-nV zC0b+3#X17`=H07akb8pOlWJVZ`VS|x#k zATbrZ;xfy)!GprGb|~EetoNi>*T%Ed;QRH=R;P`{zj2}pBzpIt}^3byn89gZ^;63aV0 z!Gd$K)>ei}nEUlp@8gA5 z6y$20&;})RP2jNH+&^8e{@{(xN35FzQ*qDVSQs^sv(OylG8s}{&$3@8KAR^jN z9I(^s1l}MG9ENM3H)u0}V@Gv?rDZ!Vo1g8x$VxRuf6R$qBd?l%BVGLa#A+lq%7%Oe;IS(~&TAT6TdHN6JcD701mm-68mSmkE~~C>BnL)U zGgg7Bi({lQO$o1~exhZZbp)&!J zE@wlKxrcN(XjuT2EXn!Lce_wYsXUwbKDjf~DrZIzJ8V-*(h+_sbvSmVsQ>|0j;dx8 zMX%}%<*R?pax2P zd!9cGo+37-^Wo*ux=!jM>fYrbmp0u$=NLER5erP7>iAiOPi=yin)JkNRCee0V7vZH z%tK|}oa0W=^rNDy!EFTd^c!=1!?QsHoWb%!8RPV89wG|DF%A^?h+QEso;wk{{U3)C z;_ZlPj3m7P3C5CSM^Y<)PaBWCwN%{%2E?T&v&YLDs5bqzVaMnN6f*xt01AIVI-eZTUcu)dO?v7G= zfb$ncaAK^n!;Z|GnOK3u(eA6N1tf zX%v<4gvjFJ8g9Q$Lv%J(|I=Y~3CaIxiUdp4P2N-!P1wG789=tU=p(fk-qyZ*V`iAn z)cjfX4DLF+AKbF}ZB(EF7s9QfrVp<1fW#_#imTgSl{HaTYF=XrRXx^H;l~}#duWI- z5YR_Gi$h?QUp<|0XZ+%;;Ln~**DdC3JH_b{Gg{FKscD*m$#X^z}`JoEnkX2TKE_Yd^_56L|T06aaWWo0gqT+X+|O!<^g0PT%Uz;h=H90Cae zDX5Atb#ypL9rrjJXWD@0D*Jm%LxVgKP%QG!*NCFZ#dI#11il5LNiuTcjo@haZQhZA zm^sz)l-HGqfnw&U+np)4ncN2pZb`22(U&nsuUzOglvq~r(8K7VP_}R`+`XJBTr!S5 zA{O8-5f5Rm)Wr&n5u;HNOWqvvhJZD*QzGCZHKG~32C2lqlJG=&i4@z&MR@mEOPxb> znti+bvqkV>*9Nk14h8&Y&fEuPZl$?ek7odv)Z z6I5)Lh68P$XrS2f?p1LnC5`lVzlkN`9llkzOxx(3fXjUG*=5$gC0R8{b{~M`}(g=*ee0LR)Yi)I5C~=nD;g{qot=4&+5k=gXf~)^B)nHEaDn zTWe%{q1;f2Eomu?L*nNm(0E)F&H@`=o%wKZgloNE$38nLvvG)W&?wCuy=VPCo<&*` z2m*+qW&{GvK^&d!w!;zBznl?Sbz%ju_iJ7sg`;!XH}JZqBVYhTgPrEpKN^q9;biX^ zAhzj$u=Y<=-=Eyj(2Jx)wZqJHi9;1|TQD-Xa)nonN>+K!wD46!#ZinYvXg#%*iBP^ zl#a1hF+vwWB0S&chJ`@#kPZTAq(QB9gC%>1p2Z^i%^9*_6*zdO(-AzCHyx_lV75